void base_type(exprt &expr, const namespacet &ns)
{
base_type(expr.type(), ns);
Forall_operands(it, expr)
base_type(*it, ns);
}
void be_sequence::GenerateStreamOps (be_ClientHeader& source)
{
be_predefined_type * prtype = be_predefined_type::_narrow(base_type());
//
// don't generate StreamOps for types that are already in
// the core
//
if ( /* !baseType->IsStringType() && */ // note remove this when replace strseq
!(prtype &&
( (prtype->pt() == AST_PredefinedType::PT_octet) ||
(prtype->pt() == AST_PredefinedType::PT_char) ||
(prtype->pt() == AST_PredefinedType::PT_wchar) ||
(prtype->pt() == AST_PredefinedType::PT_boolean) ) ) )
{
//
// Unbounded String sequence stream operators are defined in the
// core, as are unbounded octet sequences (PR 10175)
//
if ((!isStringSeq || IsBounded()) && (TypeName() != "octetSeq"))
{
//
// generic code
//
be_Type::GenerateStreamOps(source);
}
}
}
void be_sequence::GenerateAuxTypes (be_ClientHeader & source)
{
ostream & os = source.Stream();
be_Tab tab(source);
DDS_StdString baseName = BaseTypeName ();
DDS_StdString seqName = localName;
DDS_StdString varName = localName + "_var";
DDS_StdString outName = localName + "_out";
DDS_StdString templateBase = "DDS_DCPSSequence";
pbbool wideString = pbfalse;
if (isStringSeq)
{
AST_Type* astbt = be_typedef::_astBase (base_type ());
be_string* sbt = be_string::_narrow (astbt);
wideString = sbt->IsWide ();
}
if (isStringSeq && !IsBounded ())
{
templateBase = wideString ? "DDS_DCPSUWStrSeq" : "DDS_DCPSUStrSeq";
}
os << tab << "typedef " << templateBase << "_var < " << seqName << "> "
<< varName << ";" << nl;
os << tab << "typedef " << templateBase << "_out < " << seqName << "> "
<< outName << ";" << nl;
}
unsigned long be_sequence::isRecursive ()
{
UTL_Scope * scope = 0;
be_Type * btype = 0;
AST_Decl * adecl = (AST_Decl *)this->narrow((long) & AST_Decl::type_id);
assert(adecl);
be_Type * base = (be_Type *)base_type()->narrow((long) & be_Type::type_id);
assert(base);
unsigned long offset = 1;
for (
offset = 1;
adecl &&
(scope = adecl->defined_in()) &&
(btype = (be_Type *)scope->narrow((long) & be_Type::type_id));
++offset
)
{
adecl = (AST_Decl *)scope->narrow((long) & AST_Decl::type_id);
if (btype->TypeCodeTypeName() == base->TypeCodeTypeName())
{
break;
}
}
if (scope && btype)
{
return offset;
}
return 0;
}
int print_array(struct type_info *tinfo, long long offset, char *data)
{
int id ;
int btype;
int start, end;
int i;
char *ptr;
int len=0;
if (tinfo->type != ARRAY) return 0;
id = tinfo->id;
btype = base_type(id);
if (btype == TYPE_STRUCT || btype == TYPE_BASIC_UNION
|| btype == TYPE_ENUM)
return 0;
start = tinfo->info.atype.start_index;
end = tinfo->info.atype.end_index;
ptr = data;
my_printf("[ ");
for (i = start; i <= end ; i ++) {
len = print_id(id, offset, ptr);
if (i != end ) my_printf(" , ");
ptr += len;
}
my_printf(" ]");
if (btype == CHAR || btype == UCHAR) {
my_printf(" \"%s\"", data);
}
return 0;
}
be_typedef::be_typedef (AST_Type *bt, UTL_ScopedName *n, const UTL_Pragmas &p)
:
AST_Decl (AST_Decl::NT_typedef, n, p),
AST_Typedef (bt, n, p),
m_generateBase (FALSE),
m_generated (FALSE),
m_baseBeType (0)
{
AST_Type* astType = base_type();
be_array* ba;
be_sequence* bs;
localName = local_name()->get_string();
enclosingScope = be_Type::EnclosingScopeString(this);
m_baseBeType = get_base_be_type();
//
// make sure the base type has a name (if anonymous)
//
bs = (be_sequence*)astType->narrow((long) & be_sequence::type_id);
if (bs)
{
m_generateBase = bs->SetName(enclosingScope, localName);
}
else if ((ba = (be_array*)astType->narrow((long) & be_array::type_id)))
{
m_generateBase = ba->SetName(enclosingScope, localName);
}
//
// now initialize the base's type and typemap
//
m_baseBeType->Initialize();
m_baseBeType->HasTypeDef (pbtrue);
InitializeTypeMap (this);
m_typecode = m_baseBeType->m_typecode;
m_typecode->id = get_decl_pragmas().get_repositoryID()->get_string();
m_typecode->name_of_type = localName;
DDS_StdString scopedname = NoColons(enclosingScope + "_" + localName);
TypeCodeTypeName(BE_Globals::TCPrefix + localName);
MetaTypeTypeName(BE_Globals::MTPrefix + scopedname);
TypeCodeRepName(BE_Globals::TCRepPrefix + scopedname);
TypeCodeBaseName(BE_Globals::TCBasePrefix + scopedname);
}
void
be_typedef::Generate(be_ClientHeader& source)
{
if (BE_Globals::ignore_interfaces && IsInterfaceDependant ())
{
return;
}
if (!Generated())
{
be_Type * btype;
m_generated = TRUE;
if (base_type() &&
(btype = (be_Type*)base_type()->narrow((long) & be_Type::type_id)))
{
if (m_generateBase)
{
be_CodeGenerator * cg;
if ((cg = (be_CodeGenerator *) btype->narrow((long) & be_CodeGenerator::type_id)))
{
cg->isAtModuleScope (this->isAtModuleScope());
}
btype->GenerateType(source);
}
else
{
btype->GenerateTypedefs(enclosingScope, *this, source);
be_root::AddTypedef(*this);
be_root::AddTypecode(*this);
}
}
else
{
assert(pbfalse);
}
}
}
void be_sequence::GeneratePutGetOps (be_ClientHeader& source)
{
ostream & os = source.Stream ();
be_Tab tab (source);
be_predefined_type * prtype = be_predefined_type::_narrow (base_type ());
//
// don't generate StreamOps for types that are already in
// the core
//
if ( /* !baseType->IsStringType() && */ // note remove this when replace strseq
!(prtype &&
( (prtype->pt() == AST_PredefinedType::PT_octet) ||
(prtype->pt() == AST_PredefinedType::PT_char) ||
(prtype->pt() == AST_PredefinedType::PT_wchar) ||
(prtype->pt() == AST_PredefinedType::PT_boolean) ) ) )
{
os << tab << DLLMACRO << "void " << m_tc_put_val << nl;
os << tab << "(" << nl;
tab.indent ();
os << tab << "DDS::Codec::OutStream & os," << nl;
os << tab << "const void * arg," << nl;
os << tab << "DDS::ParameterMode mode" << nl;
if (XBE_Ev::generate ())
{
os << tab << XBE_Ev::arg (XBE_ENV_ARGN, false) << nl;
}
tab.outdent ();
os << tab << ");" << nl << nl;
os << tab << DLLMACRO << "void " << m_tc_get_val << nl;
os << tab << "(" << nl;
tab.indent ();
os << tab << "DDS::Codec::InStream & is," << nl;
os << tab << "void * arg," << nl;
os << tab << "DDS::ParameterMode mode" << nl;
if (XBE_Ev::generate ())
{
os << tab << XBE_Ev::arg (XBE_ENV_ARGN, false) << nl;
}
tab.outdent (); //2
os << tab << ");" << nl << nl;
}
}
void goto_checkt::add_guarded_claim(const exprt &_expr,
const std::string &comment, const std::string &property,
const locationt &location, const guardt &guard)
{
bool all_claims = options.get_bool_option("all-claims");
exprt expr(_expr);
// first try simplifier on it
if (!options.get_bool_option("no-simplify"))
{
expr2tc tmpexpr;
migrate_expr(expr, tmpexpr);
base_type(tmpexpr, ns);
expr = migrate_expr_back(tmpexpr);
simplify(expr);
}
if (!all_claims && expr.is_true())
return;
// add the guard
exprt guard_expr = migrate_expr_back(guard.as_expr());
exprt new_expr;
if (guard_expr.is_true())
new_expr.swap(expr);
else
{
new_expr = exprt("=>", bool_typet());
new_expr.move_to_operands(guard_expr, expr);
}
if (assertions.insert(new_expr).second)
{
goto_programt::targett t = new_code.add_instruction(ASSERT);
migrate_expr(new_expr, t->guard);
t->location = location;
t->location.comment(comment);
t->location.property(property);
}
}
explicit operator const foo_thing2_t* () const {
return base_type();
}
int print_type_info(struct type_info *tinfo, long long offset, char *data)
{
int btype;
int ret;
GElf_Sym sym;
switch(tinfo->type) {
case BASIC_TYPE :
if (tinfo->info.btype.sign) {
switch (tinfo->info.btype.size) {
case 1 : my_printf("0x%x", (char)*data); return 1;
case 2 : my_printf("0x%hx", *((short*)data)); return 2;
case 4 : my_printf("0x%lx",*((int*)data)); return 4;
case 8 : my_printf("0x%llx", *((long*)data)); return 8;
}
} else {
switch (tinfo->info.btype.size) {
case 1 : my_printf("0x%x", (unsigned char)*data); return 1;
case 2 : my_printf("0x%hx", *((unsigned short*)data)); return 2;
case 4 : my_printf("0x%lx",*((unsigned int*)data)); return 4;
case 8 : my_printf("0x%llx", *((unsigned long*)data)); return 8;
}
}
break;
case FLOAT_TYPE :
switch(tinfo->info.ftype.size) {
case 4 : my_printf(" float "); return 4;
case 8 : my_printf(" double "); return 8;
}
break;
case EQUAL :
return print_id(tinfo->id, offset, data);
case POINTER :
/* print strings for char data type else print %p */
if (sizeof(void*) == 8)
my_printf("0x%llx", *((long*)data));
else
my_printf("0x%x", *((long*)data));
btype = base_type(tinfo->id);
if (btype == CHAR || btype == UCHAR) {
if (*(long*)data == 0) return 8;
memset(str, 0, MAX_STR_LEN);
ret = mdb_readstr(str, MAX_STR_LEN, *((long*)data));
if (ret <= 0) return 8;
my_printf(" \"%s\"", str);
}
if (btype == TYPE_FUNCTION_PTR)
{
memset(str, 0, MAX_STR_LEN);
ret= mdb_lookup_by_addr(*(long*)data, MDB_SYM_EXACT, str,
MAX_STR_LEN, &sym);
if (ret != -1) my_printf(" \"%s\" ", str);
}
return 8;
case ARRAY :
return print_array(tinfo, offset, data);
case FORWARD_REF :
return print_id(tinfo->id, offset, data);
default :
my_printf("error");
}
}
static Tuple proc_init_rec(Symbol type_name, Tuple field_names,
Node variant_node, Node out_param) /*;proc_init_rec*/
{
/*
* This is a subsidiary procedure to BUILD_PROC_INIT, which performs
* the recursive part of construction of an initialization procedure
* for a record type.
*
* Input: field_names is a list of component unique names (excluding
* discriminants. Variant node is the AST for the variant part
* of a component list.
* variant_node is the variant part of the record declaration
* and has the same structure as a case statement.
*
* out_param designates the object being initialized
*
* Output: the statement list required to initialize this fragment of
* the record, or [] if not default initialization is needed.
*/
Tuple init_stmt, stmts;
Node one_component, f_init, c_node, variant_list;
Symbol f_type, f_name, ip;
Fortup ft1;
int empty_case;
Tuple case_list, comp_case_list;
Node choice_list, comp_list, disc_node;
Node invariant_node, new_case, list_node, case_node;
Tuple tup, index_list;
int nb_dim, i;
Node d_node, node, node1, node2, node3, node4, node5;
Symbol one_index_type;
/* process fixed part first. */
init_stmt = tup_new(0);
FORTUP(f_name=(Symbol), field_names, ft1);
one_component = new_selector_node(out_param, f_name);
f_type = TYPE_OF(f_name);
CONTAINS_TASK(type_name) = (char *)
((int)CONTAINS_TASK(type_name) | (int) CONTAINS_TASK(f_type));
f_init = (Node) default_expr(f_name);
if (f_init != OPT_NODE) {
init_stmt = tup_with(init_stmt,
(char *) new_assign_node(one_component,
remove_discr_ref(f_init, out_param)));
}
else if ((ip = INIT_PROC(base_type(f_type)))!=(Symbol)0) {
init_stmt = tup_with(init_stmt,
(char *) build_init_call(one_component, ip, f_type, out_param));
}
else if (is_task_type(f_type)) {
init_stmt = tup_with(init_stmt, (char *)
new_assign_node(one_component, new_create_task_node(f_type)));
}
else if (is_access_type(f_type)) {
init_stmt = tup_with(init_stmt, (char *)
new_assign_node(one_component, new_null_node(f_type)));
}
/* if we have an aray then we have to check if its bounds are
* compatible with the index subtypes (of the unconstrained array)
* (This code was generated beforehand in type.c ("need_qual_r") but
* it was wrong : we have to test the bounds only if the field is
* present (case of variant record).
* The generation of the tests is easier here
*/
if (is_array_type (f_type)) {
tup = (Tuple) SIGNATURE(TYPE_OF(f_type));
index_list = tup_copy((Tuple) tup[1]);
nb_dim = tup_size(index_list);
for (i = 1; i <= nb_dim; i++) {
one_index_type = (Symbol) (tup_fromb (index_list));
d_node = new_ivalue_node(int_const(i), symbol_integer);
node1 = new_attribute_node(ATTR_O_FIRST,
one_component, d_node, one_index_type);
node2 = new_attribute_node(ATTR_O_LAST,
one_component, d_node, one_index_type);
node3 = new_attribute_node(ATTR_T_FIRST,
new_name_node(one_index_type), OPT_NODE, one_index_type);
node4 = new_attribute_node(ATTR_T_LAST,
new_name_node(one_index_type), OPT_NODE, one_index_type);
node5 = new_binop_node(symbol_or,
new_binop_node(symbol_lt, node1, node3, symbol_boolean),
new_binop_node(symbol_gt, node2, node4, symbol_boolean),
symbol_boolean);
node = node_new (as_list);
make_if_node(node,
tup_new1((char *) new_cond_stmts_node(
new_binop_node(symbol_and,
new_binop_node(symbol_le, node1, node2, symbol_boolean),
node5, symbol_boolean),
new_raise_node(symbol_constraint_error))), OPT_NODE);
init_stmt = tup_with(init_stmt, (char *) (node));
}
}
ENDFORTUP(ft1);
/* then build case statement to parallel structure of variant part. */
empty_case = TRUE; /* assumption */
if (variant_node != OPT_NODE) {
disc_node= N_AST1(variant_node);
variant_list = N_AST2(variant_node);
case_list = tup_new(0);
comp_case_list = N_LIST(variant_list);
FORTUP(c_node=(Node), comp_case_list, ft1);
choice_list = N_AST1(c_node);
comp_list = N_AST2(c_node);
invariant_node = N_AST1(comp_list);
variant_node = N_AST2(comp_list);
field_names = build_comp_names(invariant_node);
stmts = proc_init_rec(type_name,field_names,variant_node, out_param);
/*empty_case and= stmts = [];*/
empty_case = empty_case ? (tup_size(stmts)==0) : FALSE;
new_case = (N_KIND(c_node) == as_others_choice) ?
new_node(as_others_choice) : new_node(as_variant_choices);
N_AST1(new_case) = copy_tree(choice_list);
N_AST2(new_case) = new_statements_node(stmts);
case_list = tup_with(case_list, (char *) new_case );
ENDFORTUP(ft1);
if (! empty_case) {
/* Build a case statement ruled by the value of the discriminant */
/* for this variant part. */
list_node = new_node(as_list);
N_LIST(list_node) = case_list;
case_node = new_node(as_case);
N_AST1(case_node) = new_selector_node(out_param, N_UNQ(disc_node));
N_AST2(case_node) = list_node;
init_stmt = tup_with(init_stmt, (char *) case_node );
}
}
return init_stmt;
}
void be_sequence::generate_tc_get_val (be_Source & source)
{
be_predefined_type * prtype = be_predefined_type::_narrow (base_type ());
ostream & os = source.Stream ();
be_Tab tab (source);
// declare reader body
os << tab << "void " << m_tc_get_val << nl;
os << tab << "(" << nl;
tab.indent ();
os << tab << "DDS::Codec::InStream & is," << nl;
os << tab << "void * arg," << nl;
os << tab << "DDS::ParameterMode mode" << nl;
if (XBE_Ev::generate ())
{
os << tab << XBE_Ev::arg (XBE_ENV_ARGN, false) << nl;
}
tab.outdent ();
os << tab << ")" << nl;
os << tab << "{" << nl;
tab.indent ();
/* Sequences of 1/2/4 byte types handled as special cases */
if
(
prtype &&
! IsBounded () &&
(
(prtype->pt () == AST_PredefinedType::PT_octet) ||
(prtype->pt () == AST_PredefinedType::PT_char) ||
(prtype->pt () == AST_PredefinedType::PT_long) ||
(prtype->pt () == AST_PredefinedType::PT_ulong) ||
(prtype->pt () == AST_PredefinedType::PT_float) ||
(prtype->pt () == AST_PredefinedType::PT_short) ||
(prtype->pt () == AST_PredefinedType::PT_ushort)
)
)
{
os << tab << "DDS::Codec::Param p = {";
if
(
(prtype->pt () == AST_PredefinedType::PT_octet) ||
(prtype->pt () == AST_PredefinedType::PT_char)
)
{
os << "DDS::_tc_sequence";
}
else if
(
(prtype->pt () == AST_PredefinedType::PT_short) ||
(prtype->pt () == AST_PredefinedType::PT_ushort)
)
{
os << "DDS::_tc_sequence2";
}
else
{
os << "DDS::_tc_sequence4";
}
os << ", arg, mode };" << nl
<< tab << "is.get (&p, 1"
<< XBE_Ev::arg (XBE_ENV_VARN) << ");" << nl;
}
else
{
os << tab << ScopedName () << " * p = ("
<< ScopedName () << "*) arg;" << nl;
getter (os, tab, "p", 0);
}
tab.outdent ();
os << tab << "}" << nl << nl;
}
void be_sequence::generate_tc_put_val (be_Source & source)
{
be_predefined_type * prtype = be_predefined_type::_narrow (base_type ());
ostream & os = source.Stream ();
be_Tab tab (source);
// declare writer body
os << tab << "void " << m_tc_put_val << nl;
os << tab << "(" << nl;
tab.indent ();
os << tab << "DDS::Codec::OutStream & os," << nl;
os << tab << "const void * arg," << nl;
os << tab << "DDS::ParameterMode mode" << nl;
if (XBE_Ev::generate ())
{
os << tab << XBE_Ev::arg (XBE_ENV_ARGN, false) << nl;
}
tab.outdent ();
os << tab << ")" << nl;
os << tab << "{" << nl;
tab.indent ();
/* Sequences of 1/2/4 byte types handled as special cases */
if
(
prtype &&
! IsBounded () &&
(
(prtype->pt () == AST_PredefinedType::PT_octet) ||
(prtype->pt () == AST_PredefinedType::PT_char) ||
(prtype->pt () == AST_PredefinedType::PT_long) ||
(prtype->pt () == AST_PredefinedType::PT_ulong) ||
(prtype->pt () == AST_PredefinedType::PT_float) ||
(prtype->pt () == AST_PredefinedType::PT_short) ||
(prtype->pt () == AST_PredefinedType::PT_ushort)
)
)
{
os << tab << "DDS::Codec::Param p = { ";
if
(
(prtype->pt () == AST_PredefinedType::PT_octet) ||
(prtype->pt () == AST_PredefinedType::PT_char)
)
{
os << "DDS::_tc_sequence";
}
else if
(
(prtype->pt () == AST_PredefinedType::PT_short) ||
(prtype->pt () == AST_PredefinedType::PT_ushort)
)
{
os << "DDS::_tc_sequence2";
}
else
{
os << "DDS::_tc_sequence4";
}
os << ", (void*) arg, mode };" << nl
<< tab << "os.put (&p, 1"
<< XBE_Ev::arg (XBE_ENV_VARN) << ");" << nl;
}
else
{
// since the put param must be a sequence pointer pointer,
// that's what the writer takes. The putter, however,
os << tab << ScopedName () << " * p = ("
<< ScopedName () << "*) arg;" << nl;
// now put the data
putter (os, tab, "p", 0);
}
tab.outdent ();
os << tab << "}" << nl << nl;
}
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);
}
void CodeTypeInference::on_visit(CodeAssemblyCallExpression *object) {
auto res = new CodeTypeReference();
res->base_type("Void");
res->scope(object->scope());
this->m_result = res;
}
void CodeTypeInference::on_visit(CodeIrBlockStatement *object) {
auto res = new CodeTypeReference();
res->base_type("Void");
res->scope(object->scope());
this->m_result = res;
}
void be_sequence::GenerateSequence (be_ClientImplementation & source)
{
ostream & os = source.Stream ();
be_Tab tab (source);
DDS_StdString elemName;
elemName = baseType->ScopedName();
DDS_StdString FileClassname;
DDS_StdString charFileClassname;
DDS_StdString boolFileClassname;
FileClassname = elemName;
charFileClassname = DDS_StdString("DDSChar");
boolFileClassname = DDS_StdString("DDSBoolean");
os << "#if DDS_USE_EXPLICIT_TEMPLATES" << nl;
if (IsBounded())
{
// Bounded sequence types
if (baseType->IsFixedLength())
{
be_predefined_type * pdt = be_predefined_type::_narrow(base_type());
os << tab << "template class DDS_DCPSBFLSeq < " << elemName
<< ", " << FileClassname << ", " << maxSize << ">;" << nl;
}
else if (isInterfaceSeq)
{
os << tab << "template class DDS_DCPSBObjSeq < " << elemName << ", struct "
<< localName << "_uniq_, " << maxSize << ">;" << nl;
}
else if (isValueSeq)
{
os << tab << "template class DDS_DCPSBValSeq < " << elemName
<< ", " << maxSize << ">;" << nl;
}
else
{
os << tab << "template class DDS_DCPSBVLSeq < " << elemName
<< ", " << maxSize << ">;" << nl;
}
}
else
{
// Unbounded sequence types
if (baseType->IsFixedLength ())
{
os << tab << "template class DDS_DCPSUFLSeq < " << elemName
<< ", struct " << localName << "_uniq_>;" << nl;
}
else if (isInterfaceSeq)
{
os << tab << "template class DDS_DCPSUObjSeq < " << elemName
<< ", struct " << localName << "_uniq_>;" << nl;
}
else if (isValueSeq)
{
os << tab << "template class DDS_DCPSUValSeq < " << elemName
<< ">;" << nl;
}
else
{
os << tab << "template class DDS_DCPSUVLSeq < " << elemName << ", struct "
<< localName << "_uniq_>;" << nl;
}
}
os << "#endif" << nl;
}
void be_sequence::GenerateSequence (be_ClientHeader & source)
{
ostream & os = source.Stream ();
be_Tab tab (source);
DDS_StdString elemName;
pbbool wideString = pbfalse;
if (isInterfaceSeq || isValueSeq)
{
elemName = BE_Globals::RelativeScope(enclosingScope, baseType->ScopedName());
}
else
{
elemName = BE_Globals::RelativeScope(enclosingScope, baseTypeName);
if (isStringSeq)
{
AST_Type* astbt = be_typedef::_astBase(base_type());
be_string* sbt = be_string::_narrow(astbt);
wideString = sbt->IsWide();
}
}
DDS_StdString FileClassname;
DDS_StdString charFileClassname;
DDS_StdString boolFileClassname;
FileClassname = elemName;
charFileClassname = DDS_StdString("DDSChar");
boolFileClassname = DDS_StdString("DDSBoolean");
os << tab << "struct " << localName << "_uniq_ {};" << nl;
if (IsBounded())
{
// Bounded sequence types
if (baseType->IsFixedLength())
{
be_predefined_type * pdt = be_predefined_type::_narrow(base_type());
os << tab << "typedef DDS_DCPSBFLSeq < " << elemName
<< ", " << FileClassname << ", " << maxSize << "> " << localName << ";" << nl;
}
else if (isStringSeq)
{
if (wideString)
{
os << tab << "typedef DDS_DCPSBWStrSeq < " << maxSize << "> "
<< localName << ";" << nl;
}
else
{
os << tab << "typedef DDS_DCPSBStrSeq < " << maxSize << "> "
<< localName << ";" << nl;
}
}
else if (isInterfaceSeq)
{
os << tab << "typedef DDS_DCPSBObjSeq < " << elemName << ", struct "
<< localName << "_uniq_, " << maxSize << "> " << localName << ";"
<< nl;
}
else if (isValueSeq)
{
os << tab << "typedef DDS_DCPSBValSeq < " << elemName
<< ", " << maxSize << "> " << localName << ";" << nl;
}
else
{
os << tab << "typedef DDS_DCPSBVLSeq < " << elemName
<< ", " << maxSize << "> " << localName << ";" << nl;
}
}
else
{
// Unbounded sequence types
if (baseType->IsFixedLength ())
{
os << tab << "typedef DDS_DCPSUFLSeq < " << elemName << ", struct "
<< localName << "_uniq_> " << localName << ";" << nl;
}
else if (isStringSeq)
{
if (wideString)
{
os << tab << "typedef DDS_DCPSUWStrSeqT <struct " << localName
<< "_uniq_> " << localName << ";" << nl;
}
else
{
os << tab << "typedef DDS_DCPSUStrSeqT <struct " << localName
<< "_uniq_> " << localName << ";" << nl;
}
}
else if (isInterfaceSeq)
{
os << tab << "typedef DDS_DCPSUObjSeq < " << elemName << ", struct "
<< localName << "_uniq_> " << localName << ";" << nl;
}
else if (isValueSeq)
{
os << tab << "typedef DDS_DCPSUValSeq < " << elemName
<< "> " << localName << ";" << nl;
}
else
{
os << tab << "typedef DDS_DCPSUVLSeq < " << elemName << ", struct "
<< localName << "_uniq_> " << localName << ";" << nl;
}
}
}
Node build_proc_init_ara(Symbol type_name) /*;build_proc_init_ara*/
{
/*
* This is the main procedure for building default initialization
* procedures for array types. Those initialization procedures are
* built if the type given contains some subcomponent for which a
* default initialization exists (at any level of nesting), or if it
* has determinants.
* Note that scalar objects are not initialized at all, which implies
* that they get whatever initial value is in that location in memory
* This saves some time in object creation.
*
* All init. procedures have an 'out' parameter that designates the
* object being initialized (the space has already been allocated).
*
*/
int side_effect;
Tuple tup, formals, subscripts;
Symbol c_type, ip, index_t, proc_name, index_sym;
Node one_component, init_stmt, out_param, i_nodes, d_node, iter_node;
Fortup ft1;
Node iterator, index_node;
#ifdef TRACE
if (debug_flag) {
gen_trace_symbol("BUILD_PROC_INIT_ARR", type_name);
}
#endif
side_effect = FALSE; /* Let's hope... TBSL */
tup = SIGNATURE(type_name);
c_type = (Symbol) tup[2];
one_component = new_node(as_index);
ip = INIT_PROC(base_type(c_type));
if (ip != (Symbol)0 ){
/* Use the initialization procedure for the component type */
init_stmt = (Node) build_init_call(one_component, ip, c_type, OPT_NODE);
}
else if (is_task_type(c_type)) {
/* initialization is task creation. */
init_stmt =
new_assign_node(one_component, new_create_task_node(c_type));
}
else if (is_access_type(c_type)) {
/* default value is the null pointer. */
init_stmt = new_assign_node(one_component, new_null_node(c_type));
}
else {
init_stmt = (Node) 0;
}
if (init_stmt != (Node)0) {
/* body of initialization procedure is a loop over the indices */
/* allocating each component. Generate loop variables and code */
/* for iteration, using the attributes of the type. */
proc_name = new_unique_name("type_name+INIT");
out_param = new_param_node("param_type_name", proc_name,
type_name, na_out);
generate_object(N_UNQ(out_param));
formals = tup_new1((char *) out_param);
subscripts = tup_new(0);
FORTUP(index_t=(Symbol), index_types(type_name), ft1);
/*index = index_t + 'INDEX';*/
index_sym = new_unique_name("index_t+INDEX");
NATURE (index_sym) = na_obj;
TYPE_OF(index_sym) = index_t;
subscripts = tup_with(subscripts, (char *)new_name_node(index_sym));
ENDFORTUP(ft1);
i_nodes = new_node(as_list);
/* need tup_copy since subscripts used destructively below */
N_LIST(i_nodes) = tup_copy(subscripts);
/* Build the tree for the one_component of the array. */
N_AST1(one_component) = out_param;
N_AST2(one_component) = i_nodes;
N_TYPE(one_component) = c_type;
while (tup_size(subscripts)) {
/* Build loop from innermost index outwards. The iterations */
/* span the ranges of the array being initialized. */
/* dimension spanned by this loop: */
d_node = new_ivalue_node(int_const(tup_size(subscripts)),
symbol_integer);
iterator = new_attribute_node(ATTR_O_RANGE,
new_name_node(N_UNQ(out_param)), d_node, type_name);
index_node = (Node) tup_frome(subscripts);
iter_node = new_node(as_for);
N_AST1(iter_node) = index_node;
N_AST2(iter_node) = iterator;
init_stmt = new_loop_node(OPT_NODE, iter_node,
tup_new1((char *)init_stmt));
}
INIT_PROC(type_name) = proc_name;
return initialization_proc(proc_name, type_name,
formals, tup_new1((char *) init_stmt));
}
else {
return OPT_NODE;
}
}
void CodeTypeInference::on_visit(CodeSizeOfExpression *object) {
auto res = new CodeTypeReference();
res->base_type("UInt64");
res->scope(object->scope());
this->m_result = res;
}
bool base_type_eqt::base_type_eq_rec(
const typet &type1,
const typet &type2)
{
if(type1==type2)
return true;
#if 0
std::cout << "T1: " << type1.pretty() << std::endl;
std::cout << "T2: " << type2.pretty() << std::endl;
#endif
// loop avoidance
if((type1.id()==ID_symbol ||
type1.id()==ID_c_enum_tag ||
type1.id()==ID_struct_tag ||
type1.id()==ID_union_tag) &&
type2.id()==type1.id())
{
// already in same set?
if(identifiers.make_union(
type1.get(ID_identifier),
type2.get(ID_identifier)))
return true;
}
if(type1.id()==ID_symbol ||
type1.id()==ID_c_enum_tag ||
type1.id()==ID_struct_tag ||
type1.id()==ID_union_tag)
{
const symbolt &symbol=
ns.lookup(type1.get(ID_identifier));
if(!symbol.is_type)
return false;
return base_type_eq_rec(symbol.type, type2);
}
if(type2.id()==ID_symbol ||
type2.id()==ID_c_enum_tag ||
type2.id()==ID_struct_tag ||
type2.id()==ID_union_tag)
{
const symbolt &symbol=
ns.lookup(type2.get(ID_identifier));
if(!symbol.is_type)
return false;
return base_type_eq_rec(type1, symbol.type);
}
if(type1.id()!=type2.id())
return false;
if(type1.id()==ID_struct ||
type1.id()==ID_union)
{
const struct_union_typet::componentst &components1=
to_struct_union_type(type1).components();
const struct_union_typet::componentst &components2=
to_struct_union_type(type2).components();
if(components1.size()!=components2.size())
return false;
for(unsigned i=0; i<components1.size(); i++)
{
const typet &subtype1=components1[i].type();
const typet &subtype2=components2[i].type();
if(!base_type_eq_rec(subtype1, subtype2)) return false;
if(components1[i].get_name()!=components2[i].get_name()) return false;
}
return true;
}
else if(type1.id()==ID_incomplete_struct)
{
return true;
}
else if(type1.id()==ID_incomplete_union)
{
return true;
}
else if(type1.id()==ID_code)
{
const code_typet::parameterst ¶meters1=
to_code_type(type1).parameters();
const code_typet::parameterst ¶meters2=
to_code_type(type2).parameters();
if(parameters1.size()!=parameters2.size())
return false;
for(unsigned i=0; i<parameters1.size(); i++)
{
const typet &subtype1=parameters1[i].type();
const typet &subtype2=parameters2[i].type();
if(!base_type_eq_rec(subtype1, subtype2)) return false;
}
const typet &return_type1=to_code_type(type1).return_type();
const typet &return_type2=to_code_type(type2).return_type();
if(!base_type_eq_rec(return_type1, return_type2))
return false;
return true;
}
else if(type1.id()==ID_pointer)
{
return base_type_eq_rec(
to_pointer_type(type1).subtype(), to_pointer_type(type2).subtype());
}
else if(type1.id()==ID_array)
{
if(!base_type_eq_rec(
to_array_type(type1).subtype(), to_array_type(type2).subtype()))
return false;
if(to_array_type(type1).size()!=to_array_type(type2).size())
return false;
return true;
}
else if(type1.id()==ID_incomplete_array)
{
return base_type_eq_rec(
to_incomplete_array_type(type1).subtype(),
to_incomplete_array_type(type2).subtype());
}
// the below will go away
typet tmp1(type1), tmp2(type2);
base_type(tmp1, ns);
base_type(tmp2, ns);
return tmp1==tmp2;
}
explicit operator foo_thing2_t* () {
return base_type();
}
xmscalar<scalar_type> angle() const {
return 2.0f * acos(base_type(detail::splat<3>(this->v)));
}
void print() const {
foo_thing2_print(base_type());
}
opt_traits(): Option(base_type()) {}
