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;
}
