usr/src/cmd/c/c01.c

#
/*
 * C compiler
 *
 *
 */

#include "c0.h"

/*
 * Called from tree, this routine takes the top 1, 2, or 3
 * operands on the expression stack, makes a new node with
 * the operator op, and puts it on the stack.
 * Essentially all the work is in inserting
 * appropriate conversions.
 */
build(op)
{
        register int t1;
        int t2, t;
        register struct tnode *p1, *p2;
        struct tnode *p3;
        int dope, leftc, cvn, pcvn;

        /*
         * a[i] => *(a+i)
         */
        if (op==LBRACK) {
                build(PLUS);
                op = STAR;
        }
        dope = opdope[op];
        if ((dope&BINARY)!=0) {
                p2 = chkfun(disarray(*--cp));
                t2 = p2->type;
        }
        p1 = *--cp;
        /*
         * sizeof gets turned into a number here.
         */
        if (op==SIZEOF) {
                t1 = cblock(length(p1));
                t1->type = UNSIGN;
                *cp++ = t1;
                return;
        }
        if (op!=AMPER) {
                p1 = disarray(p1);
                if (op!=CALL)
                        p1 = chkfun(p1);
        }
        t1 = p1->type;
        pcvn = 0;
        t = INT;
        switch (op) {

        case CAST:
                if ((t1&XTYPE)==FUNC || (t1&XTYPE)==ARRAY)
                        error("Disallowed conversion");
                if (t1==UNSIGN && t2==CHAR) {
                        t2 = INT;
                        p2 = block(AND,INT,NULL,NULL,p2,cblock(0377));
                }
                break;

        /* end of expression */
        case 0:
                *cp++ = p1;
                return;

        /* no-conversion operators */
        case QUEST:
                if (p2->op!=COLON)
                        error("Illegal conditional");
                else
                        if (fold(QUEST, p1, p2))
                                return;

        case SEQNC:
                t = t2;

        case COMMA:
        case LOGAND:
        case LOGOR:
                *cp++ = block(op, t, NULL, NULL, p1, p2);
                return;

        case EXCLA:
                t1 = INT;
                break;

        case CALL:
                if ((t1&XTYPE) != FUNC)
                        error("Call of non-function");
                *cp++ = block(CALL,decref(t1),p1->subsp,p1->strp,p1,p2);
                return;

        case STAR:
                if ((t1&XTYPE) == FUNC)
                        error("Illegal indirection");
                *cp++ = block(STAR, decref(t1), p1->subsp, p1->strp, p1);
                return;

        case AMPER:
                if (p1->op==NAME || p1->op==STAR) {
                        *cp++ = block(op,incref(t1),p1->subsp,p1->strp,p1);
                        return;
                }
                error("Illegal lvalue");
                break;

        /*
         * a.b goes to (&a)->b
         */
        case DOT:
                if (p1->op==CALL && t1==STRUCT) {
                        t1 = incref(t1);
                        setype(p1, t1, p1);
                } else {
                        *cp++ = p1;
                        build(AMPER);
                        p1 = *--cp;
                }

        /*
         * In a->b, a is given the type ptr-to-structure element;
         * then the offset is added in without conversion;
         * then * is tacked on to access the member.
         */
        case ARROW:
                if (p2->op!=NAME || p2->tr1->hclass!=MOS) {
                        error("Illegal structure ref");
                        *cp++ = p1;
                        return;
                }
                if (t2==INT && p2->tr1->hflag&FFIELD)
                        t2 = UNSIGN;
                t = incref(t2);
                chkw(p1, -1);
                setype(p1, t, p2);
                *cp++ = block(PLUS,t,p2->subsp,p2->strp,p1,cblock(p2->tr1->hoffset));
                build(STAR);
                if (p2->tr1->hflag&FFIELD)
                        *cp++ = block(FSEL,UNSIGN,NULL,NULL,*--cp,p2->tr1->hstrp);
                return;
        }
        if ((dope&LVALUE)!=0)
                chklval(p1);
        if ((dope&LWORD)!=0)
                chkw(p1, LONG);
        if ((dope&RWORD)!=0)
                chkw(p2, LONG);
        if ((dope&BINARY)==0) {
                if (op==ITOF)
                        t1 = DOUBLE;
                else if (op==FTOI)
                        t1 = INT;
                if (!fold(op, p1, 0))
                        *cp++ = block(op,t1,p1->subsp,p1->strp,p1);
                return;
        }
        cvn = 0;
        if (t1==STRUCT || t2==STRUCT) {
                if (t1!=t2 || p1->strp != p2->strp)
                        error("Incompatible structures");
                cvn = 0;
        } else
                cvn = cvtab[lintyp(t1)][lintyp(t2)];
        leftc = (cvn>>4)&017;
        cvn =& 017;
        t = leftc? t2:t1;
        if ((t==INT||t==CHAR) && (t1==UNSIGN||t2==UNSIGN))
                t = UNSIGN;
        if (dope&ASSGOP || op==CAST) {
                t = t1;
                if (op==ASSIGN || op==CAST) {
                        if (cvn==ITP||cvn==PTI)
                                cvn = leftc = 0;
                        else if (cvn==LTP) {
                                if (leftc==0)
                                        cvn = LTI;
                                else {
                                        cvn = ITL;
                                        leftc = 0;
                                }
                        }
                }
                if (leftc)
                        cvn = leftc;
                leftc = 0;
        } else if (op==COLON || op==MAX || op==MIN) {
                if (t1>=PTR && t1==t2)
                        cvn = 0;
                if (op!=COLON && (t1>=PTR || t2>=PTR))
                        op =+ MAXP-MAX;
        } else if (dope&RELAT) {
                if (op>=LESSEQ && (t1>=PTR||t2>=PTR||(t1==UNSIGN||t2==UNSIGN)
                 && (t==INT||t==CHAR||t==UNSIGN)))
                        op =+ LESSEQP-LESSEQ;
                if (cvn==ITP || cvn==PTI)
                        cvn = 0;
        }
        if (cvn==PTI) {
                cvn = 0;
                if (op==MINUS) {
                        t = INT;
                        pcvn++;
                } else {
                        if (t1!=t2 || t1!=(PTR+CHAR))
                                cvn = XX;
                }
        }
        if (cvn) {
                t1 = plength(p1);
                t2 = plength(p2);
                if (cvn==XX || (cvn==PTI&&t1!=t2))
                        error("Illegal conversion");
                else if (leftc)
                        p1 = convert(p1, t, cvn, t2);
                else
                        p2 = convert(p2, t, cvn, t1);
        }
        if (dope&RELAT)
                t = INT;
        if (t==FLOAT)
                t = DOUBLE;
        if (t==CHAR)
                t = INT;
        if (op==CAST) {
                if (t!=DOUBLE && (t!=INT || p2->type!=CHAR)) {
                        p2->type = t;
                        p2->subsp = p1->subsp;
                        p2->strp = p1->strp;
                }
                if (t==INT && p1->type==CHAR)
                        p2 = block(ITOC, INT, NULL, NULL, p2);
                *cp++ = p2;
                return;
        }
        if (fold(op, p1, p2)==0) {
                p3 = leftc?p2:p1;
                *cp++ = block(op, t, p3->subsp, p3->strp, p1, p2);
        }
        if (pcvn && t1!=(PTR+CHAR)) {
                p1 = *--cp;
                *cp++ = convert(p1, 0, PTI, plength(p1->tr1));
        }
}

