cleanup, add manual pages

[unix-history] / usr / src / old / dbx / printsym.c

diff --git a/usr/src/old/dbx/printsym.c b/usr/src/old/dbx/printsym.c
index b37d034..3bf9531 100644 (file)
--- a/usr/src/old/dbx/printsym.c
+++ b/usr/src/old/dbx/printsym.c
@@ -1,6 +1,14 @@
-/* Copyright (c) 1982 Regents of the University of California */
+/*
+ * Copyright (c) 1983 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)printsym.c 5.5 (Berkeley) %G%";
+#endif not lint

 
 

-static char sccsid[] = "@(#)printsym.c 1.12 %G%";
+static char rcsid[] = "$Header: printsym.c,v 1.4 87/04/15 00:23:35 donn Exp $";

 
 /*
  * Printing of symbolic information.
 
 /*
  * Printing of symbolic information.


@@ -17,7 +25,9 @@ static char sccsid[] = "@(#)printsym.c 1.12 %G%";
 #include "runtime.h"
 #include "machine.h"
 #include "names.h"
 #include "runtime.h"
 #include "machine.h"
 #include "names.h"

+#include "keywords.h"

 #include "main.h"
 #include "main.h"

+#include <ctype.h>

 
 #ifndef public
 #endif
 
 #ifndef public
 #endif


@@ -37,11 +47,12 @@ static char sccsid[] = "@(#)printsym.c 1.12 %G%";
  */
 
 private String clname[] = {
  */
 
 private String clname[] = {

-    "bad use", "constant", "type", "variable", "array", "fileptr",
-    "record", "field", "procedure", "function", "funcvar",
+    "bad use", "constant", "type", "variable", "array", "array",
+    "dynarray", "subarray", "fileptr", "record", "field",
+    "procedure", "function", "funcvar",

     "ref", "pointer", "file", "set", "range", "label", "withptr",
     "scalar", "string", "program", "improper", "variant",
     "ref", "pointer", "file", "set", "range", "label", "withptr",
     "scalar", "string", "program", "improper", "variant",

-    "procparam", "funcparam", "module", "tag", "common", "typeref"
+    "procparam", "funcparam", "module", "tag", "common", "extref", "typeref"

 };
 
 public String classname(s)
 };
 
 public String classname(s)


@@ -58,7 +69,9 @@ public printentry(s)
 Symbol s;
 {
     if (s != program) {
 Symbol s;
 {
     if (s != program) {

-       printf("\nentering %s %s\n", classname(s), symname(s));
+       printf("\nentering %s ", classname(s));
+       printname(stdout, s);
+       printf("\n");

     }
 }
 
     }
 }
 


@@ -70,7 +83,9 @@ public printexit(s)
 Symbol s;
 {
     if (s != program) {
 Symbol s;
 {
     if (s != program) {

-       printf("leaving %s %s\n\n", classname(s), symname(s));
+       printf("leaving %s ", classname(s));
+       printname(stdout, s);
+       printf("\n\n");

     }
 }
 
     }
 }
 


