dds_generator.cpp File Reference

#include "dds_generator.h"
#include "field_info.h"
#include <utl_identifier.h>

Include dependency graph for dds_generator.cpp:

Go to the source code of this file.

Functions
string	type_to_default_array (const std::string &indent, AST_Type *type, const string &name, bool is_anonymous, bool is_union, bool use_cxx11, Classification fld_cls)
string	type_to_default (const std::string &indent, AST_Type *type, const string &name, bool is_anonymous, bool is_union)
std::string	field_type_name (AST_Field *field, AST_Type *field_type)
AST_Type *	deepest_named_type (AST_Type *type)

Function Documentation

deepest_named_type()

AST_Type* deepest_named_type

(

AST_Type *

type

)

For the some situations, like a tag name, the type name we need is the deepest named type, not the actual type. This will be the name of the deepest typedef if it's an array or sequence, otherwise the name of the type.

Definition at line 442 of file dds_generator.cpp.

Referenced by field_type_name(), marshal_generator::gen_enum(), marshal_generator::gen_field_getValueFromSerialized(), metaclass_generator::gen_typedef(), gen_union_branch(), generate_anon_fields(), Intro::insert(), and type_to_default_array().

{
  AST_Type* consider = type;
  AST_Type* named_type = type;
  while (consider->node_type() == AST_Decl::NT_typedef) {
    named_type = consider;
    consider = dynamic_cast<AST_Typedef*>(named_type)->base_type();
  }
  return named_type;
}

field_type_name()

std::string field_type_name	(	AST_Field *	field,
		AST_Type *	field_type
	)

Definition at line 425 of file dds_generator.cpp.

References FieldInfo::as_base_, AstTypeClassification::CL_STRING, AstTypeClassification::classify(), deepest_named_type(), name, scoped(), FieldInfo::scoped_type_, string_type(), and FieldInfo::type_.

Referenced by marshal_generator::gen_field_getValueFromSerialized(), marshal_generator::gen_typedef(), gen_union_branch(), generateCaseBody(), and Intro::insert().

{
  if (!field_type) {
    field_type = field->field_type();
  }
  const Classification cls = classify(field_type);
  const std::string name = (cls & CL_STRING) ?
    string_type(cls) : scoped(deepest_named_type(field_type)->name());
  if (field) {
    FieldInfo af(*field);
    if (af.as_base_ && af.type_->anonymous()) {
      return af.scoped_type_;
    }
  }
  return name;
}

type_to_default()

string type_to_default	(	const std::string &	indent,
		AST_Type *	type,
		const string &	name,
		bool	is_anonymous,
		bool	is_union
	)

Definition at line 359 of file dds_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(), AstTypeClassification::resolveActualType(), scoped(), and type_to_default_array().

Referenced by bounded_arg(), marshal_generator::gen_enum(), marshal_generator::gen_struct(), marshal_generator::gen_typedef(), marshal_generator::gen_union(), marshal_generator::gen_union_default(), and generateCaseBody().

