path: root/modules/TAO/TAO_IDL/be_include/be_global.h

// -*- C++ -*-

// $Id$

// ============================================================================
//
// = LIBRARY
//    TAO IDL
//
// = FILENAME
//    be_global.h
//
// = DESCRIPTION
//    Header file for class containing compiler back end global data.
//
// = AUTHOR
//    Jeff Parsons <parsons@cs.wustl.edu>
//
// ============================================================================

#ifndef _BE_GLOBAL_H
#define _BE_GLOBAL_H

#include "TAO_IDL_BE_Export.h"

#include "ace/Unbounded_Queue.h"
#include "ace/SString.h"

class be_interface;
class be_valuetype;
class be_module;
class be_interface;
class be_interface_fwd;
class UTL_String;
class AST_PredefinedType;
class AST_Generator;

// Defines a class containing all back end global data.

class TAO_IDL_BE_Export BE_GlobalData
{
public:
  // = TITLE
  //    BE_GlobalData
  //
  // = DESCRIPTION
  //    Storage of global data specific to the compiler back end
  //
  enum LOOKUP_STRATEGY
  {
    // various lookup strategies
    TAO_LINEAR_SEARCH,
    TAO_DYNAMIC_HASH,
    TAO_PERFECT_HASH,
    TAO_BINARY_SEARCH
  };

  // Constructor
  BE_GlobalData (void);
  // Destructor
  virtual ~BE_GlobalData (void);

  // To switch between changing or non-changing standard include
  // files (e.g. tao/corba.h)  so that #include statements can be
  // generated with ""s or <>s respectively.
  virtual void changing_standard_include_files (size_t changing);
  virtual size_t changing_standard_include_files (void);

  // Helper functions that generate the file names for the C++ mapping
  // generated code.
  // The parameter <base_name_only> set to 0 (no base name, but full
  // name with output dir path, is useful, when I just want just the
  // base name to use in #include's etc.
  static const char *be_get_client_hdr_fname (
      bool base_name_only = false);
      
  static const char *be_get_client_stub_fname (void);
  
  static const char *be_get_client_inline_fname (
      bool base_name_only = false);
      
  static const char *be_get_server_hdr_fname (
      bool base_name_only = false);
      
  static const char *be_get_implementation_hdr_fname (
      bool base_name_only = false);
      
  static const char *be_get_implementation_skel_fname (
      bool base_name_only = false);
      
  static const char *be_get_server_template_hdr_fname (
      bool base_name_only = false);
      
  static const char *be_get_server_skeleton_fname (void);
  
  static const char *be_get_implementation_skeleton_fname (void);
  
  static const char *be_get_server_template_skeleton_fname (
      bool base_name_only = false);
      
  static const char *be_get_server_inline_fname (
      bool base_name_only = false);
      
  static const char *be_get_anyop_source_fname (
      bool base_name_only = false);
      
  static const char *be_get_anyop_header_fname (
      bool base_name_only = false);
      
  static const char *be_get_ciao_svnt_hdr_fname (
      bool base_name_only = false);
      
  static const char *be_get_ciao_svnt_src_fname (
      bool base_name_only = false);
      
  static const char *be_get_ciao_exec_hdr_fname (
      bool base_name_only = false);
      
  static const char *be_get_ciao_exec_src_fname (
      bool base_name_only = false);
      
  static const char *be_get_ciao_exec_stub_hdr_fname (
      bool base_name_only = false);

  static const char *be_get_ciao_exec_idl_fname (
      bool base_name_only = false);

  // Helper functions: obtain the names of each generated file given
  // the IDL file name.
  // The parameter <base_name_only> set to 0 (no base name, but full
  // name with output dir path, is useful, when I want just the
  // base name to use in #include's etc.
  static const char *be_get_client_hdr (
    UTL_String *idl_file_name,
    bool base_name_only = false);
    
  static const char *be_get_client_stub (
    UTL_String *idl_file_name);
    
