Fixes for '#ifndef file_h' -- trim off the path prefix and translate all

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

diff --git a/usr/src/old/dbx/symbols.c b/usr/src/old/dbx/symbols.c
index a2e6f7b..3060f55 100644 (file)
--- a/usr/src/old/dbx/symbols.c
+++ b/usr/src/old/dbx/symbols.c
@@ -1,8 +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.
+ */

 
 

-static char sccsid[] = "@(#)symbols.c  1.17 (Berkeley) %G%";
+#ifndef lint
+static char sccsid[] = "@(#)symbols.c  5.4 (Berkeley) %G%";
+#endif not lint

 
 

-static char rcsid[] = "$Header: symbols.c,v 1.6 84/12/26 10:42:31 linton Exp $";
+static char rcsid[] = "$Header: symbols.c,v 1.3 87/03/26 23:17:35 donn Exp $";

 
 /*
  * Symbol management.
 
 /*
  * Symbol management.


@@ -35,7 +41,8 @@ typedef struct Symbol *Symbol;
  */
 
 typedef enum {
  */
 
 typedef enum {

-    BADUSE, CONST, TYPE, VAR, ARRAY, DYNARRAY, SUBARRAY, PTRFILE, RECORD, FIELD,
+    BADUSE, CONST, TYPE, VAR, ARRAY, OPENARRAY, DYNARRAY, SUBARRAY,
+    PTRFILE, RECORD, FIELD,

     PROC, FUNC, FVAR, REF, PTR, FILET, SET, RANGE, 
     LABEL, WITHPTR, SCAL, STR, PROG, IMPROPER, VARNT,
     FPROC, FFUNC, MODULE, TAG, COMMON, EXTREF, TYPEREF
     PROC, FUNC, FVAR, REF, PTR, FILET, SET, RANGE, 
     LABEL, WITHPTR, SCAL, STR, PROG, IMPROPER, VARNT,
     FPROC, FFUNC, MODULE, TAG, COMMON, EXTREF, TYPEREF


@@ -43,11 +50,18 @@ typedef enum {
 
 typedef enum { R_CONST, R_TEMP, R_ARG, R_ADJUST } Rangetype; 
 
 
 typedef enum { R_CONST, R_TEMP, R_ARG, R_ADJUST } Rangetype; 
 

+#define INREG 0
+#define STK 1
+#define EXT 2
+
+typedef unsigned integer Storage;
+

 struct Symbol {
     Name name;
     Language language;
     Symclass class : 8;
 struct Symbol {
     Name name;
     Language language;
     Symclass class : 8;

-    Integer level : 8;
+    Storage storage : 2;
+    unsigned int level : 6;    /* for variables stored on stack only */

     Symbol type;
     Symbol chain;
     union {
     Symbol type;
     Symbol chain;
     union {


@@ -119,6 +133,8 @@ boolean showaggrs;
 #define nosource(f) (not (f)->symvalue.funcv.src)
 #define isinline(f) ((f)->symvalue.funcv.inline)
 
 #define nosource(f) (not (f)->symvalue.funcv.src)
 #define isinline(f) ((f)->symvalue.funcv.inline)
 

+#define isreg(s)               (s->storage == INREG)
+

 #include "tree.h"
 
 /*
 #include "tree.h"
 
 /*


@@ -141,19 +157,21 @@ boolean showaggrs;
 
 /*
  * Symbol table structure currently does not support deletions.
 
 /*
  * Symbol table structure currently does not support deletions.

+ * Hash table size is a power of two to make hashing faster.
+ * Using a non-prime is ok since we aren't doing rehashing.

  */
 
  */
 

-#define HASHTABLESIZE 2003
+#define HASHTABLESIZE 8192

 
 private Symbol hashtab[HASHTABLESIZE];
 
 
 private Symbol hashtab[HASHTABLESIZE];
 

-#define hash(name) ((((unsigned) name) >> 2) mod HASHTABLESIZE)
+#define hash(name) ((((unsigned) name) >> 2) & (HASHTABLESIZE - 1))

 
 /*
  * Allocate a new symbol.
  */
 
 
 /*
  * Allocate a new symbol.
  */
 

-#define SYMBLOCKSIZE 100
+#define SYMBLOCKSIZE 1000

 
 typedef struct Sympool {
     struct Symbol sym[SYMBLOCKSIZE];
 
 typedef struct Sympool {
     struct Symbol sym[SYMBLOCKSIZE];


@@ -169,7 +187,7 @@ public Symbol symbol_alloc()
 
     if (nleft <= 0) {
        newpool = new(Sympool);
 
     if (nleft <= 0) {
        newpool = new(Sympool);

-       bzero(newpool, sizeof(newpool));
+       bzero(newpool, sizeof(*newpool));

        newpool->prevpool = sympool;
        sympool = newpool;
        nleft = SYMBLOCKSIZE;
        newpool->prevpool = sympool;
        sympool = newpool;
        nleft = SYMBLOCKSIZE;


@@ -232,6 +250,7 @@ Symbol chain;
     s = symbol_alloc();
     s->name = name;
     s->language = primlang;
     s = symbol_alloc();
     s->name = name;
     s->language = primlang;

+    s->storage = EXT;

     s->level = blevel;
     s->class = class;
     s->type = type;
     s->level = blevel;
     s->class = class;
     s->type = type;


@@ -505,7 +524,7 @@ Symbol s;
     integer r;
 
     checkref(s);
     integer r;
 
     checkref(s);

-    if (s->level < 0) {
+    if (s->storage == INREG) {

        r = s->symvalue.offset;
     } else {
        r = -1;
        r = s->symvalue.offset;
     } else {
        r = -1;


@@ -541,10 +560,9 @@ Symbol s;
  *     register        - offset is register number
  */
 
  *     register        - offset is register number
  */
 

-#define isglobal(s)            (s->level == 1)
-#define islocaloff(s)          (s->level >= 2 and s->symvalue.offset < 0)
-#define isparamoff(s)          (s->level >= 2 and s->symvalue.offset >= 0)
-#define isreg(s)               (s->level < 0)
+#define isglobal(s)            (s->storage == EXT)
+#define islocaloff(s)          (s->storage == STK and s->symvalue.offset < 0)
+#define isparamoff(s)          (s->storage == STK and s->symvalue.offset >= 0)

 
 public Address address (s, frame)
 Symbol s;
 
 public Address address (s, frame)
 Symbol s;


@@ -603,7 +621,8 @@ integer r;
     s = insert(n);
     s->language = t_addr->language;
     s->class = VAR;
     s = insert(n);
     s->language = t_addr->language;
     s->class = VAR;

-    s->level = -3;
+    s->storage = INREG;
+    s->level = 3;

     s->type = t_addr;
     s->symvalue.offset = r;
 }
     s->type = t_addr;
     s->symvalue.offset = r;
 }


@@ -749,6 +768,7 @@ Symbol sym;
            r = nel*elsize;
            break;
 
            r = nel*elsize;
            break;
 

+       case OPENARRAY:

        case DYNARRAY:
            r = (t->symvalue.ndims + 1) * sizeof(Word);
            break;
        case DYNARRAY:
            r = (t->symvalue.ndims + 1) * sizeof(Word);
            break;


@@ -775,9 +795,16 @@ Symbol sym;
            break;
 
        case TYPE:
            break;
 
        case TYPE:

+           /*
+            * This causes problems on the IRIS because of the compiler bug
+            * with stab offsets for parameters.  Not sure it's really
+            * necessary anyway.
+            */
+#          ifndef IRIS

            if (t->type->class == PTR and t->type->type->class == BADUSE) {
                findtype(t);
            }
            if (t->type->class == PTR and t->type->type->class == BADUSE) {
                findtype(t);
            }

+#          endif

            r = size(t->type);
            break;
 
            r = size(t->type);
            break;
 


@@ -878,7 +905,7 @@ Symbol s;
 
     if (s->class == REF) {
        t = rtype(s->type);
 
     if (s->class == REF) {
        t = rtype(s->type);

-       if (t->class == DYNARRAY) {
+       if (t->class == OPENARRAY) {

            r = (t->symvalue.ndims + 1) * sizeof(Word);
        } else if (t->class == SUBARRAY) {
            r = (2 * t->symvalue.ndims + 1) * sizeof(Word);
            r = (t->symvalue.ndims + 1) * sizeof(Word);
        } else if (t->class == SUBARRAY) {
            r = (2 * t->symvalue.ndims + 1) * sizeof(Word);


@@ -918,7 +945,7 @@ Symbol type;
     Symbol t;
 
     t = rtype(type);
     Symbol t;
 
     t = rtype(type);

-    return (boolean) (t->class == DYNARRAY);
+    return (boolean) (t->class == OPENARRAY);

 }
 
 /*
 }
 
 /*


@@ -1044,17 +1071,17 @@ register Symbol t1, t2;
        b = isblock(t2);
     } else if (t2 == procsym) {
        b = isblock(t1);
        b = isblock(t2);
     } else if (t2 == procsym) {
        b = isblock(t1);

-    } else if (t1->language == primlang) {
-       if (t2->language == primlang) {
-           b = primlang_typematch(rtype(t1), rtype(t2));
-       } else {
-           b = (boolean) (*language_op(t2->language, L_TYPEMATCH))(t1, t2);
-       }
-    } else if (t2->language == primlang) {
-       b = (boolean) (*language_op(t1->language, L_TYPEMATCH))(t1, t2);

     } else if (t1->language == nil) {
        if (t2->language == nil) {
            b = false;
     } else if (t1->language == nil) {
        if (t2->language == nil) {
            b = false;

+       } else if (t2->language == primlang) {
+           b = (boolean) primlang_typematch(rtype(t1), rtype(t2));
+       } else {
+           b = (boolean) (*language_op(t2->language, L_TYPEMATCH))(t1, t2);
+       }
+    } else if (t1->language == primlang) {
+       if (t2->language == primlang or t2->language == nil) {
+           b = primlang_typematch(rtype(t1), rtype(t2));

        } else {
            b = (boolean) (*language_op(t2->language, L_TYPEMATCH))(t1, t2);
        }
        } else {
            b = (boolean) (*language_op(t2->language, L_TYPEMATCH))(t1, t2);
        }