V7M/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);
}