@@ -81,9 +96,12 @@ Symbol s;
 public printcall(s, t)
 Symbol s, t;
 {
 public printcall(s, t)
 Symbol s, t;
 {

-    printf("calling %s", symname(s));
+    printf("calling ");
+    printname(stdout, s);

     printparams(s, nil);
     printparams(s, nil);

-    printf(" from %s %s\n", classname(t), symname(t));
+    printf(" from %s ", classname(t));
+    printname(stdout, t);
+    printf("\n");

 }
 
 /*
 }
 
 /*


@@ -112,12 +130,17 @@ Symbol s;
            printf("(value too large) ");
        }
     }
            printf("(value too large) ");
        }
     }

-    printf("from %s\n", symname(s));
+    printf("from ");
+    printname(stdout, s);
+    printf("\n");

 }
 
 /*
  * Print the values of the parameters of the given procedure or function.
  * The frame distinguishes recursive instances of a procedure.
 }
 
 /*
  * Print the values of the parameters of the given procedure or function.
  * The frame distinguishes recursive instances of a procedure.

+ *
+ * If the procedure or function is internal, the argument count is
+ * not valid so we ignore it.

  */
 
 public printparams(f, frame)
  */
 
 public printparams(f, frame)


@@ -128,18 +151,25 @@ Frame frame;
     int n, m, s;
 
     n = nargspassed(frame);
     int n, m, s;
 
     n = nargspassed(frame);

+    if (isinternal(f)) {
+       n = 0;
+    }
+    printf("(");

     param = f->chain;
     if (param != nil or n > 0) {
     param = f->chain;
     if (param != nil or n > 0) {

-       printf("(");

        m = n;
        if (param != nil) {
            for (;;) {
        m = n;
        if (param != nil) {
            for (;;) {

-               s = size(param) div sizeof(Word);
+               s = psize(param) div sizeof(Word);

                if (s == 0) {
                    s = 1;
                }
                m -= s;
                if (s == 0) {
                    s = 1;
                }
                m -= s;

-               printv(param, frame);
+               if (showaggrs) {
+                   printv(param, frame);
+               } else {
+                   printparamv(param, frame);
+               }

                param = param->chain;
            if (param == nil) break;
                printf(", ");
                param = param->chain;
            if (param == nil) break;
                printf(", ");


@@ -159,8 +189,8 @@ Frame frame;
                printf(", ");
            }
        }
                printf(", ");
            }
        }

-       printf(")");

     }
     }

+    printf(")");

 }
 
 /*
 }
 
 /*


@@ -207,6 +237,43 @@ Symbol s;
     return b;
 }
 
     return b;
 }
 

+/*
+ * Print out a parameter value.
+ *
+ * Since this is intended to be printed on a single line with other information
+ * aggregate values are not printed.
+ */
+
+public printparamv (p, frame)
+Symbol p;
+Frame frame;
+{
+    Symbol t;
+
+    t = rtype(p->type);
+    switch (t->class) {
+       case ARRAY:
+       case OPENARRAY:
+       case DYNARRAY:
+       case SUBARRAY:
+           t = rtype(t->type);
+           if (compatible(t, t_char)) {
+               printv(p, frame);
+           } else {
+               printf("%s = (...)", symname(p));
+           }
+           break;
+
+       case RECORD:
+           printf("%s = (...)", symname(p));
+           break;
+
+       default:
+           printv(p, frame);
+           break;
+    }
+}
+

 /*
  * Print the name and value of a variable.
  */
 /*
  * Print the name and value of a variable.
  */


@@ -224,24 +291,22 @@ Frame frame;
     } else {
        printf("%s = ", symname(s));
     }
     } else {
        printf("%s = ", symname(s));
     }