  static const char *be_get_client_inline (
    UTL_String *idl_file_name,
    bool base_name_only = false);
    
  static const char *be_get_server_hdr (
    UTL_String *idl_file_name,
    bool base_name_only = false);
    
  static const char *be_get_implementation_hdr (
    UTL_String *idl_file_name,
    bool base_name_only = false);
    
  static const char *be_get_implementation_skel (
    UTL_String *idl_file_name,
    bool base_name_only = false);
    
  static const char *be_get_server_template_hdr (
    UTL_String *idl_file_name,
    bool base_name_only = false);
    
  static const char *be_get_server_skeleton (
    UTL_String *idl_file_name);
    
  static const char *be_get_server_template_skeleton (
      UTL_String *idl_file_name,
      bool base_name_only = false);
      
  static const char *be_get_server_inline (
    UTL_String *idl_file_name,
    bool base_name_only = false);
    
  static const char *be_get_anyop_header (
    UTL_String *idl_file_name,
    bool base_name_only = false);
    
  static const char *be_get_anyop_source (
    UTL_String *idl_file_name,
    bool base_name_only = false);

  static const char *be_get_ciao_svnt_header (
    UTL_String *idl_file_name,
    bool base_name_only = false);

  static const char *be_get_ciao_svnt_source (
    UTL_String *idl_file_name,
    bool base_name_only = false);

  static const char *be_get_ciao_exec_header (
    UTL_String *idl_file_name,
    bool base_name_only = false);

  static const char *be_get_ciao_exec_source (
    UTL_String *idl_file_name,
    bool base_name_only = false);
    
  static const char *be_get_ciao_exec_stub_header (
    UTL_String *idl_file_name,
    bool base_name_only = false);

  static const char *be_get_ciao_exec_idl (
    UTL_String *idl_file_name,
    bool base_name_only = false);
    
  static const char *be_get_dds_typesupport_header (
    UTL_String *idl_file_name,
    bool base_name_only = false);

  const char* skel_export_macro (void) const;
  /// Returns the macro name for exporting server side classes in Win32
  /// DLL.

  void skel_export_macro (const char* s);
  /// Set the macro name for export server side classes in Win32 DLL.

  const char* skel_export_include (void) const;
  /// Returns the name of the include file that contains the server
  /// side export macro definition.

  void skel_export_include (const char* s);
  /// Set the name of the include file that contains the server side
  /// export macro definition.

  const char* stub_export_macro (void) const;
  /// Returns the macro name for exporting client side classes in Win32
  /// DLL.

  void stub_export_macro (const char* s);
  /// Set the macro name for export client side classes in Win32 DLL.

  const char* stub_export_include (void) const;
  /// Returns the name of the include file that contains the client
  /// side export macro definition.

  void stub_export_include (const char* s);
  /// Set the name of the include file that contains the client side
  /// export macro definition.

  const char* anyop_export_macro (void) const;
  /// Returns the macro name for exporting *A.h file classes in Win32
  /// DLL.

  void anyop_export_macro (const char* s);
  /// Set the macro name for export *A.h file classes in Win32 DLL.

  const char* anyop_export_include (void) const;
  /// Returns the name of the include file that contains the *A.h
  /// file export macro definition.

  void anyop_export_include (const char* s);
  /// Set the name of the include file that contains the *A.h file
  /// export macro definition.

  const char* exec_export_macro (void) const;
  /// Returns the macro name for exporting exec impl classes in Win32
  /// DLL.

  void exec_export_macro (const char* s);
  /// Set the macro name for export exec impl classes in Win32 DLL.

  const char* exec_export_include (void) const;
  /// Returns the name of the include file that contains the exec
  /// impl export macro definition.

  void exec_export_include (const char* s);
  /// Set the name of the include file that contains the exec impl
  /// export macro definition.

  const char* svnt_export_macro (void) const;
  /// Returns the macro name for exporting CIAO svnt classes in Win32
  /// DLL.

