std::string idl_mapping_java::type(AST_Type *decl)
{
switch (decl->node_type()) {
case AST_Decl::NT_pre_defined: {
AST_PredefinedType *p = AST_PredefinedType::narrow_from_decl(decl);
switch (p->pt()) {
case AST_PredefinedType::PT_boolean:
return "boolean";
case AST_PredefinedType::PT_char:
case AST_PredefinedType::PT_wchar:
return "char";
case AST_PredefinedType::PT_octet:
return "byte";
case AST_PredefinedType::PT_short:
case AST_PredefinedType::PT_ushort:
return "short";
case AST_PredefinedType::PT_long:
case AST_PredefinedType::PT_ulong:
return "int";
case AST_PredefinedType::PT_longlong:
case AST_PredefinedType::PT_ulonglong:
return "long";
case AST_PredefinedType::PT_float:
return "float";
case AST_PredefinedType::PT_double:
return "double";
default: ;//fall through
}
}
case AST_Decl::NT_string:
return "String";
case AST_Decl::NT_enum:
case AST_Decl::NT_interface:
case AST_Decl::NT_interface_fwd:
case AST_Decl::NT_native:
case AST_Decl::NT_union:
case AST_Decl::NT_struct:
case AST_Decl::NT_struct_fwd:
return scoped(decl->name());
case AST_Decl::NT_typedef: {
AST_Typedef *td = AST_Typedef::narrow_from_decl(decl);
return type(td->primitive_base_type());
}
case AST_Decl::NT_sequence: {
AST_Sequence *seq = AST_Sequence::narrow_from_decl(decl);
return type(seq->base_type()) + "[]";
}
case AST_Decl::NT_array: {
AST_Array *arr = AST_Array::narrow_from_decl(decl);
return type(arr->base_type()) + "[]";
}
default: ;//fall through
}
cerr << "ERROR - unknown Java type " << decl->node_type()
<< " for IDL type: "
<< decl->local_name()->get_string() << endl;
return "**unknown**";
}
bool
metaclass_generator::gen_typedef(AST_Typedef*, UTL_ScopedName* name, AST_Type* type, const char*)
{
AST_Array* arr = AST_Array::narrow_from_decl(type);
AST_Sequence* seq = 0;
if (!arr && !(seq = AST_Sequence::narrow_from_decl(type))) {
return true;
}
const Classification cls = classify(type);
const std::string clazz = scoped(name);
ContentSubscriptionGuard csg;
NamespaceGuard ng;
Function f("gen_skip_over", "bool");
f.addArg("ser", "Serializer&");
f.addArg("", clazz + ((cls & CL_ARRAY) ? "_forany*" : "*"));
f.endArgs();
std::string len;
AST_Type* elem;
if (arr) {
elem = arr->base_type();
size_t n_elems = 1;
for (size_t i = 0; i < arr->n_dims(); ++i) {
n_elems *= arr->dims()[i]->ev()->u.ulval;
}
std::ostringstream strstream;
strstream << n_elems;
len = strstream.str();
} else { // Sequence
elem = seq->base_type();
be_global->impl_ <<
" ACE_CDR::ULong length;\n"
" if (!(ser >> length)) return false;\n";
len = "length";
}
const std::string cxx_elem = scoped(elem->name());
elem = resolveActualType(elem);
const Classification elem_cls = classify(elem);
if ((elem_cls & (CL_PRIMITIVE | CL_ENUM)) && !(elem_cls & CL_WIDE)) {
// fixed-length sequence/array element -> skip all elements at once
int sz = 1;
to_cxx_type(elem, sz);
be_global->impl_ <<
" return ser.skip(" << len << ", " << sz << ");\n";
} else {
be_global->impl_ <<
" for (ACE_CDR::ULong i = 0; i < " << len << "; ++i) {\n";
if ((elem_cls & CL_PRIMITIVE) && (elem_cls & CL_WIDE)) {
be_global->impl_ <<
" ACE_CDR::Octet o;\n"
" if (!(ser >> ACE_InputCDR::to_octet(o))) return false;\n"
" if (!ser.skip(o)) return false;\n";
} else if (elem_cls & CL_STRING) {
be_global->impl_ <<
" ACE_CDR::ULong strlength;\n"
" if (!(ser >> strlength)) return false;\n"
" if (!ser.skip(strlength)) return false;\n";
} else if (elem_cls & (CL_ARRAY | CL_SEQUENCE | CL_STRUCTURE)) {
be_global->impl_ <<
" if (!gen_skip_over(ser, static_cast<" << cxx_elem <<
((elem_cls & CL_ARRAY) ? "_forany" : "") << "*>(0))) return false;\n";
}
be_global->impl_ <<
" }\n";
be_global->impl_ <<
" return true;\n";
}
return true;
}
int
ast_visitor_reifying::visit_array (AST_Array *node)
{
AST_Type *bt = node->base_type ();
if (bt->ast_accept (this) != 0)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ast_visitor_reifying::")
ACE_TEXT ("visit_array - ")
ACE_TEXT ("visit of base type failed\n")),
-1);
}
bt = AST_Type::narrow_from_decl (this->reified_node_);
AST_Expression **dims = node->dims ();
AST_Expression *v = 0;
UTL_ExprList *v_list = 0;
for (ACE_CDR::ULong i = 0; i < node->n_dims (); ++i)
{
AST_Param_Holder *ph = dims[i]->param_holder ();
if (ph != 0)
{
if (this->visit_param_holder (ph) != 0)
{
if (v_list != 0)
{
v_list->destroy ();
delete v_list;
v_list = 0;
}
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("ast_visitor_reifying::")
ACE_TEXT ("visit_array - ")
ACE_TEXT ("visit_param_holder() ")
ACE_TEXT ("failed\n")),
-1);
}
AST_Constant *c =
AST_Constant::narrow_from_decl (this->reified_node_);
ACE_NEW_RETURN (v,
AST_Expression (c->constant_value (),
AST_Expression::EV_ulong),
-1);
}
else
{
ACE_NEW_RETURN (v,
AST_Expression (dims[i],
AST_Expression::EV_ulong),
-1);
}
UTL_ExprList *el = 0;
ACE_NEW_RETURN (el,
UTL_ExprList (v, 0),
-1);
if (v_list == 0)
{
v_list = el;
}
else
{
v_list->nconc (el);
}
}
UTL_ScopedName sn (node->local_name (), 0);
AST_Array *arr =
idl_global->gen ()->create_array (&sn,
node->n_dims (),
v_list,
false,
false);
// No need to add this new node to any scope - it's anonymous
// and owned by the node that references it.
if (v_list != 0)
{
v_list->destroy ();
delete v_list;
v_list = 0;
}
arr->set_base_type (bt);
this->reified_node_ = arr;
return 0;
}
