Skip to content

Commit

Permalink
dynsub example: also print the minimal typeobject
Browse files Browse the repository at this point in the history 
Signed-off-by: Erik Boasson <[email protected]>
  • Loading branch information
@eboasson
eboasson committed Jun 17, 2024
1 parent 841cd25 commit 3adfa6c
Show file tree
Hide file tree
Showing 4 changed files with 243 additions and 9 deletions.
12 changes: 6 additions & 6 deletions examples/dynsub/dynsub.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -104,17 +104,17 @@ static dds_return_t get_topic_and_typeobj (const char *topic_name, dds_duration_
dds_return_loan (triggered_reader, &epraw, 1);
goto error;
}
if (load_type_with_deps_min (participant, typeinfo, &ppc) == NULL)
{
fprintf (stderr, "loading minimal type with all dependencies failed\n");
dds_return_loan (triggered_reader, &epraw, 1);
goto error;
}
}
dds_return_loan (triggered_reader, &epraw, 1);
}
if (*xtypeobj)
{
{
struct ppc ppc;
ppc_init (&ppc);
ppc_print_to (&ppc, &(*xtypeobj)->_u.complete);
}

// If we got the type object, populate the type cache
size_t align, size;
build_typecache_to (&(*xtypeobj)->_u.complete, &align, &size);
Expand Down
6 changes: 5 additions & 1 deletion examples/dynsub/dynsub.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -54,11 +54,15 @@ void type_cache_free (void);

struct type_hashid_map *lookup_hashid (const DDS_XTypes_EquivalenceHash hashid);
const DDS_XTypes_CompleteTypeObject *get_complete_typeobj_for_hashid (const DDS_XTypes_EquivalenceHash hashid);
const DDS_XTypes_MinimalTypeObject *get_minimal_typeobj_for_hashid (const DDS_XTypes_EquivalenceHash hashid);
void build_typecache_to (const DDS_XTypes_CompleteTypeObject *typeobj, size_t *align, size_t *size);
DDS_XTypes_TypeObject *load_type_with_deps (dds_entity_t participant, const dds_typeinfo_t *typeinfo);
DDS_XTypes_TypeObject *load_type_with_deps (dds_entity_t participant, const dds_typeinfo_t *typeinfo, struct ppc *ppc);
DDS_XTypes_TypeObject *load_type_with_deps_min (dds_entity_t participant, const dds_typeinfo_t *typeinfo, struct ppc *ppc);

void ppc_init (struct ppc *ppc);
void ppc_print_ti (struct ppc *ppc, const DDS_XTypes_TypeIdentifier *typeid);
void ppc_print_to (struct ppc *ppc, const DDS_XTypes_CompleteTypeObject *typeobj);
void ppc_print_to_min (struct ppc *ppc, const DDS_XTypes_MinimalTypeObject *typeobj);

void print_sample (bool valid_data, const void *sample, const DDS_XTypes_CompleteTypeObject *typeobj);

Expand Down
146 changes: 145 additions & 1 deletion examples/dynsub/print_type.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -247,7 +247,7 @@ static bool ppc_print_simple (struct ppc *ppc, const uint8_t disc)
return false;
}

static void ppc_print_ti (struct ppc *ppc, const DDS_XTypes_TypeIdentifier *typeid)
void ppc_print_ti (struct ppc *ppc, const DDS_XTypes_TypeIdentifier *typeid)
{
if (ppc_print_simple (ppc, typeid->_d))
return;
Expand Down Expand Up @@ -337,6 +337,22 @@ static void ppc_print_ti (struct ppc *ppc, const DDS_XTypes_TypeIdentifier *type
ppc_outdent (ppc);
break;
}
case DDS_XTypes_EK_MINIMAL: {
ppc_print (ppc, "MINIMAL id=");
ppc_print_equivhash (ppc, typeid->_u.equivalence_hash);
ppc_indent (ppc);
struct type_hashid_map *info = lookup_hashid (typeid->_u.equivalence_hash);
if (info->lineno)
ppc_print (ppc, ": See line %d\n", info->lineno);
else
{
ppc_print (ppc, "\n");
info->lineno = ppc_lineno (ppc);
ppc_print_to_min (ppc, get_minimal_typeobj_for_hashid (typeid->_u.equivalence_hash));
}
ppc_outdent (ppc);
break;
}
default: {
printf ("type id discriminant %u encountered, sorry\n", (unsigned) typeid->_d);
abort ();
Expand Down Expand Up @@ -487,3 +503,131 @@ void ppc_print_to (struct ppc *ppc, const DDS_XTypes_CompleteTypeObject *typeobj
}
}
}

