GeneratorBase Struct Reference

Inheritance diagram for GeneratorBase:

Classes
struct	GenerateUnionAccessors

Public Member Functions
virtual	~GeneratorBase ()
virtual void	init ()=0
virtual void	gen_sequence (UTL_ScopedName *tdname, AST_Sequence *seq)=0
virtual bool	gen_struct (AST_Structure *s, UTL_ScopedName *name, const std::vector< AST_Field *> &fields, AST_Type::SIZE_TYPE size, const char *x)=0
virtual std::string	const_keyword (AST_Expression::ExprType)
std::string	map_type (AST_Type *type)
std::string	map_type (AST_Field *field)
virtual std::string	map_type_string (AST_PredefinedType::PredefinedType chartype, bool constant)
std::string	map_type (AST_Expression::ExprType type)
virtual void	gen_simple_out (const char *nm)
virtual bool	scoped_enum ()
virtual std::string	enum_base ()
virtual void	struct_decls (UTL_ScopedName *name, AST_Type::SIZE_TYPE size, const char *struct_or_class="struct")
virtual bool	gen_union (AST_Union *u, UTL_ScopedName *name, const std::vector< AST_UnionBranch *> &branches, AST_Type *discriminator)
virtual void	gen_array (UTL_ScopedName *tdname, AST_Array *arr)
virtual void	gen_array_traits (UTL_ScopedName *tdname, AST_Array *arr)
virtual void	gen_array_typedef (const char *nm, AST_Type *base)
virtual void	gen_typedef_varout (const char *nm, AST_Type *base)

Static Public Member Functions
static std::string	generateDefaultValue (AST_Union *the_union)
static bool	hasDefaultLabel (const std::vector< AST_UnionBranch *> &branches)
static size_t	countLabels (const std::vector< AST_UnionBranch *> &branches)
static bool	needsDefault (const std::vector< AST_UnionBranch *> &branches, AST_Type *discriminator)
static void	generate_union_field (AST_UnionBranch *branch)
static std::string	generateCopyCtor (const std::string &, AST_Decl *, const std::string &name, AST_Type *field_type, const std::string &, bool, Intro &, const std::string &)
static std::string	generateAssign (const std::string &, AST_Decl *, const std::string &name, AST_Type *field_type, const std::string &, bool, Intro &, const std::string &)
static std::string	generateEqual (const std::string &, AST_Decl *, const std::string &name, AST_Type *field_type, const std::string &, bool, Intro &, const std::string &)
static std::string	generateReset (const std::string &, AST_Decl *, const std::string &name, AST_Type *field_type, const std::string &, bool, Intro &, const std::string &)

Detailed Description

Definition at line 87 of file langmap_generator.cpp.

Constructor & Destructor Documentation

~GeneratorBase()

virtual GeneratorBase::~GeneratorBase ( )

inlinevirtual

Definition at line 89 of file langmap_generator.cpp.

References init(), and name.

{}

Member Function Documentation

const_keyword()

virtual std::string GeneratorBase::const_keyword ( AST_Expression::ExprType  )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 94 of file langmap_generator.cpp.

  {
    return "const";
  }

countLabels()

static size_t GeneratorBase::countLabels ( const std::vector< AST_UnionBranch *> &  branches )

inlinestatic

Definition at line 394 of file langmap_generator.cpp.

  {
    size_t count = 0;

    for (std::vector<AST_UnionBranch*>::const_iterator pos = branches.begin(), limit = branches.end();
         pos != limit;
         ++pos) {
      count += (*pos)->label_list_length();
    }

    return count;
  }

enum_base()

virtual std::string GeneratorBase::enum_base ( )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 179 of file langmap_generator.cpp.

{ return ""; }

gen_array()

virtual void GeneratorBase::gen_array ( UTL_ScopedName *  tdname, AST_Array *  arr  )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 660 of file langmap_generator.cpp.

