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     ! 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.