/*
 * Generate the appropriate conversion operator.
 */
struct tnode *
convert(p, t, cvn, len)
struct tnode *p;
{
        register int op;

        op = cvntab[cvn];
        if (opdope[op]&BINARY) {
                if (len==0)
                        error("Illegal conversion");
                return(block(op, t, NULL, NULL, p, cblock(len)));
        }
        return(block(op, t, NULL, NULL, p));
}

/*
 * Traverse an expression tree, adjust things
 * so the types of things in it are consistent
 * with the view that its top node has
 * type at.
 * Used with structure references.
 */
setype(ap, at, anewp)
struct tnode *ap, *anewp;
{
        register struct tnode *p, *newp;
        register t;

        p = ap;
        t = at;
        newp = anewp;
        for (;; p = p->tr1) {
                p->subsp = newp->subsp;
                p->strp = newp->strp;
                p->type = t;
                if (p->op==AMPER)
                        t = decref(t);
                else if (p->op==STAR)
                        t = incref(t);
                else if (p->op!=PLUS)
                        break;
        }
}

/*
 * A mention of a function name is turned into
 * a pointer to that function.
 */
struct tnode *
chkfun(ap)
struct tnode *ap;
{
        register struct tnode *p;
        register int t;

        p = ap;
        if (((t = p->type)&XTYPE)==FUNC && p->op!=ETYPE)
                return(block(AMPER,incref(t),p->subsp,p->strp,p));
        return(p);
}