References be_global, AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_WIDE, AstTypeClassification::classify(), and NestedForLoops::index_.

  {
    be_global->add_include("<tao/Array_VarOut_T.h>", BE_GlobalData::STREAM_LANG_H);
    be_global->add_include("dds/DCPS/SafetyProfilePool.h", BE_GlobalData::STREAM_LANG_H);
    const char* const nm = tdname->last_component()->get_string();
    AST_Type* elem = arr->base_type();
    const Classification elem_cls = classify(elem);
    const Helper var = (elem->size_type() == AST_Type::VARIABLE)
      ? HLP_ARR_VAR_VAR : HLP_ARR_FIX_VAR,
      out = HLP_ARR_OUT,
      forany = HLP_ARR_FORANY;

    std::ostringstream bound, nofirst, total;
    const std::string zeros = array_zero_indices(arr);
    for (ACE_CDR::ULong dim = 0; dim < arr->n_dims(); ++dim) {
      const ACE_CDR::ULong extent = arr->dims()[dim]->ev()->u.ulval;
      bound << '[' << extent << ']';
      if (dim) {
        nofirst << '[' << extent << ']';
        total << " * ";
      }
      total << extent;
    }

    std::string elem_type = map_type(elem);
    if (elem_cls & CL_STRING) {
      elem_type = helpers_[(elem_cls & CL_WIDE) ? HLP_WSTR_MGR : HLP_STR_MGR];
    }

    std::string out_type = nm;
    if (elem->size_type() == AST_Type::VARIABLE) {
      out_type = helpers_[out] + '<' + nm + ", " + nm + "_var, " + nm +
        "_slice, " + nm + "_tag>";
    }

    be_global->lang_header_ <<
      "typedef " << elem_type << ' ' << nm << bound.str() << ";\n"
      "typedef " << elem_type << ' ' << nm << "_slice" << nofirst.str() << ";\n"
      "struct " << nm << "_tag {};\n"
      "typedef " << helpers_[var] << '<' << nm << ", " << nm << "_slice, "
      << nm << "_tag> " << nm << "_var;\n"
      "typedef " << out_type << ' ' << nm << "_out;\n"
      "typedef " << helpers_[forany] << '<' << nm << ", " << nm << "_slice, "
      << nm << "_tag> " << nm << "_forany;\n\n" <<
      exporter() << nm << "_slice* " << nm << "_alloc();\n" <<
      exporter() << "void " << nm << "_init_i(" << elem_type << "* begin);\n" <<
      exporter() << "void " << nm << "_fini_i(" << elem_type << "* begin);\n" <<
      exporter() << "void " << nm << "_free(" << nm << "_slice* slice);\n" <<
      exporter() << nm << "_slice* " << nm << "_dup(const " << nm
      << "_slice* slice);\n" <<
      exporter() << "void " << nm << "_copy(" << nm << "_slice* dst, const "
      << nm << "_slice* src);\n\n";
    const ScopedNamespaceGuard namespaces(tdname, be_global->impl_);
    be_global->impl_ <<
      nm << "_slice* " << nm << "_alloc()\n"
      "{\n"
      "  void* const raw = ACE_Allocator::instance()->malloc"
      "(sizeof(" << nm << "));\n"
      "  " << nm << "_slice* const slice = static_cast<" << nm << "_slice*"
      << ">(raw);\n"
      "  " << nm << "_init_i(slice" << zeros << ");\n"
      "  return slice;\n"
      "}\n\n"
      "void " << nm << "_init_i(" << elem_type << "* begin)\n"
      "{\n";

    if (elem_cls & (CL_PRIMITIVE | CL_ENUM)) {
      be_global->impl_ << "  ACE_UNUSED_ARG(begin);\n";
    } else if (elem_cls & CL_ARRAY) {
      std::string indent = "  ";
      const NestedForLoops nfl("ACE_CDR::ULong", "i", arr, indent);
      be_global->impl_ <<
        indent << elem_type << "_init_i(begin" << nfl.index_ << ");\n";
    } else {
      be_global->impl_ <<
        "  std::uninitialized_fill_n(begin, " << total.str() << ", "
        << elem_type << "());\n";
    }

    be_global->impl_ <<
      "}\n\n"
      "void " << nm << "_fini_i(" << elem_type << "* begin)\n"
      "{\n";

    if (elem_cls & (CL_PRIMITIVE | CL_ENUM)) {
      be_global->impl_ << "  ACE_UNUSED_ARG(begin);\n";
    } else if (elem_cls & CL_ARRAY) {
      std::string indent = "  ";
      const NestedForLoops nfl("ACE_CDR::ULong", "i", arr, indent);
      be_global->impl_ <<
        indent << elem_type << "_fini_i(begin" << nfl.index_ << ");\n";
    } else {
      const std::string::size_type idx_last = elem_type.rfind("::");
      const std::string elem_last =
        (elem_cls & CL_STRING) ? "StringManager" :
        ((idx_last == std::string::npos) ? elem_type
         : elem_type.substr(idx_last + 2));
      be_global->impl_ <<
        "  for (int i = 0; i < " << total.str() << "; ++i) {\n"
        "    begin[i]."
        "~" << elem_last << "();\n"
        "  }\n";
    }

    be_global->impl_ <<
      "}\n\n"
      "void " << nm << "_free(" << nm << "_slice* slice)\n"
      "{\n"
      "  if (!slice) return;\n"
      "  " << nm << "_fini_i(slice" << zeros << ");\n"
      "  ACE_Allocator::instance()->free(slice);\n"
      "}\n\n" <<
      nm << "_slice* " << nm << "_dup(const " << nm << "_slice* slice)\n"
      "{\n"
      "  " << nm << "_slice* const arr = " << nm << "_alloc();\n"
      "  if (arr) " << nm << "_copy(arr, slice);\n"
      "  return arr;\n"
      "}\n\n"
      "void " << nm << "_copy(" << nm << "_slice* dst, const " << nm
      << "_slice* src)\n"
      "{\n"
      "  if (!src || !dst) return;\n";

    {
      std::string indent = "  ";
      const NestedForLoops nfl("ACE_CDR::ULong", "i", arr, indent);
      if (elem_cls & CL_ARRAY) {
        be_global->impl_ <<
          indent << elem_type << "_copy(dst" << nfl.index_ << ", src"
          << nfl.index_ << ");\n";
      } else {
        be_global->impl_ <<
          indent << "dst" << nfl.index_ << " = src" << nfl.index_ << ";\n";
      }
    }

    be_global->impl_ <<
      "}\n\n";

    be_global->lang_header_ <<
      "inline ACE_CDR::Boolean operator<<(ACE_OutputCDR &, const " << nm << "_forany&) { return true; }\n\n"
      "inline ACE_CDR::Boolean operator>>(ACE_InputCDR &, " << nm << "_forany&) { return true; }\n\n";
  }