void ppc_print_to_min (struct ppc *ppc, const DDS_XTypes_MinimalTypeObject *typeobj)
{
if (ppc_print_simple (ppc, typeobj->_d))
return;
switch (typeobj->_d)
{
case DDS_XTypes_TK_ALIAS: {
const DDS_XTypes_MinimalAliasType *x = &typeobj->_u.alias_type;
ppc_print (ppc, "ALIAS ");
ppc_print_typeflags (ppc, x->alias_flags);
ppc_print (ppc, "\n");
ppc_indent (ppc);
ppc_print_memberflags (ppc, x->body.common.related_flags);
ppc_print (ppc, "\n");
ppc_print_ti (ppc, &x->body.common.related_type);
ppc_outdent (ppc);
break;
}
case DDS_XTypes_TK_ENUM: {
const DDS_XTypes_MinimalEnumeratedType *x = &typeobj->_u.enumerated_type;
ppc_print (ppc, "ENUM bit_bound=%"PRIu32" ", x->header.common.bit_bound);
ppc_print_typeflags (ppc, x->enum_flags);
ppc_print (ppc, "\n");
ppc_indent (ppc);
for (uint32_t i = 0; i < x->literal_seq._length; i++)
{
const DDS_XTypes_MinimalEnumeratedLiteral *l = &x->literal_seq._buffer[i];
ppc_print (ppc, "%02"PRIx8"%02"PRIx8"%02"PRIx8"%02"PRIx8" = %"PRId32" ", l->detail.name_hash[0], l->detail.name_hash[1], l->detail.name_hash[2], l->detail.name_hash[3], l->common.value);
ppc_print_memberflags (ppc, l->common.flags);
ppc_print (ppc, "\n");
}
ppc_outdent (ppc);
break;
}
case DDS_XTypes_TK_BITMASK: {
const DDS_XTypes_MinimalBitmaskType *x = &typeobj->_u.bitmask_type;
ppc_print (ppc, "BITMASK bit_bound=%"PRIu32" ", x->header.common.bit_bound);
ppc_print_typeflags (ppc, x->bitmask_flags);
ppc_print (ppc, "\n");
ppc_indent (ppc);
for (uint32_t i = 0; i < x->flag_seq._length; i++)
{
const DDS_XTypes_MinimalBitflag *l = &x->flag_seq._buffer[i];
ppc_print (ppc, "%02"PRIx8"%02"PRIx8"%02"PRIx8"%02"PRIx8" = %"PRId32" ", l->detail.name_hash[0], l->detail.name_hash[1], l->detail.name_hash[2], l->detail.name_hash[3], l->common.position);
ppc_print_memberflags (ppc, l->common.flags);
ppc_print (ppc, "\n");
}
ppc_outdent (ppc);
break;
}
case DDS_XTypes_TK_SEQUENCE: {
const DDS_XTypes_MinimalSequenceType *x = &typeobj->_u.sequence_type;
ppc_print (ppc, "SEQUENCE bound=%"PRIu32" ", x->header.common.bound);
ppc_print_typeflags (ppc, x->collection_flag);
ppc_print_memberflags (ppc, x->element.common.element_flags);
ppc_print (ppc, "\n");
ppc_indent (ppc);
ppc_print_ti (ppc, &x->element.common.type);
ppc_outdent (ppc);
break;
}
case DDS_XTypes_TK_STRUCTURE: {
const DDS_XTypes_MinimalStructType *t = &typeobj->_u.struct_type;
ppc_print (ppc, "STRUCTURE ");
ppc_print_typeflags (ppc, t->struct_flags);
ppc_print (ppc, "\n");
ppc_indent (ppc);
if (t->header.base_type._d != DDS_XTypes_TK_NONE)
{
ppc_print (ppc, "basetype=\n");
ppc_indent (ppc);
ppc_print_ti (ppc, &t->header.base_type);
ppc_outdent (ppc);
}
for (uint32_t i = 0; i < t->member_seq._length; i++)
{
const DDS_XTypes_MinimalStructMember *m = &t->member_seq._buffer[i];
ppc_print (ppc, "name_hash=%02"PRIx8"%02"PRIx8"%02"PRIx8"%02"PRIx8" ", m->detail.name_hash[0], m->detail.name_hash[1], m->detail.name_hash[2], m->detail.name_hash[3]);
ppc_print (ppc, "memberid=0x%"PRIx32" ", m->common.member_id);
ppc_print_memberflags (ppc, m->common.member_flags);
ppc_print (ppc, "\n");
ppc_indent (ppc);
ppc_print_ti (ppc, &m->common.member_type_id);
ppc_outdent (ppc);
}
ppc_outdent (ppc);
break;
}
case DDS_XTypes_TK_UNION: {
const DDS_XTypes_MinimalUnionType *t = &typeobj->_u.union_type;
ppc_print (ppc, "UNION ");
ppc_print_typeflags (ppc, t->union_flags);
ppc_print (ppc, "\n");
ppc_indent (ppc);
ppc_print (ppc, "discriminator=");
ppc_indent (ppc);
const DDS_XTypes_MinimalDiscriminatorMember *disc = &t->discriminator;
ppc_print_memberflags (ppc, disc->common.member_flags);
ppc_print (ppc, " ");
ppc_print_ti (ppc, &disc->common.type_id);
ppc_outdent (ppc);
for (uint32_t i = 0; i < t->member_seq._length; i++)
{
const DDS_XTypes_MinimalUnionMember *m = &t->member_seq._buffer[i];
if (m->common.label_seq._length == 0)
ppc_print (ppc, "default:\n");
for (uint32_t j = 0; j < m->common.label_seq._length; j++)
ppc_print (ppc, "case %"PRIu32":\n", m->common.label_seq._buffer[j]);
ppc_indent (ppc);
ppc_print (ppc, "name_hash=%02"PRIx8"%02"PRIx8"%02"PRIx8"%02"PRIx8" ", m->detail.name_hash[0], m->detail.name_hash[1], m->detail.name_hash[2], m->detail.name_hash[3]);
ppc_print (ppc, "memberid=0x%"PRIx32" ", m->common.member_id);
ppc_print_memberflags (ppc, m->common.member_flags);
ppc_print (ppc, "\n");
ppc_indent (ppc);
ppc_print_ti (ppc, &m->common.type_id);
ppc_outdent (ppc);
ppc_outdent (ppc);
}
ppc_outdent (ppc);
break;
}
default: {
printf ("type object discriminant %u encountered, sorry\n", (unsigned) typeobj->_d);
abort ();
}
}
}
88 changes: 87 additions & 1 deletion examples/dynsub/type_cache.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -187,6 +187,14 @@ const DDS_XTypes_CompleteTypeObject *get_complete_typeobj_for_hashid (const DDS_
return &info->typeobj->_u.complete;
}

