2.11BSD/src/lib/ccom/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 union tree *p1, *p2, *p3;
int dope, leftc, cvn, pcvn;
/*
* a[i] => *(a+i)
*/
if (op==LBRACK) {
build(PLUS);
op = STAR;
}
dope = opdope[op];
t2 = INT;
if ((dope&BINARY)!=0) {
p2 = chkfun(disarray(*--cp));
if (p2)
t2 = p2->t.type;
}
p1 = *--cp;
/*
* sizeof gets turned into a number here.
*/
if (op==SIZEOF) {
p1 = cblock(length(p1));
p1->c.type = UNSIGN;
*cp++ = p1;
return;
}
if (op!=AMPER) {
p1 = disarray(p1);
if (op!=CALL)
p1 = chkfun(p1);
}
t1 = p1->t.type;
if (t1==CHAR)
t1 = INT;
else if (t1==UNCHAR)
t1 = UNSIGN;
if (t2==CHAR)
t2 = INT;
else if (t2==UNCHAR)
t2 = UNSIGN;
pcvn = 0;
t = INT;
switch (op) {
case CAST:
if ((t1&XTYPE)==FUNC || (t1&XTYPE)==ARRAY)
error("Disallowed conversion");
if (p1->t.type==UNCHAR) {
*cp++ = block(ETYPE, UNSIGN, (int *)NULL, (union str *)NULL,
TNULL, TNULL);
*cp++ = p2;
build(CAST);
*cp++ = cblock(0377);
build(AND);
return;
}
if (p2->t.type==CHAR || p2->t.type==UNCHAR)
p2 = block(PLUS, t2, (int *)NULL, (union str *)NULL,
p2, cblock(0));
break;
/* end of expression */
case 0:
*cp++ = p1;
return;
/* no-conversion operators */
case QUEST:
if (p2->t.op!=COLON)
error("Illegal conditional");
else
if (fold(QUEST, p1, p2))
return;
/*
* Bug fix, because copying type is not enough,
* i.e. t = (t, t) + 1;
* Original code was:
* case SEQNC:
* t = t2;
* case COMMA:
*/
case SEQNC:
*cp++ = block(op, t2, p2->t.subsp, p2->t.strp, p1, p2);
return;
case COMMA:
case LOGAND:
case LOGOR:
*cp++ = block(op, t, p2->t.subsp, p2->t.strp, p1, p2);
return;
case EXCLA:
t1 = INT;
break;
case CALL:
if ((t1&XTYPE) == PTR && (decref(t1)&XTYPE) == FUNC) {
/*
* Modification to allow calling a function via a
* pointer to a function ("f") without explicitly
* dereferencing the pointer. That is: f(...) is now
* legal as well as (*f)(...). The insistence that
* decref(t1) be FUNC prevents pointers to pointers to
* functions and so on from being automatically
* dereferenced which would be incorrect and introduce
* porting problems. Note that for purity FUNC's
* should really always be referenced (as in pcc) and
* that the new notation is actually more consistent
* with the rest of C ...
*/
*cp++ = p1;
build(STAR);
*cp++ = p2;
build(CALL);
return;
}
if ((t1&XTYPE) != FUNC)
error("Call of non-function");
*cp++ = block(CALL,decref(t1),p1->t.subsp,p1->t.strp,p1,p2);
return;
case STAR:
if ((t1&XTYPE) == FUNC)
error("Illegal indirection");
*cp++ = block(STAR, decref(t1), p1->t.subsp, p1->t.strp, p1, TNULL);
return;
case AMPER:
if (p1->t.op==NAME || p1->t.op==STAR) {
*cp++ = block(op,incref(p1->t.type),p1->t.subsp,p1->t.strp,p1,TNULL);
return;
}
error("Illegal lvalue");
break;
/*
* a.b goes to (&a)->b
*/
case DOT:
if (p1->t.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->t.op!=NAME || p2->t.tr1->n.hclass!=MOS) {
error("Illegal structure ref");
*cp++ = p1;
return;
}
p2 = structident(p1, p2);
t2 = p2->n.htype;
if (t2==INT && p2->t.tr1->n.hflag&FFIELD)
t2 = UNSIGN;
t = incref(t2);
chkw(p1, -1);
setype(p1, t, p2);
*cp++ = block(PLUS, t, p2->t.subsp, p2->t.strp,
p1, cblock(p2->t.tr1->n.hoffset));
build(STAR);
if (p2->t.tr1->n.hflag&FFIELD)
*cp++ = block(FSEL, UNSIGN, (int *)NULL, (union str *)NULL,
*--cp, p2->t.tr1->n.hstrp);
return;
}
if ((dope&LVALUE)!=0)
chklval(p1);
if ((dope&LWORD)!=0)
chkw(p1, LONG);
if ((dope&RWORD)!=0)
chkw(p2, LONG);
if ((t1==VOID && op!=CAST) || (t2==VOID && (op!=CAST || t1!=VOID))) {
error("Illegal use of void object");
t = t1 = t2 = INT;
}
if ((dope&BINARY)==0) {
if (op==ITOF)
t1 = DOUBLE;
else if (op==FTOI)
t1 = INT;
if (!fold(op, p1, (union tree *)NULL))
*cp++ = block(op, t1, p1->t.subsp, p1->t.strp, p1,TNULL);
return;
}
cvn = 0;
if (t1==STRUCT || t2==STRUCT) {
if (t1!=t2 || p1->t.strp != p2->t.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) {
/*
* Weird "lhs op= rhs" requiring a temporary to evaluate as
* "lhs = lhs op rhs" so lhs can be converted up for the
* operation and then the result converted back down for
* the assignment. As a special sub case, "(int) op= (long)"
* doesn't require a temporary except for /= and %= ...
*/
if (leftc && op>=ASPLUS && op<=ASXOR
&& (leftc!=LTI || op==ASDIV || op==ASMOD)) {
assignop(op, p1, p2);
return;
}
t = t1;
if (op==ASSIGN) {
if (cvn==PTI) {
if (t1!=t2 || ((t1&TYPE)==STRUCT && p1->t.strp!=p2->t.strp))
werror("mixed pointer assignment");
cvn = leftc = 0;
} if ((cvn==ITP || cvn==LTP)
&& (p2->t.op!=CON || p2->c.value!=0)
&& (p2->t.op!=LCON || p2->l.lvalue!=0)) {
/*
* Allow "i = p" and "p = i" with a warning, where
* i is some form of integer (not 0) and p is a
* pointer. Note that in both this patch and the
* similar one for "?:" below, code from the CAST
* immediately below and the illegal conversion
* check farther below is simply stolen. It would
* require either a recursive call to build or a
* fairly large rewrite to eliminate the
* duplication.
*/
werror("illegal combination of pointer and integer, op =");
if (cvn==ITP)
cvn = leftc = 0;
else
if (leftc==0)
cvn = LTI;
else {
cvn = ITL;
leftc = 0;
}
}
} else if (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;
/*
* Allow "e ? i : p" and "e ? p : i" with warning.
*/
if (op==COLON && (cvn==ITP || cvn==LTP)) {
p3 = leftc? p1: p2;
if ((p3->t.op!=CON || p3->c.value!=0)
&& (p3->t.op!=LCON || p3->l.lvalue!=0)) {
werror("illegal combination of pointer and integer, op :");
if (cvn==ITP)
cvn = leftc = 0;
else
if (leftc==0)
cvn = LTI;
else {
cvn = ITL;
leftc = 0;
}
}
}
} else if (dope&RELAT) {
if (op>=LESSEQ && (t1>=PTR||t2>=PTR||(t1==UNSIGN||t1==UNLONG||t2==UNSIGN||t2==UNLONG)
&& (t==INT||t==CHAR||t==UNSIGN||t==UNLONG)))
op += LESSEQP-LESSEQ;
if (cvn==ITP || cvn==PTI)
cvn = 0;
}
if (cvn==PTI) {
cvn = 0;
if (op==MINUS) {
pcvn++;
p1 = block(ITOL, LONG, (int *)NULL, (union str *)NULL, p1, TNULL);
p2 = block(ITOL, LONG, (int *)NULL, (union str *)NULL, p2, TNULL);
t = LONG;
} else {
if (t1!=t2 || (t1!=(PTR+CHAR) && t1!=(PTR+UNCHAR)))
cvn = XX;
}
}
if (cvn) {
if ((cvn==ITP || cvn==LTP) && (opdope[op]&PCVOK)==0) {
p3 = leftc? p1: p2;
if ((p3->t.op!=CON || p3->c.value!=0)
&& (p3->t.op!=LCON || p3->l.lvalue!=0))
cvn = XX;
else
cvn = 0;
}
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->t.type!=CHAR || p2->t.type!=UNCHAR)) {
p2->t.type = t;
p2->t.subsp = p1->t.subsp;
p2->t.strp = p1->t.strp;
}
if (t==INT && p1->t.type==CHAR)
p2 = block(ITOC, INT, (int *)NULL, (union str *)NULL, p2, TNULL);
*cp++ = p2;
return;
}
if (pcvn)
t2 = plength(p1->t.tr1);
if (fold(op, p1, p2)==0) {
p3 = leftc?p2:p1;
*cp++ = block(op, t, p3->t.subsp, p3->t.strp, p1, p2);
}
if (pcvn) {
p1 = *--cp;
*cp++ = convert(p1, 0, PTI, t2);
}
}
union tree *
structident(p1, p2)
register union tree *p1, *p2;
{
register struct nmlist *np;
int vartypes = 0, namesame = 1;
np = (struct nmlist *)p2->t.tr1;
for (;;) {
if (namesame && p1->t.type==STRUCT+PTR && p1->t.strp == np->sparent) {
p2->t.type = np->htype;
p2->t.strp = np->hstrp;
p2->t.subsp = np->hsubsp;
p2->t.tr1 = (union tree *)np;
return(p2);
}
np = np->nextnm;
if (np==NULL)
break;
namesame = 0;
if (strcmp(p2->t.tr1->n.name, np->name) != 0)
continue;
if ((p2->t.tr1->n.hflag&FKIND) != (np->hflag&FMOS))
continue;
namesame = 1;
if (p2->t.tr1->n.htype==np->htype && p2->t.tr1->n.hoffset==np->hoffset)
continue;
vartypes++;
}
if (vartypes)
error("Ambiguous structure reference for %s",p2->t.tr1->n.name);
else
werror("%s not member of cited struct/union",p2->t.tr1->n.name);
return(p2);
}
/*
* Generate the appropriate conversion operator.
*/
union tree *
convert(p, t, cvn, len)
union tree *p;
{
register int op;
if (cvn==0)
return(p);
op = cvntab[cvn];
if (opdope[op]&BINARY) {
if (len==0)
error("Illegal conversion");
return(block(op, t, (int *)NULL, (union str *)NULL, p, cblock(len)));
}
return(block(op, t, (int *)NULL, (union str *)NULL, p, TNULL));
}
/*
* 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(p, t, newp)
register union tree *p, *newp;
register t;
{
for (;; p = p->t.tr1) {
p->t.subsp = newp->t.subsp;
p->t.strp = newp->t.strp;
p->t.type = t;
if (p->t.op==AMPER)
t = decref(t);
else if (p->t.op==STAR)
t = incref(t);
else if (p->t.op!=PLUS)
break;
}
}
/*
* A mention of a function name is turned into
* a pointer to that function.
*/
union tree *
chkfun(p)
register union tree *p;
{
register int t;
if (((t = p->t.type)&XTYPE)==FUNC && p->t.op!=ETYPE)
return(block(AMPER,incref(t),p->t.subsp,p->t.strp,p,TNULL));
return(p);
}
/*
* A mention of an array is turned into
* a pointer to the base of the array.
*/
union tree *
disarray(p)
register union tree *p;
{
register int t;
if (p==NULL)
return(p);
/* check array & not MOS and not typer */
if (((t = p->t.type)&XTYPE)!=ARRAY
|| p->t.op==NAME && p->t.tr1->n.hclass==MOS
|| p->t.op==ETYPE)
return(p);
p->t.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)
union tree *p;
{
register int t = p->t.type;
if (t == UNLONG)
t = LONG;
if (t!=INT && t<PTR && t!=CHAR && t!=UNCHAR && 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:
case UNCHAR:
return(0);
case FLOAT:
case DOUBLE:
return(1);
case UNLONG:
case LONG:
return(2);
default:
return(3);
}
}
/*
* Report an error.
*/
extern int Wflag = 0; /* Non-zero means do not print warnings */
/* VARARGS1 */
werror(s, p1, p2, p3, p4, p5, p6)
char *s;
{
if (Wflag)
return;
if (filename[0])
fprintf(stderr, "%s:", filename);
fprintf(stderr, "%d: warning: ", line);
fprintf(stderr, s, p1, p2, p3, p4, p5, p6);
fprintf(stderr, "\n");
}
/* VARARGS1 */
error(s, p1, p2, p3, p4, p5, p6)
char *s;
{
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.
*/
union tree *
block(op, t, subs, str, p1,p2)
int *subs;
union str *str;
union tree *p1, *p2;
{
register union tree *p;
p = (union tree *)Tblock(sizeof(struct tnode));
p->t.op = op;
p->t.type = t;
p->t.subsp = subs;
p->t.strp = str;
p->t.tr1 = p1;
if (opdope[op]&BINARY)
p->t.tr2 = p2;
else
p->t.tr2 = NULL;
return(p);
}
union tree *
nblock(ds)
register struct nmlist *ds;
{
return(block(NAME, ds->htype, ds->hsubsp, ds->hstrp, (union tree *)ds, TNULL));
}
/*
* Generate a block for a constant
*/
union tree *
cblock(v)
{
register union tree *p;
p = (union tree *)Tblock(sizeof(struct cnode));
p->c.op = CON;
p->c.type = INT;
p->c.subsp = NULL;
p->c.strp = NULL;
p->c.value = v;
return(p);
}
/*
* A block for a float constant
*/
union tree *
fblock(t, string)
char *string;
{
register union tree *p;
p = (union tree *)Tblock(sizeof(struct fnode));
p->f.op = FCON;
p->f.type = t;
p->f.subsp = NULL;
p->f.strp = NULL;
p->f.cstr = string;
return(p);
}
/*
* Assign a block for use in the
* expression tree.
*/
char *
Tblock(n)
{
register char *p;
p = treebase;
if (p==NULL) {
error("c0 internal error: Tblock");
exit(1);
}
if ((treebase += n) >= coremax) {
if (sbrk(1024) == (char *)-1) {
error("Out of space");
exit(1);
}
coremax += 1024;
}
return(p);
}
char *
starttree()
{
register char *st;
st = treebase;
if (st==NULL)
treebot = treebase = locbase+DCLSLOP;
return(st);
}
endtree(tp)
char *tp;
{
treebase = tp;
if (tp==NULL)
treebot = NULL;
}
/*
* Assign a block for use in a declaration
*/
char *
Dblock(n)
{
register char *p;
p = locbase;
locbase += n;
if (treebot && locbase > treebot) {
error("Too much declaring in an expression");
exit(1);
}
if (locbase > coremax) {
if (sbrk(1024) == (char *)-1) {
error("out of space");
exit(1);
}
coremax += 1024;
}
return(p);
}
/*
* Check that a tree can be used as an lvalue.
*/
chklval(p)
register union tree *p;
{
if (p->t.op==FSEL)
p = p->t.tr1;
if (p->t.op!=NAME && p->t.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, p1, p2)
register union tree *p1;
union tree *p2;
{
register int v1, v2;
int unsignf;
if (p1->t.op!=CON)
return(0);
unsignf = p1->c.type==UNSIGN;
unsignf |= p1->c.type==UNLONG;
if (op==QUEST) {
if (p2->t.tr1->t.op==CON && p2->t.tr2->t.op==CON) {
p1->c.value = p1->c.value? p2->t.tr1->c.value: p2->t.tr2->c.value;
*cp++ = p1;
p1->t.type = p2->t.type;
return(1);
}
return(0);
}
if (p2) {
if (p2->t.op!=CON)
return(0);
v2 = p2->c.value;
unsignf |= p2->c.type==UNSIGN;
unsignf |= p2->c.type==UNLONG;
}
v1 = p1->c.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) {
if (v2==1)
break;
if (v2<0) {
v1 = (unsigned)v1 >= (unsigned)v2;
break;
}
v1 = (unsigned)v1 / v2;
break;
}
v1 /= v2;
break;
case MOD:
if (v2==0)
goto divchk;
if (unsignf) {
if (v2==1) {
v1 = 0;
break;
}
if (v2<0) {
if ((unsigned)v1 >= (unsigned)v2)
v1 -= v2;
break;
}
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;
case LESSP:
v1 = (unsigned)v1<v2;
break;
case GREATP:
v1 = (unsigned)v1>v2;
break;
case LESSEQP:
v1 = (unsigned)v1<=v2;
break;
case GREATQP:
v1 = (unsigned)v1>=v2;
break;
divchk:
error("Divide check");
nerror--;
default:
return(0);
}
p1->c.value = v1;
*cp++ = p1;
if (unsignf)
p1->t.type = UNSIGN;
return(1);
}
/*
* Compile an expression expected to have constant value,
* for example an array bound or a case value.
*/
conexp()
{
register union tree *t;
initflg++;
if (t = tree(1))
if (t->t.op != CON)
error("Constant required");
initflg--;
return(t->c.value);
}
/*
* Handle peculiar assignment ops that need a temporary.
*/
assignop(op, p1, p2)
register union tree *p1, *p2;
{
register struct nmlist *np;
op += PLUS - ASPLUS;
if (p1->t.op==NAME) {
*cp++ = p1;
*cp++ = p1;
*cp++ = p2;
build(op);
build(ASSIGN);
return;
}
np = gentemp(incref(p1->t.type));
*cp++ = nblock(np);
*cp++ = p1;
build(AMPER);
build(ASSIGN);
*cp++ = nblock(np);
build(STAR);
*cp++ = nblock(np);
build(STAR);
*cp++ = p2;
build(op);
build(ASSIGN);
build(SEQNC);
}
/*
* Generate an automatic temporary for
* use in certain assignment ops
*/
struct nmlist *
gentemp(type)
{
register struct nmlist *tp;
tp = (struct nmlist *)Tblock(sizeof(struct nmlist));
tp->hclass = AUTO;
tp->htype = type;
tp->hflag = 0;
tp->hsubsp = NULL;
tp->hstrp = NULL;
tp->hblklev = blklev;
autolen -= rlength((union tree *)tp);
tp->hoffset = autolen;
if (autolen < maxauto)
maxauto = autolen;
return(tp);
}