+build(op) {
+ extern cp[], cvtab, opdope[], maprel[];
+ auto p1[], t1, d1, p2[], t2, d2, p3[], t3, d3, t;
+ auto d, dope, leftc, cvn, pcvn;
+ char cvtab[];
+
+ if (op==4) { /* [] */
+ build(40); /* + */
+ op = 36; /* * */
+ }
+ dope = opdope[op];
+ if ((dope&01)!=0) { /* binary */
+ p2 = disarray(*--cp);
+ t2 = p2[1];
+ chkfun(p2);
+ d2 = p2[2];
+ if (*p2==20)
+ d2 = 0;
+ }
+ p1 = disarray(*--cp);
+ if (op!=100 & op!=35) /* call, * */
+ chkfun(p1);
+ t1 = p1[1];
+ d1 = p1[2];
+ if (*p1==20)
+ d1 = 0;
+ pcvn = 0;
+ switch (op) {
+
+ /* : */
+ case 8:
+ if (t1!=t2)
+ error("Type clash in conditional");
+ t = t1;
+ goto nocv;
+
+ /* , */
+ case 9:
+ *cp++ = block(2, 9, 0, 0, p1, p2);
+ return;
+
+ /* ? */
+ case 90:
+ if (*p2!=8)
+ error("Illegal conditional");
+ t = t2;
+ goto nocv;
+
+ /* call */
+ case 100:
+ if ((t1&030) != 020)
+ error("Call of non-function");
+ *cp++ = block(2,100,decref(t1),24,p1,p2);
+ return;
+
+ /* * */
+ case 36:
+ if (*p1==35 | *p1==29) { /* & unary */
+ *cp++ = p1[3];
+ return;
+ }
+ if (*p1!=20 & d1==0)
+ d1 = 1;
+ if ((t1&030) == 020) /* function */
+ error("Illegal indirection");
+ *cp++ = block(1,36,decref(t1),d1,p1);
+ return;
+
+ /* & unary */
+ case 35:
+ if (*p1==36) { /* * */
+ *cp++ = p1[3];
+ return;
+ }
+ if (*p1==20) {
+ *cp++ = block(1,p1[3]==5?29:35,incref(t1),1,p1);
+ return;
+ }
+ error("Illegal lvalue");
+ break;
+
+ case 43: /* / */
+ case 44: /* % */
+ case 73: /* =/ */
+ case 74: /* =% */
+ d1++;
+ d2++;
+
+ case 42: /* * */
+ case 72: /* =* */
+ d1++;
+ d2++;
+ break;
+
+ case 30: /* ++ -- pre and post */
+ case 31:
+ case 32:
+ case 33:
+ chklval(p1);
+ *cp++ = block(2,op,t1,max(d1,1),p1,plength(p1));
+ return;
+
+ case 39: /* . (structure ref) */
+ case 50: /* -> (indirect structure ref) */
+ if (p2[0]!=20 | p2[3]!=4) /* not mos */
+ error("Illegal structure ref");
+ *cp++ = p1;
+ t = t2;
+ if ((t&030) == 030) /* array */
+ t = decref(t);
+ setype(p1, t);
+ if (op==39) /* is "." */
+ build(35); /* unary & */
+ *cp++ = block(1,21,7,0,p2[5]);
+ build(40); /* + */
+ if ((t2&030) != 030) /* not array */
+ build(36); /* unary * */
+ return;
+ }
+ if ((dope&02)!=0) /* lvalue needed on left? */
+ chklval(p1);
+ if ((dope&020)!=0) /* word operand on left? */
+ chkw(p1);
+ if ((dope&040)!=0) /* word operand on right? */
+ chkw(p2);
+ if ((dope&01)==0) { /* unary op? */
+ *cp++ = block(1,op,t1,max(d1,1),p1);
+ return;
+ }
+ if (t2==7) {
+ t = t1;
+ p2[1] = 0; /* no int cv for struct */
+ t2 = 0;
+ goto nocv;
+ }
+ cvn = cvtab[11*lintyp(t1)+lintyp(t2)];
+ leftc = cvn&0100;
+ t = leftc? t2:t1;
+ if (op==80 & t1!=4 & t2!=4) { /* = */
+ t = t1;
+ if (leftc | cvn!=1)
+ goto nocv;
+ }
+ if (cvn =& 077) {
+ if (cvn==077) {
+ illcv:
+ error("Illegal conversion");
+ goto nocv;
+ }
+ if (cvn>4 & cvn<10) { /* ptr conv */
+ t = 0; /* integer result */
+ cvn = 0;
+ if ((dope&04)!=0) /* relational? */
+ goto nocv;
+ if (op!=41) /* - */
+ goto illcv;
+ pcvn = cvn;
+ goto nocv;
+ }
+ if (leftc) {
+ if ((dope&010) != 0) { /* =op */
+ if (cvn == 1) {
+ leftc = 0;
+ cvn = 8;
+ t = t1;
+ goto rcvt;
+ } else
+ goto illcv;
+ }
+ d1 = (p1=convert(p1, t, d1, cvn, plength(p2)))[2];
+ } else {
+ rcvt:
+ d2 = (p2=convert(p2, t, d2, cvn, plength(p1)))[2];
+ }
+nocv:; }
+ if (d1==d2)
+ d = d1+1; else
+ d = max(d1,d2);
+ if ((dope&04)!=0) { /* relational? */
+ if (op>61 & t>=010)
+ op =+ 4; /* ptr relation */
+ t = 0; /* relational is integer */
+ }
+ *cp++ = optim(block(2,op,t,d,p1,p2));
+ if (pcvn) {
+ p1 = *--cp;
+ *cp++ = block(1,50+pcvn,0,d,p1);
+ }
+ return;
+ *cp++ = block(1,op,t1,d1==0?1:d1,p1);
+}
+
+setype(p, t)
+int p[];
+{
+ int p1[];
+
+ if ((p[1]&07) != 4) /* not structure */
+ return;
+ p[1] = t;
+ switch(*p) {
+
+ case 29: /* & */
+ case 35:
+ setype(p[3], decref(t));
+ return;
+
+ case 36: /* * */
+ setype(p[3], incref(t));
+ return;
+
+ case 40: /* + */
+ setype(p[4], t);
+ }
+}
+
+chkfun(p)
+int p[];
+{
+ if ((p[1]&030)==020) /* func */
+ error("Illegal use of function");
+}
+
+optim(p)
+int p[];
+{
+ int p1[], p2[], t;
+
+ if (*p != 40) /* + */
+ return(p);
+ p1 = p[3];
+ p2 = p[4];
+ if (*p1==21) { /* const */
+ t = p1;
+ p1 = p2;
+ p2 = t;
+ }
+ if (*p2 != 21) /* const */
+ return(p);
+ if ((t=p2[3]) == 0) /* const 0 */
+ return(p1);
+ if (*p1!=35 & *p1!=29) /* not & */
+ return(p);
+ p2 = p1[3];
+ if (*p2!=20) { /* name? */
+ error("C error (optim)");
+ return(p);
+ }
+ p2[4] =+ t;
+ return(p1);
+}
+
+disarray(p)
+int p[];
+{
+ extern cp;
+ int t, cp[];
+
+ if (((t = p[1]) & 030)!=030 | p[0]==20&p[3]==4) /* array & not MOS */
+ return(p);
+ p[1] = decref(t);
+ *cp++ = p;
+ build(35); /* add & */
+ return(*--cp);
+}
+
+convert(p, t, d, cvn, len)
+int p[];
+{
+ int c, p1[];
+
+ if (*p==21) { /* constant */
+ c = p[3];
+ switch(cvn) {
+
+ case 4: /* int -> double[] */
+ c =<< 1;
+
+ case 3: /* int -> float[] */
+ c =<< 1;
+
+ case 2: /* int -> int[] */
+ c =<< 1;
+ p[3] = c;
+ return(p);
+
+ case 10: /* i -> s[] */
+ p[3] = c*len;
+ return(p);
+ }
+ }
+ if (cvn==10) /* i -> s[]; retrun i*len */
+ return(block(2,42,t,d+2,p,block(1,21,0,0,len)));
+ return(block(1, 50+cvn, t, max(1,d), p));
+}
+
+chkw(p)
+int p[]; {
+ extern error;
+ auto t;
+
+ if ((t=p[1])>1 & t<=07)
+ error("Integer operand required");
+ return;
+}
+
+lintyp(t)
+{
+ if (t<=07)
+ return(t);
+ if ((t&037)==t)
+ return((t&07)+5);
+ return(10);
+}
+
+error(s, p1, p2, p3, p4, p5, p6) {
+ extern line, fout, nerror;
+ int f;
+
+ nerror++;
+ flush();
+ f = fout;
+ fout = 1;
+ printf("%d: ", line);
+ printf(s, p1, p2, p3, p4, p5, p6);
+ putchar('\n');
+ fout = f;
+}
+
+block(n, op, t, d, p1,p2,p3)
+int p1[],p2[],p3[]; {
+ int p[], ap[], space[];
+ extern space;
+
+ ap = &op;
+ n =+ 3;
+ p = space;
+ while(n--)
+ pblock(*ap++);
+ return(p);
+}
+
+pblock(p)
+{
+ extern space, osleft;
+ int space[];
+
+ *space++ = p;
+ if (--osleft<=0) {
+ error("Expression overflow");
+ exit(1);
+ }
+}
+
+chklval(p)
+int p[]; {
+ extern error;
+
+ if (*p!=20 & *p !=36)
+ error("Lvalue required");
+}
+
+max(a, b)
+{
+ if (a>b)
+ return(a);
+ return(b);
+}
+
projects / unix-history / commitdiff