gen_array_traits()

virtual void GeneratorBase::gen_array_traits ( UTL_ScopedName *  tdname, AST_Array *  arr  )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 806 of file langmap_generator.cpp.

References be_global, and scoped().

  {
    const std::string nm = scoped(tdname);
    const std::string zeros = array_zero_indices(arr);
    be_global->lang_header_ <<
      "TAO_BEGIN_VERSIONED_NAMESPACE_DECL\nnamespace TAO {\n"
      "template <>\n"
      "struct " << exporter() << "Array_Traits<" << nm << "_forany>\n"
      "{\n"
      "  static void free(" << nm << "_slice* slice)\n"
      "  {\n"
      "    " << nm << "_free(slice);\n"
      "  }\n\n"
      "  static " << nm << "_slice* dup(const " << nm << "_slice* slice)\n"
      "  {\n"
      "    return " << nm << "_dup(slice);\n"
      "  }\n\n"
      "  static void copy(" << nm << "_slice* dst, const " << nm
      << "_slice* src)\n"
      "  {\n"
      "    " << nm << "_copy(dst, src);\n"
      "  }\n\n"
      "  static " << nm << "_slice* alloc()\n"
      "  {\n"
      "    return " << nm << "_alloc();\n"
      "  }\n\n"
      "  static void zero(" << nm << "_slice* slice)\n"
      "  {\n"
      "    " << nm << "_fini_i(slice" << zeros << ");\n"
      "    " << nm << "_init_i(slice" << zeros << ");\n"
      "  }\n"
      "  static void construct(" << nm << "_slice* slice)\n"
      "  {\n"
      "    " << nm << "_init_i(slice" << zeros << ");\n"
      "  }\n"
      "  static void destroy(" << nm << "_slice* slice)\n"
      "  {\n"
      "    " << nm << "_fini_i(slice" << zeros << ");\n"
      "  }\n"
      "};\n}\nTAO_END_VERSIONED_NAMESPACE_DECL\n\n";
  }

gen_array_typedef()

virtual void GeneratorBase::gen_array_typedef ( const char *  nm, AST_Type *  base  )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 848 of file langmap_generator.cpp.

References be_global.

  {
    be_global->lang_header_ <<
      "typedef " << map_type(base) << "_var " << nm << "_var;\n" <<
      "typedef " << map_type(base) << "_slice " << nm << "_slice;\n" <<
      "typedef " << map_type(base) << "_forany " << nm << "_forany;\n\n" <<
      "inline " << nm << "_slice *" << nm << "_alloc() { return " << map_type(base) << "_alloc(); }\n" <<
      "inline " << nm << "_slice* " << nm << "_dup(" << nm << "_slice *a) { return " << map_type(base) << "_dup(a); }\n" <<
      "inline void " << nm << "_copy(" << nm << "_slice* to, const " << nm << "_slice* from) { " << map_type(base) << "_copy(to, from); }\n" <<
      "inline void " << nm << "_free(" << nm << "_slice *a) { " << map_type(base) << "_free(a); }\n";
  }

gen_sequence()

virtual void GeneratorBase::gen_sequence ( UTL_ScopedName *  tdname, AST_Sequence *  seq  )

pure virtual

Implemented in Cxx11Generator, SafetyProfileGenerator, and FaceGenerator.

gen_simple_out()

virtual void GeneratorBase::gen_simple_out ( const char *  nm )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 172 of file langmap_generator.cpp.

References be_global.

  {
    be_global->lang_header_ <<
      "typedef " << nm << "& " << nm << "_out;\n";
  }

gen_struct()

