Return to size.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / c / n0

Annotation of coherent/b/bin/c/n0/size.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * n0/size.c
                      3:  * C compiler.
                      4:  * sizeof(thing) computation for symbols and trees.
                      5:  */
                      6: 
                      7: #ifdef   vax
                      8: #include "INC$LIB:cc0.h"
                      9: #else
                     10: #include "cc0.h"
                     11: #endif
                     12: 
                     13: /*
                     14:  * Given a pointer to a symbol table entry,
                     15:  * return the size of the object in "bytes".
                     16:  */
                     17: sizeof_t
                     18: ssize(sp) register SYM *sp;
                     19: {
                     20:        register sizeof_t n;
                     21:        n = tidsize(sp->s_type, sp->s_ip, sp->s_dp, 1);
                     22:        if (n == 0 && sp->s_class == C_GREF)
                     23:                sizewarn(sp->s_id, 0);
                     24:        return n;
                     25: }
                     26: 
                     27: /*
                     28:  * Much like ssize, but takes a tree node pointer
                     29:  * rather than a symbol table entry pointer.
                     30:  */
                     31: sizeof_t
                     32: tsize(tp) register TREE *tp;
                     33: {
                     34:        register sizeof_t n;
                     35:        n = tidsize(tp->t_type, tp->t_ip, tp->t_dp, 1);
                     36:        if (n == 0 && tp->t_op == GID && tp->t_sp->s_class == C_GREF)
                     37:                sizewarn(tp->t_sp->s_id, 0);
                     38:        return n;
                     39: }
                     40: 
                     41: /*
                     42:  * Much like ssize, but takes a symbol pointer and a dimension list.
                     43:  */
                     44: sizeof_t
                     45: sdsize(sp, dp) register SYM *sp; DIM *dp;
                     46: {
                     47:        register sizeof_t n;
                     48:        n = tidsize(sp->s_type, sp->s_ip, dp, 1);
                     49:        if (n == 0 && sp->s_class == C_GREF)
                     50:                sizewarn(sp->s_id, 0);
                     51:        return n;
                     52: }
                     53: 
                     54: 
                     55: /*
                     56:  * Figure out a size given a type,
                     57:  * an INFO structure pointer and a dimension list.
                     58:  */
                     59: sizeof_t
                     60: tidsize(t, ip, dp, f) register int t; register INFO *ip; register DIM *dp;
                     61:                      int f;                    /* Message requested flag */
                     62: {
                     63:        unsigned long n;
                     64:        int a = 0;              /* Array flag for szcheck() */
                     65:        char *s = "object";
                     66: 
                     67:        n = 1;
                     68:        while (dp!=NULL && (dp->d_type==D_ARRAY || dp->d_type==D_MOSAR)) {
                     69:                s = "array";
                     70:                n *= dp->d_bound;
                     71:                dp = dp->d_dp;
                     72:                a += 1;
                     73:        }
                     74:        if (n == 0)
                     75:                return 0;
                     76:        if (dp!=NULL && dp->d_type==D_FUNC)
                     77:                return(f ? sizewarn("function", 0) : 0);
                     78:        if (dp != NULL)
                     79:                n *= mysizes[T_PTR];
                     80:        else {
                     81:                if (t == T_VOID)
                     82:                        return(f ? sizewarn("void", 0) : 0);
                     83:                if (isfr(t)) {
                     84:                        if (f) unksize(t, ip);
                     85:                        return 0;
                     86:                }
                     87:                if (t==T_STRUCT || t==T_UNION) {
                     88:                        s = (t==T_STRUCT) ? "structure" : "union";
                     89:                        n *= ip->i_size;
                     90:                } else {
                     91:                        if (t == T_ENUM)
                     92:                                t = ip->i_type;
                     93:                        n *= mysizes[t];
                     94:                }
                     95:        }
                     96:        if (f)
                     97:                n = szcheck(n, a, s);
                     98:        return n;
                     99: }
                    100: 
                    101: /*
                    102:  * Is this a forward reference?
                    103:  */
                    104: isfr(t) register int t;
                    105: {
                    106:        return (t==T_FSTRUCT || t==T_FUNION || t==T_FENUM);
                    107: }
                    108: 
                    109: /*
                    110:  * Mutter about an unknown size.
                    111:  */
                    112: unksize(t, sp) register int t; register SYM *sp;
                    113: {
                    114:        register char *p;
                    115: 
                    116:        p = "enumeration";
                    117:        if (t == T_FSTRUCT)
                    118:                p = "structure";
                    119:        if (t == T_FUNION)
                    120:                p = "union";
                    121:        cerror("size of %s \"%s\" is not known", p, sp->s_id);
                    122: }
                    123: 
                    124: static
                    125: sizewarn(s, i) char *s; register int i;
                    126: {
                    127:        cerror("sizeof(%s) set to %d", s, i);
                    128:        return i;
                    129: }
                    130: 
                    131: /* end of n0/size.c */

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