  void svnt_export_macro (const char* s);
  /// Set the macro name for export CIAO svnt classes in Win32 DLL.

  const char* svnt_export_include (void) const;
  /// Returns the name of the include file that contains the CIAO
  /// svnt export macro definition.

  void svnt_export_include (const char* s);
  /// Set the name of the include file that contains the CIAO svnt
  /// export macro definition.

  const char* pch_include (void) const;
  /// Returns the name of the include file to be used for precompiled
  /// header support.

  void pch_include (const char* s);
  /// Set the name of the include file to be used for precompiled
  /// header support.

  const char* pre_include (void) const;
  /// Returns the name of the include file to be put at the top of
  /// every header file.

  void pre_include (const char* s);
  /// Set the name of the include file to be put at the top of every
  /// header file.

  const char* post_include (void) const;
  /// Returns the name of the include file to be put at the bottom of
  /// every header file.

  void post_include (const char* s);
  /// Set the name of the include file to be put at the bottom of every
  /// header file.

  const char* include_guard (void) const;
  /// Returns the guard that is placed in the client header file

  void include_guard (const char* s);
  /// Set the guard that is placed in the client header file

  const char* safe_include (void) const;
  /// Returns the name of the include file that is used instead of the own
  /// generated client header file

  void safe_include (const char* s);
  /// set the name of the include file that is used instead of the own
  /// generated client header file

  const char* unique_include (void) const;
  /// Returns the name of the include file that should on get
  /// generated in the client header file

  void unique_include (const char* s);
  // Set the name of the include file that should on get
  // generated in the client header file

  /// Set text that opens a "versioned" namespace.
  void versioning_begin (const char* s);

  /// Get text that opens a "versioned" namespace.
  const char * versioning_begin (void) const;

  /// Get text that opens a "versioned" namespace for core TAO/orbsvcs
  /// related code.
  const char * core_versioning_begin (void) const;

  /// Set text that closes a "versioned" namespace.
  void versioning_end (const char* s);

  /// Get text that closes a "versioned" namespace.
  const char * versioning_end (void) const;

  /// Get text that closes a "versioned" namespace for core TAO/orbsvcs
  /// related code.
  const char * core_versioning_end (void) const;

  // = Set and get methods for different file name endings.

  void client_hdr_ending (const char* s);
  // Set the client_hdr_ending.

  const char* client_hdr_ending (void) const;
  // Get the client_hdr_ending.

  void client_inline_ending (const char* s);
  // Set the client_inline_ending.

  const char* client_inline_ending (void) const;
  // Get the client_inline_ending.

  void  client_stub_ending (const char* s);
  // Set the client_stub_ending.

  const char* client_stub_ending (void) const;
  // Get the client_stub_ending.

  void server_hdr_ending (const char* s);
  // Set the server_hdr_ending.

  const char* server_hdr_ending (void) const;
  // Get the server_hdr_ending.

  void implementation_hdr_ending (const char* s);
  // Set the implementation_hdr_ending.

  void impl_class_prefix (const char* s);
  // Set the implementation class prefix.

  void impl_class_suffix (const char* s);
  // Set the implementation class suffix.

  void implementation_skel_ending (const char* s);
  // Set the implementation_skel_ending.

  const char* implementation_hdr_ending (void) const;
  // Get the implementation_hdr_ending.

  const char* impl_class_prefix (void) const;
  //Get implementation class prefix

  const char* impl_class_suffix (void) const;
  //Get implementation class suffix

  const char* implementation_skel_ending (void) const;
  // Get the implementation_skel_ending.

  void server_template_hdr_ending (const char* s);
  // Set the server_template_hdr_ending.

  const char* server_template_hdr_ending (void) const;
  // Get the server_template_hdr_ending.

  void server_skeleton_ending (const char* s);
  // Set the server_skeleton_ending.

  const char* server_skeleton_ending (void) const;
  // Get the server_skeleton_ending.