virtual bool GeneratorBase::gen_struct ( AST_Structure *  s, UTL_ScopedName *  name, const std::vector< AST_Field *> &  fields, AST_Type::SIZE_TYPE  size, const char *  x  )

pure virtual

Implemented in Cxx11Generator, SafetyProfileGenerator, and FaceGenerator.

gen_typedef_varout()

virtual void GeneratorBase::gen_typedef_varout ( const char *  nm, AST_Type *  base  )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 860 of file langmap_generator.cpp.

References be_global, AstTypeClassification::CL_STRING, AstTypeClassification::CL_WIDE, and AstTypeClassification::classify().

  {
    const Classification cls = classify(base);
    if (cls & CL_STRING) {
      const Helper var = (cls & CL_WIDE) ? HLP_WSTR_VAR : HLP_STR_VAR,
        out = (cls & CL_WIDE) ? HLP_WSTR_OUT : HLP_STR_OUT;
      be_global->lang_header_ <<
        "typedef " << helpers_[var] << ' ' << nm << "_var;\n"
        "typedef " << helpers_[out] << ' ' << nm << "_out;\n";
    } else {
      be_global->lang_header_ <<
        "typedef " << generator_->map_type(base) << "_out " << nm << "_out;\n";
    }
  }

gen_union()

virtual bool GeneratorBase::gen_union ( AST_Union *  u, UTL_ScopedName *  name, const std::vector< AST_UnionBranch *> &  branches, AST_Type *  discriminator  )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 548 of file langmap_generator.cpp.

References be_global, generateSwitchForUnion(), and scoped().

  {
    const ScopedNamespaceGuard namespaces(name, be_global->lang_header_);
    const char* const nm = name->last_component()->get_string();
    struct_decls(name, u->size_type(), "class");
    be_global->lang_header_ <<
      "\n"
      "class " << exporter() << nm << "\n"
      "{\n"
      " public:\n"
      "  typedef " << nm << "_var _var_type;\n"
      "  typedef " << nm << "_out _out_type;\n"
      "  " << nm << "();\n"
      "  " << nm << "(const " << nm << "&);\n"
      "  ~" << nm << "() { _reset(); };\n"
      "  " << nm << "& operator=(const " << nm << "&);\n"
      "  void _d(" << scoped(discriminator->name()) << " d) { _discriminator = d; }\n"
      "  " << scoped(discriminator->name()) << " _d() const { return _discriminator; }\n";

    std::for_each (branches.begin(), branches.end(), GenerateUnionAccessors(u, discriminator));

    if (needsDefault(branches, discriminator)) {
      be_global->lang_header_ <<
        "  void _default() {\n"
        "    _reset();\n"
        "    _discriminator = " << generateDefaultValue(u) << ";\n"
        "  }\n";
    }

    be_global->lang_header_ <<
      "  bool operator==(const " << nm << "& rhs) const;\n"
      "  bool operator!=(const " << nm << "& rhs) const { return !(*this == rhs); }\n"
      "  OPENDDS_POOL_ALLOCATION_HOOKS\n";

    be_global->lang_header_ <<
      " private:\n"
      "  " << scoped(discriminator->name()) << " _discriminator;\n"
      "  union {\n";

    std::for_each (branches.begin(), branches.end(), generate_union_field);

    be_global->lang_header_ <<
      "  } _u;\n";

    be_global->lang_header_ <<
      "  void _reset();\n"
      "};\n\n";

    be_global->add_include("dds/DCPS/PoolAllocationBase.h", BE_GlobalData::STREAM_LANG_H);
    be_global->add_include("<ace/CDR_Stream.h>", BE_GlobalData::STREAM_LANG_H);

    be_global->lang_header_ <<
      exporter() << "ACE_CDR::Boolean operator<< (ACE_OutputCDR& os, const " << nm << "& x);\n\n";
    be_global->lang_header_ <<
      exporter() << "ACE_CDR::Boolean operator>> (ACE_InputCDR& os, " << nm << "& x);\n\n";

    {
      const ScopedNamespaceGuard guard(name, be_global->impl_);

      be_global->impl_ <<
        nm << "::" << nm << "() { std::memset (this, 0, sizeof (" << nm << ")); }\n\n";

      be_global->impl_ <<
        nm << "::" << nm << "(const " << nm << "& other)\n"
        "{\n"
        "  this->_discriminator = other._discriminator;\n";
      generateSwitchForUnion(u, "this->_discriminator", generateCopyCtor, branches, discriminator, "", "", "", false, false);
      be_global->impl_ <<
        "}\n\n";

      be_global->impl_ <<
        nm << "& " << nm << "::operator=(const " << nm << "& other)\n"
        "{\n" <<
        "  if (this == &other) {\n"
        "    return *this;\n"
        "  }\n\n"
        "  _reset();\n"
        "  this->_discriminator = other._discriminator;\n";
      generateSwitchForUnion(u, "this->_discriminator", generateAssign, branches, discriminator, "", "", "", false, false);
      be_global->impl_ <<
        "  return *this;\n"
        "}\n\n";

      be_global->impl_ <<
        "bool " << nm << "::operator==(const " << nm << "& rhs) const\n"
        "{\n"
        "  if (this->_discriminator != rhs._discriminator) return false;\n";
      if (generateSwitchForUnion(u, "this->_discriminator", generateEqual, branches, discriminator, "", "", "", false, false)) {
        be_global->impl_ <<
          "  return false;\n";
      }
      be_global->impl_ <<
        "}\n\n";

      be_global->impl_ <<
        "void " << nm << "::_reset()\n"
        "{\n";
      generateSwitchForUnion(u, "this->_discriminator", generateReset, branches, discriminator, "", "", "", false, false);
      be_global->impl_ <<
        "}\n\n";

      be_global->impl_ <<
        "ACE_CDR::Boolean operator<<(ACE_OutputCDR&, const " << nm << "&) { return true; }\n\n";
      be_global->impl_ <<
        "ACE_CDR::Boolean operator>>(ACE_InputCDR&, " << nm << "&) { return true; }\n\n";
    }

    gen_typecode(name);
    return true;
  }

