From b71531b42b3325fd6079a7039aae8641262c8adf Mon Sep 17 00:00:00 2001 From: jai Date: Mon, 29 Jan 2007 21:15:18 +0000 Subject: branching/tagging --- modules/CIAO/CIDLC/AttributeHeaderEmitters.cpp | 196 + modules/CIAO/CIDLC/AttributeHeaderEmitters.hpp | 119 + modules/CIAO/CIDLC/AttributeSourceEmitters_T.hpp | 360 ++ modules/CIAO/CIDLC/CIDLC.mpc | 16 + modules/CIAO/CIDLC/CIDLC.mwc | 10 + modules/CIAO/CIDLC/Collectors.hpp | 280 ++ modules/CIAO/CIDLC/CompositionEmitter.cpp | 27 + modules/CIAO/CIDLC/CompositionEmitter.hpp | 26 + modules/CIAO/CIDLC/CorbaTypeNameEmitters.cpp | 2014 ++++++++++ modules/CIAO/CIDLC/CorbaTypeNameEmitters.hpp | 469 +++ modules/CIAO/CIDLC/CxxNamePrinter.cpp | 103 + modules/CIAO/CIDLC/CxxNamePrinter.hpp | 18 + modules/CIAO/CIDLC/DescriptorGenerator.cpp | 582 +++ modules/CIAO/CIDLC/DescriptorGenerator.hpp | 35 + modules/CIAO/CIDLC/EmitterBase.cpp | 11 + modules/CIAO/CIDLC/EmitterBase.hpp | 20 + modules/CIAO/CIDLC/EmitterContext.cpp | 45 + modules/CIAO/CIDLC/EmitterContext.hpp | 35 + modules/CIAO/CIDLC/ExecImplGenerator.cpp | 201 + modules/CIAO/CIDLC/ExecImplGenerator.hpp | 44 + modules/CIAO/CIDLC/ExecImplHeaderGenerator.cpp | 819 ++++ modules/CIAO/CIDLC/ExecImplHeaderGenerator.hpp | 43 + modules/CIAO/CIDLC/ExecImplSourceGenerator.cpp | 1136 ++++++ modules/CIAO/CIDLC/ExecImplSourceGenerator.hpp | 43 + modules/CIAO/CIDLC/ExecutorMappingGenerator.cpp | 2099 ++++++++++ modules/CIAO/CIDLC/ExecutorMappingGenerator.hpp | 32 + modules/CIAO/CIDLC/InterfaceEmitter.cpp | 26 + modules/CIAO/CIDLC/InterfaceEmitter.hpp | 30 + modules/CIAO/CIDLC/Literals.cpp | 81 + modules/CIAO/CIDLC/Literals.hpp | 58 + modules/CIAO/CIDLC/ModuleEmitter.cpp | 22 + modules/CIAO/CIDLC/ModuleEmitter.hpp | 24 + modules/CIAO/CIDLC/OperationHeaderEmitters.cpp | 264 ++ modules/CIAO/CIDLC/OperationHeaderEmitters.hpp | 151 + modules/CIAO/CIDLC/ParameterEmitter_T.hpp | 33 + modules/CIAO/CIDLC/README.html | 95 + modules/CIAO/CIDLC/RepositoryIdGenerator.cpp | 289 ++ modules/CIAO/CIDLC/RepositoryIdGenerator.hpp | 21 + modules/CIAO/CIDLC/ServantGenerator.cpp | 220 ++ modules/CIAO/CIDLC/ServantGenerator.hpp | 53 + modules/CIAO/CIDLC/ServantHeaderGenerator.cpp | 1783 +++++++++ modules/CIAO/CIDLC/ServantHeaderGenerator.hpp | 54 + modules/CIAO/CIDLC/ServantSourceGenerator.cpp | 4476 ++++++++++++++++++++++ modules/CIAO/CIDLC/ServantSourceGenerator.hpp | 53 + modules/CIAO/CIDLC/SizeTypeCalculator.cpp | 217 ++ modules/CIAO/CIDLC/SizeTypeCalculator.hpp | 21 + modules/CIAO/CIDLC/UnescapedNamePrinter.hpp | 23 + modules/CIAO/CIDLC/Upcase.hpp | 21 + modules/CIAO/CIDLC/UtilityTypeNameEmitters.cpp | 78 + modules/CIAO/CIDLC/UtilityTypeNameEmitters.hpp | 66 + modules/CIAO/CIDLC/Version | 1 + modules/CIAO/CIDLC/cidlc.cpp | 386 ++ 52 files changed, 17329 insertions(+) create mode 100644 modules/CIAO/CIDLC/AttributeHeaderEmitters.cpp create mode 100644 modules/CIAO/CIDLC/AttributeHeaderEmitters.hpp create mode 100644 modules/CIAO/CIDLC/AttributeSourceEmitters_T.hpp create mode 100644 modules/CIAO/CIDLC/CIDLC.mpc create mode 100644 modules/CIAO/CIDLC/CIDLC.mwc create mode 100644 modules/CIAO/CIDLC/Collectors.hpp create mode 100644 modules/CIAO/CIDLC/CompositionEmitter.cpp create mode 100644 modules/CIAO/CIDLC/CompositionEmitter.hpp create mode 100644 modules/CIAO/CIDLC/CorbaTypeNameEmitters.cpp create mode 100644 modules/CIAO/CIDLC/CorbaTypeNameEmitters.hpp create mode 100644 modules/CIAO/CIDLC/CxxNamePrinter.cpp create mode 100644 modules/CIAO/CIDLC/CxxNamePrinter.hpp create mode 100644 modules/CIAO/CIDLC/DescriptorGenerator.cpp create mode 100644 modules/CIAO/CIDLC/DescriptorGenerator.hpp create mode 100644 modules/CIAO/CIDLC/EmitterBase.cpp create mode 100644 modules/CIAO/CIDLC/EmitterBase.hpp create mode 100644 modules/CIAO/CIDLC/EmitterContext.cpp create mode 100644 modules/CIAO/CIDLC/EmitterContext.hpp create mode 100644 modules/CIAO/CIDLC/ExecImplGenerator.cpp create mode 100644 modules/CIAO/CIDLC/ExecImplGenerator.hpp create mode 100644 modules/CIAO/CIDLC/ExecImplHeaderGenerator.cpp create mode 100644 modules/CIAO/CIDLC/ExecImplHeaderGenerator.hpp create mode 100644 modules/CIAO/CIDLC/ExecImplSourceGenerator.cpp create mode 100644 modules/CIAO/CIDLC/ExecImplSourceGenerator.hpp create mode 100644 modules/CIAO/CIDLC/ExecutorMappingGenerator.cpp create mode 100644 modules/CIAO/CIDLC/ExecutorMappingGenerator.hpp create mode 100644 modules/CIAO/CIDLC/InterfaceEmitter.cpp create mode 100644 modules/CIAO/CIDLC/InterfaceEmitter.hpp create mode 100644 modules/CIAO/CIDLC/Literals.cpp create mode 100644 modules/CIAO/CIDLC/Literals.hpp create mode 100644 modules/CIAO/CIDLC/ModuleEmitter.cpp create mode 100644 modules/CIAO/CIDLC/ModuleEmitter.hpp create mode 100644 modules/CIAO/CIDLC/OperationHeaderEmitters.cpp create mode 100644 modules/CIAO/CIDLC/OperationHeaderEmitters.hpp create mode 100644 modules/CIAO/CIDLC/ParameterEmitter_T.hpp create mode 100644 modules/CIAO/CIDLC/README.html create mode 100644 modules/CIAO/CIDLC/RepositoryIdGenerator.cpp create mode 100644 modules/CIAO/CIDLC/RepositoryIdGenerator.hpp create mode 100644 modules/CIAO/CIDLC/ServantGenerator.cpp create mode 100644 modules/CIAO/CIDLC/ServantGenerator.hpp create mode 100644 modules/CIAO/CIDLC/ServantHeaderGenerator.cpp create mode 100644 modules/CIAO/CIDLC/ServantHeaderGenerator.hpp create mode 100644 modules/CIAO/CIDLC/ServantSourceGenerator.cpp create mode 100644 modules/CIAO/CIDLC/ServantSourceGenerator.hpp create mode 100644 modules/CIAO/CIDLC/SizeTypeCalculator.cpp create mode 100644 modules/CIAO/CIDLC/SizeTypeCalculator.hpp create mode 100644 modules/CIAO/CIDLC/UnescapedNamePrinter.hpp create mode 100644 modules/CIAO/CIDLC/Upcase.hpp create mode 100644 modules/CIAO/CIDLC/UtilityTypeNameEmitters.cpp create mode 100644 modules/CIAO/CIDLC/UtilityTypeNameEmitters.hpp create mode 100644 modules/CIAO/CIDLC/Version create mode 100644 modules/CIAO/CIDLC/cidlc.cpp (limited to 'modules/CIAO/CIDLC') diff --git a/modules/CIAO/CIDLC/AttributeHeaderEmitters.cpp b/modules/CIAO/CIDLC/AttributeHeaderEmitters.cpp new file mode 100644 index 00000000000..d5794a889f5 --- /dev/null +++ b/modules/CIAO/CIDLC/AttributeHeaderEmitters.cpp @@ -0,0 +1,196 @@ +// file : CIDLC/AttributeHeaderEmitters.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "AttributeHeaderEmitters.hpp" +#include "Literals.hpp" + +using namespace StringLiterals; + +WriteAttributeHeaderEmitter::WriteAttributeHeaderEmitter (Context& c) + : EmitterBase (c), + write_type_name_emitter_ (c), + type_name_emitter_ (c) +{ + write_belongs_.node_traverser (write_type_name_emitter_); + + edge_traverser (set_raises_); + set_raises_.node_traverser (type_name_emitter_); +} + +void +WriteAttributeHeaderEmitter::pre (SemanticGraph::ReadWriteAttribute&) +{ + os << "void" << endl; +} + +void +WriteAttributeHeaderEmitter::name (SemanticGraph::ReadWriteAttribute& a) +{ + os << a.name () << " (" << endl; + + Traversal::ReadWriteAttribute::belongs (a, write_belongs_); + + os << " " << a.name () << ")" << endl; +} + +void +WriteAttributeHeaderEmitter::get_raises (SemanticGraph::ReadWriteAttribute&) +{ +} + +void +WriteAttributeHeaderEmitter::set_raises_none (SemanticGraph::ReadWriteAttribute&) +{ + os << STRS[EXCP_SNGL]; +} + +void +WriteAttributeHeaderEmitter::set_raises_pre (SemanticGraph::ReadWriteAttribute&) +{ + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; +} + +void +WriteAttributeHeaderEmitter::set_raises_post (SemanticGraph::ReadWriteAttribute&) +{ + os << "))"; +} + +void +WriteAttributeHeaderEmitter::post (SemanticGraph::ReadWriteAttribute&) +{ + os << ";" << endl; +} + +void +WriteAttributeHeaderEmitter::comma (SemanticGraph::ReadWriteAttribute&) +{ + os << "," << endl; +} + +// ============================================================ + +AttributeHeaderEmitter::AttributeHeaderEmitter (Context& c) + : EmitterBase (c), + read_type_name_emitter_ (c), + type_name_emitter_ (c) +{ + read_belongs_.node_traverser (read_type_name_emitter_); + + edge_traverser (get_raises_); + get_raises_.node_traverser (type_name_emitter_); +} + +// ReadWriteAttribute +// +void +AttributeHeaderEmitter::pre (SemanticGraph::ReadWriteAttribute& a) +{ + os << "virtual "; + + Traversal::ReadWriteAttribute::belongs (a, read_belongs_); + + os << endl; +} + +void +AttributeHeaderEmitter::name (SemanticGraph::ReadWriteAttribute& a) +{ + os << a.name () << " ()" << endl; +} + +void +AttributeHeaderEmitter::get_raises_none (SemanticGraph::ReadWriteAttribute&) +{ + os << STRS[EXCP_SNGL]; +} + +void +AttributeHeaderEmitter::get_raises_pre (SemanticGraph::ReadWriteAttribute&) +{ + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; +} + +void +AttributeHeaderEmitter::get_raises_post (SemanticGraph::ReadWriteAttribute&) +{ + os << "))"; +} + +void +AttributeHeaderEmitter::set_raises (SemanticGraph::ReadWriteAttribute&) +{ +} + +void +AttributeHeaderEmitter::post (SemanticGraph::ReadWriteAttribute& a) +{ + os << ";" << endl; + + WriteAttributeHeaderEmitter write_attribute_emitter (ctx); + write_attribute_emitter.traverse (a); +} + +void +AttributeHeaderEmitter::comma (SemanticGraph::ReadWriteAttribute&) +{ + os << "," << endl; +} + +// ReadAttribute +// +void +AttributeHeaderEmitter::pre (SemanticGraph::ReadAttribute& a) +{ + os << "virtual "; + + Traversal::ReadAttribute::belongs (a, read_belongs_); + + os << endl; +} + +void +AttributeHeaderEmitter::name (SemanticGraph::ReadAttribute& a) +{ + os << a.name () << " ()" << endl; +} + +void +AttributeHeaderEmitter::get_raises_none (SemanticGraph::ReadAttribute&) +{ + os << STRS[EXCP_SNGL]; +} + +void +AttributeHeaderEmitter::get_raises_pre (SemanticGraph::ReadAttribute&) +{ + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; +} + +void +AttributeHeaderEmitter::get_raises_post (SemanticGraph::ReadAttribute&) +{ + os << "))"; +} + +void +AttributeHeaderEmitter::set_raises (SemanticGraph::ReadAttribute&) +{ +} + +void +AttributeHeaderEmitter::post (SemanticGraph::ReadAttribute&) +{ + os << ";" << endl; +} + +void +AttributeHeaderEmitter::comma (SemanticGraph::ReadAttribute&) +{ + os << "," << endl; +} + diff --git a/modules/CIAO/CIDLC/AttributeHeaderEmitters.hpp b/modules/CIAO/CIDLC/AttributeHeaderEmitters.hpp new file mode 100644 index 00000000000..f4318ad0073 --- /dev/null +++ b/modules/CIAO/CIDLC/AttributeHeaderEmitters.hpp @@ -0,0 +1,119 @@ +// file : CIDLC/AttributeHeaderEmitters.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef ATTRIBUTEHEADEREMITTERS_HPP +#define ATTRIBUTEHEADEREMITTERS_HPP + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +#include "CorbaTypeNameEmitters.hpp" +#include "UtilityTypeNameEmitters.hpp" +#include "EmitterBase.hpp" + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +struct WriteAttributeHeaderEmitter : Traversal::ReadWriteAttribute, + EmitterBase +{ + WriteAttributeHeaderEmitter (Context& c); + + virtual void + pre (SemanticGraph::ReadWriteAttribute&); + + virtual void + name (SemanticGraph::ReadWriteAttribute&); + + virtual void + get_raises (SemanticGraph::ReadWriteAttribute&); + + virtual void + set_raises_none (SemanticGraph::ReadWriteAttribute&); + + virtual void + set_raises_pre (SemanticGraph::ReadWriteAttribute&); + + virtual void + set_raises_post (SemanticGraph::ReadWriteAttribute&); + + virtual void + post (SemanticGraph::ReadWriteAttribute&); + + virtual void + comma (SemanticGraph::ReadWriteAttribute&); + + private: + INArgTypeNameEmitter write_type_name_emitter_; + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs write_belongs_; + Traversal::SetRaises set_raises_; +}; + +struct AttributeHeaderEmitter : Traversal::ReadAttribute, + Traversal::ReadWriteAttribute, + EmitterBase +{ + AttributeHeaderEmitter (Context&); + + // ReadWriteAttribute + // + virtual void + pre (SemanticGraph::ReadWriteAttribute&); + + virtual void + name (SemanticGraph::ReadWriteAttribute&); + + virtual void + get_raises_none (SemanticGraph::ReadWriteAttribute&); + + virtual void + get_raises_pre (SemanticGraph::ReadWriteAttribute&); + + virtual void + get_raises_post (SemanticGraph::ReadWriteAttribute&); + + virtual void + set_raises (SemanticGraph::ReadWriteAttribute&); + + virtual void + post (SemanticGraph::ReadWriteAttribute&); + + virtual void + comma (SemanticGraph::ReadWriteAttribute&); + + // ReadAttribute + // + virtual void + pre (SemanticGraph::ReadAttribute&); + + virtual void + name (SemanticGraph::ReadAttribute&); + + virtual void + get_raises_none (SemanticGraph::ReadAttribute&); + + virtual void + get_raises_pre (SemanticGraph::ReadAttribute&); + + virtual void + get_raises_post (SemanticGraph::ReadAttribute&); + + virtual void + set_raises (SemanticGraph::ReadAttribute&); + + virtual void + post (SemanticGraph::ReadAttribute&); + + virtual void + comma (SemanticGraph::ReadAttribute&); + +private: + ReturnTypeNameEmitter read_type_name_emitter_; + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs read_belongs_; + Traversal::GetRaises get_raises_; +}; + +#endif // ATTRIBUTEHEADEREMITTERS_HPP diff --git a/modules/CIAO/CIDLC/AttributeSourceEmitters_T.hpp b/modules/CIAO/CIDLC/AttributeSourceEmitters_T.hpp new file mode 100644 index 00000000000..9f601d27de7 --- /dev/null +++ b/modules/CIAO/CIDLC/AttributeSourceEmitters_T.hpp @@ -0,0 +1,360 @@ +// file : CIDLC/AttributeSourceEmitters_T.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef ATTRIBUTESOURCEEMITTERS_T_HPP +#define ATTRIBUTESOURCEEMITTERS_T_HPP + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +#include "Literals.hpp" +#include "CorbaTypeNameEmitters.hpp" +#include "UtilityTypeNameEmitters.hpp" + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; +using namespace StringLiterals; + +template +struct WriteAttributeSourceEmitter : Traversal::ReadWriteAttribute, + EmitterBase +{ + WriteAttributeSourceEmitter (Context& c, + T& scope, + bool swapping, + bool exec_src) + : EmitterBase (c), + scope_ (scope), + write_type_name_emitter_ (c), + type_name_emitter_ (c), + swapping_ (swapping), + exec_src_ (exec_src) + { + write_belongs_.node_traverser (write_type_name_emitter_); + edge_traverser (set_raises_); + set_raises_.node_traverser (type_name_emitter_); + } + + virtual void + gen_swapping_set () + { + os << "this->activate_component (" << ");" + << endl; + } + + virtual void + pre (SemanticGraph::ReadWriteAttribute&) + { + os << "void" << endl; + } + + virtual void + name (SemanticGraph::ReadWriteAttribute& a) + { + os << scope_.name () + << (exec_src_ ? "_exec_i::" : "_Servant::") + << a.name () << " (" << endl; + + Traversal::ReadWriteAttribute::belongs (a, write_belongs_); + + os << (exec_src_ ? " /* " : " ") + << a.name () + << (exec_src_ ? " */" : "") << endl + << ")" << endl; + } + + virtual void + get_raises (SemanticGraph::ReadWriteAttribute&) + { + } + + virtual void + set_raises_none (SemanticGraph::ReadWriteAttribute&) + { + os << STRS[EXCP_SNGL]; + } + + virtual void + set_raises_pre (SemanticGraph::ReadWriteAttribute&) + { + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; + } + + virtual void + set_raises_post (SemanticGraph::ReadWriteAttribute&) + { + os << "))" << endl; + } + + virtual void + post (SemanticGraph::ReadWriteAttribute& a) + { + os << "{"; + + if (exec_src_) + { + os << STRS[YCH]; + } + else + { + if (swapping_) + { + this->gen_swapping_set (); + } + + os << "this->executor_->" << a.name () << " (" << endl + << a.name () << endl + << ");" << endl; + } + + os << "}"; + } + + virtual void + comma (SemanticGraph::ReadWriteAttribute&) + { + os << "," << endl; + } + +protected: + T& scope_; + Traversal::Belongs write_belongs_; + +private: + INArgTypeNameEmitter write_type_name_emitter_; + FullTypeNameEmitter type_name_emitter_; + Traversal::SetRaises set_raises_; + bool swapping_; + bool exec_src_; +}; + +template +struct AttributeSourceEmitter : Traversal::ReadAttribute, + Traversal::ReadWriteAttribute, + EmitterBase +{ + AttributeSourceEmitter (Context& c, T& scope, bool exec_src = false) + : EmitterBase (c), + scope_ (scope), + read_type_name_emitter_ (c), + type_name_emitter_ (c), + return_emitter_ (c), + exec_src_ (exec_src) + { + read_belongs_.node_traverser (read_type_name_emitter_); + return_belongs_.node_traverser (return_emitter_); + edge_traverser (get_raises_); + get_raises_.node_traverser (type_name_emitter_); + } + + // ReadWriteAttribute + // + + // Overridden by facet attribute emitter in servant source generator. + virtual void + gen_swapping_get (SemanticGraph::ReadWriteAttribute& a) + { + os << "this->activate_component ();"; + + Traversal::ReadWriteAttribute::belongs (a, ace_check_return_belongs_); + + os << endl; + } + + // Overridden by facet attribute emitter in servant source generator. + virtual void + gen_write_operation (SemanticGraph::ReadWriteAttribute& a, + bool swapping) + { + WriteAttributeSourceEmitter write_attribute_emitter (ctx, + scope_, + swapping, + exec_src_); + write_attribute_emitter.traverse (a); + } + + virtual void + pre (SemanticGraph::ReadWriteAttribute& a) + { + Traversal::ReadWriteAttribute::belongs (a, read_belongs_); + + os << endl; + } + + virtual void + name (SemanticGraph::ReadWriteAttribute& a) + { + os << scope_.name () + << (exec_src_ ? "_exec_i::" : "_Servant::") + << a.name () << " (" << endl + << ")" << endl; + } + + virtual void + get_raises_none (SemanticGraph::ReadWriteAttribute&) + { + os << STRS[EXCP_SNGL] << endl; + } + + virtual void + get_raises_pre (SemanticGraph::ReadWriteAttribute&) + { + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; + } + + virtual void + get_raises_post (SemanticGraph::ReadWriteAttribute&) + { + os << "))" << endl; + } + + virtual void + set_raises (SemanticGraph::ReadWriteAttribute&) + { + } + + virtual void + post (SemanticGraph::ReadWriteAttribute& a) + { + bool swapping = false; + + os << "{"; + + if (exec_src_) + { + os << STRS[YCH] << endl; + + Traversal::ReadWriteAttribute::belongs (a, return_belongs_); + } + else + { + string swap_option = ctx.cl ().get_value ("custom-container", ""); + swapping = (swap_option == "upgradeable"); + + if (swapping) + { + this->gen_swapping_get (a); + } + + os << "return this->executor_->" << a.name () << " ();"; + } + + os << "}"; + + this->gen_write_operation (a, swapping); + } + + virtual void + comma (SemanticGraph::ReadWriteAttribute&) + { + os << "," << endl; + } + + // ReadAttribute + // + + // Overridden by facet attribute emitter in servant source generator. + virtual void + gen_swapping_get (SemanticGraph::ReadAttribute& a) + { + os << "this->activate_component ();"; + + Traversal::ReadAttribute::belongs (a, ace_check_return_belongs_); + + os << endl; + } + + virtual void + pre (SemanticGraph::ReadAttribute& a) + { + Traversal::ReadAttribute::belongs (a, read_belongs_); + + os << endl; + } + + virtual void + name (SemanticGraph::ReadAttribute& a) + { + os << scope_.name () + << (exec_src_ ? "_exec_i::" : "_Servant::") + << a.name () << " (" << endl + << ")" << endl; + } + + virtual void + get_raises_none (SemanticGraph::ReadAttribute&) + { + os << STRS[EXCP_SNGL] << endl; + } + + virtual void + get_raises_pre (SemanticGraph::ReadAttribute&) + { + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; + } + + virtual void + get_raises_post (SemanticGraph::ReadAttribute&) + { + os << "))" << endl; + } + + virtual void + set_raises (SemanticGraph::ReadAttribute&) + { + } + + virtual void + post (SemanticGraph::ReadAttribute& a) + { + bool swapping = false; + + os << "{"; + + if (exec_src_) + { + os << STRS[YCH] << endl; + + Traversal::ReadAttribute::belongs (a, return_belongs_); + } + else + { + string swap_option = ctx.cl ().get_value ("custom-container", ""); + swapping = (swap_option == "upgradeable"); + + if (swapping) + { + this->gen_swapping_get (a); + } + + os << "return this->executor_->" << a.name () << " ();"; + } + + os << "}"; + } + + virtual void + comma (SemanticGraph::ReadAttribute&) + { + os << "," << endl; + } + +protected: + T& scope_; + +private: + ReturnTypeNameEmitter read_type_name_emitter_; + FullTypeNameEmitter type_name_emitter_; + NullReturnEmitter return_emitter_; + Traversal::Belongs read_belongs_; + Traversal::Belongs return_belongs_; + Traversal::Belongs ace_check_return_belongs_; + Traversal::GetRaises get_raises_; + bool exec_src_; +}; + +#endif // ATTRIBUTESOURCEEMITTERS_T_HPP diff --git a/modules/CIAO/CIDLC/CIDLC.mpc b/modules/CIAO/CIDLC/CIDLC.mpc new file mode 100644 index 00000000000..034bf35a71b --- /dev/null +++ b/modules/CIAO/CIDLC/CIDLC.mpc @@ -0,0 +1,16 @@ +//$Id$ + +project(CIDLC): cidlc { + exename = cidlc + after += IDL2 IDL3 CIDL CodeGenerationKit CompilerElements + install = ../bin + libs += CIDL IDL3 IDL2 CodeGenerationKit CompilerElements + + Source_Files { + *.cpp + } + + Header_Files { + *.hpp + } +} diff --git a/modules/CIAO/CIDLC/CIDLC.mwc b/modules/CIAO/CIDLC/CIDLC.mwc new file mode 100644 index 00000000000..7cddcf9a001 --- /dev/null +++ b/modules/CIAO/CIDLC/CIDLC.mwc @@ -0,0 +1,10 @@ +// $Id: +workspace { + cmdline += -static + ../CCF/CCF/CIDL + ../CCF/CCF/IDL2 + ../CCF/CCF/CodeGenerationKit + ../CCF/CCF/CompilerElements + ../CCF/CCF/IDL3 + CIDLC.mpc +} diff --git a/modules/CIAO/CIDLC/Collectors.hpp b/modules/CIAO/CIDLC/Collectors.hpp new file mode 100644 index 00000000000..e87667579b5 --- /dev/null +++ b/modules/CIAO/CIDLC/Collectors.hpp @@ -0,0 +1,280 @@ +// file : CIDLC/Collectors.hpp +// author : Boris Kolpackov +// cvs-id : $Id$ + +#ifndef COLLECTORS_HPP +#define COLLECTORS_HPP + +#include + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +class Declarations +{ +public: + bool + add (CCF::IDL3::SyntaxTree::HomeDefPtr const& h) + { + return homes_.insert (h).second; + } + + bool + add (CCF::IDL3::SyntaxTree::ComponentDefPtr const& c) + { + return components_.insert (c).second; + } + + bool + add (CCF::CIDL::SyntaxTree::CompositionPtr const& cs, + CCF::IDL3::SyntaxTree::ComponentDefPtr const& cn) + { + return compositions_.insert (make_pair(cs, cn)).second; + } + + bool + add (CCF::IDL3::SyntaxTree::UnconstrainedInterfaceDeclPtr const& i) + { + return interfaces_.insert (i).second + && interface_names_.insert (i->name ()).second; + } + +public: + bool + find (CCF::IDL3::SyntaxTree::HomeDefPtr const& h) const + { + return homes_.find (h) != homes_.end (); + } + + bool + find (CCF::IDL3::SyntaxTree::ComponentDefPtr const& c) const + { + return components_.find (c) != components_.end (); + } + + bool + find (CCF::CIDL::SyntaxTree::CompositionPtr const& c) const + { + return compositions_.find (c) != compositions_.end (); + } + + bool + find (CCF::IDL2::SyntaxTree::UnconstrainedInterfaceDefPtr const& i) const + { + return interface_names_.find (i->name ()) != interface_names_.end (); + } + +public: + CCF::IDL3::SyntaxTree::ComponentDefPtr + resolve (CCF::CIDL::SyntaxTree::CompositionPtr const& c) const + { + CompositionMap::const_iterator i = compositions_.find (c); + if (i != compositions_.end ()) + { + return i->second; + } + else + { + return CCF::IDL3::SyntaxTree::ComponentDefPtr (0); + } + } + +public: + bool + contains_suborder (CCF::CIDL::SyntaxTree::Order const& o) const + { + for (CCF::IDL2::SyntaxTree::UnconstrainedInterfaceDeclSet::const_iterator i = + interfaces_.begin (); + i != interfaces_.end (); + i++) + { + if (o.suborder ((*i)->order ())) return true; + } + + for (CCF::IDL3::SyntaxTree::ComponentDefSet::const_iterator i = components_.begin (); + i != components_.end (); + i++) + { + if (o.suborder ((*i)->order ())) return true; + } + + for (CCF::IDL3::SyntaxTree::HomeDefSet::const_iterator i = homes_.begin (); + i != homes_.end (); + i++) + { + if (o.suborder ((*i)->order ())) return true; + } + + for (CompositionMap::const_iterator i = compositions_.begin (); + i != compositions_.end (); + i++) + { + if (o.suborder (i->first->order ())) return true; + } + + return false; + } + +private: + typedef + std::map CompositionMap; + + CCF::IDL3::SyntaxTree::HomeDefSet homes_; + CCF::IDL3::SyntaxTree::ComponentDefSet components_; + CompositionMap compositions_; + CCF::IDL2::SyntaxTree::UnconstrainedInterfaceDeclSet interfaces_; + CCF::IDL2::SyntaxTree::ScopedNameSet interface_names_; +}; + + +// +// +// +class HomeCollector : public CCF::IDL3::Traversal::HomeDef +{ +public: + HomeCollector (Declarations& declarations) + : declarations_ (declarations) + { + } + + virtual void + traverse (CCF::CIDL::SyntaxTree::HomeDefPtr const& h) + { + CCF::CIDL::SyntaxTree::ScopedName n (h->name ()); + + CCF::CIDL::SyntaxTree::ScopedName main (n.scope (), "CCM_" + n.simple ()); + CCF::CIDL::SyntaxTree::ScopedName expl (n.scope (), "CCM_" + n.simple () + "Explicit"); + CCF::CIDL::SyntaxTree::ScopedName impl (n.scope (), "CCM_" + n.simple () + "Implicit"); + + // Check if mapping has already been provided. + if (h->table ().exist (main) || + h->table ().exist (expl) || + h->table ().exist (impl)) return; + + if (declarations_.add (h)) + { + // Note that I don't go after components that inherited home manages + // because it will be handled by component inheritance tree. + // + if (h->inherits ()) traverse (h->inherits ().resolve ()); + } + } + +private: + Declarations& declarations_; +}; + +// +// +// +class ComponentCollector : public CCF::IDL3::Traversal::ComponentDef +{ +public: + ComponentCollector (Declarations& declarations) + : declarations_ (declarations) + { + } + + virtual void + pre (CCF::IDL3::SyntaxTree::ComponentDefPtr const& c) + { + CCF::CIDL::SyntaxTree::ScopedName n (c->name ()); + + CCF::CIDL::SyntaxTree::ScopedName monolith (n.scope (), "CCM_" + n.simple ()); + CCF::CIDL::SyntaxTree::ScopedName context (n.scope (), "CCM_" + n.simple () + "_Context"); + + // Check if mapping has already been provided. + if (c->table ().exist (context) || + c->table ().exist (monolith)) return; + + if(declarations_.add (c)) + { + if (c->inherits ()) + { + traverse (c->inherits ().resolve ()); + } + } + } + +private: + Declarations& declarations_; +}; + +// +// +// +class ProvidedInterfaceCollector : public CCF::IDL3::Traversal::ProvidesDecl +{ +public: + ProvidedInterfaceCollector (Declarations& declarations) + : declarations_ (declarations) + { + } + + virtual void + traverse (CCF::IDL3::SyntaxTree::ProvidesDeclPtr const& i) + { + //@@ CCM issue: interface should be defined at this point + CCF::IDL2::SyntaxTree::UnconstrainedInterfaceDeclPtr def + (i->type () + ->dynamic_type ()); + + if (def != 0) + { + // Add to the list if it's not already there. + declarations_.add (def); + } + } + +private: + Declarations& declarations_; +}; + + +// +// +// +class HomeExecutorCollector : public CCF::CIDL::Traversal::HomeExecutor +{ +public: + HomeExecutorCollector (Declarations& declarations, + CCF::CIDL::Traversal::Dispatcher* home_collector, + CCF::CIDL::Traversal::Dispatcher* component_collector) + : declarations_ (declarations), + home_collector_ (home_collector), + component_collector_ (component_collector) + { + } + + virtual void + traverse (CCF::CIDL::SyntaxTree::HomeExecutorPtr const& he) + { + CCF::CIDL::SyntaxTree::HomeDefPtr home (he->implements ()); + home_collector_->dispatch (home); + + CCF::CIDL::SyntaxTree::ComponentDefPtr component (home->manages ()); + component_collector_->dispatch (component); + + CCF::CIDL::SyntaxTree::CompositionPtr + composition (he->scope ()->dynamic_type ()); + declarations_.add (composition, component); + } + +private: + Declarations& declarations_; + + CCF::CIDL::Traversal::Dispatcher* home_collector_; + CCF::CIDL::Traversal::Dispatcher* component_collector_; +}; + +#endif // COLLECTORS_HPP + +/* + * Local Variables: + * mode: C++ + * c-basic-offset: 2 + * End: + */ diff --git a/modules/CIAO/CIDLC/CompositionEmitter.cpp b/modules/CIAO/CIDLC/CompositionEmitter.cpp new file mode 100644 index 00000000000..d477ae4a3b8 --- /dev/null +++ b/modules/CIAO/CIDLC/CompositionEmitter.cpp @@ -0,0 +1,27 @@ +// file : CIDLC/CompositionEmitter.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "CompositionEmitter.hpp" +#include "Literals.hpp" + +using namespace StringLiterals; + +CompositionEmitter::CompositionEmitter (Context& c) + : EmitterBase (c) +{ +} + +void +CompositionEmitter::pre (Type& t) +{ + ctx.composition_name (t.name ().unescaped_str ()); + + os << STRS[CIDL_NS] << t.name () << "{"; +} + +void +CompositionEmitter::post (Type&) +{ + os << "}"; +} diff --git a/modules/CIAO/CIDLC/CompositionEmitter.hpp b/modules/CIAO/CIDLC/CompositionEmitter.hpp new file mode 100644 index 00000000000..c6aeab17229 --- /dev/null +++ b/modules/CIAO/CIDLC/CompositionEmitter.hpp @@ -0,0 +1,26 @@ +// file : CIDLC/CompositionEmitter.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef COMPOSITIONEMITTER_HPP +#define COMPOSITIONEMITTER_HPP + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +#include "EmitterBase.hpp" + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +struct CompositionEmitter : Traversal::Composition, + EmitterBase +{ + CompositionEmitter (Context& c); + + virtual void pre (Type&); + + virtual void post (Type&); +}; + +#endif // COMPOSITIONEMITTER_HPP diff --git a/modules/CIAO/CIDLC/CorbaTypeNameEmitters.cpp b/modules/CIAO/CIDLC/CorbaTypeNameEmitters.cpp new file mode 100644 index 00000000000..84507c151b6 --- /dev/null +++ b/modules/CIAO/CIDLC/CorbaTypeNameEmitters.cpp @@ -0,0 +1,2014 @@ +// file : CIDLC/CorbaTypeNameEmitter.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "CorbaTypeNameEmitters.hpp" +#include "Literals.hpp" + +#include + +using namespace std; +using namespace StringLiterals; + +CorbaTypeNameEmitter::CorbaTypeNameEmitter (Context& c) + : EmitterBase (c) +{ +} + +void +CorbaTypeNameEmitter::traverse (Void&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Boolean&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Octet&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Char&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Wchar&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Short&) +{ +} + +void +CorbaTypeNameEmitter::traverse (UnsignedShort&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Long&) +{ +} + +void +CorbaTypeNameEmitter::traverse (UnsignedLong&) +{ +} + +void +CorbaTypeNameEmitter::traverse (LongLong&) +{ +} + +void +CorbaTypeNameEmitter::traverse (UnsignedLongLong&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Float&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Double&) +{ +} + +void +CorbaTypeNameEmitter::traverse (String&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::BoundedString&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Wstring&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::BoundedWideString&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Object&) +{ +} + +void +CorbaTypeNameEmitter::traverse (ValueBase&) +{ +} + +void +CorbaTypeNameEmitter::traverse (Any&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::Array&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::Enum&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::Struct&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::Union&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::BoundedSequence&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::UnboundedSequence&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::Interface&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::ValueType&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::EventType&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::Component&) +{ +} + +void +CorbaTypeNameEmitter::traverse (SemanticGraph::Home&) +{ +} + +// ==================================================================== + +ReturnTypeNameEmitter::ReturnTypeNameEmitter (Context& c) + : CorbaTypeNameEmitter (c) +{ +} + +void +ReturnTypeNameEmitter::traverse (Void&) +{ + os << "void"; +} + +void +ReturnTypeNameEmitter::traverse (Boolean&) +{ + os << "::CORBA::Boolean"; +} + +void +ReturnTypeNameEmitter::traverse (Octet&) +{ + os << "::CORBA::Octet"; +} + +void +ReturnTypeNameEmitter::traverse (Char&) +{ + os << "::CORBA::Char"; +} + +void +ReturnTypeNameEmitter::traverse (Wchar&) +{ + os << "::CORBA::WChar"; +} + +void +ReturnTypeNameEmitter::traverse (Short&) +{ + os << "::CORBA::Short"; +} + +void +ReturnTypeNameEmitter::traverse (UnsignedShort&) +{ + os << "::CORBA::UShort"; +} + +void +ReturnTypeNameEmitter::traverse (Long&) +{ + os << "::CORBA::Long"; +} + +void +ReturnTypeNameEmitter::traverse (UnsignedLong&) +{ + os << "::CORBA::ULong"; +} + +void +ReturnTypeNameEmitter::traverse (LongLong&) +{ + os << "::CORBA::LongLong"; +} + +void +ReturnTypeNameEmitter::traverse (UnsignedLongLong&) +{ + os << "::CORBA::ULongLong"; +} + +void +ReturnTypeNameEmitter::traverse (Float&) +{ + os << "::CORBA::Float"; +} + +void +ReturnTypeNameEmitter::traverse (Double&) +{ + os << "::CORBA::Double"; +} + +void +ReturnTypeNameEmitter::traverse (String&) +{ + os << "char *"; +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::BoundedString&) +{ + os << "char *"; +} + +void +ReturnTypeNameEmitter::traverse (Wstring&) +{ + os << "::CORBA::WChar *"; +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::BoundedWideString&) +{ + os << "::CORBA::WChar *"; +} + +void +ReturnTypeNameEmitter::traverse (Object&) +{ + os << "::CORBA::Object_ptr"; +} + +void +ReturnTypeNameEmitter::traverse (ValueBase&) +{ + os << "::CORBA::ValueBase *"; +} + +void +ReturnTypeNameEmitter::traverse (Any&) +{ + os << "::CORBA::Any *"; +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::Array& a) +{ + os << a.scoped_name () << "_slice *"; +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::Enum& e) +{ + os << e.scoped_name (); +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::Struct& s) +{ + // This should always be in the context, since the SizeTypeCalculator + // is executed before the servant code generators. + bool var_size = s.context ().get (STRS[VAR_SIZE]); + + os << s.scoped_name (); + + if (var_size) + { + os << " *"; + } +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::Union& u) +{ + // This should always be in the context, since the SizeTypeCalculator + // is executed before the servant code generators. + bool var_size = u.context ().get (STRS[VAR_SIZE]); + + os << u.scoped_name (); + + if (var_size) + { + os << " *"; + } +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::BoundedSequence& s) +{ + os << s.scoped_name () << " *"; +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::UnboundedSequence& s) +{ + os << s.scoped_name () << " *"; +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::Interface& i) +{ + os << i.scoped_name () << "_ptr"; +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::ValueType& v) +{ + os << v.scoped_name () << " *"; +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::EventType& e) +{ + os << e.scoped_name () << " *"; +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::Component& c) +{ + os << c.scoped_name () << "_ptr"; +} + +void +ReturnTypeNameEmitter::traverse (SemanticGraph::Home& h) +{ + os << h.scoped_name () << "_ptr"; +} + +// =============================================================== + +INArgTypeNameEmitter::INArgTypeNameEmitter (Context& c) + : CorbaTypeNameEmitter (c) +{ +} + +void +INArgTypeNameEmitter::traverse (Boolean&) +{ + os << "::CORBA::Boolean"; +} + +void +INArgTypeNameEmitter::traverse (Octet&) +{ + os << "::CORBA::Octet"; +} + +void +INArgTypeNameEmitter::traverse (Char&) +{ + os << "::CORBA::Char"; +} + +void +INArgTypeNameEmitter::traverse (Wchar&) +{ + os << "::CORBA::WChar"; +} + +void +INArgTypeNameEmitter::traverse (Short&) +{ + os << "::CORBA::Short"; +} + +void +INArgTypeNameEmitter::traverse (UnsignedShort&) +{ + os << "::CORBA::UShort"; +} + +void +INArgTypeNameEmitter::traverse (Long&) +{ + os << "::CORBA::Long"; +} + +void +INArgTypeNameEmitter::traverse (UnsignedLong&) +{ + os << "::CORBA::ULong"; +} + +void +INArgTypeNameEmitter::traverse (LongLong&) +{ + os << "::CORBA::LongLong"; +} + +void +INArgTypeNameEmitter::traverse (UnsignedLongLong&) +{ + os << "::CORBA::ULongLong"; +} + +void +INArgTypeNameEmitter::traverse (Float&) +{ + os << "::CORBA::Float"; +} + +void +INArgTypeNameEmitter::traverse (Double&) +{ + os << "::CORBA::Double"; +} + +void +INArgTypeNameEmitter::traverse (String&) +{ + os << "const char *"; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::BoundedString&) +{ + os << "const char *"; +} + +void +INArgTypeNameEmitter::traverse (Wstring&) +{ + os << "const ::CORBA::WChar *"; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::BoundedWideString&) +{ + os << "const ::CORBA::WChar *"; +} + +void +INArgTypeNameEmitter::traverse (Object&) +{ + os << "::CORBA::Object_ptr"; +} + +void +INArgTypeNameEmitter::traverse (ValueBase&) +{ + os << "::CORBA::ValueBase *"; +} + +void +INArgTypeNameEmitter::traverse (Any&) +{ + os << "const ::CORBA::Any &"; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::Array& a) +{ + os << "const " << a.scoped_name (); +} +void +INArgTypeNameEmitter::traverse (SemanticGraph::Enum& e) +{ + os << e.scoped_name (); +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::Struct& s) +{ + os << "const " << s.scoped_name () << " &";; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::Union& u) +{ + os << "const " << u.scoped_name () << " &";; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::BoundedSequence& s) +{ + os << "const " << s.scoped_name () << " &";; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::UnboundedSequence& s) +{ + os << "const " << s.scoped_name () << " &";; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::Interface& i) +{ + os << i.scoped_name () << "_ptr"; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::ValueType& v) +{ + os << v.scoped_name () << " *"; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::EventType& e) +{ + os << e.scoped_name () << " *"; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::Component& c) +{ + os << c.scoped_name () << "_ptr"; +} + +void +INArgTypeNameEmitter::traverse (SemanticGraph::Home& h) +{ + os << h.scoped_name () << "_ptr"; +} + +// =============================================================== + +INOUTArgTypeNameEmitter::INOUTArgTypeNameEmitter (Context& c) + : CorbaTypeNameEmitter (c) +{ +} + +void +INOUTArgTypeNameEmitter::traverse (Boolean&) +{ + os << "::CORBA::Boolean &"; +} + +void +INOUTArgTypeNameEmitter::traverse (Octet&) +{ + os << "::CORBA::Octet &"; +} + +void +INOUTArgTypeNameEmitter::traverse (Char&) +{ + os << "::CORBA::Char &"; +} + +void +INOUTArgTypeNameEmitter::traverse (Wchar&) +{ + os << "::CORBA::WChar &"; +} + +void +INOUTArgTypeNameEmitter::traverse (Short&) +{ + os << "::CORBA::Short &"; +} + +void +INOUTArgTypeNameEmitter::traverse (UnsignedShort&) +{ + os << "::CORBA::UShort &"; +} + +void +INOUTArgTypeNameEmitter::traverse (Long&) +{ + os << "::CORBA::Long &"; +} + +void +INOUTArgTypeNameEmitter::traverse (UnsignedLong&) +{ + os << "::CORBA::ULong &"; +} + +void +INOUTArgTypeNameEmitter::traverse (LongLong&) +{ + os << "::CORBA::LongLong &"; +} + +void +INOUTArgTypeNameEmitter::traverse (UnsignedLongLong&) +{ + os << "::CORBA::ULongLong &"; +} + +void +INOUTArgTypeNameEmitter::traverse (Float&) +{ + os << "::CORBA::Float &"; +} + +void +INOUTArgTypeNameEmitter::traverse (Double&) +{ + os << "::CORBA::Double &"; +} + +void +INOUTArgTypeNameEmitter::traverse (String&) +{ + os << "char *&"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::BoundedString&) +{ + os << "char *&"; +} + +void +INOUTArgTypeNameEmitter::traverse (Wstring&) +{ + os << "::CORBA::WChar *&"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::BoundedWideString&) +{ + os << "::CORBA::WChar *&"; +} + +void +INOUTArgTypeNameEmitter::traverse (Object&) +{ + os << "::CORBA::Object_ptr &"; +} + +void +INOUTArgTypeNameEmitter::traverse (ValueBase&) +{ + os << "::CORBA::ValueBase *&"; +} + +void +INOUTArgTypeNameEmitter::traverse (Any&) +{ + os << "::CORBA::Any &"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::Array& a) +{ + os << a.scoped_name (); +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::Enum& e) +{ + os << e.scoped_name () << " &"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::Struct& s) +{ + os << s.scoped_name () << " &"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::Union& u) +{ + os << u.scoped_name () << " &"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::BoundedSequence& s) +{ + os << s.scoped_name () << " &"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::UnboundedSequence& s) +{ + os << s.scoped_name () << " &"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::Interface& i) +{ + os << i.scoped_name () << "_ptr &"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::ValueType& v) +{ + os << v.scoped_name () << " *&"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::EventType& e) +{ + os << e.scoped_name () << " *&"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::Component& c) +{ + os << c.scoped_name () << "_ptr &"; +} + +void +INOUTArgTypeNameEmitter::traverse (SemanticGraph::Home& h) +{ + os << h.scoped_name () << "_ptr"; +} + +// ================================================================= + +OUTArgTypeNameEmitter::OUTArgTypeNameEmitter (Context& c) + : CorbaTypeNameEmitter (c) +{ +} + +void +OUTArgTypeNameEmitter::traverse (Boolean&) +{ + os << "::CORBA::Boolean_out"; +} + +void +OUTArgTypeNameEmitter::traverse (Octet&) +{ + os << "::CORBA::Octet_out"; +} + +void +OUTArgTypeNameEmitter::traverse (Char&) +{ + os << "::CORBA::Char_out"; +} + +void +OUTArgTypeNameEmitter::traverse (Wchar&) +{ + os << "::CORBA::WChar_out"; +} + +void +OUTArgTypeNameEmitter::traverse (Short&) +{ + os << "::CORBA::Short_out"; +} + +void +OUTArgTypeNameEmitter::traverse (UnsignedShort&) +{ + os << "::CORBA::UShort_out"; +} + +void +OUTArgTypeNameEmitter::traverse (Long&) +{ + os << "::CORBA::Long_out"; +} + +void +OUTArgTypeNameEmitter::traverse (UnsignedLong&) +{ + os << "::CORBA::ULong_out"; +} + +void +OUTArgTypeNameEmitter::traverse (LongLong&) +{ + os << "::CORBA::LongLong_out"; +} + +void +OUTArgTypeNameEmitter::traverse (UnsignedLongLong&) +{ + os << "::CORBA::ULongLong_out"; +} + +void +OUTArgTypeNameEmitter::traverse (Float&) +{ + os << "::CORBA::Float_out"; +} + +void +OUTArgTypeNameEmitter::traverse (Double&) +{ + os << "::CORBA::Double_out"; +} + +void +OUTArgTypeNameEmitter::traverse (String&) +{ + os << "::CORBA::String_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::BoundedString& s) +{ + os << s.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (Wstring&) +{ + os << "::CORBA::WString_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::BoundedWideString& s) +{ + os << s.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (Object&) +{ + os << "::CORBA::Object_out"; +} + +void +OUTArgTypeNameEmitter::traverse (ValueBase&) +{ + os << "::CORBA::ValueBase_out"; +} + +void +OUTArgTypeNameEmitter::traverse (Any&) +{ + os << "::CORBA::Any_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::Array& a) +{ + os << a.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::Enum& e) +{ + os << e.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::Struct& s) +{ + os << s.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::Union& u) +{ + os << u.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::BoundedSequence& s) +{ + os << s.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::UnboundedSequence& s) +{ + os << s.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::Interface& i) +{ + os << i.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::ValueType& v) +{ + os << v.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::EventType& e) +{ + os << e.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::Component& c) +{ + os << c.scoped_name () << "_out"; +} + +void +OUTArgTypeNameEmitter::traverse (SemanticGraph::Home& h) +{ + os << h.scoped_name () << "_ptr"; +} + +// ==================================================================== + +NullReturnEmitter::NullReturnEmitter (Context& c) + : CorbaTypeNameEmitter (c) +{ +} + +void +NullReturnEmitter::traverse (Boolean&) +{ + os << "return false;"; +} + +void +NullReturnEmitter::traverse (Octet&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (Char&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (Wchar&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (Short&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (UnsignedShort&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (Long&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (UnsignedLong&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (LongLong&) +{ + os << "return ACE_CDR_LONGLONG_INITIALIZER;"; +} + +void +NullReturnEmitter::traverse (UnsignedLongLong&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (Float&) +{ + os << "return 0.0f;"; +} + +void +NullReturnEmitter::traverse (Double&) +{ + os << "return 0.0;"; +} + +void +NullReturnEmitter::traverse (String&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::BoundedString&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (Wstring&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::BoundedWideString&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (Object&) +{ + os << "return ::CORBA::Object::_nil ();"; +} + +void +NullReturnEmitter::traverse (ValueBase&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (Any&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::Array&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::Enum& e) +{ + os << e.scoped_name () << " retval;" << endl + << "return retval;"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::Struct& s) +{ + // This should always be in the context, since the SizeTypeCalculator + // is executed before the servant code generators. + bool var_size = s.context ().get (STRS[VAR_SIZE]); + + if (var_size) + { + os << "return 0;"; + } + else + { + os << s.scoped_name () << " retval;" << endl + << "return retval;"; + } +} + +void +NullReturnEmitter::traverse (SemanticGraph::Union& u) +{ + // This should always be in the context, since the SizeTypeCalculator + // is executed before the servant code generators. + bool var_size = u.context ().get (STRS[VAR_SIZE]); + + if (var_size) + { + os << "return 0;"; + } + else + { + os << u.scoped_name () << " retval;" << endl + << "return retval;"; + } +} + +void +NullReturnEmitter::traverse (SemanticGraph::BoundedSequence&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::UnboundedSequence&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::Interface& i) +{ + os << "return " << i.scoped_name () << "::_nil ();"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::ValueType&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::EventType&) +{ + os << "return 0;"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::Component& c) +{ + os << "return " << c.scoped_name () << "::_nil ();"; +} + +void +NullReturnEmitter::traverse (SemanticGraph::Home& h) +{ + os << "return " << h.scoped_name () << "::_nil ();"; +} + +// ==================================================================== +/* Not currently used, but it was at one time and may be useful again. + +NullRHSEmitter::NullRHSEmitter (Context& c) + : CorbaTypeNameEmitter (c) +{ +} + +void +NullRHSEmitter::traverse (Boolean&) +{ + os << "= false;"; +} + +void +NullRHSEmitter::traverse (Octet&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (Char&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (Wchar&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (Short&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (UnsignedShort&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (Long&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (UnsignedLong&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (LongLong&) +{ + os << "= ACE_CDR_LONGLONG_INITIALIZER;"; +} + +void +NullRHSEmitter::traverse (UnsignedLongLong&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (Float&) +{ + os << "= 0.0f;"; +} + +void +NullRHSEmitter::traverse (Double&) +{ + os << "= 0.0;"; +} + +void +NullRHSEmitter::traverse (String&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::BoundedString&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (Wstring&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::BoundedWideString&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (Object&) +{ + os << "= ::CORBA::Object::_nil ();"; +} + +void +NullRHSEmitter::traverse (ValueBase&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (Any&) +{ + // This will hopefully work both if the lhs is a pointer (for example + // RetunrTypeNameEmitter) or not (for example INArgTypeNameEmitter). + os << ";"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::Array&) +{ + // This will hopefully work both if the lhs is a slice pointer (for example + // RetunrTypeNameEmitter) or not (for example INArgTypeNameEmitter). + os << ";"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::Enum&) +{ + os << ";"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::Struct& s) +{ + // This should always be in the context, since the SizeTypeCalculator + // is executed before the servant code generators. + bool var_size = s.context ().get (STRS[VAR_SIZE]); + + if (var_size) + { + os << "= 0;"; + } + else + { + os << ";"; + } +} + +void +NullRHSEmitter::traverse (SemanticGraph::Union& u) +{ + // This should always be in the context, since the SizeTypeCalculator + // is executed before the servant code generators. + bool var_size = u.context ().get (STRS[VAR_SIZE]); + + if (var_size) + { + os << "= 0;"; + } + else + { + os << ";"; + } +} + +void +NullRHSEmitter::traverse (SemanticGraph::BoundedSequence&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::UnboundedSequence&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::Interface& i) +{ + os << "= " << i.scoped_name () << "::_nil ();"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::ValueType&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::EventType&) +{ + os << "= 0;"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::Component& c) +{ + os << "= " << c.scoped_name () << "::_nil ();"; +} + +void +NullRHSEmitter::traverse (SemanticGraph::Home& h) +{ + os << "= " << h.scoped_name () << "::_nil ();"; +} +*/ +// ==================================================================== + +ExtractedTypeDeclEmitter::ExtractedTypeDeclEmitter (Context& c) + : CorbaTypeNameEmitter (c) +{ +} + +void +ExtractedTypeDeclEmitter::traverse (Boolean&) +{ + os << "::CORBA::Boolean " << STRS[EXTRACT_TMP] << " = false;" + << "::CORBA::Any::to_boolean " << STRS[EXTRACT] + << " (" << STRS[EXTRACT_TMP] << ");"; +} + +void +ExtractedTypeDeclEmitter::traverse (Octet&) +{ + os << "::CORBA::Octet " << STRS[EXTRACT_TMP] << " = 0;" + << "::CORBA::Any::to_octet " << STRS[EXTRACT] + << " (" << STRS[EXTRACT_TMP] << ");"; +} + +void +ExtractedTypeDeclEmitter::traverse (Char&) +{ + os << "::CORBA::Char " << STRS[EXTRACT_TMP] << " = 0;" + << "::CORBA::Any::to_char " << STRS[EXTRACT] + << " (" << STRS[EXTRACT_TMP] << ");"; +} + +void +ExtractedTypeDeclEmitter::traverse (Wchar&) +{ + os << "::CORBA::WChar " << STRS[EXTRACT_TMP] << " = 0;" + << "::CORBA::Any::to_wchar " << STRS[EXTRACT] + << " (" << STRS[EXTRACT_TMP] << ");"; +} + +void +ExtractedTypeDeclEmitter::traverse (Short&) +{ + os << "::CORBA::Short " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (UnsignedShort&) +{ + os << "::CORBA::UShort " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (Long&) +{ + os << "::CORBA::Long " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (UnsignedLong&) +{ + os << "::CORBA::ULong " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (LongLong&) +{ + os << "::CORBA::LongLong " << STRS[EXTRACT] + << " = ACE_CDR_LONGLONG_INITIALIZER;"; +} + +void +ExtractedTypeDeclEmitter::traverse (UnsignedLongLong&) +{ + os << "::CORBA::ULongLong " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (Float&) +{ + os << "::CORBA::Float " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (Double&) +{ + os << "::CORBA::Double " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (String&) +{ + os << "const char * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::BoundedString&) +{ + os << "const char * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (Wstring&) +{ + os << "::CORBA::WChar * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::BoundedWideString&) +{ + os << "::CORBA::WChar * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (Object&) +{ + os << "::CORBA::Object_ptr " << STRS[EXTRACT] + << " = ::CORBA::Object::_nil ();"; +} + +void +ExtractedTypeDeclEmitter::traverse (ValueBase&) +{ + os << "::CORBA::ValueBase * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (Any&) +{ + os << "::CORBA::Any * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::Array& a) +{ + os << a.scoped_name () << "_forany & " << STRS[EXTRACT] << ";"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::Enum& e) +{ + os << e.scoped_name () << " " << STRS[EXTRACT] << ";"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::Struct& s) +{ + os << s.scoped_name () << " * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::Union& u) +{ + os << u.scoped_name () << " * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::BoundedSequence& s) +{ + os << s.scoped_name () << " * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::UnboundedSequence& s) +{ + os << s.scoped_name () << " * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::Interface& i) +{ + os << i.scoped_name () << "_ptr " << STRS[EXTRACT] << " = " + << i.scoped_name () << "::_nil ();"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::ValueType& v) +{ + os << v.scoped_name () << " * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::EventType& e) +{ + os << e.scoped_name () << " * " << STRS[EXTRACT] << " = 0;"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::Component& c) +{ + os << c.scoped_name () << "_ptr " << STRS[EXTRACT] << " = " + << c.scoped_name () << "::_nil ();"; +} + +void +ExtractedTypeDeclEmitter::traverse (SemanticGraph::Home& h) +{ + os << h.scoped_name () << "_ptr " << STRS[EXTRACT] << " = " + << h.scoped_name () << "::_nil ();"; +} + +// ==================================================================== + +AssignFromExtractedEmitter::AssignFromExtractedEmitter (Context& c) + : CorbaTypeNameEmitter (c) +{ +} + +void +AssignFromExtractedEmitter::traverse (Boolean&) +{ + os << STRS[EXTRACT] << ".ref_"; +} + +void +AssignFromExtractedEmitter::traverse (Octet&) +{ + os << STRS[EXTRACT] << ".ref_"; +} + +void +AssignFromExtractedEmitter::traverse (Char&) +{ + os << STRS[EXTRACT] << ".ref_"; +} + +void +AssignFromExtractedEmitter::traverse (Wchar&) +{ + os << STRS[EXTRACT] << ".ref_"; +} + +void +AssignFromExtractedEmitter::traverse (Short&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (UnsignedShort&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (Long&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (UnsignedLong&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (LongLong&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (UnsignedLongLong&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (Float&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (Double&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (String&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::BoundedString&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (Wstring&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::BoundedWideString&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (Object&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (ValueBase&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (Any&) +{ + os << "*" << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::Array&) +{ + os << STRS[EXTRACT] << ".in ()"; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::Enum&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::Struct& s) +{ + // This should always be in the context, since the SizeTypeCalculator + // is executed before the servant code generators. + bool var_size = s.context ().get (STRS[VAR_SIZE]); + + if (!var_size) + { + os << "*"; + } + + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::Union& u) +{ + // This should always be in the context, since the SizeTypeCalculator + // is executed before the servant code generators. + bool var_size = u.context ().get (STRS[VAR_SIZE]); + + if (!var_size) + { + os << "*"; + } + + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::BoundedSequence&) +{ + os << "*" << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::UnboundedSequence&) +{ + os << "*" << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::Interface&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::ValueType&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::EventType&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::Component&) +{ + os << STRS[EXTRACT]; +} + +void +AssignFromExtractedEmitter::traverse (SemanticGraph::Home&) +{ + os << STRS[EXTRACT]; +} + +// ==================================================================== + +SetAttributeDelegationEmitter::SetAttributeDelegationEmitter ( + Context& c, + SemanticGraph::ReadWriteAttribute& a + ) + : CorbaTypeNameEmitter (c), + attr_ (a) + , assign_emitter_ (c) + , extract_emitter_ (c) +{ + assign_belongs_.node_traverser (assign_emitter_); + extract_belongs_.node_traverser (extract_emitter_); +} + +void +SetAttributeDelegationEmitter::traverse (Boolean&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (Octet&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (Char&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (Wchar&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (Short&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (UnsignedShort&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (Long&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (UnsignedLong&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (LongLong&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (UnsignedLongLong&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (Float&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (Double&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (String&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::BoundedString&) +{ + emit_error ("bounded string"); +} + +void +SetAttributeDelegationEmitter::traverse (Wstring&) +{ + emit_error ("wstring"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::BoundedWideString&) +{ + emit_error ("bounded wstring"); +} + +void +SetAttributeDelegationEmitter::traverse (Object&) +{ + emit_error ("CORBA::Object"); +} + +void +SetAttributeDelegationEmitter::traverse (ValueBase&) +{ + emit_error ("CORBA::ValueBase"); +} + +void +SetAttributeDelegationEmitter::traverse (Any&) +{ + emit_error ("CORBA::Any"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::Array&) +{ + emit_error ("array"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::Enum&) +{ + emit_delegation (); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::Struct&) +{ + emit_error ("struct"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::Union&) +{ + emit_error ("union"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::BoundedSequence&) +{ + emit_error ("bounded sequence"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::UnboundedSequence&) +{ + emit_error ("unbounded sequence"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::Interface&) +{ + emit_error ("interface"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::ValueType&) +{ + emit_error ("valuetype"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::EventType&) +{ + emit_error ("eventtype"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::Component&) +{ + emit_error ("component"); +} + +void +SetAttributeDelegationEmitter::traverse (SemanticGraph::Home&) +{ + emit_error ("home"); +} + +void +SetAttributeDelegationEmitter::emit_delegation (void) +{ + open_if_block (); + + Traversal::ReadWriteAttribute::belongs (attr_, extract_belongs_); + + os << "descr_value >>= " << STRS[EXTRACT] << ";" + << "this->" << attr_.name () << " ("; + + Traversal::ReadWriteAttribute::belongs (attr_, assign_belongs_); + + os << ");"; + + close_if_block (); +} + +void +SetAttributeDelegationEmitter::emit_error (const char *corba_kind) +{ + open_if_block (); + + os << "ACE_ERROR ((" << endl + << " LM_ERROR," << endl + << " \"Component attributes of " << corba_kind << "\"" << endl + << " \"IDL type are not yet supported by CIAO\\n\"" << endl + << " ));"; + + close_if_block (); +} + +void +SetAttributeDelegationEmitter::open_if_block (void) +{ + os << "if (ACE_OS::strcmp (descr_name, \"" + << attr_.name ().unescaped_str () << "\") == 0)" << endl + << "{"; +} + +void +SetAttributeDelegationEmitter::close_if_block (void) +{ + os << "continue;" + << "}"; +} diff --git a/modules/CIAO/CIDLC/CorbaTypeNameEmitters.hpp b/modules/CIAO/CIDLC/CorbaTypeNameEmitters.hpp new file mode 100644 index 00000000000..b0aa8ea7dd8 --- /dev/null +++ b/modules/CIAO/CIDLC/CorbaTypeNameEmitters.hpp @@ -0,0 +1,469 @@ +// file : CIDLC/FullTypeNameEmitter.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef TYPENAME_EMITTER_HPP +#define TYPENAME_EMITTER_HPP + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +#include "EmitterBase.hpp" + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +// Base class that holds the ostream member +// common to every other class in this file, +// and collects the ancestors in one place. +// +// Derived classes encapsulate the CORBA rules for +// the C++ mapping of different type kinds. +class CorbaTypeNameEmitter : public EmitterBase, + public Traversal::Void, + public Traversal::Boolean, + public Traversal::Octet, + public Traversal::Char, + public Traversal::Wchar, + public Traversal::Short, + public Traversal::UnsignedShort, + public Traversal::Long, + public Traversal::UnsignedLong, + public Traversal::LongLong, + public Traversal::UnsignedLongLong, + public Traversal::Float, + public Traversal::Double, + public Traversal::String, + public Traversal::BoundedString, + public Traversal::Wstring, + public Traversal::BoundedWideString, + public Traversal::Object, + public Traversal::ValueBase, + public Traversal::Any, + public Traversal::Array, + public Traversal::Enum, + public Traversal::Struct, + public Traversal::Union, + public Traversal::BoundedSequence, + public Traversal::UnboundedSequence, + public Traversal::Interface, + public Traversal::ValueType, + public Traversal::EventType, + public Traversal::Component, + public Traversal::Home +{ +public: + virtual void traverse (Void&); + virtual void traverse (Boolean&); + virtual void traverse (Octet&); + virtual void traverse (Char&); + virtual void traverse (Wchar&); + virtual void traverse (Short&); + virtual void traverse (UnsignedShort&); + virtual void traverse (Long&); + virtual void traverse (UnsignedLong&); + virtual void traverse (LongLong&); + virtual void traverse (UnsignedLongLong&); + virtual void traverse (Float&); + virtual void traverse (Double&); + virtual void traverse (String&); + virtual void traverse (SemanticGraph::BoundedString&); + virtual void traverse (Wstring&); + virtual void traverse (SemanticGraph::BoundedWideString&); + virtual void traverse (Object&); + virtual void traverse (ValueBase&); + virtual void traverse (Any&); + virtual void traverse (SemanticGraph::Array&); + virtual void traverse (SemanticGraph::Enum&); + virtual void traverse (SemanticGraph::Struct&); + virtual void traverse (SemanticGraph::Union&); + virtual void traverse (SemanticGraph::BoundedSequence&); + virtual void traverse (SemanticGraph::UnboundedSequence&); + virtual void traverse (SemanticGraph::Interface&); + virtual void traverse (SemanticGraph::ValueType&); + virtual void traverse (SemanticGraph::EventType&); + virtual void traverse (SemanticGraph::Component&); + virtual void traverse (SemanticGraph::Home&); + +protected: + CorbaTypeNameEmitter (Context&); +}; + +// Generates the name of an operation's return type. +// +// +class ReturnTypeNameEmitter : public CorbaTypeNameEmitter +{ +public: + ReturnTypeNameEmitter (Context&); + + virtual void traverse (Void&); + virtual void traverse (Boolean&); + virtual void traverse (Octet&); + virtual void traverse (Char&); + virtual void traverse (Wchar&); + virtual void traverse (Short&); + virtual void traverse (UnsignedShort&); + virtual void traverse (Long&); + virtual void traverse (UnsignedLong&); + virtual void traverse (LongLong&); + virtual void traverse (UnsignedLongLong&); + virtual void traverse (Float&); + virtual void traverse (Double&); + virtual void traverse (String&); + virtual void traverse (SemanticGraph::BoundedString&); + virtual void traverse (Wstring&); + virtual void traverse (SemanticGraph::BoundedWideString&); + virtual void traverse (Object&); + virtual void traverse (ValueBase&); + virtual void traverse (Any&); + virtual void traverse (SemanticGraph::Array&); + virtual void traverse (SemanticGraph::Enum&); + virtual void traverse (SemanticGraph::Struct&); + virtual void traverse (SemanticGraph::Union&); + virtual void traverse (SemanticGraph::BoundedSequence&); + virtual void traverse (SemanticGraph::UnboundedSequence&); + virtual void traverse (SemanticGraph::Interface&); + virtual void traverse (SemanticGraph::ValueType&); + virtual void traverse (SemanticGraph::EventType&); + virtual void traverse (SemanticGraph::Component&); + virtual void traverse (SemanticGraph::Home&); +}; + +// Generates the typename of an IN argument. +// +// +class INArgTypeNameEmitter : public CorbaTypeNameEmitter +{ +public: + INArgTypeNameEmitter (Context&); + + virtual void traverse (Boolean&); + virtual void traverse (Octet&); + virtual void traverse (Char&); + virtual void traverse (Wchar&); + virtual void traverse (Short&); + virtual void traverse (UnsignedShort&); + virtual void traverse (Long&); + virtual void traverse (UnsignedLong&); + virtual void traverse (LongLong&); + virtual void traverse (UnsignedLongLong&); + virtual void traverse (Float&); + virtual void traverse (Double&); + virtual void traverse (String&); + virtual void traverse (SemanticGraph::BoundedString&); + virtual void traverse (Wstring&); + virtual void traverse (SemanticGraph::BoundedWideString&); + virtual void traverse (Object&); + virtual void traverse (ValueBase&); + virtual void traverse (Any&); + virtual void traverse (SemanticGraph::Array&); + virtual void traverse (SemanticGraph::Enum&); + virtual void traverse (SemanticGraph::Struct&); + virtual void traverse (SemanticGraph::Union&); + virtual void traverse (SemanticGraph::BoundedSequence&); + virtual void traverse (SemanticGraph::UnboundedSequence&); + virtual void traverse (SemanticGraph::Interface&); + virtual void traverse (SemanticGraph::ValueType&); + virtual void traverse (SemanticGraph::EventType&); + virtual void traverse (SemanticGraph::Component&); + virtual void traverse (SemanticGraph::Home&); +}; + +// Generates the typename of an INOUT argument. +// +// +class INOUTArgTypeNameEmitter : public CorbaTypeNameEmitter +{ +public: + INOUTArgTypeNameEmitter (Context&); + + virtual void traverse (Boolean&); + virtual void traverse (Octet&); + virtual void traverse (Char&); + virtual void traverse (Wchar&); + virtual void traverse (Short&); + virtual void traverse (UnsignedShort&); + virtual void traverse (Long&); + virtual void traverse (UnsignedLong&); + virtual void traverse (LongLong&); + virtual void traverse (UnsignedLongLong&); + virtual void traverse (Float&); + virtual void traverse (Double&); + virtual void traverse (String&); + virtual void traverse (SemanticGraph::BoundedString&); + virtual void traverse (Wstring&); + virtual void traverse (SemanticGraph::BoundedWideString&); + virtual void traverse (Object&); + virtual void traverse (ValueBase&); + virtual void traverse (Any&); + virtual void traverse (SemanticGraph::Array&); + virtual void traverse (SemanticGraph::Enum&); + virtual void traverse (SemanticGraph::Struct&); + virtual void traverse (SemanticGraph::Union&); + virtual void traverse (SemanticGraph::BoundedSequence&); + virtual void traverse (SemanticGraph::UnboundedSequence&); + virtual void traverse (SemanticGraph::Interface&); + virtual void traverse (SemanticGraph::ValueType&); + virtual void traverse (SemanticGraph::EventType&); + virtual void traverse (SemanticGraph::Component&); + virtual void traverse (SemanticGraph::Home&); +}; + +// Generates the typename of an OUT argument. +// +// +class OUTArgTypeNameEmitter : public CorbaTypeNameEmitter +{ +public: + OUTArgTypeNameEmitter (Context&); + + virtual void traverse (Boolean&); + virtual void traverse (Octet&); + virtual void traverse (Char&); + virtual void traverse (Wchar&); + virtual void traverse (Short&); + virtual void traverse (UnsignedShort&); + virtual void traverse (Long&); + virtual void traverse (UnsignedLong&); + virtual void traverse (LongLong&); + virtual void traverse (UnsignedLongLong&); + virtual void traverse (Float&); + virtual void traverse (Double&); + virtual void traverse (String&); + virtual void traverse (SemanticGraph::BoundedString&); + virtual void traverse (Wstring&); + virtual void traverse (SemanticGraph::BoundedWideString&); + virtual void traverse (Object&); + virtual void traverse (ValueBase&); + virtual void traverse (Any&); + virtual void traverse (SemanticGraph::Array&); + virtual void traverse (SemanticGraph::Enum&); + virtual void traverse (SemanticGraph::Struct&); + virtual void traverse (SemanticGraph::Union&); + virtual void traverse (SemanticGraph::BoundedSequence&); + virtual void traverse (SemanticGraph::UnboundedSequence&); + virtual void traverse (SemanticGraph::Interface&); + virtual void traverse (SemanticGraph::ValueType&); + virtual void traverse (SemanticGraph::EventType&); + virtual void traverse (SemanticGraph::Component&); + virtual void traverse (SemanticGraph::Home&); +}; + +// Generates 'return' plus the appropriate NULL return value, +// including no output for Void. +// +// +class NullReturnEmitter : public CorbaTypeNameEmitter +{ +public: + NullReturnEmitter (Context&); + + virtual void traverse (Boolean&); + virtual void traverse (Octet&); + virtual void traverse (Char&); + virtual void traverse (Wchar&); + virtual void traverse (Short&); + virtual void traverse (UnsignedShort&); + virtual void traverse (Long&); + virtual void traverse (UnsignedLong&); + virtual void traverse (LongLong&); + virtual void traverse (UnsignedLongLong&); + virtual void traverse (Float&); + virtual void traverse (Double&); + virtual void traverse (String&); + virtual void traverse (SemanticGraph::BoundedString&); + virtual void traverse (Wstring&); + virtual void traverse (SemanticGraph::BoundedWideString&); + virtual void traverse (Object&); + virtual void traverse (ValueBase&); + virtual void traverse (Any&); + virtual void traverse (SemanticGraph::Array&); + virtual void traverse (SemanticGraph::Enum&); + virtual void traverse (SemanticGraph::Struct&); + virtual void traverse (SemanticGraph::Union&); + virtual void traverse (SemanticGraph::BoundedSequence&); + virtual void traverse (SemanticGraph::UnboundedSequence&); + virtual void traverse (SemanticGraph::Interface&); + virtual void traverse (SemanticGraph::ValueType&); + virtual void traverse (SemanticGraph::EventType&); + virtual void traverse (SemanticGraph::Component&); + virtual void traverse (SemanticGraph::Home&); +}; + +/* Not currently used, but it was at one time and may be useful again. + +// Generates the appropriate NULL value, including the assignment operator, +// if needed, for the rhs of an assignment statement. +// +// +class NullRHSEmitter : public CorbaTypeNameEmitter +{ +public: + NullRHSEmitter (Context&); + + virtual void traverse (Boolean&); + virtual void traverse (Octet&); + virtual void traverse (Char&); + virtual void traverse (Wchar&); + virtual void traverse (Short&); + virtual void traverse (UnsignedShort&); + virtual void traverse (Long&); + virtual void traverse (UnsignedLong&); + virtual void traverse (LongLong&); + virtual void traverse (UnsignedLongLong&); + virtual void traverse (Float&); + virtual void traverse (Double&); + virtual void traverse (String&); + virtual void traverse (SemanticGraph::BoundedString&); + virtual void traverse (Wstring&); + virtual void traverse (SemanticGraph::BoundedWideString&); + virtual void traverse (Object&); + virtual void traverse (ValueBase&); + virtual void traverse (Any&); + virtual void traverse (SemanticGraph::Array&); + virtual void traverse (SemanticGraph::Enum&); + virtual void traverse (SemanticGraph::Struct&); + virtual void traverse (SemanticGraph::Union&); + virtual void traverse (SemanticGraph::BoundedSequence&); + virtual void traverse (SemanticGraph::UnboundedSequence&); + virtual void traverse (SemanticGraph::Interface&); + virtual void traverse (SemanticGraph::ValueType&); + virtual void traverse (SemanticGraph::EventType&); + virtual void traverse (SemanticGraph::Component&); + virtual void traverse (SemanticGraph::Home&); +}; +*/ +// Declares and initializes a variable to use for any extraction. +// +// +class ExtractedTypeDeclEmitter : public CorbaTypeNameEmitter +{ +public: + ExtractedTypeDeclEmitter (Context&); + + virtual void traverse (Boolean&); + virtual void traverse (Octet&); + virtual void traverse (Char&); + virtual void traverse (Wchar&); + virtual void traverse (Short&); + virtual void traverse (UnsignedShort&); + virtual void traverse (Long&); + virtual void traverse (UnsignedLong&); + virtual void traverse (LongLong&); + virtual void traverse (UnsignedLongLong&); + virtual void traverse (Float&); + virtual void traverse (Double&); + virtual void traverse (String&); + virtual void traverse (SemanticGraph::BoundedString&); + virtual void traverse (Wstring&); + virtual void traverse (SemanticGraph::BoundedWideString&); + virtual void traverse (Object&); + virtual void traverse (ValueBase&); + virtual void traverse (Any&); + virtual void traverse (SemanticGraph::Array&); + virtual void traverse (SemanticGraph::Enum&); + virtual void traverse (SemanticGraph::Struct&); + virtual void traverse (SemanticGraph::Union&); + virtual void traverse (SemanticGraph::BoundedSequence&); + virtual void traverse (SemanticGraph::UnboundedSequence&); + virtual void traverse (SemanticGraph::Interface&); + virtual void traverse (SemanticGraph::ValueType&); + virtual void traverse (SemanticGraph::EventType&); + virtual void traverse (SemanticGraph::Component&); + virtual void traverse (SemanticGraph::Home&); +}; + +// Declares and initializes a variable to use for any extraction. +// +// +class AssignFromExtractedEmitter : public CorbaTypeNameEmitter +{ +public: + AssignFromExtractedEmitter (Context&); + + virtual void traverse (Boolean&); + virtual void traverse (Octet&); + virtual void traverse (Char&); + virtual void traverse (Wchar&); + virtual void traverse (Short&); + virtual void traverse (UnsignedShort&); + virtual void traverse (Long&); + virtual void traverse (UnsignedLong&); + virtual void traverse (LongLong&); + virtual void traverse (UnsignedLongLong&); + virtual void traverse (Float&); + virtual void traverse (Double&); + virtual void traverse (String&); + virtual void traverse (SemanticGraph::BoundedString&); + virtual void traverse (Wstring&); + virtual void traverse (SemanticGraph::BoundedWideString&); + virtual void traverse (Object&); + virtual void traverse (ValueBase&); + virtual void traverse (Any&); + virtual void traverse (SemanticGraph::Array&); + virtual void traverse (SemanticGraph::Enum&); + virtual void traverse (SemanticGraph::Struct&); + virtual void traverse (SemanticGraph::Union&); + virtual void traverse (SemanticGraph::BoundedSequence&); + virtual void traverse (SemanticGraph::UnboundedSequence&); + virtual void traverse (SemanticGraph::Interface&); + virtual void traverse (SemanticGraph::ValueType&); + virtual void traverse (SemanticGraph::EventType&); + virtual void traverse (SemanticGraph::Component&); + virtual void traverse (SemanticGraph::Home&); +}; + +class SetAttributeDelegationEmitter : public CorbaTypeNameEmitter, + public Traversal::ReadWriteAttribute +{ +public: + SetAttributeDelegationEmitter (Context&, + SemanticGraph::ReadWriteAttribute&); + + virtual void traverse (Boolean&); + virtual void traverse (Octet&); + virtual void traverse (Char&); + virtual void traverse (Wchar&); + virtual void traverse (Short&); + virtual void traverse (UnsignedShort&); + virtual void traverse (Long&); + virtual void traverse (UnsignedLong&); + virtual void traverse (LongLong&); + virtual void traverse (UnsignedLongLong&); + virtual void traverse (Float&); + virtual void traverse (Double&); + virtual void traverse (String&); + virtual void traverse (SemanticGraph::BoundedString&); + virtual void traverse (Wstring&); + virtual void traverse (SemanticGraph::BoundedWideString&); + virtual void traverse (Object&); + virtual void traverse (ValueBase&); + virtual void traverse (Any&); + virtual void traverse (SemanticGraph::Array&); + virtual void traverse (SemanticGraph::Enum&); + virtual void traverse (SemanticGraph::Struct&); + virtual void traverse (SemanticGraph::Union&); + virtual void traverse (SemanticGraph::BoundedSequence&); + virtual void traverse (SemanticGraph::UnboundedSequence&); + virtual void traverse (SemanticGraph::Interface&); + virtual void traverse (SemanticGraph::ValueType&); + virtual void traverse (SemanticGraph::EventType&); + virtual void traverse (SemanticGraph::Component&); + virtual void traverse (SemanticGraph::Home&); + +private: + void emit_delegation (void); + void emit_error (const char *); + void open_if_block (void); + void close_if_block (void); + +private: + SemanticGraph::ReadWriteAttribute& attr_; + AssignFromExtractedEmitter assign_emitter_; + ExtractedTypeDeclEmitter extract_emitter_; + Traversal::Belongs assign_belongs_; + Traversal::Belongs extract_belongs_; +}; + +#endif /* TYPENAME_EMITTER_HPP */ diff --git a/modules/CIAO/CIDLC/CxxNamePrinter.cpp b/modules/CIAO/CIDLC/CxxNamePrinter.cpp new file mode 100644 index 00000000000..027889791ec --- /dev/null +++ b/modules/CIAO/CIDLC/CxxNamePrinter.cpp @@ -0,0 +1,103 @@ +// file : CIDLC/CxxNamePrinter.cpp +// author : Boris Kolpackov +// cvs-id : $Id: Collectors.hpp 55138 2004-01-05 07:53:05Z parsons $ + +#include "CIDLC/CxxNamePrinter.hpp" + +#include +#include + +namespace +{ + // Sorted C++ keywords. + // + char* keywords[] = { + "and", + "asm", + "auto", + "bitand", + "bitor", + "bool", + "break", + "case", + "catch", + "char", + "class", + "compl", + "const", + "const_cast", + "continue", + "default", + "delete", + "do", + "double", + "dynamic_cast", + "else", + "end_eq", + "enum", + "explicit", + "export", + "extern", + "false", + "float", + "for", + "friend", + "goto", + "if", + "inline", + "int", + "long", + "mutable", + "namespace", + "new", + "not", + "not_eq", + "operator", + "or", + "or_eq", + "private", + "protected", + "public", + "register", + "reinterpret_cast", + "return", + "short", + "signed", + "sizeof", + "static", + "static_cast", + "struct", + "switch", + "template", + "this", + "throw", + "true", + "try", + "typedef", + "typeid", + "typename", + "union", + "unsigned", + "using", + "virtual", + "void", + "volatile", + "wchar_t", + "while", + "xor", + "xor_eq" + }; +} + +void CxxNamePrinter:: +print (std::ostream& os, CCF::IDL2::SemanticGraph::SimpleName const& n) +{ + std::size_t const size (sizeof (keywords) / sizeof (char*)); + std::string const& str (n.unescaped_str ()); + + if (std::binary_search (keywords, keywords + size, str)) + os << "_cxx_"; + + os << str; +} + diff --git a/modules/CIAO/CIDLC/CxxNamePrinter.hpp b/modules/CIAO/CIDLC/CxxNamePrinter.hpp new file mode 100644 index 00000000000..417dfa16a9f --- /dev/null +++ b/modules/CIAO/CIDLC/CxxNamePrinter.hpp @@ -0,0 +1,18 @@ +// file : CIDLC/CxxNamePrinter.hpp +// author : Boris Kolpackov +// cvs-id : $Id: Collectors.hpp 55138 2004-01-05 07:53:05Z parsons $ + +#ifndef CXX_NAME_PRINTER_HPP +#define CXX_NAME_PRINTER_HPP + +#include "CCF/IDL2/SemanticGraph/Name.hpp" + +// Prints names while escaping C++ keywords with the _cxx_ prefix. +// +struct CxxNamePrinter: CCF::IDL2::SemanticGraph::NamePrinter +{ + virtual void + print (std::ostream&, CCF::IDL2::SemanticGraph::SimpleName const&); +}; + +#endif // CXX_NAME_PRINTER_HPP diff --git a/modules/CIAO/CIDLC/DescriptorGenerator.cpp b/modules/CIAO/CIDLC/DescriptorGenerator.cpp new file mode 100644 index 00000000000..76a5a810774 --- /dev/null +++ b/modules/CIAO/CIDLC/DescriptorGenerator.cpp @@ -0,0 +1,582 @@ +// $Id$ + +#include "DescriptorGenerator.hpp" +#include "UnescapedNamePrinter.hpp" +#include "Literals.hpp" + +#include + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +#include "CCF/CodeGenerationKit/Regex.hpp" +#include "CCF/CodeGenerationKit/IndentationXML.hpp" +#include "CCF/CodeGenerationKit/IndentationImplanter.hpp" + +using std::cout; +using std::endl; +using std::string; + +using namespace StringLiterals; +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +namespace +{ + class EmitterBase + { + public: + EmitterBase (fs::ofstream& ofs) + : os (ofs) + {} + + protected: + fs::ofstream& os; + }; + + class CompositionEmitter : public EmitterBase, + public Traversal::Composition + { + // Nested classes for emitters created and dispatched inside + // ComponsitionEmitter::traverse(). + private: + struct ComponentIdEmitter : Traversal::Component, EmitterBase + { + ComponentIdEmitter (fs::ofstream& ofs) + : EmitterBase (ofs) + {} + + virtual void + traverse (Type& c) + { + os << " (STRS[REPO_ID]) + << "\"/>" + << endl; + } + }; + + struct HomeIdEmitter : Traversal::Home, EmitterBase + { + HomeIdEmitter (fs::ofstream& ofs) + : EmitterBase (ofs) + {} + + virtual void + traverse (Type& h) + { + os << " (STRS[REPO_ID]) + << "\"/>" + << endl; + } + }; + + struct HomeFeaturesEmitter : Traversal::Home, EmitterBase + { + HomeFeaturesEmitter (fs::ofstream& ofs) + : EmitterBase (ofs) + {} + + virtual void + traverse (Type& h) + { + os << " (STRS[REPO_ID]) + << "\">" << endl; + + Traversal::Inherits home_inherits; + HomeInheritanceEmitter emitter (os); + home_inherits.node_traverser (emitter); + + inherits (h, home_inherits); + + os << "" << endl << endl; + + // Go after inherited homes. + // + Traversal::Home::traverse (h); + } + + struct HomeInheritanceEmitter : Traversal::Home, EmitterBase + { + HomeInheritanceEmitter (fs::ofstream& ofs) + : EmitterBase (ofs) + {} + + virtual void + traverse (Type& h) + { + os << " (STRS[REPO_ID]) + << "\"/>" + << endl; + } + }; + }; + + struct ComponentFeaturesEmitter : Traversal::Component, EmitterBase + { + ComponentFeaturesEmitter (fs::ofstream& ofs) + : EmitterBase (ofs) + {} + + virtual void + traverse (Type& c) + { + os << " (STRS[REPO_ID]) + << "\">" << endl; + + Traversal::Inherits component_inherits; + Traversal::Supports component_supports; + ComponentInheritanceEmitter i_emitter (os); + ComponentSupportsEmitter s_emitter (os); + component_inherits.node_traverser (i_emitter); + component_supports.node_traverser (s_emitter); + + inherits (c, component_inherits); + supports (c, component_supports); + + os << "" << endl; + + Traversal::Defines defines; + PortsEmitter ports_emitter (os); + defines.node_traverser (ports_emitter); + + names (c, defines); + + os << "" << endl; + + os << "" << endl << endl; + + // Go after inherited components. + // + Traversal::Component::traverse (c); + } + + struct ComponentInheritanceEmitter : Traversal::Component, EmitterBase + { + ComponentInheritanceEmitter (fs::ofstream& ofs) + : EmitterBase (ofs) + {} + + virtual void + traverse (Type& c) + { + os << " (STRS[REPO_ID]) + << "\"/>" + << endl; + } + }; + + struct ComponentSupportsEmitter : Traversal::Interface, EmitterBase + { + ComponentSupportsEmitter (fs::ofstream& ofs) + : EmitterBase (ofs) + {} + + virtual void + traverse (Type& i) + { + os << " (STRS[REPO_ID]) + << "\"/>" + << endl; + } + }; + + struct PortsEmitter : Traversal::EmitterData, + Traversal::UserData, + Traversal::ProviderData, + Traversal::ConsumerData, + Traversal::PublisherData, + EmitterBase + { + PortsEmitter (fs::ofstream& ofs) + : EmitterBase (ofs), + type_name_emitter_ (ofs), + facettag_ (1U) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::Emitter& e) + { + os << "" << endl + << "" << endl + << "" << endl; + } + + virtual void + traverse (SemanticGraph::User& u) + { + os << "" << endl + << "" << endl; + } + + virtual void + traverse (SemanticGraph::Provider& p) + { + os << "" << endl + << "" << endl; + + ++facettag_; + } + + virtual void + traverse (SemanticGraph::Consumer& c) + { + os << "" << endl + << "" << endl + << "" << endl; + } + + virtual void + traverse (SemanticGraph::Publisher& p) + { + os << "" << endl + << "" << endl + << "" << endl; + } + + struct FullTypeNameEmitter : Traversal::Type, EmitterBase + { + FullTypeNameEmitter (fs::ofstream& ofs) + : EmitterBase (ofs) + {} + + virtual void + traverse (SemanticGraph::Type& t) + { + os << '\"' + << t.context ().get (STRS[REPO_ID]) + << '\"'; + } + }; + + private: + FullTypeNameEmitter type_name_emitter_; + unsigned long facettag_; + Traversal::Belongs belongs_; + }; + }; + + struct InterfaceEmitter : Traversal::UnconstrainedInterface, + EmitterBase + { + InterfaceEmitter (fs::ofstream& ofs) + : EmitterBase (ofs) + {} + + bool + add (UnconstrainedInterface& i) + { + return interfaces_.insert (&i).second; + } + + virtual void + traverse (UnconstrainedInterface& i) + { + if (add (i)) + { + os << " (STRS[REPO_ID]) + << "\">" << endl; + + Traversal::Inherits interface_inherits; + InterfaceInheritanceEmitter i_emitter (os); + interface_inherits.node_traverser (i_emitter); + + inherits (i, interface_inherits); + + os << "" << endl << endl; + + // Go after inherited interfaces. + Traversal::UnconstrainedInterface::traverse (i); + } + } + + struct InterfaceInheritanceEmitter : Traversal::Interface, EmitterBase + { + InterfaceInheritanceEmitter (fs::ofstream& ofs) + : EmitterBase (ofs) + {} + + virtual void + traverse (Type& i) + { + os << " (STRS[REPO_ID]) + << "\"/>" << endl; + } + }; + + private: + std::set interfaces_; + }; + + public: + CompositionEmitter (fs::ofstream& ofs, + CommandLine const& cl) + : EmitterBase (ofs), + cl_ (cl) + {} + + virtual void + traverse (Composition& c) + { + ScopedName scoped (c.scoped_name ()); + Name stripped (scoped.begin () + 1, scoped.end ()); + string name (stripped.unescaped_str ()); + configure_stream (name); + + os << "" << endl + << "" + << endl << endl; + + os << "" << endl + << "3.0" << endl; + + { + ComponentIdEmitter component_id_emitter (os); + HomeIdEmitter home_id_emitter (os); + Traversal::Defines defines; + Traversal::ComponentExecutor component_executor; + Traversal::HomeExecutor home_executor; + defines.node_traverser (component_executor); + defines.node_traverser (home_executor); + Traversal::Implements implements; + component_executor.edge_traverser (implements); + home_executor.edge_traverser (implements); + implements.node_traverser (component_id_emitter); + implements.node_traverser (home_id_emitter); + + names (c, defines); + } + + os << "" << endl + << "" << endl + << "" << endl + << "" << endl + << "" << endl + << "" << endl + << "" << endl << endl; + + { + HomeFeaturesEmitter home_features_emitter (os); + Traversal::Defines defines; + Traversal::HomeExecutor home_executor; + defines.node_traverser (home_executor); + Traversal::Implements implements; + home_executor.edge_traverser (implements); + implements.node_traverser (home_features_emitter); + + Traversal::Inherits inherits; + home_features_emitter.edge_traverser (inherits); + inherits.node_traverser (home_features_emitter); + + names (c, defines); + } + + { + ComponentFeaturesEmitter component_features_emitter (os); + Traversal::Defines defines; + Traversal::ComponentExecutor component_executor; + defines.node_traverser (component_executor); + Traversal::Implements implements; + component_executor.edge_traverser (implements); + implements.node_traverser (component_features_emitter); + + Traversal::Inherits inherits; + component_features_emitter.edge_traverser (inherits); + inherits.node_traverser (component_features_emitter); + + names (c, defines); + } + + { + Traversal::Component component; + Traversal::Home home; + Traversal::Defines defines; + Traversal::ComponentExecutor component_executor; + Traversal::HomeExecutor home_executor; + defines.node_traverser (component_executor); + defines.node_traverser (home_executor); + Traversal::Implements implements; + component_executor.edge_traverser (implements); + home_executor.edge_traverser (implements); + implements.node_traverser (component); + implements.node_traverser (home); + + Traversal::Supports supports; + InterfaceEmitter interface_emitter (os); + supports.node_traverser (interface_emitter); + component.edge_traverser (supports); + home.edge_traverser (supports); + + Traversal::Defines component_defines; + component.edge_traverser (component_defines); + Traversal::Provider provider; + Traversal::User user; + component_defines.node_traverser (provider); + component_defines.node_traverser (user); + Traversal::Belongs belongs; + belongs.node_traverser (interface_emitter); + provider.edge_traverser (belongs); + user.edge_traverser (belongs); + + Traversal::Inherits inherits; + inherits.node_traverser (interface_emitter); + interface_emitter.edge_traverser (inherits); + + names (c, defines); + } + + os << "" << endl; + } + + private: + void configure_stream (string const& scoped_name) + { + string file_suffix = cl_.get_value ("desc-file-suffix", + ".ccd"); + + string desc_file_name = regex::perl_s (scoped_name, "/::/_/"); + + desc_file_name += file_suffix; + + fs::path desc_file_path (desc_file_name); + + if (os.is_open ()) + { + os.close (); + } + + os.open (desc_file_path, std::ios_base::out); + + if (!os.is_open ()) + { + cerr << desc_file_name + << ": error: unable to open file in write mode" + << endl; + } + } + + private: + CommandLine const& cl_; + }; +} + +// ========================================================== + +void +DescriptorGenerator::options (CL::Description& d) +{ + d.add_option (CL::OptionDescription ( + "desc-file-suffix", + "suffix", + "Use provided suffix instead of default \'.ccd\' " + "when constructing name of descriptor file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "desc-file-regex", + "regex", + "Use provided regular expression when constructing " + "name of descriptor file.", + CL::OptionType::value)); +} + +void +DescriptorGenerator::generate (CommandLine const& cl, + TranslationUnit& u) +{ + // Set auto-indentation for os. + // + Indentation::Implanter guard (ofs_); + + // Set unescaped name printer for os. + // + UnescapedNamePrinter name_printer; + ofs_.pword (name_printer_index) = &name_printer; + + // + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion region; + contains_principal.node_traverser (region); + + // Layer 2 + // + Traversal::ContainsRoot contains_root; + Traversal::Includes includes; + + region.edge_traverser (includes); + region.edge_traverser (contains_root); + + //-- + Traversal::Root root; + includes.node_traverser (region); + contains_root.node_traverser (root); + + // Layer 3 + // + Traversal::Defines defines; + root.edge_traverser (defines); + + //-- + Traversal::Module module; + CompositionEmitter composition (ofs_, cl); + defines.node_traverser (module); + defines.node_traverser (composition); + + unit.traverse (u); +} diff --git a/modules/CIAO/CIDLC/DescriptorGenerator.hpp b/modules/CIAO/CIDLC/DescriptorGenerator.hpp new file mode 100644 index 00000000000..e481c38e7d9 --- /dev/null +++ b/modules/CIAO/CIDLC/DescriptorGenerator.hpp @@ -0,0 +1,35 @@ +// file : CIDLC/DescriptorGenerator.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef DESCRIPTOR_GENERATOR_HPP +#define DESCRIPTOR_GENERATOR_HPP + +#include "CCF/CodeGenerationKit/CommandLine.hpp" +#include "CCF/CodeGenerationKit/CommandLineDescriptor.hpp" + +#include "CCF/CIDL/SemanticGraph.hpp" + +class DescriptorGenerator +{ +public: + static void + options (CL::Description& d); + + void + generate (CommandLine const&, + CCF::CIDL::SemanticGraph::TranslationUnit&); + +private: + fs::ofstream ofs_; +}; + + +#endif // DESCRIPTOR_GENERATOR_HPP + +/* + * Local Variables: + * mode: C++ + * c-basic-offset: 2 + * End: + */ diff --git a/modules/CIAO/CIDLC/EmitterBase.cpp b/modules/CIAO/CIDLC/EmitterBase.cpp new file mode 100644 index 00000000000..418db97852a --- /dev/null +++ b/modules/CIAO/CIDLC/EmitterBase.cpp @@ -0,0 +1,11 @@ +// file : CIDLC/EmitterBase.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "EmitterBase.hpp" + +EmitterBase::EmitterBase (Context& c) + : ctx (c), + os (ctx.os ()) +{ +} diff --git a/modules/CIAO/CIDLC/EmitterBase.hpp b/modules/CIAO/CIDLC/EmitterBase.hpp new file mode 100644 index 00000000000..407eee8d0e0 --- /dev/null +++ b/modules/CIAO/CIDLC/EmitterBase.hpp @@ -0,0 +1,20 @@ +// file : CIDLC/EmitterBase.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef EMITTERBASE_HPP +#define EMITTERBASE_HPP + +#include "EmitterContext.hpp" + +class EmitterBase +{ +public: + EmitterBase (Context&); + +protected: + Context& ctx; + ostream& os; +}; + +#endif // EMITTERBASE_HPP diff --git a/modules/CIAO/CIDLC/EmitterContext.cpp b/modules/CIAO/CIDLC/EmitterContext.cpp new file mode 100644 index 00000000000..478ae5d0027 --- /dev/null +++ b/modules/CIAO/CIDLC/EmitterContext.cpp @@ -0,0 +1,45 @@ +// file : CIDLC/EmitterContext.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "EmitterContext.hpp" + +Context::Context (ostream& os, + string export_macro, + CommandLine const& cl) + : os_ (os), + export_macro_ (export_macro), + cl_ (cl) +{ +} + +ostream& +Context::os (void) +{ + return os_; +} + +string +Context::export_macro (void) +{ + return export_macro_; +} + +CommandLine const& +Context::cl (void) +{ + return cl_; +} + +string +Context::composition_name (void) +{ + return composition_name_; +} + +void +Context::composition_name (const string& name) +{ + composition_name_ = name; +} + diff --git a/modules/CIAO/CIDLC/EmitterContext.hpp b/modules/CIAO/CIDLC/EmitterContext.hpp new file mode 100644 index 00000000000..bec5e74f91d --- /dev/null +++ b/modules/CIAO/CIDLC/EmitterContext.hpp @@ -0,0 +1,35 @@ +// file : CIDLC/EmitterContext.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef EMITTERCONTEXT_HPP +#define EMITTERCONTEXT_HPP + +#include "CCF/CodeGenerationKit/CommandLine.hpp" + +#include +#include + +using namespace std; + +class Context +{ +public: + Context (ostream& os, + string export_macro, + CommandLine const& cl); + + ostream& os (void); + string export_macro (void); + CommandLine const& cl (void); + string composition_name (void); + void composition_name (const string& name); + +private: + ostream& os_; + string export_macro_; + CommandLine const& cl_; + string composition_name_; +}; + +#endif // EMITTERCONTEXT_HPP diff --git a/modules/CIAO/CIDLC/ExecImplGenerator.cpp b/modules/CIAO/CIDLC/ExecImplGenerator.cpp new file mode 100644 index 00000000000..26f0d1c8ede --- /dev/null +++ b/modules/CIAO/CIDLC/ExecImplGenerator.cpp @@ -0,0 +1,201 @@ +// file : CIDLC/ExecImplGenerator.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "ExecImplGenerator.hpp" +#include "ExecImplHeaderGenerator.hpp" +#include "ExecImplSourceGenerator.hpp" +#include "CxxNamePrinter.hpp" + +#include "CCF/CodeGenerationKit/Regex.hpp" +#include "CCF/CodeGenerationKit/IndentationCxx.hpp" +#include "CCF/CodeGenerationKit/IndentationImplanter.hpp" + +using namespace CCF; +using namespace CIDL; +using namespace SemanticGraph; +using namespace Traversal; + +using std::string; +using std::ostream; + +namespace +{ + // On some platforms toupper can be something else than a + // function. + int + upcase (int c) + { + return toupper (c); + } +} + +ExecImplGenerator::ExecImplGenerator (CommandLine const& cl) + : cl_ (cl), + file_name_ (""), + export_macro_ ("") +{ +} + +void ExecImplGenerator::options (CL::Description& d) +{ + d.add_option (CL::OptionDescription ( + "exec-hdr-file-suffix", + "suffix", + "Use provided suffix instead of default \'_exec.h\' " + "when constructing name of executor implementation file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "exec-hdr-file-regex", + "regex", + "Use provided regular expression when constructing " + "name of executor implementation file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "exec-src-file-suffix", + "suffix", + "Use provided suffix instead of default \'_exec.cpp\' " + "when constructing name of executor implementation file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "exec-src-file-regex", + "regex", + "Use provided regular expression when constructing " + "name of executor implementation file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "exec-export-macro", + "macro", + "Replace default executor DLL export macro " + "with provided macro.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "exec-export-include", + "file", + "Replace default executor export include file " + "with provided file.", + CL::OptionType::value)); +} + + +void ExecImplGenerator::generate (SemanticGraph::TranslationUnit& u, + fs::path const& file) +{ + // Generate files + compute_export_macro (file); + + { + fs::ofstream hdr_ofs; + ostream& hdr_os = configure_stream ("exec-hdr-file-suffix", + "_exec.h", + "exec-hdr-file-regex", + hdr_ofs); + + Indentation::Implanter header_guard (hdr_os); + + // Set C++ name printer for os. + // + CxxNamePrinter name_printer; + hdr_os.pword (name_printer_index) = &name_printer; + + + ExecImplHeaderEmitter hdr_emitter (hdr_os, + cl_, + export_macro_, + file); + hdr_emitter.generate (u); + } + + { + fs::ofstream src_ofs; + ostream& src_os = configure_stream ("exec-src-file-suffix", + "_exec.cpp", + "exec-src-file-regex", + src_ofs); + + Indentation::Implanter header_guard (src_os); + + // Set C++ name printer for os. + // + CxxNamePrinter name_printer; + src_os.pword (name_printer_index) = &name_printer; + + ExecImplSourceEmitter src_emitter (src_os, + cl_, + export_macro_, + file); + src_emitter.generate (u); + } +} + +void +ExecImplGenerator::compute_export_macro (const fs::path& file_path) +{ + if (!file_path.empty ()) + { + file_name_ = file_path.leaf (); + } + + export_macro_ = cl_.get_value ("exec-export-macro", ""); + + if (export_macro_.empty () && !file_name_.empty ()) + { + // Modify a copy of the filename string. + export_macro_ = file_name_; + + + // Convert filename string to upper case. + transform (export_macro_.begin (), + export_macro_.end (), + export_macro_.begin (), + upcase); + + // Replace the suffix. + export_macro_ = + regex::perl_s (export_macro_, + "/^(.+?)(\\.(IDL|CIDL|CDL))?$/$1_EXEC_Export/"); + + // Replace any remaining '.' in the string with '_'. + export_macro_ = regex::perl_s (export_macro_, + "/\\./_/"); + } +} + +ostream& +ExecImplGenerator::configure_stream (string const& suffix_option, + string const& default_suffix, + string const& regex_option, + fs::ofstream& ofs) +{ + if (! file_name_.empty ()) + { + string file_suffix = cl_.get_value (suffix_option, + default_suffix); + string file_expr = + cl_.get_value (regex_option, + "/^(.+?)(\\.(idl|cidl|cdl))?$/$1" + file_suffix + "/"); + + string file_name = regex::perl_s (file_name_, file_expr); + + fs::path file_path (file_name); + + ofs.open (file_path, std::ios_base::out); + + if (!ofs.is_open ()) + { + cerr << file_name + << ": error: unable to open file in write mode" + << endl; + } + } + + return ofs.is_open () + ? static_cast (ofs) + : static_cast (std::cout); +} + diff --git a/modules/CIAO/CIDLC/ExecImplGenerator.hpp b/modules/CIAO/CIDLC/ExecImplGenerator.hpp new file mode 100644 index 00000000000..51536b3aaa3 --- /dev/null +++ b/modules/CIAO/CIDLC/ExecImplGenerator.hpp @@ -0,0 +1,44 @@ +// file : CIDLC/ExecImplGenerator.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef EXEC_IMPL_GENERATOR_HPP +#define EXEC_IMPL_GENERATOR_HPP + +#include "CCF/CodeGenerationKit/CommandLine.hpp" +#include "CCF/CodeGenerationKit/CommandLineDescriptor.hpp" + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +class ExecImplGenerator +{ +public: + static void + options (CL::Description& d); + + ExecImplGenerator (CommandLine const& cl); + + void + generate (CCF::CIDL::SemanticGraph::TranslationUnit&, + fs::path const& file); + +private: + void + compute_export_macro (const fs::path& file_path); + + std::ostream& + configure_stream (std::string const& suffix_option, + std::string const& default_suffix, + std::string const& regex_option, + fs::ofstream& ofs); + +private: + CommandLine const& cl_; + std::string file_name_; + std::string export_macro_; +}; + + +#endif // EXEC_IMPL_GENERATOR_HPP + diff --git a/modules/CIAO/CIDLC/ExecImplHeaderGenerator.cpp b/modules/CIAO/CIDLC/ExecImplHeaderGenerator.cpp new file mode 100644 index 00000000000..6ee4899a4df --- /dev/null +++ b/modules/CIAO/CIDLC/ExecImplHeaderGenerator.cpp @@ -0,0 +1,819 @@ +// file : CIDLC/ExecImplHeaderGenerator.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "ExecImplHeaderGenerator.hpp" +#include "CorbaTypeNameEmitters.hpp" +#include "UtilityTypeNameEmitters.hpp" +#include "AttributeHeaderEmitters.hpp" +#include "OperationHeaderEmitters.hpp" +#include "ParameterEmitter_T.hpp" +#include "CompositionEmitter.hpp" +#include "ModuleEmitter.hpp" +#include "InterfaceEmitter.hpp" +#include "Literals.hpp" +#include "Upcase.hpp" + +#include +#include + +#include "CCF/CodeGenerationKit/Regex.hpp" + +using std::endl; + +using namespace StringLiterals; +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +namespace +{ + struct FacetEmitter : Traversal::UnconstrainedInterface, + EmitterBase + { + FacetEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (UnconstrainedInterface& i) + { + if (i.context ().count ("facet_impl_hdr_gen")) return; + + os << "class " << ctx.export_macro () << " " + << i.name () << "_exec_i" << endl + << " : public virtual " << i.scoped_name ().scope_name () + << "::CCM_" << i.name () << "," << endl + << " public virtual TAO_Local_RefCounted_Object" << endl + << "{" + << "public:" << endl + << i.name () << "_exec_i (void);" + << "virtual ~" << i.name () << "_exec_i (void);" << endl + << "// Operations from " << i.scoped_name () << endl << endl; + + { + InterfaceEmitter interface_emitter (ctx); + + Traversal::Defines defines_; + Traversal::Inherits inherits_; + interface_emitter.edge_traverser (defines_); + interface_emitter.edge_traverser (inherits_); + + AttributeHeaderEmitter attribute_emitter (ctx); + defines_.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx); + defines_.node_traverser (operation_emitter); + inherits_.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + inherits (i, inherits_); + names (i, defines_); + } + + os << "};"; + + i.context ().set ("facet_impl_hdr_gen", true); + } + }; + + struct ExecPortsEmitter : Traversal::ConsumerData, + Traversal::ProviderData, + EmitterBase + { + ExecPortsEmitter (Context& c) + : EmitterBase (c), + enclosing_type_name_emitter_ (c), + simple_type_name_emitter_ (c), + type_name_emitter_ (c) + { + enclosing_belongs_.node_traverser (enclosing_type_name_emitter_); + simple_belongs_.node_traverser (simple_type_name_emitter_); + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::Provider& p) + { + os << "virtual "; + + Traversal::ProviderData::belongs (p, enclosing_belongs_); + + os << "::CCM_"; + + Traversal::ProviderData::belongs (p, simple_belongs_); + + os << "_ptr" << endl + << "get_" << p.name () << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + virtual void + traverse (SemanticGraph::Consumer& c) + { + os << "virtual void" << endl + << "push_" << c.name () << " (" << endl; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << " *ev" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + private: + EnclosingTypeNameEmitter enclosing_type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs enclosing_belongs_; + Traversal::Belongs simple_belongs_; + Traversal::Belongs belongs_; + }; + + struct ComponentExecImplEmitter : Traversal::Component, EmitterBase + { + ComponentExecImplEmitter (Context& c, ComponentExecutor& exec) + : EmitterBase (c), + exec_ (exec) + { + } + + virtual void + pre (Type& t) + { + // Generate the facet executor class(es) first. + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (component_inherits); + + Traversal::Provider provider; + defines.node_traverser (provider); + + Traversal::Belongs belongs; + provider.edge_traverser (belongs); + + FacetEmitter facet_emitter (ctx); + belongs.node_traverser (facet_emitter); + + component_emitter.traverse (t); + } + + os << "class " << ctx.export_macro () << " " + << t.name () << "_exec_i" << endl + << " : public virtual " << exec_.name () << "," << endl + << " public virtual TAO_Local_RefCounted_Object" << endl + << "{" + << "public:" << endl + << t.name () << "_exec_i (void);" + << "virtual ~" << t.name () << "_exec_i (void);" << endl; + + os << "// Supported or inherited operations." << endl << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Supports supports_; + component_emitter.edge_traverser (component_inherits); + component_emitter.edge_traverser (supports_); + InterfaceEmitter interface_emitter (ctx); + supports_.node_traverser (interface_emitter); + + Traversal::Defines defines; + Traversal::Inherits interface_inherits; + interface_emitter.edge_traverser (defines); + interface_emitter.edge_traverser (interface_inherits); + + AttributeHeaderEmitter attribute_emitter (ctx); + defines.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx); + defines.node_traverser (operation_emitter); + interface_inherits.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + component_emitter.traverse (t); + } + + os << "// Attribute operations." << endl << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + component_emitter.edge_traverser (component_inherits); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + + AttributeHeaderEmitter attribute_emitter (ctx); + defines.node_traverser (attribute_emitter); + + component_emitter.traverse (t); + } + + os << "// Port operations." << endl << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + component_emitter.edge_traverser (component_inherits); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + + ExecPortsEmitter exec_ports_emitter (ctx); + defines.node_traverser (exec_ports_emitter); + + component_emitter.traverse (t); + } + + os << "// Operations from Components::SessionComponent" << endl << endl; + + os << "virtual void" << endl + << "set_session_context (" << endl + << STRS[COMP_SC] << "_ptr ctx" << endl + << ")" << endl + << STRS[EXCP_START] << endl + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "));" << endl; + + os << "virtual void" << endl + << "ciao_preactivate (" << endl + << ")" << endl + << STRS[EXCP_START] << endl + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "));" << endl; + + os << "virtual void" << endl + << "ciao_postactivate (" << endl + << ")" << endl + << STRS[EXCP_START] << endl + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "));" << endl; + + os << "virtual void" << endl + << "ccm_activate (" << endl + << ")" << endl + << STRS[EXCP_START] << endl + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "));" << endl; + + os << "virtual void" << endl + << "ccm_passivate (" << endl + << ")" << endl + << STRS[EXCP_START] << endl + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "));" << endl; + + os << "virtual void" << endl + << "ccm_remove (" << endl + << ")" << endl + << STRS[EXCP_START] << endl + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "));" << endl; + } + + virtual void + post (Type& t) + { + os << "protected:" << endl + << t.name () << "_Context *context_;" << endl + << "};"; + } + + private: + ComponentExecutor& exec_; + }; + + struct ComponentExecutorEmitter : Traversal::ComponentExecutor, EmitterBase + { + ComponentExecutorEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + implements (Type& i) + { + Traversal::ComponentExecutor component_executor; + + Traversal::Implements implements; + component_executor.edge_traverser (implements); + + ComponentExecImplEmitter component_exec_impl_emitter (ctx, i); + implements.node_traverser (component_exec_impl_emitter); + + component_executor.traverse (i); + } + }; + + struct HomeExecImplEmitter : Traversal::Home, EmitterBase + { + HomeExecImplEmitter (Context& c, HomeExecutor& exec) + : EmitterBase (c), + exec_ (exec) + { + } + + virtual void + pre (Type& t) + { + os << "class " << ctx.export_macro () << " " + << t.name () << "_exec_i" << endl + << " : public virtual " << exec_.name () << "," << endl + << " public virtual TAO_Local_RefCounted_Object" << endl + << "{" + << "public:" << endl + << t.name () << "_exec_i (void);" + << "virtual ~" << t.name () << "_exec_i (void);" << endl; + + os << "// Supported or inherited operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits home_inherits; + home_inherits.node_traverser (home_emitter); + + Traversal::Supports supports_; + home_emitter.edge_traverser (home_inherits); + home_emitter.edge_traverser (supports_); + InterfaceEmitter interface_emitter (ctx); + supports_.node_traverser (interface_emitter); + + Traversal::Defines defines; + Traversal::Inherits interface_inherits; + interface_emitter.edge_traverser (defines); + interface_emitter.edge_traverser (interface_inherits); + + AttributeHeaderEmitter attribute_emitter (ctx); + defines.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx); + defines.node_traverser (operation_emitter); + interface_inherits.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + os << "// Home operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits home_inherits; + home_inherits.node_traverser (home_emitter); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + home_emitter.edge_traverser (home_inherits); + + HomeOperationEmitter home_operation_emitter (ctx); + defines.node_traverser (home_operation_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + home_operation_emitter.edge_traverser (receives); + home_operation_emitter.edge_traverser (returns); + home_operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + // Generate home factory operations. This is a separate traversal + // stack because we want to generate the factory operations + // of ancestors with the return type of the base component. + os << "// Factory and finder operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits inherits; + home_emitter.edge_traverser (inherits); + inherits.node_traverser (home_emitter); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + + bool for_exec = true; + FactoryOperationEmitter factory_operation_emitter (ctx, for_exec); + FinderOperationEmitter finder_operation_emitter (ctx, for_exec); + defines.node_traverser (factory_operation_emitter); + defines.node_traverser (finder_operation_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + factory_operation_emitter.edge_traverser (receives); + factory_operation_emitter.edge_traverser (returns); + factory_operation_emitter.edge_traverser (raises); + finder_operation_emitter.edge_traverser (receives); + finder_operation_emitter.edge_traverser (returns); + finder_operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + os << "// Attribute operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits home_inherits; + home_inherits.node_traverser (home_emitter); + + home_emitter.edge_traverser (home_inherits); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + + AttributeHeaderEmitter attribute_emitter (ctx); + defines.node_traverser (attribute_emitter); + + home_emitter.traverse (t); + } + + os << "// Implicit operations." << endl << endl + << "virtual " << STRS[COMP_EC] << "_ptr" << endl + << "create (" << endl + << ")" << endl + << STRS[EXCP_START] << endl + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "));" << endl; + } + + virtual void + post (Type& t) + { + os << "};"; + + string name; + + // We need to escape C++ keywords before flattening the name. + // + { + std::ostringstream ostr; + ostr.pword (name_printer_index) = os.pword (name_printer_index); + ostr << t.scoped_name (); + name = regex::perl_s (ostr.str (), "/::/_/"); + } + + os << "extern \"C\" " << ctx.export_macro () + << " ::Components::HomeExecutorBase_ptr" << endl + << "create" << name << "_Impl (void);" << endl; + } + + private: + HomeExecutor& exec_; + }; + + struct HomeExecutorEmitter : Traversal::HomeExecutor, EmitterBase + { + HomeExecutorEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + implements (Type& i) + { + Traversal::HomeExecutor home_executor; + + Traversal::Implements implements; + home_executor.edge_traverser (implements); + + HomeExecImplEmitter home_exec_impl_emitter (ctx, i); + implements.node_traverser (home_exec_impl_emitter); + + home_executor.traverse (i); + } + }; +} + +ExecImplHeaderEmitter::ExecImplHeaderEmitter (std::ostream& os_, + CommandLine const& cl, + string export_macro, + fs::path const& file) + : os (os_), + cl_ (cl), + export_macro_ (export_macro), + file_ (file) +{} + +void +ExecImplHeaderEmitter::pre (TranslationUnit&) +{ + os << COPYRIGHT; + + string file_name (""); + + if (!file_.empty ()) + { + file_name = file_.leaf (); + } + + string uc_file_name = file_name; + + std::transform (uc_file_name.begin (), + uc_file_name.end (), + uc_file_name.begin (), + upcase); + + string uc_file_suffix = cl_.get_value ("exec-hdr-file-suffix", + "_exec.h"); + + std::transform (uc_file_suffix.begin (), + uc_file_suffix.end (), + uc_file_suffix.begin (), + upcase); + + string guard = + "CIAO_" + + regex::perl_s (uc_file_name, + "/^(.+?)(\\.(IDL|CIDL|CDL))?$/$1" + + uc_file_suffix + + "/"); + + // Replace any remaining '.' with '_'. + guard = regex::perl_s (guard, "/\\./_/"); + + os << "#ifndef " << guard << endl + << "#define " << guard << endl << endl + << "#include /**/ \"ace/pre.h\"" << endl << endl; + + string file_suffix = cl_.get_value ("svnt-hdr-file-suffix", + "_svnt.h"); + + string svnt_file_name = regex::perl_s (file_name, + "/^(.+?)(\\.(idl|cidl|cdl))?$/$1" + + file_suffix + + "/"); + + os << "#include \"" << svnt_file_name << "\"" << endl << endl; + + os << "#if !defined (ACE_LACKS_PRAGMA_ONCE)" << endl + << "# pragma once" << endl + << "#endif /* ACE_LACKS_PRAGMA_ONCE */" << endl << endl; + + string default_export_include = + regex::perl_s (file_name, + "/^(.+?)(\\.(idl|cidl|cdl))?$/$1_exec_export.h/"); + + string export_include = cl_.get_value ("exec-export-include", + default_export_include); + + if (!export_include.empty ()) + { + os << "#include \"" << export_include << "\"" << endl; + } + + os << "#include \"tao/LocalObject.h\"" << endl << endl; +} + +void +ExecImplHeaderEmitter::generate (TranslationUnit& u) +{ + pre (u); + + Context c (os, export_macro_, cl_); + + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion principal_region; + contains_principal.node_traverser (principal_region); + + // Layer 2 + // + Traversal::ContainsRoot contains_root; + principal_region.edge_traverser (contains_root); + + //-- + Traversal::Root root; + contains_root.node_traverser (root); + + // Layer 3 + // + Traversal::Defines defines; + root.edge_traverser (defines); + + //-- + ModuleEmitter module (c); + CompositionEmitter composition (c); + defines.node_traverser (module); + defines.node_traverser (composition); + + // Layer 4 + // + composition.edge_traverser (defines); + module.edge_traverser (defines); + + //-- + ComponentExecutorEmitter component_executor (c); + HomeExecutorEmitter home_executor (c); + defines.node_traverser (component_executor); + defines.node_traverser (home_executor); + + // Layer 5 + // + Traversal::Implements implements; + component_executor.edge_traverser (implements); + home_executor.edge_traverser (implements); + + unit.traverse (u); + + post (u); +} + +void +ExecImplHeaderEmitter::post (TranslationUnit&) +{ + if (file_.empty ()) return; + + string uc_file_name = file_.leaf (); + + std::transform (uc_file_name.begin (), + uc_file_name.end (), + uc_file_name.begin (), + upcase); + + string uc_file_suffix = cl_.get_value ("exec-hdr-file-suffix", + "_exec.h"); + + std::transform (uc_file_suffix.begin (), + uc_file_suffix.end (), + uc_file_suffix.begin (), + upcase); + + string guard = + "CIAO_" + + regex::perl_s (uc_file_name, + "/^(.+?)(\\.(IDL|CIDL))?$/$1" + uc_file_suffix + "/"); + + guard = regex::perl_s (guard, "/\\./_/"); + + os << "#include /**/ \"ace/post.h\"" << endl << endl + << "#endif /* " << guard << " */" + << endl << endl; +} + diff --git a/modules/CIAO/CIDLC/ExecImplHeaderGenerator.hpp b/modules/CIAO/CIDLC/ExecImplHeaderGenerator.hpp new file mode 100644 index 00000000000..0cc8127cc76 --- /dev/null +++ b/modules/CIAO/CIDLC/ExecImplHeaderGenerator.hpp @@ -0,0 +1,43 @@ +// file : CIDLC/ServantHeaderGenerator.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef EXEC_IMPL_HEADER_GENERATOR_HPP +#define EXEC_IMPL_HEADER_GENERATOR_HPP + +#include "CCF/CodeGenerationKit/CommandLine.hpp" + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +using std::string; + +class ExecImplHeaderEmitter +{ +public: + ExecImplHeaderEmitter (std::ostream& os_, + CommandLine const& cl, + string export_macro, + fs::path const& file); + + virtual ~ExecImplHeaderEmitter () {} + + virtual void + pre (CCF::CIDL::SemanticGraph::TranslationUnit& u); + + virtual void + generate (CCF::CIDL::SemanticGraph::TranslationUnit& u); + + virtual void + post (CCF::CIDL::SemanticGraph::TranslationUnit& u); + +private: + std::ostream& os; + CommandLine const& cl_; + string export_macro_; + fs::path file_; +}; + + +#endif // EXEC_IMPL_HEADER_GENERATOR_HPP + diff --git a/modules/CIAO/CIDLC/ExecImplSourceGenerator.cpp b/modules/CIAO/CIDLC/ExecImplSourceGenerator.cpp new file mode 100644 index 00000000000..1f36dd99248 --- /dev/null +++ b/modules/CIAO/CIDLC/ExecImplSourceGenerator.cpp @@ -0,0 +1,1136 @@ +// file : CIDLC/ExecImplSourceGenerator.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "ExecImplSourceGenerator.hpp" +#include "CorbaTypeNameEmitters.hpp" +#include "UtilityTypeNameEmitters.hpp" +#include "ParameterEmitter_T.hpp" +#include "AttributeSourceEmitters_T.hpp" +#include "CompositionEmitter.hpp" +#include "ModuleEmitter.hpp" +#include "InterfaceEmitter.hpp" +#include "Literals.hpp" + +#include +#include + +#include "CCF/CodeGenerationKit/Regex.hpp" + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; +using namespace StringLiterals; + +namespace +{ + template + struct OperationEmitter : Traversal::Operation, EmitterBase + { + OperationEmitter (Context& c, T& scope) + : EmitterBase (c), + scope_ (scope) + {} + + virtual void + name (Type& o) + { + os << endl + << scope_.name () << "_exec_i::" << o.name (); + } + + virtual void + receives_pre (Type&) + { + os << " (" << endl; + } + + virtual void + receives_none (Type&) + { + os << " ()" << endl; + } + + virtual void + receives_post (Type&) + { + os << endl << ")" << endl; + } + + virtual void + raises_pre (Type&) + { + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; + } + + virtual void + raises_none (Type&) + { + os << STRS[EXCP_SNGL]; + } + + virtual void + raises_post (Type&) + { + os << "))"; + } + + virtual void + post (Type& o) + { + os << "{" + << STRS[YCH] << endl; + + Traversal::Operation operation_emitter; + + Traversal::Belongs returns; + operation_emitter.edge_traverser (returns); + + NullReturnEmitter return_emitter (ctx); + returns.node_traverser (return_emitter); + + operation_emitter.traverse (o); + + os << "}"; + } + + virtual void + comma (Type&) + { + os << "," << endl; + } + + protected: + T& scope_; + }; + + struct FacetEmitter : Traversal::UnconstrainedInterface, + EmitterBase + { + FacetEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (UnconstrainedInterface& i) + { + if (i.context ().count ("facet_impl_src_gen")) return; + + os << STRS[SEP] << endl + << "// Facet Executor Implementation Class: " + << i.name () << "_exec_i" << endl + << STRS[SEP] << endl << endl; + + os << i.name () << "_exec_i::" + << i.name () << "_exec_i (void)" << endl + << "{" + << "}" + << i.name () << "_exec_i::~" + << i.name () << "_exec_i (void)" << endl + << "{" + << "}" + << "// Operations from " << i.scoped_name () << endl << endl; + + { + InterfaceEmitter interface_emitter (ctx); + + Traversal::Defines defines_; + Traversal::Inherits inherits_; + interface_emitter.edge_traverser (defines_); + interface_emitter.edge_traverser (inherits_); + + bool exec_src = true; + AttributeSourceEmitter attribute_emitter ( + ctx, + i, + exec_src + ); + defines_.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx, i); + defines_.node_traverser (operation_emitter); + inherits_.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + bool for_exec_src = true; + ParameterEmitter in_param ( + ctx, + for_exec_src + ); + ParameterEmitter inout_param ( + ctx, + for_exec_src + ); + ParameterEmitter out_param ( + ctx, + for_exec_src + ); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + inherits (i, inherits_); + names (i, defines_); + } + + i.context ().set ("facet_impl_src_gen", true); + } + }; + + struct ExecPortsEmitter : Traversal::ConsumerData, + Traversal::ProviderData, + EmitterBase + { + ExecPortsEmitter (Context& c, SemanticGraph::Component& scope) + : EmitterBase (c), + enclosing_type_name_emitter_ (c), + simple_type_name_emitter_ (c), + type_name_emitter_ (c), + scope_ (scope) + { + enclosing_belongs_.node_traverser (enclosing_type_name_emitter_); + simple_belongs_.node_traverser (simple_type_name_emitter_); + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::Provider& p) + { + Traversal::ProviderData::belongs (p, enclosing_belongs_); + + os << "::CCM_"; + + Traversal::ProviderData::belongs (p, simple_belongs_); + + os << "_ptr" << endl + << scope_.name () << "_exec_i::get_" + << p.name () << " ()" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << STRS[YCH] << endl + << "return "; + + Traversal::ProviderData::belongs (p, enclosing_belongs_); + + os << "::CCM_"; + + Traversal::ProviderData::belongs (p, simple_belongs_); + + os << "::_nil ();" << endl + << "}"; + } + + virtual void + traverse (SemanticGraph::Consumer& c) + { + os << "void" << endl + << scope_.name () << "_exec_i::push_" + << c.name () << " (" << endl; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << " * /* ev */" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << STRS[YCH] << endl + << "}"; + } + + private: + EnclosingTypeNameEmitter enclosing_type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs enclosing_belongs_; + Traversal::Belongs simple_belongs_; + Traversal::Belongs belongs_; + SemanticGraph::Component& scope_; + }; + + struct ComponentExecImplEmitter : Traversal::Component, EmitterBase + { + ComponentExecImplEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + pre (Type& t) + { + // Generate the facet executor class(es) first. + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (component_inherits); + + Traversal::Provider provider; + defines.node_traverser (provider); + + Traversal::Belongs belongs; + provider.edge_traverser (belongs); + + FacetEmitter facet_emitter (ctx); + belongs.node_traverser (facet_emitter); + + component_emitter.traverse (t); + } + + os << STRS[SEP] << endl + << "// Component Executor Implementation Class: " + << t.name () << "_exec_i" << endl + << STRS[SEP] << endl << endl; + + os << t.name () << "_exec_i::" + << t.name () << "_exec_i (void)" << endl + << "{" + << "}" + << t.name () << "_exec_i::~" + << t.name () << "_exec_i (void)" << endl + << "{" + << "}"; + + os << "// Supported or inherited operations." << endl << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Supports supports_; + component_emitter.edge_traverser (component_inherits); + component_emitter.edge_traverser (supports_); + InterfaceEmitter interface_emitter (ctx); + supports_.node_traverser (interface_emitter); + + Traversal::Defines defines; + Traversal::Inherits interface_inherits; + interface_emitter.edge_traverser (defines); + interface_emitter.edge_traverser (interface_inherits); + + bool exec_src = true; + AttributeSourceEmitter attribute_emitter ( + ctx, + t, + exec_src + ); + defines.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx, t); + defines.node_traverser (operation_emitter); + interface_inherits.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + bool for_exec_src = true; + ParameterEmitter in_param ( + ctx, + for_exec_src + ); + ParameterEmitter inout_param ( + ctx, + for_exec_src + ); + ParameterEmitter out_param ( + ctx, + for_exec_src + ); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + component_emitter.traverse (t); + } + + os << "// Attribute operations." << endl << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + component_emitter.edge_traverser (component_inherits); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + + bool exec_src = true; + AttributeSourceEmitter attribute_emitter ( + ctx, + t, + exec_src + ); + defines.node_traverser (attribute_emitter); + + component_emitter.traverse (t); + } + + os << "// Port operations." << endl << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + component_emitter.edge_traverser (component_inherits); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + + ExecPortsEmitter exec_ports_emitter (ctx, t); + defines.node_traverser (exec_ports_emitter); + + component_emitter.traverse (t); + } + + os << "// Operations from Components::SessionComponent" << endl << endl; + + os << "void" << endl + << t.name () << "_exec_i::set_session_context (" << endl + << STRS[COMP_SC] << "_ptr ctx" << endl + << ")" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "))" << endl + << "{" + << "this->context_ =" << endl + << " " << t.name () << "_Context::_narrow (" << endl + << " ctx" << endl + << " " <<");" + << endl; + + os << "if (this->context_ == 0)" << endl + << "{" + << "throw ::CORBA::INTERNAL ();" + << "}" + << "}"; + + os << "void" << endl + << t.name () << "_exec_i::ciao_preactivate ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "))" << endl + << "{" + << STRS[YCH] + << "}"; + + os << "void" << endl + << t.name () << "_exec_i::ciao_postactivate ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "))" << endl + << "{" + << STRS[YCH] + << "}"; + + os << "void" << endl + << t.name () << "_exec_i::ccm_activate ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "))" << endl + << "{" + << STRS[YCH] + << "}"; + + os << "void" << endl + << t.name () << "_exec_i::ccm_passivate ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "))" << endl + << "{" + << STRS[YCH] + << "}"; + + os << "void" << endl + << t.name () << "_exec_i::ccm_remove ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "))" << endl + << "{" + << STRS[YCH] + << "}"; + } + + virtual void + post (Type&) + { + } + }; + + // HomeFactory and HomeFinder are tied to Operation in + // the front end. Since we want to treat them differently + // than regular operations in a home (we want to generate + // base class factory operations returning the base component, + // for example), we use this class for regular home operations + // that overrides HomeFactory and HomeFinder traversals + // to do nothing. + struct HomeOperationEmitter : OperationEmitter, + Traversal::HomeFactory, + Traversal::HomeFinder + { + HomeOperationEmitter (Context& c, SemanticGraph::Home& scope) + : OperationEmitter (c, scope) + {} + + virtual void + traverse (SemanticGraph::HomeFactory&) + { + } + + virtual void + traverse (SemanticGraph::HomeFinder&) + { + } + }; + + struct FactoryOperationEmitter : Traversal::HomeFactory, + EmitterBase + { + FactoryOperationEmitter (Context& c, SemanticGraph::Home& scope) + : EmitterBase (c), + enclosing_type_name_emitter_ (c), + simple_type_name_emitter_ (c), + scope_ (scope) + { + enclosing_returns_.node_traverser (enclosing_type_name_emitter_); + simple_returns_.node_traverser (simple_type_name_emitter_); + } + + virtual void + returns (SemanticGraph::HomeFactory&) + { + os << STRS[COMP_EC] << "_ptr" << endl; + } + + virtual void + name (SemanticGraph::HomeFactory& hf) + { + os << scope_.name () << "_exec_i::" << hf.name (); + } + + virtual void + receives_none (SemanticGraph::HomeFactory&) + { + os << " ()" << endl; + } + + virtual void + receives_pre (SemanticGraph::HomeFactory&) + { + os << " (" << endl; + } + + virtual void + receives_post (SemanticGraph::HomeFactory&) + { + os << endl << ")" << endl; + } + + virtual void + raises_none (SemanticGraph::HomeFactory&) + { + os << STRS[EXCP_SNGL]; + } + + virtual void + raises_pre (SemanticGraph::HomeFactory&) + { + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; + } + + virtual void + raises_post (SemanticGraph::HomeFactory&) + { + os << "))"; + } + + virtual void + post (SemanticGraph::HomeFactory& hf) + { + os << "{" + << STRS[YCH] << endl + << "return "; + + Traversal::HomeFactory::returns (hf, enclosing_returns_); + + os << "::CCM_"; + + Traversal::HomeFactory::returns (hf, simple_returns_); + + os << "::_nil ();" + << "}"; + } + + virtual void + comma (SemanticGraph::HomeFactory&) + { + os << "," << endl; + } + + private: + EnclosingTypeNameEmitter enclosing_type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + Traversal::Returns enclosing_returns_; + Traversal::Returns simple_returns_; + SemanticGraph::Home& scope_; + }; + + struct FinderOperationEmitter : Traversal::HomeFinder, + EmitterBase + { + FinderOperationEmitter (Context& c, SemanticGraph::Home& scope) + : EmitterBase (c), + enclosing_type_name_emitter_ (c), + simple_type_name_emitter_ (c), + scope_ (scope) + { + enclosing_returns_.node_traverser (enclosing_type_name_emitter_); + simple_returns_.node_traverser (simple_type_name_emitter_); + } + + virtual void + returns (SemanticGraph::HomeFinder&) + { + os << STRS[COMP_EC] << "_ptr" << endl; + } + + virtual void + name (SemanticGraph::HomeFinder& hf) + { + os << scope_.name () << "_exec_i::" << hf.name (); + } + + virtual void + receives_none (SemanticGraph::HomeFinder&) + { + os << " ()" << endl; + } + + virtual void + receives_pre (SemanticGraph::HomeFinder&) + { + os << " (" << endl; + } + + virtual void + receives_post (SemanticGraph::HomeFinder&) + { + os << endl << ")" << endl; + } + + virtual void + raises_none (SemanticGraph::HomeFinder&) + { + os << STRS[EXCP_SNGL]; + } + + virtual void + raises_pre (SemanticGraph::HomeFinder&) + { + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; + } + + virtual void + raises_post (SemanticGraph::HomeFinder&) + { + os << "))"; + } + + virtual void + post (SemanticGraph::HomeFinder& hf) + { + os << "{" + << STRS[YCH] << endl + << "return "; + + Traversal::HomeFinder::returns (hf, enclosing_returns_); + + os << "::CCM_"; + + Traversal::HomeFinder::returns (hf, simple_returns_); + + os << "::_nil ();" + << "}"; + } + + virtual void + comma (SemanticGraph::HomeFinder&) + { + os << "," << endl; + } + + private: + EnclosingTypeNameEmitter enclosing_type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + Traversal::Returns enclosing_returns_; + Traversal::Returns simple_returns_; + SemanticGraph::Home& scope_; + }; + + struct HomeExecImplEmitter : Traversal::Home, EmitterBase + { + HomeExecImplEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + pre (Type& t) + { + os << STRS[SEP] << endl + << "// Home Executor Implementation Class: " + << t.name () << "_exec_i" << endl + << STRS[SEP] << endl << endl; + + os << t.name () << "_exec_i::" + << t.name () << "_exec_i (void)" << endl + << "{" + << "}" + << t.name () << "_exec_i::~" + << t.name () << "_exec_i (void)" << endl + << "{" + << "}"; + + os << "// Supported or inherited operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits home_inherits; + home_inherits.node_traverser (home_emitter); + + Traversal::Supports supports_; + home_emitter.edge_traverser (home_inherits); + home_emitter.edge_traverser (supports_); + InterfaceEmitter interface_emitter (ctx); + supports_.node_traverser (interface_emitter); + + Traversal::Defines defines; + Traversal::Inherits interface_inherits; + interface_emitter.edge_traverser (defines); + interface_emitter.edge_traverser (interface_inherits); + + bool exec_src = true; + AttributeSourceEmitter attribute_emitter ( + ctx, + t, + exec_src + ); + defines.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx, t); + defines.node_traverser (operation_emitter); + interface_inherits.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + bool for_exec_src = true; + ParameterEmitter in_param ( + ctx, + for_exec_src + ); + ParameterEmitter inout_param ( + ctx, + for_exec_src + ); + ParameterEmitter out_param ( + ctx, + for_exec_src + ); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + os << "// Home operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits home_inherits; + home_inherits.node_traverser (home_emitter); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + home_emitter.edge_traverser (home_inherits); + + HomeOperationEmitter home_operation_emitter (ctx, t); + defines.node_traverser (home_operation_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + home_operation_emitter.edge_traverser (receives); + home_operation_emitter.edge_traverser (returns); + home_operation_emitter.edge_traverser (raises); + + bool for_exec_src = true; + ParameterEmitter in_param ( + ctx, + for_exec_src + ); + ParameterEmitter inout_param ( + ctx, + for_exec_src + ); + ParameterEmitter out_param ( + ctx, + for_exec_src + ); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + // Generate home factory operations. This is a separate traversal + // stack because we want to generate the factory operations + // of ancestors with the return type of the base component. + os << "// Factory and finder operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits inherits; + home_emitter.edge_traverser (inherits); + inherits.node_traverser (home_emitter); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + + FactoryOperationEmitter factory_operation_emitter (ctx, t); + FinderOperationEmitter finder_operation_emitter (ctx, t); + defines.node_traverser (factory_operation_emitter); + defines.node_traverser (finder_operation_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + factory_operation_emitter.edge_traverser (receives); + factory_operation_emitter.edge_traverser (returns); + factory_operation_emitter.edge_traverser (raises); + finder_operation_emitter.edge_traverser (receives); + finder_operation_emitter.edge_traverser (returns); + finder_operation_emitter.edge_traverser (raises); + + bool for_exec_src = true; + ParameterEmitter in_param ( + ctx, + for_exec_src + ); + ParameterEmitter inout_param ( + ctx, + for_exec_src + ); + ParameterEmitter out_param ( + ctx, + for_exec_src + ); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + os << "// Attribute operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits home_inherits; + home_inherits.node_traverser (home_emitter); + + home_emitter.edge_traverser (home_inherits); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + + bool exec_src = true; + AttributeSourceEmitter attribute_emitter ( + ctx, + t, + exec_src + ); + defines.node_traverser (attribute_emitter); + + home_emitter.traverse (t); + } + + os << "// Implicit operations." << endl << endl + << STRS[COMP_EC] << "_ptr" << endl + << t.name () << "_exec_i::create ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_CE] << "))" << endl + << "{" + << STRS[COMP_EC] << "_ptr retval =" << endl + << " " << STRS[COMP_EC] << "::_nil ();" << endl + << "ACE_NEW_THROW_EX (" << endl + << "retval," << endl; + + Traversal::Home home_emitter; + + Traversal::Manages manages_; + home_emitter.edge_traverser (manages_); + + SimpleTypeNameEmitter manages_emitter (ctx); + manages_.node_traverser (manages_emitter); + + home_emitter.traverse (t); + + os << "_exec_i," << endl + << "::CORBA::NO_MEMORY ());" + << endl + << "return retval;" + << "}"; + } + + virtual void + post (Type& t) + { + // We need to escape C++ keywords before flattening the name. + // + string name; + { + std::ostringstream ostr; + ostr.pword (name_printer_index) = os.pword (name_printer_index); + ostr << t.scoped_name (); + name = regex::perl_s (ostr.str (), "/::/_/"); + } + + os << "extern \"C\" " << ctx.export_macro () + << " ::Components::HomeExecutorBase_ptr" << endl + << "create" << name << "_Impl (void)" << endl + << "{" + << "::Components::HomeExecutorBase_ptr retval =" << endl + << " ::Components::HomeExecutorBase::_nil ();" << endl + << "ACE_NEW_RETURN (" << endl + << "retval," << endl + << t.name () << "_exec_i," << endl + << "::Components::HomeExecutorBase::_nil ());" << endl + << "return retval;" + << "}"; + } + }; +} + +ExecImplSourceEmitter::ExecImplSourceEmitter (std::ostream& os_, + CommandLine const& cl, + string export_macro, + fs::path const& file) + : os (os_), + cl_ (cl), + export_macro_ (export_macro), + file_ (file) +{} + +void +ExecImplSourceEmitter::pre (TranslationUnit&) +{ + os << COPYRIGHT; + + string file_name (""); + + if (! file_.empty ()) + { + file_name = file_.leaf (); + } + + string file_suffix = cl_.get_value ("exec-hdr-file-suffix", + "_exec.h"); + + file_name = regex::perl_s (file_name, + "/^(.+?)(\\.(idl|cidl|cdl))?$/$1" + + file_suffix + + "/"); + + os << "#include \"" << file_name << "\"" << endl + << "#include \"ciao/CIAO_common.h\"" << endl << endl; +} + +void +ExecImplSourceEmitter::generate (TranslationUnit& u) +{ + pre (u); + + Context c (os, export_macro_, cl_); + + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion principal_region; + contains_principal.node_traverser (principal_region); + + // Layer 2 + // + Traversal::ContainsRoot contains_root; + principal_region.edge_traverser (contains_root); + + //-- + Traversal::Root root; + contains_root.node_traverser (root); + + // Layer 3 + // + Traversal::Defines defines; + root.edge_traverser (defines); + + //-- + ModuleEmitter module (c); + CompositionEmitter composition (c); + defines.node_traverser (module); + defines.node_traverser (composition); + + // Layer 4 + // + composition.edge_traverser (defines); + module.edge_traverser (defines); + + //-- + Traversal::ComponentExecutor component_executor; + Traversal::HomeExecutor home_executor; + defines.node_traverser (component_executor); + defines.node_traverser (home_executor); + + // Layer 5 + // + Traversal::Implements implements; + component_executor.edge_traverser (implements); + home_executor.edge_traverser (implements); + + //-- + ComponentExecImplEmitter component_exec_impl_emitter (c); + HomeExecImplEmitter home_exec_impl_emitter (c); + implements.node_traverser (component_exec_impl_emitter); + implements.node_traverser (home_exec_impl_emitter); + + unit.traverse (u); + + post (u); +} + +void +ExecImplSourceEmitter::post (TranslationUnit&) +{ +} + diff --git a/modules/CIAO/CIDLC/ExecImplSourceGenerator.hpp b/modules/CIAO/CIDLC/ExecImplSourceGenerator.hpp new file mode 100644 index 00000000000..bf70a53870a --- /dev/null +++ b/modules/CIAO/CIDLC/ExecImplSourceGenerator.hpp @@ -0,0 +1,43 @@ +// file : CIDLC/ExecImplSourceGenerator.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef EXEC_IMPL_SOURCE_GENERATOR_HPP +#define EXEC_IMPL_SOURCE_GENERATOR_HPP + +#include "CCF/CodeGenerationKit/CommandLine.hpp" + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +using std::string; + +class ExecImplSourceEmitter +{ +public: + ExecImplSourceEmitter (std::ostream& os_, + CommandLine const& cl, + string export_macro, + fs::path const& file); + + virtual ~ExecImplSourceEmitter () {} + + virtual void + pre (CCF::CIDL::SemanticGraph::TranslationUnit& u); + + virtual void + generate (CCF::CIDL::SemanticGraph::TranslationUnit& u); + + virtual void + post (CCF::CIDL::SemanticGraph::TranslationUnit& u); + +private: + std::ostream& os; + CommandLine const& cl_; + string export_macro_; + fs::path file_; +}; + + +#endif // EXEC_IMPL_SOURCE_GENERATOR_HPP + diff --git a/modules/CIAO/CIDLC/ExecutorMappingGenerator.cpp b/modules/CIAO/CIDLC/ExecutorMappingGenerator.cpp new file mode 100644 index 00000000000..369fbbaac02 --- /dev/null +++ b/modules/CIAO/CIDLC/ExecutorMappingGenerator.cpp @@ -0,0 +1,2099 @@ +// file : CIDLC/ExecutorMappingGenerator.cpp +// author : Boris Kolpackov +// cvs-id : $Id$ + +#include "ExecutorMappingGenerator.hpp" +#include "Literals.hpp" + +#include +#include +#include + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +#include "CCF/CodeGenerationKit/Regex.hpp" +#include "CCF/CodeGenerationKit/IndentationIDL.hpp" +#include "CCF/CodeGenerationKit/IndentationImplanter.hpp" + +using std::string; +using std::ostream; +using std::endl; + +using namespace StringLiterals; +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +namespace +{ + class Context + { + public: + Context (TranslationUnit& tu) + : tu_ (tu) + { + } + + TranslationUnit& + tu () const + { + return tu_; + } + + public: + bool + add (Home& h) + { + return homes_.insert (&h).second; + } + + bool + add (Component& c) + { + return components_.insert (&c).second; + } + + bool + add (UnconstrainedInterface& i) + { + return interfaces_.insert (std::make_pair(&i, true)).second; + } + + bool + add (Composition& c) + { + return compositions_.insert (&c).second; + } + + public: + bool + find (Home& h) const + { + return homes_.find (&h) != homes_.end (); + } + + bool + find (Component& c) const + { + return components_.find (&c) != components_.end (); + } + + bool + find (UnconstrainedInterface& i) const + { + return interfaces_.find (&i) != interfaces_.end (); + } + + // The next two functions help to keep track of forward + // declarations for LEM. The non-const version should be + // used in emitter (note that it changed the flag to false). + // The const version should be used in module re-opener. + // + bool + find_fwd (UnconstrainedInterface& i) + { + Interfaces::iterator it (interfaces_.find (&i)); + + if (it == interfaces_.end ()) return false; + + if (it->second) + { + it->second = false; + return true; + } + + return false; + } + + bool + find_fwd (UnconstrainedInterface& i) const + { + Interfaces::const_iterator it (interfaces_.find (&i)); + + return it != interfaces_.end () && it->second; + } + + bool + find (Composition& c) const + { + return compositions_.find (&c) != compositions_.end (); + } + + private: + typedef std::set Homes; + typedef std::set Components; + typedef std::map Interfaces; + typedef std::set Compositions; + + TranslationUnit& tu_; + + Homes homes_; + Components components_; + Interfaces interfaces_; + Compositions compositions_; + }; + + class Traverser + { + protected: + Traverser (Context& c) + : ctx (c) + { + } + + Context& ctx; + }; + + struct Collector : Traverser + { + protected: + Collector (Context& c) + : Traverser (c) + { + } + + bool + exist (ScopedName const& name) + { + return !ctx.tu ().lookup (name).empty (); + } + }; + + // + // + // + struct ComponentCollector : Traversal::Component, Collector + { + ComponentCollector (Context& c) + : Collector (c) + { + } + + virtual void + traverse (Type& c) + { + SimpleName name (c.name ()); + ScopedName scope (c.scoped_name ().scope_name ()); + + ScopedName monolith (scope, "CCM_" + name); + ScopedName context (scope, "CCM_" + name + "_Context"); + + // Check if mapping has already been provided. + // + if (exist (context) || exist (monolith)) return; + + if(ctx.add (c)) + { + // Collect inherited components and provides interfaces. + // + Traversal::Component::traverse (c); + } + } + }; + + + // + // + // + struct HomeCollector : Traversal::Home, Collector + { + HomeCollector (Context& c) + : Collector (c) + { + } + + virtual void + traverse (Type& h) + { + SimpleName name (h.name ()); + ScopedName scope (h.scoped_name ().scope_name ()); + + ScopedName main (scope, "CCM_" + name); + ScopedName expl (scope, "CCM_" + name + "Explicit"); + ScopedName impl (scope, "CCM_" + name + "Implicit"); + + // Check if mapping has already been provided. + // + if (exist (main) || exist (expl) || exist (impl)) return; + + if(ctx.add (h)) + { + // Note that I don't go after components that inherited home manages + // because it will be handled by component inheritance tree. + // + Traversal::Home::traverse (h); + } + } + }; + + + // + // + // + struct InterfaceCollector : Traversal::UnconstrainedInterface, Collector + { + InterfaceCollector (Context& c) + : Collector (c) + { + } + + virtual void + traverse (Type& i) + { + SimpleName name (i.name ()); + ScopedName scope (i.scoped_name ().scope_name ()); + + ScopedName mapping (scope, "CCM_" + name); + + // Check if mapping has already been provided. + // + if (exist (mapping)) return; + + // Add to the list if it's not already there. + // + ctx.add (i); + } + }; + + struct CompositionCollector : Traversal::Composition, Collector + { + CompositionCollector (Context& c) + : Collector (c) + { + } + + virtual void + traverse (Type& c) + { + // Add to the list if it's not already there. + // + if (ctx.add (c)) + { + Traversal::Composition::traverse (c); + } + } + }; + + struct Emitter : Traverser + { + protected: + Emitter (Context& c, ostream& os_) + : Traverser (c), os (os_) + { + } + + protected: + ostream& os; + }; + + + // + // + // + struct FullTypeNameEmitter : Traversal::FundamentalType, + Traversal::Type, + Emitter + { + FullTypeNameEmitter (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + traverse (SemanticGraph::FundamentalType& t) + { + os << t.name (); + } + + virtual void + traverse (SemanticGraph::Type& t) + { + os << t.scoped_name (); + } + }; + + + struct NameMangler : Traversal::Nameable, Emitter + { + NameMangler (Context& c, + ostream& os, + string const& prefix, + string const& suffix = "") + : Emitter (c, os), prefix_ (prefix), suffix_ (suffix) + { + } + + virtual void + traverse (Type& t) + { + ScopedName n (t.scoped_name ()); + os << n.scope_name () << "::" << prefix_ << n.simple_name () << suffix_; + } + + private: + string prefix_, suffix_; + }; + + + // + // + // + struct ComponentEmitter : Traversal::Component, Emitter + { + protected: + ComponentEmitter (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + traverse (Type& c) + { + if (ctx.find (c)) + { + Component::traverse (c); + } + } + }; + + struct AttributeEmitter : Traversal::ReadAttribute, + Traversal::ReadWriteAttribute, + Emitter + { + AttributeEmitter (Context& c, ostream& os) + : Emitter (c, os), + type_name_ (c, os) + { + edge_traverser (get_raises_); + edge_traverser (set_raises_); + + get_raises_.node_traverser (type_name_); + set_raises_.node_traverser (type_name_); + } + + // ReadAttribute + // + virtual void + pre (SemanticGraph::ReadAttribute& ) + { + os << "readonly attribute "; + } + + virtual void + name (SemanticGraph::ReadAttribute& a) + { + os << " " << a.name (); + } + + virtual void + get_raises_pre (SemanticGraph::ReadAttribute&) + { + os << " raises ("; + } + + virtual void + get_raises_post (SemanticGraph::ReadAttribute&) + { + os << ")"; + } + + virtual void + post (SemanticGraph::ReadAttribute&) + { + os << ";"; + } + + virtual void + comma (SemanticGraph::ReadAttribute&) + { + os << ", "; + } + + // ReadWriteAttribute + // + virtual void + pre (SemanticGraph::ReadWriteAttribute& ) + { + os << "attribute "; + } + + virtual void + name (SemanticGraph::ReadWriteAttribute& a) + { + os << " " << a.name (); + } + + virtual void + get_raises_pre (SemanticGraph::ReadWriteAttribute&) + { + os << " getraises ("; + } + + virtual void + get_raises_post (SemanticGraph::ReadWriteAttribute&) + { + os << ")"; + } + + virtual void + set_raises_pre (SemanticGraph::ReadWriteAttribute&) + { + os << " setraises ("; + } + + virtual void + set_raises_post (SemanticGraph::ReadWriteAttribute&) + { + os << ")"; + } + + virtual void + post (SemanticGraph::ReadWriteAttribute&) + { + os << ";"; + } + + virtual void + comma (SemanticGraph::ReadWriteAttribute&) + { + os << ", "; + } + + private: + Traversal::GetRaises get_raises_; + Traversal::SetRaises set_raises_; + FullTypeNameEmitter type_name_; + }; + + + // MonolithEmitter generates what spec calls 'Monolithic Component + // Executor'. + // + struct MonolithEmitter : ComponentEmitter + { + MonolithEmitter (Context& c, ostream& os) + : ComponentEmitter (c, os), + monolith_name_emitter (c, os, "CCM_"), + attribute (c, os), + consumer (c, os), + provider (c, os), + type_name_emitter (c, os) + { + edge_traverser (inherits); + edge_traverser (defines); + + inherits.node_traverser (monolith_name_emitter); + + defines.node_traverser (attribute); + defines.node_traverser (consumer); + defines.node_traverser (provider); + + attribute.edge_traverser (belongs); + consumer.edge_traverser (belongs); + provider.edge_traverser (provider_belongs); + + belongs.node_traverser (type_name_emitter); + provider_belongs.node_traverser (monolith_name_emitter); + } + + virtual void + pre (Type&) + { + os << "local interface "; + } + + virtual void + name (Type& c) + { + os << "CCM_" << c.name (); + } + + virtual void + inherits_pre (Type&) + { + os << " : "; + } + + virtual void + inherits_none (Type&) + { + os << " : " << STRS[COMP_EC]; + } + + virtual void + supports_pre (Type&) + { + os << ", "; + } + + virtual void + names_pre (Type&) + { + os << "{"; + } + + virtual void + names_post (Type&) + { + os << "}"; + } + + virtual void + post (Type&) + { + os << ";"; + } + + virtual void + comma (Type&) + { + os << ", "; + } + + private: + struct Consumer : Traversal::ConsumerSet, Emitter + { + Consumer (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + returns (Type&) + { + os << "void"; + } + + virtual void + name (Type& c) + { + os << " push_" << c.name (); + } + + virtual void + receives_pre (Type&) + { + os << " (in "; + } + + virtual void + receives_post (Type&) + { + os << " e)"; + } + + virtual void + post (Type&) + { + os << ";"; + } + }; + + + struct Provider : Traversal::ProviderGet, Emitter + { + Provider (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + name (Type& c) + { + os << " get_" << c.name (); + } + + virtual void + receives_pre (Type&) + { + os << " ("; + } + + virtual void + receives_post (Type&) + { + os << ")"; + } + + virtual void + post (Type&) + { + os << ";"; + } + }; + + Traversal::Inherits inherits; + Traversal::Defines defines; + + NameMangler monolith_name_emitter; + + AttributeEmitter attribute; + Consumer consumer; + Provider provider; + + Traversal::Belongs belongs; + Traversal::Belongs provider_belongs; + + FullTypeNameEmitter type_name_emitter; + }; + + + // ContextEmitter generates component context interface. + // + // + struct ContextPortEmitter : Traversal::MultiUserGet, + Traversal::SingleUserGet, + Traversal::PublisherSet, + Traversal::EmitterSet, + Emitter + { + ContextPortEmitter (Context& c, ostream& os) + : Emitter (c, os) + { + } + + + // MultiUser. + // + virtual void + returns (SemanticGraph::MultiUser& u) + { + Component& c (dynamic_cast((*u.named_begin ())->scope ())); + os << c.scoped_name () << "::" << u.name () << "Connections"; + } + + virtual void + name (SemanticGraph::MultiUser& u) + { + os << " get_connections_" << u.name (); + } + + virtual void + receives_pre (SemanticGraph::MultiUser&) + { + os << " ("; + } + + virtual void + receives_post (SemanticGraph::MultiUser&) + { + os << ")"; + } + + virtual void + post (SemanticGraph::MultiUser&) + { + os << ";"; + } + + + // SingleUser. + // + virtual void + name (SemanticGraph::SingleUser& u) + { + os << " get_connection_" << u.name (); + } + + virtual void + receives_pre (SemanticGraph::SingleUser&) + { + os << " ("; + } + + virtual void + receives_post (SemanticGraph::SingleUser&) + { + os << ")"; + } + + virtual void + post (SemanticGraph::SingleUser&) + { + os << ";"; + } + + // Publisher. + // + virtual void + returns (SemanticGraph::Publisher&) + { + os << "void"; + } + + virtual void + name (SemanticGraph::Publisher& p) + { + os << " push_" << p.name (); + } + + virtual void + receives_pre (SemanticGraph::Publisher&) + { + os << " (in "; + } + + virtual void + receives_post (SemanticGraph::Publisher&) + { + os << " e)"; + } + + virtual void + post (SemanticGraph::Publisher&) + { + os << ";"; + } + + + // Emitter. + // + virtual void + returns (SemanticGraph::Emitter&) + { + os << "void"; + } + + virtual void + name (SemanticGraph::Emitter& e) + { + os << " push_" << e.name (); + } + + virtual void + receives_pre (SemanticGraph::Emitter&) + { + os << " (in "; + } + + virtual void + receives_post (SemanticGraph::Emitter&) + { + os << " e)"; + } + + virtual void + post (SemanticGraph::Emitter&) + { + os << ";"; + } + }; + + + struct ContextEmitter : ComponentEmitter + { + ContextEmitter (Context& c, ostream& os, CommandLine const& cl) + : ComponentEmitter (c, os), + name_emitter (c, os, "CCM_", "_Context"), + cl_ (cl) + { + edge_traverser (inherits); + inherits.node_traverser (name_emitter); + } + + virtual void + pre (Type&) + { + os << "local interface "; + } + + virtual void + name (Type& c) + { + os << "CCM_" << c.name () << "_Context"; + } + + virtual void + inherits_pre (Type&) + { + os << " : "; + } + + virtual void + inherits_none (Type&) + { + string swap_option = cl_.get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + if (swapping) + { + os << " : ::CIAO::UpgradeableContext"; + } + else + { + //@@ should be os << " : ::Components::CCMContext"; + os << " : " << STRS[COMP_SC]; + } + } + + virtual void + names_pre (Type&) + { + os << "{"; + } + + virtual void + names_post (Type&) + { + os << "}"; + } + + virtual void + post (Type&) + { + os << ";"; + } + + private: + Traversal::Inherits inherits; + NameMangler name_emitter; + CommandLine const& cl_; + }; + + + // + // + // + struct HomeEmitter : Traversal::Home, Emitter + { + HomeEmitter (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + traverse (Type& h) + { + if (ctx.find (h)) + { + Home::traverse (h); + } + } + }; + + + // HomeExplicitEmitter generates home explicit interface + // + // + struct ExplicitPortEmitter : AttributeEmitter, + Traversal::Operation, + Traversal::HomeFactory, + Traversal::HomeFinder + { + ExplicitPortEmitter (Context& c, ostream& os) + : AttributeEmitter (c, os) + { + } + + // Operation. + // + + virtual void + name (SemanticGraph::Operation& o) + { + os << " " << o.name (); + } + + virtual void + receives_pre (SemanticGraph::Operation&) + { + os << " ("; + } + + virtual void + receives_post (SemanticGraph::Operation&) + { + os << ")"; + } + + virtual void + receives_none (SemanticGraph::Operation&) + { + os << " ()"; + } + + virtual void + raises_pre (SemanticGraph::Operation&) + { + os << " raises ("; + } + + virtual void + raises_post (SemanticGraph::Operation&) + { + os << ")"; + } + + virtual void + post (SemanticGraph::Operation&) + { + os << ";"; + } + + virtual void + comma (SemanticGraph::Operation&) + { + os << ", "; + } + + + // HomeFactory. + // + + virtual void + returns (SemanticGraph::HomeFactory&) + { + os << STRS[COMP_EC] << " "; + } + + virtual void + name (SemanticGraph::HomeFactory& hf) + { + os << " " << hf.name (); + } + + virtual void + receives_pre (SemanticGraph::HomeFactory&) + { + os << " ("; + } + + virtual void + receives_post (SemanticGraph::HomeFactory&) + { + os << ")"; + } + + virtual void + receives_none (SemanticGraph::HomeFactory&) + { + os << " ()"; + } + + virtual void + raises_pre (SemanticGraph::HomeFactory&) + { + os << " raises ("; + } + + virtual void + raises_post (SemanticGraph::HomeFactory&) + { + os << ")"; + } + + virtual void + post (SemanticGraph::HomeFactory&) + { + os << ";"; + } + + virtual void + comma (SemanticGraph::HomeFactory&) + { + os << ", "; + } + + // HomeFinder. + // + + virtual void + returns (SemanticGraph::HomeFinder&) + { + os << STRS[COMP_EC] << " "; + } + + virtual void + name (SemanticGraph::HomeFinder& hf) + { + os << " " << hf.name (); + } + + virtual void + receives_pre (SemanticGraph::HomeFinder&) + { + os << " ("; + } + + virtual void + receives_post (SemanticGraph::HomeFinder&) + { + os << ")"; + } + + virtual void + receives_none (SemanticGraph::HomeFinder&) + { + os << " ()"; + } + + virtual void + raises_pre (SemanticGraph::HomeFinder&) + { + os << " raises ("; + } + + virtual void + raises_post (SemanticGraph::HomeFinder&) + { + os << ")"; + } + + virtual void + post (SemanticGraph::HomeFinder&) + { + os << ";"; + } + + virtual void + comma (SemanticGraph::HomeFinder&) + { + os << ", "; + } + }; + + struct ParameterEmitter : Traversal::InParameter, + Traversal::OutParameter, + Traversal::InOutParameter, + public Emitter + { + ParameterEmitter (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + pre (InParameter&) + { + os << endl << "in "; + } + + virtual void + pre (OutParameter&) + { + os << endl << "out "; + } + + virtual void + pre (InOutParameter&) + { + os << endl << "inout "; + } + + virtual void + name (InParameter& p) + { + os << " " << p.name (); + } + + virtual void + name (OutParameter& p) + { + os << " " << p.name (); + } + + virtual void + name (InOutParameter& p) + { + os << " " << p.name (); + } + }; + + struct HomeExplicitEmitter : HomeEmitter + { + HomeExplicitEmitter (Context& c, ostream& os) + : HomeEmitter (c, os), name_emitter (c, os, "CCM_", "Explicit") + { + edge_traverser (inherits); + inherits.node_traverser (name_emitter); + } + + virtual void + pre (Type&) + { + os << "local interface "; + } + + virtual void + name (Type& h) + { + os << "CCM_" << h.name () << "Explicit"; + } + + virtual void + inherits_pre (Type&) + { + os << " : "; + } + + virtual void + inherits_none (Type&) + { + os << " : ::Components::HomeExecutorBase"; + } + + virtual void + supports_pre (Type&) + { + os << ", "; + } + + virtual void + names_pre (Type&) + { + os << "{"; + } + + virtual void + names_post (Type&) + { + os << "}"; + } + + virtual void + post (Type&) + { + os << ";"; + } + + virtual void + comma (Type&) + { + os << ", "; + } + + private: + Traversal::Inherits inherits; + NameMangler name_emitter; + }; + + + // HomeImplicitEmitter generates home implicit interface + // + // + struct HomeImplicitEmitter : HomeEmitter + { + HomeImplicitEmitter (Context& c, ostream& os) + : HomeEmitter (c, os) + { + } + + virtual void + pre (Type&) + { + os << "local interface "; + } + + virtual void + name (Type& h) + { + os << "CCM_" << h.name () << "Implicit"; + } + + virtual void + names (Type&) + { + os << "{" + << STRS[COMP_EC] << " " + << "create () raises (" << STRS[EXCP_CE] << ");" + << "}"; + } + + virtual void + post (Type&) + { + os << ";"; + } + }; + + + // HomeMainEmitter generates home main interface + // + // + struct HomeMainEmitter : HomeEmitter + { + HomeMainEmitter (Context& c, ostream& os) + : HomeEmitter (c, os) + { + } + + virtual void + pre (Type&) + { + os << "local interface "; + } + + virtual void + name (Type& h) + { + os << "CCM_" << h.name (); + } + + virtual void + inherits (Type& h) + { + os << " : " + << "CCM_" << h.name () << "Explicit, " + << "CCM_" << h.name () << "Implicit"; + } + + virtual void + names (Type&) + { + os << "{}"; + } + + virtual void + post (Type&) + { + os << ";"; + } + }; + + // + // + // + struct ModuleEmitter : Traversal::Module, Emitter + { + ModuleEmitter (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + traverse (Type& m) + { + if (has_elements (m)) + { + Traversal::Module::traverse (m); + } + } + + virtual void + pre (Type&) + { + os << "module "; + } + + virtual void + name (Type& m) + { + os << m.name (); + } + + virtual void + names_pre (Type&) + { + os << "{"; + } + + virtual void + names_post (Type&) + { + os << "}"; + } + + virtual void + post (Type&) + { + os << ";"; + } + + private: + + template + struct Finder : T + { + Finder (Context& c, bool& r) + : ctx (c), r_ (r) + { + } + + virtual void + traverse (typename T::Type& t) + { + if (ctx.find (t)) r_ = true; + } + + private: + Context& ctx; + bool& r_; + }; + + + struct InterfaceFwdFinder : Traversal::UnconstrainedInterface + { + InterfaceFwdFinder (Context const& c, bool& r) + : ctx (c), r_ (r) + { + } + + virtual void + traverse (Type& i) + { + // Make sure we use const version of find_fwd. + // + if (ctx.find_fwd (i)) r_ = true; + } + + private: + Context const& ctx; + bool& r_; + }; + + bool + has_elements (Type& m) + { + bool r (false); + + Traversal::Module module; + Traversal::Defines defines; + Traversal::Mentions mentions; + + module.edge_traverser (defines); + module.edge_traverser (mentions); + + //@@ MSVC bug: interface is considered to be an alias for a struct. + // + Finder composition (ctx, r); + Finder interface_ (ctx, r); + InterfaceFwdFinder interface_fwd (ctx, r); + Finder component (ctx, r); + Finder home (ctx, r); + + defines.node_traverser (module); + defines.node_traverser (composition); + defines.node_traverser (interface_); + defines.node_traverser (component); + defines.node_traverser (home); + + mentions.node_traverser (interface_fwd); + + module.traverse (m); + + return r; + } + }; + + // + // + // + struct InterfaceFwdEmitter : Traversal::UnconstrainedInterface, Emitter + { + InterfaceFwdEmitter (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + traverse (Type& i) + { + if (ctx.find_fwd (i)) + { + os << "local interface CCM_" << i.name () << ";"; + } + } + }; + + // + // + // + struct InterfaceEmitter : Traversal::UnconstrainedInterface, Emitter + { + InterfaceEmitter (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + traverse (Type& i) + { + if (ctx.find (i)) + { + // No need to emit forward declarations anymore. + // + ctx.find_fwd (i); + + Traversal::UnconstrainedInterface::traverse (i); + } + } + + virtual void + pre (Type&) + { + os << "local interface "; + } + + virtual void + name (Type& i) + { + os << "CCM_" << i.name (); + } + + virtual void + inherits (Type& i) + { + os << " : " << i.name (); + } + + virtual void + names_pre (Type&) + { + os << "{"; + } + + virtual void + names_post (Type&) + { + os << "}"; + } + + virtual void + post (Type&) + { + os << ";"; + } + }; + + + // + // + // + struct CompositionEmitter : Traversal::Composition, Emitter + { + CompositionEmitter (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + traverse (Type& c) + { + if (ctx.find (c)) + { + Traversal::Composition::traverse (c); + } + } + + virtual void + pre (Type&) + { + os << "module "; + } + + virtual void + name (Type& m) + { + os << "CIDL_" << m.name (); + } + + virtual void + names_pre (Type&) + { + os << "{"; + } + + virtual void + names_post (Type&) + { + os << "}"; + } + + virtual void + post (Type&) + { + os << ";"; + } + }; + + + struct ComponentContextEmitter : Traversal::ComponentExecutor, Emitter + { + ComponentContextEmitter (Context& c, ostream& os) + : Emitter (c, os), + name_emitter_ (c, os, "CCM_", "_Context") + { + implements_traverser_.node_traverser (name_emitter_); + } + + virtual void + pre (Type& i) + { + //@@ This code temporarily generates typedef. Should be changed + // when we have proper C++ generated code. + // + // os << "local interface "; + os << "typedef "; + Traversal::ComponentExecutor::implements (i, implements_traverser_); + } + + virtual void + name (Type& i) + { + //@@ need to check if spec prescribes this name. + // + os << " " << i.name () << "_Context;"; + } + + virtual void + implements (Type&) + { + // os << " : "; + + // Traversal::ComponentExecutor::implements (i, implements_traverser_); + + // os << ", " + // << STRS[COMP_SC]; + } + + virtual void + post (Type&) + { + // os << "{};"; + } + + private: + NameMangler name_emitter_; + Traversal::Implements implements_traverser_; + }; + + + struct ComponentExecutorEmitter : Traversal::ComponentExecutor, Emitter + { + ComponentExecutorEmitter (Context& c, ostream& os) + : Emitter (c, os), + name_emitter_ (c, os, "CCM_") + { + implements_traverser_.node_traverser (name_emitter_); + } + + virtual void + pre (Type&) + { + os << "local interface "; + } + + virtual void + name (Type& i) + { + os << i.name (); + } + + virtual void + implements (Type& i) + { + os << " : "; + + Traversal::ComponentExecutor::implements (i, implements_traverser_); + + os << ", " + << "::Components::SessionComponent"; + } + + virtual void + post (Type&) + { + os << "{};"; + } + + private: + NameMangler name_emitter_; + Traversal::Implements implements_traverser_; + }; + + + struct HomeExecutorEmitter : Traversal::HomeExecutor, Emitter + { + HomeExecutorEmitter (Context& c, ostream& os) + : Emitter (c, os), + name_emitter_ (c, os, "CCM_") + { + implements_traverser_.node_traverser (name_emitter_); + } + + virtual void + pre (Type&) + { + os << "local interface "; + } + + virtual void + name (Type& i) + { + os << i.name (); + } + + virtual void + implements (Type& i) + { + os << " : "; + + Traversal::HomeExecutor::implements (i, implements_traverser_); + } + + virtual void + post (Type&) + { + os << "{};"; + } + + private: + NameMangler name_emitter_; + Traversal::Implements implements_traverser_; + }; + + // + // + // + struct IncludesEmitter : Traversal::QuoteIncludes, + Traversal::BracketIncludes, + Emitter + { + IncludesEmitter (Context& c, ostream& os) + : Emitter (c, os) + { + } + + virtual void + traverse (SemanticGraph::QuoteIncludes& qi) + { + os << "#include \"" << qi.file ().string () << "\"" << endl; + } + + virtual void + traverse (SemanticGraph::BracketIncludes& bi) + { + os << "#include <" << bi.file ().string () << ">" << endl; + } + }; +} + +void ExecutorMappingGenerator:: +options (CL::Description& d) +{ + d.add_option (CL::OptionDescription ( + "lem-force-all", + "Force generation of local executor mapping for all IDL " + "types including those not used (directly or inderectly) " + "by compositions. This option is useful for generating a " + "common portion of local executor mapping used by more " + "than one component or composition.", + CL::OptionType::flag)); + + d.add_option (CL::OptionDescription ( + "lem-file-suffix", + "suffix", + "Use provided suffix instead of default \'E\' " + "when constructing name of local executor mapping file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "lem-file-regex", + "regex", + "Use provided regular expression when constructing " + "name of local executor mapping file.", + CL::OptionType::value)); +} + + +void ExecutorMappingGenerator:: +generate (CommandLine const& cl, + TranslationUnit& tu, + fs::path const& file_path) +{ + fs::ofstream ofs; + + string file_name (file_path.empty () ? "" : file_path.leaf ()); + + if (!file_name.empty ()) + { + string file_name (file_path.leaf ()); + + string suffix (cl.get_value ("lem-file-suffix", "E.idl")); + + string expr (cl.get_value ( + "lem-file-regex", + "/^(.+?)(\\.(idl|cidl|cdl))?$/$1" + suffix + "/")); + + string lem_file_name (regex::perl_s (file_name, expr)); + + fs::path lem_file_path (lem_file_name); + + ofs.open (lem_file_path, std::ios_base::out); + + if (!ofs.is_open ()) + { + cerr << lem_file_name << ": error: unable to open in write mode" + << endl; + return; + } + } + + ostream& os = ofs.is_open () + ? static_cast (ofs) + : static_cast (std::cout); + + // Dump file header. + // + os << COPYRIGHT; + + // Set auto-indentation for os. + // + Indentation::Implanter guard (os); + + Context ctx (tu); + + if (cl.get_value ("lem-force-all", false)) + { + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion region; + + contains_principal.node_traverser (region); + + + // Layer 2 + // + Traversal::ContainsRoot contains_root; + region.edge_traverser (contains_root); + + //-- + Traversal::Root root; + contains_root.node_traverser (root); + + + // Layer 3 + // + Traversal::Defines defines; + root.edge_traverser (defines); + + //-- + Traversal::Module module; + HomeCollector home (ctx); + ComponentCollector component (ctx); + InterfaceCollector interface_ (ctx); + + defines.node_traverser (module); + defines.node_traverser (home); + defines.node_traverser (component); + defines.node_traverser (interface_); + + // Layer 4 + // + Traversal::Defines component_defines; + Traversal::Inherits component_inherits; + Traversal::Inherits home_inherits; + + module.edge_traverser (defines); + + home.edge_traverser (home_inherits); + component.edge_traverser (component_defines); + component.edge_traverser (component_inherits); + + //-- + + Traversal::Provider provider; + + component_defines.node_traverser (provider); + component_inherits.node_traverser (component); + home_inherits.node_traverser (home); + + + // Layer 5 + // + Traversal::Belongs provider_belongs; + provider.edge_traverser (provider_belongs); + + // + provider_belongs.node_traverser (interface_); + + // end + + unit.traverse (tu); + } + else + { + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion region; + + contains_principal.node_traverser (region); + + + // Layer 2 + // + Traversal::ContainsRoot contains_root; + Traversal::Includes includes; + + region.edge_traverser (contains_root); + region.edge_traverser (includes); + + //-- + Traversal::Root root; + + contains_root.node_traverser (root); + includes.node_traverser (region); + + + // Layer 3 + // + Traversal::Defines defines; + root.edge_traverser (defines); + + //-- + Traversal::Module module; + CompositionCollector composition (ctx); + + defines.node_traverser (module); + defines.node_traverser (composition); + + + // Layer 4 + // + Traversal::Defines composition_defines; + + module.edge_traverser (defines); + composition.edge_traverser (composition_defines); + + //-- + Traversal::ComponentExecutor component_executor; + Traversal::HomeExecutor home_executor; + + composition_defines.node_traverser (component_executor); + composition_defines.node_traverser (home_executor); + + // Layer 5 + // + Traversal::Implements component_executor_implements; + Traversal::Implements home_executor_implements; + + component_executor.edge_traverser (component_executor_implements); + home_executor.edge_traverser (home_executor_implements); + + //-- + ComponentCollector component (ctx); + HomeCollector home (ctx); + + component_executor_implements.node_traverser (component); + home_executor_implements.node_traverser (home); + + + // Layer 6 + // + Traversal::Defines component_defines; + Traversal::Inherits component_inherits; + Traversal::Inherits home_inherits; + + component.edge_traverser (component_defines); + component.edge_traverser (component_inherits); + home.edge_traverser (home_inherits); + + //-- + + Traversal::Provider provider; + + component_defines.node_traverser (provider); + component_inherits.node_traverser (component); + home_inherits.node_traverser (home); + + + // Layer 7 + // + Traversal::Belongs provider_belongs; + provider.edge_traverser (provider_belongs); + + // + InterfaceCollector interface_ (ctx); + + provider_belongs.node_traverser (interface_); + + + // end + + unit.traverse (tu); + } + + { + os << "#include \"ciao/CCM_Container.idl\"" << endl; + + if (cl.get_value ("lem-force-all", false) && !file_name.empty ()) + { + os << "#include \"" << file_name << '\"' << endl; + } + + string swap_option = cl.get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + if (swapping) + { + os << "#include " << endl; + } + + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion principal_region; + + contains_principal.node_traverser (principal_region); + + + // Layer 2 + // + Traversal::TranslationRegion included_region; + + // Inclusion handling is somewhat tricky because we want + // to print only top-level #include's. + // + + Traversal::ContainsRoot contains_root; + Traversal::QuoteIncludes quote_includes; + Traversal::BracketIncludes bracket_includes; + IncludesEmitter includes_emitter (ctx, os); + + + principal_region.edge_traverser (includes_emitter); + principal_region.edge_traverser (quote_includes); + principal_region.edge_traverser (bracket_includes); + principal_region.edge_traverser (contains_root); + + included_region.edge_traverser (quote_includes); + included_region.edge_traverser (bracket_includes); + included_region.edge_traverser (contains_root); + + + //-- + Traversal::Root root; + + contains_root.node_traverser (root); + quote_includes.node_traverser (included_region); + bracket_includes.node_traverser (included_region); + + + // Layer 3 + // + Traversal::Defines defines; + Traversal::Mentions mentions; + root.edge_traverser (defines); + root.edge_traverser (mentions); + + //-- + ModuleEmitter module (ctx, os); + + CompositionEmitter composition (ctx, os); + + InterfaceEmitter interface_ (ctx, os); + InterfaceFwdEmitter interface_fwd (ctx, os); + + MonolithEmitter component_monolith (ctx, os); + ContextEmitter component_context (ctx, os, cl); + + HomeImplicitEmitter home_implicit (ctx, os); + HomeExplicitEmitter home_explicit (ctx, os); + HomeMainEmitter home_main (ctx, os); + + defines.node_traverser (module); + + defines.node_traverser (composition); + + defines.node_traverser (interface_); + mentions.node_traverser (interface_fwd); + + defines.node_traverser (component_monolith); + defines.node_traverser (component_context); + + defines.node_traverser (home_implicit); + defines.node_traverser (home_explicit); + defines.node_traverser (home_main); + + // Layer 4 + // + + Traversal::Supports supports; + + Traversal::Defines composition_defines; + + Traversal::Defines component_context_defines; + + Traversal::Defines home_explicit_defines; + + module.edge_traverser (defines); + module.edge_traverser (mentions); + + composition.edge_traverser (composition_defines); + + component_monolith.edge_traverser (supports); + component_context.edge_traverser (component_context_defines); + + home_explicit.edge_traverser (supports); + home_explicit.edge_traverser (home_explicit_defines); + + //-- + FullTypeNameEmitter type (ctx, os); + + ComponentContextEmitter session_component_context (ctx, os); + ComponentExecutorEmitter session_component_executor (ctx, os); + HomeExecutorEmitter session_home_executor (ctx, os); + + ContextPortEmitter port_context (ctx, os); + ExplicitPortEmitter port_explicit (ctx, os); + + supports.node_traverser (type); + + composition_defines.node_traverser (session_component_context); + composition_defines.node_traverser (session_component_executor); + composition_defines.node_traverser (session_home_executor); + + component_context_defines.node_traverser (port_context); + + home_explicit_defines.node_traverser (port_explicit); + + + // Layer 5 + // + Traversal::Belongs belongs; + Traversal::Receives receives; + Traversal::Raises raises; + + port_context.edge_traverser (belongs); + port_explicit.edge_traverser (belongs); + port_explicit.edge_traverser (raises); + + port_explicit.edge_traverser (receives); + + //-- + ParameterEmitter parameter (ctx, os); + + belongs.node_traverser (type); + receives.node_traverser (parameter); + raises.node_traverser (type); + + // Layer 6 + // + parameter.edge_traverser (belongs); + + + // end + + unit.traverse (tu); + } +} diff --git a/modules/CIAO/CIDLC/ExecutorMappingGenerator.hpp b/modules/CIAO/CIDLC/ExecutorMappingGenerator.hpp new file mode 100644 index 00000000000..b67892c0658 --- /dev/null +++ b/modules/CIAO/CIDLC/ExecutorMappingGenerator.hpp @@ -0,0 +1,32 @@ +// file : CIDLC/ExecutorMappingGenerator.hpp +// author : Boris Kolpackov +// cvs-id : $Id$ + +#ifndef EXECUTOR_MAPPING_GENERATOR_HPP +#define EXECUTOR_MAPPING_GENERATOR_HPP + +#include "CCF/CompilerElements/FileSystem.hpp" + +#include "CCF/CodeGenerationKit/CommandLine.hpp" +#include "CCF/CodeGenerationKit/CommandLineDescriptor.hpp" + +//@@ SemanticGraphFwd could be useful here. +// +#include "CCF/CIDL/SemanticGraph.hpp" + +class ExecutorMappingGenerator +{ +public: + static void + options (CL::Description& d); + + //@@ maybe I should introduce constant and non-constant + // traversal. + // + void + generate (CommandLine const& cl, + CCF::CIDL::SemanticGraph::TranslationUnit&, + fs::path const& file); +}; + +#endif // EXECUTOR_MAPPING_GENERATOR_HPP diff --git a/modules/CIAO/CIDLC/InterfaceEmitter.cpp b/modules/CIAO/CIDLC/InterfaceEmitter.cpp new file mode 100644 index 00000000000..1ce524cdfab --- /dev/null +++ b/modules/CIAO/CIDLC/InterfaceEmitter.cpp @@ -0,0 +1,26 @@ +// file : CIDLC/InterfaceEmitter.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "InterfaceEmitter.hpp" + +InterfaceEmitter::InterfaceEmitter (Context& c) + : EmitterBase (c) +{ +} + +void +InterfaceEmitter::traverse (UnconstrainedInterface& i) +{ + if (add (i)) + { + Traversal::UnconstrainedInterface::traverse (i); + } +} + +bool +InterfaceEmitter::add (UnconstrainedInterface& i) +{ + return interfaces_.insert (&i).second; +} + diff --git a/modules/CIAO/CIDLC/InterfaceEmitter.hpp b/modules/CIAO/CIDLC/InterfaceEmitter.hpp new file mode 100644 index 00000000000..fdd2411f912 --- /dev/null +++ b/modules/CIAO/CIDLC/InterfaceEmitter.hpp @@ -0,0 +1,30 @@ +// file : CIDLC/InterfaceEmitter.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef INTERFACEEMITTER_HPP +#define INTERFACEEMITTER_HPP + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +#include "EmitterBase.hpp" + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +struct InterfaceEmitter : Traversal::UnconstrainedInterface, + EmitterBase +{ + InterfaceEmitter (Context& c); + + virtual void traverse (UnconstrainedInterface&); + +private: + bool add (UnconstrainedInterface&); + +private: + std::set interfaces_; +}; + +#endif // INTERFACEEMITTER_HPP diff --git a/modules/CIAO/CIDLC/Literals.cpp b/modules/CIAO/CIDLC/Literals.cpp new file mode 100644 index 00000000000..0ed8f8e9699 --- /dev/null +++ b/modules/CIAO/CIDLC/Literals.cpp @@ -0,0 +1,81 @@ +// file : CIDLC/Literals.hpp +// author : Boris Kolpackov +// cvs-id : $Id$ + +#include "Literals.hpp" + +namespace StringLiterals +{ + char const* const COPYRIGHT = + "// $I" "d$\n" + "//\n" + "// **** Code generated by the ****\n" + "// **** Component Integrated ACE ORB (CIAO) CIDL Compiler ****\n" + "// CIAO has been developed by:\n" + "// Center for Distributed Object Computing\n" + "// Washington University\n" + "// St. Louis, MO\n" + "// USA\n" + "// http://www.cs.wustl.edu/~schmidt/doc-center.html\n" + "// CIDL Compiler has been developed by:\n" + "// Institute for Software Integrated Systems\n" + "// Vanderbilt University\n" + "// Nashville, TN\n" + "// USA\n" + "// http://www.isis.vanderbilt.edu/\n" + "//\n" + "// Information about CIAO is available at:\n" + "// http://www.dre.vanderbilt.edu/CIAO" + "\n\n"; + + char const* const STRS[LIT_SIZE] = + { + // Common CORBA and all Components exceptions. + "ACE_THROW_SPEC (( ::CORBA::SystemException))", // EXCP_SNGL + "ACE_THROW_SPEC ((", // EXCP_START + "::CORBA::SystemException", // EXCP_SYS + "::CORBA::BAD_PARAM ()", // EXCP_BP + "::Components::IllegalState", // EXCP_IS + "::Components::AlreadyConnected", // EXCP_AC + "::Components::InvalidConnection", // EXCP_IC + "::Components::NoConnection", // EXCP_NC + "::Components::ExceededConnectionLimit", // EXCP_ECL + "::Components::InvalidName", // EXCP_IN + "::Components::RemoveFailure", // EXCP_RF + "::Components::NoKeyAvailable", // EXCP_NKA + "::Components::InvalidConfiguration", // EXCP_ICF + "::Components::CookieRequired", // EXCP_CR + "::Components::BadEventType", // EXCP_BET + "::Components::CCMException", // EXCP_CE + + // Commonly used Components module members. + "::Components::Cookie", // COMP_CK + "::Components::NameList & /* names */", // COMP_NAMES + "::Components::EventConsumerBase", // COMP_ECB + "::Components::EnterpriseComponent", // COMP_EC + "::Components::SessionContext", // COMP_SC + "::Components::ConsumerDescriptions", // COMP_CD + "::Components::ReceptacleDescriptions", // COMP_RD + "::Components::PublisherDescriptions", // COMP_PD + "::Components::EmitterDescriptions", // COMP_ED + + // This could change - don't want it scattered all over. + "namespace CIDL_", // CIDL_NS + "CIAO_FACET", // FACET_PREFIX + + // Labels for things stored in a SyntaxTree node's Context. + "CIDLC::RepositoryIdGenerator::TypeId", // TYPE_ID + "CIDLC::RepositoryIdGenerator::TypePrefix", // TYPE_PREFIX + "CIDLC::RepositoryIdGenerator::RepoId", // REPO_ID + + "// Your code here.", // YCH + "//==================================================================", // SEP + + "variable-size", // VAR_SIZE + "_ciao_extract_val", // EXTRACT + "_ciao_extract_tmp", // EXTRACT_TMP + "ACE_UNUSED_ARG", // ACE_UA + "ACE_THROW_RETURN" // ACE_TR + }; +} + diff --git a/modules/CIAO/CIDLC/Literals.hpp b/modules/CIAO/CIDLC/Literals.hpp new file mode 100644 index 00000000000..09e2a8cb7c4 --- /dev/null +++ b/modules/CIAO/CIDLC/Literals.hpp @@ -0,0 +1,58 @@ +// file : CIDLC/Literals.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef LITERALS_HPP +#define LITERALS_HPP + +namespace StringLiterals +{ + extern char const* const COPYRIGHT; + + // Index into the string array in Literals.cpp. + enum + { + EXCP_SNGL, + EXCP_START, + EXCP_SYS, + EXCP_BP, + EXCP_IS, + EXCP_AC, + EXCP_IC, + EXCP_NC, + EXCP_ECL, + EXCP_IN, + EXCP_RF, + EXCP_NKA, + EXCP_ICF, + EXCP_CR, + EXCP_BET, + EXCP_CE, + COMP_CK, + COMP_NAMES, + COMP_ECB, + COMP_EC, + COMP_SC, + COMP_CD, + COMP_RD, + COMP_PD, + COMP_ED, + CIDL_NS, + FACET_PREFIX, + TYPE_ID, + TYPE_PREFIX, + REPO_ID, + YCH, + SEP, + VAR_SIZE, + EXTRACT, + EXTRACT_TMP, + ACE_UA, + ACE_TR, + LIT_SIZE + }; + + extern char const* const STRS[LIT_SIZE]; +} + +#endif // LITERALS_HPP diff --git a/modules/CIAO/CIDLC/ModuleEmitter.cpp b/modules/CIAO/CIDLC/ModuleEmitter.cpp new file mode 100644 index 00000000000..990d95ef4b8 --- /dev/null +++ b/modules/CIAO/CIDLC/ModuleEmitter.cpp @@ -0,0 +1,22 @@ +// file : CIDLC/ModuleEmitter.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "ModuleEmitter.hpp" + +ModuleEmitter::ModuleEmitter (Context& c) + : EmitterBase (c) +{ +} + +void +ModuleEmitter::pre (Type& t) +{ + os << "namespace " << t.name () << "{"; +} + +void +ModuleEmitter::post (Type&) +{ + os << "}"; +} diff --git a/modules/CIAO/CIDLC/ModuleEmitter.hpp b/modules/CIAO/CIDLC/ModuleEmitter.hpp new file mode 100644 index 00000000000..9aa8de2f9ff --- /dev/null +++ b/modules/CIAO/CIDLC/ModuleEmitter.hpp @@ -0,0 +1,24 @@ +// file : CIDLC/ModuleEmitter.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef MODULEEMITTER_HPP +#define MODULEEMITTER_HPP + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +#include "EmitterBase.hpp" + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +struct ModuleEmitter : Traversal::Module, EmitterBase +{ + ModuleEmitter (Context& c); + + virtual void pre (Type&); + virtual void post (Type&); +}; + +#endif // MODULEEMITTER_HPP diff --git a/modules/CIAO/CIDLC/OperationHeaderEmitters.cpp b/modules/CIAO/CIDLC/OperationHeaderEmitters.cpp new file mode 100644 index 00000000000..e41e3d6d023 --- /dev/null +++ b/modules/CIAO/CIDLC/OperationHeaderEmitters.cpp @@ -0,0 +1,264 @@ +// file : CIDLC/OperationHeaderEmitters.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "OperationHeaderEmitters.hpp" +#include "Literals.hpp" + +using namespace StringLiterals; + +OperationEmitter::OperationEmitter (Context& c) + : EmitterBase (c) +{ +} + +void +OperationEmitter::pre (Type&) +{ + os << "virtual "; +} + +void +OperationEmitter::name (Type& o) +{ + os << endl << o.name (); +} + +void +OperationEmitter::receives_pre (Type&) +{ + os << " (" << endl; +} + +void +OperationEmitter::receives_none (Type&) +{ + os << " ()" << endl; +} + +void +OperationEmitter::receives_post (Type&) +{ + os << endl << ")" << endl; +} + +void +OperationEmitter::raises_pre (Type&) +{ + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; +} + +void +OperationEmitter::raises_none (Type&) +{ + os << STRS[EXCP_SNGL]; +} + +void +OperationEmitter::raises_post (Type&) +{ + os << "))"; +} + +void +OperationEmitter::post (Type&) +{ + os << ";" << endl; +} + +void +OperationEmitter::comma (Type&) +{ + os << "," << endl; +} + +// ================================================== + +HomeOperationEmitter::HomeOperationEmitter (Context& c) + : OperationEmitter (c) +{ +} + +void +HomeOperationEmitter::traverse (SemanticGraph::HomeFactory&) +{ +} + +void +HomeOperationEmitter::traverse (SemanticGraph::HomeFinder&) +{ +} + +// ================================================== + +FactoryOperationEmitter::FactoryOperationEmitter (Context& c, bool for_exec) + : EmitterBase (c), + returns_emitter_ (c), + for_exec_ (for_exec) +{ + returns_.node_traverser (returns_emitter_); +} + +void +FactoryOperationEmitter::pre (SemanticGraph::HomeFactory&) +{ + os << "virtual "; +} + +void +FactoryOperationEmitter::returns (SemanticGraph::HomeFactory& t) +{ + if (for_exec_) + { + os << STRS[COMP_EC] << "_ptr"; + } + else + { + Traversal::HomeFactory::returns (t, returns_); + } + + os << endl; +} + +void +FactoryOperationEmitter::name (SemanticGraph::HomeFactory& t) +{ + os << t.name (); +} + +void +FactoryOperationEmitter::receives_none (SemanticGraph::HomeFactory&) +{ + os << " ()" << endl; +} + +void +FactoryOperationEmitter::receives_pre (SemanticGraph::HomeFactory&) +{ + os << " (" << endl; +} + +void +FactoryOperationEmitter::receives_post (SemanticGraph::HomeFactory&) +{ + os << endl << ")" << endl; +} + +void +FactoryOperationEmitter::raises_none (SemanticGraph::HomeFactory&) +{ + os << STRS[EXCP_SNGL]; +} + +void +FactoryOperationEmitter::raises_pre (SemanticGraph::HomeFactory&) +{ + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; +} + +void +FactoryOperationEmitter::raises_post (SemanticGraph::HomeFactory&) +{ + os << "))"; +} + +void +FactoryOperationEmitter::post (SemanticGraph::HomeFactory&) +{ + os << ";" << endl; +} + +void +FactoryOperationEmitter::comma (SemanticGraph::HomeFactory&) +{ + os << "," << endl; +} + +// ================================================== + +FinderOperationEmitter::FinderOperationEmitter (Context& c, bool for_exec) + : EmitterBase (c), + returns_emitter_ (c), + for_exec_ (for_exec) +{ + returns_.node_traverser (returns_emitter_); +} + +void +FinderOperationEmitter::pre (SemanticGraph::HomeFinder&) +{ + os << "virtual "; +} + +void +FinderOperationEmitter::returns (SemanticGraph::HomeFinder& t) +{ + if (for_exec_) + { + os << STRS[COMP_EC] << "_ptr"; + } + else + { + Traversal::HomeFinder::returns (t, returns_); + } + + os << endl; +} + +void +FinderOperationEmitter::name (SemanticGraph::HomeFinder& t) +{ + os << t.name (); +} + +void +FinderOperationEmitter::receives_none (SemanticGraph::HomeFinder&) +{ + os << " ()" << endl; +} + +void +FinderOperationEmitter::receives_pre (SemanticGraph::HomeFinder&) +{ + os << " (" << endl; +} + +void +FinderOperationEmitter::receives_post (SemanticGraph::HomeFinder&) +{ + os << endl << ")" << endl; +} + +void +FinderOperationEmitter::raises_none (SemanticGraph::HomeFinder&) +{ + os << STRS[EXCP_SNGL]; +} + +void +FinderOperationEmitter::raises_pre (SemanticGraph::HomeFinder&) +{ + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; +} + +void +FinderOperationEmitter::raises_post (SemanticGraph::HomeFinder&) +{ + os << "))"; +} + +void +FinderOperationEmitter::post (SemanticGraph::HomeFinder&) +{ + os << ";" << endl; +} + +void +FinderOperationEmitter::comma (SemanticGraph::HomeFinder&) +{ + os << "," << endl; +} + diff --git a/modules/CIAO/CIDLC/OperationHeaderEmitters.hpp b/modules/CIAO/CIDLC/OperationHeaderEmitters.hpp new file mode 100644 index 00000000000..d1fc148e0c3 --- /dev/null +++ b/modules/CIAO/CIDLC/OperationHeaderEmitters.hpp @@ -0,0 +1,151 @@ +// file : CIDLC/OperationHeaderEmitters.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef OPERATIONHEADEREMITTERS_HPP +#define OPERATIONHEADEREMITTERS_HPP + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +#include "EmitterBase.hpp" +#include "CorbaTypeNameEmitters.hpp" + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +struct OperationEmitter : Traversal::Operation, + EmitterBase +{ + OperationEmitter (Context& c); + + virtual void pre (Type&); + + virtual void name (Type&); + + virtual void receives_pre (Type&); + + virtual void receives_none (Type&); + + virtual void receives_post (Type&); + + virtual void raises_pre (Type&); + + virtual void raises_none (Type&); + + virtual void raises_post (Type&); + + virtual void post (Type&); + + virtual void comma (Type&); +}; + +// HomeFactory and HomeFinder are tied to Operation in +// the front end. Since we want to treat them differently +// than regular operations in a home (we want to generate +// base class factory operations returning the base component, +// for example), we use this class for regular home operations +// that overrides HomeFactory and HomeFinder traversals +// to do nothing. +struct HomeOperationEmitter : OperationEmitter, + Traversal::HomeFactory, + Traversal::HomeFinder +{ + HomeOperationEmitter (Context& c); + + virtual void + traverse (SemanticGraph::HomeFactory&); + + virtual void + traverse (SemanticGraph::HomeFinder&); +}; + +struct FactoryOperationEmitter : Traversal::HomeFactory, + EmitterBase +{ + FactoryOperationEmitter (Context& c, bool for_exec = false); + + virtual void + pre (SemanticGraph::HomeFactory&); + + virtual void + returns (SemanticGraph::HomeFactory&); + + virtual void + name (SemanticGraph::HomeFactory&); + + virtual void + receives_none (SemanticGraph::HomeFactory&); + + virtual void + receives_pre (SemanticGraph::HomeFactory&); + + virtual void + receives_post (SemanticGraph::HomeFactory&); + + virtual void + raises_none (SemanticGraph::HomeFactory&); + + virtual void + raises_pre (SemanticGraph::HomeFactory&); + + virtual void + raises_post (SemanticGraph::HomeFactory&); + + virtual void + post (SemanticGraph::HomeFactory&); + + virtual void + comma (SemanticGraph::HomeFactory&); + +private: + ReturnTypeNameEmitter returns_emitter_; + Traversal::Returns returns_; + bool for_exec_; +}; + +struct FinderOperationEmitter : Traversal::HomeFinder, + EmitterBase +{ + FinderOperationEmitter (Context& c, bool for_exec = false); + + virtual void + pre (SemanticGraph::HomeFinder&); + + virtual void + returns (SemanticGraph::HomeFinder&); + + virtual void + name (SemanticGraph::HomeFinder&); + + virtual void + receives_none (SemanticGraph::HomeFinder&); + + virtual void + receives_pre (SemanticGraph::HomeFinder&); + + virtual void + receives_post (SemanticGraph::HomeFinder&); + + virtual void + raises_none (SemanticGraph::HomeFinder&); + + virtual void + raises_pre (SemanticGraph::HomeFinder&); + + virtual void + raises_post (SemanticGraph::HomeFinder&); + + virtual void + post (SemanticGraph::HomeFinder&); + + virtual void + comma (SemanticGraph::HomeFinder&); + +private: + ReturnTypeNameEmitter returns_emitter_; + Traversal::Returns returns_; + bool for_exec_; +}; + +#endif // OPERATIONHEADEREMITTERS_HPP diff --git a/modules/CIAO/CIDLC/ParameterEmitter_T.hpp b/modules/CIAO/CIDLC/ParameterEmitter_T.hpp new file mode 100644 index 00000000000..4fe0d55867f --- /dev/null +++ b/modules/CIAO/CIDLC/ParameterEmitter_T.hpp @@ -0,0 +1,33 @@ +// file : CIDLC/ParameterEmitter_T.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef PARAMETEREMITTER_T_HPP +#define PARAMETEREMITTER_T_HPP + +#include "EmitterBase.hpp" + +// For generating parameter names. +template +struct ParameterEmitter : T, EmitterBase +{ + ParameterEmitter (Context& c, bool for_exec_src = false) + : EmitterBase (c), + for_exec_src_ (for_exec_src) + { + } + + virtual void + name (typename T::Type& p) + { + os << " " + << (for_exec_src_ ? "/* " : "") + << p.name () + << (for_exec_src_ ? " */" : ""); + } + +private: + bool for_exec_src_; +}; + +#endif // PARAMETEREMITTER_T_HPP diff --git a/modules/CIAO/CIDLC/README.html b/modules/CIAO/CIDLC/README.html new file mode 100644 index 00000000000..97388a54ce7 --- /dev/null +++ b/modules/CIAO/CIDLC/README.html @@ -0,0 +1,95 @@ + + + + + + + + + CIAO CIDL Compiler Synopsis + + + + + + + + + + +

CIAO CIDL compiler README

+

Before continuing, please note that + +pre-built binary +executables of CIDL compiler are available for different platforms +The CIDL compiler options are documented here.

+ +

The C++ source files in this directory are compiled into the +code generators and driver for the CIAO CIDL compiler. CORBA +Compiler Framework (CCF) provides the front-end for the compiler. +To build CIDL compiler you will need to compile CCF libraries +first. Please refer to +instructions for building CCF libraries.

+ +

After you have compiled the CCF libraries, you are ready to build the +CIDLC compiler. In order to build the compiler, you must generate the +appropriate project files. If there are makefiles, or project solutions, +already in the directory, please disgard them since because they can be +out-of-date, or invalid. To regenerate all project files, type the following +command: +

+%> $ACE_ROOT/bin/mwc.pl -type <project-type> -static -features cidl=1,exceptions=1,boost=1 CIDLC.mwc
+
+ +Once MPC finishes generating the project files, you can now build CIDLC. + +
    +
  • On Linux/UNIX: +

    If you are building with a make utility, e.g., gmake, use the following command to build CCF: + +

    %> gmake cidl=1 exceptions=1 boost=1

    • +
  • On Windows:

    Just open the generated solution file.

    • +
+

Note: If you are building CCF on a Windows platform, use %ACE_ROOT%\bin\mwc.pl instead + +of $ACE_ROOT/bin/mwc.pl. Also, for a list of project types and other command-line options +supported by MPC, type $ACE_ROOT/bin/mwc.pl --help.

+ + + diff --git a/modules/CIAO/CIDLC/RepositoryIdGenerator.cpp b/modules/CIAO/CIDLC/RepositoryIdGenerator.cpp new file mode 100644 index 00000000000..03a28ab8b7e --- /dev/null +++ b/modules/CIAO/CIDLC/RepositoryIdGenerator.cpp @@ -0,0 +1,289 @@ +// file : CIDLC/RepositoryIdGenerator.cpp +// author : Boris Kolpackov +// cvs-id : $Id$ + +#include "RepositoryIdGenerator.hpp" +#include "Literals.hpp" + +#include "CCF/CompilerElements/Diagnostic.hpp" +#include "CCF/CIDL/Traversal.hpp" +#include "CCF/CodeGenerationKit/Regex.hpp" + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; +using namespace StringLiterals; +using namespace std; + +namespace +{ + Nameable* defined_in (Nameable& n) + { + for (Nameable::NamedIterator i (n.named_begin ()), e (n.named_end ()); + i != e; + ++i) + { + if (Defines* d = dynamic_cast (*i)) + { + return &d->scope (); + } + } + + return 0; + } + + void + compute_new_repo_id (Nameable& d) + { + string prefix (""); + TypePrefix *tp = 0; + + if (d.context ().count (STRS[TYPE_PREFIX])) + { + tp = d.context ().get (STRS[TYPE_PREFIX]); + prefix = tp->prefix ().literal (); + } + else + { + Nameable* parent = defined_in (d); + + while (parent != 0) + { + if (parent->context ().count (STRS[TYPE_PREFIX])) + { + tp = + parent->context ().get (STRS[TYPE_PREFIX]); + + prefix = tp->prefix ().literal (); + break; + } + + parent = defined_in (*parent); + } + } + + if (prefix != "") prefix += "/"; + + ScopedName scoped (d.scoped_name ()); + Name stripped (scoped.begin () + 1, scoped.end ()); + + string scope_name = regex::perl_s (stripped.unescaped_str (), "%::%/%"); + + string repo_id = "IDL:" + prefix + scope_name + ":1.0"; + + d.context ().set (STRS[REPO_ID], repo_id); + } + + void + compute_repo_id (Nameable& d) + { + if (d.context ().count (STRS[REPO_ID])) + { + return; + } + else + { + compute_new_repo_id (d); + } + } +} + +namespace +{ + class TypeIdLabelGenerator : public Traversal::TypeId + { + public: + TypeIdLabelGenerator (Diagnostic::Stream& dout, + TranslationUnit& tu) + : dout_ (dout), + tu_ (tu) + { + } + + virtual void + traverse (SemanticGraph::TypeId& ti) + { + ScopedName decl_name (ti.declaration ()); + Nameables ref = tu_.lookup (decl_name); + + for (Nameables::const_iterator iter (ref.begin ()); + iter != ref.end (); + ++iter) + { + Nameable *decl = *iter; + + if (decl->context ().count (STRS[TYPE_ID])) + { + //@@ Seems it should contain filename and line + // of its origin. + // + Diagnostic::Error err ("???", 0); + + err << "repetition of typeid for " << decl_name + << " is illegal"; + + dout_ << err; + + Diagnostic::Info inf ("???", 0); + + err << "original typeid here"; + + dout_ << inf; + } + else + { + decl->context ().set (STRS[TYPE_ID], &ti); + decl->context ().set (STRS[REPO_ID], ti.id ().literal ()); + } + } + } + + private: + Diagnostic::Stream& dout_; + SemanticGraph::TranslationUnit& tu_; + }; + + class TypePrefixLabelGenerator : public Traversal::TypePrefix + { + public: + TypePrefixLabelGenerator (Diagnostic::Stream& dout, + TranslationUnit& tu) + : dout_ (dout), + tu_ (tu) + { + } + + virtual void + traverse (SemanticGraph::TypePrefix& tp) + { + ScopedName decl_name (tp.declaration ()); + Nameables ref = tu_.lookup (decl_name); + + for (Nameables::const_iterator iter (ref.begin ()); + iter != ref.end (); + ++iter) + { + Nameable *decl = *iter; + CCF::CompilerElements::Context& ctx = decl->context (); + + if (ctx.count (STRS[TYPE_PREFIX])) + { + SemanticGraph::TypePrefix* prev = + ctx.get (STRS[TYPE_PREFIX]); + + if (prev->prefix () != tp.prefix ()) + { + //@@ Seems tp should contain filename and line + // of it's origin. + // + Diagnostic::Error err ("???", 0); + + err << "resetting type prefix for " << decl_name + << " is illegal"; + + dout_ << err; + + Diagnostic::Info inf ("???", 0); + + err << "original typeprefix here"; + + dout_ << inf; + } + } + else + { + decl->context ().set (STRS[TYPE_PREFIX], &tp); + + // A typeprefix declaration could appear after the IDL + // type declaration, so we want to update the repo id + // every time. + compute_new_repo_id (*decl); + } + } + } + + private: + Diagnostic::Stream& dout_; + SemanticGraph::TranslationUnit& tu_; + }; + + class RepoIdGenerator : public Traversal::Interface, + public Traversal::EventType, + public Traversal::Home, + public Traversal::Component + { + virtual void + traverse (SemanticGraph::Interface& i) + { + compute_repo_id (i); + } + + virtual void + traverse (SemanticGraph::EventType& e) + { + compute_repo_id (e); + } + + virtual void + traverse (SemanticGraph::Home& h) + { + compute_repo_id (h); + } + + virtual void + traverse (SemanticGraph::Component& c) + { + compute_repo_id (c); + } + }; +} + + +bool RepositoryIdGenerator::generate (TranslationUnit& u) +{ + Diagnostic::Stream dout; + + TypeIdLabelGenerator type_id (dout, u); + TypePrefixLabelGenerator type_prefix (dout, u); + RepoIdGenerator repo_id; + + Traversal::TranslationUnit unit; + + Traversal::ContainsPrincipal contains_principal; + unit.edge_traverser (contains_principal); + + Traversal::TranslationRegion region; + contains_principal.node_traverser (region); + + Traversal::ContainsRoot contains_root; + Traversal::Includes includes; + + region.edge_traverser (includes); + region.edge_traverser (contains_root); + + Traversal::Root root; + includes.node_traverser (region); + contains_root.node_traverser (root); + + Traversal::Defines defines; + root.edge_traverser (defines); + + Traversal::Module module; + + defines.node_traverser (module); + defines.node_traverser (type_id); + defines.node_traverser (type_prefix); + defines.node_traverser (repo_id); + + module.edge_traverser (defines); + + Traversal::Interface iface; + defines.node_traverser (iface); + + unit.traverse (u); + + if (dout.error_count () != 0) return false; + + //@@ check errors + + return true; +} diff --git a/modules/CIAO/CIDLC/RepositoryIdGenerator.hpp b/modules/CIAO/CIDLC/RepositoryIdGenerator.hpp new file mode 100644 index 00000000000..36dc13e064e --- /dev/null +++ b/modules/CIAO/CIDLC/RepositoryIdGenerator.hpp @@ -0,0 +1,21 @@ +// file : CIDLC/RepositoryIdGenerator.hpp +// author : Boris Kolpackov +// cvs-id : $Id$ + +#ifndef CIDLC_REPOSITORY_ID_GENERATOR_HPP +#define CIDLC_REPOSITORY_ID_GENERATOR_HPP + + +//@@ Don't really need this. just forward declaration of +// TranslationUnit would be enough. +// +#include "CCF/CIDL/SemanticGraph.hpp" + +class RepositoryIdGenerator +{ +public: + bool + generate (CCF::CIDL::SemanticGraph::TranslationUnit& u); +}; + +#endif // CIDLC_REPOSITORY_ID_GENERATOR_HPP diff --git a/modules/CIAO/CIDLC/ServantGenerator.cpp b/modules/CIAO/CIDLC/ServantGenerator.cpp new file mode 100644 index 00000000000..f817087b92d --- /dev/null +++ b/modules/CIAO/CIDLC/ServantGenerator.cpp @@ -0,0 +1,220 @@ +// file : CIDLC/ServantGenerator.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "ServantGenerator.hpp" +#include "ServantHeaderGenerator.hpp" +#include "ServantSourceGenerator.hpp" +#include "CxxNamePrinter.hpp" + +#include "CCF/CodeGenerationKit/Regex.hpp" +#include "CCF/CodeGenerationKit/IndentationCxx.hpp" +#include "CCF/CodeGenerationKit/IndentationImplanter.hpp" + +using namespace CCF; +using namespace CIDL; +using namespace SemanticGraph; +using namespace Traversal; + +using std::string; +using std::ostream; + +namespace +{ + // On some platforms toupper can be something else than a + // function. + int + upcase (int c) + { + return toupper (c); + } +} + +ServantGenerator::ServantGenerator (CommandLine const& cl) + : cl_ (cl), + file_name_ (""), + export_macro_ ("") +{ +} + +void ServantGenerator::options (CL::Description& d) +{ + d.add_option (CL::OptionDescription ( + "svnt-hdr-file-suffix", + "suffix", + "Use provided suffix instead of default \'_svnt.h\' " + "when constructing name of servant file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "svnt-hdr-file-regex", + "regex", + "Use provided regular expression when constructing " + "name of servant file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "svnt-src-file-suffix", + "suffix", + "Use provided suffix instead of default \'_svnt.cpp\' " + "when constructing name of servant file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "svnt-src-file-regex", + "regex", + "Use provided regular expression when constructing " + "name of servant file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "svnt-export-macro", + "macro", + "Replace default servant DLL export macro " + "with provided ,acro.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "svnt-export-include", + "file", + "Replace default servant export include file " + "with provided file.", + CL::OptionType::value)); + + d.add_option (CL::OptionDescription ( + "suppress-register-factory", + "Suppress generation of code to register eventtype " + "factories for event sinks.", + CL::OptionType::flag)); + + d.add_option (CL::OptionDescription ( + "custom-container", + "type", + "Generate code for custom container of the provided type.", + CL::OptionType::value)); +} + + +void ServantGenerator::generate (SemanticGraph::TranslationUnit& u, + fs::path const& file) +{ + // Generate files + compute_export_macro (file); + + { + fs::ofstream hdr_ofs; + ostream& hdr_os = configure_stream ("svnt-hdr-file-suffix", + "_svnt.h", + "svnt-hdr-file-regex", + hdr_ofs); + + Indentation::Implanter header_guard (hdr_os); + + // Set C++ name printer for os. + // + CxxNamePrinter name_printer; + hdr_os.pword (name_printer_index) = &name_printer; + + ServantHeaderEmitter hdr_emitter (hdr_os, + cl_, + export_macro_, + file); + hdr_emitter.generate (u); + } + + { + fs::ofstream src_ofs; + ostream& src_os = configure_stream ("svnt-src-file-suffix", + "_svnt.cpp", + "svnt-src-file-regex", + src_ofs); + + Indentation::Implanter header_guard (src_os); + + // Set C++ name printer for os. + // + CxxNamePrinter name_printer; + src_os.pword (name_printer_index) = &name_printer; + + ServantSourceEmitter src_emitter (src_os, + cl_, + export_macro_, + file); + src_emitter.generate (u); + } +} + +void +ServantGenerator::compute_export_macro (const fs::path& file_path) +{ + if (!file_path.empty ()) + { + file_name_ = file_path.leaf (); + } + + export_macro_ = cl_.get_value ("svnt-export-macro", ""); + + if (export_macro_.empty () && !file_name_.empty ()) + { + // Modify a copy of the filename string. + export_macro_ = file_name_; + + // Convert filename string to upper case. + transform (export_macro_.begin (), + export_macro_.end (), + export_macro_.begin (), + upcase); + + // Replace the suffix. + export_macro_ = + regex::perl_s (export_macro_, + "/^(.+?)(\\.(IDL|CIDL|CDL))?$/$1_SVNT_Export/"); + + // Replace any remaining '.' in the string with '_'. + export_macro_ = regex::perl_s (export_macro_, + "/\\./_/"); + } +} + + + +ostream& +ServantGenerator::configure_stream (string const& suffix_option, + string const& default_suffix, + string const& regex_option, + fs::ofstream& ofs) +{ + if (! file_name_.empty ()) + { + string file_suffix = cl_.get_value (suffix_option, + default_suffix); + string file_expr = + cl_.get_value (regex_option, + "/^(.+?)(\\.(idl|cidl|cdl))?$/$1" + file_suffix + "/"); + + string file_name = regex::perl_s (file_name_, file_expr); + + fs::path file_path (file_name); + + ofs.open (file_path, std::ios_base::out); + + if (!ofs.is_open ()) + { + cerr << file_name + << ": error: unable to open file in write mode" + << endl; + } + } + + return ofs.is_open () + ? static_cast (ofs) + : static_cast (std::cout); +} + + +/* + * Local Variables: + * mode: C++ + * c-basic-offset: 2 + * End: + */ diff --git a/modules/CIAO/CIDLC/ServantGenerator.hpp b/modules/CIAO/CIDLC/ServantGenerator.hpp new file mode 100644 index 00000000000..ae6a4a90477 --- /dev/null +++ b/modules/CIAO/CIDLC/ServantGenerator.hpp @@ -0,0 +1,53 @@ +// file : CIDLC/ServantGenerator.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef SERVANT_GENERATOR_HPP +#define SERVANT_GENERATOR_HPP + +#include +#include + +#include "CCF/CodeGenerationKit/CommandLine.hpp" +#include "CCF/CodeGenerationKit/CommandLineDescriptor.hpp" + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +class ServantGenerator +{ +public: + static void + options (CL::Description& d); + + ServantGenerator (CommandLine const& cl); + + void + generate (CCF::CIDL::SemanticGraph::TranslationUnit&, + fs::path const& file); + +private: + void + compute_export_macro (const fs::path& file_path); + + std::ostream& + configure_stream (std::string const& suffix_option, + std::string const& default_suffix, + std::string const& regex_option, + fs::ofstream& ofs); + +private: + CommandLine const& cl_; + std::string file_name_; + std::string export_macro_; +}; + + +#endif // SERVANT_GENERATOR_HPP + +/* + * Local Variables: + * mode: C++ + * c-basic-offset: 2 + * End: + */ diff --git a/modules/CIAO/CIDLC/ServantHeaderGenerator.cpp b/modules/CIAO/CIDLC/ServantHeaderGenerator.cpp new file mode 100644 index 00000000000..6676db3e77d --- /dev/null +++ b/modules/CIAO/CIDLC/ServantHeaderGenerator.cpp @@ -0,0 +1,1783 @@ +// file : CIDLC/ServantHeaderGenerator.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "ServantHeaderGenerator.hpp" +#include "CorbaTypeNameEmitters.hpp" +#include "UtilityTypeNameEmitters.hpp" +#include "AttributeHeaderEmitters.hpp" +#include "OperationHeaderEmitters.hpp" +#include "ParameterEmitter_T.hpp" +#include "CompositionEmitter.hpp" +#include "ModuleEmitter.hpp" +#include "InterfaceEmitter.hpp" +#include "Literals.hpp" +#include "Upcase.hpp" + +#include +#include + +#include "CCF/CodeGenerationKit/Regex.hpp" + +using std::endl; +using std::string; + +using namespace StringLiterals; +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +namespace +{ + struct FacetEmitter : Traversal::UnconstrainedInterface, + EmitterBase + { + FacetEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (UnconstrainedInterface& i) + { + if (i.context ().count ("facet_hdr_gen")) return; + + ScopedName scoped (i.scoped_name ()); + Name stripped (scoped.begin () + 1, scoped.end ()); + + // We need to escape C++ keywords before flattening the name. + // + string name; + { + std::ostringstream ostr; + ostr.pword (name_printer_index) = os.pword (name_printer_index); + ostr << scoped.scope_name (); + name = regex::perl_s (ostr.str (), "/::/_/"); + } + + /// Open a namespace made from the interface scope's name. + os << "namespace " << STRS[FACET_PREFIX] << name + << "{"; + + os << "template " << endl + << "class " << i.name () << "_Servant_T" << endl + << ": public virtual POA_" << stripped << endl + << "{" + << "public:" << endl + << i.name () << "_Servant_T (" << endl + << i.scoped_name ().scope_name () << "::CCM_" << i.name () + << "_ptr executor," << endl + << "::Components::CCMContext_ptr ctx);" << endl + << "virtual ~" << i.name () << "_Servant_T (void);" << endl; + + { + InterfaceEmitter interface_emitter (ctx); + + Traversal::Defines defines_; + Traversal::Inherits inherits_; + interface_emitter.edge_traverser (defines_); + interface_emitter.edge_traverser (inherits_); + + // Works for both read/write and readonly attributes. + AttributeHeaderEmitter attribute_emitter (ctx); + defines_.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx); + defines_.node_traverser (operation_emitter); + inherits_.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + inherits (i, inherits_); + names (i, defines_); + } + + os << "// Get component implementation." << endl + << "virtual CORBA::Object_ptr" << endl + << "_get_component ()" << endl + << STRS[EXCP_SNGL] << ";" << endl + << "protected:" << endl + << "// Facet executor." << endl + << i.scoped_name ().scope_name ()<< "::CCM_" << i.name () + << "_var executor_;" << endl + << "// Context object." << endl + << "::Components::CCMContext_var ctx_;" << endl + << "};"; + + os << "typedef " << i.name () << "_Servant_T " + << i.name () << "_Servant;"; + + // Close the facet servant's namespace. + os << "}"; + + i.context ().set ("facet_hdr_gen", true); + } + }; + + struct ContextEmitter : Traversal::Component, EmitterBase + { + ContextEmitter (Context& c, CommandLine const& cl) + : EmitterBase (c), + cl_ (cl) + {} + + // Nested classes used by this emitter. + private: + struct PortsEmitterPublic : Traversal::EmitterData, + Traversal::SingleUserData, + Traversal::MultiUserData, + Traversal::PublisherData, + EmitterBase + { + PortsEmitterPublic (Context& c) + : EmitterBase (c), + type_name_emitter_ (c) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::Emitter& e) + { + os << "virtual void" << endl + << "push_" << e.name () + << " (" << endl; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "ev)" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + virtual void + traverse (SemanticGraph::SingleUser& u) + { + os << "virtual "; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << endl + << "get_connection_" << u.name () + << " ()" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + virtual void + traverse (SemanticGraph::MultiUser& u) + { + os << "virtual " << u.scoped_name () << "Connections *" << endl + << "get_connections_" << u.name () + << " ()" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + virtual void + traverse (SemanticGraph::Publisher& p) + { + os << "virtual void" << endl + << "push_" << p.name () + << " (" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "ev)" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + private: + INArgTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + }; + + struct PortsEmitterProtected : Traversal::EmitterData, + Traversal::SingleUserData, + Traversal::MultiUserData, + Traversal::PublisherData, + EmitterBase + { + PortsEmitterProtected (Context& c) + : EmitterBase (c), + type_name_emitter_ (c) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::Emitter& e) + { + os << "virtual void" << endl + << "connect_" << e.name () << " (" << endl; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_AC] << "));" << endl; + + os << "virtual "; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer_ptr" << endl + << "disconnect_" << e.name () << " ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_NC] << "));" << endl; + } + + virtual void + traverse (SemanticGraph::SingleUser& u) + { + os << "virtual void" << endl + << "connect_" << u.name () << " (" << endl; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_AC] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + + os << "virtual "; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << "disconnect_" << u.name () << " ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_NC] << "));" << endl; + } + + virtual void + traverse (SemanticGraph::MultiUser& u) + { + os << "virtual ::Components::Cookie *" << endl + << "connect_" << u.name () << " (" << endl; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_ptr)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + + os << "virtual "; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << "disconnect_" << u.name () << " (" << endl + << "::Components::Cookie * ck)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + } + + virtual void + traverse (SemanticGraph::Publisher& p) + { + os << "virtual " << STRS[COMP_CK] << " *" << endl + << "subscribe_" << p.name () << " (" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "));" << endl; + + os << "// CIAO-specific." << endl + << STRS[COMP_CK] << " *" << endl + << "subscribe_" << p.name () << "_generic (" << endl + << STRS[COMP_ECB] << "_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "));" << endl; + + os << "virtual "; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_ptr" << endl + << "unsubscribe_" << p.name () << " (" << endl + << STRS[COMP_CK] << " *ck)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + }; + + struct PortsEmitterMembers : Traversal::EmitterData, + Traversal::SingleUserData, + Traversal::MultiUserData, + Traversal::PublisherData, + EmitterBase + { + PortsEmitterMembers (Context& c) + : EmitterBase (c), + type_name_emitter_ (c) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::Emitter& e) + { + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer_var" << endl + << "ciao_emits_" << e.name () << "_consumer_;" + << endl; + } + + virtual void + traverse (SemanticGraph::SingleUser& u) + { + os << "// Simplex " << u.name () << " connection." << endl; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_var" << endl + << "ciao_uses_" << u.name () << "_;" << endl; + } + + virtual void + traverse (SemanticGraph::MultiUser& u) + { + os << "// Multiplex " << u.name () << " connection." << endl + << "ACE_Active_Map_Manager<" << endl; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_var>" << endl + << "ciao_uses_" << u.name () << "_;" << endl; + } + + virtual void + traverse (SemanticGraph::Publisher& p) + { + os << "ACE_Active_Map_Manager<" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_var>" << endl + << "ciao_publishes_" << p.name () << "_map_;" + << endl; + + os << "ACE_Active_Map_Manager<" << endl + << STRS[COMP_ECB] << "_var>" << endl + << "ciao_publishes_" << p.name () << "_generic_map_;" + << endl; + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + }; + + public: + virtual void + pre (Type& t) + { + os << "class " << t.name () << "_Servant;" << endl; + + string swap_option = cl_.get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + os << "class " << ctx.export_macro () << " " << t.name () + << "_Context" << endl + << " : public virtual CIAO::" + << (swapping ? "Upgradeable_" : "") << "Context_Impl<" << endl + << " " << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << "_Context," << endl + << " " << t.name () << "_Servant," << endl + << " " << t.scoped_name () << "," << endl + << " " << t.scoped_name () << "_var" << endl + << " >" << endl + << "{" + << "public:" << endl; + + os << "// We will allow the servant glue code we generate to " + << "access our state." << endl + << "friend class " << t.name () << "_Servant;" << endl; + + os << t.name () << "_Context (" << endl + << "::Components::CCMHome_ptr h," << endl + << "::CIAO::Session_Container *c," << endl + << t.name () << "_Servant *sv);" << endl; + + os << "virtual ~" << t.name () << "_Context (void);" + << endl; + + os << "// Operations for " << t.name () << " receptacles" + << " and event sources," << endl + << "// defined in " << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << "_Context." + << endl << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (component_inherits); + + PortsEmitterPublic ports_emitter (ctx); + defines.node_traverser (ports_emitter); + + component_emitter.traverse (t); + } + + // Extra *_Context methods for swapping container. + if (swapping) + { + os << "// Operations defined in " << t.scoped_name ().scope_name () + << "::CCM_" << t.name () << "_Context" << endl + << "// that enable component swapping in the container" + << endl << endl; + + os << "virtual " << STRS[COMP_CD] << " *" << endl + << "get_registered_consumers (" << endl + << "const char *publisher_name)" << endl + << STRS[EXCP_START] << endl + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + } + + os << "// CIAO-specific." << endl << endl; + + os << "static " << t.name () << "_Context *" << endl + << "_narrow (" << endl + << STRS[COMP_SC] << "_ptr p);" << endl; + + os << "protected:" << endl + << "// Methods that manage this component's connections" + << " and consumers." << endl << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (component_inherits); + + PortsEmitterProtected ports_emitter (ctx); + defines.node_traverser (ports_emitter); + + component_emitter.traverse (t); + } + + os << "protected:" << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (component_inherits); + + PortsEmitterMembers ports_emitter (ctx); + defines.node_traverser (ports_emitter); + + component_emitter.traverse (t); + } + } + + virtual void + post (Type&) + { + // Component context class closer. + os << "};"; + } + + private: + CommandLine const& cl_; + }; + + struct ServantEmitter : Traversal::Component, EmitterBase + { + ServantEmitter (Context& c) + : EmitterBase (c) + {} + + // Nested classes used by this emitter. + private: + struct PortsEmitterPublic : Traversal::EmitterData, + Traversal::SingleUserData, + Traversal::MultiUserData, + Traversal::PublisherData, + Traversal::ConsumerData, + Traversal::ProviderData, + EmitterBase + { + PortsEmitterPublic (Context& c) + : EmitterBase (c), + type_name_emitter_ (c), + simple_type_name_emitter_ (c), + stripped_type_name_emitter_ (c) + { + belongs_.node_traverser (type_name_emitter_); + simple_belongs_.node_traverser (simple_type_name_emitter_); + stripped_belongs_.node_traverser (stripped_type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::Provider& p) + { + os << "virtual "; + + Traversal::ProviderData::belongs (p, belongs_); + + os << "_ptr" << endl + << "provide_" << p.name () << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + virtual void + traverse (SemanticGraph::SingleUser& u) + { + os << "virtual void" << endl + << "connect_" << u.name () << " (" << endl; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_AC] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + + os << "virtual "; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << "disconnect_" << u.name () << " ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_NC] << "));" << endl; + + os << "virtual "; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << "get_connection_" << u.name () << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + virtual void + traverse (SemanticGraph::MultiUser& u) + { + os << "virtual ::Components::Cookie *" << endl + << "connect_" << u.name () << " (" << endl; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + + os << "virtual "; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << "disconnect_" << u.name () << " (" << endl + << "::Components::Cookie * ck)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + + os << "virtual " << u.scoped_name () << "Connections *" << endl + << "get_connections_" << u.name () << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + virtual void + traverse (SemanticGraph::Consumer& c) + { + os << "// Servant class for the " << c.name () + << " consumer." << endl + << "class " << ctx.export_macro () << " "; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" + << c.name () << "_Servant" << endl + << ": public virtual POA_"; + + Traversal::ConsumerData::belongs (c, stripped_belongs_); + + os << "Consumer" << endl + << "{" + << "public:" << endl; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () << "_Servant (" << endl + << c.scoped_name ().scope_name ().scope_name () << "::CCM_" + << c.scoped_name ().scope_name ().simple_name () << "_ptr executor," + << endl + << c.scoped_name ().scope_name ().scope_name () << "::CCM_" + << c.scoped_name ().scope_name ().simple_name () + << "_Context_ptr c);" << endl; + + os << "virtual ~"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" + << c.name () << "_Servant (void);" << endl; + + os << "virtual void" << endl + << "push_"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << " (" << endl; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << " *evt" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + + os << "// Inherited from " << STRS[COMP_ECB] << "." << endl + << "virtual void" << endl + << "push_event ( ::Components::EventBase *ev)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_BET] << "));" << endl; + + // @@ GD added below code. + + os << "// CIAO-specific in " << STRS[COMP_ECB] << "." << endl + << "virtual void" << endl + << "ciao_push_event ( ::Components::EventBase *ev," << endl + << "const char * source_id," << endl + << "::CORBA::TypeCode_ptr tc)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_BET] << "));" << endl; + + os << "// CIAO-specific in " << STRS[COMP_ECB] << "." << endl + << "virtual CORBA::Boolean" << endl + << "ciao_is_substitutable (" << endl + << "const char *event_repo_id" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + + os << "// Get component implementation." << endl + << "virtual CORBA::Object_ptr" << endl + << "_get_component (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + + os << "protected:" << endl + << c.scoped_name ().scope_name ().scope_name () << "::CCM_" + << c.scoped_name ().scope_name ().simple_name () + << "_var" << endl + << "executor_;" << endl; + + os << c.scoped_name ().scope_name ().scope_name () << "::CCM_" + << c.scoped_name ().scope_name ().simple_name () + << "_Context_var" << endl + << "ctx_;" << endl; + + os << "};"; + + os << "virtual "; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << "Consumer_ptr" << endl + << "get_consumer_" << c.name () << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + virtual void + traverse (SemanticGraph::Emitter& e) + { + os << "virtual void" << endl + << "connect_" << e.name () << " (" << endl; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_AC] << "));" << endl; + + os << "virtual "; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer_ptr" << endl + << "disconnect_" << e.name () << " ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_NC] << "));" << endl; + } + + virtual void + traverse (SemanticGraph::Publisher& p) + { + os << "virtual " << STRS[COMP_CK] << " *" << endl + << "subscribe_" << p.name () << " (" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "));" << endl; + + os << "// CIAO-specific." << endl + << STRS[COMP_CK] << " *" << endl + << "subscribe_" << p.name () << "_generic (" << endl + << STRS[COMP_ECB] << "_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "));" << endl; + + os << "virtual "; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_ptr" << endl + << "unsubscribe_" << p.name () << " (" << endl + << STRS[COMP_CK] << " *ck)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + } + + private: + FullTypeNameEmitter type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + StrippedTypeNameEmitter stripped_type_name_emitter_; + Traversal::Belongs belongs_; + Traversal::Belongs simple_belongs_; + Traversal::Belongs stripped_belongs_; + }; + + struct PortsEmitterProtected : Traversal::ConsumerData, + Traversal::ProviderData, + EmitterBase + { + PortsEmitterProtected (Context& c) + : EmitterBase (c), + type_name_emitter_ (c) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::Provider& p) + { + Traversal::ProviderData::belongs (p, belongs_); + + os << "_var" << endl + << "provide_" << p.name () << "_;" << endl; + } + + virtual void + traverse (SemanticGraph::Consumer& c) + { + Traversal::ConsumerData::belongs (c, belongs_); + + os << "Consumer_var" << endl + << "consumes_" << c.name () << "_;" << endl; + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + }; + + struct PortsEmitterPrivate : Traversal::EmitterData, + Traversal::SingleUserData, + Traversal::MultiUserData, + Traversal::PublisherData, + Traversal::ConsumerData, + Traversal::ProviderData, + EmitterBase + { + PortsEmitterPrivate (Context& c) + : EmitterBase (c), + type_name_emitter_ (c), + simple_type_name_emitter_ (c), + stripped_type_name_emitter_ (c) + { + belongs_.node_traverser (type_name_emitter_); + simple_belongs_.node_traverser (simple_type_name_emitter_); + stripped_belongs_.node_traverser (stripped_type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::Provider& p) + { + os << "::CORBA::Object_ptr" << endl + << "provide_" << p.name () << "_i (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + virtual void + traverse (SemanticGraph::SingleUser&) + { + } + + virtual void + traverse (SemanticGraph::MultiUser&) + { + } + + virtual void + traverse (SemanticGraph::Consumer& c) + { + os << "::Components::EventConsumerBase_ptr" << endl + << "get_consumer_" << c.name () << "_i (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + } + + virtual void + traverse (SemanticGraph::Emitter&) + { + } + + virtual void + traverse (SemanticGraph::Publisher&) + { + } + + private: + FullTypeNameEmitter type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + StrippedTypeNameEmitter stripped_type_name_emitter_; + Traversal::Belongs belongs_; + Traversal::Belongs simple_belongs_; + Traversal::Belongs stripped_belongs_; + }; + + public: + virtual void + pre (Type& t) + { + ScopedName scoped (t.scoped_name ()); + Name stripped (scoped.begin () + 1, scoped.end ()); + + os << "class " << ctx.export_macro () << " " << t.name () + << "_Servant" << endl + << " : public virtual CIAO::Servant_Impl<" << endl + << " POA_" << stripped << "," << endl + << " " << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << "," << endl + << " " << t.name () << "_Context" << endl + << " >" << endl + << "{" + << "public:" << endl << endl; + + os << "typedef " << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << " _exec_type;" << endl; + + os << t.name () << "_Servant (" << endl + << t.scoped_name ().scope_name () << "::CCM_" << t.name () + << "_ptr executor," << endl + << "::Components::CCMHome_ptr h," << endl + << "const char *ins_name," << endl + << "::CIAO::Home_Servant_Impl_Base *hs," << endl + << "::CIAO::Session_Container *c);" << endl; + + os << "virtual ~" << t.name () << "_Servant (void);" << endl; + + os << "virtual void" << endl + << "set_attributes (" << endl + << "const ::Components::ConfigValues &descr" << endl + << ");" << endl; + + os << "// Supported operations." << endl << endl; + + // Generate operations for all supported interfaces. + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Supports supports_; + component_emitter.edge_traverser (component_inherits); + component_emitter.edge_traverser (supports_); + InterfaceEmitter interface_emitter (ctx); + supports_.node_traverser (interface_emitter); + + Traversal::Defines defines; + Traversal::Inherits interface_inherits; + interface_emitter.edge_traverser (defines); + interface_emitter.edge_traverser (interface_inherits); + + // Works for both read/write and readonly attributes. + AttributeHeaderEmitter attribute_emitter (ctx); + defines.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx); + defines.node_traverser (operation_emitter); + interface_inherits.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + component_emitter.traverse (t); + } + + os << "// Public port operations." << endl << endl; + + // Generate public operations for ports, and nested classes for + // event consumers. + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (component_inherits); + component_emitter.edge_traverser (defines); + + PortsEmitterPublic ports_emitter (ctx); + defines.node_traverser (ports_emitter); + + component_emitter.traverse (t); + } + + // Generate operations for component attributes. + os << "// Component attribute operations." << endl << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (component_inherits); + + // Works for both read/write and readonly attributes. + AttributeHeaderEmitter attribute_emitter (ctx); + defines.node_traverser (attribute_emitter); + + component_emitter.traverse (t); + } + + os << "// Operations for Receptacles interface." << endl << endl; + + os << "virtual " << STRS[COMP_CK] << " *" << endl + << "connect (" << endl + << "const char *name," << endl + << "CORBA::Object_ptr connection)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_IC] << "," << endl + << STRS[EXCP_AC] << "," << endl + << STRS[EXCP_ECL] << "));" << endl; + + os << "virtual CORBA::Object_ptr" << endl + << "disconnect (" << endl + << "const char *name," << endl + << STRS[COMP_CK] << " *ck)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_IC] << "," << endl + << STRS[EXCP_CR] << "," << endl + << STRS[EXCP_NC] << "));" << endl; + + os << "virtual " << STRS[COMP_RD] << " *" << endl + << "get_all_receptacles (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + + os << "// Operations for Events interface." << endl << endl; + + os << "virtual " << STRS[COMP_CK] << " *" << endl + << "subscribe (" << endl + << "const char *publisher_name," << endl + << STRS[COMP_ECB] << "_ptr subscriber)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_IC] << "," << endl + << STRS[EXCP_ECL] << "));" << endl; + + os << "virtual " << STRS[COMP_ECB] << "_ptr" << endl + << "unsubscribe (" << endl + << "const char *publisher_name," << endl + << STRS[COMP_CK] << " *ck)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + + os << "virtual void" << endl + << "connect_consumer (" << endl + << "const char *emitter_name," << endl + << STRS[COMP_ECB] << "_ptr consumer)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_AC] << "," << endl + << STRS[EXCP_IC] << "));" << endl; + + os << "virtual " << STRS[COMP_ECB] << "_ptr" << endl + << "disconnect_consumer (" << endl + << "const char *source_name)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_NC] << "));" << endl; + + os << "virtual " << STRS[COMP_PD] << " *" << endl + << "get_all_publishers (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + + os << "virtual " << STRS[COMP_ED] << " *" << endl + << "get_all_emitters (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + + os << "// CIAO specific operations on the servant. " << endl + << "CORBA::Object_ptr" << endl + << "get_facet_executor (" << endl + << "const char *name)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS]<< "));" << endl; + + os << "private:" << endl << endl; + + // Generate protected operations for facets and event sinks. + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (component_inherits); + + PortsEmitterProtected ports_emitter (ctx); + defines.node_traverser (ports_emitter); + + component_emitter.traverse (t); + } + + os << "const char *ins_name_;" << endl; + + os << "private:" << endl << endl + << "void" << endl + << "populate_port_tables (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << ";" << endl; + + // Generate private operations for ports. + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (component_inherits); + + PortsEmitterPrivate ports_emitter (ctx); + defines.node_traverser (ports_emitter); + + component_emitter.traverse (t); + } + } + + virtual void + post (Type&) + { + // Component servant class closer. + os << "};"; + } + }; + + struct HomeEmitter : Traversal::Home, EmitterBase + { + HomeEmitter (Context& c, CommandLine const& cl) + : EmitterBase (c), + cl_ (cl), + type_name_emitter_ (c), + simple_type_name_emitter_ (c), + enclosing_type_name_emitter_ (c) + { + manages_.node_traverser (type_name_emitter_); + simple_manages_.node_traverser (simple_type_name_emitter_); + enclosing_manages_.node_traverser (enclosing_type_name_emitter_); + } + + virtual void pre (Type& t) + { + os << "class " << ctx.export_macro () << " " << t.name () + << "_Servant" << endl + << " : public virtual" << endl + << " ::CIAO::"; + + string swap_option = cl_.get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + ScopedName scoped (t.scoped_name ()); + Name stripped (scoped.begin () + 1, scoped.end ()); + + os << (swapping ? "Swapping_" : "") << "Home_Servant_Impl<" << endl + << " ::POA_" << stripped << "," << endl + << " " << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << "," << endl + << " "; + + Traversal::Home::manages (t, simple_manages_); + + os << "_Servant" << endl + << " >" << endl + << "{" + << "public:" << endl << endl; + os << t.name () << "_Servant (" << endl + << t.scoped_name ().scope_name () << "::CCM_" << t.name () + << "_ptr exe," << endl + << "const char *ins_name," << endl + << "::CIAO::Session_Container *c);" << endl; + + os << "virtual ~" << t.name () << "_Servant (void);" << endl; + + // Generate home operations. + os << "// Home operations." << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits home_inherits; + home_inherits.node_traverser (home_emitter); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + home_emitter.edge_traverser (home_inherits); + + HomeOperationEmitter home_operation_emitter (ctx); + defines.node_traverser (home_operation_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + home_operation_emitter.edge_traverser (receives); + home_operation_emitter.edge_traverser (returns); + home_operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + // Generate home factory operations. This is a separate traversal + // stack because we want to generate the factory operations + // of ancestors with the return type of the base component. + os << "// Home factory and finder operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits inherits; + home_emitter.edge_traverser (inherits); + inherits.node_traverser (home_emitter); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + + FactoryOperationEmitter factory_operation_emitter (ctx); + FinderOperationEmitter finder_operation_emitter (ctx); + defines.node_traverser (factory_operation_emitter); + defines.node_traverser (finder_operation_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + factory_operation_emitter.edge_traverser (receives); + factory_operation_emitter.edge_traverser (returns); + factory_operation_emitter.edge_traverser (raises); + finder_operation_emitter.edge_traverser (receives); + finder_operation_emitter.edge_traverser (returns); + finder_operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + // Generate operations for home attributes. + os << "// Attribute operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits home_inherits; + home_inherits.node_traverser (home_emitter); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + home_emitter.edge_traverser (home_inherits); + + // Works for both read/write and readonly attributes. + AttributeHeaderEmitter attribute_emitter (ctx); + defines.node_traverser (attribute_emitter); + + home_emitter.traverse (t); + } + + // Generate operations for all supported interfaces. + { + Traversal::Home home_emitter; + + Traversal::Inherits home_inherits; + home_inherits.node_traverser (home_emitter); + + Traversal::Supports supports_; + home_emitter.edge_traverser (supports_); + home_emitter.edge_traverser (home_inherits); + + InterfaceEmitter interface_emitter (ctx); + supports_.node_traverser (interface_emitter); + + Traversal::Defines defines; + Traversal::Inherits inherits; + interface_emitter.edge_traverser (defines); + interface_emitter.edge_traverser (inherits); + + // Works for both read/write and readonly attributes. + AttributeHeaderEmitter attribute_emitter (ctx); + defines.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx); + defines.node_traverser (operation_emitter); + inherits.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + // Home servant class closer. + os << "};"; + + string name; + + // We need to escape C++ keywords before flattening the name. + // + { + std::ostringstream ostr; + ostr.pword (name_printer_index) = os.pword (name_printer_index); + ostr << t.scoped_name (); + name = regex::perl_s (ostr.str (), "/::/_/"); + } + + os << "extern \"C\" " << ctx.export_macro () + << " ::PortableServer::Servant" << endl + << "create" << name << "_Servant (" << endl + << "::Components::HomeExecutorBase_ptr p," << endl + << "CIAO::Session_Container *c," << endl + << "const char *ins_name" << endl + << ");" << endl; + } + + private: + CommandLine const& cl_; + FullTypeNameEmitter type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + EnclosingTypeNameEmitter enclosing_type_name_emitter_; + Traversal::Manages manages_; + Traversal::Manages simple_manages_; + Traversal::Manages enclosing_manages_; + }; + + struct IncludesEmitter : Traversal::QuoteIncludes, + Traversal::BracketIncludes, + EmitterBase + { + IncludesEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (SemanticGraph::QuoteIncludes& qi) + { + os << "#include \"" + << regex::perl_s (qi.file ().string (), + "/^(.+?)(\\.(idl|cidl|cdl))?$/$1S.h/") + << "\"" << endl << endl; + } + + virtual void + traverse (SemanticGraph::BracketIncludes& bi) + { + os << "#include \"" + << regex::perl_s (bi.file ().string (), + "/^(.+?)(\\.(idl|cidl|cdl))?$/$1S.h/") + << "\"" + << endl; + } + }; +} + +ServantHeaderEmitter::ServantHeaderEmitter (std::ostream& os_, + CommandLine const& cl, + string export_macro, + fs::path const& file) + : os (os_), + cl_ (cl), + export_macro_ (export_macro), + file_ (file) +{} + +void +ServantHeaderEmitter::generate (TranslationUnit& u) +{ + pre (u); + + Context c (os, export_macro_, cl_); + + /// CIAO has facet classes outside the context and servant classes. + /// We launch it here to generate the classes inside namespaces + /// constructed to be unique for each interface type used in a facet. + generate_facets (u, c); + + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion region; + contains_principal.node_traverser (region); + + // Layer 2 + // + Traversal::ContainsRoot contains_root; + Traversal::Includes includes; + + region.edge_traverser (includes); + region.edge_traverser (contains_root); + + //-- + Traversal::Root root; + contains_root.node_traverser (root); + + // Layer 3 + // + Traversal::Defines defines; + root.edge_traverser (defines); + + //-- + ModuleEmitter module (c); + CompositionEmitter composition (c); + defines.node_traverser (module); + defines.node_traverser (composition); + + // Layer 4 + // + Traversal::Defines composition_defines; + composition.edge_traverser (composition_defines); + + module.edge_traverser (defines); + + //-- + Traversal::ComponentExecutor component_executor; + Traversal::HomeExecutor home_executor; + composition_defines.node_traverser (component_executor); + composition_defines.node_traverser (home_executor); + + // Layer 5 + // + Traversal::Implements implements; + component_executor.edge_traverser (implements); + home_executor.edge_traverser (implements); + + //-- + ContextEmitter context_emitter (c, cl_); + ServantEmitter servant_emitter (c); + HomeEmitter home_emitter (c, cl_); + implements.node_traverser (context_emitter); + implements.node_traverser (servant_emitter); + implements.node_traverser (home_emitter); + + unit.traverse (u); + + post (u); +} + +void +ServantHeaderEmitter::pre (TranslationUnit&) +{ + os << COPYRIGHT; + + string file_name (""); + + if (!file_.empty ()) + { + file_name = file_.leaf (); + } + + string uc_file_name = file_name; + + std::transform (uc_file_name.begin (), + uc_file_name.end (), + uc_file_name.begin (), + upcase); + + string uc_file_suffix = cl_.get_value ("svnt-hdr-file-suffix", + "_svnt.h"); + + std::transform (uc_file_suffix.begin (), + uc_file_suffix.end (), + uc_file_suffix.begin (), + upcase); + + string guard = + "CIAO_GLUE_SESSION_" + + regex::perl_s (uc_file_name, + "/^(.+?)(\\.(IDL|CIDL|CDL))?$/$1" + + uc_file_suffix + + "/"); + + // Replace any remaining '.' with '_'. + guard = regex::perl_s (guard, "/\\./_/"); + + os << "#ifndef " << guard << endl + << "#define " << guard << endl << endl + << "#include /**/ \"ace/pre.h\"" << endl << endl; + + string export_include = cl_.get_value ("svnt-export-include", ""); + + if (!export_include.empty ()) + { + os << "#include \"" << export_include << "\"" << endl << endl; + } + + // Get the suffix for the executor IDL file and strip off the + // trailing .idl. + // @@@ (JP) I guess it's a safe assumption that the tail of the + // suffix will be .idl. + string suffix = cl_.get_value ("lem-file-suffix", "E.idl"); + suffix = regex::perl_s (suffix, "/^(.+?)(\\.idl)?$/$1/"); + + // @@@ (JP) No way of knowing if the IDL compiler had command line + // option(s) to change C.h and/or S.h. We could add command line options + // to the CIDL compiler for them, but the user will have to make sure + // they are in synch with the IDL compiler's options. + os << "#include \"" + << regex::perl_s (file_name, + "/^(.+?)(\\.(idl|cidl|cdl))?$/$1" + suffix + "C.h/") + << "\"" + << endl << endl; + + os << "#if !defined (ACE_LACKS_PRAGMA_ONCE)" << endl + << "# pragma once" << endl + << "#endif /* ACE_LACKS_PRAGMA_ONCE */" << endl << endl; + + string swap_option = cl_.get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + os << "#include \"ciao/" + << (swapping ? "Swapping_Container.h" : "Container_Base.h") + << "\"" << endl + << "#include \"ciao/" + << (swapping ? "Upgradeable_Context_Impl_T.h" + : "Context_Impl_T.h") + << "\"" << endl + << "#include \"ciao/Servant_Impl_T.h\"" << endl + << "#include \"ciao/" + << (swapping ? "Swapping_Servant_Home_Impl_T.h" + : "Home_Servant_Impl_T.h") + << "\"" << endl << endl; +} + +void +ServantHeaderEmitter::generate_facets (TranslationUnit& u, Context& c) +{ + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion principal_region; + contains_principal.node_traverser (principal_region); + + // Layer 2 + // + + /// Includes are handled here so they will all be present + /// before the facet servants (if any) are generated. + + Traversal::ContainsRoot contains_root; + IncludesEmitter includes_emitter (c); + + principal_region.edge_traverser (includes_emitter); + principal_region.edge_traverser (contains_root); + + //-- + Traversal::Root root; + contains_root.node_traverser (root); + + // Layer 3 + // + Traversal::Defines root_defines; + root.edge_traverser (root_defines); + + //-- + Traversal::Module module; + Traversal::Composition composition; + root_defines.node_traverser (module); + root_defines.node_traverser (composition); + + module.edge_traverser (root_defines); + + // Layer 4 + // + Traversal::Defines composition_defines; + composition.edge_traverser (composition_defines); + + //-- + Traversal::ComponentExecutor component_executor; + Traversal::HomeExecutor home_executor; + composition_defines.node_traverser (component_executor); + composition_defines.node_traverser (home_executor); + + // Layer 5 + // + Traversal::Implements implements; + component_executor.edge_traverser (implements); + home_executor.edge_traverser (implements); + + // Layer 6 + // + Traversal::Component component_emitter; + implements.node_traverser (component_emitter); + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines component_defines; + component_emitter.edge_traverser (component_defines); + component_emitter.edge_traverser (component_inherits); + + // Layer 7 + // + Traversal::Provider provider; + component_defines.node_traverser (provider); + + Traversal::Belongs belongs; + provider.edge_traverser (belongs); + + FacetEmitter facet_emitter (c); + belongs.node_traverser (facet_emitter); + + unit.traverse (u); +} + +void +ServantHeaderEmitter::post (TranslationUnit&) +{ + if (file_.empty ()) return; + + string uc_file_name = file_.leaf (); + + std::transform (uc_file_name.begin (), + uc_file_name.end (), + uc_file_name.begin (), + upcase); + + string uc_file_suffix = cl_.get_value ("svnt-hdr-file-suffix", + "_svnt.h"); + + std::transform (uc_file_suffix.begin (), + uc_file_suffix.end (), + uc_file_suffix.begin (), + upcase); + + string guard = + "CIAO_GLUE_SESSION_" + + regex::perl_s (uc_file_name, + "/^(.+?)(\\.(IDL|CIDL|CDL))?$/$1" + + uc_file_suffix + + "/"); + + guard = regex::perl_s (guard, "/\\./_/"); + + os << "#include /**/ \"ace/post.h\"" << endl << endl + << "#endif /* " << guard << " */" + << endl << endl; +} diff --git a/modules/CIAO/CIDLC/ServantHeaderGenerator.hpp b/modules/CIAO/CIDLC/ServantHeaderGenerator.hpp new file mode 100644 index 00000000000..91e881e1411 --- /dev/null +++ b/modules/CIAO/CIDLC/ServantHeaderGenerator.hpp @@ -0,0 +1,54 @@ +// file : CIDLC/ServantHeaderGenerator.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef SERVANT_HEADER_GENERATOR_HPP +#define SERVANT_HEADER_GENERATOR_HPP + +#include +#include + +#include "EmitterContext.hpp" + +#include "CCF/CodeGenerationKit/CommandLine.hpp" + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +class ServantHeaderEmitter +{ +public: + ServantHeaderEmitter (std::ostream& os_, + CommandLine const& cl, + std::string export_macro, + fs::path const& file); + + virtual ~ServantHeaderEmitter () {} + + /// Called by the backend driver. + virtual void + generate (CCF::CIDL::SemanticGraph::TranslationUnit& u); + +private: + /// Called from generate(). + + virtual void + pre (CCF::CIDL::SemanticGraph::TranslationUnit& u); + + virtual void + generate_facets (CCF::CIDL::SemanticGraph::TranslationUnit& u, + Context& c); + + virtual void + post (CCF::CIDL::SemanticGraph::TranslationUnit& u); + +private: + std::ostream& os; + CommandLine const& cl_; + std::string export_macro_; + fs::path file_; +}; + + +#endif // SERVANT_HEADER_GENERATOR_HPP + diff --git a/modules/CIAO/CIDLC/ServantSourceGenerator.cpp b/modules/CIAO/CIDLC/ServantSourceGenerator.cpp new file mode 100644 index 00000000000..f4d715b523d --- /dev/null +++ b/modules/CIAO/CIDLC/ServantSourceGenerator.cpp @@ -0,0 +1,4476 @@ +// file : CIDLC/ServantSourceGenerator.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "ServantSourceGenerator.hpp" +#include "CorbaTypeNameEmitters.hpp" +#include "UtilityTypeNameEmitters.hpp" +#include "ParameterEmitter_T.hpp" +#include "AttributeSourceEmitters_T.hpp" +#include "CompositionEmitter.hpp" +#include "ModuleEmitter.hpp" +#include "InterfaceEmitter.hpp" +#include "Literals.hpp" + +#include +#include + +#include "CCF/CodeGenerationKit/Regex.hpp" + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; +using namespace StringLiterals; + +using std::string; + +namespace +{ + struct RepoIdEmitter : Traversal::Type, + EmitterBase + { + RepoIdEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (SemanticGraph::Type& t) + { + os << "\"" << t.context ().get (STRS[REPO_ID]) << "\""; + } + }; + + struct ConsumerRepoIdEmitter : Traversal::Type, + EmitterBase + { + ConsumerRepoIdEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (SemanticGraph::Type& t) + { + string holder (t.context ().get (STRS[REPO_ID])); + os << "\"" << holder.substr (0, holder.rfind (':')) + << "Consumer:1.0\""; + } + }; + + struct FlatNameEmitter : Traversal::Type, + EmitterBase + { + FlatNameEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (SemanticGraph::Type& t) + { + // We need to escape C++ keywords before flattening the name. + // + std::ostringstream ostr; + ostr.pword (name_printer_index) = os.pword (name_printer_index); + ostr << t.scoped_name (); + os << regex::perl_s (ostr.str (), "/::/_/"); + } + }; + + struct OperationExecEmitter : Traversal::Operation, + EmitterBase + { + OperationExecEmitter (Context& c) + : EmitterBase (c) + {} + + virtual void + name (Type& o) + { + os << o.name (); + } + + virtual void + receives_pre (Type&) + { + os << " (" << endl; + } + + virtual void + receives_none (Type&) + { + os << " ();"; + } + + virtual void + receives_post (Type&) + { + os << endl << ");"; + } + + /// If we don't do this, the comma() method just below + /// gets used not only with the arguments, but also + /// in raises(). Even though we are not generating the + /// exception list here, the front end iterator still + /// executes, and picks up the overridden comma(). So + /// we override raises() itself to do nothing. + virtual void + raises (Type&) + { + } + + virtual void + comma (Type&) + { + os << "," << endl; + } + }; + + struct OpExecReturnEmitter : Traversal::Type, + Traversal::Void + { + OpExecReturnEmitter (std::ostream& os_) + : os (os_) + {} + + virtual void + traverse (Void&) + { + os << "this->executor_->"; + } + + virtual void + traverse (SemanticGraph::Type&) + { + os << "return this->executor_->"; + } + + private: + std::ostream& os; + }; + + // For generating parameter names in operation delegation. + template + struct ParameterExecEmitter : T + { + ParameterExecEmitter (std::ostream& os_) + : os (os_) + {} + + virtual void + name (typename T::Type& p) + { + os << p.name (); + } + + private: + std::ostream& os; + }; + + template + struct OperationEmitter : Traversal::Operation, EmitterBase + { + OperationEmitter (Context& c, + T& scope) + : EmitterBase (c), + scope_ (scope) + { + } + + // Overridden by facet and home operation emitters to do nothing. + virtual void + gen_swap_related (Type& o) + { + string swap_option = ctx.cl ().get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + if (swapping) + { + os << "this->activate_component ();" << endl; + } + } + + virtual void + name (Type& o) + { + os << endl + << scope_.name () << "_Servant::" << o.name (); + } + + virtual void + receives_pre (Type&) + { + os << " (" << endl; + } + + virtual void + receives_none (Type&) + { + os << " ()" << endl; + } + + virtual void + receives_post (Type&) + { + os << endl << ")" << endl; + } + + virtual void + raises_pre (Type&) + { + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; + } + + virtual void + raises_none (Type&) + { + os << STRS[EXCP_SNGL]; + } + + virtual void + raises_post (Type&) + { + os << "))"; + } + + virtual void + post (Type& o) + { + os << "{"; + + this->gen_swap_related (o); + + OperationExecEmitter operation_emitter (ctx); + + Traversal::Receives receives; + Traversal::Belongs returns; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + + ParameterExecEmitter param (os); + receives.node_traverser (param); + + OpExecReturnEmitter return_emitter (os); + returns.node_traverser (return_emitter); + + operation_emitter.traverse (o); + + os << "}"; + } + + virtual void + comma (Type&) + { + os << "," << endl; + } + + protected: + T& scope_; + }; + + struct FacetEmitter : Traversal::UnconstrainedInterface, + EmitterBase + { + FacetEmitter (Context& c) + : EmitterBase (c) + { + } + + struct FacetOperationEmitter + : OperationEmitter + { + FacetOperationEmitter (Context& c, + SemanticGraph::UnconstrainedInterface& i) + : OperationEmitter (c, i) + {} + + // Overriden to do nothing since we don't want to generate + // component swapping related code for facet operations. + virtual void + gen_swap_related (Type&) + { + } + + virtual void + pre (Type&) + { + os << "template " << endl; + } + + virtual void + name (Type& o) + { + os << endl + << scope_.name () << "_Servant_T::" << o.name (); + } + }; + + struct FacetWriteAttributeEmitter + : WriteAttributeSourceEmitter + { + // Since swapping does not affect facets, we can just pass 'false' + // to the base class constructor, and not override gen_swapping_set(). + FacetWriteAttributeEmitter (Context& c, SemanticGraph::Interface& i) + : WriteAttributeSourceEmitter (c, + i, + false, + false) + {} + + virtual void + pre (SemanticGraph::ReadWriteAttribute& a) + { + os << "template " << endl; + + WriteAttributeSourceEmitter::pre (a); + } + + virtual void + name (SemanticGraph::ReadWriteAttribute& a) + { + os << scope_.name () << "_Servant_T::" + << a.name () << " (" << endl; + + Traversal::ReadWriteAttribute::belongs (a, write_belongs_); + + os << " " << a.name () << endl + << ")" << endl; + } + }; + + struct FacetAttributeEmitter + : AttributeSourceEmitter + { + FacetAttributeEmitter (Context& c, + SemanticGraph::Interface& i) + : AttributeSourceEmitter (c, i) + {} + + // ReadWriteAttribute + // + + // No-op override because we don't want to generate any swapping + // code for facets. + virtual void gen_swapping_get (SemanticGraph::ReadWriteAttribute&) + { + } + + virtual void + gen_write_operation (SemanticGraph::ReadWriteAttribute& a, + bool /* swapping */) + { + FacetWriteAttributeEmitter write_attribute_emitter (ctx, scope_); + write_attribute_emitter.traverse (a); + } + + virtual void + pre (SemanticGraph::ReadWriteAttribute& a) + { + os << "template " << endl; + + AttributeSourceEmitter::pre (a); + } + + virtual void + name (SemanticGraph::ReadWriteAttribute& a) + { + os << scope_.name () << "_Servant_T::" + << a.name () << " (" << endl + << ")" << endl; + } + + // ReadAttribute + // + + // No-op override because we don't want to generate any swapping + // code for facets. + virtual void gen_swapping_get (SemanticGraph::ReadAttribute&) + { + } + + virtual void + pre (SemanticGraph::ReadAttribute& a) + { + os << "template " << endl; + + AttributeSourceEmitter::pre (a); + } + + virtual void + name (SemanticGraph::ReadAttribute& a) + { + os << scope_.name () << "_Servant_T::" + << a.name () << " (" << endl + << ")" << endl; + } + }; + + virtual void + traverse (UnconstrainedInterface& i) + { + if (i.context ().count ("facet_src_gen")) return; + + // We need to escape C++ keywords before flattening the name. + // + string name; + { + std::ostringstream ostr; + ostr.pword (name_printer_index) = os.pword (name_printer_index); + ostr << i.scoped_name ().scope_name (); + name = regex::perl_s (ostr.str (), "/::/_/"); + } + + + /// Open a namespace made from the interface scope's name. + os << "namespace " << STRS[FACET_PREFIX] << name + << "{"; + + os << "template " << endl + << i.name () << "_Servant_T::" << i.name () + << "_Servant_T (" << endl + << i.scoped_name ().scope_name () << "::CCM_" << i.name () + << "_ptr executor," << endl + << "::Components::CCMContext_ptr c)" << endl + << " : executor_ ( " << i.scoped_name ().scope_name () << "::CCM_" + << i.name () << "::_duplicate (executor))," << endl + << " ctx_ ( ::Components::CCMContext::_duplicate (c))" << endl + << "{" + << "}"; + + os << "template " << endl + << i.name () << "_Servant_T::~" << i.name () + << "_Servant_T (void)" << endl + << "{" + << "}"; + + { + InterfaceEmitter interface_emitter (ctx); + + Traversal::Defines defines_; + Traversal::Inherits inherits_; + interface_emitter.edge_traverser (defines_); + interface_emitter.edge_traverser (inherits_); + + FacetAttributeEmitter attribute_emitter (ctx, i); + defines_.node_traverser (attribute_emitter); + + FacetOperationEmitter operation_emitter (ctx, i); + defines_.node_traverser (operation_emitter); + inherits_.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + inherits (i, inherits_); + names (i, defines_); + } + + os << "template " << endl + << "::CORBA::Object_ptr" << endl + << i.name () << "_Servant_T::_get_component (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << STRS[COMP_SC] << "_var sc =" << endl + << " " << STRS[COMP_SC] << "::_narrow (" << endl + << " this->ctx_.in ()" << endl + << " " << ");" + << endl + << "if (! ::CORBA::is_nil (sc.in ()))" << endl + << "{" + << "return sc->get_CCM_object (" << endl + << ");" + << "}" + << "::Components::EntityContext_var ec =" << endl + << "::Components::EntityContext::_narrow (" << endl + << "this->ctx_.in ()" << endl + << ");" + << endl + << "if (! ::CORBA::is_nil (ec.in ()))" << endl + << "{" + << "return ec->get_CCM_object (" << endl + << ");" + << "}" + << STRS[ACE_TR] << " ( ::CORBA::INTERNAL (), 0);" << endl + << "}" << endl; + + // Close the facet servant's namespace. + os << "}"; + + i.context ().set ("facet_src_gen", true); + } + }; + + struct ContextEmitter : Traversal::Component, EmitterBase + { + ContextEmitter (Context& c) + : EmitterBase (c) + {} + + // Nested classes used by ContextEmitter. + private: + struct ContextPortsEmitter : Traversal::SingleUserData, + Traversal::MultiUserData, + Traversal::PublisherData, + Traversal::EmitterData, + EmitterBase + { + ContextPortsEmitter (Context& c, SemanticGraph::Component& scope) + : EmitterBase (c), + type_name_emitter_ (c), + enclosing_type_name_emitter_ (c), + simple_type_name_emitter_ (c), + scope_ (scope) + { + belongs_.node_traverser (type_name_emitter_); + enclosing_belongs_.node_traverser (enclosing_type_name_emitter_); + simple_belongs_.node_traverser (simple_type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::SingleUser& u) + { + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << scope_.name () << "_Context::get_connection_" + << u.name () << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "return "; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "::_duplicate (" << endl + << "this->ciao_uses_" << u.name () + << "_.in ());" << endl + << "}"; + + os << "void" << endl + << scope_.name () << "_Context::connect_" + << u.name () << " (" << endl; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_AC] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{" + << "if (! ::CORBA::is_nil (this->ciao_uses_" + << u.name () << "_.in ()))" << endl + << "{" + << "throw " << STRS[EXCP_AC] << " ();" + << "}" + << "if ( ::CORBA::is_nil (c))" << endl + << "{" + << "throw " << STRS[EXCP_IC] << " ();" + << "}" + << "this->ciao_uses_" << u.name () << "_ =" << endl + << " "; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "::_duplicate (c);" << endl + << "}"; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << scope_.name () << "_Context::disconnect_" + << u.name () << " ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_NC] << "))" << endl + << "{" + << "if ( ::CORBA::is_nil (this->ciao_uses_" + << u.name () << "_.in ()))" << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_NC] << " ()," << endl; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "::_nil ());" << endl + << "}" + << "return this->ciao_uses_" << u.name () + << "_._retn ();" << endl + << "}"; + } + + virtual void + traverse (SemanticGraph::MultiUser& u) + { + os << u.scoped_name () << "Connections *" << endl + << scope_.name () << "_Context::get_connections_" + << u.name () << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << u.scoped_name () << "Connections *tmp_retv = 0;" + << "ACE_NEW_THROW_EX (" + << "tmp_retv," << endl + << u.scoped_name () << "Connections (" << endl + << "this->ciao_uses_" + << u.name () << "_.current_size ())," << endl + << "::CORBA::NO_MEMORY ());" << endl + << u.scoped_name () << "Connections_var retv" + << " = tmp_retv;" << endl + << "retv->length (this->ciao_uses_" << u.name () + << "_.current_size ());" << endl; + + os << "::CORBA::ULong i = 0;" << endl; + + os << "for (ACE_Active_Map_Manager< " << endl + << " "; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_var>::iterator iter =" << endl + << " this->ciao_uses_" << u.name () << "_.begin ();" << endl + << "iter != this->ciao_uses_" << u.name () << "_.end ();" + << endl + << "++iter)" << endl + << "{" + << "ACE_Active_Map_Manager< " << endl; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_var>::ENTRY & entry = *iter;" << endl + << "retv[i].objref = "; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "::_narrow (" << endl + << "entry.int_id_.in ()" << endl + << ");" + << endl; + + os << "ACE_NEW_THROW_EX (" + << "retv[i].ck.inout ()," << endl + << "::CIAO::Map_Key_Cookie (entry.ext_id_)," << endl + << "::CORBA::NO_MEMORY ());" << endl + << "++i;" << endl + << "}"; + + os << "return retv._retn ();" << endl + << "}"; + + os << STRS[COMP_CK] << " *" << endl + << scope_.name () << "_Context::connect_" + << u.name () << " (" << endl; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{" + << "if ( ::CORBA::is_nil (c))" << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_IC] << " (), 0);" << endl + << "}"; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_var conn = "; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "::_duplicate (c);" + << "ACE_Active_Map_Manager_Key key;" << endl; + + os << "if (this->ciao_uses_" << u.name () + << "_.bind (conn.in (), key) == -1)" << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_IC] << " (), 0);" << endl + << "}"; + + os << "conn._retn ();" << endl; + + os << STRS[COMP_CK] << " * ck = 0;" + << "ACE_NEW_THROW_EX (" + << "ck," << endl + << "::CIAO::Map_Key_Cookie (key)," << endl + << "::CORBA::NO_MEMORY ());" << endl; + + + os << "return ck;" << endl + << "}"; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << scope_.name () << "_Context::disconnect_" + << u.name () << " (" << endl + << STRS[COMP_CK] << " * ck)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{"; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_var retv;" + << "ACE_Active_Map_Manager_Key key;" << endl; + + os << "if (! CIAO::Map_Key_Cookie::extract (ck, key))" + << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_IC] << " ()," << endl; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "::_nil ());" << endl + << "}"; + + os << "if (this->ciao_uses_" << u.name () + << "_.unbind (key, retv) != 0)" << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_IC] << " ()," << endl; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "::_nil ());" << endl + << "}"; + + os << "return retv._retn ();" << endl + << "}"; + } + + virtual void + traverse (SemanticGraph::Publisher& p) + { + os << "void" << endl + << scope_.name () << "_Context::push_" + << p.name () << " (" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << " *ev" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "for (ACE_Active_Map_Manager< " << endl + << " "; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_var>::iterator iter =" << endl + << " this->ciao_publishes_" << p.name () + << "_map_.begin ();" << endl + << "iter != this->ciao_publishes_" << p.name () + << "_map_.end ();" << endl + << "++iter)" << endl + << "{" + << "(*iter).int_id_->push_"; + + Traversal::PublisherData::belongs (p, simple_belongs_); + + os << " (" << endl + << "ev" << endl + << ");" << endl + << "}"; + + // @@ GD Modified Code Below + + os << endl; + os << "ACE_CString source_id = this->_ciao_instance_id ();"; + os << "source_id += \"_\";" << endl; + os << "source_id += \"" << p.name () << "\";//port name" << endl << endl; + + os << "for (ACE_Active_Map_Manager< " << endl + << " " << STRS[COMP_ECB] << "_var>::iterator giter =" << endl + << " this->ciao_publishes_" << p.name () + << "_generic_map_.begin ();" << endl + << "giter != this->ciao_publishes_" << p.name () + << "_generic_map_.end ();" << endl + << "++giter)" << endl + << "{" + << "(*giter).int_id_->ciao_push_event" << " (" << endl + << "ev," << endl + << "source_id.c_str ()," << endl; + + Traversal::PublisherData::belongs (p, enclosing_belongs_); + + os << "::_tc_"; + + Traversal::PublisherData::belongs (p, simple_belongs_); + + os << endl + << ");" << endl + << "}" + << "}"; + + os << STRS[COMP_CK] << " *" << endl + << scope_.name () << "_Context::subscribe_" + << p.name () << " (" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "))" << endl + << "{" + << "if ( ::CORBA::is_nil (c))" << endl + << "{" + << STRS[ACE_TR] << " ( ::CORBA::BAD_PARAM (), 0);" << endl + << "}"; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_var sub =" << endl + << " "; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer::_duplicate (c);" << endl + << "ACE_Active_Map_Manager_Key key;" + << "this->ciao_publishes_" << p.name () + << "_map_.bind (sub.in (), key);" + << "sub._retn ();" << endl + << STRS[COMP_CK] << " * retv = 0;" + << "ACE_NEW_THROW_EX (" + << "retv," << endl + << "::CIAO::Map_Key_Cookie (key)," << endl + << "::CORBA::NO_MEMORY ());" << endl + << "return retv;" << endl + << "}"; + + os << STRS[COMP_CK] << " *" << endl + << scope_.name () << "_Context::subscribe_" + << p.name () << "_generic (" << endl + << STRS[COMP_ECB] << "_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "))" << endl + << "{" + << "if ( ::CORBA::is_nil (c))" << endl + << "{" + << STRS[ACE_TR] << " ( ::CORBA::BAD_PARAM (), 0);" << endl + << "}"; + + os << STRS[COMP_ECB] << "_var sub =" << endl + << " " << STRS[COMP_ECB] << "::_duplicate (c);" << endl + << "ACE_Active_Map_Manager_Key key;" + << "this->ciao_publishes_" << p.name () + << "_generic_map_.bind (sub.in (), key);" + << "sub._retn ();" << endl + << STRS[COMP_CK] << " * retv = 0;" + << "ACE_NEW_THROW_EX (" + << "retv," << endl + << "::CIAO::Map_Key_Cookie (key)," << endl + << "::CORBA::NO_MEMORY ());" << endl + << "return retv;" << endl + << "}"; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_ptr" << endl + << scope_.name () << "_Context::unsubscribe_" + << p.name () << " (" << endl + << STRS[COMP_CK] << " *ck)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{" + << "ACE_Active_Map_Manager_Key key;" << endl + << "if (ck == 0 || ::CIAO::Map_Key_Cookie::extract (ck, key) == false)" + << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_IC] << " ()," << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer::_nil ());" << endl + << "}"; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_var retv;" + << "if (this->ciao_publishes_" << p.name () + << "_map_.unbind (key, retv) == 0)" << endl + << "{" + << "return retv._retn ();" << endl + << "}"; + + os << STRS[COMP_ECB] << "_var ecb;" << endl; + + os << "if (this->ciao_publishes_" << p.name () + << "_generic_map_.unbind (key, ecb) != 0)" << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_IC] << " ()," << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer::_nil ());" << endl + << "}" + << "return "; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer::_nil ();" << endl + << "}"; + } + + virtual void + traverse (SemanticGraph::Emitter& e) + { + os << "void" << endl + << scope_.name () << "_Context::push_" + << e.name () << " (" << endl; + + Traversal::EmitterData::belongs (e, belongs_); + + os << " *ev" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "this->ciao_emits_" << e.name () + << "_consumer_->push_"; + + Traversal::EmitterData::belongs (e, simple_belongs_); + + os << " (" << endl + << "ev" << endl + << ");" << endl + << "}"; + + os << "void" << endl + << scope_.name () << "_Context::connect_" + << e.name () << " (" << endl; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_AC] << "))" << endl + << "{" + << "if ( ::CORBA::is_nil (c))" << endl + << "{" + << "throw ::CORBA::BAD_PARAM ();" << endl + << "}" + << "if (! ::CORBA::is_nil (this->ciao_emits_" << e.name () + << "_consumer_.in ()))" << endl + << "{" + << "throw " << STRS[EXCP_AC] << " ();" << endl + << "}" + << "this->ciao_emits_" << e.name () + << "_consumer_ = " << endl; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer::_duplicate (c);" << endl + << "}"; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer_ptr" << endl + << scope_.name () << "_Context::disconnect_" + << e.name () << " ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_NC] << "))" << endl + << "{" + << "if ( ::CORBA::is_nil (this->ciao_emits_" << e.name () + << "_consumer_.in ()))" << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_NC] << " ()," << endl; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer::_nil ());" << endl + << "}" + << "return this->ciao_emits_" << e.name () + << "_consumer_._retn ();" << endl + << "}"; + } + + private: + FullTypeNameEmitter type_name_emitter_; + EnclosingTypeNameEmitter enclosing_type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + Traversal::Belongs belongs_; + Traversal::Belongs enclosing_belongs_; + Traversal::Belongs simple_belongs_; + SemanticGraph::Component& scope_; + }; + + struct SwappableGetConsumersEmitter : Traversal::PublisherData, + Traversal::EmitterData, + EmitterBase + { + SwappableGetConsumersEmitter (Context& c) + : EmitterBase (c), + type_name_emitter_ (c) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::Publisher& p) + { + os << "if (ACE_OS::strcmp (publisher_name, \"" + << p.name ().unescaped_str () << "\") == 0)" << endl + << "{" + << "_ciao_size = this->ciao_publishes_" << p.name () + << "_map_.current_size ();" << endl + << "ACE_NEW_THROW_EX (" + << "tmp," << endl + << STRS[COMP_CD] << " (_ciao_size)," << endl + << "::CORBA::NO_MEMORY ());" << endl + << "retval = tmp;" + << "retval->length (_ciao_size);" << endl + << "ACE_Active_Map_Manager<" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_var>::iterator end =" << endl + << " this->ciao_publishes_" << p.name () + << "_map_.end ();" << endl + << "for (ACE_Active_Map_Manager<" << endl + << " "; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_var>::iterator iter =" << endl + << " this->ciao_publishes_" << p.name () + << "_map_.begin ();" + << "iter != end;" + << "++iter)" << endl + << "{" + << "ACE_Active_Map_Manager<" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_var>::entry &e = *iter;" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_var c =" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer::_narrow (" << endl + << "e.int_id_.in ()" << endl + << ");" + << endl + << "if ( ::CORBA::is_nil (c.in ()))" + << "{" + << STRS[ACE_TR] << " ( " << STRS[EXCP_IC] << " (), 0);" + << "}" + << "::Components::ConsumerDescription *cd = 0;" + << "ACE_NEW_THROW_EX (" + << "cd," << endl + << "OBV_Components::ConsumerDescription ()," << endl + << "::CORBA::NO_MEMORY ());" << endl + << "::Components::ConsumerDescription_var safe = cd;" + << "safe->name (\"\");" + << "safe->type_id (\"\");" + << "safe->consumer (c.in ());" << endl + << "retval[_ciao_index++] = safe;" + << "}" + << "return retval._retn ();" + << "}"; + } + + virtual void + traverse (SemanticGraph::Emitter&) + { + // Don't know yet if swappable components need anything here. + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + }; + + public: + virtual void + pre (Type& t) + { + os << t.name () << "_Context::" + << t.name () << "_Context (" << endl + << "::Components::CCMHome_ptr h," << endl + << "::CIAO::Session_Container *c," << endl + << t.name () << "_Servant *sv)" << endl + << " : ::CIAO::Context_Impl_Base (h, c), " << endl + << " ::CIAO::Context_Impl<" << endl + << " " << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << "_Context," << endl + << " " << t.name () << "_Servant," << endl + << " " << t.scoped_name () << "," << endl + << " " << t.scoped_name () << "_var" << endl + << " > (h, c, sv)"; + + string swap_option = ctx.cl ().get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + if (swapping) + { + os << "," << endl + << " ::CIAO::Upgradeable_Context_Impl<" << endl + << " " << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << "_Context," << endl + << " " << t.name () << "_Servant," << endl + << " " << t.scoped_name () << "," << endl + << " " << t.scoped_name () << "_var" << endl + << " > (h, c, sv)" << endl; + } + else + { + os << endl; + } + + os << "{" + << "}"; + + os << t.name () << "_Context::~" + << t.name () << "_Context (void)" << endl + << "{" + << "}"; + + os << "// Operations for " << t.name () << " receptacles" + << " and event sources," << endl + << "// defined in " << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << "_Context." + << endl << endl; + + // Generate Context class operations for receptacles and event sources. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + ContextPortsEmitter ports_emitter (ctx, t); + defines.node_traverser (ports_emitter); + + component_emitter.traverse (t); + } + + // Extra *_Context methods for swapping container. + if (swapping) + { + os << "// Operations defined in " << t.scoped_name ().scope_name () + << "::CCM_" << t.name () << "_Context" << endl + << "// that enable component swapping in the container" + << endl << endl; + + os << STRS[COMP_CD] << " *" << endl + << t.name () << "_Context::get_registered_consumers (" << endl + << "const char *publisher_name)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{" + << "if (publisher_name == 0)" << endl + << "{" + << STRS[ACE_TR] << " ( " << STRS[EXCP_IN] << " (), 0);" + << "}" + << STRS[COMP_CD] << " *tmp = 0;" + << STRS[COMP_CD] << "_var retval;" + << "CORBA::ULong _ciao_index = 0;" + << "CORBA::ULong _ciao_size = 0;" + << STRS[ACE_UA] << " (tmp);" + << STRS[ACE_UA] << " (retval);" + << STRS[ACE_UA] << " (_ciao_index);" + << STRS[ACE_UA] << " (_ciao_size);" << endl; + + // Generate IF block for each event sources. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + SwappableGetConsumersEmitter get_consumers_emitter (ctx); + defines.node_traverser (get_consumers_emitter); + + component_emitter.traverse (t); + } + + os << STRS[ACE_TR] << " ( " << STRS[EXCP_IN] << " (), 0);" + << "}"; + } + + os << "// CIAO-specific." << endl << endl; + + os << t.name () << "_Context *" << endl + << t.name () << "_Context::_narrow (" << endl + << STRS[COMP_SC] << "_ptr p" << endl + << ")" << endl + << "{" + << "return dynamic_cast<" << t.name () << "_Context *> (p);" + << endl + << "}"; + } + }; + + struct ServantEmitter : Traversal::Component, EmitterBase + { + ServantEmitter (Context& c) + : EmitterBase (c) + {} + + // Nested classes used by ServantEmitter. + private: + struct EmitsConnectEmitter : Traversal::EmitterData, + EmitterBase + + { + EmitsConnectEmitter (Context& c) + : EmitterBase (c), + type_name_emitter_ (c) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (Type& t) + { + os << "if (ACE_OS::strcmp (emitter_name, \"" + << t.name ().unescaped_str () << "\") == 0)" << endl + << "{"; + + Traversal::EmitterData::belongs (t, belongs_); + + os << "Consumer_var _ciao_consumer =" << endl + << " "; + + Traversal::EmitterData::belongs (t, belongs_); + + os << "Consumer::_narrow (" << endl + << " consumer" << endl + << " " << ");" << endl + << "if ( ::CORBA::is_nil (_ciao_consumer.in ()))" << endl + << "{" + << "throw " << STRS[EXCP_IC] << " ();" + << endl + << "}" + << "this->connect_" << t.name () + << " (" << endl + << "_ciao_consumer.in ()" << endl + << ");" << endl + << "return;" + << "}"; + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + }; + + struct EmitsDisconnectEmitter : Traversal::EmitterData, + EmitterBase + { + EmitsDisconnectEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (Type& t) + { + os << "if (ACE_OS::strcmp (source_name, \"" + << t.name ().unescaped_str () << "\") == 0)" << endl + << "{" + << "return this->disconnect_" << t.name () + << " ();" << endl + << "}"; + } + }; + + struct NavigationGetFacetExecEmitter : Traversal::ProviderData, + EmitterBase + { + NavigationGetFacetExecEmitter (Context& c) + : EmitterBase (c) + {} + + virtual void + traverse (Type& t) + { + os << "if (ACE_OS::strcmp (name, \"" + << t.name ().unescaped_str () << "\") == 0)" << endl + << "{" + << "return this->executor_->get_" << t.name () + << " ();" << endl + << "}"; + } + }; + + struct PublishesEmitter : Traversal::PublisherData, + EmitterBase + { + PublishesEmitter (Context& c, + SemanticGraph::Component& scope) + : EmitterBase (c), + type_name_emitter_ (c), + scope_ (scope) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (Type& p) + { + os << STRS[COMP_CK] << " *" << endl + << scope_.name () + << "_Servant::subscribe_" << p.name () << " (" << endl; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "))" << endl + << "{"; + + string swap_option = ctx.cl ().get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "return this->context_->subscribe_" << p.name () + << " (" << endl + << "c" << endl + << ");" << endl + << "}"; + + os << STRS[COMP_CK] << " *" << endl + << scope_.name () + << "_Servant::subscribe_" << p.name () << "_generic (" << endl + << STRS[COMP_ECB] << "_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "))" << endl + << "{"; + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "return this->context_->subscribe_" << p.name () + << "_generic (" << endl + << "c" << endl + << ");" << endl + << "}"; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_ptr" << endl + << scope_.name () + << "_Servant::unsubscribe_" << p.name () << " (" << endl + << STRS[COMP_CK] << " *ck)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{"; + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "return this->context_->unsubscribe_" + << p.name () << " (" << endl + << "ck" << endl + << ");" << endl + << "}"; + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + SemanticGraph::Component& scope_; + }; + + struct UsesConnectEmitter : Traversal::SingleUserData, + Traversal::MultiUserData, + EmitterBase + { + UsesConnectEmitter (Context& c) + : EmitterBase (c), + type_name_emitter_ (c) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::SingleUser& u) + { + os << "if (ACE_OS::strcmp (name, \"" + << u.name ().unescaped_str () << "\") == 0)" << endl + << "{"; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_var _ciao_conn =" << endl; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "::_narrow (" << endl + << "connection" << endl + << ");" + << endl + << "if ( ::CORBA::is_nil (_ciao_conn.in ()))" << endl + << "{" + << STRS[ACE_TR] << " ( " << STRS[EXCP_IC] << " (), 0);" + << endl + << "}" + << "// Simplex connect." << endl + << "this->connect_" << u.name () << " (" << endl + << "_ciao_conn.in ()" << endl + << ");" + << endl + << "return 0;" << endl + << "}"; + } + + virtual void + traverse (SemanticGraph::MultiUser& u) + { + os << "if (ACE_OS::strcmp (name, \"" + << u.name ().unescaped_str () << "\") == 0)" << endl + << "{"; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_var _ciao_conn =" << endl; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "::_narrow (" << endl + << "connection" << endl + << ");" + << endl + << "if ( ::CORBA::is_nil (_ciao_conn.in ()))" << endl + << "{" + << STRS[ACE_TR] << " ( " << STRS[EXCP_IC] << " (), 0);" + << endl + << "}" + << "// Multiplex connect." << endl + << "return this->connect_" << u.name () << " (" << endl + << "_ciao_conn.in ()" << endl + << ");" + << "}"; + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + }; + + struct UsesDisconnectEmitter : Traversal::SingleUserData, + Traversal::MultiUserData, + EmitterBase + { + UsesDisconnectEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (SemanticGraph::SingleUser& u) + { + os << "if (ACE_OS::strcmp (name, \"" + << u.name ().unescaped_str () << "\") == 0)" << endl + << "{" + << "// Simplex disconnect." << endl + << "return this->disconnect_" << u.name () + << " ();" << endl + << "}"; + } + + virtual void + traverse (SemanticGraph::MultiUser& u) + { + os << "if (ACE_OS::strcmp (name, \"" + << u.name ().unescaped_str () << "\") == 0)" << endl + << "{" + << "// Multiplex disconnect." << endl + << "if (ck == 0)" << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_CR] << " ()," << endl + << "::CORBA::Object::_nil ());" << endl + << "}" + << "return this->disconnect_" << u.name () << " (" << endl + << "ck" << endl + << ");" << endl + << "}"; + } + }; + + struct UsesEmitter : Traversal::SingleUserData, + Traversal::MultiUserData, + EmitterBase + { + UsesEmitter (Context& c, SemanticGraph::Component& scope) + : EmitterBase (c), + type_name_emitter_ (c), + scope_ (scope) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (SemanticGraph::SingleUser& u) + { + os << "void" << endl + << scope_.name () << "_Servant::connect_" + << u.name () << " (" << endl; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_AC] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{" + << "this->context_->connect_" << u.name () << " (" + << endl + << "c" << endl + << ");" << endl + << "this->add_receptacle (\"" << u.name ().unescaped_str () + << "\", c, 0);" << endl + << "}"; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << scope_.name () << "_Servant::disconnect_" + << u.name () << " ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_NC] << "))" << endl + << "{" + << "return this->context_->disconnect_" << u.name () + << " (" << endl + << ");" << endl + << "}"; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << scope_.name () + << "_Servant::get_connection_" << u.name () + << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "return this->context_->get_connection_" + << u.name () << " (" << endl + << ");" << endl + << "}"; + } + + virtual void + traverse (SemanticGraph::MultiUser& u) + { + os << STRS[COMP_CK] << " *" << endl + << scope_.name () << "_Servant::connect_" + << u.name () << " (" << endl; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_ECL] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{" + << "::Components::Cookie * cookie = " + "this->context_->connect_" << u.name () << " (" + << endl + << "c" << endl + << ");" << endl + << "this->add_receptacle (\"" << u.name ().unescaped_str () + << "\", c, cookie);" << endl + << "return cookie;" << endl + << "}"; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_ptr" << endl + << scope_.name () << "_Servant::disconnect_" + << u.name () << " (" << endl + << STRS[COMP_CK] << " * ck)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{" + << "return this->context_->disconnect_" << u.name () + << " (" << endl + << "ck" << endl + << ");" << endl + << "}"; + + os << u.scoped_name () << "Connections *" << endl + << scope_.name () + << "_Servant::get_connections_" << u.name () + << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "return this->context_->get_connections_" + << u.name () << " (" << endl + << ");" << endl + << "}"; + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + SemanticGraph::Component& scope_; + }; + + struct PublishesSubscribeEmitter : Traversal::PublisherData, + EmitterBase + { + PublishesSubscribeEmitter (Context& c) + : EmitterBase (c), + type_name_emitter_ (c) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (Type& p) + { + os << "if (ACE_OS::strcmp (publisher_name, \"" + << p.name ().unescaped_str () << "\") == 0)" << endl + << "{"; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_var sub =" << endl + << " "; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer::_narrow (" << endl + << "subscribe" << endl + << ");" + << endl; + + os << "if ( ::CORBA::is_nil (sub.in ()))" << endl + << "{" + << "::CORBA::Boolean substitutable =" << endl + << " subscribe->ciao_is_substitutable (" << endl + << " "; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "::_tao_obv_static_repository_id ()" << endl + << " " << ");" + << endl; + + os << "if (substitutable)" << endl + << "{" + << "return this->subscribe_" << p.name () << "_generic (" << endl + << "subscribe" << endl + << ");" << endl + << "}" + << "else" << endl + << "{" + << STRS[ACE_TR] << " ( " << STRS[EXCP_IC] << " (), 0);" << endl + << "}" + << "}" + << "else" << endl + << "{" + << "return this->subscribe_" << p.name () << " (" << endl + << "sub.in ()" << endl + << ");" << endl + << "}" + << "}"; + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + }; + + struct PublishesUnsubscribeEmitter : Traversal::PublisherData, + EmitterBase + { + PublishesUnsubscribeEmitter (Context& c) + : EmitterBase (c) + {} + + virtual void + traverse (Type& p) + { + os << "if (ACE_OS::strcmp (publisher_name, \"" + << p.name ().unescaped_str () << "\") == 0)" << endl + << "{" + << "return this->unsubscribe_" << p.name () + << " (" << endl + << "ck" << endl + << ");" << endl + << "}"; + } + }; + + struct EmitsEmitter : Traversal::EmitterData, + EmitterBase + { + EmitsEmitter (Context& c, SemanticGraph::Component& scope) + : EmitterBase (c), + type_name_emitter_ (c), + scope_ (scope) + { + belongs_.node_traverser (type_name_emitter_); + } + + virtual void + traverse (Type& e) + { + os << "void" << endl + << scope_.name () << "_Servant::connect_" + << e.name () << " (" << endl; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer_ptr c)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_AC] << "))" << endl + << "{" + << "this->context_->connect_" << e.name () + << " (" << endl + << "c" << endl + << ");" << endl + << "}"; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer_ptr" << endl + << scope_.name () << "_Servant::disconnect_" + << e.name () << " ()" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_NC] << "))" << endl + << "{" + << "return this->context_->disconnect_" + << e.name () << " (" << endl + << ");" << endl + << "}"; + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + SemanticGraph::Component& scope_; + }; + + struct ServantTypeNameEmitter : Traversal::Type, + EmitterBase + { + ServantTypeNameEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (SemanticGraph::Type& t) + { + os << t.name () << "_Servant"; + } + }; + + struct FacetProvidesEmitter : Traversal::ProviderData, + EmitterBase + { + FacetProvidesEmitter (Context& c, + SemanticGraph::Component& scope) + : EmitterBase (c), + type_name_emitter_ (c), + simple_type_name_emitter_ (c), + servant_type_name_emitter_ (c), + enclosing_type_name_emitter_ (c), + facet_enclosing_type_name_emitter_ (c), + repo_id_emitter_ (c), + scope_ (scope) + { + belongs_.node_traverser (type_name_emitter_); + simple_belongs_.node_traverser (simple_type_name_emitter_); + servant_belongs_.node_traverser (servant_type_name_emitter_); + enclosing_belongs_.node_traverser (enclosing_type_name_emitter_); + facet_enclosing_belongs_.node_traverser ( + facet_enclosing_type_name_emitter_ + ); + repo_id_belongs_.node_traverser (repo_id_emitter_); + } + + virtual void + traverse (Type& p) + { + Traversal::ProviderData::belongs (p, belongs_); + + os << "_ptr" << endl + << scope_.name () + << "_Servant::provide_" << p.name () << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{"; + + string swap_option = ctx.cl ().get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + if (swapping) + + { + os << "this->activate_component ();" + << endl; + } + + os << "if (! ::CORBA::is_nil (this->provide_" + << p.name () << "_.in ()))" << endl + << "{" + << "return "; + + Traversal::ProviderData::belongs (p, belongs_); + + os << "::_duplicate (this->provide_" << p.name () << "_.in ());" + << "}"; + + os << "::CORBA::Object_var obj =" << endl + << " this->provide_" << p.name () << "_i (" + << ");" + << endl; + + ScopedName scoped (scope_.scoped_name ()); + Name stripped (scoped.begin () + 1, scoped.end ()); + + Traversal::ProviderData::belongs (p, belongs_); + + os << "_var fo =" << endl + << " "; + + Traversal::ProviderData::belongs (p, belongs_); + + os << "::_narrow (" + << "obj.in ()" << endl + << ");" + << endl + << "this->provide_" << p.name () << "_ = fo;" + << "return "; + + Traversal::ProviderData::belongs (p, belongs_); + + os << "::_duplicate (this->provide_" + << p.name () << "_.in ());" << endl + << "}"; + + // Corresponding private provide_*_i() method. + + os << "::CORBA::Object_ptr" << endl + << scope_.name () + << "_Servant::provide_" << p.name () << "_i (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "::CORBA::Object_ptr ret =" << endl + << " this->lookup_facet (\"" + << p.name ().unescaped_str () << "\");" << endl; + + os << "if (! ::CORBA::is_nil (ret))" << endl + << "{" + << "return ret;" + << "}"; + + os << "::CIAO::Port_Activator_T<" << endl + << " ::" << STRS[FACET_PREFIX]; + + Traversal::ProviderData::belongs (p, facet_enclosing_belongs_); + + os << "::"; + + Traversal::ProviderData::belongs (p, servant_belongs_); + + os << "," << endl + << " "; + + Traversal::ProviderData::belongs (p, enclosing_belongs_); + + os << "::CCM_"; + + Traversal::ProviderData::belongs (p, simple_belongs_); + + os << "," << endl + << " ::Components::CCMContext," << endl + << " " << scope_.name () << "_Servant" << endl + << " > *tmp = 0;" << endl + << "typedef ::CIAO::Port_Activator_T<" << endl + << " ::" << STRS[FACET_PREFIX]; + + Traversal::ProviderData::belongs (p, facet_enclosing_belongs_); + + os << "::"; + + Traversal::ProviderData::belongs (p, servant_belongs_); + + os << "," << endl + << " "; + + Traversal::ProviderData::belongs (p, enclosing_belongs_); + + os << "::CCM_"; + + Traversal::ProviderData::belongs (p, simple_belongs_); + + os << "," << endl + << " ::Components::CCMContext," << endl + << " " << scope_.name () << "_Servant" << endl + << " >" << endl + << "MACRO_MADNESS_TYPEDEF;" << endl; + + os << "ACE_CString obj_id (this->ins_name_);" + << "obj_id += \"_" << p.name ().unescaped_str () << "\";" << endl; + + os << "ACE_NEW_THROW_EX (" + << "tmp," << endl + << "MACRO_MADNESS_TYPEDEF (" << endl + << "obj_id.c_str ()," << endl + << "\"" << p.name ().unescaped_str () << "\"," << endl + << "::CIAO::Port_Activator::Facet," << endl + << "0," << endl + << "this->context_," << endl + << "this)," << endl + << "::CORBA::NO_MEMORY ());" << endl; + + os << "::CIAO::Servant_Activator *sa = " << endl + << "this->container_->ports_servant_activator ();" << endl + << "if (!sa->register_port_activator (tmp))" << endl + << "{" + << "return "; + + Traversal::ProviderData::belongs (p, belongs_); + + os << "::_nil ();" + << "}"; + + os << "::CORBA::Object_var obj =" << endl + << " this->container_->generate_reference (" << endl + << " obj_id.c_str ()," << endl + << " "; + + Traversal::ProviderData::belongs (p, repo_id_belongs_); + + os << "," << endl + << " ::CIAO::Container::Facet_Consumer" << endl + << " " << ");" + << endl + << "this->add_facet (\"" + << p.name ().unescaped_str () << "\"," << endl + << "obj.in ()" << endl + << ");" + << endl; + + os << "return obj._retn ();" << endl + << "}"; + } + + private: + FullTypeNameEmitter type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + ServantTypeNameEmitter servant_type_name_emitter_; + EnclosingTypeNameEmitter enclosing_type_name_emitter_; + FacetEnclosingTypeNameEmitter facet_enclosing_type_name_emitter_; + RepoIdEmitter repo_id_emitter_; + Traversal::Belongs belongs_; + Traversal::Belongs simple_belongs_; + Traversal::Belongs servant_belongs_; + Traversal::Belongs enclosing_belongs_; + Traversal::Belongs facet_enclosing_belongs_; + Traversal::Belongs repo_id_belongs_; + SemanticGraph::Component& scope_; + }; + + struct ConsumesEmitter : Traversal::ConsumerData, + EmitterBase + { + ConsumesEmitter (Context& c, SemanticGraph::Component& scope) + : EmitterBase (c), + type_name_emitter_ (c), + simple_type_name_emitter_ (c), + repo_id_emitter_ (c), + scope_ (scope) + { + belongs_.node_traverser (type_name_emitter_); + simple_belongs_.node_traverser (simple_type_name_emitter_); + repo_id_belongs_.node_traverser (repo_id_emitter_); + } + + virtual void + traverse (Type& c) + { + os << scope_.name () << "_Servant::"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant::"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant (" << endl + << c.scoped_name ().scope_name ().scope_name () << "::CCM_" + << c.scoped_name ().scope_name ().simple_name () + << "_ptr executor," + << endl + << c.scoped_name ().scope_name ().scope_name () << "::CCM_" + << c.scoped_name ().scope_name ().simple_name () + << "_Context_ptr c)" << endl + << " : executor_ ( " << c.scoped_name ().scope_name ().scope_name () + << "::CCM_" << c.scoped_name ().scope_name ().simple_name () + << "::_duplicate (executor))," << endl + << " ctx_ ( " << c.scoped_name ().scope_name ().scope_name () + << "::CCM_" << c.scoped_name ().scope_name ().simple_name () + << "_Context::_duplicate (c))" << endl + << "{" + << "}"; + + os << scope_.name () << "_Servant::"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant::~"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant (void)" << endl + << "{" + << "}"; + + os << "::CORBA::Object_ptr" << endl + << scope_.name () << "_Servant::"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant::_get_component (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "return this->ctx_->get_CCM_object " + << "();" << endl + << "}"; + + os << "void" << endl + << scope_.name () << "_Servant::"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant::push_"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << " (" << endl; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << " *evt" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "this->executor_->push_" << c.name () + << " (" << endl + << "evt" << endl + << ");" << endl + << "}"; + + os << "// Inherited from " << STRS[COMP_ECB] << "." << endl + << "void" << endl + << scope_.name () << "_Servant::"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant::push_event (" << endl + << "::Components::EventBase *ev)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_BET] << "))" << endl + << "{"; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << " *ev_type =" << endl + << " "; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << "::_downcast (ev);" << endl + << "if (ev_type != 0)" << endl + << "{" + << "this->push_"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << " (" << endl + << "ev_type" << endl + << ");" << endl + << "return;" << endl + << "}" + << "throw " << STRS[EXCP_BET] << " ();" << endl + << "}"; + + // GD Added below code + // Begin + + os << "// Inherited from " << STRS[COMP_ECB] << "." << endl + << "void" << endl + << scope_.name () << "_Servant::"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant::ciao_push_event (" << endl + << "::Components::EventBase *ev," << endl + << "const char * /* source_id */," << endl + << "::CORBA::TypeCode_ptr /* tc */)" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_BET] << "))" << endl + << "{" + << "this->push_event (ev);" << endl + << "}"; + + // End + + os << "CORBA::Boolean" << endl + << scope_.name () << "_Servant::"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant::ciao_is_substitutable (" << endl + << "const char * event_repo_id" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "if (event_repo_id == 0)" << endl + << "{" + << STRS[ACE_TR] << " ( ::CORBA::BAD_PARAM (), false);" << endl + << "}" + << scope_.name () << "_Context *ctx =" << endl + << " " << scope_.name () << "_Context::_narrow (" << endl + << " this->ctx_.in ()" << endl + << " " << ");" + << endl; + + os << "CORBA::ORB_ptr orb = ctx->_ciao_the_Container ()->the_ORB ();" + << endl; + + os << "CORBA::ValueFactory f =" << endl + << " orb->lookup_value_factory (" << endl + << " event_repo_id" << endl + << " " << ");" + << endl; + + os << "if (f == 0)" << endl + << "{" + << "return false;" << endl + << "}" + << "CORBA::ValueBase_var v =" << endl + << " f->create_for_unmarshal ();" + << endl; + + os << "f->_remove_ref ();" << endl; + + os << "if (v.in () == 0)" << endl + << "{" + << "return false;" << endl + << "}"; + + os << "return dynamic_cast< "; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << " *> (v.in ()) != 0;" << endl + << "}" << endl; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << "Consumer_ptr" << endl + << scope_.name () << "_Servant::" + << "get_consumer_" << c.name () << " (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "if (! ::CORBA::is_nil (this->consumes_" << c.name () + << "_.in ()))" << endl + << "{" + << "return "; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << "Consumer::_duplicate (this->consumes_" + << c.name () << "_.in ());" + << "}"; + + os << "::Components::EventConsumerBase_var obj =" << endl + << " this->get_consumer_" << c.name () << "_i (" << endl + << " " << ");" + << endl; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << "Consumer_var eco =" << endl + << " "; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << "Consumer::_narrow (" << endl + << " obj.in ()" << endl + << " " << ");" + << endl + << "this->consumes_" << c.name () << "_ = eco;" + << "return "; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << "Consumer::_duplicate (this->consumes_" << c.name () + << "_.in ());" << endl + << "}"; + + // Corresponding private get_consumer_*_i() method. + + os << "::Components::EventConsumerBase_ptr" << endl + << scope_.name () << "_Servant::" + << "get_consumer_" << c.name () << "_i (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << "::Components::EventConsumerBase_ptr ret =" << endl + << " this->lookup_consumer (\"" + << c.name ().unescaped_str () << "\");" << endl; + + os << "if (! ::CORBA::is_nil (ret))" << endl + << "{" + << "return ret;" + << "}"; + + os << "::CIAO::Port_Activator_T<" << endl; + + os << scope_.name () << "_Servant::"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant," << endl + << c.scoped_name ().scope_name ().scope_name () + << "::CCM_" + << c.scoped_name ().scope_name ().simple_name () + << "," << endl + << c.scoped_name ().scope_name ().scope_name () << "::CCM_" + << c.scoped_name ().scope_name ().simple_name () + << "_Context," << endl + << scope_.name () << "_Servant" + << " > *tmp = 0;" << endl + << "typedef CIAO::Port_Activator_T<" << endl; + + os << " " << scope_.name () << "_Servant::"; + + Traversal::ConsumerData::belongs (c, simple_belongs_); + + os << "Consumer_" << c.name () + << "_Servant," << endl + << " " << c.scoped_name ().scope_name ().scope_name () + << "::CCM_" + << c.scoped_name ().scope_name ().simple_name () + << "," << endl + << " " << c.scoped_name ().scope_name ().scope_name () << "::CCM_" + << c.scoped_name ().scope_name ().simple_name () + << "_Context, " << endl + << " " << scope_.name () << "_Servant" << endl + << " >" << endl + << "MACRO_MADNESS_TYPEDEF;" << endl; + + os << "ACE_CString obj_id (this->ins_name_);" + << "obj_id += \"_" << c.name ().unescaped_str () << "\";" << endl; + + os << "ACE_NEW_THROW_EX (" << endl + << "tmp," << endl + << "MACRO_MADNESS_TYPEDEF (" + << "obj_id.c_str ()," << endl + << "\"" << c.name ().unescaped_str () << "\"," << endl + << "::CIAO::Port_Activator::Sink," << endl + << "this->executor_.in ()," << endl + << "this->context_," << endl + << "this)," << endl + << "::CORBA::NO_MEMORY ());" << endl; + + os << "::CIAO::Servant_Activator *sa =" << endl + << " this->container_->ports_servant_activator ();" << endl + << "if (!sa->register_port_activator (tmp))" << endl + << "{" + << "return "; + + Traversal::ConsumerData::belongs (c, belongs_); + + os << "Consumer::_nil ();" + << "}"; + + os << "::CORBA::Object_var obj =" << endl + << " this->container_->generate_reference (" << endl + << " obj_id.c_str ()," << endl + << " "; + + Traversal::ConsumerData::belongs (c, repo_id_belongs_); + + os << "," << endl + << " ::CIAO::Container::Facet_Consumer" << endl + << " " << ");" + << endl; + + os << "::Components::EventConsumerBase_var ecb =" << endl + << " ::Components::EventConsumerBase::_narrow (" << endl + << " obj.in ()" << endl + << " " << ");" + << endl; + + os << "this->add_consumer (\"" + << c.name ().unescaped_str () << "\"," << endl + << "ecb.in ()" << endl + << ");" + << endl; + + os << "return ecb._retn ();" << endl + << "}"; + } + + private: + FullTypeNameEmitter type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + ConsumerRepoIdEmitter repo_id_emitter_; + Traversal::Belongs belongs_; + Traversal::Belongs simple_belongs_; + Traversal::Belongs repo_id_belongs_; + SemanticGraph::Component& scope_; + }; + + struct OperationExistsEmitter; + + struct RegisterValueFactoryEmitter : Traversal::ConsumerData, + Traversal::PublisherData, + Traversal::EmitterData, + EmitterBase + { + RegisterValueFactoryEmitter (Context& c) + : EmitterBase (c), + type_name_emitter_ (c), + gen_factory_ (true) + { + belongs_.node_traverser (type_name_emitter_); + } + + void factory_gen_off (void) + { + gen_factory_ = false; + } + + bool gen_factory (void) const + { + return gen_factory_; + } + + virtual void + traverse (SemanticGraph::Publisher& p) + { + Traversal::PublisherData publisher; + RegisterValueFactoryEmitter::traverse_common< + SemanticGraph::Publisher, + Traversal::PublisherData> (p, publisher, this, os, belongs_); + } + + virtual void + traverse (SemanticGraph::Emitter& e) + { + Traversal::EmitterData emitter; + RegisterValueFactoryEmitter::traverse_common< + SemanticGraph::Emitter, + Traversal::EmitterData> (e, emitter, this, os, belongs_); + } + + virtual void + traverse (SemanticGraph::Consumer& c) + { + Traversal::ConsumerData consumer; + RegisterValueFactoryEmitter::traverse_common< + SemanticGraph::Consumer, + Traversal::ConsumerData> (c, consumer, this, os, belongs_); + } + + template + static void + traverse_common (SemanticType& st, + TraversalType& tt, + RegisterValueFactoryEmitter* r, + ostream& os, + Traversal::Belongs& blongs) + { + { + Traversal::Belongs tt_belongs; + tt.edge_traverser (tt_belongs); + + // Separate traversers because we want to catch inherited + // operations, but not base class factories or private + // members. + Traversal::ValueType event_type_operations; + Traversal::ValueType event_type_factories; + tt_belongs.node_traverser (event_type_operations); + tt_belongs.node_traverser (event_type_factories); + + Traversal::Inherits inherits; + inherits.node_traverser (event_type_operations); + event_type_operations.edge_traverser (inherits); + + Traversal::Defines include_inherit_defines; + event_type_operations.edge_traverser (include_inherit_defines); + OperationExistsEmitter op_emitter (r); + include_inherit_defines.node_traverser (op_emitter); + + Traversal::Supports supports; + event_type_operations.edge_traverser (supports); + Traversal::Interface iface; + supports.node_traverser (iface); + inherits.node_traverser (iface); + iface.edge_traverser (inherits); + iface.edge_traverser (include_inherit_defines); + + Traversal::Defines no_include_inherit_defines; + event_type_factories.edge_traverser (no_include_inherit_defines); + PrivateExistsEmitter priv_emitter (r); + FactoryExistsEmitter factory_emitter (r); + no_include_inherit_defines.node_traverser (priv_emitter); + no_include_inherit_defines.node_traverser (factory_emitter); + + tt.traverse (st); + } + + if (r->gen_factory ()) + { + os << "CIAO_REGISTER_OBV_FACTORY (" << endl; + + r->TraversalType::belongs (st, blongs); + + os << "_init," << endl; + + r->TraversalType::belongs (st, blongs); + + os << ");" << endl; + } + } + + private: + FullTypeNameEmitter type_name_emitter_; + Traversal::Belongs belongs_; + bool gen_factory_; + }; + + struct OperationExistsEmitter : Traversal::Operation, + Traversal::ValueTypeFactory + { + OperationExistsEmitter (RegisterValueFactoryEmitter* r) + : r_ (r) + { + } + + virtual void + traverse (SemanticGraph::Operation&) + { + r_->factory_gen_off (); + } + + virtual void + traverse (SemanticGraph::ValueTypeFactory&) + { + // This gets called for base eventtypes as well, so + // we don't want to catch this here, but there's no + // way to avoid it, so we make it a no-op. This + // catches both valuetype and eventtype factories. + } + + private: + RegisterValueFactoryEmitter* r_; + }; + + // Since we're not interested in ancestors' factories, we can + // specialize all the way to EventTypeFactory. + struct FactoryExistsEmitter : Traversal::EventTypeFactory + { + FactoryExistsEmitter (RegisterValueFactoryEmitter* r) + : r_ (r) + { + } + + virtual void + traverse (SemanticGraph::EventTypeFactory&) + { + r_->factory_gen_off (); + } + + private: + RegisterValueFactoryEmitter* r_; + }; + + struct PrivateExistsEmitter : Traversal::ValueTypePrivateMember + { + PrivateExistsEmitter (RegisterValueFactoryEmitter* r) + : r_ (r) + { + } + + virtual void + traverse (Type&) + { + r_->factory_gen_off (); + } + + private: + RegisterValueFactoryEmitter* r_; + }; + + struct PortTablePopulator : Traversal::ProviderData, + Traversal::UserData, + Traversal::PublisherData, + Traversal::EmitterData, + Traversal::ConsumerData, + EmitterBase + { + PortTablePopulator (Context& c) + : EmitterBase (c) + { + } + + virtual void + traverse (SemanticGraph::Provider& p) + { + os << "obj_var =" << endl + << " this->provide_" << p.name () << "_i (" << endl + << " " << ");" << endl; + } + + virtual void + traverse (SemanticGraph::User&) + { + } + + virtual void + traverse (SemanticGraph::Publisher&) + { + } + + virtual void + traverse (SemanticGraph::Emitter&) + { + } + + virtual void + traverse (SemanticGraph::Consumer& p) + { + os << "ecb_var =" << endl + << " this->get_consumer_" << p.name () << "_i (" << endl + << " " << ");" << endl; + } + }; + + struct SetAttributesEmitter : Traversal::ReadWriteAttribute, + EmitterBase + { + SetAttributesEmitter (Context& c) + : EmitterBase (c) + { + } + + virtual void + pre (SemanticGraph::ReadWriteAttribute& a) + { + Traversal::Belongs delegate_belongs; + + SetAttributeDelegationEmitter delegater (ctx, a); + delegate_belongs.node_traverser (delegater); + + Traversal::ReadWriteAttribute::belongs (a, delegate_belongs); + } + }; + + struct UsesSizeCalculator : Traversal::SingleUserData, + Traversal::MultiUserData, + EmitterBase + { + UsesSizeCalculator (Context& c, unsigned long& size) + : EmitterBase (c), + size_ (size) + { + } + + virtual void + traverse (SemanticGraph::SingleUser&) + { + ++size_; + } + + virtual void + traverse (SemanticGraph::MultiUser&) + { + ++size_; + } + + private: + unsigned long& size_; + }; + + struct UsesGetAllEmitter : Traversal::SingleUserData, + Traversal::MultiUserData, + EmitterBase + { + UsesGetAllEmitter (Context& c) + : EmitterBase (c), + type_name_emitter_ (c), + repo_id_emitter_ (c), + slot_ (0UL) + { + belongs_.node_traverser (type_name_emitter_); + repo_id_belongs_.node_traverser (repo_id_emitter_); + } + + virtual void + traverse (SemanticGraph::SingleUser& u) + { + os << "::CIAO::Servant_Impl_Base::describe_simplex_receptacle<" + << endl + << " "; + + Traversal::SingleUserData::belongs (u, belongs_); + + os << "_var" << endl + << " > (\"" << u.name ().unescaped_str () << "\"," << endl; + + Traversal::SingleUserData::belongs (u, repo_id_belongs_); + + os << "," << endl + << "this->context_->ciao_uses_" << u.name () << "_," << endl + << "safe_retval," << endl + << slot_ << "UL);" << endl; + + ++slot_; + } + + virtual void + traverse (SemanticGraph::MultiUser& u) + { + os << "::CIAO::Servant_Impl_Base::describe_multiplex_receptacle<" + << endl + << " "; + + Traversal::MultiUserData::belongs (u, belongs_); + + os << "_var" << endl + << " > (\"" << u.name ().unescaped_str () << "\"," << endl; + + Traversal::MultiUserData::belongs (u, repo_id_belongs_); + + os << "," << endl + << "this->context_->ciao_uses_" << u.name () << "_," << endl + << "safe_retval," << endl + << slot_ << "UL);" << endl; + + ++slot_; + } + + private: + FullTypeNameEmitter type_name_emitter_; + RepoIdEmitter repo_id_emitter_; + Traversal::Belongs belongs_; + Traversal::Belongs repo_id_belongs_; + unsigned long slot_; + }; + + struct PublishesSizeCalculator : Traversal::PublisherData, + EmitterBase + { + PublishesSizeCalculator (Context& c, unsigned long& size) + : EmitterBase (c), + size_ (size) + { + } + + virtual void + traverse (SemanticGraph::Publisher&) + { + ++size_; + } + + private: + unsigned long& size_; + }; + + struct PublishesGetAllEmitter : Traversal::PublisherData, + EmitterBase + { + PublishesGetAllEmitter (Context& c) + : EmitterBase (c), + type_name_emitter_ (c), + repo_id_emitter_ (c), + slot_ (0UL) + { + belongs_.node_traverser (type_name_emitter_); + repo_id_belongs_.node_traverser (repo_id_emitter_); + } + + virtual void + traverse (SemanticGraph::Publisher& p) + { + os << "::CIAO::Servant_Impl_Base::describe_pub_event_source<" + << endl + << " "; + + Traversal::PublisherData::belongs (p, belongs_); + + os << "Consumer_var" << endl + << " > (\"" << p.name ().unescaped_str () << "\"," << endl; + + Traversal::PublisherData::belongs (p, repo_id_belongs_); + + os << "," << endl + << "this->context_->ciao_publishes_" << p.name () + << "_map_," << endl + << "safe_retval," << endl + << slot_ << "UL);" << endl; + + ++slot_; + } + + private: + FullTypeNameEmitter type_name_emitter_; + RepoIdEmitter repo_id_emitter_; + Traversal::Belongs belongs_; + Traversal::Belongs repo_id_belongs_; + unsigned long slot_; + }; + + struct EmitsSizeCalculator : Traversal::EmitterData, + EmitterBase + { + EmitsSizeCalculator (Context& c, unsigned long& size) + : EmitterBase (c), + size_ (size) + + { + } + + virtual void + traverse (SemanticGraph::Emitter&) + { + ++size_; + } + + private: + unsigned long& size_; + }; + + struct EmitsGetAllEmitter : Traversal::EmitterData, + EmitterBase + { + EmitsGetAllEmitter (Context& c) + : EmitterBase (c), + type_name_emitter_ (c), + repo_id_emitter_ (c), + slot_ (0UL) + { + belongs_.node_traverser (type_name_emitter_); + repo_id_belongs_.node_traverser (repo_id_emitter_); + } + + virtual void + traverse (SemanticGraph::Emitter& e) + { + os << "::CIAO::Servant_Impl_Base::describe_emit_event_source<" + << endl + << " "; + + Traversal::EmitterData::belongs (e, belongs_); + + os << "Consumer_var" << endl + << " > (\"" << e.name ().unescaped_str () << "\"," << endl; + + Traversal::EmitterData::belongs (e, repo_id_belongs_); + + os << "," << endl + << "this->context_->ciao_emits_" << e.name () + << "_consumer_," << endl + << "safe_retval," << endl + << slot_ << "UL);" << endl; + + ++slot_; + } + + private: + FullTypeNameEmitter type_name_emitter_; + RepoIdEmitter repo_id_emitter_; + Traversal::Belongs belongs_; + Traversal::Belongs repo_id_belongs_; + unsigned long slot_; + }; + + public: + virtual void + pre (Type& t) + { + ScopedName scoped (t.scoped_name ()); + Name stripped (scoped.begin () + 1, scoped.end ()); + + // Servant Constructor + os << t.name () << "_Servant::" + << t.name () << "_Servant (" << endl + << t.scoped_name ().scope_name () << "::CCM_" << t.name () + << "_ptr exe," << endl + << "::Components::CCMHome_ptr h," << endl + << "const char *ins_name," << endl + << "::CIAO::Home_Servant_Impl_Base *hs," << endl + << "::CIAO::Session_Container *c)" << endl + << " : ::CIAO::Servant_Impl_Base " + << "(h, hs, c)," << endl + << " ::CIAO::Servant_Impl<" << endl + << " ::POA_" << stripped << "," << endl + << " " << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << "," << endl + << " " << t.name () << "_Context" << endl + << " > (exe, h, hs, c)," << endl + << " ins_name_ (ins_name)" << endl + << "{" + << "ACE_NEW (" + << "this->context_," << endl + << t.name () << "_Context (h, c, this));" << endl; + + os << "// Set the instance id of the component on the context" << endl + << endl + << "this->context_->_ciao_instance_id (this->ins_name_);" << endl; + + + // Generate the macro to register a value factory for each + // eventtype consumed. + if (!ctx.cl ().get_value ("suppress-register-factory", false)) + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + RegisterValueFactoryEmitter factory_emitter (ctx); + defines.node_traverser (factory_emitter); + + component_emitter.traverse (t); + } + + os << "try" << endl + << "{" + << "::Components::SessionComponent_var scom =" << endl + << " ::Components::SessionComponent::_narrow (" << endl + << " exe" << endl + << " " << ");" << endl + << "if (! ::CORBA::is_nil (scom.in ()))" << endl + << "{" + << "scom->set_session_context (" << endl + << "this->context_" << endl + << ");" + << "}" + << "this->populate_port_tables (" << endl + << ");" + << "}" + << "catch (const CORBA::Exception&)" << endl + << "{" + << "}" + << endl + << "}"; + + // Servant Destructor + os << t.name () << "_Servant::~" + << t.name () << "_Servant (void)" << endl + << "{" + << "}"; + + // Override pure virtual set_attributes() operation. + os << "void" << endl + << t.name () << "_Servant::set_attributes (" << endl + << "const ::Components::ConfigValues &descr" << endl + << ")" << endl + << "{" << endl; + + string swap_option = ctx.cl ().get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "for ( ::CORBA::ULong i = 0; i < descr.length (); ++i)" << endl + << "{" + << "const char *descr_name = descr[i]->name ();" + << "::CORBA::Any &descr_value = descr[i]->value ();" << endl; + + // Generate string compare and set for each attribute. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + SetAttributesEmitter set_attributes_emitter (ctx); + defines.node_traverser (set_attributes_emitter); + + component_emitter.traverse (t); + } + + + os << STRS[ACE_UA] << " (descr_name);" + << STRS[ACE_UA] << " (descr_value);" << endl; + + os << "}" + << "}"; + + // Generate provides_ operation. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + FacetProvidesEmitter provides_emitter (ctx, t); + defines.node_traverser (provides_emitter); + + component_emitter.traverse (t); + } + + // Generate subscribe_* and unsubscribe_* operations. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + PublishesEmitter publishes_emitter (ctx, t); + defines.node_traverser (publishes_emitter); + + component_emitter.traverse (t); + } + + // Generate operations for nested Consumer classes. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + ConsumesEmitter consumes_emitter (ctx, t); + defines.node_traverser (consumes_emitter); + + component_emitter.traverse (t); + } + + os << STRS[COMP_CK] << " *" << endl + << t.name () << "_Servant::connect (" << endl + << "const char *name," << endl + << "::CORBA::Object_ptr connection" << endl + << ")" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_IC] << "," << endl + << STRS[EXCP_AC] << "," << endl + << STRS[EXCP_ECL] << "))" << endl + << "{"; + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "// If the component has no receptacles, this will be unused." + << endl + << STRS[ACE_UA] << " (connection);" << endl + << "if (name == 0)" << endl + << "{" + << STRS[ACE_TR] << " ( " << STRS[EXCP_IN] << " (), 0);" << endl + << "}"; + + // Generate IF block in connect operation for each receptacle. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + UsesConnectEmitter uses_emitter (ctx); + defines.node_traverser (uses_emitter); + + component_emitter.traverse (t); + } + + os << STRS[ACE_TR] << " ( " << STRS[EXCP_IN] << " (), 0);" << endl + << "}"; + + os << "::CORBA::Object_ptr" << endl + << t.name () << "_Servant::disconnect (" << endl + << "const char *name," << endl + << STRS[COMP_CK] << " * ck" << endl + << ")" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_IC] << "," << endl + << STRS[EXCP_CR] << "," << endl + << STRS[EXCP_NC] << "))" << endl + << "{" + << STRS[ACE_UA] << " (ck);" << endl; + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "if (name == 0)" << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_BP] << "," << endl + << "::CORBA::Object::_nil ());" << endl + << "}"; + + // Generate IF block in disconnect operation for each receptacle. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + UsesDisconnectEmitter uses_emitter (ctx); + defines.node_traverser (uses_emitter); + + component_emitter.traverse (t); + } + + os << STRS[ACE_TR] << " ( " + << STRS[EXCP_IN] << " ()," << endl + << "::CORBA::Object::_nil ());" + << "}"; + + os << STRS[COMP_RD] << " *" << endl + << t.name () << "_Servant::get_all_receptacles (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << STRS[COMP_RD] << " *retval = 0;" + << "ACE_NEW_RETURN (retval," << endl + << STRS[COMP_RD] << "," << endl + << "0);" + << STRS[COMP_RD] << "_var safe_retval = retval;"; + + unsigned long size = 0; + + // Calculate the number of uses ports. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + UsesSizeCalculator size_calculator (ctx, size); + defines.node_traverser (size_calculator); + + component_emitter.traverse (t); + } + + os << "safe_retval->length (" << size << "UL);" << endl; + + // Generate a sequence element assignment for each uses port. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + UsesGetAllEmitter get_all_emitter (ctx); + defines.node_traverser (get_all_emitter); + + component_emitter.traverse (t); + } + + os << "return safe_retval._retn ();" + << "}"; + + // Generate generic operations for receptacles. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + UsesEmitter uses_emitter (ctx, t); + defines.node_traverser (uses_emitter); + + component_emitter.traverse (t); + } + + os << "void" << endl + << t.name () << "_Servant::connect_consumer (" + << endl + << "const char * emitter_name," << endl + << STRS[COMP_ECB] << "_ptr consumer" << endl + << ")" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_AC] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{"; + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "if (emitter_name == 0)" << endl + << "{" + << "throw " << STRS[EXCP_BP] << ";" << endl + << "}"; + + // Generate an IF block for each 'emits' declaration. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + EmitsConnectEmitter emits_connect_emitter (ctx); + defines.node_traverser (emits_connect_emitter); + + component_emitter.traverse (t); + } + + os << STRS[ACE_UA] << " (consumer);" + << "throw " + << STRS[EXCP_IN] << " ();" << endl + << "}"; + + os << STRS[COMP_ECB] << "_ptr" << endl + << t.name () << "_Servant::disconnect_consumer (" << endl + << "const char *source_name" << endl + << ")" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_NC] << "))" << endl + << "{"; + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "if (source_name == 0)" << endl + << "{" + << STRS[ACE_TR] << " ( " << STRS[EXCP_BP] << "," << endl + << STRS[COMP_ECB] << "::_nil ());" << endl + << "}"; + + // Generate an IF block for each 'emits' declaration. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + EmitsDisconnectEmitter emits_disconnect_emitter (ctx); + defines.node_traverser (emits_disconnect_emitter); + + component_emitter.traverse (t); + } + + os << STRS[ACE_TR] << " ( " + << STRS[EXCP_IN] << " ()," << endl + << STRS[COMP_ECB] << "::_nil ());" << endl + << "}"; + + os << STRS[COMP_PD] << " *" << endl + << t.name () << "_Servant::get_all_publishers (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << STRS[COMP_PD] << " *retval = 0;" + << "ACE_NEW_RETURN (retval," << endl + << STRS[COMP_PD] << "," << endl + << "0);" + << STRS[COMP_PD] << "_var safe_retval = retval;"; + + size = 0UL; + + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + PublishesSizeCalculator publishes_size_calculator (ctx, size); + defines.node_traverser (publishes_size_calculator); + + component_emitter.traverse (t); + } + + os << "safe_retval->length (" << size << "UL);" << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + PublishesGetAllEmitter publishes_get_all_emitter (ctx); + defines.node_traverser (publishes_get_all_emitter); + + component_emitter.traverse (t); + } + + os << "return safe_retval._retn ();" + << "}"; + + os << STRS[COMP_ED] << " *" << endl + << t.name () << "_Servant::get_all_emitters (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << STRS[COMP_ED] << " *retval = 0;" + << "ACE_NEW_RETURN (retval," << endl + << STRS[COMP_ED] << "," << endl + << "0);" + << STRS[COMP_ED] << "_var safe_retval = retval;"; + + size = 0UL; + + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + EmitsSizeCalculator emits_size_calculator (ctx, size); + defines.node_traverser (emits_size_calculator); + + component_emitter.traverse (t); + } + + os << "safe_retval->length (" << size << "UL);" << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + EmitsGetAllEmitter emits_get_all_emitter (ctx); + defines.node_traverser (emits_get_all_emitter); + + component_emitter.traverse (t); + } + + os << "return safe_retval._retn ();" + << "}"; + + os << STRS[COMP_CK] << " *" << endl + << t.name () << "_Servant::subscribe (" << endl + << "const char *publisher_name," << endl + << STRS[COMP_ECB] << "_ptr subscribe" << endl + << ")" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_IC] << "," << endl + << STRS[EXCP_ECL] << "))" << endl + << "{"; + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "// Just in case there are no if blocks" << endl + << STRS[ACE_UA] << " (subscribe);" << endl + << "if (publisher_name == 0)" << endl + << "{" + << STRS[ACE_TR] << " ( " << STRS[EXCP_IN] << " (), 0);" + << endl + << "}"; + + // Generate an IF block in for each publisher in subscribe(). + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + PublishesSubscribeEmitter publishes_emitter (ctx); + defines.node_traverser (publishes_emitter); + + component_emitter.traverse (t); + } + + os << STRS[ACE_TR] << " ( " << STRS[EXCP_IN] << " (), 0);" << endl + << "}"; + + os << STRS[COMP_ECB] << "_ptr" << endl + << t.name () << "_Servant::unsubscribe (" + << endl + << "const char *publisher_name," << endl + << STRS[COMP_CK] << " *ck" << endl + << ")" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl + << STRS[EXCP_IN] << "," << endl + << STRS[EXCP_IC] << "))" << endl + << "{"; + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "// Just in case there are no if blocks" << endl + << STRS[ACE_UA] << " (ck);" << endl + << "if (publisher_name == 0)" << endl + << "{" + << STRS[ACE_TR] << " ( " + << STRS[EXCP_IN] << " ()," << endl + << STRS[COMP_ECB] << "::_nil ());" << endl + << "}"; + + // Generate an IF block in for each publisher in unsubscribe(). + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + PublishesUnsubscribeEmitter publishes_emitter (ctx); + defines.node_traverser (publishes_emitter); + + component_emitter.traverse (t); + } + + os << STRS[ACE_TR] << " ( " + << STRS[EXCP_IN] << " ()," << endl + << STRS[COMP_ECB] << "::_nil ());" << endl + << "}"; + + // Generate connect() and disconnect() for each emits declaration. + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + EmitsEmitter emits_emitter (ctx, t); + defines.node_traverser (emits_emitter); + + component_emitter.traverse (t); + } + + os << "::CORBA::Object_ptr" << endl + << t.name () + << "_Servant::get_facet_executor (" << endl + << "const char *name" << endl + << ")" << endl + << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "))" << endl + << "{"; + + if (swapping) + { + os << "this->activate_component ();" + << endl; + } + + os << "if (name == 0)" << endl + << "{" + << STRS[ACE_TR] << " ( " << STRS[EXCP_BP] << "," << endl + << "::CORBA::Object::_nil ());" << endl + << "}"; + + + // Generate an IF block for each facet inside provide_facet(). + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + component_emitter.edge_traverser (inherits); + + NavigationGetFacetExecEmitter navigation_facet_exec_emitter (ctx); + defines.node_traverser (navigation_facet_exec_emitter); + + component_emitter.traverse (t); + } + + os << "return ::CORBA::Object::_nil ();" + << "}"; + + os << "// Supported operations." << endl << endl; + + // Generate operations for all supported interfaces. + { + Traversal::Component component_emitter; + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Supports supports_; + component_emitter.edge_traverser (supports_); + component_emitter.edge_traverser (component_inherits); + + InterfaceEmitter interface_emitter (ctx); + supports_.node_traverser (interface_emitter); + + Traversal::Defines defines; + Traversal::Inherits interface_inherits; + interface_emitter.edge_traverser (defines); + interface_emitter.edge_traverser (interface_inherits); + + AttributeSourceEmitter attribute_emitter (ctx, t); + defines.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx, t); + defines.node_traverser (operation_emitter); + interface_inherits.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + component_emitter.traverse (t); + } + + // Generate operations for component attributes. + os << "// Component attribute operations." << endl << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + component_emitter.edge_traverser (inherits); + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + + AttributeSourceEmitter attribute_emitter (ctx, t); + defines.node_traverser (attribute_emitter); + + component_emitter.traverse (t); + } + + os << "// Private method to populate the port tables." + << endl; + + os << "void" << endl + << t.name () << "_Servant::populate_port_tables (" << endl + << ")" << endl + << STRS[EXCP_SNGL] << endl + << "{" + << ";" + << "::CORBA::Object_var obj_var;" + << "::Components::EventConsumerBase_var ecb_var;" << endl; + + { + Traversal::Component component_emitter; + + Traversal::Inherits inherits; + component_emitter.edge_traverser (inherits); + inherits.node_traverser (component_emitter); + + Traversal::Defines defines; + component_emitter.edge_traverser (defines); + + PortTablePopulator port_table_populator (ctx); + defines.node_traverser (port_table_populator); + + component_emitter.traverse (t); + } + + os << "}"; + } + }; + + struct HomeEmitter : Traversal::Home, EmitterBase + { + HomeEmitter (Context& c, CommandLine const& cl) + : EmitterBase (c), + cl_ (cl), + simple_type_name_emitter_ (c), + repo_id_emitter_ (c), + flat_name_emitter_ (c) + { + simple_manages_.node_traverser (simple_type_name_emitter_); + repo_id_manages_.node_traverser (repo_id_emitter_); + flat_name_manages_.node_traverser (flat_name_emitter_); + } + + // Nested classes used by this emitter. + private: + struct HomeOpExecReturnEmitter : Traversal::Type + { + HomeOpExecReturnEmitter (std::ostream& os_) + : os (os_) + {} + + virtual void + traverse (SemanticGraph::Type&) + { + os << STRS[COMP_EC] << "_var _ciao_ec =" << endl + << "this->executor_->"; + } + + private: + std::ostream& os; + }; + + // HomeFactory and HomeFinder are tied to Operation in + // the front end. Since we want to treat them differently + // than regular operations in a home (we don't want to + // generate anything for base class factory operations, + // example), we use this class for regular home operations + // that overrides HomeFactory and HomeFinder traversals + // to do nothing. + struct HomeOperationEmitter : OperationEmitter, + Traversal::HomeFactory, + Traversal::HomeFinder + { + HomeOperationEmitter (Context& c, SemanticGraph::Home& home) + : OperationEmitter (c, home) + {} + + // Overriden to do nothing since we don't want to generate + // component swapping related code for facet operations. + virtual void + gen_swap_related (SemanticGraph::Operation&) + { + } + + virtual void + traverse (SemanticGraph::HomeFactory&) + { + } + + virtual void + traverse (SemanticGraph::HomeFinder&) + { + } + }; + + struct FactoryOperationEmitter : Traversal::HomeFactory, + Traversal::Home, + EmitterBase + { + FactoryOperationEmitter (Context& c, SemanticGraph::Home& home) + : EmitterBase (c), + return_type_name_emitter_ (c), + enclosing_type_name_emitter_ (c), + simple_type_name_emitter_ (c), + type_name_emitter_ (c), + scope_ (home) + { + returns_.node_traverser (return_type_name_emitter_); + enclosing_manages_.node_traverser (enclosing_type_name_emitter_); + simple_manages_.node_traverser (simple_type_name_emitter_); + manages_.node_traverser (type_name_emitter_); + } + + virtual void + returns (SemanticGraph::HomeFactory& hf) + { + Traversal::HomeFactory::returns (hf, returns_); + + os << endl; + } + + virtual void + name (SemanticGraph::HomeFactory& hf) + { + os << scope_.name () << "_Servant::" << hf.name (); + } + + virtual void + receives_none (SemanticGraph::HomeFactory&) + { + os << " (" << endl + << ")" << endl; + } + + virtual void + receives_pre (SemanticGraph::HomeFactory&) + { + os << " (" << endl; + } + + virtual void + receives_post (SemanticGraph::HomeFactory&) + { + os << endl << ")" << endl; + } + + virtual void + raises_none (SemanticGraph::HomeFactory&) + { + os << STRS[EXCP_SNGL]; + } + + virtual void + raises_pre (SemanticGraph::HomeFactory&) + { + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; + } + + virtual void + raises_post (SemanticGraph::HomeFactory&) + { + os << "))"; + } + + virtual void + post (SemanticGraph::HomeFactory& hf) + { + os << "{"; + + { + OperationExecEmitter operation_emitter (ctx); + + Traversal::Receives receives; + Traversal::Belongs returns; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + + ParameterExecEmitter in_param (os); + ParameterExecEmitter inout_param (os); + ParameterExecEmitter out_param (os); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + HomeOpExecReturnEmitter return_emitter (os); + returns.node_traverser (return_emitter); + + operation_emitter.traverse (hf); + } + + Traversal::Home::manages (scope_, enclosing_manages_); + + os << "::CCM_"; + + Traversal::Home::manages (scope_, simple_manages_); + + os << "_var _ciao_comp =" << endl; + + Traversal::Home::manages (scope_, enclosing_manages_); + + os << "::CCM_"; + + Traversal::Home::manages (scope_, simple_manages_); + + os << "::_narrow (" << endl + << "_ciao_ec.in ()" << endl + << ");" << endl; + + os << "return this->_ciao_activate_component (" << endl + << "_ciao_comp.in ()" << endl + << ");" << endl; + + os << "}"; + } + + virtual void + comma (SemanticGraph::HomeFactory&) + { + os << "," << endl; + } + + private: + ReturnTypeNameEmitter return_type_name_emitter_; + EnclosingTypeNameEmitter enclosing_type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + FullTypeNameEmitter type_name_emitter_; + Traversal::Returns returns_; + Traversal::Manages enclosing_manages_; + Traversal::Manages simple_manages_; + Traversal::Manages manages_; + SemanticGraph::Home& scope_; + }; + + struct FinderOperationEmitter : Traversal::HomeFinder, + Traversal::Home, + EmitterBase + { + FinderOperationEmitter (Context& c, SemanticGraph::Home& home) + : EmitterBase (c), + type_name_emitter_ (c), + return_type_name_emitter_ (c), + enclosing_type_name_emitter_ (c), + simple_type_name_emitter_ (c), + scope_ (home) + { + returns_.node_traverser (return_type_name_emitter_); + simple_returns_.node_traverser (type_name_emitter_); + enclosing_manages_.node_traverser (enclosing_type_name_emitter_); + simple_manages_.node_traverser (simple_type_name_emitter_); + } + + virtual void + returns (SemanticGraph::HomeFinder& hf) + { + Traversal::HomeFinder::returns (hf, returns_); + + os << endl; + } + + virtual void + name (SemanticGraph::HomeFinder& hf) + { + os << scope_.name () << "_Servant::" << hf.name (); + } + + virtual void + receives_none (SemanticGraph::HomeFinder&) + { + os << " (" << endl + << ")" << endl; + } + + virtual void + receives_pre (SemanticGraph::HomeFinder&) + { + os << " (" << endl; + } + + virtual void + receives_post (SemanticGraph::HomeFinder&) + { + os << endl << ")" << endl; + } + + virtual void + raises_none (SemanticGraph::HomeFinder&) + { + os << STRS[EXCP_SNGL]; + } + + virtual void + raises_pre (SemanticGraph::HomeFinder&) + { + os << STRS[EXCP_START] << " " + << STRS[EXCP_SYS] << "," << endl; + } + + virtual void + raises_post (SemanticGraph::HomeFinder&) + { + os << "))"; + } + + virtual void + post (SemanticGraph::HomeFinder& hf) + { + os << "{" + << STRS[ACE_TR] << " ( ::CORBA::NO_IMPLEMENT ()," << endl; + + Traversal::HomeFinder::returns (hf, simple_returns_); + + os << "::_nil ());" + << "}"; + } + + virtual void + comma (SemanticGraph::HomeFinder&) + { + os << "," << endl; + } + + private: + FullTypeNameEmitter type_name_emitter_; + ReturnTypeNameEmitter return_type_name_emitter_; + EnclosingTypeNameEmitter enclosing_type_name_emitter_; + SimpleTypeNameEmitter simple_type_name_emitter_; + Traversal::Returns returns_; + Traversal::Returns simple_returns_; + Traversal::Manages enclosing_manages_; + Traversal::Manages simple_manages_; + SemanticGraph::Home& scope_; + }; + + public: + virtual void + pre (Type& t) + { + os << t.name () << "_Servant::" + << t.name () << "_Servant (" << endl + << t.scoped_name ().scope_name () << "::CCM_" << t.name () + << "_ptr exe," << endl + << "const char *ins_name," << endl + << "::CIAO::Session_Container *c)" << endl + << " : ::CIAO::Home_Servant_Impl_Base (c)," << endl + << " ::CIAO::"; + + string swap_option = cl_.get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + ScopedName scoped (t.scoped_name ()); + Name stripped (scoped.begin () + 1, scoped.end ()); + + os << (swapping ? "Swapping_" : "") << "Home_Servant_Impl<" << endl + << " ::POA_" << stripped << "," << endl + << " " << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << "," << endl + << " "; + + Traversal::Home::manages (t, simple_manages_); + + os << "_Servant" << endl + << " > (exe, c, ins_name"; + + if (swapping) + { + os << ", \"" << ctx.composition_name (); + + Traversal::Home::manages (t, flat_name_manages_); + + os << "\", "; + + Traversal::Home::manages (t, repo_id_manages_); + } + + os << ")" << endl + << "{" + << "}"; + + os << t.name () << "_Servant::~" + << t.name () << "_Servant (void)" << endl + << "{" + << "}"; + + os << "// Home operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits inherits; + home_emitter.edge_traverser (inherits); + inherits.node_traverser (home_emitter); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + + HomeOperationEmitter home_operation_emitter (ctx, t); + defines.node_traverser (home_operation_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + home_operation_emitter.edge_traverser (receives); + home_operation_emitter.edge_traverser (returns); + home_operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + os << "// Home supported interface operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits home_inherits; + home_inherits.node_traverser (home_emitter); + home_emitter.edge_traverser (home_inherits); + + Traversal::Supports supports_; + home_emitter.edge_traverser (supports_); + + InterfaceEmitter interface_emitter (ctx); + supports_.node_traverser (interface_emitter); + + Traversal::Defines defines; + Traversal::Inherits interface_inherits; + interface_emitter.edge_traverser (defines); + interface_emitter.edge_traverser (interface_inherits); + + AttributeSourceEmitter attribute_emitter (ctx, t); + defines.node_traverser (attribute_emitter); + + OperationEmitter operation_emitter (ctx, t); + defines.node_traverser (operation_emitter); + interface_inherits.node_traverser (interface_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + operation_emitter.edge_traverser (receives); + operation_emitter.edge_traverser (returns); + operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + os << "// Home factory and finder operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits inherits; + home_emitter.edge_traverser (inherits); + inherits.node_traverser (home_emitter); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + + FactoryOperationEmitter factory_operation_emitter (ctx, t); + FinderOperationEmitter finder_operation_emitter (ctx, t); + defines.node_traverser (factory_operation_emitter); + defines.node_traverser (finder_operation_emitter); + + Traversal::Receives receives; + Traversal::Belongs returns; + Traversal::Raises raises; + factory_operation_emitter.edge_traverser (receives); + factory_operation_emitter.edge_traverser (returns); + factory_operation_emitter.edge_traverser (raises); + finder_operation_emitter.edge_traverser (receives); + finder_operation_emitter.edge_traverser (returns); + finder_operation_emitter.edge_traverser (raises); + + ParameterEmitter in_param (ctx); + ParameterEmitter inout_param (ctx); + ParameterEmitter out_param (ctx); + receives.node_traverser (in_param); + receives.node_traverser (inout_param); + receives.node_traverser (out_param); + + ReturnTypeNameEmitter return_type_emitter (ctx); + FullTypeNameEmitter type_name_emitter (ctx); + returns.node_traverser (return_type_emitter); + raises.node_traverser (type_name_emitter); + + Traversal::Belongs in_belongs, inout_belongs, out_belongs; + in_param.edge_traverser (in_belongs); + inout_param.edge_traverser (inout_belongs); + out_param.edge_traverser (out_belongs); + + INArgTypeNameEmitter in_arg_emitter (ctx); + INOUTArgTypeNameEmitter inout_arg_emitter (ctx); + OUTArgTypeNameEmitter out_arg_emitter (ctx); + in_belongs.node_traverser (in_arg_emitter); + inout_belongs.node_traverser (inout_arg_emitter); + out_belongs.node_traverser (out_arg_emitter); + + home_emitter.traverse (t); + } + + // Generate operations for component attributes. + os << "// Home attribute operations." << endl << endl; + + { + Traversal::Home home_emitter; + + Traversal::Inherits inherits; + home_emitter.edge_traverser (inherits); + inherits.node_traverser (home_emitter); + + Traversal::Defines defines; + home_emitter.edge_traverser (defines); + + AttributeSourceEmitter attribute_emitter (ctx, t); + defines.node_traverser (attribute_emitter); + + home_emitter.traverse (t); + } + } + + virtual void + post (Type& t) + { + // We need to escape C++ keywords before flattening the name. + // + string name; + { + std::ostringstream ostr; + ostr.pword (name_printer_index) = os.pword (name_printer_index); + ostr << t.scoped_name (); + name = regex::perl_s (ostr.str (), "/::/_/"); + } + + os << "extern \"C\" " << ctx.export_macro () + << " ::PortableServer::Servant" + << endl + << "create" << name << "_Servant (" << endl + << "::Components::HomeExecutorBase_ptr p," << endl + << "::CIAO::Session_Container *c," << endl + << "const char *ins_name" << endl + << ")" << endl + << "{" + << "if (p == 0)" << endl + << "{" + << "return 0;" << endl + << "}" + << t.scoped_name ().scope_name () << "::CCM_" + << t.name () << "_var x =" << endl + << t.scoped_name ().scope_name () << "::CCM_" << t.name () + << "::_narrow (" << endl + << "p" << endl + << ");" + << endl + << "if (::CORBA::is_nil (x.in ()))" << endl + << "{" + << "return 0;" << endl + << "}" + << "return new" << endl; + + os << t.name () << "_Servant (" << endl + << "x.in ()," << endl + << "ins_name," << endl + << "c);" << endl + << "}"; + } + + private: + CommandLine const& cl_; + SimpleTypeNameEmitter simple_type_name_emitter_; + RepoIdEmitter repo_id_emitter_; + FlatNameEmitter flat_name_emitter_; + Traversal::Manages simple_manages_; + Traversal::Manages repo_id_manages_; + Traversal::Manages flat_name_manages_; + }; +} + +ServantSourceEmitter::ServantSourceEmitter (std::ostream& os_, + CommandLine const& cl, + string export_macro, + fs::path const& file) + : os (os_), + cl_ (cl), + export_macro_ (export_macro), + file_ (file) +{} + +void +ServantSourceEmitter::generate (TranslationUnit& u) +{ + pre (u); + + Context c (os, export_macro_, cl_); + + /// CIAO has facet classes outside the context and servant classes. + /// We launch it here to generate the classes inside namespaces + /// constructed to be unique for each interface type used in a facet. + generate_facets (u, c); + + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion region; + contains_principal.node_traverser (region); + + // Layer 2 + // + Traversal::ContainsRoot contains_root; + Traversal::Includes includes; + + region.edge_traverser (includes); + region.edge_traverser (contains_root); + + //-- + Traversal::Root root; + contains_root.node_traverser (root); + + // Layer 3 + // + Traversal::Defines defines; + root.edge_traverser (defines); + + //-- + ModuleEmitter module (c); + CompositionEmitter composition (c); + defines.node_traverser (module); + defines.node_traverser (composition); + + // Layer 4 + // + Traversal::Defines composition_defines; + composition.edge_traverser (composition_defines); + + //-- + Traversal::ComponentExecutor component_executor; + Traversal::HomeExecutor home_executor; + composition_defines.node_traverser (component_executor); + composition_defines.node_traverser (home_executor); + + module.edge_traverser (defines); + + // Layer 5 + // + Traversal::Implements implements; + component_executor.edge_traverser (implements); + home_executor.edge_traverser (implements); + + //-- + ContextEmitter context_emitter (c); + ServantEmitter servant_emitter (c); + HomeEmitter home_emitter (c, cl_); + implements.node_traverser (context_emitter); + implements.node_traverser (servant_emitter); + implements.node_traverser (home_emitter); + + unit.traverse (u); +} + +void +ServantSourceEmitter::pre (TranslationUnit&) +{ + os << COPYRIGHT; + + string file_name (""); + + if (! file_.empty ()) + { + file_name = file_.leaf (); + } + + string file_suffix = cl_.get_value ("svnt-hdr-file-suffix", + "_svnt.h"); + + file_name = regex::perl_s (file_name, + "/^(.+?)(\\.(idl|cidl|cdl))?$/$1" + + file_suffix + + "/"); + + string swap_option = cl_.get_value ("custom-container", ""); + bool swapping = (swap_option == "upgradeable"); + + os << "#include \"" << file_name << "\"" << endl + << "#include \"Cookies.h\"" << endl + << "#include \"ciao/Servant_Activator.h\"" << endl + << (swapping ? "#include \"ciao/Dynamic_Component_Activator.h\"\n" : "") + << "#include \"ciao/Port_Activator_T.h\"" << endl + << "#include \"ace/SString.h\"" << endl << endl; +} + +void +ServantSourceEmitter::generate_facets (TranslationUnit& u, Context& c) +{ + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion region; + contains_principal.node_traverser (region); + + // Layer 2 + // + Traversal::ContainsRoot contains_root; + Traversal::Includes includes; + + region.edge_traverser (includes); + region.edge_traverser (contains_root); + + //-- + Traversal::Root root; + contains_root.node_traverser (root); + + // Layer 3 + // + Traversal::Defines defines; + root.edge_traverser (defines); + + //-- + Traversal::Module module; + Traversal::Composition composition; + defines.node_traverser (module); + defines.node_traverser (composition); + + // Layer 4 + // + Traversal::Defines composition_defines; + composition.edge_traverser (composition_defines); + + //-- + Traversal::ComponentExecutor component_executor; + Traversal::HomeExecutor home_executor; + composition_defines.node_traverser (component_executor); + composition_defines.node_traverser (home_executor); + + module.edge_traverser (defines); + + // Layer 5 + // + Traversal::Implements implements; + component_executor.edge_traverser (implements); + home_executor.edge_traverser (implements); + + // Layer 6 + // + Traversal::Component component_emitter; + implements.node_traverser (component_emitter); + + Traversal::Inherits component_inherits; + component_inherits.node_traverser (component_emitter); + + Traversal::Defines component_defines; + component_emitter.edge_traverser (component_defines); + component_emitter.edge_traverser (component_inherits); + + // Layer 7 + // + Traversal::Provider provider; + component_defines.node_traverser (provider); + + Traversal::Belongs belongs; + provider.edge_traverser (belongs); + + FacetEmitter facet_emitter (c); + belongs.node_traverser (facet_emitter); + + unit.traverse (u); +} diff --git a/modules/CIAO/CIDLC/ServantSourceGenerator.hpp b/modules/CIAO/CIDLC/ServantSourceGenerator.hpp new file mode 100644 index 00000000000..c5a15fd062c --- /dev/null +++ b/modules/CIAO/CIDLC/ServantSourceGenerator.hpp @@ -0,0 +1,53 @@ +// file : CIDLC/ServantSourceGenerator.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef SERVANT_SOURCE_GENERATOR_HPP +#define SERVANT_SOURCE_GENERATOR_HPP + +#include +#include + +#include "EmitterContext.hpp" + +#include "CCF/CodeGenerationKit/CommandLine.hpp" + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +class ServantSourceEmitter +{ +public: + ServantSourceEmitter (std::ostream& os_, + CommandLine const& cl, + std::string export_macro, + fs::path const& file); + + virtual ~ServantSourceEmitter () {} + + virtual void + generate (CCF::CIDL::SemanticGraph::TranslationUnit& u); + +private: + virtual void + pre (CCF::CIDL::SemanticGraph::TranslationUnit& u); + + virtual void + generate_facets (CCF::CIDL::SemanticGraph::TranslationUnit& u, + Context& c); + +private: + std::ostream& os; + CommandLine const& cl_; + std::string export_macro_; + fs::path file_; +}; + +#endif // SERVANT_SOURCE_GENERATOR_HPP + +/* + * Local Variables: + * mode: C++ + * c-basic-offset: 2 + * End: + */ diff --git a/modules/CIAO/CIDLC/SizeTypeCalculator.cpp b/modules/CIAO/CIDLC/SizeTypeCalculator.cpp new file mode 100644 index 00000000000..b8f44e879ed --- /dev/null +++ b/modules/CIAO/CIDLC/SizeTypeCalculator.cpp @@ -0,0 +1,217 @@ +// file : CIDLC/SizeTypeCalculator.cpp +// author : Boris Kolpackov +// cvs-id : $Id$ + +#include "SizeTypeCalculator.hpp" +#include "Literals.hpp" + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" + +#include + +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; +using namespace StringLiterals; + +namespace +{ + class Calculator : public Traversal::String, + public Traversal::Struct, + public Traversal::Union, + public Traversal::Wstring, + public Traversal::UnboundedSequence, + public Traversal::Interface, + public Traversal::ValueType + { + public: + Calculator () + { + push (false); + } + + public: + virtual void + traverse (SemanticGraph::String&) + { + top () = true; + } + + virtual void + traverse (SemanticGraph::Wstring&) + { + top () = true; + } + + virtual void + traverse (SemanticGraph::UnboundedSequence&) + { + top () = true; + } + + virtual void + traverse (SemanticGraph::Interface&) + { + top () = true; + } + + virtual void + traverse (SemanticGraph::ValueType&) + { + top () = true; + } + + virtual void + pre (SemanticGraph::Struct&) + { + push (false); + } + + virtual void + traverse (SemanticGraph::Struct& s) + { + std::string n (s.scoped_name ().str ()); + if (s.context ().count (STRS[VAR_SIZE])) + { + // Never set 'top' to false (except in pre() above), + // so a 'true' value will propagate up the scopes. + bool r = s.context ().get (STRS[VAR_SIZE]); + if (r) top () = r; + } + else + { + Traversal::Struct::traverse (s); + } + } + + virtual void + post (SemanticGraph::Struct& s) + { + // Set our context to the result of nested scope traversal. + s.context ().set (STRS[VAR_SIZE], top ()); + } + + virtual void + pre (SemanticGraph::Union&) + { + push (false); + } + + virtual void + traverse (SemanticGraph::Union& u) + { + if (u.context ().count (STRS[VAR_SIZE])) + { + // Never set 'top' to false (except in pre() above), + // so a 'true' value will propagate up the scopes. + bool r = u.context ().get (STRS[VAR_SIZE]); + if (r) top () = r; + } + else + { + Traversal::Union::traverse (u); + } + } + + virtual void + post (SemanticGraph::Union& u) + { + // Set our context to the result of nested scope traversal. + u.context ().set (STRS[VAR_SIZE], top ()); + } + + private: + void + push (bool v) + { + stack_.push (v); + } + + bool& + top () + { + return stack_.top (); + } + + void + pop () + { + stack_.pop (); + } + + private: + std::stack stack_; + }; +} + + +void SizeTypeCalculator:: +calculate (SemanticGraph::TranslationUnit& u) +{ + Traversal::TranslationUnit unit; + + // Layer 1 + // + Traversal::ContainsPrincipal contains_principal; + unit.edge_traverser (contains_principal); + + //-- + Traversal::TranslationRegion region; + contains_principal.node_traverser (region); + + // Layer 2 + // + Traversal::ContainsRoot contains_root; + Traversal::Includes includes; + + region.edge_traverser (includes); + region.edge_traverser (contains_root); + + //-- + Traversal::Root root; + includes.node_traverser (region); + contains_root.node_traverser (root); + + // Layer 3 + // + Traversal::Defines defines; + root.edge_traverser (defines); + + //-- + // Everything that can contain a struct or union. + Traversal::Module module; + Traversal::UnconstrainedInterface uinterface; + Traversal::ValueType vtype; + Traversal::Home component_home; + + Calculator calculator; + + defines.node_traverser (module); + defines.node_traverser (uinterface); + defines.node_traverser (vtype); + defines.node_traverser (component_home); + defines.node_traverser (calculator); + + // Layer 4 + // + Traversal::Defines struct_defines; + module.edge_traverser (defines); + uinterface.edge_traverser (defines); + vtype.edge_traverser (defines); + component_home.edge_traverser (defines); + calculator.edge_traverser (struct_defines); + + //-- + Traversal::Member member; + struct_defines.node_traverser (member); + + // Layer 5 + // + Traversal::Belongs belongs; + member.edge_traverser (belongs); + + //-- + belongs.node_traverser (calculator); + + unit.traverse (u); +} diff --git a/modules/CIAO/CIDLC/SizeTypeCalculator.hpp b/modules/CIAO/CIDLC/SizeTypeCalculator.hpp new file mode 100644 index 00000000000..ea765e29cdc --- /dev/null +++ b/modules/CIAO/CIDLC/SizeTypeCalculator.hpp @@ -0,0 +1,21 @@ +// file : CIDLC/SizeTypeCalculator.hpp +// author : Boris Kolpackov +// cvs-id : $Id$ + +#ifndef CIDLC_SIZE_TYPE_CALCULATOR_HPP +#define CIDLC_SIZE_TYPE_CALCULATOR_HPP + + +//@@ Don't really need this. just forward declaration of +// TranslationUnit would be enough. +// +#include "CCF/CIDL/SemanticGraph.hpp" + +class SizeTypeCalculator +{ +public: + void + calculate (CCF::CIDL::SemanticGraph::TranslationUnit&); +}; + +#endif // CIDLC_SIZE_TYPE_CALCULATOR_HPP diff --git a/modules/CIAO/CIDLC/UnescapedNamePrinter.hpp b/modules/CIAO/CIDLC/UnescapedNamePrinter.hpp new file mode 100644 index 00000000000..0b4d31628a4 --- /dev/null +++ b/modules/CIAO/CIDLC/UnescapedNamePrinter.hpp @@ -0,0 +1,23 @@ +// file : CIDLC/UnescapedNamePrinter.hpp +// author : Boris Kolpackov +// cvs-id : $Id: Collectors.hpp 55138 2004-01-05 07:53:05Z parsons $ + +#ifndef UNESCAPED_NAME_PRINTER_HPP +#define UNESCAPED_NAME_PRINTER_HPP + +#include "CCF/IDL2/SemanticGraph/Name.hpp" + +#include + +// Prints names in the unescaped form. +// +struct UnescapedNamePrinter: CCF::IDL2::SemanticGraph::NamePrinter +{ + virtual void + print (std::ostream& os, CCF::IDL2::SemanticGraph::SimpleName const& n) + { + os << n.unescaped_str (); + } +}; + +#endif // UNESCAPED_NAME_PRINTER_HPP diff --git a/modules/CIAO/CIDLC/Upcase.hpp b/modules/CIAO/CIDLC/Upcase.hpp new file mode 100644 index 00000000000..cf114dd8392 --- /dev/null +++ b/modules/CIAO/CIDLC/Upcase.hpp @@ -0,0 +1,21 @@ +// file : CIDLC/Upcase.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef UPCASE_HPP +#define UPCASE_HPP + +#include + +namespace +{ + // On some platforms toupper can be something other than a + // function. + int + upcase (int c) + { + return std::toupper (c); + } +} + +#endif // UPCASE_HPP diff --git a/modules/CIAO/CIDLC/UtilityTypeNameEmitters.cpp b/modules/CIAO/CIDLC/UtilityTypeNameEmitters.cpp new file mode 100644 index 00000000000..44864e4b05e --- /dev/null +++ b/modules/CIAO/CIDLC/UtilityTypeNameEmitters.cpp @@ -0,0 +1,78 @@ +// file : CIDLC/UtilityTypeNameEmitters.cpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#include "UtilityTypeNameEmitters.hpp" +#include "CCF/CodeGenerationKit/Regex.hpp" + +#include + +FullTypeNameEmitter::FullTypeNameEmitter (Context& c) + : EmitterBase (c) +{ +} + +void +FullTypeNameEmitter::traverse (SemanticGraph::Type& t) +{ + os << t.scoped_name (); +} + +// =================================================== + +SimpleTypeNameEmitter::SimpleTypeNameEmitter (Context& c) + : EmitterBase (c) +{ +} + +void +SimpleTypeNameEmitter::traverse (SemanticGraph::Type& t) +{ + os << t.name (); +} + +// =================================================== + +EnclosingTypeNameEmitter::EnclosingTypeNameEmitter (Context& c) + : EmitterBase (c) +{ +} + +void +EnclosingTypeNameEmitter::traverse (SemanticGraph::Type& t) +{ + os << t.scoped_name ().scope_name (); +} + +// =================================================== + +StrippedTypeNameEmitter::StrippedTypeNameEmitter (Context& c) + : EmitterBase (c) +{ +} + +void +StrippedTypeNameEmitter::traverse (SemanticGraph::Type& t) +{ + ScopedName scoped (t.scoped_name ()); + os << Name (scoped.begin () + 1, scoped.end ()); +} + +// =================================================== + +FacetEnclosingTypeNameEmitter::FacetEnclosingTypeNameEmitter (Context& c) + : EmitterBase (c) +{ +} + +void +FacetEnclosingTypeNameEmitter::traverse (SemanticGraph::Type& t) +{ + // We need to escape C++ keywords before flattening the name. + // + std::ostringstream ostr; + ostr.pword (name_printer_index) = os.pword (name_printer_index); + ostr << t.scoped_name ().scope_name (); + os << regex::perl_s (ostr.str (), "/::/_/"); +} + diff --git a/modules/CIAO/CIDLC/UtilityTypeNameEmitters.hpp b/modules/CIAO/CIDLC/UtilityTypeNameEmitters.hpp new file mode 100644 index 00000000000..94c499e1a9d --- /dev/null +++ b/modules/CIAO/CIDLC/UtilityTypeNameEmitters.hpp @@ -0,0 +1,66 @@ +// file : CIDLC/UtilityTypeNameEmitters.hpp +// author : Jeff Parsons +// cvs-id : $Id$ + +#ifndef UTILITYTYPENAMEEMITTERS_HPP +#define UTILITYTYPENAMEEMITTERS_HPP + +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/Traversal.hpp" +#include "EmitterBase.hpp" + +using namespace std; +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +// Emits type's full scoped name. +struct FullTypeNameEmitter : Traversal::Type, + EmitterBase +{ + FullTypeNameEmitter (Context&); + + virtual void + traverse (SemanticGraph::Type&); +}; + +// Emits type's local name. +struct SimpleTypeNameEmitter : Traversal::Type, + EmitterBase +{ + SimpleTypeNameEmitter (Context&); + + virtual void + traverse (SemanticGraph::Type&); +}; + +// Emits name of type's enclosing scope. +struct EnclosingTypeNameEmitter : Traversal::Type, + EmitterBase +{ + EnclosingTypeNameEmitter (Context&); + + virtual void + traverse (SemanticGraph::Type&); +}; + +// Emits scoped name minus the leading double colon. +struct StrippedTypeNameEmitter : Traversal::Type, + EmitterBase +{ + StrippedTypeNameEmitter (Context&); + + virtual void + traverse (SemanticGraph::Type&); +}; + +// Emits scoped name in flat form for use with a prefix. +struct FacetEnclosingTypeNameEmitter : Traversal::Type, + EmitterBase +{ + FacetEnclosingTypeNameEmitter (Context&); + + virtual void + traverse (SemanticGraph::Type&); +}; + +#endif // UTILITYTYPENAMEEMITTERS_HPP diff --git a/modules/CIAO/CIDLC/Version b/modules/CIAO/CIDLC/Version new file mode 100644 index 00000000000..1750564f270 --- /dev/null +++ b/modules/CIAO/CIDLC/Version @@ -0,0 +1 @@ +0.0.6 diff --git a/modules/CIAO/CIDLC/cidlc.cpp b/modules/CIAO/CIDLC/cidlc.cpp new file mode 100644 index 00000000000..b0ca7e2b178 --- /dev/null +++ b/modules/CIAO/CIDLC/cidlc.cpp @@ -0,0 +1,386 @@ +// file : CIDLC/cidlc.cpp +// author : Boris Kolpackov +// cvs-id : $Id$ + +#include +#include + +#include "CCF/CompilerElements/Context.hpp" +#include "CCF/CompilerElements/FileSystem.hpp" +#include "CCF/CompilerElements/Diagnostic.hpp" +#include "CCF/CompilerElements/TokenStream.hpp" +#include "CCF/CompilerElements/Preprocessor.hpp" + +#include "CCF/CodeGenerationKit/CommandLine.hpp" +#include "CCF/CodeGenerationKit/CommandLineParser.hpp" +#include "CCF/CodeGenerationKit/CommandLineDescriptor.hpp" + +#include "CCF/CIDL/LexicalAnalyzer.hpp" +#include "CCF/CIDL/Parser.hpp" +#include "CCF/CIDL/SemanticGraph.hpp" +#include "CCF/CIDL/SemanticAction/Impl/Factory.hpp" + +#include "ExecutorMappingGenerator.hpp" +#include "ServantGenerator.hpp" +#include "ExecImplGenerator.hpp" +#include "RepositoryIdGenerator.hpp" +#include "DescriptorGenerator.hpp" +#include "SizeTypeCalculator.hpp" + +#include "ciao/Version.h" // for --version + +using std::cerr; +using std::endl; + +class ErrorDetector : public std::streambuf +{ +public: + ErrorDetector (std::ostream& os) + : error_ (false), + os_ (os), + prev_ (*os_.rdbuf ()) + { + os_.rdbuf (this); + } + + ~ErrorDetector () + { + os_.rdbuf (&prev_); + } + + virtual int_type + overflow (int_type c) + { + error_ = true; + return prev_.sputc (c); + } + + virtual int + sync () + { + return prev_.pubsync (); + } + + bool + error () const throw () + { + return error_; + } + +private: + bool error_; + std::ostream& os_; + std::streambuf& prev_; +}; + +using namespace CCF::CompilerElements; +using namespace CCF::CIDL; +using namespace CCF::CIDL::SemanticGraph; + +int +main (int argc, char* argv[]) +{ + try + { + // Parsing command line options and arguments. + // + + CL::Description cld (argv[0]); + + cld.add_option (CL::OptionDescription ( + "version", + "Display version information and exit.", + CL::OptionType::flag)); + + cld.add_option (CL::OptionDescription ( + "help", + "Display usage information and exit.", + CL::OptionType::flag)); + + cld.add_option (CL::OptionDescription ( + "help-html", + "Dump usage information in html format and exit.", + CL::OptionType::flag)); + + cld.add_option (CL::OptionDescription ( + "I", + "dir", + "Add the directory dir to the list of directories to " + "be searched for header files.", + CL::OptionType::value)); + + cld.add_option (CL::OptionDescription ( + "D", + "name[=definition]", + "Predefine name as a macro with the value definition " + "if present, 1 otherwise.", + CL::OptionType::value)); + + cld.add_option (CL::OptionDescription ( + "gen-exec-impl", + "Generate the executor implementation classes.", + CL::OptionType::flag)); + + ExecutorMappingGenerator::options (cld); + ServantGenerator::options (cld); + DescriptorGenerator::options (cld); + ExecImplGenerator::options (cld); + + cld.add_option (CL::OptionDescription ( + "trace-semantic-actions", + "Turn on semantic actions tracing facility.", + CL::OptionType::flag)); + + cld.add_option (CL::OptionDescription ( + "preprocess-only", + "Run preprocessor only and output result to stdout.", + CL::OptionType::flag)); + + cld.add_argument ("cidl file"); + + + CommandLine cl; + + if (!parse (argc, argv, cld, cl)) + { + cerr << "try " << argv[0] << " --help for usage information" << endl; + return -1; + } + + if (cl.get_value ("version", false)) + { + cerr << "CIAO CIDL Compiler " << CIAO_VERSION + << " (built on " << __DATE__ << " at " << __TIME__ << ")" << endl; + return 0; + } + + if (cl.get_value ("help", false)) + { + CL::print_text (cerr, cld); + return 0; + } + + if (cl.get_value ("help-html", false)) + { + CL::print_html (cerr, cld); + return 0; + } + + + fs::ifstream ifs; + ifs.exceptions (std::ios_base::badbit | std::ios_base::failbit); + + fs::path file_path; + + CommandLine::ArgumentsIterator i = cl.arguments_begin (); + + if (i != cl.arguments_end ()) + { + try + { + file_path = fs::path (*i, fs::native); + ifs.open (file_path, std::ios_base::in); + } + catch (fs::filesystem_error const&) + { + cerr << *i << ": error: unable to open in read mode" << endl; + return -1; + } + catch (std::ios_base::failure const&) + { + cerr << *i << ": error: unable to open in read mode" << endl; + return -1; + } + } + + //@@ for some reason ifs throws exception if I don't reset it to + // original state. It probably has something to do with call to + // get after eof. + ifs.exceptions (std::ios_base::iostate (0)); + + std::istream& is = ifs.is_open () + ? static_cast (ifs) + : static_cast (std::cin); + + InputStreamAdapter isa (is); + + + // Extract preprocessor symbol definitions (-D). We are not + // interested in the values, just symbols. + // + CPP::Symbols symbols; + + for (CommandLine::OptionsIterator + i (cl.options_begin ()), e (cl.options_end ()); i != e; ++i) + { + if (i->name () == "D") + { + std::string def (i->value ()); + + // Get rid of '=value' in 'symbol=value' definitions. + // + std::size_t p (def.find ('=')); + if (p != std::string::npos) + symbols.insert (std::string (def, 0, p)); + else + symbols.insert (def); + } + } + + CPP::Preprocessor pp (isa, symbols); + + if (cl.get_value ("preprocess-only", false)) + { + while (true) + { + CPP::Token t (pp.next ()); + + if (t == CPP::Token::eos) break; + + std::cout << t; + } + + return 0; + } + + Diagnostic::Stream dout; + ErrorDetector detector (cerr); + + LexicalAnalyzer lexer (pp); + + TokenList token_stream; + + //@@ bad token comparison + for (TokenPtr token = lexer.next ();; token = lexer.next ()) + { + // cerr << typeid(*(token.in ())).name () << " : " << token << endl; + token_stream.push_back (token); + if (ReferenceCounting::strict_cast (token) != 0) break; + } + + if (token_stream.size () < 2) + { + cerr << "no tokens produced so nothing to parse" << endl; + return 0; + } + + TranslationUnit tu (file_path, 0); + + // Initialize compilation context. + // + CCF::CompilerElements::Context context; + context.set ("file-path", file_path); + context.set ("trace-semantic-action", + cl.get_value ("trace-semantic-actions", false)); + context.set ("cpp-symbols", symbols); + + + // Extract include search paths. + // + + std::vector include_paths; + + for (CommandLine::OptionsIterator + i (cl.options_begin ()), e (cl.options_end ()); i != e; ++i) + { + std::string path; + + if (i->name () == "I") + { + path = i->value (); + + try + { + include_paths.push_back (fs::path (path, fs::native)); + } + catch (fs::filesystem_error const&) + { + cerr << "error: invalid filesystem path '" << path << "' " + << "provided with the -I option" << endl; + + return 1; + } + } + } + + context.set ("include-search-paths", include_paths); + + // Instantiate semantic actions factory. + // + SemanticAction::Impl::Factory actions (context, dout, tu); + + Parser parser (context, dout, lexer, actions); + + //@@ should be able to use CIDL here. Or better yet get rid of this + // function completely. + // + CCF::IDL2::Parsing::parse (token_stream.begin (), + token_stream.end (), + parser.start ()); + + if (dout.error_count () != 0) return 1; + + // This is a little hack to make CIDL compiler signal + // error conditions by return value. Once I redesign + // diagnostic in CCF this should be removed. + + if (detector.error ()) return 1; + + + // Generate executor mapping. + { + ExecutorMappingGenerator lem_gen; + lem_gen.generate (cl, tu, file_path); + } + + // Calculate the size type of everything in the AST. + // This must be executed before the servant code generator. + { + SizeTypeCalculator sizetype_calc; + sizetype_calc.calculate (tu); + } + + // Compute repository IDs in a separate pass. + { + RepositoryIdGenerator repid_gen; + if (!repid_gen.generate (tu)) return 1; + } + + // Generate servant code. + { + ServantGenerator svnt_gen (cl); + svnt_gen.generate (tu, file_path); + } + + // Generate executor implementation code. + if (cl.get_value ("gen-exec-impl", false)) + { + ExecImplGenerator impl_gen (cl); + impl_gen.generate (tu, file_path); + } + + // Generate descriptor code. + { + DescriptorGenerator desc_gen; + desc_gen.generate (cl, tu); + } + + return 0; + } + catch (std::bad_cast const&) + { + cerr << "bad cast exception" << endl; + } + catch (InvalidName const&) + { + cerr << "invalid name exception" << endl; + } + /* + catch (...) + { + cerr << "caught unknown exception" << endl; + } + */ + + return 1; +} -- cgit v1.2.1