  void server_template_skeleton_ending (const char* s);
  // Set the server_template_skeleton_ending.

  const char* server_template_skeleton_ending (void) const;
  // Get the server_template_skeleton_ending.

  void server_inline_ending (const char* s);
  // Set the server_inline_ending.

  const char* server_inline_ending (void) const;
  // Get the server_inline_ending.

  void anyop_header_ending (const char* s);
  // Set the anyop_header_ending.

  const char* anyop_header_ending (void) const;
  // Get the anyop_header_ending.

  void anyop_source_ending (const char* s);
  // Set the anyop_source_ending.

  const char* anyop_source_ending (void) const;
  // Get the anyop_source_ending.
  
  void ciao_svnt_header_ending (const char* s);
  const char* ciao_svnt_header_ending (void) const;
  void ciao_svnt_source_ending (const char* s);
  const char* ciao_svnt_source_ending (void) const;
  void ciao_exec_header_ending (const char* s);
  const char* ciao_exec_header_ending (void) const;
  void ciao_exec_source_ending (const char* s);
  const char* ciao_exec_source_ending (void) const;
  void ciao_exec_stub_header_ending (const char* s);
  const char* ciao_exec_stub_header_ending (void) const;
  void ciao_exec_idl_ending (const char* s);
  const char* ciao_exec_idl_ending (void) const;
  // Similar to above, but for CIAO servant and executor
  // impl and executor IDL files, if generated.
  
  void dds_typesupport_hdr_ending (const char* s);
  const char* dds_typesupport_hdr_ending (void) const;
  // For generating TypeSupport header file includes.

  void use_clonable_in_args (bool clonable);
  // Set the clonable_in_args.

  bool use_clonable_in_args (void) const;
  // Get the clonable_in_args setting.

  bool gen_template_export (void) const;
  // Get the gen_seq_template_export_ member.

  void gen_template_export (bool val);
  // Set the gen_seq_template_export_ member.

  bool gen_ostream_operators (void) const;
  // Get the gen_ostream_operators_ member.

  void gen_ostream_operators (bool val);
  // Set the gen_ostream_operators_ member.

  void output_dir (const char* s);
  // Set the directory where all the IDL-Compiler-Generated files are
  // to be kept. Default is current directory from which the
  // <tao_idl> is called.

  const char* output_dir (void) const;
  // Get the directory where all the IDL-Compiler-Generated files are
  // to be kept. Default is current directory from which the
  // <tao_idl> is called.

  void skel_output_dir (const char* s);
  // Set the directory where all the *S.* files are
  // to be kept. Default is output_dir_.

  const char* skel_output_dir (void) const;
  // Get the directory where all the *S.* files are
  // to be kept. Default is output_dir_.

  void anyop_output_dir (const char* s);
  // Set the directory where all the *A.* files are
  // to be kept. Default is output_dir_.

  const char* anyop_output_dir (void) const;
  // Get the directory where all the *A.* files are
  // to be kept. Default is output_dir_.

  void any_support (bool);
  // Set any support.

  bool any_support (void) const;
  // Check Any support.

  void tc_support (bool);
  // Set TypeCode support.

  bool tc_support (void) const;
  // Check TypeCode support

  void obv_opt_accessor (bool);
  // Set optimized valuetype member accessor generation.

  bool obv_opt_accessor (void) const;
  // Check optimized valuetype member accessor generation.

  void gen_impl_files (bool);
  // Set generation of implementation files.

  bool gen_impl_files (void) const;
  // Check if we want to generate implementation files.

  void gen_impl_debug_info (bool);
  // Set generation of source file and line number for implementation files.

  bool gen_impl_debug_info (void) const;
  // Check generation of source file and line number implementation files.

  void gen_copy_ctor (bool);
  // Set generation of copy constructor.

  bool gen_copy_ctor (void) const;
  // Check if we want to generate the copy constructor.

  void gen_assign_op (bool);
  // Set the generation of the assignment operator.

