From 0e47c66125c03dd6118a9db58f093d8d9804cd40 Mon Sep 17 00:00:00 2001 From: Ebersold Date: Mon, 20 Dec 2021 21:34:45 +0100 Subject: [PATCH] Initial import from SVN --- CMakeLists.txt | 184 ++++ ast/ast_builder.cpp | 412 ++++++++ ast/ast_builder.h | 54 ++ ast/ast_recursive_visitor.h | 250 +++++ gdmo_config.h | 36 + gdmo_config.h.in | 36 + libgen/CMakeLists.txt | 28 + libgen/gdmo_genasn1.cpp | 139 +++ libgen/gdmo_genasn1.h | 24 + libgen/gdmo_gencpp.cpp | 256 +++++ libgen/gdmo_gencpp.h | 30 + libgen/gdmo_gencpp_action.cpp | 91 ++ libgen/gdmo_gencpp_action.h | 38 + libgen/gdmo_gencpp_attribute.cpp | 135 +++ libgen/gdmo_gencpp_attribute.h | 38 + libgen/gdmo_gencpp_mo.cpp | 328 +++++++ libgen/gdmo_gencpp_mo.h | 41 + libgen/gdmo_gencpp_parameter.cpp | 321 ++++++ libgen/gdmo_gencpp_parameter.h | 41 + libgen/gdmo_generator.cpp | 83 ++ libgen/gdmo_generator.h | 82 ++ libgen/gdmo_genhpp.cpp | 449 +++++++++ libgen/gdmo_genhpp.h | 29 + libparser/CMakeLists.txt | 29 + libparser/gdmo.l | 264 +++++ libparser/gdmo.y | 1300 +++++++++++++++++++++++++ libparser/gdmo_parser.h | 220 +++++ libparser/parser.cpp | 385 ++++++++ libparser/parser_listener.cpp | 77 ++ main.cpp | 262 +++++ pgdmo/GDMOTemplates.py | 5 + pgdmo/GDMOUtils.py | 44 + pgdmo/Generators/__init__.py | 7 + pgdmo/Generators/asn1.py | 88 ++ pgdmo/Generators/common.py | 35 + pgdmo/Generators/db.py | 261 +++++ pgdmo/Generators/mocpp.py | 269 ++++++ pgdmo/__init__.py | 2 + pgdmo/gdmolex.py | 234 +++++ pgdmo/gdmoparse.py | 1559 ++++++++++++++++++++++++++++++ pgdmo/pgdom | 76 ++ rt/managed_object.h | 21 + 42 files changed, 8263 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 ast/ast_builder.cpp create mode 100644 ast/ast_builder.h create mode 100644 ast/ast_recursive_visitor.h create mode 100644 gdmo_config.h create mode 100644 gdmo_config.h.in create mode 100644 libgen/CMakeLists.txt create mode 100644 libgen/gdmo_genasn1.cpp create mode 100644 libgen/gdmo_genasn1.h create mode 100644 libgen/gdmo_gencpp.cpp create mode 100644 libgen/gdmo_gencpp.h create mode 100644 libgen/gdmo_gencpp_action.cpp create mode 100644 libgen/gdmo_gencpp_action.h create mode 100644 libgen/gdmo_gencpp_attribute.cpp create mode 100644 libgen/gdmo_gencpp_attribute.h create mode 100644 libgen/gdmo_gencpp_mo.cpp create mode 100644 libgen/gdmo_gencpp_mo.h create mode 100644 libgen/gdmo_gencpp_parameter.cpp create mode 100644 libgen/gdmo_gencpp_parameter.h create mode 100644 libgen/gdmo_generator.cpp create mode 100644 libgen/gdmo_generator.h create mode 100644 libgen/gdmo_genhpp.cpp create mode 100644 libgen/gdmo_genhpp.h create mode 100644 libparser/CMakeLists.txt create mode 100644 libparser/gdmo.l create mode 100644 libparser/gdmo.y create mode 100644 libparser/gdmo_parser.h create mode 100644 libparser/parser.cpp create mode 100644 libparser/parser_listener.cpp create mode 100644 main.cpp create mode 100644 pgdmo/GDMOTemplates.py create mode 100644 pgdmo/GDMOUtils.py create mode 100644 pgdmo/Generators/__init__.py create mode 100644 pgdmo/Generators/asn1.py create mode 100644 pgdmo/Generators/common.py create mode 100755 pgdmo/Generators/db.py create mode 100644 pgdmo/Generators/mocpp.py create mode 100644 pgdmo/__init__.py create mode 100644 pgdmo/gdmolex.py create mode 100755 pgdmo/gdmoparse.py create mode 100755 pgdmo/pgdom create mode 100644 rt/managed_object.h diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..c09b79e --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,184 @@ +PROJECT(gdmo) + +SUBDIRS(libparser libgen) + +OPTION(WITH_X721 "Gdmo Build" OFF) + +INCLUDE(CheckIncludeFiles) +INCLUDE(CheckIncludeFile) +INCLUDE(CheckTypeSize) +INCLUDE(CheckFunctionExists) +INCLUDE(CheckLibraryExists) +INCLUDE(CheckSymbolExists) +CHECK_INCLUDE_FILE(unistd.h HAVE_UNISTD_H) +CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/gdmo_config.h.in + ${CMAKE_CURRENT_BINARY_DIR}/gdmo_config.h) + +IF (NOT CMAKE_BUILD_TYPE) + SET(CMAKE_BUILD_TYPE Debug) +ENDIF(NOT CMAKE_BUILD_TYPE) + +# Only for Linux not MAC +IF(APPLE) + SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG ") +ELSE(APPLE) + SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG -std=c++0x") + SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -std=c++0x") +ENDIF(APPLE) + + +INCLUDE(${rules_SOURCE_DIR}/flex.cmake) +INCLUDE_DIRECTORIES(${cmip-lib_BINARY_DIR}/) +INCLUDE_DIRECTORIES(${asn1_SOURCE_DIR}/) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/rt) +IF (NOT WIN32) + SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__FILENAME__='\"$(subst ${CMAKE_CURRENT_SOURCE_DIR}/,,$<)\"'") +ENDIF(NOT WIN32) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}) +INCLUDE_DIRECTORIES(${aebutils_SOURCE_DIR}/aeb) +INCLUDE_DIRECTORIES(${aebutils_SOURCE_DIR}/) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../common/include) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/libparser) +ADD_DEFINITIONS(-DWITH_ADT_GDMO) + + +IF (NOT CMAKE_CROSSCOMPILING) + ADD_EXECUTABLE(gdmo + main.cpp + ast/ast_builder.cpp + ) + TARGET_LINK_LIBRARIES(gdmo gdmoparser gdmogen) + EXPORT(TARGETS gdmo FILE ${CMAKE_BINARY_DIR}/ImportExecutables.cmake + NAMESPACE native-) +ENDIF(NOT CMAKE_CROSSCOMPILING) + + +IF(CMAKE_CROSSCOMPILING) + SET(gdmo_EXE native-gdmo) + GET_TARGET_PROPERTY(test ${gdmo_EXE} IMPORTED_LOCATION_DEBUG) + SET(asn1p_EXE ${test}) +ELSE(CMAKE_CROSSCOMPILING) + SET(gdmo_EXE ${CMAKE_CURRENT_BINARY_DIR}/gdmo) + SET(asn1_EXE ${CMAKE_CURRENT_BINARY_DIR}/../asn1/asn1p) +ENDIF(CMAKE_CROSSCOMPILING) + +# +# Ok, Add some custom commands +# +IF (WITH_X721) + +ADD_CUSTOM_COMMAND( + OUTPUT + ${CMAKE_CURRENT_BINARY_DIR}/mo/top.h + ${CMAKE_CURRENT_BINARY_DIR}/mo/top.cpp + ${CMAKE_CURRENT_BINARY_DIR}/attribute/weekMask.cpp + COMMAND ${gdmo_EXE} + ARGS -I ${asn1-data-models_SOURCE_DIR}/cmip/ + -f x721.gdmo + DEPENDS ${gdmo_EXE} + ${CMAKE_CURRENT_BINARY_DIR}/Attribute_ASN1Module.h + ${CMAKE_CURRENT_BINARY_DIR}/Notification_ASN1Module.h + ${CMAKE_CURRENT_BINARY_DIR}/Parameter_ASN1Module.h + ${CMAKE_CURRENT_BINARY_DIR}/ACSE_1.h + COMMENT "Build x721 Managed Objects " + ) + +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/x721.asn1 + GENERATED) +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/mo/top.cpp + GENERATED) +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/attribute/weekMask.cpp + GENERATED) + +# +# We need asn1 types +# +ADD_CUSTOM_COMMAND( + OUTPUT + ${CMAKE_CURRENT_BINARY_DIR}/Attribute_ASN1Module.h + ${CMAKE_CURRENT_BINARY_DIR}/Attribute-ASN1Module.cpp + COMMAND ${asn1_EXE} + ARGS -I ${asn1-data-models_SOURCE_DIR}/cmip/ + -f Attribute-ASN1Module.asn1 + -f ../CMIP-1.asn1 + -f ../cstav1/apdu_acse.asn1 + -o Attribute-ASN1Module + DEPENDS ${gdmo_EXE} ${asn1_EXE} + COMMENT "Build Attribute-ASN1Module.asn1" + ) + +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/Attribute_ASN1Module.h + GENERATED) +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/Attribute-ASN1Module.cpp + GENERATED) +# +# ACSE +ADD_CUSTOM_COMMAND( + OUTPUT + ${CMAKE_CURRENT_BINARY_DIR}/ACSE_1.h + ${CMAKE_CURRENT_BINARY_DIR}/ACSE-1.cpp + COMMAND ${asn1_EXE} + ARGS -I ${asn1-data-models_SOURCE_DIR}/cmip/ + -f Attribute-ASN1Module.asn1 + -f ../CMIP-1.asn1 + -f ../cstav1/apdu_acse.asn1 + -o ACSE-1 + DEPENDS ${gdmo_EXE} ${asn1_EXE} + COMMENT "Build ACSE-1.asn1" + ) + +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/ACSE_1.h + GENERATED) +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/ACSE-1.cpp + GENERATED) + + +# +# Notif +ADD_CUSTOM_COMMAND( + OUTPUT + ${CMAKE_CURRENT_BINARY_DIR}/Notification_ASN1Module.h + ${CMAKE_CURRENT_BINARY_DIR}/Notification-ASN1Module.cpp + COMMAND ${asn1_EXE} + ARGS -I ${asn1-data-models_SOURCE_DIR}/cmip/ + -f Notification-ASN1Module.asn1 + -f Attribute-ASN1Module.asn1 + -f ../CMIP-1.asn1 + -f ../cstav1/apdu_acse.asn1 + -o Notification-ASN1Module + DEPENDS ${gdmo_EXE} ${asn1_EXE} + COMMENT "Compiling Notification-ASN1Module.asn1" + ) +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/Notification_ASN1Module.h + GENERATED) +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/Notification-ASN1Module.cpp + GENERATED) + +# +# Notif +ADD_CUSTOM_COMMAND( + OUTPUT + ${CMAKE_CURRENT_BINARY_DIR}/Parameter_ASN1Module.h + ${CMAKE_CURRENT_BINARY_DIR}/Parameter-ASN1Module.cpp + COMMAND ${asn1_EXE} + ARGS -I ${asn1-data-models_SOURCE_DIR}/cmip/ + -f Parameter-ASN1Module.asn1 + -f Attribute-ASN1Module.asn1 + -f ../CMIP-1.asn1 + -f ../cstav1/apdu_acse.asn1 + -o Parameter-ASN1Module + DEPENDS ${gdmo_EXE} ${asn1_EXE} + COMMENT "Compiling Parameter-ASN1Module.asn1" + ) +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/Parameter_ASN1Module.h + GENERATED) +SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/Parameter-ASN1Module.cpp + GENERATED) + + +ADD_LIBRARY(x721 + ${CMAKE_CURRENT_BINARY_DIR}/mo/top.cpp + ${CMAKE_CURRENT_BINARY_DIR}/attribute/weekMask.cpp +) +ENDIF(WITH_X721) diff --git a/ast/ast_builder.cpp b/ast/ast_builder.cpp new file mode 100644 index 0000000..c2e8efc --- /dev/null +++ b/ast/ast_builder.cpp @@ -0,0 +1,412 @@ +#include "gdmo_config.h" +#include "ADT/Adt.h" + +#include "gdmo_parser.h" +#include "ast_builder.h" + +struct sdisp +{ + void operator ()(const std::string &s) + { + std::cerr<<"ASN1 -> "<(m_Stack.top()); + mod->insert(tmp); + } +} + +void +ast_builder::on_pkg_attribute_start(ADT::GDMO::pkg_attribute &t) +{ + m_Stack.push(&t); +} + +void +ast_builder::on_pkg_attribute(ADT::GDMO::pkg_attribute &t) +{ + m_Stack.pop(); +} + +void +ast_builder::on_module_end(module &m) +{ + std::cerr<<"ast_builder::got module end stack size="<(m_Stack.top()); + if (mo) + { + mo->set_characterized_by(&_c); + } else + { + std::cerr<<"ast::builder::on_characterized_by failed"<(m_Stack.top()); + if (mo) + { + mo->set_cond_packages(&_c); + } else + { + std::cerr<<"ast::builder::on_set_cond_packages failed"<(m_Stack.top()); + if (mo) + { + mo->set_registered(&_c); + } else + { + std::cerr<<"ast::builder::on_set_registered failed"<(m_Stack.top()); + if (pkg) + { + pkg->set_behaviour(&_c); + } else + { + std::cerr<<"ast::builder::on_pkg_behaviour failed"<(m_Stack.top()); + if (pkg) + { + //std::cerr<<"ast::builder::on_pkg_attributes got "<<_c.size()<set_attributes(&_c); + } else + { + std::cerr<<"ast::builder::on_pkg_attributes failed"<(m_Stack.top()); + if (pkg) + { + pkg->set_actions(&_c); + } else + { + std::cerr<<"ast::builder::on_pkg_actions failed"<(m_Stack.top()); + if (pkg) + { + pkg->set_notifications(&_c); + } else + { + std::cerr<<"ast::builder::on_pkg_notifications failed"<(m_Stack.top()); + if (attr) + { + attr->set_syntax(&_c); + if (ADT::GDMO::typeref *ref = dynamic_cast(_c.get_decl())) + { + m_asn1_mset.insert(ref->get_asn1_module()); + } + } else + { + std::cerr<<"ast::builder::on_attr_syntax failed"<(m_Stack.top()); + if (attr) + { + attr->set_match_for(&_c); + } else + { + std::cerr<<"ast::builder::on_match_for failed"<(m_Stack.top()); + if (attr) + { + attr->set_behaviour(&_c); + } else + { + std::cerr<<"ast::builder::on_attr_behaviour failed"<(m_Stack.top()); + if (attr) + { + attr->set_parameters(&_c); + } else + { + std::cerr<<"ast::builder::on_attr_parameters failed"<(m_Stack.top()); + if (attr) + { + attr->set_registered(&_c); + } else + { + std::cerr<<"ast::builder::on_attr_parameters failed"<(m_Stack.top()); \ + if (attr) \ + { \ + attr->set_##cls(&_c); \ + } else \ + { \ + std::cerr<<"ast::builder::on_attr_parameters " #cls " failed"<(_c.get_decl())) + { + m_asn1_mset.insert(ref->get_asn1_module()); + } + +}) +GDMO_CONSTRUCT_DECL(parameter,attribute,{}) +GDMO_CONSTRUCT_DECL(parameter,behaviour,{}) +GDMO_CONSTRUCT_DECL(parameter,registered,{}) + +/** + * + */ +GDMO_CONSTRUCT_DECL(name_binding,subordinate,{}) +GDMO_CONSTRUCT_DECL(name_binding,named_by_superior,{}) +GDMO_CONSTRUCT_DECL(name_binding,with_attribute,{}) +GDMO_CONSTRUCT_DECL(name_binding,behaviour,{}) +GDMO_CONSTRUCT_DECL(name_binding,create,{}) +GDMO_CONSTRUCT_DECL(name_binding,delete,{}) +GDMO_CONSTRUCT_DECL(name_binding,registered,{}) + +/** + * + */ +GDMO_CONSTRUCT_DECL(action,behaviour,{}) +GDMO_CONSTRUCT_DECL(action,mode,{}) +GDMO_CONSTRUCT_DECL(action,parameters,{}) +GDMO_CONSTRUCT_DECL(action,with_information,{ + if (ADT::GDMO::typeref *ref = dynamic_cast(_c.get_decl())) + { + m_asn1_mset.insert(ref->get_asn1_module()); + } + +}) +GDMO_CONSTRUCT_DECL(action,with_reply,{ + if (ADT::GDMO::typeref *ref = dynamic_cast(_c.get_decl())) + { + m_asn1_mset.insert(ref->get_asn1_module()); + } +}) +GDMO_CONSTRUCT_DECL(action,registered,{}) + +/** + * + */ +GDMO_CONSTRUCT_DECL(notification,mode,{}) +GDMO_CONSTRUCT_DECL(notification,behaviour,{}) +GDMO_CONSTRUCT_DECL(notification,parameters,{}) +GDMO_CONSTRUCT_DECL(notification,with_information,{ + if (ADT::GDMO::typeref *ref = dynamic_cast(_c.get_decl())) + { + m_asn1_mset.insert(ref->get_asn1_module()); + } +}) +GDMO_CONSTRUCT_DECL(notification,with_reply,{ + if (ADT::GDMO::typeref *ref = dynamic_cast(_c.get_decl())) + { + m_asn1_mset.insert(ref->get_asn1_module()); + } +}) +GDMO_CONSTRUCT_DECL(notification,registered,{}) + + +GDMO_CONSTRUCT_DECL(attribute_group,group_elements,{}) + +GDMO_CONSTRUCT_DECL(behaviour,defined_as,{}) + + +#undef GDMO_PROPLIST_DECL +#define GDMO_PROPLIST_DECL(tplte,cls,parent) \ +void ast_builder::on_## tplte##_##cls(tplte ##_## cls &_c) \ +{ \ + pkg_attribute *attr = dynamic_cast(m_Stack.top()); \ + if (attr) \ + { \ + attr->set_##cls(&_c); \ + } else \ + { \ + std::cerr<<"ast::builder::on_attr_parameters " #cls " failed"< asn1ModuleSet; + typedef std::list moduleList; + typedef std::stack declStack; + + ast_builder(); + ~ast_builder(); + +#define GDMO_DECL(cls,p) +#define GDMO_TPLT_DECL(cls,p) \ + virtual void on_##cls(ADT::GDMO::cls &t) ; + +#define GDMO_CONSTRUCT_DECL(cls,p) \ + virtual void on_##cls(ADT::GDMO::cls &t) ; +#define GDMO_PROPLIST_DECL(cls,p) \ + virtual void on_##cls(ADT::GDMO::cls &t) ; +#include "ADT/gdmo/Gdmo.h.inc" +#include "ADT/gdmo/Gdmo.h.inc" + + virtual void on_module_start(module &m); + + virtual void on_module_end(module &m); + + void on_template_start(ADT::GDMO::templates *t); + void on_template(ADT::GDMO::templates &t); + + void on_pkg_attribute_start(ADT::GDMO::pkg_attribute &t); + void on_pkg_attribute(ADT::GDMO::pkg_attribute &t); + GDMO::parser_listener *get_listener() + { + return this; + } + moduleList &get_modules() + { + return m_Modules; + } + protected: + moduleList m_Modules; + declStack m_Stack; + asn1ModuleSet m_asn1_mset; +}; + +#endif /*AST_BUILD_H*/ diff --git a/ast/ast_recursive_visitor.h b/ast/ast_recursive_visitor.h new file mode 100644 index 0000000..0d1287e --- /dev/null +++ b/ast/ast_recursive_visitor.h @@ -0,0 +1,250 @@ +#ifndef AST_RECURSIVE_VISITOR_H__ +#define AST_RECURSIVE_VISITOR_H__ + +template +class ast_recursive_visitor +{ + public: + ast_recursive_visitor() {}; + + Derived &get_derived() { return *static_cast(this); } + +#define TRY_TO(x) do { \ + if (! get_derived().x ) \ + return false; \ +} while(0) + + bool traverse_templates(templates *S); + bool traverse_construct(construct *S); + bool traverse_Adt(Adt *S); + bool traverse_decl(decl *S); + // +#define GDMO_DECL(cls,parent) +//#define GDMO_DECL(cls,parent) bool traverse_##cls(cls *s); +#define GDMO_PROPLIST_DECL(cls,parent) +#define GDMO_TPLT_DECL(cls,parent) bool traverse_##cls(cls *s); +#define GDMO_CONSTRUCT_DECL(cls,parent) bool traverse_##cls(cls *s); + +#include "ADT/gdmo/Gdmo.h.inc" + // + bool walkup_from_decl(decl *S) + { return get_derived().visit_decl(S);}; + + bool visit_decl(decl *S) + { return true;} + // + // + bool walkup_from_templates(templates *S) + { return get_derived().visit_templates(S);}; + + bool visit_templates(templates *S) + { return true;} + // + bool walkup_from_construct(construct *S) + { return get_derived().visit_construct(S);}; + + bool visit_construct(construct *S) + { return true;} + +#define GDMO_DECL(cls,parent) +#define GDMO_PROPLIST_DECL(cls,parent) +#define GDMO_TPLT_DECL(cls,parent) \ + bool walkup_from_##cls(cls *S) \ + { \ + TRY_TO(walkup_from_ ## parent(S)); \ + TRY_TO(visit_##cls(S)); \ + return true; \ + } \ + bool visit_##cls(cls *S) { return true;} +#define GDMO_CONSTRUCT_DECL(x,y) GDMO_TPLT_DECL(x,y) +//#define GDMO_DECL(x,y) GDMO_TPLT_DECL(x,y) +#include "ADT/gdmo/Gdmo.h.inc" +}; + +/** + * Implementation part for traverse + */ +template +bool ast_recursive_visitor::traverse_decl(decl *d) +{ + if (!d ) + return true; + TRY_TO(walkup_from_decl(d)); +#if 0 + switch (d->getClass()) + { +#define GDMO_TPLT_DECL(cls,parent) +#define GDMO_CONSTRUCT_DECL(cls,parent) +#define GDMO_DECL(cls,parent) \ + case Adt::cls##Class : DISPATCH(cls,d) +#include "ADT/gdmo/Gdmo.h.inc" + default: + ; + } +#endif + return true; +} + + +template +bool ast_recursive_visitor::traverse_templates(templates *d) +{ +#define DISPATCH(cls,v) \ + return get_derived().traverse_##cls(static_cast(v)); + + if (!d ) + return true; + switch (d->getClass()) + { +#define GDMO_DECL(cls,parent) +#define GDMO_TPLT_DECL(cls,parent) \ + case Adt::cls##Class : DISPATCH(cls,d) +#define GDMO_CONSTRUCT_DECL(cls,parent) +#include "ADT/gdmo/Gdmo.h.inc" + default: + ; + } + return true; + +} + +template +bool ast_recursive_visitor::traverse_Adt(Adt *d) +{ +#define DISPATCH(cls,v) \ + return get_derived().traverse_##cls(static_cast(v)); + + if (!d ) + return true; + switch (d->getClass()) + { +#define GDMO_DECL(cls,parent) +#define GDMO_TPLT_DECL(cls,parent) \ + case Adt::cls##Class : DISPATCH(cls,d) +#define GDMO_CONSTRUCT_DECL(cls,parent) +#include "ADT/gdmo/Gdmo.h.inc" + case Adt::labelClass: + DISPATCH(decl,d) + default: + ; + } + return true; + +} + + +template +bool ast_recursive_visitor::traverse_construct(construct *d) +{ + if (!d ) + return true; + switch (d->getClass()) + { +#define GDMO_DECL(cls,parent) +#define GDMO_TPLT_DECL(cls,parent) +#define GDMO_CONSTRUCT_DECL(cls,parent) \ + case Adt::cls##Class : DISPATCH(cls,d) +#include "ADT/gdmo/Gdmo.h.inc" + default: + ; + } + return true; +} + + +#define DEF_TRAVERSE_TPLT(DECL,CODE) \ + template \ + bool ast_recursive_visitor::traverse_##DECL(DECL *d) { \ + TRY_TO(walkup_from_##DECL(d)); \ + { CODE;} \ + return true; \ + } \ + + +DEF_TRAVERSE_TPLT(mo_tplt,{ + TRY_TO(traverse_construct(d->get_derived_from())); + TRY_TO(traverse_construct(d->get_characterized_by())); + TRY_TO(traverse_construct(d->get_cond_packages())); +}) +DEF_TRAVERSE_TPLT(package_tplt,{ + TRY_TO(traverse_construct(d->get_attributes())); + TRY_TO(traverse_construct(d->get_notifications())); + TRY_TO(traverse_construct(d->get_actions())); +}) +DEF_TRAVERSE_TPLT(name_binding_tplt,{}) +DEF_TRAVERSE_TPLT(attribute_tplt,{}) +DEF_TRAVERSE_TPLT(attribute_group_tplt,{}) +DEF_TRAVERSE_TPLT(behaviour_tplt,{}) +DEF_TRAVERSE_TPLT(action_tplt,{}) +DEF_TRAVERSE_TPLT(parameter_tplt,{}) +DEF_TRAVERSE_TPLT(notification_tplt,{}) + +//#define GDMO_CONSTRUCT_DECL(x,y) DEF_TRAVERSE_TPLT(x,y) +#define GDMO_CONSTRUCT_DECL(DECL,CODE) \ + template \ + bool ast_recursive_visitor::traverse_##DECL(DECL *d) { \ + TRY_TO(walkup_from_##DECL(d)); \ + { CODE;} \ + for (Container::iterator i = d->begin() ; i != d->end() ; ++i) { \ + TRY_TO(traverse_Adt(static_cast(&(*i)))); \ + } \ + return true; \ + } \ + + +GDMO_CONSTRUCT_DECL(mo_derived_from,{}) +GDMO_CONSTRUCT_DECL(mo_characterized_by,{}) +GDMO_CONSTRUCT_DECL(mo_cond_packages,{}) +GDMO_CONSTRUCT_DECL(mo_registered,{}) + +GDMO_CONSTRUCT_DECL(pkg_behaviour,{}) +GDMO_CONSTRUCT_DECL(pkg_attributes,{}) +GDMO_CONSTRUCT_DECL(pkg_attribute_group,{}) +GDMO_CONSTRUCT_DECL(pkg_actions,{}) +GDMO_CONSTRUCT_DECL(pkg_notifications,{}) +GDMO_CONSTRUCT_DECL(pkg_registered,{}) + + +GDMO_CONSTRUCT_DECL(attr_syntax,{}) +GDMO_CONSTRUCT_DECL(attr_match_for,{}) +GDMO_CONSTRUCT_DECL(attr_behaviour,{}) +GDMO_CONSTRUCT_DECL(attr_parameters,{}) +GDMO_CONSTRUCT_DECL(attr_registered,{}) + +GDMO_CONSTRUCT_DECL(parameter_context,{}) +GDMO_CONSTRUCT_DECL(parameter_syntax,{}) +GDMO_CONSTRUCT_DECL(parameter_attribute,{}) +GDMO_CONSTRUCT_DECL(parameter_behaviour,{}) +GDMO_CONSTRUCT_DECL(parameter_registered,{}) + +GDMO_CONSTRUCT_DECL(name_binding_subordinate,{}) +GDMO_CONSTRUCT_DECL(name_binding_named_by_superior,{}) +GDMO_CONSTRUCT_DECL(name_binding_with_attribute,{}) +GDMO_CONSTRUCT_DECL(name_binding_behaviour,{}) +GDMO_CONSTRUCT_DECL(name_binding_create,{}) +GDMO_CONSTRUCT_DECL(name_binding_delete,{}) +GDMO_CONSTRUCT_DECL(name_binding_registered,{}) + +GDMO_CONSTRUCT_DECL(action_behaviour,{}) +GDMO_CONSTRUCT_DECL(action_mode,{}) +GDMO_CONSTRUCT_DECL(action_parameters,{}) +GDMO_CONSTRUCT_DECL(action_with_information,{}) +GDMO_CONSTRUCT_DECL(action_with_reply,{}) +GDMO_CONSTRUCT_DECL(action_registered,{}) + +GDMO_CONSTRUCT_DECL(notification_mode,{}) +GDMO_CONSTRUCT_DECL(notification_behaviour,{}) +GDMO_CONSTRUCT_DECL(notification_parameters,{}) +GDMO_CONSTRUCT_DECL(notification_with_information,{}) +GDMO_CONSTRUCT_DECL(notification_with_reply,{}) +GDMO_CONSTRUCT_DECL(notification_registered,{}) + +GDMO_CONSTRUCT_DECL(attribute_group_group_elements,{}) + +GDMO_CONSTRUCT_DECL(behaviour_defined_as,{}) + +/** + * Implementation part for + */ +#endif + diff --git a/gdmo_config.h b/gdmo_config.h new file mode 100644 index 0000000..4d90fd3 --- /dev/null +++ b/gdmo_config.h @@ -0,0 +1,36 @@ +#ifndef GDMO_CONFIG_H +#define GDMO_CONFIG_H + +/* Define to 1 if you have the header file. */ +#define HAVE_UNISTD_H 1 + +/**/ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +// for memset +#include +#include +#include +#if defined(HAVE_UNISTD_H) +#include +#endif +#if defined (_WIN32) +#include +#define access _access_s +#define F_OK 0 + +#include +#include +#define getcwd _getcwd +#define mkdir _mkdir +#endif + +#endif /*GDMO_CONFIG_H*/ diff --git a/gdmo_config.h.in b/gdmo_config.h.in new file mode 100644 index 0000000..9d458e3 --- /dev/null +++ b/gdmo_config.h.in @@ -0,0 +1,36 @@ +#ifndef GDMO_CONFIG_H +#define GDMO_CONFIG_H + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_UNISTD_H 1 + +/**/ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +// for memset +#include +#include +#include +#if defined(HAVE_UNISTD_H) +#include +#endif +#if defined (_WIN32) +#include +#define access _access_s +#define F_OK 0 + +#include +#include +#define getcwd _getcwd +#define mkdir _mkdir +#endif + +#endif /*GDMO_CONFIG_H*/ diff --git a/libgen/CMakeLists.txt b/libgen/CMakeLists.txt new file mode 100644 index 0000000..1451679 --- /dev/null +++ b/libgen/CMakeLists.txt @@ -0,0 +1,28 @@ +PROJECT(gdmogen) + + +IF (NOT CMAKE_BUILD_TYPE) + SET(CMAKE_BUILD_TYPE Debug) +ENDIF(NOT CMAKE_BUILD_TYPE) + +# Only for Linux not MAC +IF(APPLE) + SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG ") +ELSE(APPLE) + SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG -std=c++0x") + SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -std=c++0x") +ENDIF(APPLE) + +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../) + + +ADD_LIBRARY(gdmogen + gdmo_generator.cpp + gdmo_genasn1.cpp + gdmo_genhpp.cpp + gdmo_gencpp.cpp + gdmo_gencpp_mo.cpp + gdmo_gencpp_attribute.cpp + gdmo_gencpp_action.cpp + ) diff --git a/libgen/gdmo_genasn1.cpp b/libgen/gdmo_genasn1.cpp new file mode 100644 index 0000000..de09b81 --- /dev/null +++ b/libgen/gdmo_genasn1.cpp @@ -0,0 +1,139 @@ +#include "gdmo_config.h" + +#include "ADT/Adt.h" +#include "gdmo_generator.h" +#include "gdmo_genasn1.h" + + +genasn1::genasn1(GDMO::generator::moduleList &l) + : GDMO::generator(l) +{ + std::cout<<"Start generator ASN1"<begin(); + m_os<<" {"; + for ( ; i != r->end() + ; ++i) + { + ADT::GDMO::oid_item *oidi = dynamic_cast(&(*i)); + m_os<<" "<get_name(); + } + m_os<<"}"; + } +} + + +#undef GDMO_TPLT_DECL +#define GDMO_TPLT_DECL(cls,parent) \ +void genasn1::gen_## cls( ADT::GDMO::cls &c) \ +{ \ + parent \ +} + +/** + * + */ + +GDMO_TPLT_DECL(mo_tplt,{}) +GDMO_TPLT_DECL(package_tplt,{}) +GDMO_TPLT_DECL(name_binding_tplt,{}) +GDMO_TPLT_DECL(attribute_tplt, +{ + ADT::GDMO::attr_registered *r = c.get_registered(); + if (r) + { + m_os<lookup(s); +} + +void +gencpp::gen_oid(ADT::GDMO::construct *r) +{ + if (r) + { + ADT::Container::iterator i = r->begin(); + m_os<<" {"; + for ( ; i != r->end() + ; ++i) + { + ADT::GDMO::oid_item *oidi = dynamic_cast(&(*i)); + m_os<<" "<get_name(); + } + m_os<<"}"; + } +} + +void +gencpp::open(ADT::GDMO::templates &t) +{ + struct stat st; + std::string fn; + std::string tname = t.get_label().getName(); + // Check if gLog directory exists +#ifdef WIN32 +#define MKDIR(x) mkdir(x); +#else +#define MKDIR(x) mkdir(x,0777); +#endif + +#define CHECK_CREATE(x) \ + if (stat (x,ast) == -1) \ + MKDIR(x) + +#define TPLT(cls) \ + case ADT::Adt::cls ## _tpltClass: \ + { MKDIR(#cls); fn.append(#cls) ; fn+="/";} break; + switch (t.getClass()) + { + TPLT(mo) + TPLT(action) + TPLT(notification) + TPLT(parameter) + TPLT(attribute) + default: + ; + }; +#undef TPLT +#undef MKDIR +#undef CHECK_CREATE + + fn.append(tname); + fn += ".cpp"; + if (m_os.is_open()) + m_os.close(); + m_os.open(fn.c_str(),std::fstream::out); +} + +void +gencpp::close() +{ + m_os.close(); +} + +#undef GDMO_TPLT_DECL +#define GDMO_TPLT_DECL(cls,parent) \ +void gencpp::gen_## cls( ADT::GDMO::cls &c) \ +{ \ + parent \ +} + +/** + * + */ + +/** + * Generate code for managed Object + */ +GDMO_TPLT_DECL(mo_tplt, +{ + std::string mo = c.get_label().getName(); + open(c); + + gencpp_mo gen(m_os,*this,c); + gen.generate(); + close(); +}) + +/** + * + * + */ +void gencpp::gen_mo_package(mo_tplt &mo,ADT::GDMO::package_tplt &t) +{ + std::string cname = mo.get_label().getName(); + ADT::GDMO::pkg_attributes *attrs = t.get_attributes(); + if (attrs) + { + ADT::Container::iterator i = attrs->begin(); + for ( ; i != attrs->end() + ; ++i) + { + ADT::GDMO::label *l = dynamic_cast(&(*i)); + if (l) + { + m_os<<"\n//\n"; + m_os<<"void\n"<getName()<<"_set(const "<getName()<<" &e)\n"; + m_os<<"{}\n"; + m_os<<"\n//\nvoid\n"<getName()<<"_get("<getName()<<" &e)\n"; + m_os<<"{}\n"; + // resolve and call gen + } else + { + m_os<<"//"<<"_xxx();\n"; + } + } + } + +} + +GDMO_TPLT_DECL(package_tplt, +{ + // std::cout<<"gencpp::package_tplt "<(reply->get_decl())) + { + m_os<<"\t"<getName()<<"\tm_reply;\n"; + } + } + // + if (info) + { + if (ADT::GDMO::typeref *ref = dynamic_cast(info->get_decl())) + { + m_os<<"\t"<getName()<<"\tm_info;\n"; + } + } + m_os<<"};\n"<\n"; + m_os<<"#include \n"; + m_os<<"#include \n"; + // Need to include asn1 definitions + m_os<<"#include \"asn1/asn1_rose.h\"\n"; + m_os<<"#include \"cmip/CMIP_1.h\"\n"; + + // Try to use a template visitor for this purpose + // Need to include parameters attributes actions notifications + m_os<<"#include \"action/"<(syntax->get_decl()); + lbl = dynamic_cast(syntax->get_decl()); + } + + //mo_derived_from *derived = m_tplt.get_derived_from(); + m_os<<"// Autamtic generated do not edit\n"; + m_os<<"#include \n"; + m_os<<"#include \n"; + m_os<<"#include \n"; + // Need to include asn1 definitions + //m_os<<"#include \"asn1/asn1_rose.h\"\n"; + //m_os<<"#include \"cmip/CMIP_1.h\"\n"; + m_os<<"#include \"CMIP_1.h\"\n"; + m_os<<"#include \"ACSE_1.h\"\n"; + if (ref) + { + m_os<<"#include \""<<::GDMO::cpp(ref->get_asn1_module())<<".h\"\n"; + m_os<<"using namespace "<<::GDMO::cpp(ref->get_asn1_module())<<";\n"; + } + if (lbl) + { + // Missing syntax ... + m_os<<"#include \"attribute/"<getName()<<".h\"\n"; + } + // Try to use a template visitor for this purpose + // Need to include parameters attributes actions notifications + m_os<<"#include \"attribute/"<(syntax->get_decl()); + } + + // encode function + m_os<<"\nvoid "<get_asn1_module())<<"::"<getName()<<" &v)\n{\n"; + m_os<<"\tm_syntax = v;\n"; + m_os<<"\n}\n"; + // getter + m_os<<"\tint "<get_asn1_module())<<"::"<getName()<<" &v)\n{\n"; + m_os<<"\tv = m_syntax;\n"; + m_os<<"\treturn true;\n"; + m_os<<"\n}\n"; + } +} + +void +gencpp_attribute::gen_equal() +{ +} + diff --git a/libgen/gdmo_gencpp_attribute.h b/libgen/gdmo_gencpp_attribute.h new file mode 100644 index 0000000..9547695 --- /dev/null +++ b/libgen/gdmo_gencpp_attribute.h @@ -0,0 +1,38 @@ +#ifndef GDMO_GENCPP_ATTRIBUTE_H +#define GDMO_GENCPP_ATTRIBUTE_H + +/** + * + */ +class gencpp_attribute +{ + public: + typedef void (gencpp_attribute::*fct_gen_ptr)(decl &l); + + gencpp_attribute(std::ostream &os,gencpp &g,attribute_tplt &t); + + void generate(); + + attribute_tplt & tplt() + { + return m_tplt; + } + gencpp & gen() + { + return m_gen; + } + protected: + void gen_includes(); + void gen_ctors(); + void gen_codec(); + void gen_equal(); + void gen_attribute_include(decl &attr); + // setter / getter for attribute + protected: + std::string m_inc_path; + gencpp &m_gen; + attribute_tplt &m_tplt; + std::ostream &m_os; +} +; +#endif /*GDMO_GENCPP_ATTRIBUTE_H*/ diff --git a/libgen/gdmo_gencpp_mo.cpp b/libgen/gdmo_gencpp_mo.cpp new file mode 100644 index 0000000..8e88c4c --- /dev/null +++ b/libgen/gdmo_gencpp_mo.cpp @@ -0,0 +1,328 @@ +#include "gdmo_config.h" + +#include "ADT/Adt.h" +#include "gdmo_generator.h" +#include "gdmo_gencpp.h" + +using namespace ADT; +using namespace ADT::GDMO; +#include "gdmo_gencpp_mo.h" + +/** + * + */ +struct do_package +{ + do_package(std::ostream &os,gencpp_mo &c) + : m_os(os),m_gen(c) + { + } + void operator()(Adt &adt) + { + package_tplt *p = dynamic_cast(&(adt)); + label *l = dynamic_cast