/*
 * A mention of an array is turned into
 * a pointer to the base of the array.
 */
struct tnode *
disarray(ap)
struct tnode *ap;
{
        register int t;
        register struct tnode *p;

        p = ap;
        /* check array & not MOS and not typer */
        if (((t = p->type)&XTYPE)!=ARRAY || p->op==NAME&&p->tr1->hclass==MOS
         || p->op==ETYPE)
                return(p);
        p->subsp++;
        *cp++ = p;
        setype(p, decref(t), p);
        build(AMPER);
        return(*--cp);
}

/*
 * make sure that p is a ptr to a node
 * with type int or char or 'okt.'
 * okt might be nonexistent or 'long'
 * (e.g. for <<).
 */
chkw(p, okt)
struct tnode *p;
{
        register int t;

        if ((t=p->type)!=INT && t<PTR && t!=CHAR && t!=UNSIGN && t!=okt)
                error("Illegal type of operand");
        return;
}

/*
 *'linearize' a type for looking up in the
 * conversion table
 */
lintyp(t)
{
        switch(t) {

        case INT:
        case CHAR:
        case UNSIGN:
                return(0);

        case FLOAT:
        case DOUBLE:
                return(1);

        case LONG:
                return(2);

        default:
                return(3);
        }
}

/*
 * Report an error.
 */
error(s, p1, p2, p3, p4, p5, p6)
{
        nerror++;
        if (filename[0])
                fprintf(stderr, "%s:", filename);
        fprintf(stderr, "%d: ", line);
        fprintf(stderr, s, p1, p2, p3, p4, p5, p6);
        fprintf(stderr, "\n");
}

/*
 * Generate a node in an expression tree,
 * setting the operator, type, dimen/struct table ptrs,
 * and the operands.
 */
struct tnode *
block(op, t, subs, str, p1,p2)
int *subs;
struct str *str;
struct tnode *p1, *p2;
{
        register struct tnode *p;

        p = gblock(sizeof(*p));
        p->op = op;
        p->type = t;
        p->subsp = subs;
        p->strp = str;
        p->tr1 = p1;
        if (opdope[op]&BINARY)
                p->tr2 = p2;
        else
                p->tr2 = NULL;
        return(p);
}

struct tnode *
nblock(ads)
struct hshtab *ads;
{
        register struct hshtab *ds;

        ds = ads;
        return(block(NAME, ds->htype, ds->hsubsp, ds->hstrp, ds));
}

/*
 * Generate a block for a constant
 */
struct cnode *
cblock(v)
{
        register struct cnode *p;

        p = gblock(sizeof(*p));
        p->op = CON;
        p->type = INT;
        p->subsp = NULL;
        p->strp = NULL;
        p->value = v;
        return(p);
}

