--- /dev/null
+#include "../lpass1/lint.h"
+#include "../lpass1/manifest.h"
+#include "inpdef.h"
+#include <ctype.h> /* for efficient definition of isdigit */
+
+#define INP_NPUSHBACK 2
+
+#include <inp_pkg.spec>
+#include <inp_pkg.body>
+
+#define min(a, b) ((a) <= (b) ? (a) : (b))
+#define same_name() !strcmp(cur_name, next_id->id_name)
+
+#define ReadUnsigned ReadInt /* for the time being ??? */
+
+char *cur_name;
+struct inpdef *next_id,
+ *ext_def,
+ *static_def;
+struct inpdef *id_read();
+static int LineNr = 1;
+
+/* Two dangerous macro's. They replace a single statement by
+ * two statements
+ */
+#define loadchar(ch) LoadChar(ch); if (ch=='\n') LineNr++
+#define pushback(ch) PushBack(); if (ch=='\n') LineNr--
+
+
+main(argc, argv)
+ char *argv[];
+{
+ struct inpdef *id;
+
+ init(argc, argv);
+ while (next_id) {
+ cur_name = next_id->id_name;
+ read_defs();
+ while (next_id && same_name()) {
+ id = id_read();
+ check(id);
+ free_inpdef(id);
+ }
+ check_usage();
+ free_defs();
+ }
+}
+
+char options[128];
+static char *table[] = {0};
+
+init(argc, argv)
+ char *argv[];
+{
+/* Prepare standard input for reading using the input-package
+ * Read first inpdef into next_id
+ * Parse options
+ */
+
+ char *result;
+
+ if (!InsertFile((char *)0, table, &result))
+ panic("InsertFile() fails");
+ next_id = new_inpdef();
+ if (get_id(next_id) == EOI) {
+ free_inpdef(next_id);
+ next_id = 0;
+ return;
+ }
+ for (;argc > 1 && *argv[1] == '-'; argc--, argv++)
+ switch (argv[1][1]) {
+ case 'u':
+ /* don't give warnings like "used but not defined"
+ * and "defined but never used"
+ */
+ options[argv[1][1]] = 1;
+ break;
+ default:
+ /* ready to extend */
+ break;
+ }
+}
+
+read_defs()
+{
+ struct inpdef *id;
+
+ while (next_id && same_name() && next_id->id_class <= LVDF) {
+ id = id_read();
+ switch (id->id_class) {
+ case EFDF:
+ case EVDF:
+ if (ext_def) {
+ warning("%s multiply defined", id->id_name);
+ places(id, ext_def);
+ free_inpdef(id);
+ }
+ else {
+ ext_def = id;
+ }
+ break;
+ case SFDF:
+ case SVDF:
+ if (ext_def) {
+ warning("%s multiply defined", id->id_name);
+ places(id, ext_def);
+ free_inpdef(id);
+ }
+ else {
+ static_in_list(id);
+ }
+ break;
+ case LFDF:
+ case LVDF:
+ if (ext_def) {
+ /* Some libraries contain more than one
+ * definition
+ */
+ if ( ext_def->id_class != LFDF
+ && ext_def->id_class != LVDF
+ ) {
+ warning("%s also defined in library",
+ id->id_name);
+ places(id, ext_def);
+ }
+ free_inpdef(id);
+ }
+ else {
+ ext_def = id;
+ }
+ break;
+ default:
+ panic("invalid class (%c) in read_defs", id->id_class);
+ }
+ }
+}
+
+struct inpdef *
+id_read()
+{
+/* Returns the value of next_id if present, 0 otherwise.
+ * Reads a new inpdef ahead, to which next_id will be pointing.
+ * Cur_name will be pointing to id_name of the returned inpdef.
+ */
+ struct inpdef *old_id;
+
+ if (!next_id)
+ return (0);
+ old_id = next_id;
+ cur_name = old_id->id_name;
+ next_id = new_inpdef();
+ if (get_id(next_id) == EOI) {
+ free_inpdef(next_id);
+ cur_name = "";
+ next_id = 0;
+ }
+ return (old_id);
+}
+
+int
+get_id(id)
+ struct inpdef *id;
+{
+/* A low-level function which just reads a definition */
+
+ int eoi;
+
+ if (ReadString(id->id_name, ':', NAMESIZE) == EOI)
+ return (EOI);
+ loadchar(id->id_class);
+ if (id->id_class == EOI)
+ return (EOI);
+ SkipChar(':');
+ if (ReadString(id->id_file, ':', FNAMESIZE) == EOI)
+ return (EOI);
+ if (ReadUnsigned(&id->id_line) == EOI)
+ return (EOI);
+ SkipChar(':');
+ switch (id->id_class) {
+ case EFDF:
+ case SFDF:
+ case LFDF:
+ case FC:
+ if (ReadInt(&id->id_nrargs) == EOI)
+ return (EOI);
+ SkipChar(':');
+ eoi = args_read(
+ (id->id_nrargs < 0 ? -id->id_nrargs-1 : id->id_nrargs),
+ id->id_argtps);
+ if (eoi == EOI)
+ return (EOI);
+ if (ReadInt(&id->id_returns) == EOI)
+ return (EOI);
+ SkipChar(':');
+ break;
+ }
+ return (ReadString(id->id_type, '\n', TYPESIZE));
+}
+
+int
+ReadString(buf, delim, maxsize)
+ char *buf;
+{
+/* Reads a string until 'delim' is encountered.
+ * Delim is discarded.
+ * If 'maxsize-1' is exeded, "string too long" is written by panic().
+ * A '\0' is appended to the string.
+ * At EOI EOI is returned, else the length of the string (including
+ * the appended '\0') is returned.
+ */
+ int ch;
+ int nread = 0;
+
+ while (nread < maxsize - 1) {
+ loadchar(ch);
+ if (ch == EOI)
+ return (EOI);
+ if (ch == delim)
+ break;
+ buf[nread++] = (char)ch;
+ }
+ if (ch != delim) {
+ buf[nread] = '\0';
+ panic("line %d: string too long: %s", LineNr, buf);
+ }
+ buf[nread++] = '\0';
+ return (nread);
+}
+
+int
+ReadInt(ip)
+ int *ip;
+{
+/* Reads a decimal integer until a character which is not
+ * a digit is encountered.
+ * Non-digits except minus-sign in front of the number are discarded.
+ * Doesn't check on overflow.
+ * Just a minus-sign is interpreted as 0. (To prevent a look-ahead.)
+ * At EOI EOI is returned.
+ */
+ int ch;
+ int negative = 0;
+ int i = 0;
+
+ do {
+ loadchar(ch);
+ } /* {} needed because of the loadchar-macro; yack */
+ while (!isdigit(ch) && ch != '-');
+ if (ch == EOI)
+ return (EOI);
+ if (ch == '-')
+ negative = 1;
+ else
+ i = ch - '0';
+ loadchar(ch);
+ while (isdigit(ch)) {
+ i = 10*i + ch - '0';
+ loadchar(ch);
+ }
+ pushback(ch);
+ *ip = negative ? -i : i;
+ return (!EOI);
+}
+
+SkipChar(ch)
+{
+ int c;
+
+ loadchar(c);
+ if (c != ch)
+ panic("line %d: bad format, '%c' expected; '%c' read",
+ LineNr, ch, c);
+}
+
+int
+args_read(nrargs, buf)
+char *buf;
+{
+/* Reads a string into buf with format <type1>:<type2>: ... :<typen>: */
+
+ int i;
+ int charcount = 1;
+ int n;
+
+ *buf = '\0';
+ for (i = 0; i < nrargs; i++) {
+ if ((n = ReadString(buf, ':', ARGTPSSIZE-charcount-1)) == EOI)
+ return (EOI);
+ charcount += n;
+ buf += n - 1;
+ *buf++ = ':';
+ }
+ *buf = '\0';
+ return (!EOI);
+}
+
+struct inpdef *definition();
+
+check(id)
+ struct inpdef *id;
+{
+/* Checks a declaration, function call or variable usage, described by id,
+ * against the definitions.
+ */
+ struct inpdef *idef;
+
+ idef = definition(id);
+ switch (id->id_class) {
+ case EFDC:
+ if (!idef) {
+ uwarning("%s declared but never defined", id->id_name);
+ unewline();
+ discard_defs();
+ break;
+ }
+ if (idef->id_class == EVDF || idef->id_class == LVDF) {
+ warning("%s value declared inconsistently",
+ id->id_name);
+ places(id, idef);
+ break;
+ }
+ if (strcmp(id->id_type, idef->id_type)) {
+ warning("%s value declared inconsistently",
+ id->id_name);
+ places(id, idef);
+ }
+ break;
+ case EVDC:
+ if (!idef) {
+ uwarning("%s declared but never defined", id->id_name);
+ unewline();
+ discard_defs();
+ break;
+ }
+ if (idef->id_class == EFDF || idef->id_class == LFDF) {
+ warning("%s value declared inconsistently",
+ id->id_name);
+ places(id, idef);
+ break;
+ }
+ if (strcmp(id->id_type, idef->id_type)) {
+ warning("%s value declared inconsistently",
+ id->id_name);
+ places(id, idef);
+ }
+ break;
+ case IFDC:
+ if (!idef)
+ break; /* used but not defined */
+ if (idef->id_class == EVDF || idef->id_class == LVDF) {
+ warning("%s value declared inconsistently",
+ id->id_name);
+ places(id, idef);
+ break;
+ }
+ if (strcmp(id->id_type, idef->id_type)) {
+ warning("%s implicitly declared inconsistently",
+ id->id_name);
+ places(id, idef);
+ }
+ break;
+ case FC:
+ case VU:
+ if (!idef) {
+ uwarning("%s used but not defined", id->id_name);
+ unewline();
+ discard_defs();
+ break;
+ }
+ idef->id_called = 1;
+ if (id->id_class == VU)
+ break;
+ check_args(id, idef);
+ if (id->id_returns == USED && !idef->id_returns) {
+ warning("%s value is used, but none is returned",
+ id->id_name);
+ places(id, idef);
+ }
+ switch (id->id_returns) {
+ case USED:
+ idef->id_used = 1;
+ break;
+ case IGNORED:
+ idef->id_ignored = 1;
+ break;
+ case VOIDED:
+ idef->id_voided = 1;
+ break;
+ default:
+ panic("invalid id->id_returns in check");
+ }
+ break;
+ default:
+ panic("invalid class (%c) in check", id->id_class);
+ break;
+ }
+}
+
+discard_defs()
+{
+/* Read until a definition having another name */
+
+ struct inpdef *id;
+
+ while (next_id && same_name()) {
+ id = id_read();
+ free_inpdef(id);
+ }
+}
+
+check_args(id, idef)
+ struct inpdef *id, *idef;
+{
+ register char *argtps1 = id->id_argtps;
+ register char *argtps2 = idef->id_argtps;
+ int i, n, varargs = 0;
+
+ if (idef->id_nrargs < 0) {
+ varargs = 1;
+ n = -idef->id_nrargs - 1;
+ }
+ else {
+ n = idef->id_nrargs;
+ }
+ if (varargs) {
+ if (n > id->id_nrargs) {
+ warning("%s variable # of args", id->id_name);
+ places(id, idef);
+ n = id->id_nrargs;
+ }
+ }
+ else {
+ if (n != id->id_nrargs) {
+ warning("%s variable # of args", id->id_name);
+ places(id, idef);
+ n = min(n, id->id_nrargs);
+ }
+ }
+ for (i = 1; i <= n; i++) {
+ while (*argtps1 == *argtps2 && *argtps1 != ':') {
+ argtps1++;
+ argtps2++;
+ }
+ if (*argtps1 != *argtps2) {
+ warning("%s, arg %d used inconsistently",
+ id->id_name, i);
+ places(id, idef);
+ }
+ while (*argtps1++ != ':') ;
+ while (*argtps2++ != ':') ;
+ }
+}
+
+check_usage()
+{
+/* Checks if the defined function or variable is used.
+ * There can be several static definitions.
+ */
+
+ struct inpdef *sd = static_def;
+
+ if (ext_def)
+ check_def(ext_def);
+ while (sd) {
+ check_def(sd);
+ sd = sd->next;
+ }
+}
+
+check_def(id)
+ struct inpdef *id;
+{
+ if ( !id->id_called && strcmp(id->id_name, "main")
+ && ext_def->id_class != LFDF
+ && ext_def->id_class != LVDF
+ ) {
+ uwarning("%s defined (%s(%u)) but never used",
+ id->id_name, id->id_file, id->id_line);
+ unewline();
+ }
+ if ( id->id_class == EFDF
+ || id->id_class == SFDF
+ || id->id_class == LFDF
+ ) {
+ if (id->id_returns && id->id_called && id->id_ignored) {
+ warning("%s returns value which is %s ignored",
+ id->id_name,
+ id->id_used || id->id_voided ?
+ "sometimes" : "always");
+ newline();
+ }
+ }
+}
+
+static_in_list(id)
+ struct inpdef *id;
+{
+/* Put id in the list of static definitions.
+ * static_def points to the first element.
+ */
+ id->next = static_def;
+ static_def = id;
+}
+
+struct inpdef *
+definition(id)
+ struct inpdef *id;
+{
+/* If there is a static definition that comes from the same file, a pointer
+ * to this definition will be returned.
+ * Otherwise a pointer to the ext_def is returned (which may be null).
+ */
+ struct inpdef *sd = static_def;
+
+ while (sd) {
+ if (!strcmp(id->id_file, sd->id_file))
+ return (sd);
+ sd = sd->next;
+ }
+ return (ext_def);
+}
+
+free_defs()
+{
+/* Dispose the external definition and the static definitions. */
+ struct inpdef *sd;
+
+ if (ext_def) {
+ free_inpdef(ext_def);
+ ext_def = 0;
+ }
+ while (static_def) {
+ sd = static_def;
+ static_def = static_def->next;
+ free_inpdef(sd);
+ }
+}
+
+#include "../lpass1/errout.h" /* for definition of ERROUT */
+
+places(id1, id2)
+ struct inpdef *id1, *id2;
+{
+ fprint(ERROUT, "\t%s(%u) :: %s(%u)\n",
+ id1->id_file, id1->id_line, id2->id_file, id2->id_line);
+}
+
+/* VARARGS1 */
+warning(fmt, args)
+ char *fmt;
+{
+ doprnt(ERROUT, fmt, &args);
+}
+
+/* VARARGS1 */
+uwarning(fmt, args)
+ char *fmt;
+{
+ if (!options['u'])
+ doprnt(ERROUT, fmt, &args);
+}
+
+newline()
+{
+ fprint(ERROUT, "\n");
+}
+
+unewline()
+{
+ if (!options['u'])
+ fprint(ERROUT, "\n");
+}
+
+/* VARARGS1 */
+panic(fmt, args)
+ char *fmt;
+{
+ fprint(ERROUT, "PANIC: ");
+ doprnt(ERROUT, fmt, &args);
+ fprint(ERROUT, "\n");
+ exit(1);
+}
+
+/* for DEBUGGING */
+print_id(id)
+ struct inpdef *id;
+{
+ print("%c, %s, %s, %u, %d, %s, %d, %s\n",
+ id->id_class,
+ id->id_name,
+ id->id_file,
+ id->id_line,
+ id->id_nrargs,
+ ((id->id_nrargs == 0) ? "" : id->id_argtps),
+ id->id_returns,
+ id->id_type);
+}
public / ack.git / commitdiff