generate_union_field()

static void GeneratorBase::generate_union_field ( AST_UnionBranch *  branch )

inlinestatic

Definition at line 412 of file langmap_generator.cpp.

References be_global, AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_FIXED, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::CL_UNION, AstTypeClassification::CL_WIDE, AstTypeClassification::classify(), and AstTypeClassification::resolveActualType().

  {
    AST_Type* field_type = branch->field_type();
    AST_Type* actual_field_type = resolveActualType(field_type);
    const Classification cls = classify(actual_field_type);
    const std::string lang_field_type = generator_->map_type(field_type);
    if (cls & (CL_PRIMITIVE | CL_ENUM)) {
      be_global->lang_header_ <<
        "    " << lang_field_type << ' ' << branch->local_name()->get_string() << ";\n";
    } else if (cls & CL_STRING) {
      const AST_PredefinedType::PredefinedType chartype = (cls & CL_WIDE)
        ? AST_PredefinedType::PT_wchar : AST_PredefinedType::PT_char;
      be_global->lang_header_ <<
        "    " << primtype_[chartype] << "* " << branch->local_name()->get_string() << ";\n";
    } else if (cls & CL_ARRAY) {
      be_global->lang_header_ <<
        "    " << lang_field_type << "_slice* " << branch->local_name()->get_string() << ";\n";
    } else if (cls & (CL_STRUCTURE | CL_UNION | CL_SEQUENCE | CL_FIXED)) {
      be_global->lang_header_ <<
        "    " << lang_field_type << "* " << branch->local_name()->get_string() << ";\n";
    } else {
      std::cerr << "Unsupported type for union element\n";
    }
  }

generateAssign()

static std::string GeneratorBase::generateAssign ( const std::string &  , AST_Decl *  , const std::string &  name, AST_Type *  field_type, const std::string &  , bool  , Intro &  , const std::string &    )

inlinestatic

Definition at line 464 of file langmap_generator.cpp.

References AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_FIXED, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::CL_UNION, AstTypeClassification::classify(), and AstTypeClassification::resolveActualType().

  {
    std::stringstream ss;
    AST_Type* actual_field_type = resolveActualType(field_type);
    const Classification cls = classify(actual_field_type);
    const std::string lang_field_type = generator_->map_type(field_type);
    if (cls & (CL_PRIMITIVE | CL_ENUM)) {
      ss <<
        "    this->_u." << name << " = other._u." << name << ";\n";
    } else if (cls & CL_STRING) {
      ss <<
        "    this->_u." << name << " = (other._u." << name << ") ? " << string_ns << "::string_dup(other._u." << name << ") : 0 ;\n";
    } else if (cls & CL_ARRAY) {
      ss <<
        "    this->_u." << name << " = (other._u." << name << ") ? " << lang_field_type << "_dup(other._u." << name << ") : 0 ;\n";
    } else if (cls & (CL_STRUCTURE | CL_UNION | CL_SEQUENCE | CL_FIXED)) {
      ss <<
        "    this->_u." << name << " = (other._u." << name << ") ? new " << lang_field_type << "(*other._u." << name << ") : 0;\n";
    } else {
      std::cerr << "Unsupported type for union element\n";
    }

    return ss.str();
  }

generateCopyCtor()

static std::string GeneratorBase::generateCopyCtor ( const std::string &  , AST_Decl *  , const std::string &  name, AST_Type *  field_type, const std::string &  , bool  , Intro &  , const std::string &    )

inlinestatic

Definition at line 437 of file langmap_generator.cpp.

References AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_FIXED, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::CL_UNION, AstTypeClassification::classify(), and AstTypeClassification::resolveActualType().

  {
    std::stringstream ss;
    AST_Type* actual_field_type = resolveActualType(field_type);
    const Classification cls = classify(actual_field_type);
    const std::string lang_field_type = generator_->map_type(field_type);
    if (cls & (CL_PRIMITIVE | CL_ENUM)) {
      ss <<
        "    this->_u." << name << " = other._u." << name << ";\n";
    } else if (cls & CL_STRING) {
      ss <<
        "    this->_u." << name << " = (other._u." << name << ") ? " << string_ns << "::string_dup(other._u." << name << ") : 0 ;\n";
    } else if (cls & CL_ARRAY) {
      ss <<
        "    this->_u." << name << " = (other._u." << name << ") ? " << lang_field_type << "_dup(other._u." << name << ") : 0 ;\n";
    } else if (cls & (CL_STRUCTURE | CL_UNION | CL_SEQUENCE | CL_FIXED)) {
      ss <<
        "    this->_u." << name << " = (other._u." << name << ") ? new " << lang_field_type << "(*other._u." << name << ") : 0;\n";
    } else {
      std::cerr << "Unsupported type for union element\n";
    }

    return ss.str();
  }

generateDefaultValue()

static std::string GeneratorBase::generateDefaultValue ( AST_Union *  the_union )

inlinestatic

Definition at line 204 of file langmap_generator.cpp.

References ACE_ERROR, ACE_TEXT(), be_global, Fields::begin(), LM_ERROR, be_util::misc_error_and_abort(), and scoped().

  {
    std::stringstream first_label;
    AST_Union::DefaultValue dv;
    if (the_union->default_value(dv) == -1) {
      ACE_ERROR((LM_ERROR,
        ACE_TEXT("(%P|%t) ERROR: generateDefaultValue::")
        ACE_TEXT(" computing default value failed\n")));
      return "";
    }

    switch (the_union->udisc_type ())
      {
#if OPENDDS_HAS_EXPLICIT_INTS
      case AST_Expression::EV_int8:
        first_label << signed(dv.u.char_val);
        break;
      case AST_Expression::EV_uint8:
        first_label << unsigned(dv.u.char_val);
        break;
#endif
      case AST_Expression::EV_short:
        first_label << dv.u.short_val;
        break;
      case AST_Expression::EV_ushort:
        first_label << dv.u.ushort_val;
        break;
      case AST_Expression::EV_long:
        first_label << dv.u.long_val;
        break;
      case AST_Expression::EV_ulong:
        first_label << dv.u.ulong_val;
        break;
      case AST_Expression::EV_char:
        first_label << (int)dv.u.char_val;
        break;
      case AST_Expression::EV_bool:
        first_label << (dv.u.bool_val == 0 ? "false" : "true");
        break;
      case AST_Expression::EV_enum:
        {
          AST_Enum* e = dynamic_cast<AST_Enum*>(the_union->disc_type());
          if (be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11 ||
              be_global->language_mapping() == BE_GlobalData::LANGMAP_FACE_CXX) {
            std::string prefix = scoped(e->name());
            if (be_global->language_mapping() == BE_GlobalData::LANGMAP_FACE_CXX) {
              size_t pos = prefix.rfind("::");
              if (pos == std::string::npos) {
                prefix = "";
              } else {
                prefix = prefix.substr(0, pos) + "::";
              }
            } else {
              prefix += "::";
            }
            first_label << prefix;
            UTL_ScopedName* default_name;
            if (dv.u.enum_val < static_cast<ACE_CDR::ULong>(e->member_count())) {
              default_name = e->value_to_name(dv.u.enum_val);
            } else {
              const Fields fields(the_union);
              AST_UnionBranch* ub = dynamic_cast<AST_UnionBranch*>(*(fields.begin()));
              AST_Expression::AST_ExprValue* ev = ub->label(0)->label_val()->ev();
              default_name = e->value_to_name(ev->u.eval);
            }
            first_label << default_name->last_component()->get_string();
          } else {
            first_label << scoped(e->value_to_name(dv.u.enum_val));
          }
          break;
        }
      case AST_Expression::EV_longlong:
        first_label << dv.u.longlong_val;
        break;
      case AST_Expression::EV_ulonglong:
        first_label << dv.u.ulonglong_val;
        break;
      default:
        be_util::misc_error_and_abort("Unhandled ExprType value in generateDefaultValue");
      }

    return first_label.str();
  }

generateEqual()

static std::string GeneratorBase::generateEqual ( const std::string &  , AST_Decl *  , const std::string &  name, AST_Type *  field_type, const std::string &  , bool  , Intro &  , const std::string &    )

inlinestatic

Definition at line 491 of file langmap_generator.cpp.

References AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_FIXED, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::CL_UNION, AstTypeClassification::classify(), and AstTypeClassification::resolveActualType().

  {
    std::stringstream ss;

    AST_Type* actual_field_type = resolveActualType(field_type);
    const Classification cls = classify(actual_field_type);
    if (cls & (CL_PRIMITIVE | CL_ENUM)) {
      ss <<
        "    return this->_u." << name << " == rhs._u." << name << ";\n";
    } else if (cls & CL_STRING) {
      ss <<
        "    return std::strcmp (this->_u." << name << ", rhs._u." << name << ") == 0 ;\n";
    } else if (cls & CL_ARRAY) {
      // TODO
      ss <<
        "    return false;\n";
    } else if (cls & (CL_STRUCTURE | CL_UNION | CL_SEQUENCE | CL_FIXED)) {
      ss <<
        "    return *this->_u." << name << " == *rhs._u." << name << ";\n";
    } else {
      std::cerr << "Unsupported type for union element\n";
    }

    return ss.str();
  }

generateReset()

static std::string GeneratorBase::generateReset ( const std::string &  , AST_Decl *  , const std::string &  name, AST_Type *  field_type, const std::string &  , bool  , Intro &  , const std::string &    )

inlinestatic

Definition at line 519 of file langmap_generator.cpp.

References AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_FIXED, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::CL_UNION, AstTypeClassification::classify(), and AstTypeClassification::resolveActualType().

  {
    std::stringstream ss;

    AST_Type* actual_field_type = resolveActualType(field_type);
    const Classification cls = classify(actual_field_type);
    if (cls & (CL_PRIMITIVE | CL_ENUM)) {
      // Do nothing.
    } else if (cls & CL_STRING) {
      ss <<
        "    " << string_ns << "::string_free(this->_u." << name << ");\n"
        "    this->_u." << name << " = 0;\n";
    } else if (cls & CL_ARRAY) {
      ss <<
        "    " << generator_->map_type(field_type) << "_free(this->_u." << name << ");\n"
        "    this->_u." << name << " = 0;\n";
    } else if (cls & (CL_STRUCTURE | CL_UNION | CL_SEQUENCE | CL_FIXED)) {
      ss <<
        "    delete this->_u." << name << ";\n"
        "    this->_u." << name << " = 0;\n";
    } else {
      std::cerr << "Unsupported type for union element\n";
    }

    return ss.str();
  }

hasDefaultLabel()

static bool GeneratorBase::hasDefaultLabel ( const std::vector< AST_UnionBranch *> &  branches )

inlinestatic

Definition at line 378 of file langmap_generator.cpp.

  {
    for (std::vector<AST_UnionBranch*>::const_iterator pos = branches.begin(), limit = branches.end();
         pos != limit;
         ++pos) {
      AST_UnionBranch* branch = *pos;
      for (unsigned long j = 0; j < branch->label_list_length(); ++j) {
        AST_UnionLabel* label = branch->label(j);
        if (label->label_kind() == AST_UnionLabel::UL_default) {
          return true;
        }
      }
    }
    return false;
  }

init()

virtual void GeneratorBase::init ( )

pure virtual

Implemented in Cxx11Generator, SafetyProfileGenerator, and FaceGenerator.

map_type() [1/3]

std::string GeneratorBase::map_type ( AST_Type *  type )

inline

Definition at line 99 of file langmap_generator.cpp.

References AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_FIXED, AstTypeClassification::CL_INTERFACE, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::CL_UNION, AstTypeClassification::CL_WIDE, AstTypeClassification::classify(), AstTypeClassification::resolveActualType(), and scoped().

  {
    if (dynamic_cast<AST_Typedef*>(type)) {
      return scoped(type->name());
    }
    const Classification cls = classify(type);
    if (cls & CL_PRIMITIVE) {
      AST_Type* actual = resolveActualType(type);
      return primtype_[dynamic_cast<AST_PredefinedType*>(actual)->pt()];
    }
    if (cls & CL_STRING) {
      const AST_PredefinedType::PredefinedType chartype = (cls & CL_WIDE)
        ? AST_PredefinedType::PT_wchar : AST_PredefinedType::PT_char;
      return map_type_string(chartype, false);
    }
    if (cls & (CL_STRUCTURE | CL_UNION | CL_SEQUENCE | CL_ARRAY | CL_ENUM | CL_FIXED)) {
      return scoped(type->name());
    }
    if (cls & CL_INTERFACE) {
      return scoped(type->name()) + "_var";
    }
    return "<<unknown>>";
  }

map_type() [2/3]

std::string GeneratorBase::map_type ( AST_Field *  field )

inline

Definition at line 123 of file langmap_generator.cpp.

References FieldInfo::as_base_, FieldInfo::type_, and FieldInfo::type_name_.

  {
    FieldInfo af(*field);
    return (af.type_->anonymous() && af.as_base_) ? af.type_name_ : map_type(af.type_);
  }

