be_exception::be_exception (UTL_ScopedName *n, const UTL_Pragmas &p)
:
AST_Decl (AST_Decl::NT_except, n, p),
UTL_Scope (AST_Decl::NT_except, n, p),
AST_Structure (AST_Decl::NT_except, n, p),
m_isFixedLength (TRUE),
m_elemAlignment (0),
m_elemSize (0),
m_marshalInCore (false)
{
isAtModuleScope (pbfalse);
const DDS_StdString userException = "DDS::UserException";
DDS_StdString barScopedName = NameToString(name(), "_");
localName = local_name()->get_string();
SetName(localName);
enclosingScope = be_Type::EnclosingScopeString(this);
m_tc_ctor_val = (DDS_StdString) barScopedName + "_ctor";
m_tc_dtor_val = (DDS_StdString) barScopedName + "_dtor";
m_tc_put_val = "(DDS::TypeCode::PutFunc) 0";
m_tc_get_val = "(DDS::TypeCode::GetFunc) 0";
m_tc_assign_val = (DDS_StdString) barScopedName +
"_copy";
SetScopedClassName(ScopedName());
AddParent (new be_ClassParent (userException, userException, true, false));
m_typecode->kind = DDS::tk_except;
m_typecode->id = get_decl_pragmas().get_repositoryID()->get_string();
m_typecode->name_of_type = localName;
InitializeTypeMap(this);
}
be_structure::be_structure ()
: m_canOptimize(pbfalse),
m_lastFieldSize(0),
m_interface_dependant(pbfalse)
{
isAtModuleScope(pbfalse);
}
be_attribute::be_attribute ()
:
m_getDispatchDone (FALSE),
m_setDispatchDone (FALSE)
{
isAtModuleScope (pbfalse);
}
be_sequence::be_sequence ()
:
initialized (pbfalse),
anonymous (pbtrue),
deferred (pbfalse)
{
isAtModuleScope (pbfalse);
}
be_operation::be_operation () :
returnType (0),
n_InArgs (0),
n_OutArgs (0),
n_InOutArgs (0),
n_Args (0)
{
isAtModuleScope (pbfalse);
}
be_operation::be_operation
(
AST_Type * rt,
AST_Operation::Flags fl,
UTL_ScopedName * n,
const UTL_Pragmas & p
)
:
AST_Decl (AST_Decl::NT_op, n, p),
UTL_Scope (AST_Decl::NT_op, n, p),
AST_Operation (rt, fl, n, p),
returnType (0),
n_InArgs (0),
n_OutArgs (0),
n_InOutArgs (0),
n_Args (0)
{
assert (return_type ());
isAtModuleScope (pbfalse);
if (return_type ())
{
returnType = (be_DispatchableType *) return_type ()->
narrow ((long) &be_DispatchableType::type_id);
const char * typeName = returnType->TypeName ();
if (typeName && strcmp (typeName, "DDS::Any") == 0)
{
BE_Globals::inc_any = pbtrue;
}
}
else
{
DDSError ((DDS_StdString) "unknown return type for operation " +
LocalName ());
}
enclosingScope = be_Type::EnclosingScopeString (this);
stubClassname = enclosingScope + DDSStubExtension;
opKey = NameToString (name (), "_");
}
be_enum::be_enum (UTL_ScopedName *n, const UTL_Pragmas &p)
:
AST_Decl (AST_Decl::NT_enum, n, p),
UTL_Scope (AST_Decl::NT_enum, n, p),
AST_Enum (n, p)
{
isAtModuleScope(pbfalse);
DDS_StdString barScopedName = NameToString(name(), "_");
m_swapCall = "SWAP32";
localName = local_name()->get_string();
enclosingScope = be_Type::EnclosingScopeString(this);
m_typecode->kind = DDS::tk_enum;
m_typecode->id = get_decl_pragmas().get_repositoryID()->get_string();
m_typecode->name_of_type = localName;
m_tc_put_val = (DDS_StdString) "DDS_put_" + barScopedName + "_param";
m_tc_get_val = (DDS_StdString) "DDS_get_" + barScopedName + "_param";
m_any_op_id = barScopedName;
InitializeTypeMap(this);
be_root::AddTypeThatNeedsProtoTypeCodeFinished(*this);
}
be_attribute::be_attribute
(
idl_bool ro,
AST_Type *ft,
UTL_ScopedName *n,
const UTL_Pragmas &p
)
:
AST_Decl (AST_Decl::NT_attr, n, p),
AST_Field (AST_Decl::NT_attr, ft, n, p),
AST_Attribute (ro, ft, n, p),
fieldType (0),
m_getDispatchDone (FALSE),
m_setDispatchDone (FALSE)
{
assert(field_type());
isAtModuleScope(pbfalse);
if (field_type())
{
fieldType =
(be_DispatchableType*)field_type()->narrow((long) & be_Type::type_id);
assert(fieldType);
const char * typeName = fieldType->TypeName ();
if (typeName && strcmp (typeName, "DDS::Any") == 0)
{
BE_Globals::inc_any = pbtrue;
}
}
else
{
DDSError((DDS_StdString)"unknown field type for attribute " + LocalName());
}
enclosingScope = be_Type::EnclosingScopeString(this);
setOpKey = (DDS_StdString) "_set_" + LocalName();
getOpKey = (DDS_StdString) "_get_" + LocalName();
}
be_structure::be_structure(UTL_ScopedName *n, const UTL_Pragmas &p)
:
AST_Decl (AST_Decl::NT_struct, n, p),
UTL_Scope (AST_Decl::NT_struct, n, p),
m_isFixedLength (pbtrue),
m_elemAlignment (0),
m_maxElemAlignment (1),
m_elemSize (0),
m_canOptimize (pbfalse),
m_lastFieldSize (0),
m_cppScope (g_feScopeStack.Top()),
m_cppType (g_feScopeStack.Top(), *n),
m_interface_dependant (pbfalse)
{
DDS_StdString barScopedName = NameToString(name(), "_");
isAtModuleScope(pbfalse);
localName = local_name()->get_string();
enclosingScope = be_Type::EnclosingScopeString(this);
m_tc_ctor_val = (DDS_StdString) barScopedName + "_ctor";
m_tc_dtor_val = (DDS_StdString) barScopedName + "_dtor";
m_tc_put_val = (DDS_StdString) barScopedName + "_put";
m_tc_get_val = (DDS_StdString) barScopedName + "_get";
m_tc_assign_val = (DDS_StdString) barScopedName + "_copy";
m_any_op_id = barScopedName;
m_nullArg = (DDS_StdString)"*(new " + ScopedName() + ")";
m_typecode->kind = DDS::tk_struct;
m_typecode->id = get_decl_pragmas().get_repositoryID()->get_string();
m_typecode->name_of_type = localName;
m_marshalInCore = FALSE;
InitializeTypeMap(this);
be_CppFwdDecl::Add(be_CppFwdDecl::STRUCT, this, m_cppScope);
}
be_enum::be_enum()
{
isAtModuleScope(pbfalse);
}
be_exception::be_exception ()
{
isAtModuleScope (pbfalse);
}
be_sequence::be_sequence (AST_Expression *v, AST_Type *t)
:
AST_Decl
(
AST_Decl::NT_sequence,
new UTL_ScopedName (new Identifier ("sequence", 1, 0, I_FALSE), NULL)
),
AST_Sequence(v, t),
initialized (pbfalse),
maxSize (0),
anonymous (pbtrue),
deferred (pbfalse),
isPrimitiveSeq (pbfalse),
isStringSeq (pbfalse),
isInterfaceSeq (pbfalse),
baseType (0)
{
// NOTE: BASE TYPE AND MAX SIZE ARE KNOWN
assert(base_type());
assert(max_size());
static int sequence_count = 0;
isAtModuleScope(pbfalse);
idlType = this;
if (base_type())
{
baseType = be_Type::_narrow(base_type());
baseType = baseType->idlType;
isStringSeq = baseType->IsStringType();
isInterfaceSeq = baseType->IsInterfaceType();
isValueSeq = baseType->IsValueType();
isPrimitiveSeq = (baseType->IsPrimitiveType()
&& baseType->IsFixedLength() // eliminates ANY, etc..
&& !baseType->IsEnumeratedType());
// Sequence of Typecode mem leak fix eCPP896
be_predefined_type * pdt = be_predefined_type::_narrow(base_type());
if (pdt && (pdt->pt() == AST_PredefinedType::PT_typecode))
{
isInterfaceSeq = TRUE;
}
}
else
{
UTL_Error* oops = new UTL_Error;
oops->error0(UTL_Error::EIDL_LOOKUP_ERROR);
delete oops;
}
if (baseType->IsExceptionType())
{
UTL_Error* oops = new UTL_Error;
oops->error0(UTL_Error::EIDL_ILLEGAL_USE);
delete oops;
}
maxSize = ExprToULong(max_size());
if (baseType)
{
be_Type * unaliasedBase = be_typedef::_beBase(base_type());
baseTypeName = baseType->SequenceMemberTypeName();
//
// create type id (YO maybe should be the same as the equivalence id
//
localName = (DDS_StdString)"_s_" + baseType->TypeName() + "_";
localName += BE_Globals::int_to_string(MaxSize());
ColonToBar((char *)localName);
//
// create operational type equivalence id
//
m_any_op_id = (DDS_StdString)"_s_" + unaliasedBase->any_op_id() + "_";
m_any_op_id += BE_Globals::int_to_string(MaxSize()) + "_";
m_any_op_id += BE_Globals::int_to_string(sequence_count++);
ColonToBar((char *)m_any_op_id);
}
// initialize typecode
m_typecode->kind = DDS::tk_sequence;
m_typecode->members.push_back(baseType->m_typecode);
m_typecode->bounds = MaxSize();
m_typecode->length = 0;
if (!IsBounded())
{
m_typecode->bounds = 0;
}
if (isStringSeq)
{
m_typecode->id = "SEQ_DDS::String_" + BE_Globals::ulong_to_string(m_typecode->bounds);
}
init_type (enclosingScope, localName);
}
be_root::be_root (UTL_ScopedName *n, const UTL_Pragmas &p)
: AST_Root (n, p)
{
isAtModuleScope (pbfalse);
}
be_root::be_root ()
{
isAtModuleScope (pbfalse);
}