-    if(s->type->class == ARRAY && (! istypename(s->type->type,"char")) ) {
-       printf(" ARRAY ");
+    if (isvarparam(s) and not isopenarray(s)) {
+       rpush(address(s, frame), sizeof(Address));
+       addr = pop(Address);

     } else {
     } else {

-       if (isvarparam(s)) {
-          rpush(address(s, frame), sizeof(Address));
-          addr = pop(Address);
-          len = size(s->type);
-       } else {
-          addr = address(s, frame);
-          len = size(s);
-       }
-       if (canpush(len)) {
-          rpush(addr, len);
-          printval(s->type);
-       } else {
-          printf("*** expression too large ***");
-       }
-   }
+       addr = address(s, frame);
+    }
+    len = size(s);
+    if (not canpush(len)) {
+       printf("*** expression too large ***");
+    } else if (isreg(s)) {
+       push(Address, addr);
+       printval(s->type);
+    } else {
+       rpush(addr, len);
+       printval(s->type);
+    }

 }
 
 /*
 }
 
 /*


@@ -254,6 +319,8 @@ Symbol s;
 {
     if (s == nil) {
        fprintf(f, "(noname)");
 {
     if (s == nil) {
        fprintf(f, "(noname)");

+    } else if (s == program) {
+       fprintf(f, ".");

     } else if (isredirected() or isambiguous(s)) {
        printwhich(f, s);
     } else {
     } else if (isredirected() or isambiguous(s)) {
        printwhich(f, s);
     } else {


@@ -318,8 +385,15 @@ Symbol s;
 public printdecl(s)
 Symbol s;
 {
 public printdecl(s)
 Symbol s;
 {

+    Language lang;
+

     checkref(s);
     checkref(s);

-    (*language_op(s->language, L_PRINTDECL))(s);
+    if (s->language == nil or s->language == primlang) {
+       lang = findlanguage(".s");
+    } else {
+       lang = s->language;
+    }
+    (*language_op(lang, L_PRINTDECL))(s);

 }
 
 /*
 }
 
 /*


@@ -342,19 +416,31 @@ Symbol s;
        printf(" (%s)", symname(s->chain));
     }
     printf("\nblock\t0x%x", s->block);
        printf(" (%s)", symname(s->chain));
     }
     printf("\nblock\t0x%x", s->block);

-    if (s->block->name != nil) {
+    if (s->block != nil and s->block->name != nil) {

        printf(" (");
        printname(stdout, s->block);
        putchar(')');
     }
     putchar('\n');
     switch (s->class) {
        printf(" (");
        printname(stdout, s->block);
        putchar(')');
     }
     putchar('\n');
     switch (s->class) {

+       case TYPE:
+           printf("size\t%d\n", size(s));
+           break;
+

        case VAR:
        case REF:
        case VAR:
        case REF:

-           if (s->level >= 3) {
-               printf("address\t0x%x\n", s->symvalue.offset);
-           } else {
-               printf("offset\t%d\n", s->symvalue.offset);
+           switch (s->storage) {
+               case INREG:
+                   printf("reg\t%d\n", s->symvalue.offset);
+                   break;
+
+               case STK:
+                   printf("offset\t%d\n", s->symvalue.offset);
+                   break;
+
+               case EXT:
+                   printf("address\t0x%x\n", s->symvalue.offset);
+                   break;

            }
            printf("size\t%d\n", size(s));
            break;
            }
            printf("size\t%d\n", size(s));
            break;


@@ -384,7 +470,6 @@ Symbol s;
            break;
 
        case RANGE:
            break;
 
        case RANGE:

-

            prangetype(s->symvalue.rangev.lowertype);
            printf("lower\t%d\n", s->symvalue.rangev.lower);
            prangetype(s->symvalue.rangev.uppertype);
            prangetype(s->symvalue.rangev.lowertype);
            printf("lower\t%d\n", s->symvalue.rangev.lower);
            prangetype(s->symvalue.rangev.uppertype);


@@ -429,6 +514,9 @@ Symbol t;
     Symbol s;
 
     checkref(t);
     Symbol s;
 
     checkref(t);

+    if (t->class == TYPEREF) {
+       resolveRef(t);
+    }

     switch (t->class) {
        case PROC:
        case FUNC:
     switch (t->class) {
        case PROC:
        case FUNC:


@@ -437,8 +525,8 @@ Symbol t;
            break;
 
        default:
            break;
 
        default:

-           if (t->language == nil) {
-               error("unknown language");
+           if (t->language == nil or t->language == primlang) {
+               (*language_op(findlanguage(".c"), L_PRINTVAL))(t);

            } else {
                (*language_op(t->language, L_PRINTVAL))(t);
            }
            } else {
                (*language_op(t->language, L_PRINTVAL))(t);
            }


@@ -453,33 +541,41 @@ Symbol t;
 public printrecord(s)
 Symbol s;
 {
 public printrecord(s)
 Symbol s;
 {

+    Symbol f;
+

     if (s->chain == nil) {
        error("record has no fields");
     }
     printf("(");
     sp -= size(s);
     if (s->chain == nil) {
        error("record has no fields");
     }
     printf("(");
     sp -= size(s);

-    printfield(s->chain);
+    f = s->chain;
+    if (f != nil) {
+       for (;;) {
+           printfield(f);
+           f = f->chain;
+       if (f == nil) break;
+           printf(", ");
+       }
+    }

     printf(")");
 }
 
 /*
     printf(")");
 }
 
 /*

- * Print out a field, first printing out other fields.
- * This is done because the fields are chained together backwards.
+ * Print out a field.

  */
 
  */
 

