diff options
Diffstat (limited to 'support/ltx2x/l2xisdcl.c')
-rw-r--r-- | support/ltx2x/l2xisdcl.c | 420 |
1 files changed, 420 insertions, 0 deletions
diff --git a/support/ltx2x/l2xisdcl.c b/support/ltx2x/l2xisdcl.c new file mode 100644 index 0000000000..f4fff6ad1a --- /dev/null +++ b/support/ltx2x/l2xisdcl.c @@ -0,0 +1,420 @@ +/* l2xisdcl.c LTX2X declaration analysis */ +/* Written by: Peter Wilson, CUA pwilson@cme.nist.gov */ +/* This code is partly based on algorithms presented by Ronald Mak in */ +/* "Writing Compilers & Interpreters", John Wiley & Sons, 1991 */ + +#include <stdio.h> +#include "l2xicmon.h" +#include "l2xierr.h" +#include "l2xiscan.h" +#include "l2xisymt.h" +#include "l2xiidbg.h" + +/* EXTERNALS */ + +extern int line_number; +extern TOKEN_CODE token; + +/* GLOBALS */ + +char buffer[MAX_PRINT_LINE_LENGTH]; + +char *defn_names[] = { +#define dfntc(a, b) b, +#include "l2xidftc.h" +#undef dfntc +}; + + +char *form_names[] = { +#define fotc(a, b, c, d) d, +#define sotc(a, b, c, d) +#define sftc(a, b, c, d) d, +#include "l2xisftc.h" +#undef fotc +#undef sotc +#undef sftc +}; + + + +/* ANALYSIS */ + + +/***************************************************************************/ +/* analyze_const_defn(idp) Analyze a constant definition */ + +analyze_const_defn(idp) +SYMTAB_NODE_PTR idp; /* constant id */ +{ + char *bp; + + if (DEBUG < Danalyze) return; + + /* the name */ + sprintf(buffer, ">> id = %s\n", idp->name); + debug_print(buffer); + sprintf(buffer, ">> address = %d\n", idp); + + /* definition and value */ + sprintf(buffer, ">> defn = %s, value = ", defn_names[idp->defn.key]); + bp = buffer + strlen(buffer); + + if ((idp->typep == integer_typep) || (idp->typep->form == ENUM_FORM)) + sprintf(bp, "%d\n", idp->defn.info.constant.value.integer); + else if (idp->typep == real_typep) + sprintf(bp, "%g\n", idp->defn.info.constant.value.real); + else if (idp->typep->form == ARRAY_FORM) /* ????????????????????????? */ + sprintf(bp, "'%s'\n", idp->defn.info.constant.value.stringp); + else if (idp->typep->form == STRING_FORM) + sprintf(bp, "'%s'\n", idp->defn.info.constant.value.stringp); + debug_print(buffer); + + /* and type. careful as an enum type will get into an infinite loop */ + if (idp->typep->form != ENUM_FORM) analyze_type(idp->typep, FALSE); + +} /* end analyze_const_defn */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_type_defn(idp) Analyze a type definition */ + +analyze_type_defn(idp) +SYMTAB_NODE_PTR idp; /* id */ +{ + char *bp; + + if (DEBUG < Danalyze) return; + + /* the type's name, definition ... */ + sprintf(buffer, ">>id = %s\n", idp->name); + debug_print(buffer); + sprintf(buffer, ">> address = %d\n", idp); + debug_print(buffer); + + sprintf(buffer, ">> defn = %s\n", defn_names[idp->defn.key]); +/* print_line(buffer); */ + debug_print(buffer); + + /* and type */ + analyze_type(idp->typep, TRUE); + +} /* end analyze_type_defn */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_type(tp, verbose_flag) Analyze a type definition */ + +analyze_type(tp, verbose_flag) +TYPE_STRUCT_PTR tp; /* pointer to type structure */ +BOOLEAN verbose_flag; /* TRUE for verbose analysis */ +{ + char *bp; + + if (DEBUG < Danalyze) return; + + if (tp == NULL) return; + + /* the form, byte size (and name) */ + sprintf(buffer, ">> form = %s, size = %d bytes, type id = ", + form_names[tp->form], tp->size); + bp = buffer + strlen(buffer); + if (tp->type_idp != NULL) + sprintf(bp, "%s\n", tp->type_idp->name); + else { + sprintf(bp, "<unnamed type>\n"); + verbose_flag = TRUE; + } + debug_print(buffer); + + /* do the appropriate analysus */ + switch (tp->form) { + case ENUM_FORM: { + analyze_enum_type(tp, verbose_flag); + break; + } + case SUBRANGE_FORM: { + analyze_subrange_type(tp, verbose_flag); + break; + } + case ARRAY_FORM: { + analyze_array_type(tp, verbose_flag); + break; + } + case STRING_FORM: { + verbose_flag = TRUE; + analyze_string_type(tp, verbose_flag); + break; + } + case BOUND_FORM: { + analyze_bound_type(tp, verbose_flag); + break; + } + case ENTITY_FORM: { + analyze_entity_type(tp, verbose_flag); + break; + } + case BAG_FORM: + case LIST_FORM: + case SET_FORM: { + analyze_bls_type(tp, verbose_flag); + break; + } + default: { + break; + } + } /* end switch */ + +} /* end analyze_type */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_enum_type(tp, verbose_flag) Analyze an enumeration type */ + +analyze_enum_type(tp, verbose_flag) +TYPE_STRUCT_PTR tp; /* pointer to type structure */ +BOOLEAN verbose_flag; /* TRUE for verbose analysis */ +{ + SYMTAB_NODE_PTR idp; /* id */ + + if (DEBUG < Danalyze) return; + + if (!verbose_flag) return; + + /* loop to analyze each enum constant as a constant defn */ + debug_print(">> -- Enum Constants --\n"); + for (idp = tp->info.enumeration.const_idp; idp != NULL; idp = idp->next) { + analyze_const_defn(idp); + } + +} /* end analyze_enum_type */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_subrange_type(tp, verbose_flag) Analyze a subrange type */ + +analyze_subrange_type(tp, verbose_flag) +TYPE_STRUCT_PTR tp; /* pointer to type structure */ +BOOLEAN verbose_flag; /* TRUE for verbose analysis */ +{ + SYMTAB_NODE_PTR idp; /* id */ + + if (DEBUG < Danalyze) return; + + if (!verbose_flag) return; + + sprintf(buffer, ">> min value = %d, max value = %d\n", + tp->info.subrange.min, tp->info.subrange.max); + debug_print(buffer); + + debug_print(">> -- Range Type -- \n"); + analyze_type(tp->info.subrange.range_typep, FALSE); + +} /* end analyze_subrange_type */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_bound_type(tp, verbose_flag) Analyze a bound type */ + +analyze_bound_type(tp, verbose_flag) +TYPE_STRUCT_PTR tp; /* pointer to type structure */ +BOOLEAN verbose_flag; /* TRUE for verbose analysis */ +{ + SYMTAB_NODE_PTR idp; /* id */ + + if (DEBUG < Danalyze) return; + + if (!verbose_flag) return; + + sprintf(buffer, ">> min value = %d, max value = %d\n", + tp->info.bound.min, tp->info.bound.max); + debug_print(buffer); + + debug_print(">> -- Bound Type -- \n"); + analyze_type(tp->info.bound.bound_typep, FALSE); + +} /* end analyze_bound_type */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_array_type(tp, verbose_flag) Analyze an array type */ + +analyze_array_type(tp, verbose_flag) +TYPE_STRUCT_PTR tp; /* pointer to type structure */ +BOOLEAN verbose_flag; /* TRUE for verbose analysis */ +{ + SYMTAB_NODE_PTR idp; /* id */ + + if (DEBUG < Danalyze) return; + + if (!verbose_flag) return; + + sprintf(buffer, ">> element count = %d\n", + tp->info.array.elmt_count); + debug_print(buffer); + sprintf(buffer, ">> index limits = %d to %d\n", + tp->info.array.min_index, tp->info.array.max_index); + debug_print(buffer); + + debug_print(">> -- INDEX TYPE -- \n"); + analyze_type(tp->info.array.index_typep, FALSE); + + debug_print(">> -- ELEMENT TYPE -- \n"); + analyze_type(tp->info.array.elmt_typep, FALSE); + +} /* end analyze_array_type */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_bls_type(tp, verbose_flag) Analyze a bag, etc type */ + +analyze_bls_type(tp, verbose_flag) +TYPE_STRUCT_PTR tp; /* pointer to type structure */ +BOOLEAN verbose_flag; /* TRUE for verbose analysis */ +{ + SYMTAB_NODE_PTR idp; /* id */ + + if (DEBUG < Danalyze) return; + + if (!verbose_flag) return; + + sprintf(buffer, ">> element count = %d\n", + tp->info.dynagg.elmt_count); + debug_print(buffer); + sprintf(buffer, ">> index limits = %d to %d\n", + tp->info.dynagg.min_index, tp->info.dynagg.max_index); + debug_print(buffer); + + debug_print(">> -- INDEX TYPE -- \n"); + analyze_type(tp->info.dynagg.index_typep, FALSE); + + debug_print(">> -- ELEMENT TYPE -- \n"); + analyze_type(tp->info.dynagg.elmt_typep, FALSE); + +} /* end analyze_bls_type */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_string_type(tp, verbose_flag) Analyze a string type */ + +analyze_string_type(tp, verbose_flag) +TYPE_STRUCT_PTR tp; /* pointer to type structure */ +BOOLEAN verbose_flag; /* TRUE for verbose analysis */ +{ + SYMTAB_NODE_PTR idp; /* id */ + + if (DEBUG < Danalyze) return; + + if (!verbose_flag) return; + + sprintf(buffer, ">> maximum length = %d\n", + tp->info.string.max_length); + debug_print(buffer); + + sprintf(buffer, ">> length = %d\n", + tp->info.string.length); + debug_print(buffer); + return; + +} /* end analyze_string_type */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_entity_type(tp, verbose_flag) Analyze an entity type */ + +analyze_entity_type(tp, verbose_flag) +TYPE_STRUCT_PTR tp; /* pointer to type structure */ +BOOLEAN verbose_flag; /* TRUE for verbose analysis */ +{ + SYMTAB_NODE_PTR idp; /* id */ + + if (DEBUG < Danalyze) return; + + if (!verbose_flag) return; + + /* loop to analyze each attribute as a variable decl */ + debug_print(">> -- Attributes -- \n"); + for (idp = tp->info.entity.attribute_symtab; idp != NULL; idp = idp->next) { + analyze_var_decl(idp); + } + +} /* end analyze_entity_type */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_var_decl(idp) Analyze a variable declaration */ + +analyze_var_decl(idp) +SYMTAB_NODE_PTR idp; /* id */ +{ + + if (DEBUG < Danalyze) return; + + /* the name, definition and offset */ + sprintf(buffer, ">> id = %s\n", idp->name); + debug_print(buffer); + sprintf(buffer, ">> address = %d\n", idp); + debug_print(buffer); + + sprintf(buffer, ">> defn = %s, offset = %d\n", + defn_names[idp->defn.key], idp->defn.info.data.offset); +/* print_line(buffer); */ + debug_print(buffer); + + /* and type */ + analyze_type(idp->typep, FALSE); + +} /* end analyze_var_decl */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_block(code_segment) a dummy procedure */ + +analyze_block(code_segment) +char *code_segment; +{ + return; +} /* end analyze_block */ +/***************************************************************************/ + + + +/***************************************************************************/ +/* analyze_routine_header(rtn_idp) a dummy procedure */ + +analyze_routine_header(rtn_idp) +SYMTAB_NODE_PTR rtn_idp; + +{ + return; +} /* end analyze_routine_header */ +/***************************************************************************/ + + + +/***************************************************************************/ + + + |