map_type() [3/3]

std::string GeneratorBase::map_type ( AST_Expression::ExprType  type )

inline

Definition at line 134 of file langmap_generator.cpp.

References be_global, and be_util::misc_error_and_abort().

  {
    AST_PredefinedType::PredefinedType pt = AST_PredefinedType::PT_void;
    switch (type) {
#if OPENDDS_HAS_EXPLICIT_INTS
    case AST_Expression::EV_int8: pt = AST_PredefinedType::PT_int8; break;
    case AST_Expression::EV_uint8: pt = AST_PredefinedType::PT_uint8; break;
#endif
    case AST_Expression::EV_short: pt = AST_PredefinedType::PT_short; break;
    case AST_Expression::EV_ushort: pt = AST_PredefinedType::PT_ushort; break;
    case AST_Expression::EV_long: pt = AST_PredefinedType::PT_long; break;
    case AST_Expression::EV_ulong: pt = AST_PredefinedType::PT_ulong; break;
    case AST_Expression::EV_longlong: pt = AST_PredefinedType::PT_longlong; break;
    case AST_Expression::EV_ulonglong: pt = AST_PredefinedType::PT_ulonglong; break;
    case AST_Expression::EV_float: pt = AST_PredefinedType::PT_float; break;
    case AST_Expression::EV_double: pt = AST_PredefinedType::PT_double; break;
    case AST_Expression::EV_longdouble: pt = AST_PredefinedType::PT_longdouble; break;
    case AST_Expression::EV_char: pt = AST_PredefinedType::PT_char; break;
    case AST_Expression::EV_wchar: pt = AST_PredefinedType::PT_wchar; break;
    case AST_Expression::EV_octet: pt = AST_PredefinedType::PT_octet; break;
    case AST_Expression::EV_bool: pt = AST_PredefinedType::PT_boolean; break;
    case AST_Expression::EV_string: pt = AST_PredefinedType::PT_char; break;
    case AST_Expression::EV_wstring: pt = AST_PredefinedType::PT_wchar; break;
#ifdef ACE_HAS_CDR_FIXED
    case AST_Expression::EV_fixed:
      be_global->add_include("FACE/Fixed.h", BE_GlobalData::STREAM_LANG_H);
      return helpers_[HLP_FIXED_CONSTANT];
#endif
    default:
      be_util::misc_error_and_abort("Unhandled ExprType value in map_type");
    }

    if (type == AST_Expression::EV_string || type == AST_Expression::EV_wstring)
      return map_type_string(pt, true);

    return primtype_[pt];
  }

map_type_string()

virtual std::string GeneratorBase::map_type_string ( AST_PredefinedType::PredefinedType  chartype, bool  constant  )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 129 of file langmap_generator.cpp.

  {
    return primtype_[chartype] + '*' + (constant ? " const" : "");
  }

needsDefault()

static bool GeneratorBase::needsDefault ( const std::vector< AST_UnionBranch *> &  branches, AST_Type *  discriminator  )

inlinestatic

Definition at line 407 of file langmap_generator.cpp.

References needSyntheticDefault().

  {
    return !hasDefaultLabel(branches) && needSyntheticDefault(discriminator, countLabels(branches));
  }

scoped_enum()

virtual bool GeneratorBase::scoped_enum ( )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 178 of file langmap_generator.cpp.

{ return false; }

struct_decls()

virtual void GeneratorBase::struct_decls ( UTL_ScopedName *  name, AST_Type::SIZE_TYPE  size, const char *  struct_or_class = "struct"  )

inlinevirtual

Reimplemented in Cxx11Generator.

Definition at line 181 of file langmap_generator.cpp.

References be_global.

  {
    be_global->add_include("<tao/VarOut_T.h>", BE_GlobalData::STREAM_LANG_H);
    const char* const nm = name->last_component()->get_string();
    be_global->lang_header_ <<
      struct_or_class << ' ' << nm << ";\n";
    switch (size) {
    case AST_Type::SIZE_UNKNOWN:
      be_global->lang_header_ << "/* Unknown size */\n";
      break;
    case AST_Type::FIXED:
      be_global->lang_header_ <<
        "typedef " << helpers_[HLP_FIX_VAR] << '<' << nm << "> " << nm << "_var;\n" <<
        "typedef " << nm << "& " << nm << "_out;\n";
      break;
    case AST_Type::VARIABLE:
      be_global->lang_header_ <<
        "typedef " << helpers_[HLP_VAR_VAR] << '<' << nm << "> " << nm << "_var;\n" <<
        "typedef " << helpers_[HLP_OUT] << '<' << nm << "> " << nm << "_out;\n";
      break;
    }
  }

---

The documentation for this struct was generated from the following file:

• langmap_generator.cpp