  bool gen_assign_op (void) const;
  // Check if we want to generate the assignment operator.

  void gen_thru_poa_collocation (bool);
  // Set whether we want to generate Thru_POA collocation stubs.

  bool gen_thru_poa_collocation (void) const;
  // Check if we want to generate Thru_POA collocation stubs.

  void gen_direct_collocation (bool);
  // Set whether we want to generate Direct collocation stubs.

  bool gen_direct_collocation (void) const;
  // Check if we want to generate Direct collocation stubs.

  void gen_corba_e (bool);
  // Set whether we want to generate for CORBA/e

  bool gen_corba_e (void) const;
  // Check if we want to generate for CORBA/e

  void gen_minimum_corba (bool);
  // Set whether we want to generate for Minimum CORBA

  bool gen_minimum_corba (void) const;
  // Check if we want to generate for Minimum CORBA

  void opt_tc (bool);
  // Set optimized typecodes.

  bool opt_tc (void) const;
  // Check if TypeCodes are optimized.

  void ami_call_back (bool value);
  // To enable or disable AMI call back feature of the Messaging
  // specification in the generated code.

  bool ami_call_back (void) const;
  // Return the flag.

  void gen_amh_classes (bool value);
  // To enable or disable AMH in the generated code.

  bool gen_amh_classes (void) const;
  // Return the flag.

  void gen_tie_classes (bool value);
  // Set the generation of tie classes and files.

  bool gen_tie_classes (void) const;
  // Return the flag.

  void gen_smart_proxies (bool value);
  // To enable or disable AMI call back feature of the Messaging
  // specification in the generated code.

  bool gen_smart_proxies (void) const;
  // Return the flag.

  void gen_inline_constants (bool value);
  // Set the flag.

  bool gen_inline_constants (void) const;
  // Return the flag.

  void gen_dcps_type_support (bool value);
  // Set the flag.

  bool gen_dcps_type_support (void) const;
  // Return the flag.

  void gen_dcps_type_support_only (bool value);
  // Set the flag.

  bool gen_dcps_type_support_only (void) const;
  // Return the flag.

  void gen_orb_h_include (bool value);
  // Set the flag.

  bool gen_orb_h_include (void) const;
  // Return the flag.

  bool gen_empty_anyop_header (void) const;
  // Generate an empty anyop header (A.h)

  void gen_empty_anyop_header (bool value);
  // Generate an empty anyop header (A.h)

  void lookup_strategy (LOOKUP_STRATEGY s);
  // Set the lookup strategy.

  BE_GlobalData::LOOKUP_STRATEGY lookup_strategy (void) const;
  // Return the enumerated value for the lookup strategy. Default is
  // perfect hashing.

  void destroy (void);
  // Cleanup function.

  ACE_Unbounded_Queue<be_interface *> non_local_interfaces;
  // Used in the generation of declarations for
  // xxx_Proxy_Broker_Factory_function_pointer.

  ACE_Unbounded_Queue<be_interface_fwd *> non_defined_interfaces;
  // Used in the generation of extern function declarations so we
  // can use non-defined interfaces as members and parameters.

  ACE_Unbounded_Queue<be_interface *> mixed_parentage_interfaces;
  // Used in the generation of overrides for CORBA::release and
  // CORBA::is_nil, needed when the interface inherits versions from
  // both CORBA::Object and CORBA::AbstractBase.

  AST_PredefinedType *void_type (void);
  // Accessor for the member, sets it on the first call.

  be_interface *ccmobject (void);
  // Accessor for the member, sets it on the first call.

  be_module *messaging (void);
  // Accessor for the member, sets it on the first call.

  be_valuetype *messaging_exceptionholder (void);
  // Accessor for the member, sets it on the first call.

  be_valuetype *exceptionholder (void) const;
  void exceptionholder (be_valuetype *val);
  // Accessors for the member.

  be_interface *messaging_replyhandler (void);
  // Accessor for the member, sets it on the first call.

