bool wireshark_generator::gen_typedef(AST_Typedef*, UTL_ScopedName* name, AST_Type* base,
const char* repoid)
{
if (!be_global->generate_wireshark())
return true;
switch (base->node_type()) {
case AST_Decl::NT_sequence:
{
AST_Sequence *seq = AST_Sequence::narrow_from_decl(base);
write_common (name, "sequence", repoid);
be_global->ws_config_ << name->last_component()->get_string()
<< ".element = \""
<< scoped(seq->base_type()->name())
<< "\"\n";
break;
}
case AST_Decl::NT_array:
{
write_common (name, "array", repoid);
gen_array(name, AST_Array::narrow_from_decl(base));
break;
}
default:
{
write_common (name, "alias", repoid);
be_global->ws_config_ << name->last_component()->get_string()
<< ".base = \""
<< scoped(base->name())
<< "\"\n";
return true;
}
}
return true;
}
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**";
}
void
be_type::gen_stub_decls (TAO_OutStream *os)
{
if (this->anonymous ())
{
return;
}
*os << be_nl_2
<< "// TAO_IDL - Generated from" << be_nl
<< "// " << __FILE__ << ":" << __LINE__ << be_nl_2;
AST_Interface *i = AST_Interface::narrow_from_decl (this);
AST_ValueType *v = AST_ValueType::narrow_from_decl (this);
if (i != 0)
{
*os << "typedef " << this->local_name ()
<< (v == 0 ? "_ptr" : " *") << " _ptr_type;";
}
bool skip_varout = false;
AST_Sequence *s = AST_Sequence::narrow_from_decl (this);
if (s != 0)
{
// _vars and _outs not supported yet by alt mapping.
if (be_global->alt_mapping () && s->unbounded ())
{
skip_varout = true;
}
}
if (!skip_varout)
{
*os << be_nl
<< "typedef " << this->local_name ()
<< "_var _var_type;" << be_nl
<< "typedef " << this->local_name ()
<< "_out _out_type;";
}
bool gen_any_destructor =
be_global->any_support ()
&& (!this->is_local ()
|| be_global->gen_local_iface_anyops ());
if (gen_any_destructor)
{
*os << be_nl_2
<< "static void _tao_any_destructor (void *);";
}
}
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;
}
