#include "be_global.h"

Include dependency graph for be_extern.h:

This graph shows which files directly or indirectly include this file:

Functions
int	BE_init (int &, ACE_TCHAR *[])

void	BE_post_init (char *[], long)

void	BE_version ()

void	BE_produce ()

void	BE_abort ()

void	BE_cleanup ()

Variables
BE_GlobalData *	be_global

Function Documentation

◆ BE_abort()

void BE_abort ( )

Definition at line 103 of file be_produce.cpp.

References ACE_ERROR, ACE_TEXT(), ACE_VERSION, BE_cleanup(), be_global, ACE_String_Base< char >::c_str(), ACE_OS::exit(), BE_GlobalData::filename(), ACE_OS::getpid(), ACE_OS::gettimeofday(), header, ACE_String_Base< char >::length(), LM_ERROR, ACE_Time_Value::msec(), OPENDDS_MAJOR_VERSION, OPENDDS_MICRO_VERSION, OPENDDS_MINOR_VERSION, OPENDDS_VERSION, ACE_OS::rand_r(), ACE_OS::strcasecmp(), strlen(), and ACE_OS::thr_self().

Referenced by BE_produce().

 {
   ACE_ERROR((LM_ERROR, ACE_TEXT("Fatal Error - Aborting\n")));
   BE_cleanup();
   ACE_OS::exit(1);
 }

◆ BE_cleanup()

void BE_cleanup ( )

Definition at line 94 of file be_produce.cpp.

Referenced by BE_abort(), and BE_produce().

 {
   if (idl_global) {
     idl_global->destroy();
   }
 }

◆ BE_init()

int BE_init	(	int &	,
		ACE_TCHAR *	[]
	)

Definition at line 28 of file be_init.cpp.

References ACE_NEW_RETURN, and be_global.

 {
   ACE_NEW_RETURN(be_global, BE_GlobalData, -1);
   idl_global->default_idl_version_ = IDL_VERSION_4;
   idl_global->anon_type_diagnostic(IDL_GlobalData::ANON_TYPE_SILENT);
   return 0;
 }

◆ BE_post_init()

void BE_post_init	(	char *	[],
		long
	)

Definition at line 37 of file be_init.cpp.

References be_global, ACE_String_Base< char >::c_str(), be_util::dds_root(), OPENDDS_MAJOR_VERSION, OPENDDS_MICRO_VERSION, OPENDDS_MINOR_VERSION, and Annotations::register_all().

 {
   if (idl_global->idl_version_ < IDL_VERSION_4) {
     idl_global->ignore_files_ = true; // Exit without parsing files
     be_global->error("OpenDDS requires IDL version to be 4 or greater");
     return;
   }
 
   std::ostringstream version;
   version << "-D__OPENDDS_IDL=0x"
           << std::setw(2) << std::setfill('0') << OPENDDS_MAJOR_VERSION
           << std::setw(2) << std::setfill('0') << OPENDDS_MINOR_VERSION
           << std::setw(2) << std::setfill('0') << OPENDDS_MICRO_VERSION;
   DRV_cpp_putarg(version.str().c_str());
 
 #ifdef ACE_HAS_CDR_FIXED
   DRV_cpp_putarg("-D__OPENDDS_IDL_HAS_FIXED");
 #endif
 
   std::string include_dds = be_util::dds_root();
   if (include_dds.find(' ') != std::string::npos && include_dds[0] != '"') {
     include_dds.insert(include_dds.begin(), '"');
     include_dds.insert(include_dds.end(), '"');
   }
   be_global->add_inc_path(include_dds.c_str());
   ACE_CString included;
   DRV_add_include_path(included, include_dds.c_str(), 0, true);
 
   DRV_cpp_putarg("-D__OPENDDS_IDL_HAS_ANNOTATIONS");
   be_global->builtin_annotations_.register_all();
   // This annotation isn't used, but must match the one in idl2jni to avoid
   // warnings or errors.
   idl_global->eval("module OpenDDS {@annotation hidden_op_in_java {string impl;};};\n");
 }

◆ BE_produce()

void BE_produce ( )

Definition at line 299 of file be_produce.cpp.

