From 8a073ee487f3cceba14f8987cddbc96835d7c3b2 Mon Sep 17 00:00:00 2001 From: gotoextreme Date: Mon, 23 Aug 2021 16:40:49 +0900 Subject: [PATCH] Support CION commands Change-Id: I1778a096af91fae45d044e2c0a717ee6e28bda3c --- idlc/CMakeLists.txt | 2 + idlc/gen_cion/java_cion_gen_base.cc | 48 ++++++++++ idlc/gen_cion/java_cion_gen_base.h | 46 ++++++++++ idlc/main.cc | 169 ++++++++++++++++++++++++++++-------- idlc/options.cc | 69 ++++++++++++--- idlc/options.h | 28 ++++-- 6 files changed, 308 insertions(+), 54 deletions(-) create mode 100644 idlc/gen_cion/java_cion_gen_base.cc create mode 100644 idlc/gen_cion/java_cion_gen_base.h diff --git a/idlc/CMakeLists.txt b/idlc/CMakeLists.txt index 1d60f9f..6b3f69f 100644 --- a/idlc/CMakeLists.txt +++ b/idlc/CMakeLists.txt @@ -27,6 +27,7 @@ ADD_DEFINITIONS("-DFULLVER=\"${FULLVER}\"") 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) @@ -36,6 +37,7 @@ ADD_EXECUTABLE(${PROJECT_NAME} ${BISON_TIDLC_OUTPUTS} ${FLEX_TIDLC_OUTPUTS} ${GEN_SOURCES} + ${GEN_CION_SOURCES} ${SOURCES} ) TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${LIBPKGS_LIBRARIES} ${EXE_STATIC}) diff --git a/idlc/gen_cion/java_cion_gen_base.cc b/idlc/gen_cion/java_cion_gen_base.cc new file mode 100644 index 0000000..eabea30 --- /dev/null +++ b/idlc/gen_cion/java_cion_gen_base.cc @@ -0,0 +1,48 @@ +/* + * 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 +#include + +namespace tidl { + +JavaCionGeneratorBase::JavaCionGeneratorBase(std::shared_ptr 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 diff --git a/idlc/gen_cion/java_cion_gen_base.h b/idlc/gen_cion/java_cion_gen_base.h new file mode 100644 index 0000000..aa17b28 --- /dev/null +++ b/idlc/gen_cion/java_cion_gen_base.h @@ -0,0 +1,46 @@ +/* + * 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 +#include +#include + +#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 doc); + virtual ~JavaCionGeneratorBase() = default; + + protected: + const int TAB_SIZE = 4; + + private: + std::map type_map_; + std::map parcel_type_map_; + std::map serializer_list_; +}; + +} // namespace tidl + +#endif // IDLC_GEN_CION_JAVA_CION_GEN_BASE_H_ diff --git a/idlc/main.cc b/idlc/main.cc index 2b9cbb7..37f8aa1 100644 --- a/idlc/main.cc +++ b/idlc/main.cc @@ -33,60 +33,157 @@ #include "idlc/gen/cpp_stub_body_gen.h" #include "idlc/options.h" -int main(int argc, char** argv) { - std::shared_ptr options = tidl::Options::Parse(argc, argv); - if (!options) - exit(1); +void GenerateStubCodes(std::shared_ptr 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 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 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 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 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; } diff --git a/idlc/options.cc b/idlc/options.cc index 435eb44..b717958 100644 --- a/idlc/options.cc +++ b/idlc/options.cc @@ -17,6 +17,7 @@ #include #include +#include #include "idlc/options.h" @@ -31,17 +32,19 @@ Help Options: -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"; } @@ -58,6 +61,20 @@ void Options::PrintSample() { 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::Parse(int argc, char** argv) { int cmd[CMD_MAX] = { 0, }; int opt[OPT_MAX] = { 0, }; @@ -67,6 +84,7 @@ std::shared_ptr Options::Parse(int argc, char** argv) { 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'}, @@ -76,11 +94,12 @@ std::shared_ptr Options::Parse(int argc, char** argv) { {"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; @@ -90,11 +109,15 @@ std::shared_ptr Options::Parse(int argc, char** argv) { 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': @@ -114,8 +137,7 @@ std::shared_ptr Options::Parse(int argc, char** argv) { break; case 'l': - opt[OPT_LANGUAGE] = 1; - options->language_ = optarg; + options->language_ = ConvertStr2LanguageType(optarg); break; case 'i': @@ -136,6 +158,10 @@ std::shared_ptr Options::Parse(int argc, char** argv) { options->isThreadEnabled_ = true; break; + case 'c': + options->isCion_ = true; + break; + default: cmd[CMD_HELP] = 1; } @@ -151,16 +177,38 @@ std::shared_ptr Options::Parse(int argc, char** argv) { return std::shared_ptr(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(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(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(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(nullptr); + } + break; } if (!opt[OPT_INPUT]) { @@ -183,7 +231,6 @@ std::shared_ptr Options::Parse(int argc, char** argv) { return std::shared_ptr(nullptr); } - options->isProxy_ = cmd[CMD_PROXY] ? true : false; options->hasNamespace_ = opt[OPT_NAMESPACE] ? true : false; options->hasRpcPortLib_ = opt[OPT_RPCLIB] ? true : false; diff --git a/idlc/options.h b/idlc/options.h index d0d2536..951c0e0 100644 --- a/idlc/options.h +++ b/idlc/options.h @@ -24,14 +24,30 @@ 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 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_; } @@ -39,15 +55,12 @@ class Options { private: enum Cmd { - CMD_PROXY, - CMD_STUB, CMD_VERSION, CMD_HELP, CMD_MAX }; enum Opt { - OPT_LANGUAGE, OPT_INPUT, OPT_OUTPUT, OPT_NAMESPACE, @@ -60,8 +73,8 @@ class Options { void PrintSample(); private: - bool isProxy_ = false; - std::string language_; + bool isCion_ = false; + LanguageType language_; std::string input_; std::string output_; std::string help_; @@ -69,6 +82,7 @@ class Options { bool hasRpcPortLib_ = false; bool isBetaEnabled_ = false; bool isThreadEnabled_ = false; + Type type_; }; } // namespace tidl -- 2.7.4