-private printfield(s)
-Symbol s;
+private printfield(f)
+Symbol f;

 {
     Stack *savesp;
 {
     Stack *savesp;

+    register int off, len;

 
 

-    if (s->chain != nil) {
-       printfield(s->chain);
-       printf(", ");
-    }
-    printf("%s = ", symname(s));
+    printf("%s = ", symname(f));

     savesp = sp;
     savesp = sp;

-    sp += ((s->symvalue.field.offset div BITSPERBYTE) + size(s->type));
-    printval(s);
+    off = f->symvalue.field.offset;
+    len = f->symvalue.field.length;
+    sp += ((off + len + BITSPERBYTE - 1) div BITSPERBYTE);
+    printval(f);

     sp = savesp;
 }
 
     sp = savesp;
 }
 


@@ -538,7 +634,11 @@ double r;
     extern char *index();
     char buf[256];
 
     extern char *index();
     char buf[256];
 

-    sprintf(buf, "%g", r);
+#   ifdef IRIS
+       sprintf(buf, "%lg", r);
+#   else
+       sprintf(buf, "%g", r);
+#   endif

     if (buf[0] == '.') {
        printf("0%s", buf);
     } else if (buf[0] == '-' and buf[1] == '.') {
     if (buf[0] == '.') {
        printf("0%s", buf);
     } else if (buf[0] == '-' and buf[1] == '.') {


@@ -567,7 +667,113 @@ char c;
     } else if (c > 0 and c < ' ') {
        putchar('^');
        putchar(c - 1 + 'A');
     } else if (c > 0 and c < ' ') {
        putchar('^');
        putchar(c - 1 + 'A');

-    } else {
+    } else if (c >= ' ' && c <= '~') {

        putchar(c);
        putchar(c);

+    } else {
+       printf("\\0%o",c&0xff);
+    }
+}
+
+/*
+ * Print out a value for a range type (integer, char, or boolean).
+ */
+
+public printRangeVal (val, t)
+long val;
+Symbol t;
+{
+    if (t == t_boolean->type or istypename(t->type, "boolean")) {
+       if ((boolean) val) {
+           printf("true");
+       } else {
+           printf("false");
+       }
+    } else if (t == t_char->type or istypename(t->type, "char")) {
+       if (varIsSet("$hexchars")) {
+           printf("0x%lx", val);
+       } else {
+           putchar('\'');
+           printchar(val);
+           putchar('\'');
+       }
+    } else if (varIsSet("$hexints")) {
+       printf("0x%lx", val);
+    } else if (t->symvalue.rangev.lower >= 0) {
+       printf("%lu", val);
+    } else {
+       printf("%ld", val);
+    }
+}
+
+/*
+ * Print out an enumerated value by finding the corresponding
+ * name in the enumeration list.
+ */
+
+public printEnum (i, t)
+integer i;
+Symbol t;
+{
+    register Symbol e;
+
+    e = t->chain;
+    while (e != nil and e->symvalue.constval->value.lcon != i) {
+       e = e->chain;
+    }
+    if (e != nil) {
+       printf("%s", symname(e));
+    } else {
+       printf("%d", i);
+    }
+}
+
+/*
+ * Print out a null-terminated string (pointer to char)
+ * starting at the given address.
+ */
+
+public printString (addr, quotes)
+Address addr;
+boolean quotes;
+{
+    register Address a;
+    register integer i, len;
+    register boolean endofstring;
+    register int unprintables;
+#define        MAXGARBAGE      4
+    union {
+       char ch[sizeof(Word)];
+       int word;
+    } u;
+
+    if (varIsSet("$hexstrings")) {
+       printf("0x%x", addr);
+    } else {
+       if (quotes) {
+           putchar('"');
+       }
+       a = addr;
+       unprintables = 0;
+       endofstring = false;
+       while (not endofstring) {
+           dread(&u, a, sizeof(u));
+           i = 0;
+           do {
+               if (u.ch[i] == '\0') {
+                   endofstring = true;
+               } else {
+                   printchar(u.ch[i]);
+                   if (!isascii(u.ch[i]) and ++unprintables > MAXGARBAGE) {
+                       endofstring = true;
+                       printf("...");
+                   }
+               }
+               ++i;
+           } while (i < sizeof(Word) and not endofstring);
+           a += sizeof(Word);
+       }
+       if (quotes) {
+           putchar('"');
+       }

     }
 }
     }
 }