/*
 * A block for a float or long constant
 */
struct fnode *
fblock(t, string)
char *string;
{
        register struct fnode *p;

        p = gblock(sizeof(*p));
        p->op = FCON;
        p->type = t;
        p->subsp = NULL;
        p->strp = NULL;
        p->cstr = string;
        return(p);
}

/*
 * Assign a block for use in the
 * expression tree.
 */
char *
gblock(n)
{
        register int *p;

        p = curbase;
        if ((curbase =+ n) >= coremax) {
                if (sbrk(1024) == -1) {
                        error("Out of space");
                        exit(1);
                }
                coremax =+ 1024;
        }
        return(p);
}

/*
 * Check that a tree can be used as an lvalue.
 */
chklval(ap)
struct tnode *ap;
{
        register struct tnode *p;

        p = ap;
        if (p->op==FSEL)
                p = p->tr1;
        if (p->op!=NAME && p->op!=STAR)
                error("Lvalue required");
}

/*
 * reduce some forms of `constant op constant'
 * to a constant.  More of this is done in the next pass
 * but this is used to allow constant expressions
 * to be used in switches and array bounds.
 */
fold(op, ap1, ap2)
struct tnode *ap1, *ap2;
{
        register struct tnode *p1;
        register int v1, v2;
        int unsignf;

        p1 = ap1;
        if (p1->op!=CON)
                return(0);
        unsignf = p1->type==UNSIGN;
        if (op==QUEST) {
                if (ap2->tr1->op==CON && ap2->tr2->op==CON) {
                        p1->value = p1->value? ap2->tr1->value: ap2->tr2->value;
                        *cp++ = p1;
                        return(1);
                }
                return(0);
        }
        if (ap2) {
                if (ap2->op!=CON)
                        return(0);
                v2 = ap2->value;
                unsignf |= ap2->type==UNSIGN;
        }
        v1 = p1->value;
        switch (op) {

        case PLUS:
                v1 =+ v2;
                break;

        case MINUS:
                v1 =- v2;
                break;

        case TIMES:
                v1 =* v2;
                break;

        case DIVIDE:
                if (v2==0)
                        goto divchk;
                if (unsignf) {
                        v1 = (unsigned)v1 / v2;
                        break;
                }
                v1 =/ v2;
                break;

        case MOD:
                if (v2==0)
                        goto divchk;
                if (unsignf) {
                        v1 = (unsigned)v1 % v2;
                        break;
                }
                v1 =% v2;
                break;

        case AND:
                v1 =& v2;
                break;

        case OR:
                v1 =| v2;
                break;

        case EXOR:
                v1 =^ v2;
                break;

        case NEG:
                v1 = - v1;
                break;

        case COMPL:
                v1 = ~ v1;
                break;

        case LSHIFT:
                v1 =<< v2;
                break;

        case RSHIFT:
                if (unsignf) {
                        v1 = (unsigned)v1 >> v2;
                        break;
                }
                v1 =>> v2;
                break;

        case EQUAL:
                v1 = v1==v2;
                break;

        case NEQUAL:
                v1 = v1!=v2;
                break;

        case LESS:
                v1 = v1<v2;
                break;

        case GREAT:
                v1 = v1>v2;
                break;

        case LESSEQ:
                v1 = v1<=v2;
                break;

        case GREATEQ:
                v1 = v1>=v2;
                break;

        divchk:
                error("Divide check");
        default:
                return(0);
        }
        p1->value = v1;
        *cp++ = p1;
        return(1);
}

/*
 * Compile an expression expected to have constant value,
 * for example an array bound or a case value.
 */
conexp()
{
        register struct tnode *t;

        initflg++;
        if (t = tree())
                if (t->op != CON)
                        error("Constant required");
        initflg--;
        curbase = funcbase;
        return(t->value);
}