References ACE_ERROR, ACE_TEXT(), BE_abort(), BE_cleanup(), be_global, ACE_String_Base< char >::c_str(), BE_GlobalData::filename(), ACE_String_Base< char >::length(), LM_ERROR, ACE_OS::strcasecmp(), and strncmp().

 {
   const char* idl_fn = idl_global->main_filename()->get_string();
   be_global->filename(idl_fn);
 
   const BE_GlobalData::stream_enum_t out_stream =
     be_global->language_mapping() == BE_GlobalData::LANGMAP_NONE
     ? BE_GlobalData::STREAM_H : BE_GlobalData::STREAM_LANG_H;
 
   ifstream idl(idl_fn);
   const size_t buffer_sz = 512;
   char buffer[buffer_sz];
   unsigned lineno = 0;
 
   while (idl) {
     idl.getline(buffer, buffer_sz);
     ++lineno;
 
     // search for #includes in the IDL, add them as #includes in the stubs/skels
     if (0 == strncmp("#include", buffer, 8)) { //FUTURE: account for comments?
       string inc(buffer + 8);
       size_t delim1 = inc.find_first_of("<\"");
       size_t delim2 = inc.find_first_of(">\"", delim1 + 1);
       string included(inc, delim1 + 1, delim2 - delim1 - 1);
       size_t len = included.size();
       string base_name;
 
       if (len >= 5 &&
           0 == ACE_OS::strcasecmp(included.c_str() + len - 4, ".idl")) {
         base_name.assign(included.c_str(), len - 4);
 
       } else if (len >= 6 &&
                  0 == ACE_OS::strcasecmp(included.c_str() + len - 5, ".pidl")) {
         base_name.assign(included.c_str(), len - 5);
 
       } else {
         continue;
       }
 
       if (be_global->language_mapping() == BE_GlobalData::LANGMAP_SP_CXX &&
           base_name.substr(0, 4) == "tao/" &&
           base_name.substr(base_name.size() - 3) == "Seq") {
         continue; // with Safety Profile C++, skip include of tao/*SeqC.h
       }
 
       string stb_inc = base_name + "C.h";
       if (stb_inc != "tao/orbC.h") {
         be_global->add_include(stb_inc.c_str(), out_stream);
         if (stb_inc == "orbC.h" ||
             (stb_inc.size() >= 7
             && stb_inc.substr(stb_inc.size() - 7) == "/orbC.h") ) {
           be_global->warning(
             "Potential inclusion of TAO orbC.h\n"
             "  Include TAO orb.idl with path of tao/orb.idl"
             "  to prevent compilation errors",
             idl_fn, lineno);
         }
       }
 
     }
   }
 
   idl.close();
 
   be_global->open_streams(idl_fn);
 
   AST_Decl* d = idl_global->root();
   AST_Root* root = dynamic_cast<AST_Root*>(d);
 
   if (root == 0) {
     ACE_ERROR((LM_ERROR,
                ACE_TEXT("(%N:%l) BE_produce - ")
                ACE_TEXT("No Root\n")));
 
     BE_abort();
   }
 
   be_global->set_inc_paths(idl_global->idl_flags());
 
   const bool java_ts_only = be_global->java_arg().length() > 0;
 
   dds_visitor visitor(d, java_ts_only);
 
   if (root->ast_accept(&visitor) == -1) {
     ACE_ERROR((LM_ERROR,
                ACE_TEXT("(%N:%l) BE_produce -")
                ACE_TEXT(" failed to accept adding visitor\n")));
     BE_abort();
   }
 
   if (!java_ts_only) {
     postprocess(be_global->header_name_.c_str(),
                 be_global->header_, BE_GlobalData::STREAM_H);
     if (!be_global->suppress_idl()) {
       postprocess(be_global->idl_name_.c_str(),
                   be_global->idl_, BE_GlobalData::STREAM_IDL);
     }
   }
 
   postprocess(be_global->impl_name_.c_str(),
               be_global->impl_, BE_GlobalData::STREAM_CPP);
 
   if (be_global->itl()) {
     if (!BE_GlobalData::writeFile(be_global->itl_name_.c_str(), be_global->itl_.str())) {
       BE_abort();  //error message already printed
     }
   }
 
   if (be_global->face_ts()) {
     postprocess(be_global->facets_header_name_.c_str(), be_global->facets_header_,
                 BE_GlobalData::STREAM_FACETS_H);
     postprocess(be_global->facets_impl_name_.c_str(), be_global->facets_impl_,
                 BE_GlobalData::STREAM_FACETS_CPP);
   }
 
   if (be_global->language_mapping() != BE_GlobalData::LANGMAP_NONE) {
     postprocess(be_global->lang_header_name_.c_str(), be_global->lang_header_,
                 BE_GlobalData::STREAM_LANG_H);
   }
 
   BE_cleanup();
 }

◆ BE_version()

void BE_version ( )

Definition at line 21 of file be_init.cpp.

References ACE_DEBUG, ACE_TEXT(), LM_DEBUG, and OPENDDS_VERSION.

 {
   ACE_DEBUG((LM_DEBUG, ACE_TEXT("OpenDDS version ") ACE_TEXT(OPENDDS_VERSION)
              ACE_TEXT("\n")));
 }

Variable Documentation

◆ be_global

BE_GlobalData* be_global

Definition at line 44 of file be_global.cpp.

Functions

Variables