  bool gen_anyop_files (void) const;
  void gen_anyop_files (bool val);
  // Accessors for the member.

  bool gen_skel_files (void) const;
  void gen_skel_files (bool val);
  // Accessors for the member gen_skel_files_.

  bool gen_client_inline (void) const;
  void gen_client_inline (bool val);
  // Accessors for the member gen_client_inline_.

  bool gen_server_inline (void) const;
  void gen_server_inline (bool val);
  // Accessors for the member gen_server_inline_.

  bool gen_client_stub (void) const;
  void gen_client_stub (bool val);
  // Accessors for the member gen_client_stub_.

  bool gen_server_skeleton (void) const;
  void gen_server_skeleton (bool val);
  // Accessors for the member gen_server_skeleton_.

  bool gen_local_iface_anyops (void) const;
  void gen_local_iface_anyops (bool val);
  // Accessors for the member gen_local_iface_anyops_.

  bool gen_custom_ending (void) const;
  void gen_custom_ending (bool val);
  // Accessors for the member gen_custom_ending_.
  
  bool gen_ciao_svnt (void) const;
  void gen_ciao_svnt (bool val);
  bool gen_ciao_exec_idl (void) const;
  void gen_ciao_exec_idl (bool val);
  bool gen_ciao_exec_impl (void) const;
  void gen_ciao_exec_impl (bool val);
  // Accessors for the corresponding members.
  
  bool gen_component_swapping (void) const;
  void gen_component_swapping (bool val);

  bool gen_ciao_static_config (void) const;
  void gen_ciao_static_config (bool val);

  bool gen_ciao_valuefactory_reg (void) const;
  void gen_ciao_valuefactory_reg (bool val);

  bool gen_stub_export_hdr_file (void) const;
  void gen_stub_export_hdr_file (bool val);

  bool gen_skel_export_hdr_file (void) const;
  void gen_skel_export_hdr_file (bool val);

  bool gen_svnt_export_hdr_file (void) const;
  void gen_svnt_export_hdr_file (bool val);

  bool gen_exec_export_hdr_file (void) const;
  void gen_exec_export_hdr_file (bool val);
  
  bool gen_lem_force_all (void) const;
  void gen_lem_force_all (bool val);

  ACE_CString spawn_options (void);
  // Command line passed to ACE_Process::spawn. Different
  // implementations in IDL and IFR backends.

  void parse_args (long &i, char **av);
  // Parse args that affect the backend.

  void prep_be_arg (char *s);
  // Special BE arg call factored out of DRV_args.

  void arg_post_proc (void);
  // Checks made after parsing args.

  void usage (void) const;
  // Display usage of BE-specific options.

  AST_Generator *generator_init (void);
  // Create an AST node generator.
  
  const char *get_output_path (bool for_anyop,
                               bool for_skel);
  // Called from various places.

private:
  size_t changing_standard_include_files_;
  // To switch between changing or non-changing standard include
  // files (e.g. tao/corba.h)  so that #include statements can be
  // generated with ""s or <>s respectively.

  // Macros and includes used to export classes from generated code.
  char* skel_export_macro_;
  char* skel_export_include_;
  char* stub_export_macro_;
  char* stub_export_include_;

  // Macro and include used on ORB .pidl files generating to the
  // AnyTypeCode library.
  char* anyop_export_macro_;
  char* anyop_export_include_;

  char* exec_export_macro_;
  char* exec_export_include_;
  char* svnt_export_macro_;
  char* svnt_export_include_;

  char* pch_include_;
  char* pre_include_;
  char* post_include_;
  char* include_guard_;
  char* safe_include_;
  char* unique_include_;

  /// Text that opens a "versioned" namespace for core TAO and orbsvcs
  /// related code.
  ACE_CString core_versioning_begin_;

  /// Text that closes a "versioned" namespace for core TAO and
  /// orbsvcs related code.
  ACE_CString core_versioning_end_;