const DDS_XTypes_MinimalTypeObject *get_minimal_typeobj_for_hashid (const DDS_XTypes_EquivalenceHash hashid)
{
struct type_hashid_map *info;
if ((info = lookup_hashid (hashid)) == NULL)
abort ();
return &info->typeobj->_u.minimal;
}

static void build_typecache_ti (const DDS_XTypes_TypeIdentifier *typeid, size_t *align, size_t *size)
{
if (build_typecache_simple (typeid->_d, align, size))
Expand Down Expand Up @@ -447,6 +455,7 @@ static bool load_deps_simple (uint8_t disc)
}

static bool load_deps_to (dds_entity_t participant, const DDS_XTypes_CompleteTypeObject *typeobj);
static bool load_deps_to_min (dds_entity_t participant, const DDS_XTypes_MinimalTypeObject *typeobj);

static bool load_deps_ti (dds_entity_t participant, const DDS_XTypes_TypeIdentifier *typeid)
{
Expand Down Expand Up @@ -485,6 +494,26 @@ static bool load_deps_ti (dds_entity_t participant, const DDS_XTypes_TypeIdentif
return load_deps_to (participant, &xtypeobj->_u.complete);
}
}
case DDS_XTypes_EK_MINIMAL: {
struct type_hashid_map templ, *info;
memcpy (templ.id, typeid->_u.equivalence_hash, sizeof (templ.id));
if (type_hashid_map_lookup (&templ) != NULL)
return true;
else
{
dds_typeobj_t *typeobj;
if (dds_get_typeobj (participant, (const dds_typeid_t *) typeid, 0, &typeobj) < 0)
return load_deps_failed ();
DDS_XTypes_TypeObject * const xtypeobj = (DDS_XTypes_TypeObject *) typeobj;
info = malloc (sizeof (*info));
assert (info);
memcpy (info->id, typeid->_u.equivalence_hash, sizeof (info->id));
info->typeobj = xtypeobj;
info->lineno = 0;
type_hashid_map_add (info);
return load_deps_to_min (participant, &xtypeobj->_u.minimal);
}
}
default: {
printf ("type id discriminant %u encountered, sorry\n", (unsigned) typeid->_d);
abort ();
Expand Down Expand Up @@ -534,7 +563,48 @@ static bool load_deps_to (dds_entity_t participant, const DDS_XTypes_CompleteTyp
}
}

