metaclass_generator.cpp File Reference

#include "metaclass_generator.h"
#include "marshal_generator.h"
#include "field_info.h"
#include "be_extern.h"
#include "topic_keys.h"
#include <utl_identifier.h>
#include <cstddef>
#include <stdexcept>

Include dependency graph for metaclass_generator.cpp:

Go to the source code of this file.

Functions
void	generate_anon_fields (AST_Structure *node)
static std::string	gen_union_branch (const std::string &, AST_Decl *branch, const std::string &, AST_Type *br_type, const std::string &, bool, Intro &, const std::string &)

Function Documentation

gen_union_branch()

static std::string gen_union_branch ( const std::string &  , AST_Decl *  branch, const std::string &  , AST_Type *  br_type, const std::string &  , bool  , Intro &  , const std::string &    )

static

Definition at line 615 of file metaclass_generator.cpp.

References be_global, AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_SCALAR, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::classify(), deepest_named_type(), field_type_name(), dds_generator::get_tag_name(), name, dds_generator::scoped_helper(), and to_cxx_type().

Referenced by metaclass_generator::gen_union().

{
  const bool use_cxx11 = be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11;
  std::stringstream ss;
  const Classification br_cls = classify(br_type);
  ss <<
    "    if (is_mutable && !ser.read_parameter_id(member_id, field_size, must_understand)) {\n"
    "      return false;\n"
    "    }\n";
  if (br_cls & CL_STRING) {
    ss <<
      "    ACE_CDR::ULong len;\n"
      "    if (!(ser >> len && ser.skip(len))) return false;\n";
  } else if (br_cls & CL_SCALAR) {
    size_t sz = 0;
    to_cxx_type(br_type, sz);
    ss <<
      "    if (!ser.skip(1, " << sz << ")) return false;\n";
  } else {
    std::string pre, post;
    if (!use_cxx11 && (br_cls & CL_ARRAY)) {
      post = "_forany";
    } else if (use_cxx11 && (br_cls & (CL_ARRAY | CL_SEQUENCE))) {
      pre = "IDL::DistinctType<";
      post = ", " + dds_generator::get_tag_name(dds_generator::scoped_helper(deepest_named_type(br_type)->name(), "::")) + ">";
    }
    ss <<
      "    if (!gen_skip_over(ser, static_cast<" << pre
      << field_type_name(dynamic_cast<AST_Field*>(branch), br_type) << post <<
        "*>(0))) return false;\n";
  }

  ss <<
    "    return true;\n";
  return ss.str();
}

generate_anon_fields()

void generate_anon_fields

(

AST_Structure *

node

)

Definition at line 412 of file metaclass_generator.cpp.

References Function::addArg(), FieldInfo::arr_, array_element_count(), FieldInfo::as_act_, be_global, Fields::begin(), AstTypeClassification::CL_ARRAY, AstTypeClassification::CL_ENUM, AstTypeClassification::CL_PRIMITIVE, AstTypeClassification::CL_SEQUENCE, AstTypeClassification::CL_STRING, AstTypeClassification::CL_STRUCTURE, AstTypeClassification::classify(), deepest_named_type(), Fields::end(), Function::endArgs(), marshal_generator::generate_dheader_code(), dds_generator::get_tag_name(), FieldInfo::is_new(), FieldInfo::length_, name, FieldInfo::ptr_, AstTypeClassification::resolveActualType(), scoped(), dds_generator::scoped_helper(), FieldInfo::seq_, and to_cxx_type().

Referenced by metaclass_generator::gen_struct(), and metaclass_generator::gen_union().

{
  const Fields fields(node);
  FieldInfo::EleLenSet anonymous_seq_generated;
  for (Fields::Iterator i = fields.begin(); i != fields.end(); ++i) {
    AST_Field* const field = *i;
    if (field->field_type()->anonymous()) {
      FieldInfo af(*field);
      if (af.arr_ || (af.seq_ && af.is_new(anonymous_seq_generated))) {
        Function f("gen_skip_over", "bool");
        f.addArg("ser", "Serializer&");
        f.addArg("", af.ptr_);
        f.endArgs();

        AST_Type* elem;
        if (af.seq_ != 0) {
          elem = af.seq_->base_type();
        } else {
          elem = af.arr_->base_type();
        }
        be_global->impl_ <<
          "  const Encoding& encoding = ser.encoding();\n"
          "  ACE_UNUSED_ARG(encoding);\n";
        Classification elem_cls = classify(elem);
        const bool primitive = elem_cls & CL_PRIMITIVE;
        marshal_generator::generate_dheader_code(
          "    if (!ser.read_delimiter(total_size)) {\n"
          "      return false;\n"
          "    }\n", !primitive, true);

        std::string len;
        if (af.arr_) {
          std::ostringstream strstream;
          strstream << array_element_count(af.arr_);
          len = strstream.str();
        } else { // Sequence
          be_global->impl_ <<
            "  ACE_CDR::ULong length;\n"
            "  if (!(ser >> length)) return false;\n";
          len = "length";
        }
        const std::string cxx_elem = scoped(elem->name());
        AST_Type* elem_orig = elem;
        elem = resolveActualType(elem);
        elem_cls = classify(elem);

        if ((elem_cls & (CL_PRIMITIVE | CL_ENUM))) {
          // fixed-length sequence/array element -> skip all elements at once
          size_t sz = 0;
          to_cxx_type(af.as_act_, sz);
          be_global->impl_ <<
            "  return ser.skip(" << af.length_ << ", " << sz << ");\n";
        } else {
          be_global->impl_ <<
            "  for (ACE_CDR::ULong i = 0; i < " << len << "; ++i) {\n";
          if (elem_cls & CL_STRING) {
            be_global->impl_ <<
              "    ACE_CDR::ULong strlength;\n"
              "    if (!(ser >> strlength && ser.skip(strlength))) return false;\n";
          } else if (elem_cls & (CL_ARRAY | CL_SEQUENCE | CL_STRUCTURE)) {
            std::string pre, post;
            const bool use_cxx11 = be_global->language_mapping() == BE_GlobalData::LANGMAP_CXX11;
            if (!use_cxx11 && (elem_cls & CL_ARRAY)) {
              post = "_forany";
            } else if (use_cxx11 && (elem_cls & (CL_ARRAY | CL_SEQUENCE))) {
              pre = "IDL::DistinctType<";
              post = ", " + dds_generator::get_tag_name(dds_generator::scoped_helper(deepest_named_type(elem_orig)->name(), "_")) + ">";
            }
            be_global->impl_ <<
              "    if (!gen_skip_over(ser, static_cast<" << pre << cxx_elem << post
              << "*>(0))) return false;\n";
          }
          be_global->impl_ <<
            "  }\n"
            "  return true;\n";
        }

      }
    }
  }
}