  /// Text that opens a "versioned" namepace.
  ACE_CString versioning_begin_;

  /// Text that closes a "versioned" namepace.
  ACE_CString versioning_end_;

  // Client's header file name ending. Default is "C.h".
  char* client_hdr_ending_;

  // Client's stub's file name ending. Default is "C.cpp".
  char* client_stub_ending_;

  // Client's inline file name ending. Default is "C.i".
  char* client_inline_ending_;

  // Server's hdr file name ending. Default is "S.h".
  char* server_hdr_ending_;

  // Implementation's hdr file name ending. Default is "I.h".
  char* implementation_hdr_ending_;

  // Implementation's skeleton file name ending. Default is "I.cpp".
  char* implementation_skel_ending_;

  //Implementaion class prefix
  char* impl_class_prefix_;

  //Implementation class suffix
  char* impl_class_suffix_;

  // Server's template hdr file name ending. Default is "S_T.h".
  char* server_template_hdr_ending_;

  // Server's skeleton file name ending. Default is "S.cpp".
  char* server_skeleton_ending_;

  // Server's template skeleton file name ending. Default is
  // "S_T.cpp".
  char* server_template_skeleton_ending_;

  // Server's inline file name ending. Default is "S.i".
  char* server_inline_ending_;

  // Anyop header file name ending. Default is "A.h".
  char* anyop_hdr_ending_;

  // Anyop source file name ending. Default is "A.cpp".
  char* anyop_src_ending_;
  
  // CIAO servant header file name ending. Default is "_svnt.h".
  char* ciao_svnt_hdr_ending_;

  // CIAO servant source file name ending. Default is "_svnt.cpp".
  char* ciao_svnt_src_ending_;

  // CIAO executor impl header file name ending. Default is "_exec.h".
  char* ciao_exec_hdr_ending_;

  // CIAO executor impl source file name ending. Default is "_exec.cpp".
  char* ciao_exec_src_ending_;

  // CIAO executor stub header file name ending. Default is "EC.h".
  char* ciao_exec_stub_hdr_ending_;
  
  // CIAO executor IDL file name ending. Default is "E.idl".
  char* ciao_exec_idl_ending_;
  
  // DDS TypeSupport header file name ending. Default is "Support.h".
  char* dds_typesupport_hdr_ending_;

  char* output_dir_;
  // Directory where all the IDL-Compiler-Generated files are to be
  // kept. Default value is 0 for this string which means the current
  // directory from which the <tao_idl> is called.

  char* skel_output_dir_;
  // Directory where all the *S.* files are to be
  // kept. Default value is 0 for this string which means the
  // value for output_dir_ is used.

  char* anyop_output_dir_;
  // Directory where all the *A.* files are to be
  // kept. Default value is 0 for this string which means the
  // value for output_dir_ is used.

  bool any_support_;
  // do we support Any operators?

  bool tc_support_;
  // do we support typecodes?

  bool obv_opt_accessor_;
  // do we optimize valuetype accessors?

  bool gen_impl_files_;
  // are we generating implementation files?

  bool gen_impl_debug_info_;
  // are we generating source file and line numbers for implementation files?

  bool gen_copy_ctor_;
  // are we generating the copy constructor?

  bool gen_assign_op_;
  // are we generating the assignment operator?

  bool gen_thru_poa_collocation_;
  // are we generating Thru_POA collocated stubs?

  bool gen_direct_collocation_;
  // are we generating Direct collocated stubs?

  bool gen_corba_e_;
  // are we generating for CORBA/e

  bool gen_minimum_corba_;
  // are we generating for Minimum CORBA

  bool opt_tc_;
  // do we generate optimized typecodes?

  bool ami_call_back_;
  // Flag to indicate whether the AMI Call back feature of the
  // Messaging specification should be enabled for the generated files
  // or not.

  bool gen_amh_classes_;
  // Flag for generating AMH classes.

  bool gen_tie_classes_;
  // Flag to indicate whether we generate the tie classes and
  // files or not.

