AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} SOURCES)
AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/ast AST_GEN_SOURCES)
AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/gen GEN_SOURCES)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/gen_cion GEN_CION_SOURCES)
BISON_TARGET(TIDLC ${CMAKE_CURRENT_SOURCE_DIR}/ast/tidlc.yy ${CMAKE_CURRENT_SOURCE_DIR}/ast/tidlc_y.cpp)
FLEX_TARGET(TIDLC ${CMAKE_CURRENT_SOURCE_DIR}/ast/tidlc.ll ${CMAKE_CURRENT_SOURCE_DIR}/ast/tidlc_l.cpp)
${BISON_TIDLC_OUTPUTS}
${FLEX_TIDLC_OUTPUTS}
${GEN_SOURCES}
+ ${GEN_CION_SOURCES}
${SOURCES}
)
TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${LIBPKGS_LIBRARIES} ${EXE_STATIC})
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "idlc/gen_cion/java_cion_gen_base.h"
+
+#include <ctime>
+#include <vector>
+
+namespace tidl {
+
+JavaCionGeneratorBase::JavaCionGeneratorBase(std::shared_ptr<Document> doc)
+ : Generator(doc) {
+ type_map_ = {
+ {"char", "byte"}, {"int", "int"}, {"short", "short"},
+ {"long", "long"}, {"string", "string"}, {"bool", "bool"},
+ {"list", "LinkedList"}, {"array", "List"}, {"float", "float"},
+ {"double", "double"}, {"bundle", "Bundle"}, {"void", "void"},
+ {"file", "string"}
+ };
+
+ parcel_type_map_ = {
+ {"char", "Byte"},
+ {"int", "Int"},
+ {"short", "Short"},
+ {"long", "Long"},
+ {"string", "String"},
+ {"bool", "Bool"},
+ {"float", "Float"},
+ {"double", "Double"},
+ {"bundle", "Bundle"},
+ {"file", "String"}
+ };
+}
+
+} // namespace tidl
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef IDLC_GEN_CION_JAVA_CION_GEN_BASE_H_
+#define IDLC_GEN_CION_JAVA_CION_GEN_BASE_H_
+
+#include <memory>
+#include <string>
+#include <map>
+
+#include "idlc/ast/type.h"
+#include "idlc/ast/structure.h"
+#include "idlc/gen/generator.h"
+
+namespace tidl {
+
+class JavaCionGeneratorBase : public Generator {
+ public:
+ explicit JavaCionGeneratorBase(std::shared_ptr<Document> doc);
+ virtual ~JavaCionGeneratorBase() = default;
+
+ protected:
+ const int TAB_SIZE = 4;
+
+ private:
+ std::map<std::string, std::string> type_map_;
+ std::map<std::string, std::string> parcel_type_map_;
+ std::map<std::string, const BaseType*> serializer_list_;
+};
+
+} // namespace tidl
+
+#endif // IDLC_GEN_CION_JAVA_CION_GEN_BASE_H_
#include "idlc/gen/cpp_stub_body_gen.h"
#include "idlc/options.h"
-int main(int argc, char** argv) {
- std::shared_ptr<tidl::Options> options = tidl::Options::Parse(argc, argv);
- if (!options)
- exit(1);
+void GenerateStubCodes(std::shared_ptr<tidl::Options> options,
+ tidl::Parser& ps) {
+ if (options->IsCion()) {
+ switch (options->GetLanguage()) {
+ case tidl::Options::LANGUAGE_TYPE_C:
+ break;
+ case tidl::Options::LANGUAGE_TYPE_CPP:
+ break;
+ case tidl::Options::LANGUAGE_TYPE_CSHARP:
+ break;
+ case tidl::Options::LANGUAGE_TYPE_JAVA:
+ break;
- tidl::Parser ps(options->IsBetaEnabled());
- std::string path(options->GetInput());
-
- if (!ps.ParseFromFile(path))
- exit(1);
-
- if (options->IsProxy()) {
- if (options->GetLanguage() == "C#") {
- tidl::CsProxyGen proxy(ps.GetDoc());
- proxy.Run(options->GetOutput() + ".cs");
+ default:
+ break;
+ }
+ } else {
+ switch (options->GetLanguage()) {
+ case tidl::Options::LANGUAGE_TYPE_C:
+ {
+ tidl::CStubHeaderGen stub_header(ps.GetDoc());
+ stub_header.EnableNamespace(options->HasNamespace());
+ stub_header.Run(options->GetOutput() + ".h");
+ tidl::CStubBodyGen stub_body(ps.GetDoc(), options);
+ stub_body.EnableNamespace(options->HasNamespace());
+ stub_body.Run(options->GetOutput() + ".c");
+ break;
+ }
+ case tidl::Options::LANGUAGE_TYPE_CPP:
+ {
+ tidl::CppStubHeaderGen stub_header(ps.GetDoc(), options);
+ stub_header.Run(options->GetOutput() + ".h");
+ tidl::CppStubBodyGen stub_body(ps.GetDoc(), options);
+ stub_body.Run(options->GetOutput() + ".cc");
+ break;
+ }
+ case tidl::Options::LANGUAGE_TYPE_CSHARP:
+ {
+ tidl::CsStubGen stub(ps.GetDoc());
+ stub.Run(options->GetOutput() + ".cs");
if (options->HasRpcPortLib()) {
tidl::CsLibGen lib(ps.GetDoc());
lib.Run("rpc-port.cs");
}
- } else if (options->GetLanguage() == "C++") {
- tidl::CppProxyHeaderGen proxy_header(ps.GetDoc());
- proxy_header.Run(options->GetOutput() + ".h");
- tidl::CppProxyBodyGen proxy_body(ps.GetDoc());
- proxy_body.Run(options->GetOutput() + ".cc");
- } else if (options->GetLanguage() == "C") {
+ break;
+ }
+
+ default:
+ break;
+ }
+ }
+}
+
+void GenerateProxyCodes(std::shared_ptr<tidl::Options> options,
+ tidl::Parser& ps) {
+ if (options->IsCion()) {
+ switch (options->GetLanguage()) {
+ case tidl::Options::LANGUAGE_TYPE_C:
+ break;
+ case tidl::Options::LANGUAGE_TYPE_CPP:
+ break;
+ case tidl::Options::LANGUAGE_TYPE_CSHARP:
+ break;
+ case tidl::Options::LANGUAGE_TYPE_JAVA:
+ break;
+
+ default:
+ break;
+ }
+ } else {
+ switch (options->GetLanguage()) {
+ case tidl::Options::LANGUAGE_TYPE_C:
+ {
tidl::CProxyHeaderGen proxy_header(ps.GetDoc());
proxy_header.EnableNamespace(options->HasNamespace());
proxy_header.Run(options->GetOutput() + ".h");
tidl::CProxyBodyGen proxy_body(ps.GetDoc());
proxy_body.EnableNamespace(options->HasNamespace());
proxy_body.Run(options->GetOutput() + ".c");
+ break;
}
- } else {
- if (options->GetLanguage() == "C#") {
- tidl::CsStubGen stub(ps.GetDoc());
- stub.Run(options->GetOutput() + ".cs");
+ case tidl::Options::LANGUAGE_TYPE_CPP:
+ {
+ tidl::CppProxyHeaderGen proxy_header(ps.GetDoc());
+ proxy_header.Run(options->GetOutput() + ".h");
+ tidl::CppProxyBodyGen proxy_body(ps.GetDoc());
+ proxy_body.Run(options->GetOutput() + ".cc");
+ break;
+ }
+ case tidl::Options::LANGUAGE_TYPE_CSHARP:
+ {
+ tidl::CsProxyGen proxy(ps.GetDoc());
+ proxy.Run(options->GetOutput() + ".cs");
if (options->HasRpcPortLib()) {
tidl::CsLibGen lib(ps.GetDoc());
lib.Run("rpc-port.cs");
}
- } else if (options->GetLanguage() == "C++") {
- tidl::CppStubHeaderGen stub_header(ps.GetDoc(), options);
- stub_header.Run(options->GetOutput() + ".h");
- tidl::CppStubBodyGen stub_body(ps.GetDoc(), options);
- stub_body.Run(options->GetOutput() + ".cc");
- } else if (options->GetLanguage() == "C") {
- tidl::CStubHeaderGen stub_header(ps.GetDoc());
- stub_header.EnableNamespace(options->HasNamespace());
- stub_header.Run(options->GetOutput() + ".h");
- tidl::CStubBodyGen stub_body(ps.GetDoc(), options);
- stub_body.EnableNamespace(options->HasNamespace());
- stub_body.Run(options->GetOutput() + ".c");
+ break;
+ }
+
+ default:
+ break;
}
}
+}
+
+void GenerateGroupCodes(std::shared_ptr<tidl::Options> options,
+ tidl::Parser& ps) {
+ switch (options->GetLanguage()) {
+ case tidl::Options::LANGUAGE_TYPE_C:
+ break;
+ case tidl::Options::LANGUAGE_TYPE_CPP:
+ break;
+ case tidl::Options::LANGUAGE_TYPE_CSHARP:
+ break;
+ case tidl::Options::LANGUAGE_TYPE_JAVA:
+ break;
+
+ default:
+ break;
+ }
+}
+
+void GenerateCodes(std::shared_ptr<tidl::Options> options, tidl::Parser& ps) {
+ switch (options->GetType()) {
+ case tidl::Options::Type::TYPE_STUB:
+ GenerateStubCodes(options, ps);
+ break;
+ case tidl::Options::Type::TYPE_PROXY:
+ GenerateProxyCodes(options, ps);
+ break;
+ case tidl::Options::Type::TYPE_GROUP:
+ GenerateGroupCodes(options, ps);
+ break;
+
+ default:
+ break;
+ }
+}
+
+int main(int argc, char** argv) {
+ std::shared_ptr<tidl::Options> options = tidl::Options::Parse(argc, argv);
+ if (!options)
+ exit(1);
+
+ tidl::Parser ps(options->IsBetaEnabled());
+ std::string path(options->GetInput());
+
+ if (!ps.ParseFromFile(path))
+ exit(1);
+ GenerateCodes(options, ps);
return 0;
}
#include <getopt.h>
#include <fstream>
+#include <algorithm>
#include "idlc/options.h"
-h, --help Show help options
Additional Options:
- -l, --language=LANGUAGE Select generating language (C, C++, C#).
+ -l, --language=LANGUAGE Select generating language (C, C++, C#, Java(CION only)).
-i, --input=INPUT A tidl interface file.
-o, --output=OUTPUT The generated interface file.
-n, --namespace Add the prefix in the funtion name as output file name (C language only).
-r, --rpclib Generate C# library for rpc-port (C# language only).
-b, --beta Use beta version (Support private file sharing).
-t, --thread Generate thread code (Stub only).
+ -c, --cion Generate CION code.
Application Options:
-p, --proxy Generate proxy code
-s, --stub Generate stub code
+ -g, --group Generate group code (CION only)
-v, --version Show version information
)__option_cb";
}
std::cerr << "tidlc -p -l C++ -i test.tidl -o CppTestProxy " << std::endl;
}
+Options::LanguageType ConvertStr2LanguageType(std::string str_type) {
+ std::transform(str_type.begin(), str_type.end(), str_type.begin(), ::tolower);
+ if (str_type == "java")
+ return Options::LANGUAGE_TYPE_JAVA;
+ else if ((str_type == "c++") || (str_type == "cpp"))
+ return Options::LANGUAGE_TYPE_CPP;
+ else if ((str_type == "c#") || (str_type == "csharp"))
+ return Options::LANGUAGE_TYPE_CSHARP;
+ else if (str_type == "c")
+ return Options::LANGUAGE_TYPE_C;
+
+ return Options::LANGUAGE_TYPE_UNKNOWN;
+}
+
std::shared_ptr<Options> Options::Parse(int argc, char** argv) {
int cmd[CMD_MAX] = { 0, };
int opt[OPT_MAX] = { 0, };
struct option long_options[] = {
{"proxy", no_argument, NULL, 'p'},
{"stub", no_argument, NULL, 's'},
+ {"group", no_argument, NULL, 'g'},
{"version", no_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
{"language", required_argument, NULL, 'l'},
{"rpclib", no_argument, NULL, 'r'},
{"beta", no_argument, NULL, 'b'},
{"thread", no_argument, NULL, 't'},
+ {"cion", no_argument, NULL, 'c'},
{0, 0, 0, 0}
};
while (true) {
- int c = getopt_long(argc, argv, "tbpsvhl:i:o:nr", long_options,
+ int c = getopt_long(argc, argv, "tcbpsgvhl:i:o:nr", long_options,
&option_index);
if (c == -1)
break;
break;
case 'p':
- cmd[CMD_PROXY] = 1;
+ options->type_ = TYPE_PROXY;
break;
case 's':
- cmd[CMD_STUB] = 1;
+ options->type_ = TYPE_STUB;
+ break;
+
+ case 'g':
+ options->type_ = TYPE_GROUP;
break;
case 'v':
break;
case 'l':
- opt[OPT_LANGUAGE] = 1;
- options->language_ = optarg;
+ options->language_ = ConvertStr2LanguageType(optarg);
break;
case 'i':
options->isThreadEnabled_ = true;
break;
+ case 'c':
+ options->isCion_ = true;
+ break;
+
default:
cmd[CMD_HELP] = 1;
}
return std::shared_ptr<Options>(nullptr);
}
- if (!cmd[CMD_PROXY] && !cmd[CMD_STUB]) {
- std::cerr << "Stub or proxy must be specified." << std::endl;
+ switch (options->type_) {
+ case TYPE_UNKNOWN:
+ std::cerr <<
+ "Stub or proxy or group (CION only) must be specified." << std::endl;
options->PrintSample();
return std::shared_ptr<Options>(nullptr);
+ break;
+ case TYPE_GROUP:
+ if (!options->isCion_) {
+ std::cerr <<
+ "Group is only allowed for the CION codes." << std::endl;
+ options->PrintSample();
+ return std::shared_ptr<Options>(nullptr);
+ }
+ break;
}
- if (!opt[OPT_LANGUAGE]) {
- std::cerr << "Select a language (C, C++, C#).." << std::endl;
+ switch (options->language_) {
+ case LANGUAGE_TYPE_UNKNOWN:
+ std::cerr <<
+ "Select a language (C, C++, C#, Java(CION only)).." << std::endl;
options->PrintSample();
return std::shared_ptr<Options>(nullptr);
+ break;
+ case LANGUAGE_TYPE_JAVA:
+ if (!options->isCion_) {
+ std::cerr <<
+ "Java language is only allowed for the CION codes." << std::endl;
+ options->PrintSample();
+ return std::shared_ptr<Options>(nullptr);
+ }
+ break;
}
if (!opt[OPT_INPUT]) {
return std::shared_ptr<Options>(nullptr);
}
- options->isProxy_ = cmd[CMD_PROXY] ? true : false;
options->hasNamespace_ = opt[OPT_NAMESPACE] ? true : false;
options->hasRpcPortLib_ = opt[OPT_RPCLIB] ? true : false;
namespace tidl {
class Options {
public:
+ enum Type {
+ TYPE_UNKNOWN = 0,
+ TYPE_PROXY,
+ TYPE_STUB,
+ TYPE_GROUP
+ };
+
+ enum LanguageType {
+ LANGUAGE_TYPE_UNKNOWN = 0,
+ LANGUAGE_TYPE_C,
+ LANGUAGE_TYPE_CPP,
+ LANGUAGE_TYPE_CSHARP,
+ LANGUAGE_TYPE_JAVA
+ };
+
Options();
~Options() = default;
static std::shared_ptr<Options> Parse(int argc, char** argv);
- bool IsProxy() const { return isProxy_; }
+ bool IsCion() const { return isCion_; }
+ Type GetType() const { return type_; }
bool IsBetaEnabled() const { return isBetaEnabled_; }
bool IsThreadEnabled() const { return isThreadEnabled_; }
- std::string GetLanguage() const { return language_; }
+ LanguageType GetLanguage() const { return language_; }
std::string GetInput() const { return input_; }
std::string GetOutput() const { return output_; }
bool HasNamespace() const { return hasNamespace_; }
private:
enum Cmd {
- CMD_PROXY,
- CMD_STUB,
CMD_VERSION,
CMD_HELP,
CMD_MAX
};
enum Opt {
- OPT_LANGUAGE,
OPT_INPUT,
OPT_OUTPUT,
OPT_NAMESPACE,
void PrintSample();
private:
- bool isProxy_ = false;
- std::string language_;
+ bool isCion_ = false;
+ LanguageType language_;
std::string input_;
std::string output_;
std::string help_;
bool hasRpcPortLib_ = false;
bool isBetaEnabled_ = false;
bool isThreadEnabled_ = false;
+ Type type_;
};
} // namespace tidl
projects / platform / core / appfw / tidl.git / commitdiff