{
  AST_Type* actual_type = resolveActualType(type);
  Classification fld_cls = classify(actual_type);
  const bool use_cxx11 = be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11;
  string def_val;
  std::string pre = " = ";
  std::string post;
  if (is_union) {
    pre = "(";
    post = ")";
  }
  if (fld_cls & (CL_STRUCTURE | CL_UNION)) {
    return indent + "set_default(" + name + (is_union ? "()" : "") + ");\n";
  } else if (fld_cls & CL_ARRAY) {
    return type_to_default_array(
      indent, type, name, is_anonymous, is_union, use_cxx11, fld_cls);
  } else if (fld_cls & CL_ENUM) {
    // For now, simply return the first value of the enumeration.
    // Must be changed, if support for @default_literal is desired.
    AST_Enum* enu = dynamic_cast<AST_Enum*>(actual_type);
    UTL_ScopeActiveIterator i(enu, UTL_Scope::IK_decls);
    AST_EnumVal *item = dynamic_cast<AST_EnumVal*>(i.item());
    if (use_cxx11) {
      def_val = scoped(type->name()) + "::" + item->local_name()->get_string();
    } else {
      def_val = scoped(item->name());
    }
  } else if (fld_cls & CL_SEQUENCE) {
    string seq_resize_func = (use_cxx11) ? "resize" : "length";
    if (is_union) {
      return indent + "tmp." + seq_resize_func + "(0);\n"
        + indent + name + "(tmp);\n";
    } else {
      return indent + name + "." + seq_resize_func + "(0);\n";
    }
  } else if (fld_cls & CL_STRING) {
    def_val = (fld_cls & CL_WIDE) ? "L\"\"" : "\"\"";
    if (!use_cxx11 && (fld_cls & CL_WIDE)) def_val = "TAO::WString_Manager::s_traits::default_initializer()";
  } else if (fld_cls & (CL_PRIMITIVE | CL_FIXED)) {
    AST_PredefinedType* pt = dynamic_cast<AST_PredefinedType*>(actual_type);
    if (pt && (pt->pt() == AST_PredefinedType::PT_longdouble)) {
      if (use_cxx11) {
        def_val = "0.0L";
      } else {
        string temp_val = "ACE_CDR::LongDouble val = ACE_CDR_LONG_DOUBLE_INITIALIZER";
        if (is_union) {
          def_val = "val";
          return indent + temp_val + ";\n" +
            indent + name + pre + def_val + post + ";\n";
        } else {
          def_val = "ACE_CDR_LONG_DOUBLE_ASSIGNMENT(" + name + ", val)";
          return indent + "{\n"
            "  " + indent + temp_val + ";\n"
            "  " + indent + def_val + ";\n" +
            indent + "}\n";
        }
      }
    } else {
      def_val =  "0";
    }
  }
  return indent + name + pre + def_val + post + ";\n";
}

type_to_default_array()

string type_to_default_array	(	const std::string &	indent,
		AST_Type *	type,
		const string &	name,
		bool	is_anonymous,
		bool	is_union,
		bool	use_cxx11,
		Classification	fld_cls
	)

Definition at line 322 of file dds_generator.cpp.

References deepest_named_type(), dds_generator::get_tag_name(), name, and scoped().

Referenced by type_to_default().

{
  // TODO: Most of what's in here looks like it could be replaced with RefWrapper
  string val;
  string temp = name;
  if (temp.size() > 2 && temp.substr(temp.size() - 2, 2) == "()") {
    temp.erase(temp.size() - 2);
  }
  temp += "_temp";
  replace(temp.begin(), temp.end(), '.', '_');
  replace(temp.begin(), temp.end(), '[', '_');
  replace(temp.begin(), temp.end(), ']', '_');
  if (use_cxx11) {
    string n = scoped(deepest_named_type(type)->name());
    if (is_anonymous) {
      n = n.substr(0, n.rfind("::") + 2) + "AnonymousType_" + type->local_name()->get_string();
      n = (fld_cls == AST_Decl::NT_sequence) ? (n + "_seq") : n;
    }
    val += indent + "set_default(IDL::DistinctType<" + n + ", " + dds_generator::get_tag_name(n) + ">(" +
      (is_union ? "tmp" : name) + "));\n";
  } else {
    string n = scoped(type->name());
    if (is_anonymous) {
      n = n.substr(0, n.rfind("::") + 2) + "_" + type->local_name()->get_string();
      n = (fld_cls == AST_Decl::NT_sequence) ? (n + "_seq") : n;
    }
    val = indent + n + "_forany " + temp + "(const_cast<"
      + n + "_slice*>(" + (is_union ? "tmp": name) + "));\n";
    val += indent + "set_default(" + temp + ");\n";
  }
  if (is_union) {
    val += indent + name + "(tmp);\n";
  }
  return val;
}