  bool gen_smart_proxies_;
  // Flag to indicate whether smart proxies classes will be generated
  // or not.

  bool gen_inline_constants_;
  // Flag to indicate whether we are using an inline form of constant
  // generation that pleases the C++ compiler better on some platforms.

  bool gen_dcps_type_support_;
  // Flag to indicate whether we are supporting DDS DCPS type definitions.
  // Includes Serializer operators (like TAO_Input/OutuptCDR).

  bool gen_dcps_type_support_only_;
  // Flag to indicate whether we are supporting DDS DCPS type only definitions.
  // Only generate DDS Serializer operators for tao/*Seq.pidl.

  bool gen_orb_h_include_;
  // Flag to indicate whether ORB.h include should be generated, needed for
  // regenerating the pidl files.

  bool gen_empty_anyop_header_;
  // Flag to indicate whether an empty A.h should be generated

  LOOKUP_STRATEGY lookup_strategy_;
  // The enumerated value indicating the lookup strategy.

  AST_PredefinedType *void_type_;
  // Used for void operation return types.

  be_interface *ccmobject_;
  // Reference holder for component skeleton visitors.

  be_module *messaging_;
  // Storage for the messaging exceptions holder's virtual scope.

  be_valuetype *messaging_exceptionholder_;
  // Storage for exception holders' base class node.

  be_valuetype *exceptionholder_;
  // Reference holder for the exceptionholder.

  be_interface *messaging_replyhandler_;
  // Storage for the reply handlers' base class node.

  bool gen_anyop_files_;
  // Separate files for generated Any operators?

  bool gen_skel_files_;
  // True by default, but a command line option can turn this off so
  // we generate only an empty *S.h file on the skeleton side.

  bool gen_client_inline_;
  // True by default, but a command line option can turn this off so
  // that we don't generate a client inline file

  bool gen_server_inline_;
  // True by default, but a command line option can turn this off so
  // that we don't generate a server inline file

  bool gen_client_stub_;
  // True by default, but a command line option can turn this off so
  // that we don't generate a client stub file

  bool gen_server_skeleton_;
  // True by default, but a command line option can turn this off so
  // that we don't generate a server skeleton file

  bool gen_local_iface_anyops_;
  // True by default, can be turned off by a command line option
  // for regenerating internal ORB files.

  bool use_clonable_in_args_;
  // Use in_clonable_arg_val instead of in_arg_val?

  bool gen_template_export_;
  // Generate explicit export for Visual Studio bug workaround,
  // needed only in TAO basic sequence *C.h files.

  bool gen_ostream_operators_;
  // Generate ostream operators for each type declaration, for
  // debugging or logging.

  bool gen_custom_ending_;
  // True by default, but a command line option can turn this off so
  // custom ending will not be applied to files in $TAO_ROOT/,
  // $TAO_ROOT/tao, $TAO_ROOT/orbsvcs, $TAO_ROOT/CIAO, $TAO_ROOT/CIAO/ciao.

  bool gen_ciao_svnt_;
  bool gen_ciao_exec_idl_;
  bool gen_ciao_exec_impl_;
  // False by default, these flags trigger code generation
  // formerly done by the CIAO CIDL compiler.
  
  bool gen_component_swapping_;
  // Different container #includes, modified servant code.
  
  bool gen_ciao_static_config_;
  // Suppresses generation of table guards in CIAO servants.
  
  bool gen_ciao_valuefactory_reg_;
  // Generate automatic valuetype factory registration in
  // CIAO servants.
  
  bool gen_stub_export_hdr_file_;
  bool gen_skel_export_hdr_file_;
  bool gen_svnt_export_hdr_file_;
  bool gen_exec_export_hdr_file_;
  // Flags toggling export header file generation.
  
  bool gen_lem_force_all_;
  // Toggles generation of exec IDL for facets with imported
  // interface types (not in main IDL file).
};

#endif /* _BE_GLOBAL_H */