DDS_XTypes_TypeObject *load_type_with_deps (dds_entity_t participant, const dds_typeinfo_t *typeinfo)
static bool load_deps_to_min (dds_entity_t participant, const DDS_XTypes_MinimalTypeObject *typeobj)
{
if (load_deps_simple (typeobj->_d))
return true;
switch (typeobj->_d)
{
case DDS_XTypes_TK_ALIAS:
return load_deps_ti (participant, &typeobj->_u.alias_type.body.common.related_type);
case DDS_XTypes_TK_ENUM:
case DDS_XTypes_TK_BITMASK:
return true;
case DDS_XTypes_TK_SEQUENCE:
return load_deps_ti (participant, &typeobj->_u.sequence_type.element.common.type);
case DDS_XTypes_TK_STRUCTURE: {
const DDS_XTypes_MinimalStructType *t = &typeobj->_u.struct_type;
if (!load_deps_ti (participant, &t->header.base_type))
return load_deps_failed ();
for (uint32_t i = 0; i < t->member_seq._length; i++) {
if (!load_deps_ti (participant, &t->member_seq._buffer[i].common.member_type_id))
return load_deps_failed ();
}
return true;
}
case DDS_XTypes_TK_UNION: {
const DDS_XTypes_MinimalUnionType *t = &typeobj->_u.union_type;
if (!load_deps_ti (participant, &t->discriminator.common.type_id))
return load_deps_failed ();
for (uint32_t i = 0; i < t->member_seq._length; i++) {
if (!load_deps_ti (participant, &t->member_seq._buffer[i].common.type_id))
return load_deps_failed ();
}
return true;
}
default: {
printf ("type object discriminant %u encountered, sorry\n", (unsigned) typeobj->_d);
abort ();
return load_deps_failed ();
}
}
}

DDS_XTypes_TypeObject *load_type_with_deps (dds_entity_t participant, const dds_typeinfo_t *typeinfo, struct ppc *ppc)
{
DDS_XTypes_TypeInformation const * const xtypeinfo = (DDS_XTypes_TypeInformation *) typeinfo;
if (!load_deps_ti (participant, &xtypeinfo->complete.typeid_with_size.type_id))
Expand All @@ -543,5 +613,21 @@ DDS_XTypes_TypeObject *load_type_with_deps (dds_entity_t participant, const dds_
memcpy (templ.id, &xtypeinfo->complete.typeid_with_size.type_id._u.equivalence_hash, sizeof (templ.id));
if ((info = type_hashid_map_lookup (&templ)) == NULL)
return NULL;
if (ppc)
ppc_print_ti (ppc, &xtypeinfo->complete.typeid_with_size.type_id);
return (DDS_XTypes_TypeObject *) info->typeobj;
}

DDS_XTypes_TypeObject *load_type_with_deps_min (dds_entity_t participant, const dds_typeinfo_t *typeinfo, struct ppc *ppc)
{
DDS_XTypes_TypeInformation const * const xtypeinfo = (DDS_XTypes_TypeInformation *) typeinfo;
if (!load_deps_ti (participant, &xtypeinfo->minimal.typeid_with_size.type_id))
return NULL;
struct type_hashid_map templ, *info;
memcpy (templ.id, &xtypeinfo->minimal.typeid_with_size.type_id._u.equivalence_hash, sizeof (templ.id));
if ((info = type_hashid_map_lookup (&templ)) == NULL)
return NULL;
if (ppc)
ppc_print_ti (ppc, &xtypeinfo->minimal.typeid_with_size.type_id);
return (DDS_XTypes_TypeObject *) info->typeobj;
}

0 comments on commit 3adfa6c

Please sign in to comment.