Return to attributes.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / pascal / pdx / sym

Annotation of 43BSDTahoe/ucb/pascal/pdx/sym/attributes.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1980 Regents of the University of California.
                      3:  * All rights reserved.  The Berkeley software License Agreement
                      4:  * specifies the terms and conditions for redistribution.
                      5:  */
                      6: 
                      7: #ifndef lint
                      8: static char sccsid[] = "@(#)attributes.c       5.1 (Berkeley) 6/6/85";
                      9: #endif not lint
                     10: 
                     11: /*
                     12:  * Functions to return the attributes of a symbol.
                     13:  */
                     14: 
                     15: #include "defs.h"
                     16: #include "sym.h"
                     17: #include "process.h"
                     18: #include "btypes.h"
                     19: #include "classes.h"
                     20: #include "sym.rep"
                     21: 
                     22: char *name(s)
                     23: SYM *s;
                     24: {
                     25:        return s->symbol;
                     26: }
                     27: 
                     28: int toknum(s)
                     29: SYM *s;
                     30: {
                     31:        return s->symvalue.token.toknum;
                     32: }
                     33: 
                     34: int tokval(s)
                     35: SYM *s;
                     36: {
                     37:        return s->symvalue.token.tokval;
                     38: }
                     39: 
                     40: ADDRESS codeloc(f)
                     41: SYM *f;
                     42: {
                     43:        if (f == NIL) {
                     44:                panic("codeloc: nil symbol");
                     45:        }
                     46:        if (!isblock(f)) {
                     47:                panic("codeloc: %s is not a block", f->symbol);
                     48:        }
                     49:        return f->symvalue.funcv.codeloc;
                     50: }
                     51: 
                     52: /*
                     53:  * Rtype returns the "reduced type" given a variable.
                     54:  * The idea is to remove type names so we can check the class.
                     55:  */
                     56: 
                     57: SYM *rtype(t)
                     58: register SYM *t;
                     59: {
                     60:        while (t->class == TYPE) {
                     61:                t = t->type;
                     62:        }
                     63:        return t;
                     64: }
                     65: 
                     66: /*
                     67:  * Return the SYM that contains the given SYM.
                     68:  */
                     69: 
                     70: SYM *container(s)
                     71: SYM *s;
                     72: {
                     73:        return s->func;
                     74: }
                     75: 
                     76: /*
                     77:  * Return a pointer to the string for the name of the class that
                     78:  * the given symbol belongs to.
                     79:  */
                     80: 
                     81: LOCAL char *clname[] = {
                     82:        "bad use", "constant", "type", "variable", "array", "fileptr",
                     83:        "record", "field", "procedure", "function", "funcvar",
                     84:        "ref", "pointer", "file", "set", "range", "label", "withptr",
                     85:        "scalar", "string", "program", "improper", "variant",
                     86:        "procparam", "funcparam",
                     87: };
                     88: 
                     89: char *classname(s)
                     90: SYM *s;
                     91: {
                     92:        return clname[s->class];
                     93: }
                     94: 
                     95: /*
                     96:  * size finds the size in bytes of the given type
                     97:  */
                     98: 
                     99: #define MINCHAR -128
                    100: #define MAXCHAR 127
                    101: #define MINSHORT -32768
                    102: #define MAXSHORT 32767
                    103: 
                    104: int size(t)
                    105: register SYM *t;
                    106: {
                    107:        long lower, upper;
                    108: 
                    109:        t = rtype(t);
                    110:        if (t == t_real) {
                    111:                return sizeof(double);
                    112:        }
                    113:        switch(t->class) {
                    114:                case RANGE:
                    115:                        lower = t->symvalue.rangev.lower;
                    116:                        upper = t->symvalue.rangev.upper;
                    117:                        if (lower >= MINCHAR && upper <= MAXCHAR) {
                    118:                                return sizeof(char);
                    119:                        } else if (lower >= MINSHORT && upper <= MAXSHORT) {
                    120:                                return sizeof(short);
                    121:                        } else {
                    122:                                return sizeof(long);
                    123:                        }
                    124:                        /* NOTREACHED */
                    125: 
                    126:                case ARRAY: {
                    127:                        register int nel, elsize;
                    128:                        register SYM *s;
                    129: 
                    130:                        elsize = size(t->type);
                    131:                        nel = 1;
                    132:                        for (t = t->chain; t != NIL; t = t->chain) {
                    133:                                s = rtype(t);
                    134:                                lower = s->symvalue.rangev.lower;
                    135:                                upper = s->symvalue.rangev.upper;
                    136:                                nel *= (upper-lower+1);
                    137:                        }
                    138:                        return nel*elsize;
                    139:                }
                    140: 
                    141:                case CONST:
                    142:                case VAR:
                    143:                case FVAR:
                    144:                case FIELD:
                    145:                        return size(t->type);
                    146: 
                    147:                case RECORD:
                    148:                        return t->symvalue.offset;
                    149: 
                    150:                case PTR:
                    151:                case REF:
                    152:                case FILET:
                    153:                        return sizeof(int);
                    154: 
                    155:                case SCAL:
                    156:                        if (t->symvalue.iconval > 255) {
                    157:                                return sizeof(short);
                    158:                        } else {
                    159:                                return sizeof(char);
                    160:                        }
                    161:                        /* NOTREACHED */
                    162: 
                    163:                case FPROC:
                    164:                case FFUNC:
                    165:                        return sizeof(ADDRESS *);
                    166: 
                    167:                default:
                    168:                        if (t->class < BADUSE || t->class > FFUNC) {
                    169:                                panic("size: bad class (%d)", t->class);
                    170:                        } else {
                    171:                                error("improper operation on a %s", classname(t));
                    172:                        }
                    173:                        /* NOTREACHED */
                    174:        }
                    175: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.