/* * * (c) Copyright 1989 OPEN SOFTWARE FOUNDATION, INC. * (c) Copyright 1989 HEWLETT-PACKARD COMPANY * (c) Copyright 1989 DIGITAL EQUIPMENT CORPORATION * To anyone who acknowledges that this file is provided "AS IS" * without any express or implied warranty: * permission to use, copy, modify, and distribute this * file for any purpose is hereby granted without fee, provided that * the above copyright notices and this notice appears in all source * code copies, and that none of the names of Open Software * Foundation, Inc., Hewlett-Packard Company, or Digital Equipment * Corporation be used in advertising or publicity pertaining to * distribution of the software without specific, written prior * permission. Neither Open Software Foundation, Inc., Hewlett- * Packard Company, nor Digital Equipment Corporation makes any * representations about the suitability of this software for any * purpose. * */ /* */ /* ** ** NAME ** ASTP_DMP.C ** ** ** FACILITY: ** ** Remote Procedure Call (RPC) ** ** ABSTRACT: ** ** Contains routines to dump the Abstract Syntax Tree. ** ** VERSION: DCE 1.0 ** */ #include #include #include #ifdef DUMPERS #define DUMP_INDENT_STRING " " /* Node address dumping macros */ #define DUMP_NODE_ADDRESS_OPTION "DUMP_NODE_ADDRESS" #define NODE_ADDR_FMT "@ %08lX H" static char *debug_dump = NULL; /* * Forward declarations of dump routines */ static void AST_dump_export_list ( AST_export_n_t *export_list_ptr ); static void AST_dump_exported_item ( AST_export_n_t *export_ptr ); static void AST_dump_import_list ( AST_import_n_t *import_list_ptr ); static void AST_dump_include_list ( AST_include_n_t *include_list_ptr ); static void AST_dump_ports_list ( AST_interface_n_t *interface_node_ptr ); static void AST_dump_simple_types_list ( AST_type_p_n_t *type_p_list, int indentation ); static void AST_dump_array ( AST_array_n_t *array_node_ptr, int indentation ); static void AST_dump_indices ( AST_array_index_n_t *index_node_ptr, unsigned short array_size, int indentation ); static void AST_dump_structure ( AST_structure_n_t *structure_node_ptr, int indentation ); static void AST_dump_disc_union ( AST_disc_union_n_t *disc_union_node_ptr, int indentation ); static void AST_dump_arm ( AST_arm_n_t *arm_node_ptr, int indentation ); static void AST_dump_enumerators ( AST_enumeration_n_t *enum_node_ptr, int indentation ); static void AST_dump_field_attrs ( ASTP_node_t *parent_node, AST_type_n_t *type_node, AST_field_attr_n_t *field_attr_node, int indentation ); static void AST_dump_field_ref ( AST_field_ref_n_t *field_ref_vector, fe_node_k_t parent_node_kind, unsigned short dimension, int indentation ); static void print_type_name ( char *format, AST_type_k_t type, int indentation ); /********************************************************************/ /* */ /* AST dumping routines */ /* */ /********************************************************************/ static void indent ( int scope ) { int i; for (i = 0; i < scope; i++) printf (DUMP_INDENT_STRING); } static void dump_node_address ( char *node_name, char *node_address, int indentation ) { if (debug_dump) { indent(indentation); if (node_name != NULL) printf (node_name); printf (NODE_ADDR_FMT, node_address); if (node_name != NULL) { printf("\n"); } else { printf(", "); } } } #define dump_nametable_id AST_dump_nametable_id void AST_dump_nametable_id ( char *format_string, NAMETABLE_id_t id ) { char *name_ptr; if (id == NAMETABLE_NIL_ID) printf (format_string, "NAMETABLE_NIL_ID"); else { NAMETABLE_id_to_string (id, &name_ptr); printf (format_string, name_ptr); } } #if 0 /* Currently, Unused */ static void print_boolean ( char *format, boolean value, int scope ) { indent(scope); if (value) printf(format, "true"); else printf(format, "false") ; } #endif void AST_dump_interface ( AST_interface_n_t *if_n_p ) { if (if_n_p == NULL) return; debug_dump = getenv(DUMP_NODE_ADDRESS_OPTION); printf("\n\nDumping interface "); dump_node_address((char *)NULL, (char *)if_n_p, 0); dump_nametable_id ("%s \n", if_n_p->name); if (AST_LOCAL_SET(if_n_p)) { printf("Interface is local.\n"); } else { printf("UUID\n"); indent(1); printf("time_high = %02lx.%02lx\n", if_n_p->uuid.time_hi_and_version, if_n_p->uuid.time_mid); indent(1); printf("time_low = %04x\n", if_n_p->uuid.time_low); indent(1); printf("clock_seq_hi = %02x\n", if_n_p->uuid.clock_seq_hi_and_reserved); indent(1); printf("clock_seq_low = %02x\n", if_n_p->uuid.clock_seq_low); indent(1); printf("host = %02x.%02x.%02x.%02x.%02x.%02x\n", if_n_p->uuid.node[0], if_n_p->uuid.node[1], if_n_p->uuid.node[2], if_n_p->uuid.node[3], if_n_p->uuid.node[4], if_n_p->uuid.node[5]); }; AST_dump_ports_list (if_n_p); if (if_n_p->exceptions != NULL) { AST_exception_n_t *excep_p; printf("Exceptions:\n"); for (excep_p = if_n_p->exceptions; excep_p; excep_p = excep_p->next) { dump_nametable_id(" %s", excep_p->name); if (AST_EXTERN_SET(excep_p)) printf(" [extern]"); printf("\n"); } } if (if_n_p->cs_tag_rtns != NULL) { AST_name_n_t *name_p; printf("I-char tag routines:\n"); for (name_p = if_n_p->cs_tag_rtns; name_p; name_p = name_p->next) dump_nametable_id(" %s\n", name_p->name); } if (AST_IN_LINE_SET(if_n_p) || AST_OUT_OF_LINE_SET(if_n_p) || if_n_p->binding_callout_name != NAMETABLE_NIL_ID || AST_CODE_SET(if_n_p) || AST_NO_CODE_SET(if_n_p) || AST_DECODE_SET(if_n_p) || AST_ENCODE_SET(if_n_p) || AST_AUTO_HANDLE_SET(if_n_p) || AST_EXPLICIT_HANDLE_SET(if_n_p)) { printf("Interface attributes:\n"); if (AST_IN_LINE_SET(if_n_p)) { indent(1); printf("[in_line]\n"); }; if (AST_OUT_OF_LINE_SET(if_n_p)) { indent(1); printf("[out_of_line]\n"); }; if (if_n_p->binding_callout_name != NAMETABLE_NIL_ID) { indent(1); printf("[binding_callout("); dump_nametable_id ("%s)] \n", if_n_p->binding_callout_name); } if (AST_CODE_SET(if_n_p)) { indent(1); printf("[code]\n"); }; if (AST_NO_CODE_SET(if_n_p)) { indent(1); printf("[nocode]\n"); }; if (AST_DECODE_SET(if_n_p)) { indent(1); printf("[decode]\n"); }; if (AST_ENCODE_SET(if_n_p)) { indent(1); printf("[encode]\n"); }; if (AST_AUTO_HANDLE_SET(if_n_p)) { indent(1); printf("[auto_handle]\n"); }; if (AST_EXPLICIT_HANDLE_SET(if_n_p)) { indent(1); printf("[explicit_handle]\n"); }; }; printf("Version = %d\n", if_n_p->version); if (if_n_p->implicit_handle_name != NAMETABLE_NIL_ID) { dump_nametable_id("Implicit handle name = %s \n", if_n_p->implicit_handle_name); if (if_n_p->implicit_handle_type != NULL) { AST_dump_type(if_n_p->implicit_handle_type,"Handle type = %s\n", 0); } else { dump_nametable_id("Implicit handle type name = %s \n", if_n_p->implicit_handle_type_name); } } printf("Operation count: %d\n", if_n_p->op_count); if (if_n_p->includes != NULL) AST_dump_include_list (if_n_p->includes); if (if_n_p->imports != NULL) AST_dump_import_list (if_n_p->imports); if (if_n_p->exports != NULL) AST_dump_export_list (if_n_p->exports); if (if_n_p->pipe_types != NULL) { printf("\nPipe types list:\n"); AST_dump_simple_types_list (if_n_p->pipe_types, 1); }; if (if_n_p->ool_types != NULL) { printf("\nOut-of-line types list:\n"); AST_dump_simple_types_list (if_n_p->ool_types, 1); }; if (if_n_p->ra_types != NULL) { printf("\nRepresent-as types list:\n"); AST_dump_simple_types_list (if_n_p->ra_types, 1); }; if (if_n_p->cs_types != NULL) { printf("\nI-char types list:\n"); AST_dump_simple_types_list (if_n_p->cs_types, 1); }; if (if_n_p->sp_types != NULL) { printf("\nSelf-pointing types list:\n"); AST_dump_simple_types_list (if_n_p->sp_types, 1); }; if (if_n_p->pa_types != NULL) { printf("\nPointed-at types list:\n"); AST_dump_simple_types_list (if_n_p->pa_types, 1); }; if (if_n_p->up_types != NULL) { printf("\nUnions containing pointers list:\n"); AST_dump_simple_types_list (if_n_p->up_types, 1); }; fflush(stdout); } static void AST_dump_include_list ( AST_include_n_t *include_list_ptr ) { AST_include_n_t *ip; char *include_file; for (ip = include_list_ptr; ip; ip = ip->next) { STRTAB_str_to_string (ip->file_name, &include_file); printf("Include File: %s\n", include_file); } } static void AST_dump_import_list ( AST_import_n_t *import_list_ptr ) { AST_import_n_t *ip; char *import_file; for (ip = import_list_ptr; ip; ip = ip->next) { STRTAB_str_to_string (ip->file_name, &import_file); printf("Imported File: %s\n", import_file); } } static void AST_dump_export_list ( AST_export_n_t *export_list_ptr ) { AST_export_n_t *ep; for (ep = export_list_ptr; ep; ep = ep->next) AST_dump_exported_item (ep); } static void AST_dump_exported_item ( AST_export_n_t *export_ptr ) { printf ("\nExported Item: "); dump_node_address((char *)NULL, (char *)export_ptr, 0); switch (export_ptr->kind) { case AST_constant_k: dump_nametable_id("%s ", (export_ptr->thing_p.exported_constant)->name); printf ("Type = AST_constant_k\n"); indent(1); AST_dump_constant (export_ptr->thing_p.exported_constant, 1); break; case AST_type_k: if (AST_DEF_AS_TAG_SET(export_ptr->thing_p.exported_type)) dump_nametable_id("tag %s ", (export_ptr->thing_p.exported_type)->name); else dump_nametable_id("%s ", (export_ptr->thing_p.exported_type)->name); printf ("Type = AST_type_k\n"); AST_dump_type (export_ptr->thing_p.exported_type, "Type is %s\n", 1); /* Dump the DEF_AS_TAG type associated with this type, if any */ if (debug_dump && (export_ptr->thing_p.exported_type->fe_info->tag_ptr != NULL)) { printf ("\nImplicit Export Tagged Item: "); dump_node_address((char *)NULL, (char *)export_ptr, 0); dump_nametable_id("%s ", (export_ptr->thing_p.exported_type)->fe_info->tag_ptr->name); printf ("Type = AST_type_k\n"); AST_dump_type(export_ptr->thing_p.exported_type->fe_info->tag_ptr, "Type is %s\n", 1); printf ("\n"); } break; case AST_operation_k: printf ("Type = AST_operation_k\n"); AST_dump_operation (export_ptr->thing_p.exported_operation, 1); break; } } static void AST_dump_ports_list ( AST_interface_n_t *interface_node_ptr ) { int i; /* * Dump new string formated port specs */ for (i = 0; i < interface_node_ptr->number_of_ports; i++) { char *protocol, *endpoint; STRTAB_str_to_string((interface_node_ptr->protocol)[i],&protocol); STRTAB_str_to_string((interface_node_ptr->endpoints)[i],&endpoint); printf("Port Spec: %s:[%s]\n",protocol,endpoint); } } #if 0 /* Currently unused */ void AST_dump_types_list ( AST_type_p_n_t *type_p_list, int indentation ) { AST_type_p_n_t *type_ptr; for (type_ptr = type_p_list; type_ptr; type_ptr = type_ptr->next) { indent(indentation+1); dump_nametable_id ("Type name = %s\n", type_ptr->type->name); AST_dump_type (type_ptr->type, "Type is %s\n", indentation+1); printf("\n"); } } #endif static void AST_dump_simple_types_list ( AST_type_p_n_t *type_p_list, int indentation ) { AST_type_p_n_t *type_ptr; for (type_ptr = type_p_list; type_ptr; type_ptr = type_ptr->next) { NAMETABLE_id_t name; indent (indentation); name = type_ptr->type->name; /* Output the special pa by whom attributes if debug dump */ if (debug_dump) { if (AST_IN_PA_STUB_SET(type_ptr->type)) printf("[in_pa_stub] "); if (AST_OUT_PA_STUB_SET(type_ptr->type)) printf("[out_pa_stub] "); } if (name != NAMETABLE_NIL_ID) { if (AST_DEF_AS_TAG_SET(type_ptr->type)) printf("tag "); dump_nametable_id("%s ", type_ptr->type->name); } else if ((name == NAMETABLE_NIL_ID) && (type_ptr->type->kind == AST_structure_k)) dump_nametable_id("Struct Tag %s ", type_ptr->type->type_structure.structure->tag_name); else if ((name == NAMETABLE_NIL_ID) && (type_ptr->type->kind == AST_disc_union_k)) dump_nametable_id("Union Tag %s ", type_ptr->type->type_structure.disc_union->tag_name); else printf("NAMETABLE_NIL_ID "); print_type_name ("Type = %s\n", type_ptr->type->kind, indentation); dump_node_address("Type ", (char *)type_ptr->type, indentation); printf("\n"); } } void AST_dump_constant ( AST_constant_n_t *constant_node_ptr, int indentation ) { char *string_val_ptr; switch (constant_node_ptr->kind) { case AST_boolean_const_k: printf ("boolean constant: "); if (constant_node_ptr->value.boolean_val) { printf("TRUE"); } else { printf("FALSE"); } break; case AST_int_const_k: printf ("integer constant: %ld ", constant_node_ptr->value.int_val); if ((constant_node_ptr->value.int_val > 9) || (constant_node_ptr->value.int_val < 0)) { printf ("(%lX H) ", constant_node_ptr->value.int_val); } break; case AST_hyper_int_const_k: printf ("hyper constant: %ld %ld ", constant_node_ptr->value.hyper_int_val.high, constant_node_ptr->value.hyper_int_val.low); printf ("(%lX H, %lX H) ", constant_node_ptr->value.hyper_int_val.high, constant_node_ptr->value.hyper_int_val.low); break; case AST_string_const_k: STRTAB_str_to_string(constant_node_ptr->value.string_val, &string_val_ptr); printf ("string constant: %s\n", string_val_ptr); break; case AST_char_const_k: printf ("char constant: %c\n", constant_node_ptr->value.char_val); break; case AST_nil_const_k: printf ("NULL constant: %d\n", constant_node_ptr->value.int_val); break; default: break; } printf ("\n"); if (constant_node_ptr->defined_as != NULL) { indent(indentation); dump_nametable_id ("Defined as Named constant %s\n", constant_node_ptr->defined_as->name); dump_node_address("Defined as Constant node ", (char *)constant_node_ptr->defined_as, indentation); } } static void print_type_name ( char *format, AST_type_k_t type, int indentation ) { indent (indentation); switch (type) { case AST_small_integer_k: printf (format, "AST_small_integer_k"); break; case AST_short_integer_k: printf (format, "AST_short_integer_k"); break; case AST_long_integer_k: printf (format, "AST_long_integer_k"); break; case AST_hyper_integer_k: printf (format, "AST_hyper_integer_k"); break; case AST_small_unsigned_k: printf (format, "AST_small_unsigned_k"); break; case AST_short_unsigned_k: printf (format, "AST_short unsigned_k"); break; case AST_long_unsigned_k: printf (format, "AST_long_unsigned_k"); break; case AST_hyper_unsigned_k: printf (format, "AST_hyper_unsigned_k"); break; case AST_enum_k: printf (format, "AST_enum_k"); break; case AST_short_float_k: printf (format, "AST_short_float_k"); break; case AST_long_float_k: printf (format, "AST_long_float_k"); break; case AST_array_k: printf (format, "AST_array_k"); break; case AST_structure_k: printf (format, "AST_structure_k"); break; case AST_pointer_k: printf (format, "AST_pointer_k"); break; case AST_void_k: printf (format, "AST_void_k"); break; case AST_character_k: printf (format, "AST_character_k"); break; case AST_boolean_k: printf (format, "AST_boolean_k"); break; case AST_function_k: printf (format, "AST_function_k"); break; case AST_handle_k: printf (format, "AST_handle_k") ; break; case AST_disc_union_k: printf (format, "AST_disc_union_k") ; break; case AST_pipe_k: printf (format, "AST_pipe_k") ; break; case AST_byte_k: printf (format, "AST_byte_k") ; break; default: /* Not sure why we're here - look into later if time */ /* For now, just print the new line to finish the statement */ printf ("\n"); break; } } static void AST_dump_array ( AST_array_n_t *array_node_ptr, int indentation ) { dump_node_address("Array ", (char *)array_node_ptr, indentation); AST_dump_type (array_node_ptr->element_type, "Array element type = %s\n", indentation); AST_dump_indices (array_node_ptr->index_vec, array_node_ptr->index_count, indentation); } static void AST_dump_indices ( AST_array_index_n_t *index_node_ptr, unsigned short array_size, int indentation ) { unsigned short dimension; for (dimension=0; dimensionlower_bound, indentation+1); } if (AST_FIXED_UPPER_SET(index_node_ptr)) { indent(indentation+1); printf("[Fixed Upper] "); AST_dump_constant (index_node_ptr->upper_bound, indentation+1); } } } void AST_dump_type ( AST_type_n_t * type_n_p, char * format, int indentation ) { static int visit_count = 0; #define MAX_DEPTH 10 if (visit_count > MAX_DEPTH) { printf("...\n") ; return ; } ; if (type_n_p == NULL) { indent (indentation); printf ("No type node supplied.\n"); return; } ++visit_count ; print_type_name (format, type_n_p->kind, indentation); dump_node_address("Type ", (char *)type_n_p, indentation); indent (indentation); printf("NDR size = %d, Alignment size = %d\n", type_n_p->ndr_size, type_n_p->alignment_size); /* dump out addresses of all clones of the type */ if (type_n_p->fe_info->fe_type_id == fe_clone_info) { AST_type_p_n_t *clone_p; clone_p = type_n_p->fe_info->type_specific.clone; while (clone_p != NULL) { dump_node_address("Clone ", (char *)clone_p->type, indentation); dump_node_address("Original ", (char *)clone_p->type->fe_info->original, indentation); clone_p = clone_p->next; } } if (type_n_p->xmit_as_type != NULL) { indent (indentation); dump_nametable_id ("Transmit type = %s\n", type_n_p->xmit_as_type->name); } if (type_n_p->rep_as_type != NULL) { indent (indentation); dump_nametable_id ("Represent as = %s\n", type_n_p->rep_as_type->type_name); } if (type_n_p->cs_char_type != NULL) { indent (indentation); dump_nametable_id ("I-char type = %s\n", type_n_p->cs_char_type->type_name); } if (AST_UNALIGN_SET(type_n_p)) { indent (indentation); printf ("[unalign]\n"); } if (AST_HEAP_SET(type_n_p)) { indent (indentation); printf ("[heap]\n"); } if (AST_IN_LINE_SET(type_n_p)) { indent (indentation); printf ("[in_line]\n"); } if (AST_DEF_AS_TAG_SET(type_n_p)) { indent (indentation); printf ("[def_as_tag]\n"); } if (AST_OUT_OF_LINE_SET(type_n_p)) { indent (indentation); printf ("[out_of_line]\n"); } if (AST_STRING_SET(type_n_p)) { indent (indentation); printf ("[string]\n"); } if ((debug_dump != NULL) && AST_VARYING_SET(type_n_p)) { indent (indentation); printf ("[varying]\n"); } if (AST_STRING0_SET(type_n_p)) { indent (indentation); printf ("[string0]\n"); } if (AST_UNIQUE_SET(type_n_p)) { indent (indentation); printf ("[unique]\n"); } if (AST_REF_SET(type_n_p)) { indent (indentation); printf ("[ref]\n"); } if (AST_PTR_SET(type_n_p)) { indent (indentation); printf ("[ptr]\n"); } if (AST_IGNORE_SET(type_n_p)) { indent (indentation); printf ("[ignore]\n"); } if (AST_SMALL_SET(type_n_p)) { indent (indentation); printf ("[small]\n"); } if (AST_HANDLE_SET(type_n_p)) { indent (indentation); printf("[handle]\n"); } if (AST_CONTEXT_RD_SET(type_n_p)) { indent (indentation); printf ("[context (w/ rundown)]\n"); } if (AST_IN_SET(type_n_p)) { indent (indentation); printf ("[used for IN param"); if (AST_IN_VARYING_SET(type_n_p)) { printf (", varying"); } if (AST_IN_FIXED_SET(type_n_p)) { printf (", fixed"); } printf("]\n"); } if (AST_OUT_SET(type_n_p)) { indent (indentation); printf ("[used for OUT param"); if (AST_OUT_VARYING_SET(type_n_p)) printf (", varying"); if (AST_OUT_FIXED_SET(type_n_p)) printf (", fixed"); if (AST_OUT_PA_REF_SET(type_n_p)) printf (", pa by ref"); printf("]\n"); } if (AST_SELF_POINTER_SET(type_n_p)) { indent (indentation); printf ("[self_pointing]\n"); } if (AST_CONFORMANT_SET(type_n_p)) { indent (indentation); printf ("[conformant]\n"); } if (AST_V1_ENUM_SET(type_n_p)) { indent (indentation); printf ("[v1_enum]\n"); } if (type_n_p->defined_as != NULL) { indent (indentation); dump_nametable_id ("Defined as Named type %s\n", type_n_p->defined_as->name); dump_node_address("Defined as Type node ", (char *)type_n_p->defined_as, indentation); } switch (type_n_p->kind) { case AST_function_k: AST_dump_operation(type_n_p->type_structure.function, indentation + 1); break; case AST_array_k: AST_dump_array(type_n_p->type_structure.array, indentation+1); break; case AST_structure_k: AST_dump_structure (type_n_p->type_structure.structure, indentation+1); break; case AST_disc_union_k: AST_dump_disc_union (type_n_p->type_structure.disc_union, indentation+1); break; case AST_pointer_k: /* if pointer type is recursively defined, just output the type name */ if (AST_SELF_POINTER_SET(type_n_p->type_structure.pointer->pointee_type)) { AST_type_n_t *ptype = type_n_p->type_structure.pointer->pointee_type; NAMETABLE_id_t name = ptype->name; /* If a named type, then use that name */ indent (indentation + 1); printf("Pointer to "); if (AST_DEF_AS_TAG_SET(ptype)) printf ("tag "); dump_nametable_id ("%s\n", name); /* print out the type node address to simplify look up */ indent (indentation + 1); printf("Type node address = %08lX H \n", ptype); } else AST_dump_type (type_n_p->type_structure.pointer->pointee_type, "Pointer to %s\n", indentation + 1); /* Dump the array_rep_type if used as an array */ if (type_n_p->type_structure.pointer->pointee_type->array_rep_type != NULL) AST_dump_type (type_n_p->type_structure.pointer->pointee_type->array_rep_type, "Representation of Pointer = %s\n", indentation + 1); break; case AST_enum_k: AST_dump_enumerators (type_n_p->type_structure.enumeration, indentation + 1); break; case AST_pipe_k: indent(indentation); dump_nametable_id ("Pipe name = %s\n", type_n_p->name); AST_dump_type (type_n_p->type_structure.pipe->base_type, "Base type of %s\n", indentation + 1); break; default: break; } --visit_count ; } static void AST_dump_enumerators ( AST_enumeration_n_t *enum_node_ptr, int indentation ) { AST_constant_n_t *cp; dump_node_address("Enumerator ", (char *)enum_node_ptr, indentation); for (cp = enum_node_ptr->enum_constants; cp; cp = cp->next) { indent (indentation ); dump_nametable_id ("Enumerator name: %s ", cp->name); AST_dump_constant (cp, indentation); } } static void AST_dump_structure ( AST_structure_n_t * structure_node_ptr, int indentation ) { AST_field_n_t * fp; dump_node_address("Structure ", (char *)structure_node_ptr, indentation); if (structure_node_ptr->tag_name != NAMETABLE_NIL_ID) { indent(indentation); dump_nametable_id("Struct tag = %s\n", structure_node_ptr->tag_name); } for (fp = structure_node_ptr->fields; fp; fp = fp->next) { printf("\n"); indent (indentation); dump_nametable_id ("Field_name = %s\n", fp->name); if AST_IN_LINE_SET(fp) { indent (indentation); printf ("[in_line]\n"); } if AST_OUT_OF_LINE_SET(fp) { indent (indentation); printf ("[out_of_line]\n"); } if AST_STRING_SET(fp) { indent (indentation); printf ("[string]\n"); } if AST_STRING0_SET(fp) { indent (indentation); printf ("[string0]\n"); } if AST_IGNORE_SET(fp) { indent (indentation); printf ("[ignore]\n"); } if AST_SMALL_SET(fp) { indent (indentation); printf ("[small]\n"); } if AST_CONTEXT_SET(fp) { indent (indentation); printf ("[context]\n"); } if AST_VARYING_SET(fp) { indent (indentation); printf ("[varying]\n"); } if AST_PTR_SET(fp) { indent (indentation); printf ("[ptr]\n"); } if AST_REF_SET(fp) { indent (indentation); printf ("[ref]\n"); } if AST_UNIQUE_SET(fp) { indent (indentation); printf ("[unique]\n"); } AST_dump_field_attrs((ASTP_node_t *)fp, fp->type, fp->field_attrs, indentation); AST_dump_type (fp->type, "Field type = %s\n", indentation+1); } } static void AST_dump_disc_union ( AST_disc_union_n_t * disc_union_node_ptr, int indentation ) { AST_arm_n_t * ap; indent (indentation); dump_nametable_id ("Union tag = %s\n", disc_union_node_ptr->tag_name); indent (indentation); dump_nametable_id ("Union name = %s\n", disc_union_node_ptr->union_name); indent (indentation); dump_node_address ("Union ", (char *)disc_union_node_ptr, indentation); dump_nametable_id ("Discriminant name = %s\n", disc_union_node_ptr->discrim_name); if (disc_union_node_ptr->discrim_type != NULL) AST_dump_type (disc_union_node_ptr->discrim_type, "Discriminant type = %s\n", indentation); for (ap = disc_union_node_ptr->arms; ap; ap = ap->next) AST_dump_arm (ap, indentation + 1); } static void AST_dump_arm ( AST_arm_n_t * arm_node_ptr, int indentation ) { AST_case_label_n_t * lp; /* * Output the labels */ for (lp = arm_node_ptr->labels; lp; lp = lp->next) { indent (indentation); printf ("Case Label = "); if (lp->default_label) printf ("DEFAULT\n"); else AST_dump_constant (lp->value, indentation); } /* * Output the name and type of this arm */ indent (indentation+1); dump_nametable_id ("Arm name = %s\n", arm_node_ptr->name); dump_node_address("Arm ", (char *)arm_node_ptr, indentation); /* Dump arm attributes */ if AST_STRING_SET(arm_node_ptr) { indent (indentation+1); printf ("[string]\n"); } if AST_STRING0_SET(arm_node_ptr) { indent (indentation+1); printf ("[string0]\n"); } if AST_SMALL_SET(arm_node_ptr) { indent (indentation+1); printf ("[small]\n"); } if AST_REF_SET(arm_node_ptr) { indent (indentation+1); printf ("[ref]\n"); } if AST_PTR_SET(arm_node_ptr) { indent (indentation+1); printf ("[ptr]\n"); } if AST_UNIQUE_SET(arm_node_ptr) { indent (indentation+1); printf ("[unique]\n"); } if (arm_node_ptr->type != NULL) AST_dump_type (arm_node_ptr->type, "Arm type = %s\n", indentation+1); else { indent(indentation+1); printf("Arm type = NULL\n"); } } void AST_dump_operation ( AST_operation_n_t *operation_node_ptr, int indentation ) { AST_parameter_n_t *pp; printf("\n"); indent (indentation); printf("Operation "); dump_node_address((char *)NULL, (char *)operation_node_ptr, 0); dump_nametable_id ("name = %s\n", operation_node_ptr->name); indent (indentation); printf("Operation number: %d\n", operation_node_ptr->op_number); indent (indentation); printf("routine attributes\n") ; if (operation_node_ptr->cs_tag_rtn_name != NAMETABLE_NIL_ID) { indent (indentation); dump_nametable_id ("[cs_tag_rtn(%s)] \n", operation_node_ptr->cs_tag_rtn_name); } if AST_BROADCAST_SET(operation_node_ptr) { indent (indentation); printf ("[broadcast] \n"); } if AST_MAYBE_SET(operation_node_ptr) { indent (indentation); printf ("[maybe] \n"); } if AST_CODE_SET(operation_node_ptr) { indent (indentation); printf ("[code] \n"); } if AST_NO_CODE_SET(operation_node_ptr) { indent (indentation); printf ("[nocode] \n"); } if AST_DECODE_SET(operation_node_ptr) { indent (indentation); printf ("[decode] \n"); } if AST_ENCODE_SET(operation_node_ptr) { indent (indentation); printf ("[encode] \n"); } if AST_ENABLE_ALLOCATE_SET(operation_node_ptr) { indent (indentation); printf ("[enable_allocate] \n"); } if AST_EXPLICIT_HANDLE_SET(operation_node_ptr) { indent (indentation); printf ("[explicit_handle] \n"); } if AST_IDEMPOTENT_SET(operation_node_ptr) { indent (indentation); printf ("[idempotent] \n"); } if AST_REFLECT_DELETIONS_SET(operation_node_ptr) { indent (indentation); printf ("[reflect_deletions] \n"); } if AST_HAS_INS_SET(operation_node_ptr) { indent (indentation); printf ("[has inputs"); if AST_HAS_IN_CTX_SET(operation_node_ptr) { printf (" with context"); } if AST_HAS_IN_OOLS_SET(operation_node_ptr) { printf (" with ools"); } printf ("] \n"); } if AST_HAS_IN_PIPES_SET(operation_node_ptr) { indent (indentation); printf ("[has input pipes"); /* Special case logic if only ins in op are pipes which contain ools */ if (!AST_HAS_INS_SET(operation_node_ptr) && AST_HAS_IN_OOLS_SET(operation_node_ptr)) printf(" with ools"); printf("] \n"); } if AST_HAS_IN_PTRS_SET(operation_node_ptr) { indent (indentation); printf ("[has input ptrs] \n"); } if (AST_HAS_FULL_PTRS_SET(operation_node_ptr) && debug_dump) { indent (indentation); printf ("[has full ptrs] \n"); } if AST_HAS_OUTS_SET(operation_node_ptr) { indent (indentation); printf ("[has outputs"); if AST_HAS_OUT_CTX_SET(operation_node_ptr) { printf (" with context"); } if AST_HAS_OUT_OOLS_SET(operation_node_ptr) { printf (" with ools"); } printf ("] \n"); } if AST_HAS_OUT_PIPES_SET(operation_node_ptr) { indent (indentation); printf ("[has output pipes"); /* Special case logic if only outs in op are pipes which contain ools */ if (!AST_HAS_OUTS_SET(operation_node_ptr) && AST_HAS_OUT_OOLS_SET(operation_node_ptr)) printf(" with ools"); printf("] \n"); } if AST_HAS_OUT_PTRS_SET(operation_node_ptr) { indent (indentation); printf ("[has output ptrs] \n"); } if AST_HAS_XMIT_AS_SET(operation_node_ptr) { indent (indentation); printf ("[has transmit_as types] \n"); } indent (indentation); printf ("routine parameters\n"); for (pp = operation_node_ptr->parameters; pp != NULL; pp = pp->next) { AST_dump_parameter (pp, indentation+1); if (pp->uplink != operation_node_ptr) printf("\n\n***Consistancy Check Failure***: Uplink not set\n\n"); } if (operation_node_ptr->result != NULL) { indent (indentation); printf ("operation result\n"); AST_dump_parameter(operation_node_ptr->result, indentation+1); if (operation_node_ptr->result->uplink != operation_node_ptr) printf("\n\n***Consistancy Check Failure***: Uplink not set\n\n"); } } void AST_dump_parameter ( AST_parameter_n_t *param_node_ptr, int indentation ) { printf("\n"); indent (indentation); printf ("Parameter "); dump_node_address((char *)NULL, (char *)param_node_ptr, 0); dump_nametable_id ("name = %s\n", param_node_ptr->name); if AST_HEAP_SET(param_node_ptr) { indent (indentation); printf ("[heap]\n"); } if AST_IN_LINE_SET(param_node_ptr) { indent (indentation); printf ("[in_line]\n"); } if AST_OUT_OF_LINE_SET(param_node_ptr) { indent (indentation); printf ("[out_of_line]\n"); } if AST_CS_STAG_SET(param_node_ptr) { indent (indentation); printf ("[cs_stag]\n"); } if AST_CS_DRTAG_SET(param_node_ptr) { indent (indentation); printf ("[cs_drtag]\n"); } if AST_CS_RTAG_SET(param_node_ptr) { indent (indentation); printf ("[cs_rtag]\n"); } if AST_HIDDEN_SET(param_node_ptr) { indent (indentation); printf ("[hidden]\n"); } if AST_STRING_SET(param_node_ptr) { indent (indentation); printf ("[string]\n"); } if AST_STRING0_SET(param_node_ptr) { indent (indentation); printf ("[string0]\n"); } if AST_IGNORE_SET(param_node_ptr) { indent (indentation); printf ("[ignore]\n"); } if AST_SMALL_SET(param_node_ptr) { indent (indentation); printf ("[small]\n"); } if AST_CONTEXT_SET(param_node_ptr) { indent (indentation); printf ("[context]\n"); } if AST_VARYING_SET(param_node_ptr) { indent (indentation); printf ("[varying]\n"); } if AST_IN_SET(param_node_ptr) { indent (indentation); printf ("[in]\n"); } if AST_IN_SHAPE_SET(param_node_ptr) { indent (indentation); printf ("[in(shape)]\n"); } if AST_OUT_SET(param_node_ptr) { indent (indentation); printf ("[out]\n"); } if AST_OUT_SHAPE_SET(param_node_ptr) { indent (indentation); printf ("[out(shape)]\n"); } if AST_COMM_STATUS_SET(param_node_ptr) { indent (indentation); printf ("[comm_status]\n"); } if AST_ADD_COMM_STATUS_SET(param_node_ptr) { indent (indentation); printf ("[add_comm_status]\n"); } if AST_FAULT_STATUS_SET(param_node_ptr) { indent (indentation); printf ("[fault_status]\n"); } if AST_ADD_FAULT_STATUS_SET(param_node_ptr) { indent (indentation); printf ("[add_fault_status]\n"); } if AST_REF_SET(param_node_ptr) { indent (indentation); printf ("[ref]\n"); } if AST_PTR_SET(param_node_ptr) { indent (indentation); printf ("[ptr]\n"); } if AST_UNIQUE_SET(param_node_ptr) { indent (indentation); printf ("[unique]\n"); } AST_dump_field_attrs((ASTP_node_t *)param_node_ptr, param_node_ptr->type, param_node_ptr->field_attrs, indentation); AST_dump_type (param_node_ptr->type, "parameter type = %s\n", indentation+1); } static void AST_dump_field_attrs ( ASTP_node_t *parent_node, AST_type_n_t *type_node, AST_field_attr_n_t *field_attr_node, int indentation ) { AST_type_n_t *tp; unsigned short dimension; if (type_node == NULL) return; if (field_attr_node != (AST_field_attr_n_t *) NULL ) { dump_node_address ("Field ", (char *)field_attr_node, indentation); tp = ASTP_chase_ptr_to_kind(type_node, AST_disc_union_k); if (tp != NULL) dimension = 1; else { tp = ASTP_chase_ptr_to_kind(type_node, AST_array_k); if ((tp == NULL) && (type_node->kind != AST_pointer_k)) { return; } if (tp != NULL) { dimension = tp->type_structure.array->index_count; } else { /* A pointer with field attributes is a single dimensioned array */ dimension = 1; } } if (field_attr_node->first_is_vec != NULL) { indent (indentation); printf("[first_is] attributes:\n"); AST_dump_field_ref(field_attr_node->first_is_vec, parent_node->fe_info->node_kind, dimension, indentation+1); } if (field_attr_node->last_is_vec != NULL) { indent (indentation); printf("[last_is] attributes:\n"); AST_dump_field_ref(field_attr_node->last_is_vec, parent_node->fe_info->node_kind, dimension, indentation+1); } if (field_attr_node->length_is_vec != NULL) { indent (indentation); printf("[length_is] attributes:\n"); AST_dump_field_ref(field_attr_node->length_is_vec, parent_node->fe_info->node_kind, dimension, indentation+1); } if (field_attr_node->min_is_vec != NULL) { indent (indentation); printf("[min_is] attributes:\n"); AST_dump_field_ref(field_attr_node->min_is_vec, parent_node->fe_info->node_kind, dimension, indentation+1); } if (field_attr_node->max_is_vec != NULL) { indent (indentation); printf("[max_is] attributes:\n"); AST_dump_field_ref(field_attr_node->max_is_vec, parent_node->fe_info->node_kind, dimension, indentation+1); } if (field_attr_node->size_is_vec != NULL) { indent (indentation); printf("[size_is] attributes:\n"); AST_dump_field_ref(field_attr_node->size_is_vec, parent_node->fe_info->node_kind, dimension, indentation+1); } if (field_attr_node->switch_is != NULL) { indent (indentation); printf("[switch_is] attribute:\n"); AST_dump_field_ref(field_attr_node->switch_is, parent_node->fe_info->node_kind, 1, indentation+1); } } } static void AST_dump_field_ref ( AST_field_ref_n_t *field_ref_vector, fe_node_k_t parent_node_kind, unsigned short dimension, int indentation ) { AST_field_ref_n_t *reference_ptr; unsigned short i; for (i=0, reference_ptr = field_ref_vector; i < dimension; i++, reference_ptr++) { if (reference_ptr->valid) { indent(indentation); printf("Index %d: \n", i); if (parent_node_kind == fe_field_n_k) { indent(indentation); dump_nametable_id ("Reference is field %s\n", reference_ptr->ref.f_ref->name); AST_dump_type (reference_ptr->ref.f_ref->type, "Field type = %s\n", indentation+1); } else { if (parent_node_kind == fe_parameter_n_k) { indent(indentation); dump_nametable_id ("Reference is parameter %s\n", reference_ptr->ref.p_ref->name); AST_dump_type (reference_ptr->ref.p_ref->type, "Parameter type = %s\n", indentation+1); } else { indent(indentation); printf("**** Field attributes are not valid here.\n "); } } } } } void AST_enable_hex_dump () { debug_dump = (char*)1; } #endif /* Dumpers */