123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414 |
- /*
- * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
- * See the copyright notice in the ACK home directory, in the file "Copyright".
- */
- /* $Header$ */
- /* Lint outdef construction */
- #include "lint.h"
- #ifdef LINT
- #include <alloc.h>
- #include "arith.h"
- #include "type.h"
- #include "LLlex.h"
- #include "Lpars.h"
- #include "stack.h"
- #include "def.h"
- #include "struct.h"
- #include "field.h"
- #include "idf.h"
- #include "level.h"
- #include "label.h"
- #include "expr.h"
- #include "l_lint.h"
- #include "l_outdef.h"
- #include "l_class.h"
- extern char *symbol2str();
- extern int f_VARARGSn, LINTLIB;
- int stat_number = 9999; /* static scope number */
- struct outdef OutDef, OutCall;
- lint_declare_idf(idf, sc)
- struct idf *idf;
- int sc;
- {
- register struct def *def = idf->id_def;
- register int is_function = def->df_type->tp_fund == FUNCTION;
- if (level == L_GLOBAL) {
- lint_ext_def(idf, sc);
- if (is_function)
- def2decl(sc);
- if (sc != TYPEDEF)
- outdef();
- }
- else
- if (level >= L_LOCAL && sc != STATIC && is_function) {
- local_EFDC(idf);
- }
- }
- lint_ext_def(idf, sc)
- struct idf *idf;
- {
- /* At this place the following fields of the outputdefinition can be
- * filled:
- * name, stat_number, class, file, line, type.
- * For variable definitions and declarations this will be all.
- * For functions the fields nrargs and argtps are filled after parsing
- * the arguments.
- * The returns-field is known at the end of the function definition.
- * sc indicates the storage class defined by the declaration specifier.
- */
- register struct def *def = idf->id_def;
- register struct type *type = def->df_type;
- OutDef.od_name = idf->id_text;
- OutDef.od_statnr = (sc == STATIC ? stat_number : 0);
- switch (type->tp_fund) {
- case ERRONEOUS:
- OutDef.od_class = XXDF;
- break;
- case FUNCTION:
- /* For the moment assume it will be a definition.
- * If no compound_statement follows, it is a declaration,
- * in which case the class will be adjusted by def2decl().
- */
- OutDef.od_class = (sc == STATIC ? SFDF : EFDF);
- break;
- default: /* a variable */
- OutDef.od_class =
- sc == EXTERN ? EVDC :
- sc == STATIC ? SVDF : EVDF;
- break;
- }
- OutDef.od_file = def->df_file;
- OutDef.od_line = def->df_line;
- OutDef.od_type = (type->tp_fund == FUNCTION ? type->tp_up : type);
- OutDef.od_valreturned = NORETURN;
- }
- def2decl(sc)
- int sc;
- {
- /* It was assumed we were parsing a function definition.
- * There was no compound statement following, so actually it was a
- * declaration. This function updates the class.
- */
- OutDef.od_class = (sc == STATIC ? XXDF : EFDC);
- }
- set_od_valreturned(n)
- {
- OutDef.od_valreturned = n;
- }
- local_EFDC(idf)
- struct idf *idf;
- {
- struct outdef od;
- od.od_class = EFDC;
- od.od_statnr = 0;
- od.od_name = idf->id_text;
- od.od_file = idf->id_def->df_file;
- od.od_line = idf->id_def->df_line;
- od.od_type = idf->id_def->df_type->tp_up;
- output_def(&od);
- /* The other fields are not used for this class. */
- }
- lint_formals()
- {
- /* Make a list of tp_entries containing the types of the formal
- * parameters of the function definition currently parsed.
- */
- register struct stack_entry *se = stack_level_of(L_FORMAL1)->sl_entry;
- register struct tp_entry **hook = &OutDef.od_entry;
- OutDef.od_nrargs = 0;
- while (se) {
- register struct type *type = se->se_idf->id_def->df_type;
- register struct tp_entry *te = new_tp_entry();
- switch (type->tp_fund) {
- /* Do the conversions on the formals that could not be
- done in declare_idf().
- It is, unfortunately, impossible not to do them,
- since the corresponding actuals will have been
- converted to generate proper code and we do not
- want to duplicate the whole of expression handling
- for lint.
- */
- case CHAR:
- case SHORT:
- type = int_type;
- break;
- case FLOAT:
- type = double_type;
- break;
- }
- te->te_type = type;
- te->te_class = !Const;
- *hook = te;
- hook = &te->next;
- OutDef.od_nrargs++;
- se = se->next;
- }
- if (f_VARARGSn > OutDef.od_nrargs) {
- warning("VARARGS%d function has only %d arguments",
- f_VARARGSn, OutDef.od_nrargs);
- f_VARARGSn = OutDef.od_nrargs;
- }
- }
- output_use(idf)
- struct idf *idf;
- {
- /* Output the usage-definition of the variable described by idf.
- */
- OutDef.od_name = idf->id_text;
- OutDef.od_statnr = (idf->id_def->df_sc == STATIC ? stat_number : 0);
- OutDef.od_class = VU;
- OutDef.od_file = FileName;
- OutDef.od_line = LineNumber;
- OutDef.od_type = idf->id_def->df_type;
- outdef();
- }
- outdef()
- {
- output_def(&OutDef);
- }
- outcall()
- {
- output_def(&OutCall);
- }
- output_def(od)
- struct outdef *od;
- {
- /* As the types are output the tp_entries are removed, because they
- * are then not needed anymore.
- */
- if (od->od_class == XXDF)
- return;
- if (LINTLIB) {
- switch (od->od_class) {
- case EFDF:
- od->od_class = LFDF;
- break;
- case EVDF:
- od->od_class = LVDF;
- break;
- case SFDF:
- /* remove tp_entries */
- while (od->od_entry) {
- register struct tp_entry *tmp = od->od_entry;
- od->od_entry = od->od_entry->next;
- free_tp_entry(tmp);
- }
- return;
- default:
- return;
- }
- }
- printf("%s:%d:%c", od->od_name, od->od_statnr, od->od_class);
- switch (od->od_class) {
- case EFDF:
- case SFDF:
- case LFDF:
- if (f_VARARGSn != -1) {
- printf(":%d", -1 - f_VARARGSn);
- outtypes(od->od_entry, f_VARARGSn);
- }
- else {
- printf(":%d", od->od_nrargs);
- outtypes(od->od_entry, od->od_nrargs);
- }
- od->od_entry = 0;
- printf(":%d", od->od_valreturned);
- break;
- case FC:
- printf(":%d", od->od_nrargs);
- outtypes(od->od_entry, od->od_nrargs);
- od->od_entry = 0;
- printf(":%d", od->od_valused);
- break;
- case EVDF:
- case SVDF:
- case LVDF:
- case EFDC:
- case EVDC:
- case IFDC:
- case VU:
- break;
- default:
- crash("(output_def) illegal class");
- /*NOTREACHED*/
- }
- printf(":");
- outtype(od->od_type);
- printf(":%u:%s\n", od->od_line, od->od_file);
- }
- outtypes(te, n)
- struct tp_entry *te;
- {
- /* Output n types in the tp_entry-list and remove all the entries */
- register struct tp_entry *tmp;
- while (n--) {
- if (!te) {
- crash("(outtypes) not enough tp_entries");
- /*NOTREACHED*/
- }
- printf(":");
- if (te->te_class == Const && te->te_value >= 0) {
- /* constant non-negative actual parameter */
- printf("+");
- }
- outtype(te->te_type);
- if (te->te_type->tp_fund == FUNCTION) {
- /* UGLY PATCH !!! ??? */
- /* function names as operands are sometimes
- FUNCTION and sometimes POINTER to FUNCTION,
- depending on opaque circumstances. E.g., in
- f(main, main);
- the first main is PtF and the second is F.
- */
- printf("*");
- }
- tmp = te;
- te = te->next;
- free_tp_entry(tmp);
- }
- /* remove the remaining entries */
- while (te) {
- tmp = te;
- te = te->next;
- free_tp_entry(tmp);
- }
- }
- outtype(tp)
- struct type *tp;
- {
- switch (tp->tp_fund) {
- case POINTER:
- outtype(tp->tp_up);
- printf("*");
- break;
- case ARRAY:
- outtype(tp->tp_up);
- printf("*"); /* compatible with [] */
- break;
- case FUNCTION:
- outtype(tp->tp_up);
- printf("()");
- break;
- case STRUCT:
- case UNION:
- case ENUM:
- printf("%s %s", symbol2str(tp->tp_fund), tp->tp_idf->id_text);
- break;
- case CHAR:
- case INT:
- case SHORT:
- case LONG:
- case FLOAT:
- case DOUBLE:
- case VOID:
- case ERRONEOUS:
- if (tp->tp_unsigned)
- printf("unsigned ");
- printf("%s", symbol2str(tp->tp_fund));
- break;
- default:
- crash("(outtype) illegal tp_fund");
- /*NOTREACHED*/
- }
- }
- implicit_func_decl(idf, file, line)
- struct idf *idf;
- char *file;
- unsigned int line;
- {
- struct outdef od;
- od.od_class = IFDC;
- od.od_statnr = 0;
- od.od_name = idf->id_text;
- od.od_file = file;
- od.od_line = line;
- od.od_type = idf->id_def->df_type->tp_up;
- output_def(&od);
- /* The other fields are not used for this class. */
- }
- fill_outcall(ex, used)
- struct expr *ex;
- int used;
- {
- register struct idf *idf = ex->OP_LEFT->VL_IDF;
- register struct def *def = idf->id_def;
- if (def->df_sc == IMPLICIT) {
- implicit_func_decl(idf, ex->ex_file, ex->ex_line);
- }
- OutCall.od_type = def->df_type->tp_up;
- OutCall.od_statnr = (def->df_sc == STATIC ? stat_number : 0);
- OutCall.od_class = FC;
- OutCall.od_name = idf->id_text;
- OutCall.od_file = ex->ex_file;
- OutCall.od_line = ex->ex_line;
- OutCall.od_entry = (struct tp_entry *)0;
- OutCall.od_nrargs = 0;
- if ((ex = ex->OP_RIGHT) != 0) { /* function call with arguments */
- /* store types of argument expressions in tp_entries */
- while (ex->ex_class == Oper && ex->OP_OPER == PARCOMMA) {
- fill_arg(ex->OP_RIGHT);
- ex = ex->OP_LEFT;
- }
- fill_arg(ex);
- }
- OutCall.od_valused = used; /* USED, IGNORED or VOIDED */
- }
- fill_arg(e)
- struct expr *e;
- {
- register struct tp_entry *te;
- te = new_tp_entry();
- te->te_type = e->ex_type;
- if (is_cp_cst(e)) {
- te->te_class = Const;
- te->te_value = e->VL_VALUE;
- }
- else {
- te->te_class = !Const;
- te->te_value = (arith) 0;
- }
- te->next = OutCall.od_entry;
- OutCall.od_entry = te;
- OutCall.od_nrargs++;
- }
- #endif LINT
|