CORBA::Boolean TIDorb::core::typecode::StructTypeCode::equal(CORBA::TypeCode_ptr tc) const
{
if (!ComplexTypeCode::equal(tc))
return false;
if (!m_exhaustive_equal)
return true;
try {
CORBA::ULong length = m_members->length();
if (length != tc->member_count())
return false;
for (CORBA::ULong i = 0; i < length; i++) {
if (strcmp(member_name(i), tc->member_name(i)))
return false;
if (! member_type(i)->equal(tc->member_type(i)))
return false;
}
// allright
return true;
} catch (const CORBA::TypeCode::BadKind& bk) {
return false;
} catch (const CORBA::TypeCode::Bounds& bn) {
return false;
}
}
member_type member_type::parse(const std::wstring & Str)
{
std::wstring tmp = Str;
boost::algorithm::to_lower(tmp);
if (tmp == L"named")
return member_type( named );
else if (tmp == L"next")
return member_type( next );
else if (tmp == L"previous")
return member_type( previous );
else
{
return member_type( named );
}
}
/* Infer the type of an expression. A result of no_type means we can't say,
either because of a type error, or because we don't have enough information,
e.g. due to involvement of foreign types, functions, or variables. */
Type *type_of(Node *e)
{
Type *t, *l, *r;
switch (e->tag) {
case E_BINOP: /* binary operator [left,right] */
l = type_of(e->binop_left);
r = type_of(e->binop_right);
switch (e->token.symbol) {
case TOK_SUB:
case TOK_ADD:
if (l->tag == T_POINTER) {
return l;
} else {
/* TODO: what if it's a foreign pointer? */
return num_type;
}
case TOK_ASTERISK:
case TOK_SLASH:
return num_type;
case TOK_GT:
case TOK_GE:
case TOK_EQ:
case TOK_NE:
case TOK_LE:
case TOK_LT:
return num_type;
case TOK_OROR:
case TOK_ANDAND:
return num_type;
case TOK_LSHIFT:
case TOK_RSHIFT:
return num_type;
case TOK_VBAR:
case TOK_CARET:
case TOK_AMPERSAND:
case TOK_MOD:
return num_type;
case TOK_EQUAL:
case TOK_ADDEQ:
case TOK_SUBEQ:
case TOK_ANDEQ:
case TOK_OREQ:
case TOK_DIVEQ:
case TOK_MULEQ:
case TOK_MODEQ:
case TOK_LSHEQ:
case TOK_RSHEQ:
case TOK_XOREQ:
return r;
case TOK_COMMA:
return r;
}
case E_BUILTIN: /* builtin function [] */
/* TODO: create built-in functions with their real type */
return num_type;
case E_CAST: /* type cast [type,operand] */
return e->cast_type->extra.e_decl->type;
case E_CONST: /* numeric (inkl. character) constant [] */
return num_type;
case E_FUNC: /* function call [node,args] */
t = type_of(e->func_expr);
if (t->tag == T_FUNCTION) {
return t->val.function.return_type;
} else {
return no_type;
}
case E_INIT: /* array or struct initializer [elems] */
assert(impossible);
return no_type;
case E_MEMBER: /* struct or union member [] */
/* because we handle this one in E_SELECT */
assert(impossible);
return no_type;
case E_PAREN: /* parenthesis around an expression [node] */
return type_of(e->paren_expr);
case E_POST: /* unary postfix operator [operand] */
return type_of(e->post_operand);
case E_PRE: /* unary prefix operator [operand] */
t = type_of(e->pre_operand);
switch (e->token.symbol) {
case TOK_ADD:
case TOK_SUB:
return t;
case TOK_ASTERISK:
if (t->tag == T_POINTER) {
return t->val.pointer.value_type;
} else if (t->tag == T_ARRAY) {
return t->val.array.elem_type;
} else if (t->tag == T_PRIM && t->val.prim == P_STRING) {
return num_type;
} else {
return no_type;
}
case TOK_AMPERSAND:
return new_pointer_type(t);
case TOK_NOT:
case TOK_TILDE:
return num_type;
case TOK_INCR:
case TOK_DECR:
return t;
case TOK_SIZEOF:
return num_type;
}
case E_SELECT: /* member selection [left,right] */
t = type_of(e->select_left);
switch (e->token.symbol) {
case TOK_POINTER:
#ifdef DEBUG
report("type_of(): op='->'\n");
#endif
if (t->tag == T_POINTER)
t = t->val.pointer.value_type;
else
return no_type;
case TOK_PERIOD:
#ifdef DEBUG
report("type_of(): op='.', t->tag=%s\n", type_tag_names[t->tag]);
#endif
if (t->tag == T_STRUCT)
return member_type(t->val.structure.member_decls, e->select_right->token.str);
else
return no_type;
default:
assert(impossible);
return no_type;
}
case E_STRING: /* string constant [] */
return str_type; /* just a first approximation, of course */
case E_SUBSCR: /* subscripted node [operand,index] */
t = type_of(e->subscr_operand);
switch (t->tag) {
case T_ARRAY:
return t->val.array.elem_type;
case T_POINTER:
return t->val.pointer.value_type;
default:
return type_error_at(e->subscr_operand);
}
case E_TERNOP: /* ternary operator [cond,then,else] */
return type_of(e->ternop_then);
case E_VAR: /* variable [] */
return e->extra.e_decl->type;
default:
assert(impossible);
return no_type;
}
}
void self_statement_Update(Update *v2548,OID v1741,OID v332)
{ GC_BIND;
{ OID v1712 = GC_OID(v2548->var);
OID v1736 = GC_OID(v2548->selector);
ClaireType * v4806;
{ if (INHERIT(OWNER(v1712),Language._Call_slot))
v4806 = domain_I_restriction(OBJECT(Call_slot,v1712)->selector);
else if (INHERIT(OWNER(v1712),Language._Call_array))
v4806 = Kernel._integer;
else v4806 = U_type(Kernel._any,GC_OBJECT(ClaireType,OBJECT(ClaireType,(*Kernel.domain)(v1736))));
GC_OBJECT(ClaireType,v4806);}
ClaireType * v4807;
{ if (INHERIT(OWNER(v1712),Language._Call_slot))
{ v4807 = ((v2548->arg == _oid_(Kernel.add)) ?
member_type(OBJECT(Call_slot,v1712)->selector->range) :
OBJECT(Call_slot,v1712)->selector->range );
}
else if (INHERIT(OWNER(v1712),Language._Call_array))
{ v4807 = (((OBJECT(ClaireBoolean,(*Core._inf_equalt)(GC_OID(OBJECT(Call_array,v1712)->test),
_oid_(Kernel._float)))) == CTRUE) ?
Kernel._float :
Kernel._any );
}
else v4807 = U_type(Kernel._any,GC_OBJECT(ClaireType,((v2548->arg == _oid_(Kernel.add)) ?
member_type(GC_OBJECT(ClaireType,OBJECT(ClaireType,(*Kernel.range)(v1736)))) :
OBJECT(ClaireType,(*Kernel.range)(v1736)) )));
GC_OBJECT(ClaireType,v4807);}
ClaireClass * v3625 = stupid_t_any1(GC_OID((*Kernel.arg)(v2548->var)));
ClaireClass * v3626 = stupid_t_any1(GC_OID(v2548->value));
OID v1721;
{ if ((_inf_equalt_class(v3625,psort_any(_oid_(v4806))) != CTRUE) &&
(_inf_equalt_class(v3625,Kernel._object) == CTRUE))
{ Compile_C_cast * v2072 = ((Compile_C_cast *) GC_OBJECT(Compile_C_cast,new_object_class(Optimize._C_cast)));
(v2072->arg = (*Kernel.arg)(GC_OID(v2548->var)));
(v2072->set_arg = psort_any(_oid_(v4806)));
add_I_property(Kernel.instances,Optimize._C_cast,11,_oid_(v2072));
v1721 = _oid_(v2072);
}
else v1721 = (*Kernel.arg)(GC_OID(v2548->var));
GC_OID(v1721);}
OID v4372;
{ if ((_inf_equalt_class(v3626,psort_any(_oid_(v4807))) != CTRUE) &&
(_inf_equalt_class(v3626,Kernel._object) == CTRUE))
{ Compile_C_cast * v2072 = ((Compile_C_cast *) GC_OBJECT(Compile_C_cast,new_object_class(Optimize._C_cast)));
(v2072->arg = v2548->value);
(v2072->set_arg = psort_any(_oid_(v4807)));
add_I_property(Kernel.instances,Optimize._C_cast,11,_oid_(v2072));
v4372 = _oid_(v2072);
}
else v4372 = v2548->value;
GC_OID(v4372);}
Variable * v105 = GC_OBJECT(Variable,Variable_I_symbol(gensym_void(),0,v4806));
Variable * v106 = GC_OBJECT(Variable,Variable_I_symbol(gensym_void(),0,v4807));
ClaireBoolean * v4279 = c_func_any(v1721);
new_block_void();
interface_I_class(psort_any(_oid_(v4806)));
princ_string(copy_string(" "));
expression_Variable(v105,_oid_(Kernel.emptySet));
princ_string(copy_string(" "));
if (v4279 == CTRUE)
{ princ_string(copy_string("= "));
(*Generate.expression)(v1721,
_oid_(Kernel.emptySet));
princ_string(copy_string(""));
}
princ_string(copy_string("; "));
breakline_void();
interface_I_class(psort_any(_oid_(v4807)));
princ_string(copy_string(" "));
expression_Variable(v106,_oid_(Kernel.emptySet));
princ_string(copy_string(";"));
breakline_void();
if (v4279 != CTRUE)
statement_any(v1721,GC_OID((*Generate.c_string)(Generate.PRODUCER->value,
_oid_(v105))),v332);
statement_any(v4372,GC_OID((*Generate.c_string)(Generate.PRODUCER->value,
_oid_(v106))),v332);
if (Kernel._string == OWNER(v1741))
{ c_princ_string(string_v(v1741));
princ_string(copy_string(" = "));
}
{ Update * v2367;
{ Update * v2072 = ((Update *) GC_OBJECT(Update,new_object_class(Language._Update)));
(v2072->selector = v1736);
{ Update * v6754 = v2072;
OID v6755;
if (v2548->arg == _oid_(Kernel.add))
v6755 = _oid_(Kernel.add);
else if (sort_Variable(v105) == Kernel._any)
v6755 = _oid_(v105);
else { Compile_to_CL * v2072 = ((Compile_to_CL *) GC_OBJECT(Compile_to_CL,new_object_class(Optimize._to_CL)));
(v2072->arg = _oid_(v105));
(v2072->set_arg = sort_Variable(v105));
add_I_property(Kernel.instances,Optimize._to_CL,11,_oid_(v2072));
v6755 = _oid_(v2072);
}
(v6754->arg = v6755);}
(v2072->value = _oid_(v106));
{ Update * v6758 = v2072;
OID v6759;
{ OID v5032 = GC_OID((*Kernel.copy)(v1712));
put_property2(Kernel.arg,OBJECT(ClaireObject,v5032),_oid_(v105));
v6759 = v5032;
}
(v6758->var = v6759);}
add_I_property(Kernel.instances,Language._Update,11,_oid_(v2072));
v2367 = v2072;
}
expression_Update(v2367,v332);
}
princ_string(copy_string(";"));
close_block_void();
}
GC_UNBIND;}
