void ConvType::write_cpp_decl( StreamSepMaker<Stream> &on ) { on << "struct " << cpp_name() << " : public Model {"; on.nsp += 4; // constructors on << cpp_name() << "( char *__ptr, Model *__par, char __bof ) : __ptr( __ptr ), __par( __par ), __bof( __bof ) {"; on << "}"; // attributes for( const ConvType::Attribute &attr : attributes ) { if ( ConvType *t = attr.type ) { on << t->cpp_name() << " " << attr.name << "() {"; on << " return "<< t->cpp_name() << "( __ptr, __par, __bof );"; on << "}"; } } // size and alig Past s = base_size, a = base_alig, p = new Ast_Symbol( "__ptr" ), b = new Ast_Symbol( "__bof" ); on << "int __size() const {"; on << " return " << s << ";"; on << "}"; on << "int __alig() const {"; on << " return " << a << ";"; on << "}"; on << "char *__ptr;"; on << "Model *__par;"; on << "char __bof;"; on.nsp -= 4; on << "};"; }
void inl_gen::generate(const mfast::aggregate_view_info& info) { std::string ns_prefix; std::string my_name = cpp_name(info.name_); if (this->cpp_ns_ != info.instruction_->cpp_ns()) { ns_prefix = info.instruction_->cpp_ns(); ns_prefix += "::"; } out_ << "inline " << my_name << "::"<< my_name << "(const " << ns_prefix << cpp_name(info.instruction_->name()) << "_cref& ref)\n" << " : ref_(ref)\n" << "{\n" << "}\n\n" << "inline mfast::view_iterator " << my_name << "::begin() const\n" << "{\n" << " return mfast::view_iterator(ref_, info_.data_.begin(), info_.max_depth_);\n" << "}\n\n" << "inline mfast::view_iterator " << my_name << "::end() const\n" << "{\n" << " return mfast::view_iterator(info_.data_.end()-1);\n" << "}\n\n" << "template <typename FieldAccessor>\n" << "inline void " << my_name << "::accept_accessor(FieldAccessor& accessor) const\n" << "{\n" << " BOOST_FOREACH(mfast::field_cref f, *this)\n" << " {\n" << " if (FieldAccessor::visit_absent || f.present())" << " f.accept_accessor(accessor);\n" << " }\n" << "}\n"; }
void Oni_Model_attachObjectToBone(Oni_ModelPtr obj, char* name, Oni_ModelPtr obj2){ Oni::Model* model = (Oni::Model*)(obj); Oni::Model* otherModel = (Oni::Model*)(obj2); std::string cpp_name(name); model->attachObjectToBone(cpp_name, otherModel); }
void cpp_gen::visit(const mfast::group_field_instruction* inst, void*) { std::string name( cpp_name( inst ) ); std::size_t index = inst->field_index(); add_to_instruction_list(name); prefixes_.push_back(name); if ( !contains_only_templateRef(inst) ) { subinstructions_list_.resize(subinstructions_list_.size()+1); traverse(inst, ""); } std::string subinstruction_arg = get_subinstructions(inst); out_ << "const static mfast::group_field_instruction\n" << prefix_string() << name << "_instruction(\n" << " "<< index << ",\n" << " " << get_presence(inst) << ",\n" << " " << inst->id() << ", // id\n" << " \"" << inst->name() << "\", // name\n" << " \"" << inst->ns() << "\", // ns\n" << " \"" << inst->dictionary() << "\", // dictionary\n" << subinstruction_arg << " \"" << inst->typeref_name() << "\", // typeRef name \n" << " \"" << inst->typeref_ns() << "\"); // typeRef ns \n\n"; }
void inl_gen::traverse(const mfast::group_field_instruction* inst, const char* name_suffix) { std::string saved_mref_scope = mref_scope_.str(); mref_scope_ << cpp_name(inst) << name_suffix << "_mref::"; codegen_base::traverse(inst, name_suffix); reset_scope(mref_scope_, saved_mref_scope); }
void cpp_gen::visit(const mfast::decimal_field_instruction* inst, void*) { std::string name( cpp_name( inst ) ); if (inst->mantissa_instruction() ) { // it has a separate mantissa instruction std::string mantisa_name(name); mantisa_name += "_mantissa"; std::string context = gen_op_context(mantisa_name.c_str(), inst->mantissa_instruction()->op_context()); out_ << "static mantissa_field_instruction\n" << prefix_string() << mantisa_name << "_instruction(\n" << " " << get_operator_name(inst->mantissa_instruction()) << ",\n" << " "<< context << ", // mantissa opContext\n" << " int_value_storage<int64_t>(" << get_initial_value<int64_t>(inst->mantissa_instruction()->initial_value(), "LL") << "));// mantissa inital value\n\n"; } gen_field(inst, gen_op_context(inst->name(), inst->op_context()), "decimal"); if ( inst->mantissa_instruction() ) { out_ << " &" << prefix_string() << name << "_mantissa_instruction,\n"; } const mfast::value_storage& init_value = inst->initial_value(); out_ << " decimal_value_storage("; if (!init_value.is_empty()) out_ << init_value.of_decimal.mantissa_ << "LL, " << static_cast<int> (init_value.of_decimal.exponent_); out_ << ")); // initial_value\n\n"; }
void cpp_gen::visit(const mfast::sequence_field_instruction* inst, void*) { std::string name( cpp_name( inst ) ); std::size_t index = inst->field_index(); add_to_instruction_list(name); prefixes_.push_back(name); if (inst->length_instruction()) { std::string context = gen_op_context(inst->length_instruction()->name(), inst->length_instruction()->op_context()); // length out_ << "static uint32_field_instruction\n" << prefix_string() << name << "_length_instruction(\n" << " 0," << " " << get_operator_name(inst->length_instruction()) << ",\n" << " " << get_presence(inst->length_instruction()) << ",\n" << " " << inst->length_instruction()->id() << ", // id\n" << " \""<< inst->length_instruction()->name() << "\", // name\n" << " \""<< inst->length_instruction()->ns() << "\", // ns\n" << " "<< context << ", // opContext\n" << " int_value_storage<uint32_t>("; if (!inst->length_instruction()->initial_value().is_empty()) out_ << inst->length_instruction()->initial_value().get<uint32_t>() << "U"; out_ << ")); // initial_value\n\n"; } if ( !contains_only_templateRef(inst) ) { subinstructions_list_.resize(subinstructions_list_.size()+1); traverse(inst, "_element"); } std::string lengthInstruction; if (inst->length_instruction()) { std::stringstream strm; strm << "&" << prefix_string() << name << "_length_instruction"; lengthInstruction = strm.str(); } std::string subinstruction_arg = get_subinstructions(inst); out_ << "const static mfast::sequence_field_instruction\n" << prefix_string() << name << "_instruction(\n" << " "<< index << ",\n" << " " << get_presence(inst) << ",\n" << " " << inst->id() << ", // id\n" << " \"" << inst->name() << "\", // name\n" << " \"" << inst->ns() << "\", // ns\n" << " \"" << inst->dictionary() << "\", // dictionary\n" << subinstruction_arg << " "<< lengthInstruction << ", // length\n" << " \"" << inst->typeref_name() << "\", // typeRef name \n" << " \"" << inst->typeref_ns() << "\"); // typeRef ns \n\n"; }
Oni_Animation_TrackPtr Oni_Animation_getAnimationTrack(Oni_AnimationPtr obj, char* name){ Oni::Animation* animation = (Oni::Animation*)(obj); std::string cpp_name(name); Oni::AnimationTrack* track = animation->getAnimationTrack(cpp_name); Oni_Animation_TrackPtr ptr_track = (Oni_Animation_TrackPtr)track; return ptr_track; }
Oni_Animation_BonePtr Oni_Animation_getBone(Oni_AnimationPtr obj, char* name){ Oni::Animation* animation = (Oni::Animation*)(obj); std::string cpp_name(name); Oni::AnimationBone* bone = animation->getBone(cpp_name); Oni_Animation_BonePtr ptr_bone = (Oni_Animation_BonePtr)bone; return ptr_bone; }
void inl_gen::gen_primitive (const char* cpp_type, const mfast::field_instruction* inst, void* pIndex) { std::string name (cpp_name(inst)); std::stringstream cref_type_name; cref_type_name << "mfast::" << cpp_type << "_cref"; std::stringstream mref_type_name; mref_type_name << "mfast::" << cpp_type << "_mref"; gen_accessors(inst, name, cref_type_name.str(), mref_type_name.str(), pIndex); }
void Oni_Light_initialize(Oni_LightPtr obj, Ogre_WindowPtr obj2, char* name, Ogre_NodePtr parent){ Oni::Light* light = (Oni::Light*)(obj); GameApplication* game = (GameApplication*)obj2; std::string cpp_name(name); Ogre::Node* parentNode = (Ogre::Node*)(parent); light->initialize(game->getSceneMgr(), cpp_name, parentNode); }
void Oni_Model_initialize(Oni_ModelPtr obj, Ogre_WindowPtr obj2, char* name, char* filename, Ogre_NodePtr parent){ Oni::Model* model = (Oni::Model*)(obj); GameApplication* game = (GameApplication*)obj2; std::string cpp_name(name); std::string cpp_filename(filename); Ogre::Node* parentNode = (Ogre::Node*)(parent); model->initialize(game->getSceneMgr(), cpp_name, cpp_filename, parentNode); }
void cpp_gen::gen_int_vector(const char* cpp_type, const mfast::vector_field_instruction_base* inst) { std::string name( cpp_name( inst ) ); std::size_t index = inst->field_index(); // std::string context = gen_op_context(inst->name(), inst->op_context()); out_ << "const static " << cpp_type << "_field_instruction\n" << prefix_string() << name << "_instruction(\n" << " " << index << ",\n" << " " << get_presence(inst) << ",\n" << " " << inst->id() << ", // id\n" << " \""<< inst->name() << "\", // name\n" << " \""<< inst->ns() << "\"); // ns\n"; add_to_instruction_list(name); }
void cpp_gen::visit(const mfast::template_instruction* inst, void*) { if (inst->subinstructions_count() == 0) return; std::string name( cpp_name( inst ) ); prefixes_.push_back(name); subinstructions_list_.resize(subinstructions_list_.size()+1); out_ << "const " << name << "::instruction_type*\n" << name << "::instruction()\n" << "{\n"; traverse(inst); output_subinstructions(); prefixes_.pop_back(); template_instructions_ << " " << name << "::instruction(),\n"; out_ << " const static " << name << "::instruction_type the_instruction(\n" << " " << inst->id() << ", // id\n" << " \"" << inst->name() << "\", // name\n" << " \""<< inst->ns() << "\", // ns\n" << " \""<< inst->template_ns() << "\", // templateNs\n" << " \""<< inst->dictionary() << "\", // dictionary\n" << " "<< name << "__subinstructions,\n" << " "<< inst->subinstructions_count() << ", // num_fields\n" << " " << inst->has_reset_attribute() << ", // reset\n" << " \"" << inst->typeref_name() << "\", // typeRef name \n" << " \"" << inst->typeref_ns() << "\"); // typeRef ns \n\n" << " return &the_instruction;\n" << "}\n\n"; }
codet cpp_typecheckt::cpp_constructor( const source_locationt &source_location, const exprt &object, const exprt::operandst &operands) { exprt object_tc=object; typecheck_expr(object_tc); elaborate_class_template(object_tc.type()); typet tmp_type(object_tc.type()); follow_symbol(tmp_type); assert(!is_reference(tmp_type)); if(tmp_type.id()==ID_array) { // We allow only one operand and it must be tagged with '#array_ini'. // Note that the operand is an array that is used for copy-initialization. // In the general case, a program is not allow to use this form of // construct. This way of initializing an array is used internaly only. // The purpose of the tag #arra_ini is to rule out ill-formed // programs. if(!operands.empty() && !operands.front().get_bool("#array_ini")) { error().source_location=source_location; error() << "bad array initializer" << eom; throw 0; } assert(operands.empty() || operands.size()==1); if(operands.empty() && cpp_is_pod(tmp_type)) { codet nil; nil.make_nil(); return nil; } const exprt &size_expr= to_array_type(tmp_type).size(); if(size_expr.id()=="infinity") { // don't initialize codet nil; nil.make_nil(); return nil; } exprt tmp_size=size_expr; make_constant_index(tmp_size); mp_integer s; if(to_integer(tmp_size, s)) { error().source_location=source_location; error() << "array size `" << to_string(size_expr) << "' is not a constant" << eom; throw 0; } /*if(cpp_is_pod(tmp_type)) { code_expressiont new_code; exprt op_tc=operands.front(); typecheck_expr(op_tc); // Override constantness object_tc.type().set("#constant", false); object_tc.set("#lvalue", true); side_effect_exprt assign("assign"); assign.add_source_location()=source_location; assign.copy_to_operands(object_tc, op_tc); typecheck_side_effect_assignment(assign); new_code.expression()=assign; return new_code; } else*/ { codet new_code(ID_block); // for each element of the array, call the default constructor for(mp_integer i=0; i < s; ++i) { exprt::operandst tmp_operands; exprt constant=from_integer(i, index_type()); constant.add_source_location()=source_location; exprt index(ID_index); index.copy_to_operands(object); index.copy_to_operands(constant); index.add_source_location()=source_location; if(!operands.empty()) { exprt operand(ID_index); operand.copy_to_operands(operands.front()); operand.copy_to_operands(constant); operand.add_source_location()=source_location; tmp_operands.push_back(operand); } exprt i_code = cpp_constructor(source_location, index, tmp_operands); if(i_code.is_nil()) { new_code.is_nil(); break; } new_code.move_to_operands(i_code); } return new_code; } } else if(cpp_is_pod(tmp_type)) { code_expressiont new_code; exprt::operandst operands_tc=operands; for(exprt::operandst::iterator it=operands_tc.begin(); it!=operands_tc.end(); it++) { typecheck_expr(*it); add_implicit_dereference(*it); } if(operands_tc.empty()) { // a POD is NOT initialized new_code.make_nil(); } else if(operands_tc.size()==1) { // Override constantness object_tc.type().set(ID_C_constant, false); object_tc.set(ID_C_lvalue, true); side_effect_exprt assign(ID_assign); assign.add_source_location()=source_location; assign.copy_to_operands(object_tc, operands_tc.front()); typecheck_side_effect_assignment(assign); new_code.expression()=assign; } else { error().source_location=source_location; error() << "initialization of POD requires one argument, " "but got " << operands.size() << eom; throw 0; } return new_code; } else if(tmp_type.id()==ID_union) { assert(0); // Todo: union } else if(tmp_type.id()==ID_struct) { exprt::operandst operands_tc=operands; for(exprt::operandst::iterator it=operands_tc.begin(); it!=operands_tc.end(); it++) { typecheck_expr(*it); add_implicit_dereference(*it); } const struct_typet &struct_type= to_struct_type(tmp_type); // set most-derived bits codet block(ID_block); for(std::size_t i=0; i < struct_type.components().size(); i++) { const irept &component=struct_type.components()[i]; if(component.get(ID_base_name)!="@most_derived") continue; exprt member(ID_member, bool_typet()); member.set(ID_component_name, component.get(ID_name)); member.copy_to_operands(object_tc); member.add_source_location()=source_location; member.set(ID_C_lvalue, object_tc.get_bool(ID_C_lvalue)); exprt val=false_exprt(); if(!component.get_bool("from_base")) val=true_exprt(); side_effect_exprt assign(ID_assign); assign.add_source_location()=source_location; assign.move_to_operands(member, val); typecheck_side_effect_assignment(assign); code_expressiont code_exp; code_exp.expression()=assign; block.move_to_operands(code_exp); } // enter struct scope cpp_save_scopet save_scope(cpp_scopes); cpp_scopes.set_scope(struct_type.get(ID_name)); // find name of constructor const struct_typet::componentst &components= struct_type.components(); irep_idt constructor_name; for(struct_typet::componentst::const_iterator it=components.begin(); it!=components.end(); it++) { const typet &type=it->type(); if(!it->get_bool(ID_from_base) && type.id()==ID_code && type.find(ID_return_type).id()==ID_constructor) { constructor_name=it->get(ID_base_name); break; } } // there is always a constructor for non-PODs assert(constructor_name!=""); irept cpp_name(ID_cpp_name); cpp_name.get_sub().push_back(irept(ID_name)); cpp_name.get_sub().back().set(ID_identifier, constructor_name); cpp_name.get_sub().back().set(ID_C_source_location, source_location); side_effect_expr_function_callt function_call; function_call.add_source_location()=source_location; function_call.function().swap(static_cast<exprt&>(cpp_name)); function_call.arguments().reserve(operands_tc.size()); for(exprt::operandst::iterator it=operands_tc.begin(); it!=operands_tc.end(); it++) function_call.op1().copy_to_operands(*it); typecheck_side_effect_function_call(function_call); assert(function_call.get(ID_statement)==ID_temporary_object); exprt &initializer = static_cast<exprt &>(function_call.add(ID_initializer)); assert(initializer.id()==ID_code && initializer.get(ID_statement)==ID_expression); side_effect_expr_function_callt &func_ini= to_side_effect_expr_function_call(initializer.op0()); exprt &tmp_this=func_ini.arguments().front(); assert(tmp_this.id()==ID_address_of && tmp_this.op0().id()=="new_object"); exprt address_of(ID_address_of, typet(ID_pointer)); address_of.type().subtype()=object_tc.type(); address_of.copy_to_operands(object_tc); tmp_this.swap(address_of); if(block.operands().empty()) return to_code(initializer); else { block.move_to_operands(initializer); return block; } } else assert(false); codet nil; nil.make_nil(); return nil; }
void inl_gen::visit(const mfast::group_field_instruction* inst, void* pIndex) { std::string name (cpp_name(inst)); std::size_t index = pIndex == 0 ? 0 : *static_cast<std::size_t*>(pIndex); std::string cref_type_name = cref_scope_.str() + name + "_cref"; std::string mref_type_name = mref_scope_.str() + name + "_mref"; bool embed_only_dyn_tempateref = contains_only_templateref(inst); std::stringstream cref_strm; std::stringstream mref_strm; if (embed_only_dyn_tempateref) { cref_strm << "mfast::aggregate_cref((*this)[" << index << "])[0]"; mref_strm << "mfast::aggregate_mref((*this)[" << index << "])[0]"; } else { cref_strm << "(*this)[" << index << "]"; mref_strm << "(*this)[" << index << "]"; } if (pIndex) { out_ << "\ninline " << cref_type_name << "\n" << cref_scope_.str() << "get_" << name << "() const\n" << "{\n"; if (inst->optional()) out_ << " if (" << "(*this)[" << index << "].absent())\n" << " return " << cref_type_name << "(0, " << cref_type_name << "::instruction_cptr(0));\n"; out_ << " return static_cast<" << cref_type_name << ">(" << cref_strm.str() << ");\n" << "}\n\n" << "inline " << mref_type_name << "\n" << mref_scope_.str() << "set_" << name << "() const\n" << "{\n"; if (inst->optional()) out_ << " this->field_storage(" << index << ")->present(true);\n"; out_ << " return " << mref_type_name << "("<< mref_strm.str() << ");\n" << "}\n\n"; if (inst->optional()) { out_ << "inline\n" << "void\n" << mref_scope_.str() << "omit_" << name << "() const\n" << "{\n" << " (*this)[" << index << "].omit();\n" << "}\n\n"; } if (inst->ref_instruction()) { out_ << "inline void\n" << mref_scope_.str() << "link_" << name << "(const " << mref_type_name << "& ref) const\n" << "{\n" << " this->link_group_at(" << index << ", ref);\n" << "}\n\n" << "inline void\n" << mref_scope_.str() << "unlink_" << name << "() const\n" << "{\n" << " this->unlink_group_at(" << index << ");\n" << "}\n\n"; } } if (inst->ref_instruction() == 0 && !embed_only_dyn_tempateref) { out_ << "inline\n" << cref_type_name << "::"<< name << "_cref()\n" << " : base_type(0, 0)\n" << "{\n" << "}\n\n" << "template <typename T>" << "inline\n" << cref_type_name << "::" << name << "_cref(\n" << " typename boost::enable_if<boost::is_same<typename T::cref_type, " << name << "_cref>, const mfast::value_storage*>::type storage_array,\n" << " const T* instruction)\n" << " : base_type(storage_array, instruction)\n" << "{\n" << "}\n\n" << "inline\n" << cref_type_name << "::"<< name << "_cref(\n" << " const mfast::field_cref& other)\n" << " : base_type(other)\n" << "{\n" << "}\n\n" << "inline\n" << mref_type_name << "::"<< name << "_mref()\n" << " : base_type(0, 0, 0)\n" << "{\n" << "}\n\n" << "template <typename T>" << "inline\n" << mref_type_name << "::" << name << "_mref(\n" << " mfast::allocator* alloc,\n" << " typename boost::enable_if<boost::is_same<typename T::cref_type, " << name << "_cref>, mfast::value_storage*>::type storage_array,\n" << " const T* instruction)\n" << " : base_type(alloc, storage_array, instruction)\n" << "{\n" << "}\n\n" << "inline\n" << mref_type_name << "::"<< name << "_mref(\n" << " const mfast::field_mref_base& other)\n" << " : base_type(other)\n" << "{\n" << "}\n\n"; if (!pIndex) { out_ << "inline\n" << name << "::" << name << "(\n" << " mfast::allocator* alloc)\n" << " : base_type(alloc, instruction(), this->data())\n" << "{\n" << "}\n\n" << "inline\n" << name << "::" << name << "(\n" << " const " << name << "_cref& other,\n" << " mfast::allocator* alloc)\n" << " : base_type(alloc, instruction(), this->data(), other.field_storage(0))\n" << "{\n" << "}\n\n" << "inline "<< name << "::cref_type\n" << name << "::ref() const\n" << "{\n" << " return " << name << "::cref_type(my_storage_.of_group.content_, instruction());\n" << "}\n\n" << "inline "<< name << "::cref_type\n" << name << "::cref() const\n" << "{\n" << " return " << name << "::cref_type(my_storage_.of_group.content_, instruction());\n" << "}\n\n" << "inline "<< name << "::mref_type\n" << name << "::ref()\n" << "{\n" << " return " << name << "::mref_type(alloc_, my_storage_.of_group.content_, instruction());\n" << "}\n\n" << "inline "<< name << "::mref_type\n" << name << "::mref()\n" << "{\n" << " return " << name << "::mref_type(alloc_, my_storage_.of_group.content_, instruction());\n" << "}\n\n"; } traverse(inst, ""); } }
void inl_gen::visit(const mfast::enum_field_instruction* inst, void* pIndex) { std::string name (cpp_name(inst)); std::string cref_type_name = cref_scope_.str() + name + "_cref"; std::string mref_type_name = mref_scope_.str() + name + "_mref"; if (inst->ref_instruction() == 0) { out_ << "inline\n" << cref_type_name << "::"<< name << "_cref(\n" << " const mfast::value_storage* storage,\n" << " " << cref_type_name << "::instruction_cptr instruction)\n" << " : base_type(storage, instruction)\n" << "{\n" << "}\n\n" << "inline\n" << cref_type_name << "::"<< name << "_cref(\n" << " const mfast::field_cref& other)\n" << " : base_type(other)\n" << "{\n" << "}\n\n" << "inline\n" << mref_type_name << "::"<< name << "_mref(\n" << " mfast::allocator* alloc,\n" << " mfast::value_storage* storage,\n" << " " << mref_type_name << "::instruction_cptr instruction)\n" << " : base_type(alloc, storage, instruction)\n" << "{\n" << "}\n\n" << "inline\n" << mref_type_name << "::"<< name << "_mref(\n" << " const mfast::field_mref_base& other)\n" << " : base_type(other)\n" << "{\n" << "}\n\n" << "inline\n" << cref_type_name << "::element_type\n" << cref_type_name << "::value() const\n" << "{\n" << " return static_cast<" << name << "::element>(base_type::value());\n" << "}\n\n"; for (uint64_t i = 0; i < inst->num_elements_; ++i) { std::string element_name = cpp_name(inst->elements_[i]); out_ << "inline\n" << "bool " << cref_type_name << "::is_" << element_name << "() const\n" << "{\n" << " return this->value() == " << name << "::" << element_name << ";\n" << "}\n\n" << "inline\n" << "void " << mref_type_name << "::as_" << element_name << "() const\n" << "{\n" << " return this->as(" << name << "::" << element_name << ");\n" << "}\n\n"; } } gen_accessors(inst, name, cref_type_name, mref_type_name, pIndex); }
void inl_gen::visit(const mfast::template_instruction* inst, void*) { // if (inst->subinstructions().size() == 0) // return; std::string name (cpp_name(inst)); out_ << "inline\n" << name << "_cref::" << name << "_cref()\n" << " : base_type(0, 0)\n" << "{\n" << "}\n\n" << "template <typename T>" << "inline\n" << name << "_cref::" << name << "_cref(\n" << " typename boost::enable_if<boost::is_same<typename T::cref_type, " << name << "_cref>, const mfast::value_storage*>::type storage_array,\n" << " const T* instruction)\n" << " : base_type(storage_array, instruction)\n" << "{\n" << "}\n\n" << "inline\n" << name << "_cref::" << name << "_cref(\n" << " const mfast::message_cref& other)\n" << " : base_type(other)\n" << "{\n" << "}\n\n" << "inline\n" << name << "_cref::" << name << "_cref(\n" << " const mfast::field_cref& other)\n" << " : base_type(mfast::field_cref_core_access::storage_of(other)->of_group.content_,\n" << " static_cast<instruction_cptr>(other.instruction()))\n" << "{\n" << "}\n\n" << "inline\n" << name << "_mref::" << name << "_mref()\n" << " : base_type(0, 0, 0)\n" << "{\n" << "}\n\n" << "template <typename T>" << "inline\n" << name << "_mref::" << name << "_mref(\n" << " mfast::allocator* alloc,\n" << " typename boost::enable_if<boost::is_same<typename T::cref_type, " << name << "_cref>, mfast::value_storage*>::type storage_array,\n" << " const T* instruction)\n" << " : base_type(alloc, storage_array, instruction)\n" << "{\n" << "}\n\n" << "inline\n" << name << "_mref::" << name << "_mref(\n" << " const mfast::message_mref& other)\n" << " : base_type(other)\n" << "{\n" << "}\n\n" << "inline\n" << name << "_mref::" << name << "_mref(\n" << " const mfast::field_mref_base& other)\n" << " : base_type(other.allocator(),\n" << " mfast::field_mref_core_access::storage_of(other)->of_group.content_,\n" << " static_cast<instruction_cptr>(other.instruction()))\n" << "{\n" << "}\n\n" << "inline\n" << name << "::" << name << "(\n" << " mfast::allocator* alloc)\n" << " : base_type(alloc, instruction(), this->data())\n" << "{\n" << "}\n\n" << "inline\n" << name << "::" << name << "(\n" << " const " << name << "_cref& other,\n" << " mfast::allocator* alloc)\n" << " : base_type(alloc, instruction(), this->data(), other.field_storage(0))\n" << "{\n" << "}\n\n" << "inline "<< name << "::cref_type\n" << name << "::ref() const\n" << "{\n" << " return " << name << "::cref_type(my_storage_.of_group.content_, instruction());\n" << "}\n\n" << "inline "<< name << "::cref_type\n" << name << "::cref() const\n" << "{\n" << " return " << name << "::cref_type(my_storage_.of_group.content_, instruction());\n" << "}\n\n" << "inline "<< name << "::mref_type\n" << name << "::ref()\n" << "{\n" << " return " << name << "::mref_type(alloc_, my_storage_.of_group.content_, instruction());\n" << "}\n\n" << "inline "<< name << "::mref_type\n" << name << "::mref()\n" << "{\n" << " return " << name << "::mref_type(alloc_, my_storage_.of_group.content_, instruction());\n" << "}\n\n"; this->traverse(inst, ""); }
void inl_gen::visit(const mfast::sequence_field_instruction* inst, void* pIndex) { std::string name (cpp_name(inst)); std::string cref_type_name = cref_scope_.str() + name + "_cref"; std::string mref_type_name = mref_scope_.str() + name + "_mref"; gen_accessors(inst, name, cref_type_name, mref_type_name, pIndex); const mfast::field_instruction* element_instruction = get_element_instruction(inst); if (inst->ref_instruction() == 0 && element_instruction==0) { out_ << "inline\n" << cref_scope_.str() << name << "_element_cref::"<< name << "_element_cref(\n" << " const mfast::value_storage* storage,\n" << " " << cref_scope_.str() << name << "_element_cref::instruction_cptr instruction)\n" << " : base_type(storage, instruction)\n" << "{\n" << "}\n\n" << "inline\n" << mref_scope_.str() << name << "_element_mref::"<< name << "_element_mref(\n" << " mfast::allocator* alloc,\n" << " mfast::value_storage* storage,\n" << " " << mref_scope_.str() << name << "_element_mref::instruction_cptr instruction)\n" << " : base_type(alloc,storage, instruction)\n" << "{\n" << "}\n\n"; traverse(inst, "_element"); } if (pIndex == 0) { out_ << "inline\n" << name << "::" << name << "(\n" << " mfast::allocator* alloc)\n" << " : base_type(alloc, instruction(), 0)\n" << "{\n" << "}\n\n" << "inline\n" << name << "::" << name << "(\n" << " const " << name << "_cref& other,\n" << " mfast::allocator* alloc)\n" << " : base_type(reinterpret_cast<const mfast::sequence_cref&>(other), alloc)\n" << "{\n" << "}\n\n" << "inline "<< name << "::cref_type\n" << name << "::ref() const\n" << "{\n" << " return " << name << "::cref_type(&my_storage_, instruction());\n" << "}\n\n" << "inline "<< name << "::cref_type\n" << name << "::cref() const\n" << "{\n" << " return " << name << "::cref_type(&my_storage_, instruction());\n" << "}\n\n" << "inline "<< name << "::mref_type\n" << name << "::ref()\n" << "{\n" << " return " << name << "::mref_type(alloc_, &my_storage_, instruction());\n" << "}\n\n" << "inline "<< name << "::mref_type\n" << name << "::mref()\n" << "{\n" << " return " << name << "::mref_type(alloc_, &my_storage_, instruction());\n" << "}\n\n"; } }