1 #include "forb-idl-c-backend.h"
12 static int random_id = 0;
14 static char *forb_generate_tcstruct_name (IDL_tree ts);
15 static void cbe_tc_generate (OIDL_C_Info *ci, CBETCGenInfo *tci);
18 forb_output_typecode (OIDL_C_Info *ci,
23 switch (IDL_NODE_TYPE (node)) {
25 case IDLN_TYPE_STRUCT:
29 case IDLN_TYPE_SEQUENCE:
33 g_error ("You can't produce a typecode for a %s",
34 IDL_tree_type_names[IDL_NODE_TYPE (node)]);
38 tci.structname = forb_generate_tcstruct_name (node);
39 tci.substructname = NULL;
40 tci.array_gen_ctr = 0;
42 cbe_tc_generate (ci, &tci);
44 g_free (tci.structname);
48 forb_generate_tcstruct_name (IDL_tree node)
53 tmpstr = g_string_new (NULL);
55 switch (IDL_NODE_TYPE (node)) {
56 case IDLN_TYPE_INTEGER:
58 case IDLN_TYPE_STRING:
59 case IDLN_TYPE_WIDE_STRING:
61 case IDLN_TYPE_WIDE_CHAR:
63 case IDLN_TYPE_BOOLEAN:
65 case IDLN_TYPE_SEQUENCE:
66 case IDLN_TYPE_STRUCT:
72 case IDLN_FORWARD_DCL:
73 case IDLN_TYPE_OBJECT: {
74 char *typespec = forb_cbe_get_typespec_str (node);
76 g_string_printf (tmpstr, "TC_%s", typespec);
82 g_string_printf (tmpstr, "anonTC_%d", random_id++);
87 g_string_free (tmpstr, FALSE);
93 forb_output_tcstruct_anon_subnames_array (FILE *fh, IDL_tree node, int subnames_id)
97 switch (IDL_NODE_TYPE (node)) {
99 if (!IDL_TYPE_ENUM (node).enumerator_list)
102 fprintf (fh, "static const char *anon_subnames_array%d[] = {", subnames_id);
104 for (l = IDL_TYPE_ENUM (node).enumerator_list; l; l = IDL_LIST (l).next) {
105 g_assert (IDL_NODE_TYPE (IDL_LIST (l).data) == IDLN_IDENT);
107 fprintf (fh, "\"%s\"", IDL_IDENT (IDL_LIST (l).data).str );
108 if (IDL_LIST (l).next)
112 fprintf (fh, "};\n");
114 case IDLN_EXCEPT_DCL:
115 case IDLN_TYPE_STRUCT:
116 if (!IDL_TYPE_STRUCT (node).member_list)
119 fprintf (fh, "static const char *anon_subnames_array%d[] = {", subnames_id);
121 for (l = IDL_TYPE_STRUCT (node).member_list; l; l = IDL_LIST (l).next) {
124 g_assert (IDL_NODE_TYPE (IDL_LIST (l).data) == IDLN_MEMBER);
126 for (dcl = IDL_MEMBER (IDL_LIST (l).data).dcls; dcl;
127 dcl = IDL_LIST (dcl).next) {
128 IDL_tree p = IDL_LIST (dcl).data;
130 g_assert (IDL_NODE_TYPE (p) == IDLN_IDENT ||
131 IDL_NODE_TYPE (p) == IDLN_TYPE_ARRAY);
133 if (IDL_NODE_TYPE (p) == IDLN_IDENT)
134 fprintf (fh, "\"%s\"", IDL_IDENT (p).str);
136 else /* IDLN_TYPE_ARRAY */
137 fprintf (fh, "\"%s\"",
138 IDL_IDENT (IDL_TYPE_ARRAY (p).ident).str);
140 if (IDL_LIST (dcl).next || IDL_LIST (l).next)
145 fprintf (fh, "};\n");
147 case IDLN_TYPE_UNION:
148 if (!IDL_TYPE_UNION (node).switch_body)
151 fprintf (fh, "static const char * anon_subnames_array%d[] = {", subnames_id);
153 for (l = IDL_TYPE_UNION (node).switch_body; l; l = IDL_LIST (l).next) {
157 g_assert (IDL_NODE_TYPE (IDL_LIST (l).data) == IDLN_CASE_STMT);
159 dcl = IDL_LIST (IDL_MEMBER (
160 IDL_CASE_STMT (IDL_LIST (l).data).element_spec).dcls).data;
162 g_assert (IDL_NODE_TYPE (dcl) == IDLN_IDENT ||
163 IDL_NODE_TYPE (dcl) == IDLN_TYPE_ARRAY);
165 if (IDL_NODE_TYPE (dcl) == IDLN_IDENT)
166 subname = IDL_IDENT (dcl).str;
167 else /* IDLN_TYPE_ARRAY */
168 subname = IDL_IDENT (IDL_TYPE_ARRAY (dcl).ident).str;
170 /* output the name once for each label */
171 for (label = IDL_CASE_STMT (IDL_LIST (l).data).labels;
172 label != NULL; label = IDL_LIST (label).next) {
173 fprintf (fh, "\"%s\"", subname);
174 if (IDL_LIST (label).next)
178 if (IDL_LIST (l).next)
181 fprintf (fh, "};\n");
189 forb_output_tcstruct_anon_subtypes_array (FILE *fh,
196 switch (IDL_NODE_TYPE (node)) {
197 case IDLN_EXCEPT_DCL:
198 case IDLN_TYPE_STRUCT:
199 if (!IDL_TYPE_STRUCT (node).member_list)
202 fprintf (fh, "static FORB2_MAYBE_CONST CORBA_TypeCode anon_subtypes_array%d[] = {",
205 for (l = IDL_TYPE_STRUCT (node).member_list; l; l = IDL_LIST (l).next) {
209 dcl = IDL_MEMBER (IDL_LIST (l).data).type_spec;
211 switch (IDL_NODE_TYPE (dcl)) {
214 case IDLN_TYPE_OBJECT:
215 case IDLN_FORWARD_DCL:
216 dcl = forb_cbe_get_typespec (dcl);
218 if (IDL_NODE_DECLSPEC (dcl) & IDLF_DECLSPEC_PIDL &&
219 (IDL_NODE_TYPE (dcl) == IDLN_INTERFACE ||
220 IDL_NODE_TYPE (dcl) == IDLN_FORWARD_DCL))
221 tmpstr = g_strdup ("Object");
223 tmpstr = forb_cbe_get_typespec_str (
224 IDL_MEMBER (IDL_LIST (l).data).type_spec);
227 tmpstr = forb_cbe_get_typespec_str (
228 IDL_MEMBER (IDL_LIST (l).data).type_spec);
232 g_assert (IDL_NODE_TYPE (IDL_LIST (l).data) == IDLN_MEMBER);
234 for (dcl = IDL_MEMBER (IDL_LIST (l).data).dcls; dcl;
235 dcl = IDL_LIST (dcl).next) {
237 fprintf (fh, "(CORBA_TypeCode)&TC_%s_struct", tmpstr);
239 if (IDL_LIST (dcl).next || IDL_LIST (l).next)
246 fprintf (fh, "};\n");
249 case IDLN_TYPE_UNION:
250 if (!IDL_TYPE_UNION (node).switch_body)
253 fprintf (fh, "static FORB2_MAYBE_CONST CORBA_TypeCode anon_subtypes_array%d[] = {", subtypes_id);
255 for (l = IDL_TYPE_UNION (node).switch_body; l; l = IDL_LIST (l).next) {
259 g_assert (IDL_NODE_TYPE (IDL_LIST (l).data) == IDLN_CASE_STMT);
261 dcl = IDL_MEMBER (IDL_CASE_STMT (IDL_LIST (l).data).element_spec).type_spec;
263 switch (IDL_NODE_TYPE (forb_cbe_get_typespec (dcl))) {
265 case IDLN_FORWARD_DCL:
266 if (IDL_NODE_DECLSPEC (dcl) & IDLF_DECLSPEC_PIDL)
267 tmpstr = g_strdup ( "Object");
269 tmpstr = forb_cbe_get_typespec_str (dcl);
272 tmpstr = forb_cbe_get_typespec_str (dcl);
276 for (label = IDL_CASE_STMT (IDL_LIST (l).data).labels; label;
277 label = IDL_LIST (label).next) {
278 fprintf (fh, "(CORBA_TypeCode)&TC_%s_struct", tmpstr);
280 if (IDL_LIST (label).next || IDL_LIST (l).next)
287 fprintf (fh, "};\n");
290 case IDLN_TYPE_SEQUENCE: {
294 seqts = forb_cbe_get_typespec (IDL_TYPE_SEQUENCE (node).simple_type_spec);
296 fprintf (fh, "static FORB2_MAYBE_CONST CORBA_TypeCode anon_subtypes_array%d[] = ", subtypes_id);
298 switch (IDL_NODE_TYPE (seqts)) {
300 case IDLN_FORWARD_DCL:
301 if (IDL_NODE_DECLSPEC (seqts) && IDLF_DECLSPEC_PIDL)
302 tmpstr = g_strdup ("Object");
304 tmpstr = forb_cbe_get_typespec_str (
305 IDL_TYPE_SEQUENCE (node).simple_type_spec);
308 tmpstr = forb_cbe_get_typespec_str (
309 IDL_TYPE_SEQUENCE (node).simple_type_spec);
313 fprintf (fh, "{(CORBA_TypeCode)&TC_%s_struct};\n", tmpstr);
318 case IDLN_TYPE_ARRAY:
320 fprintf (fh, "static FORB2_MAYBE_CONST CORBA_TypeCode anon_subtypes_array%d[] = ", subtypes_id);
321 fprintf (fh, "{(CORBA_TypeCode)&%s_struct};\n", substructname);
329 forb_output_tcstruct_anon_sublabels_array (FILE *fh,
335 int default_index = -1;
337 if (IDL_NODE_TYPE (node) != IDLN_TYPE_UNION ||
338 !IDL_TYPE_UNION (node).switch_body)
339 return default_index;
341 fprintf (fh, "static FORB2_MAYBE_CONST CORBA_long anon_sublabels_array%d[] = {", sublabels_id);
343 for (l = IDL_TYPE_UNION (node).switch_body; l; l = IDL_LIST (l).next)
344 for (label = IDL_CASE_STMT (IDL_LIST (l).data).labels; label;
345 label = IDL_LIST (label).next, index++) {
347 if (IDL_LIST (label).data) {
348 fprintf (fh, "(CORBA_long) ");
350 forb_cbe_write_const (fh, IDL_LIST (label).data);
352 } else { /* default case */
354 default_index = index;
357 if (IDL_LIST (label).next || IDL_LIST (l).next)
361 fprintf (fh, "};\n");
363 return default_index;
367 forb_output_tcstruct_parent (FILE *fh)
369 fprintf (fh, "{&Forb_TypeCode_epv, FORB_REFCOUNT_STATIC}");
373 forb_output_tcstruct_kind (FILE *fh, IDL_tree node, int array_gen_ctr)
375 switch (IDL_NODE_TYPE (node)) {
376 case IDLN_TYPE_ARRAY:
378 fprintf (fh, "CORBA_tk_array");
380 fprintf (fh, "CORBA_tk_alias");
383 fprintf (fh, "CORBA_tk_alias");
385 case IDLN_TYPE_STRUCT:
386 fprintf (fh, "CORBA_tk_struct");
388 case IDLN_TYPE_UNION:
389 fprintf (fh, "CORBA_tk_union");
392 fprintf (fh, "CORBA_tk_enum");
394 case IDLN_TYPE_OBJECT:
396 case IDLN_FORWARD_DCL:
397 fprintf (fh, "CORBA_tk_objref");
399 case IDLN_EXCEPT_DCL:
400 fprintf (fh, "CORBA_tk_except");
402 case IDLN_TYPE_INTEGER:
403 fprintf (fh, "CORBA_tk_");
405 if (!IDL_TYPE_INTEGER (node).f_signed)
408 switch (IDL_TYPE_INTEGER (node).f_type) {
409 case IDL_INTEGER_TYPE_SHORT:
410 fprintf (fh, "short");
412 case IDL_INTEGER_TYPE_LONG:
413 fprintf (fh, "long");
415 case IDL_INTEGER_TYPE_LONGLONG:
416 fprintf (fh, "longlong");
420 case IDLN_TYPE_FLOAT:
421 fprintf (fh, "CORBA_tk_");
423 switch (IDL_TYPE_FLOAT (node).f_type) {
424 case IDL_FLOAT_TYPE_FLOAT:
425 fprintf (fh, "float");
427 case IDL_FLOAT_TYPE_DOUBLE:
428 fprintf (fh, "double");
430 case IDL_FLOAT_TYPE_LONGDOUBLE:
431 fprintf (fh, "longdouble");
435 case IDLN_TYPE_BOOLEAN:
436 fprintf (fh, "CORBA_tk_boolean");
438 case IDLN_TYPE_OCTET:
439 fprintf (fh, "CORBA_tk_octet");
441 case IDLN_TYPE_STRING:
442 fprintf (fh, "CORBA_tk_string");
444 case IDLN_TYPE_WIDE_STRING:
445 fprintf (fh, "CORBA_tk_wstring");
448 fprintf (fh, "CORBA_tk_char");
450 case IDLN_TYPE_WIDE_CHAR:
451 fprintf (fh, "CORBA_tk_wchar");
454 fprintf (fh, "CORBA_tk_any");
456 case IDLN_TYPE_SEQUENCE:
457 fprintf (fh, "CORBA_tk_sequence");
460 g_message ("Type %s has no tk constant!",
461 IDL_tree_type_names[IDL_NODE_TYPE (node)]);
466 forb_output_tcstruct_name (FILE *fh, IDL_tree node, int array_gen_ctr)
468 switch (IDL_NODE_TYPE (node)) {
469 case IDLN_TYPE_STRUCT:
470 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_STRUCT (node).ident).str);
472 case IDLN_TYPE_UNION:
473 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_UNION (node).ident).str);
476 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_ENUM (node).ident).str);
479 case IDLN_FORWARD_DCL:
480 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_INTERFACE (node).ident).str);
482 case IDLN_EXCEPT_DCL:
483 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_EXCEPT_DCL (node).ident).str);
486 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (node).str);
488 case IDLN_TYPE_ARRAY:
490 fprintf (fh, "(char *)\"%s\"",
491 IDL_IDENT (IDL_TYPE_ARRAY (node).ident).str);
493 fprintf (fh, "NULL");
496 fprintf (fh, "NULL");
502 forb_output_tcstruct_repo_id (FILE *fh, IDL_tree node, int array_gen_ctr)
504 switch (IDL_NODE_TYPE (node)) {
505 case IDLN_TYPE_STRUCT:
506 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_STRUCT (node).ident).repo_id);
508 case IDLN_TYPE_UNION:
509 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_UNION (node).ident).repo_id);
512 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_ENUM (node).ident).repo_id);
515 case IDLN_FORWARD_DCL:
516 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_INTERFACE (node).ident).repo_id);
518 case IDLN_EXCEPT_DCL:
519 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_EXCEPT_DCL (node).ident).repo_id);
522 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (node).repo_id);
524 case IDLN_TYPE_ARRAY:
526 fprintf (fh, "(char *)\"%s\"", IDL_IDENT (IDL_TYPE_ARRAY (node).ident).repo_id);
528 fprintf (fh, "NULL");
531 fprintf (fh, "NULL");
537 forb_output_tcstruct_length (FILE *fh, IDL_tree node, int array_gen_ctr)
541 switch (IDL_NODE_TYPE (node)) {
542 case IDLN_TYPE_SEQUENCE:
543 if (IDL_TYPE_SEQUENCE (node).positive_int_const)
544 length = IDL_INTEGER (IDL_TYPE_SEQUENCE (node).positive_int_const).value;
546 case IDLN_TYPE_STRING:
547 if (IDL_TYPE_STRING (node).positive_int_const)
548 length = IDL_INTEGER (IDL_TYPE_STRING (node).positive_int_const).value;
550 case IDLN_TYPE_WIDE_STRING:
551 if (IDL_TYPE_WIDE_STRING (node).positive_int_const)
552 length = IDL_INTEGER (IDL_TYPE_STRING (node).positive_int_const).value;
554 case IDLN_TYPE_ARRAY:
558 sizer = IDL_list_nth (IDL_TYPE_ARRAY (node).size_list,
561 g_assert (IDL_NODE_TYPE (IDL_LIST (sizer).data) == IDLN_INTEGER);
563 length = IDL_INTEGER (IDL_LIST (sizer).data).value;
571 fprintf (fh, "%d", length);
575 forb_output_tcstruct_sub_parts (FILE *fh, IDL_tree node)
579 switch (IDL_NODE_TYPE (node)) {
580 case IDLN_TYPE_STRUCT:
581 case IDLN_EXCEPT_DCL: {
584 for (l = IDL_TYPE_STRUCT (node).member_list; l; l = IDL_LIST (l).next) {
587 member = IDL_LIST (l).data;
589 g_assert (IDL_NODE_TYPE (member) == IDLN_MEMBER);
591 length += IDL_list_length (IDL_MEMBER (member).dcls);
595 case IDLN_TYPE_UNION: {
598 for (l = IDL_TYPE_UNION (node).switch_body; l; l = IDL_LIST (l).next) {
601 case_stmt = IDL_LIST (l).data;
603 g_assert (IDL_NODE_TYPE (case_stmt) == IDLN_CASE_STMT);
605 length += IDL_list_length (IDL_CASE_STMT (case_stmt).labels);
610 length = IDL_list_length (IDL_TYPE_ENUM (node).enumerator_list);
613 case IDLN_TYPE_SEQUENCE:
614 case IDLN_TYPE_ARRAY:
622 fprintf (fh, "%d\n", length);
626 forb_output_tcstruct_subnames (FILE *fh, IDL_tree node, int subnames_id)
628 switch (IDL_NODE_TYPE (node)) {
630 if (IDL_TYPE_ENUM (node).enumerator_list)
631 fprintf (fh, "(char **)anon_subnames_array%d", subnames_id);
633 fprintf (fh, "NULL");
635 case IDLN_TYPE_UNION:
636 if (IDL_TYPE_UNION (node).switch_body)
637 fprintf (fh, "(char **)anon_subnames_array%d", subnames_id);
639 fprintf (fh, "NULL");
641 case IDLN_TYPE_STRUCT:
642 case IDLN_EXCEPT_DCL:
643 if (IDL_TYPE_STRUCT (node).member_list)
644 fprintf (fh, "(char **)anon_subnames_array%d", subnames_id);
646 fprintf (fh, "NULL");
649 fprintf (fh, "NULL");
655 forb_output_tcstruct_subtypes (FILE *fh, IDL_tree node, int subtypes_id)
657 switch (IDL_NODE_TYPE (node)) {
658 case IDLN_EXCEPT_DCL:
659 case IDLN_TYPE_STRUCT:
660 if (IDL_TYPE_STRUCT (node).member_list)
661 fprintf (fh, "(CORBA_TypeCode *)anon_subtypes_array%d", subtypes_id);
663 fprintf (fh, "NULL");
665 case IDLN_TYPE_UNION:
666 if (IDL_TYPE_UNION (node).switch_body)
667 fprintf (fh, "(CORBA_TypeCode *)anon_subtypes_array%d", subtypes_id);
669 fprintf (fh, "NULL");
671 case IDLN_TYPE_SEQUENCE:
672 case IDLN_TYPE_ARRAY:
674 fprintf (fh, "(CORBA_TypeCode *)anon_subtypes_array%d", subtypes_id);
677 fprintf (fh, "NULL");
683 forb_output_tcstruct_sublabels (FILE *fh, IDL_tree node, int sublabels_id)
685 switch (IDL_NODE_TYPE (node)) {
686 case IDLN_TYPE_UNION:
687 fprintf (fh, "(CORBA_long *)anon_sublabels_array%d", sublabels_id);
690 fprintf (fh, "NULL");
696 forb_output_tcstruct_discriminator (FILE *fh, IDL_tree node)
698 switch (IDL_NODE_TYPE (node)) {
699 case IDLN_TYPE_UNION: {
700 char *switch_type_spec_str;
702 switch_type_spec_str =
703 forb_cbe_get_typespec_str (IDL_TYPE_UNION (node).switch_type_spec);
705 fprintf (fh, "(CORBA_TypeCode)&TC_%s_struct", switch_type_spec_str);
707 g_free (switch_type_spec_str);
711 fprintf (fh, "CORBA_OBJECT_NIL");
717 forb_output_tcstruct_recurse_depth (FILE *fh)
723 forb_output_tcstruct_default_index (FILE *fh, int union_default_index)
725 fprintf (fh, "%d", union_default_index);
729 forb_output_tcstruct_digits_scale (FILE *fh, IDL_tree node)
731 if (IDL_NODE_TYPE (node) == IDLN_TYPE_FIXED) {
732 fprintf (fh, "%" IDL_LL "d, %" IDL_LL "d" ,
733 IDL_INTEGER (IDL_TYPE_FIXED (node).positive_int_const).value,
734 IDL_INTEGER (IDL_TYPE_FIXED (node).integer_lit).value);
737 fprintf (fh, "0, 0");
741 forb_add_align (GSList **max, const char *str)
745 for (l = *max; l; l = l->next) {
746 if (!strcmp (l->data, str))
749 *max = g_slist_prepend (*max, (gpointer) str);
753 forb_find_c_align (GSList *max, IDL_tree node)
755 node = forb_cbe_get_typespec (node);
757 switch (IDL_NODE_TYPE (node)) {
758 case IDLN_TYPE_INTEGER:
759 switch (IDL_TYPE_INTEGER (node).f_type) {
760 case IDL_INTEGER_TYPE_SHORT:
761 forb_add_align (&max, "FORB_ALIGNOF_CORBA_SHORT");
763 case IDL_INTEGER_TYPE_LONG:
764 forb_add_align (&max, "FORB_ALIGNOF_CORBA_LONG");
766 case IDL_INTEGER_TYPE_LONGLONG:
767 forb_add_align (&max, "FORB_ALIGNOF_CORBA_LONG_LONG");
771 case IDLN_TYPE_FLOAT:
772 switch (IDL_TYPE_FLOAT (node).f_type) {
773 case IDL_FLOAT_TYPE_FLOAT:
774 forb_add_align (&max, "FORB_ALIGNOF_CORBA_FLOAT");
776 case IDL_FLOAT_TYPE_DOUBLE:
777 forb_add_align (&max, "FORB_ALIGNOF_CORBA_DOUBLE");
779 case IDL_FLOAT_TYPE_LONGDOUBLE:
780 forb_add_align (&max, "FORB_ALIGNOF_CORBA_LONG_DOUBLE");
785 forb_add_align (&max, "FORB_ALIGNOF_CORBA_LONG");
787 case IDLN_TYPE_CHAR: /* drop through */
788 case IDLN_TYPE_BOOLEAN:
789 case IDLN_TYPE_OCTET:
790 forb_add_align (&max, "FORB_ALIGNOF_CORBA_CHAR");
792 case IDLN_TYPE_WIDE_CHAR:
793 forb_add_align (&max, "FORB_ALIGNOF_CORBA_SHORT");
795 case IDLN_TYPE_UNION: {
796 IDL_tree l = IDL_TYPE_UNION (node).switch_body;
798 forb_add_align (&max, "FORB_ALIGNOF_CORBA_STRUCT");
800 for (; l; l = IDL_LIST (l).next) {
801 IDL_tree subtype = IDL_MEMBER (IDL_CASE_STMT (
802 IDL_LIST (l).data).element_spec).type_spec;
803 max = forb_find_c_align (max, subtype);
807 case IDLN_EXCEPT_DCL: /* drop through */
808 case IDLN_TYPE_STRUCT: {
809 IDL_tree l = IDL_TYPE_STRUCT (node).member_list;
811 for (; l; l = IDL_LIST (l).next) {
812 IDL_tree member = IDL_MEMBER (IDL_LIST (l).data).type_spec;
814 max = forb_find_c_align (max, member);
818 case IDLN_TYPE_STRING: /* drop through */
819 case IDLN_TYPE_WIDE_STRING:
820 case IDLN_TYPE_OBJECT:
821 case IDLN_TYPE_TYPECODE:
822 case IDLN_FORWARD_DCL:
824 forb_add_align (&max, "FORB_ALIGNOF_CORBA_POINTER");
826 case IDLN_TYPE_ARRAY: {
827 IDL_tree subtype = IDL_TYPE_DCL (
828 IDL_get_parent_node (node, IDLN_TYPE_DCL, NULL)).type_spec;
829 max = forb_find_c_align (max, subtype);
832 case IDLN_TYPE_SEQUENCE:
833 forb_add_align (&max, "FORB_ALIGNOF_CORBA_STRUCT");
834 forb_add_align (&max, "FORB_ALIGNOF_CORBA_LONG");
835 forb_add_align (&max, "FORB_ALIGNOF_CORBA_POINTER");
838 forb_add_align (&max, "FORB_ALIGNOF_CORBA_STRUCT");
839 forb_add_align (&max, "FORB_ALIGNOF_CORBA_POINTER");
842 g_error ("Can't find alignment %s\n",
843 IDL_tree_type_names[IDL_NODE_TYPE (node)]);
851 forb_output_tcstruct_c_align (FILE *fh, IDL_tree node)
854 GString *str = g_string_sized_new (120);
856 max = forb_find_c_align (NULL, node);
859 g_string_append (str, "1");
862 g_string_append (str, max->data);
868 for (l = max; l; l = l->next) {
869 g_string_append (str, "MAX (");
870 g_string_append (str, l->data);
871 g_string_append (str, ", ");
875 g_string_append (str, "1");
877 g_string_append_c (str, ')');
880 fprintf (fh, "%s", str->str);
882 g_string_free (str, TRUE);
886 cbe_tc_generate (OIDL_C_Info *ci,
892 int union_default_index = -1,
893 subnames_id = random_id++,
894 subtypes_id = random_id++,
895 sublabels_id = random_id++;
897 if (strncmp (tci->structname, "anon", 4)) {
898 fprintf (ci->fh, "#if ");
899 forb_cbe_id_cond_hack (ci->fh, "TC_IMPL",
900 tci->structname, ci->c_base_name);
901 fprintf (ci->fh, " && !defined(TC_DEF_%s)\n", tci->structname);
902 fprintf (ci->fh, "#define TC_DEF_%s 1\n", tci->structname);
905 if (IDL_NODE_TYPE (tci->ts) == IDLN_TYPE_DCL) {
908 curitem = IDL_TYPE_DCL (tci->ts).type_spec;
909 subtci.substructname = ctmp = forb_generate_tcstruct_name (curitem);
912 * The only type not already defined elsewhere
913 * that can be in the left half of a TypeCode.
915 if (IDL_NODE_TYPE (curitem) == IDLN_TYPE_SEQUENCE) {
916 subtci.structname = ctmp;
918 cbe_tc_generate (ci, &subtci);
921 for (curitem = IDL_TYPE_DCL (tci->ts).dcls; curitem;
922 curitem = IDL_LIST (curitem).next) {
923 subtci.ts = IDL_LIST (curitem).data;
925 if (IDL_NODE_TYPE (subtci.ts) == IDLN_TYPE_ARRAY)
926 subtci.structname = forb_generate_tcstruct_name (
927 IDL_TYPE_ARRAY (subtci.ts).ident);
929 subtci.structname = forb_generate_tcstruct_name (subtci.ts);
931 cbe_tc_generate (ci, &subtci);
932 g_free (subtci.structname);
939 /* Do magic here - nesting of typecodes for arrays */
940 if (IDL_NODE_TYPE (tci->ts) == IDLN_TYPE_ARRAY &&
941 (IDL_list_length (IDL_TYPE_ARRAY (tci->ts).size_list) > tci->array_gen_ctr)) {
943 curitem = IDL_list_nth (IDL_TYPE_ARRAY (tci->ts).size_list,
944 tci->array_gen_ctr - 1);
947 subtci.structname = ctmp = forb_generate_tcstruct_name (curitem);
948 subtci.array_gen_ctr++;
950 cbe_tc_generate (ci, &subtci);
952 tci->substructname = ctmp; /* FIXME: memory leak */
955 forb_output_tcstruct_anon_subnames_array (ci->fh, tci->ts, subnames_id);
956 forb_output_tcstruct_anon_subtypes_array (ci->fh, tci->ts, subtypes_id,
959 union_default_index = forb_output_tcstruct_anon_sublabels_array (
960 ci->fh, tci->ts, sublabels_id);
962 if (!strncmp (tci->structname, "anon", 4))
963 fprintf (ci->fh, "static ");
965 fprintf (ci->fh, "#ifdef FORB_IDL_C_IMODULE_%s\n",
967 fprintf (ci->fh, "static\n");
968 fprintf (ci->fh, "#endif\n");
971 fprintf (ci->fh, "FORB2_MAYBE_CONST struct CORBA_TypeCode_struct %s_struct = {\n",
974 forb_output_tcstruct_parent (ci->fh);
976 fprintf (ci->fh, ",\n");
978 forb_output_tcstruct_kind (ci->fh, tci->ts, tci->array_gen_ctr);
980 fprintf (ci->fh, ",\n");
983 fprintf (ci->fh, "0,\n");
986 fprintf (ci->fh, "0,\n");
988 forb_output_tcstruct_c_align (ci->fh, tci->ts);
990 fprintf (ci->fh, ",\n");
992 forb_output_tcstruct_length (ci->fh, tci->ts, tci->array_gen_ctr);
994 fprintf (ci->fh, ",\n");
996 forb_output_tcstruct_sub_parts (ci->fh, tci->ts);
998 fprintf (ci->fh, ",\n");
1000 forb_output_tcstruct_subtypes (ci->fh, tci->ts, subtypes_id);
1002 fprintf (ci->fh, ",\n");
1004 forb_output_tcstruct_discriminator (ci->fh, tci->ts);
1006 fprintf (ci->fh, ",\n");
1008 forb_output_tcstruct_name (ci->fh, tci->ts, tci->array_gen_ctr);
1010 fprintf (ci->fh, ",\n");
1012 forb_output_tcstruct_repo_id (ci->fh, tci->ts, tci->array_gen_ctr);
1014 fprintf (ci->fh, ",\n");
1016 forb_output_tcstruct_subnames (ci->fh, tci->ts, subnames_id);
1018 fprintf (ci->fh, ",\n");
1020 forb_output_tcstruct_sublabels (ci->fh, tci->ts, sublabels_id);
1022 fprintf (ci->fh, ",\n");
1024 forb_output_tcstruct_default_index (ci->fh, union_default_index);
1026 fprintf (ci->fh, ",\n");
1028 forb_output_tcstruct_recurse_depth (ci->fh);
1030 fprintf (ci->fh, ",\n");
1032 forb_output_tcstruct_digits_scale (ci->fh, tci->ts);
1034 fprintf (ci->fh, "\n};\n");
1036 if (strncmp (tci->structname, "anon", 4))
1037 fprintf (ci->fh, "#endif\n");