开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
EXPR.C
资源名称：c_compiler.zip　[点击查看]
上传用户：hlzzc88
上传日期：2007-01-06
资源大小：220k
文件大小：79k
源码类别：

编译器/解释器

开发平台：

Others

EXPR.C：源码内容
  1. /*
  2.  * 68K/386 32-bit C compiler.
  3.  *
  4.  * copyright (c) 1997, David Lindauer
  5.  * 
  6.  * This compiler is intended for educational use.  It may not be used
  7.  * for profit without the express written consent of the author.
  8.  *
  9.  * It may be freely redistributed, as long as this notice remains intact
  10.  * and either the original sources or derived sources 
  11.  * are distributed along with any executables derived from the originals.
  12.  *
  13.  * The author is not responsible for any damages that may arise from use
  14.  * of this software, either idirect or consequential.
  15.  *
  16.  * v1.35 March 1997
  17.  * David Lindauer, gclind01@starbase.spd.louisville.edu
  18.  *
  19.  * Credits to Mathew Brandt for original K&R C compiler
  20.  *
  21.  */
  22. /*
  23.  * Evaluate expressions very recursive descent.  MAke sure your STACK
  24.  * is large enough to parse the expressions you want to parse.  a 4K stack
  25.  * will handle all but the very extreme cases
  26.  */
  27. #include        <stdio.h>
  28. #include        "expr.h"
  29. #include        "c.h"
  30. #include        "errors.h"
  31. #include "list.h"
  33. extern int block_nesting;
  34. extern int global_flag;
  35. extern enum e_sym lastst;
  36. extern char lastid[],laststr[];
  37. extern TABLE gsyms,lsyms;
  38. extern long ival;
  39. extern long double rval;
  40. /* Default types */
  41. extern TYP stdint,stdlongdouble, stduns,stdstring;
  42. TYP             stdfloat = { bt_float, 0, UF_DEFINED | UF_USED,0, 0,-1, -1, 8, {0, 0}, 0, 0,0 };
  43. TYP             stddouble = { bt_double, 0, 0,0,0, -1, -1, 8, {0, 0}, 0, 0,0 };
  44. TYP             stdvoid = { bt_matchall, 0, 0 ,0, 0,-1, -1, 4, {0, 0}, 0, 0,0 };
  45. TYP             stdmatch = { bt_matchall, 0, UF_DEFINED | UF_USED,0, 0,-1, -1, 4, {0, 0}, &stdvoid, 0,0 };
  46. TYP             stdlong = {bt_long, 0, 0,0,0,-1, -1, 4, {0, 0}, 0, 0,0 };
  47. TYP             stdunsigned = {bt_unsigned, 0, 0,0,0,-1, -1, 4, {0, 0}, 0, 0,0 };
  48. TYP             stdchar = {bt_char, 0, 0,0,0,-1, -1, 1, {0, 0}, 0, 0,0 };
  49. TYP             stdfunc = {bt_func, 1, UF_DEFINED | UF_USED,0,0,-1, -1, 0, {0, 0}, &stdint, 0,0};
  50. extern TYP      *head;          /* shared with decl */
  51. extern TABLE    tagtable;
  52. extern char declid[100];
  53. extern int goodcode;
  54. extern int prm_cplusplus;
  55. extern int regdsize,regasize,regfsize,stackadd,stackmod;
  57. int skm_closepa[] = { closepa, comma, semicolon, end, 0 };
  58. int skm_closebr[] = { closebr, comma, openbr, semicolon, end, 0 };
  59. static SYM *lastsym;
  60. static int globaldref = 0;
  61. static char regname[] = "processor reg" ;
  62. static char *nm = 0;
  63. static TYP *asntyp = 0;
  64. static int dumpos;
  65. static SYM undef;
  66. void exprini(void)
  67. {
  68. globaldref = 0;
  69. asntyp = 0;
  70. dumpos = 0;
  71. undef.value.i = 0;
  72. undef.name = "UNDEFINED";
  73. }
  74. ENODE    *makenode(enum e_node nt, char *v1, char *v2)
  75. /*
  76.  *      build an expression node with a node type of nt and values
  77.  *      v1 and v2.
  78.  */
  79. {       ENODE    *ep;
  80.         ep = xalloc(sizeof(ENODE));
  81.         ep->nodetype = (char)nt;
  82. ep->cflags = 0;
  83.         ep->v.p[0] = v1;
  84.         ep->v.p[1] = v2;
  85.         return ep;
  86. }
  88. TYP *deref(ENODE **node, TYP *tp)
  89. /*
  90.  *      build the proper dereference operation for a node using the
  91.  *      type pointer tp.
  92.  */
  93. {
  94. ENODE *onode = *node;
  95. switch( tp->type ) {
  96. case bt_double:
  97.                         *node = makenode(en_doubleref,*node,0);
  98.                         break;
  99. case bt_longdouble:
  100.                         *node = makenode(en_longdoubleref,*node,0);
  101.                         break;
  102. case bt_float:
  103.                         *node = makenode(en_floatref,*node,0);
  104.                         break;
  105. case bt_unsignedchar:
  106.                         *node = makenode(en_ub_ref,*node,0);
  107.                         break;
  108. case bt_unsignedshort:
  109.                         *node = makenode(en_uw_ref,*node,0);
  110.                         break;
  111.                 case bt_char:
  112.                         *node = makenode(en_b_ref,*node,0);
  113.                         break;
  114.                 case bt_short:
  115.                 case bt_enum:
  116.                         *node = makenode(en_w_ref,*node,0);
  117.                         break;
  118.                 case bt_unsigned:
  119.                         *node = makenode(en_ul_ref,*node,0);
  120. break;
  121.                 case bt_long:
  122.                 case bt_matchall:
  123.                 case bt_pointer:
  124. case bt_ptrfunc:
  125. case bt_ref:
  126.                         *node = makenode(en_l_ref,*node,0);
  127.                         break;
  128.                 default:
  129.                         generror(ERR_DEREF,0,0);
  130.                         break;
  131.                 }
  132. (*node)->cflags = onode->cflags;
  133.         return tp;
  134. }
  135. ENODE *dummyvar(int size, TYP *type)
  136. {
  137. char nm[20];
  138. ENODE *newnode;
  139. SYM *sp = xalloc(sizeof(SYM));
  140. sprintf(nm,"**DUMMY%d",dumpos++);
  141. sp->name = litlate(nm);
  142. sp->defalt = 0;
  143.   sp->storage_class = sc_auto;
  144.   sp->tp = type;
  145. type->uflags |= UF_USED;
  146. sp->extflag = FALSE;
  147. sp->absflag = FALSE;
  148. sp->intflag = FALSE;
  149. sp->pascaldefn = FALSE;
  150. sp->init = 0;
  151. sp->indecltable = 0;
  152. sp->funcparm = 0;
  153. sp->inreg = 0;
  154. sp->staticlabel = FALSE;
  155. sp->value.i = block_nesting;
  156. insert(sp,&lsyms);
  157. newnode = makenode(en_autocon,sp,0);
  158. return newnode;
  159. }
  160. int isintconst(int type)
  161. {
  162. switch (type) {
  163. case en_icon:
  164. case en_lcon:
  165. case en_lucon:
  166. case en_iucon:
  167. case en_ccon:
  168. return 1;
  169. }
  170. return 0;
  171. }
  172. TYP     *nameref(ENODE **node)
  173. /*
  174.  * get an identifier.  If it is followed by parenthesis gather the
  175.  * function parms.  If it is an undefined function declare it as external
  176.  * for now.
  177.  */
  178. {       SYM             *sp;
  179.         TYP             *tp,*tp1;
  180. ENODE *pnode=0,*qnode = 0;
  181. int fn = FALSE;
  182. char buf[100];
  183. strcpy(buf,lastid);
  184. getsym();
  185. /* Get function args */
  186. if (lastst == openpa) {
  187. fn = TRUE;
  188. getsym();
  189. tp1 = gatherparms(&pnode);
  190. sp = funcovermatch(buf,tp1);
  191. if (sp)
  192. tp1->sname = nm = sp->name;
  193. else
  194. #ifdef CPLUSPLUS
  195. if (prm_cplusplus)
  196. tp1->sname = nm = cppmangle(buf,tp1);
  197. else
  198. #endif
  199. tp1->sname = nm = litlate(buf);
  200. }
  201. else {
  202. nm = litlate(buf);
  203. sp = gsearch(nm);
  204. }
  205.         if( sp == 0 ) {
  206. /* No such identifier */
  207.                 if (fn) {
  208. /* External function, put it in the symbol table */
  209. #ifdef CPLUSPLUS
  210. if (prm_cplusplus) 
  211. gensymerror(ERR_NOFUNCMATCH,nm);
  212. else
  213. #endif
  214. gensymerror(ERR_NOPROTO,nm);
  215.                         ++global_flag;
  216. sp = xalloc(sizeof(SYM));
  217.                  sp->name = litlate(nm);
  218. sp->tp = maketype(bt_func,0);
  219. *(sp->tp) = stdfunc;
  220.                         sp->storage_class = sc_externalfunc;
  221. sp->extflag = TRUE;
  222.                         insert(sp,&gsyms);
  223.                         --global_flag;
  224.                         *node = makenode(en_napccon,sp,0);
  225. parmlist(&pnode,tp1,0);
  226. *node = makenode(en_void,*node,pnode);
  227.                         tp = &stdint;
  228. qnode = makenode(en_icon,(char *)-4,0);
  229.                       *node = makenode(en_fcall,qnode,*node);
  230. goodcode |= GF_ASSIGN;
  231.                         }
  232.                 else    {
  233. /* External non-function.  These also get put in the symbol table so that
  234.  * we don't keep spitting errors out but also put an error out
  235.  */
  236. #ifdef CPLUSPLUS
  237. if (prm_cplusplus && asntyp && asntyp->type == bt_ptrfunc) {
  238. sp = funcovermatch(lastid,asntyp);
  239. if (sp)
  240. goto foundsp;
  241. }
  242. #endif
  243. sp = xalloc(sizeof(SYM));
  244.                  sp->name = nm;
  245.                         sp->tp = tp = &stdmatch;
  246. sp->storage_class = sc_external;
  247. insert(sp,&lsyms);
  248. *node = makenode(en_nacon,&undef,0);
  249. gensymerror(ERR_UNDEFINED,nm);
  250.                         tp = deref(node,tp);
  251.                         }
  252.                 }
  253.         else    {
  254. /* If we get here the symbol was already in the table
  255.  */
  256. foundsp:
  257. sp->tp->uflags |= UF_USED;
  258.                 if( (tp = sp->tp) == 0 ) {
  259. /* This lack of type info should never happen */
  260.                         tp = &stdmatch;
  261. *node = makenode(en_nacon,&undef,0);
  262. gensymerror(ERR_UNDEFINED,nm);
  263.                         tp = deref(node,tp);
  264.                         return tp;       /* guard against untyped entries */
  265.                         }
  266.                 switch( sp->storage_class ) {
  267.                         case sc_static:
  268.                         case sc_global:
  269.                         case sc_external:
  270.                         case sc_externalfunc:
  271. case sc_abs:
  272. sp->extflag = TRUE;
  273. if (fn) {
  274. /* make a function node */
  275. if (sp->tp->type == bt_ptrfunc)
  276.                                  *node = makenode(en_nacon,sp,0);
  277. else
  278.                                  *node = makenode(en_napccon,sp,0);
  279. isfunc:
  280. if (sp->tp->type != bt_ptrfunc && sp->tp->type != bt_func && sp->tp->type != bt_ifunc)
  281. generror(ERR_MISMATCH,0,0);
  282. if (sp->tp->type == bt_ptrfunc)
  283. tp = deref(node,tp);
  284. #ifdef CPLUSPLUS
  285. if (prm_cplusplus && !strcmp(buf,"main"))
  286. generror(ERR_NOMAIN,0,0);
  287. #endif
  288. parmlist(&pnode,tp1,sp->tp);
  289. *node = makenode(en_void,*node,pnode);
  290. qnode = makenode(en_icon,(char *)sp->tp->btp->size,0);
  291.                                   tp = tp->btp;
  292. if (sp->intflag)
  293.                                  *node = makenode(en_intcall,qnode,*node);
  294. else
  295. if (tp->type == bt_union || tp->type == bt_struct) {
  296. if (sp->pascaldefn)
  297.                                  *node = makenode(en_pfcallb,qnode,*node);
  298. else 
  299.                                  *node = makenode(en_fcallb,qnode,*node);
  300. (*node)->size = tp->size;
  301. }
  302. else
  303. if (sp->pascaldefn)
  304.                                *node = makenode(en_pfcall,qnode,*node);
  305. else
  306.                                *node = makenode(en_fcall,qnode,*node);
  307. if (tp)
  308. (*node)->cflags = tp->cflags;
  309. goodcode |= GF_ASSIGN;
  310. }
  311. else
  312. /* otherwise make a node for a regular variable */
  313. if (sp->absflag)
  314.                                  *node = makenode(en_absacon,sp,0);
  315. else
  316. if (sp->tp->type == bt_func || sp->tp->type == bt_ifunc) {
  317. fn = TRUE;
  318.                                  *node = makenode(en_napccon,sp,0);
  319. }
  320. else
  321. if (sp->staticlabel)
  322. *node = makenode(en_nalabcon,(char *)sp->value.i,0);
  323. else
  324.                                  *node = makenode(en_nacon,sp,0);
  325.                                 break;
  326.                         case sc_const:
  327. /* constants and enums */
  328.                                 *node = makenode(en_icon,(char *)sp->value.i,0);
  329. return &stdint;
  330.                         default:        /* auto and any errors */
  331.                                 if( sp->storage_class != sc_auto && sp->storage_class != sc_autoreg) {
  332.                                         gensymerror(ERR_ILLCLASS2,sp->name);
  333. tp = 0;
  334. }
  335. else {
  336. /* auto variables */
  337.   if (sp->storage_class == sc_auto)
  338.                                  *node = makenode(en_autocon,sp,0);
  339. else if (sp->storage_class == sc_autoreg)
  340.                                  *node = makenode(en_autoreg,sp,0);
  341. if (fn)
  342. goto isfunc;
  343. }
  344.                                 break;
  345.                         }
  346. /* dereference if it isn't an array or structure address */
  348. (*node)->cflags = tp->cflags;
  349. /* deref if not an array or if is function parm */
  350.               if(!fn && tp && (tp->val_flag == 0 || (sp->funcparm && tp->type == bt_pointer)))
  351.                         tp = deref(node,tp);
  352. /* and dereference again if it is a refernece variable */
  353. if (tp->type == bt_ref) {
  354. tp = tp->btp;
  355. tp = deref(node,tp);
  356. }
  358.                 }
  359. lastsym = sp;
  360.         return tp;
  361. }
  363. void promote_type(TYP *typ, ENODE **node)
  364. /*
  365.  * Type promotion for casts and function args 
  366.  */
  367. {
  368. switch (typ->type) {
  369. case bt_char:
  370. *node = makenode(en_cb,*node,0);
  371. break;
  372. case bt_unsignedchar:
  373. *node = makenode(en_cub,*node,0);
  374. break;
  375. case bt_enum:
  376. case bt_short:
  377.    *node = makenode(en_cw,*node,0);
  378.    break;
  379. case bt_unsignedshort:
  380.    *node = makenode(en_cuw,*node,0);
  381. break;
  382.    case bt_long:
  383.      *node = makenode(en_cl,*node,0);
  384. break;
  385. case bt_unsigned:
  386. *node = makenode(en_cul,*node,0);
  387.    break;
  388. case bt_float:
  389.    *node = makenode(en_cf,*node,0);
  390. break;
  391. case bt_double:
  392. *node = makenode(en_cd,*node,0);
  393. break;
  394. case bt_longdouble:
  395. *node = makenode(en_cld,*node,0);
  396. break;
  397. default:
  398. *node = makenode(en_cp,*node,0);
  399. break;
  400. }
  401. (*node)->cflags = typ->cflags;
  402. }
  403. TYP *gatherparms( ENODE **node)
  404. /*
  405.  * create a type tree and primary parameter list for a function
  406.  *
  407.  * At this point the parameter list is backwards from what codegen
  408.  * needs!
  409.  */
  410. {
  411. ENODE *ep1 = 0,*ep2=0,**ep3 = &ep1;
  412. TABLE tbl;
  413. SYM **t = &tbl.head,*newt;
  414. TYP *tp;
  415. int ogc = goodcode;
  416. tbl.tail = tbl.head = 0;
  417. goodcode |= DF_FUNCPARMS;
  418. if (lastst == closepa) {
  419. #ifdef CPLUSPLUS
  420. if (prm_cplusplus)
  421. tbl.head=tbl.tail=(SYM *)-1;
  422. else
  423. #endif
  424. tbl.head=tbl.tail = 0;
  425. }
  426. else if (lastst == kw_void)
  427. tbl.head = tbl.tail = (SYM *)-1;
  428. else
  429.   while (lastst != closepa) {
  430. tp = exprnc(&ep2);
  431. if (!tp) {
  432. generror(ERR_EXPREXPECT,0,0);
  433. break;
  434. }
  435. ep2->cflags = tp->cflags;
  436. newt = xalloc(sizeof(SYM));
  437. newt->tp = tp;
  438. newt->next = 0;
  439. newt->name = 0;
  440. *t = newt;
  441. t = &newt->next;
  442. tbl.tail = newt;
  443. *ep3 = makenode(en_void,ep2,0);
  444. ep3 = &(*ep3)->v.p[1];
  445. if (lastst == comma)
  446. getsym();
  447. }
  448. needpunc(closepa,skm_closepa);
  449. tp = maketype(bt_func,0);
  450. tp->btp = &stdint;
  451. tp->lst = tbl;
  452. tp->bits = -1;
  453. tp->startbit = -1;
  454. tp->uflags = UF_DEFINED | UF_USED;
  455. goodcode = ogc;
  456. *node = ep1;
  457. return tp;
  458. }
  459. void checkparmconst(TYP *tp, TYP *tpi)
  460. /*
  461.  * Check the CONST flags for parameters
  462.  */
  463. {
  464. if (tpi->type != bt_pointer && tpi->type != bt_ref)
  465. return;
  466. while ((tp->type == bt_pointer || tp->type == bt_ref)&& !tp->val_flag && (!tpi || tpi->type == bt_pointer || tpi->type == bt_ref)) {
  467. if ((tp->cflags & DF_CONST) && (!tpi || !(tpi->cflags & DF_CONST)))
  468. generror(ERR_MODCONS,0,0);
  469. tp = tp->btp;
  470. tpi = tpi->btp;
  471. }
  472. if ((tp->cflags & DF_CONST) && (!tpi || !(tpi->cflags & DF_CONST)))
  473. generror(ERR_MODCONS,0,0);
  474. }
  475. void parmlist(ENODE **node, TYP *tpi, TYP *tp)
  476. /*
  477.  * take the primary type and node trees, the function argument expectations,
  478.  * and check for type mismatch errors
  479.  *
  480.  * also reverse the primary node tree so the parms will be ready for
  481.  * code generation
  482.  */
  483. {       ENODE    *ep1=0,*ep2=0,*ep3=*node;
  484. SYM *spi=tpi->lst.head,*sp=0;
  485. TYP *tp2;
  486. int matching = FALSE;
  487. if (tp)
  488. sp=tp->lst.head;
  489. if (tp && !sp)
  490. gensymerror(ERR_NOPROTO,tpi->sname);
  492. if (!prm_cplusplus && sp && sp != (SYM *)-1 && sp->tp->type != bt_ellipse)
  493. matching = TRUE;
  494. while (TRUE) {
  495. if (!spi || spi == (SYM *)-1){
  496. if (sp == (SYM *) -1)
  497. break;
  498. if (sp && sp->tp->type != bt_ellipse) 
  499. if (!sp->defalt) 
  500. genfuncerror(ERR_CALLLENSHORT,tpi->sname,0);
  501. else
  502. while (sp && sp != (SYM *)-1) {
  503. if (sp->tp->val_flag && (sp->tp->type == bt_struct || sp->tp->type == bt_union)) {
  504. ep1 = makenode(en_stackblock,sp->defalt,ep1);
  505. sp->defalt->size = sp->tp->size;
  506. }
  507. else
  508.               ep1 = makenode(en_void,sp->defalt,ep1);
  509. sp = sp->next;
  510. }
  511. break;
  512. }
  513. else {
  514. ep2 = ep3->v.p[0];
  515. ep3 = ep3->v.p[1];
  516. if (matching) {
  517. if (!sp || sp == (SYM *)-1) {
  518. genfuncerror(ERR_CALLLENLONG,tpi->sname,0);
  519. break;
  520. }
  521. else {
  522. checkparmconst(spi->tp,sp->tp);
  523. if (!checktype(spi->tp,sp->tp))
  524.    if (isscalar(sp->tp) && isscalar(spi->tp))
  525. promote_type(sp->tp,&ep2);
  526. else
  527. if (sp->tp->type == bt_pointer) {
  528. if (isintconst(ep2->nodetype)) {
  529. if (ep2->v.i != 0)
  530. generror(ERR_NONPORT,0,0);
  531. }
  532. else if (spi->tp->type != bt_pointer)
  533. genfuncerror(ERR_CALLMISMATCH,tpi->sname,sp->name);
  534.   }
  535. else genfuncerror(ERR_CALLMISMATCH,tpi->sname,sp->name);
  536. }
  537. }
  538. }
  539. if (sp && sp->tp->type == bt_ref) {
  540. if (lvalue(ep2)) {
  541. while (castvalue(ep2))
  542. ep2 = ep2->v.p[0];
  543. ep2 = ep2->v.p[0];
  544. }
  545. else {
  546. ENODE *x;
  547. tp2 = sp->tp->btp;
  548. genfuncerror(ERR_TEMPUSED,tpi->sname,sp->name);
  549. ep2 = makenode(en_refassign,dummyvar(tp2->size,tp2),ep2);
  550. }
  551. }
  552. if (spi && spi != (SYM *) -1 && spi->tp->val_flag && (spi->tp->type == bt_struct || spi->tp->type == bt_union)) {
  553. ep1 = makenode(en_stackblock,ep2,ep1);
  554. ep2->size = sp->tp->size;
  555. }
  556. else
  557.              ep1 = makenode(en_void,ep2,ep1);
  558. spi = spi->next;
  559.   if (sp && sp != (SYM *)-1) {
  560. sp = sp->next;
  561.   if (sp && sp->tp->type == bt_ellipse)
  562. matching = FALSE;
  563. }
  564. }
  565. if (tp)
  566. promote_type(tp->btp,&ep1);
  567. else
  568. promote_type(tpi->btp,&ep1);
  569. *node = ep1;
  570. }
  572. int floatrecurse(ENODE *node)
  573. /*
  574.  * Go through a node and see if it will be promoted to type FLOAT
  575.  */
  576. {
  577. if (!node)
  578. return 0;
  579. switch (node->nodetype) {
  580. case en_rcon:
  581. case en_lrcon:
  582. case en_fcon:
  583. case en_doubleref:
  584. case en_longdoubleref:
  585. case en_floatref:
  586. case en_cld:
  587. case en_cd:
  588. case en_cf:
  589. return 1;
  590.                 case en_labcon: case en_trapcall: 
  591.                 case en_nacon:  case en_autocon:  case en_autoreg: case en_nalabcon:
  592.                 case en_l_ref:  case en_tempref: case en_napccon: case en_absacon:
  593. case en_cl: case en_regref:
  594.                 case en_ul_ref:
  595. case en_cul:
  596. case en_cp:
  597.                 case en_icon:
  598. case en_lcon: case en_iucon: case en_lucon: case en_ccon:
  599. case en_bits:
  600.                 case en_ub_ref:
  601. case en_cub:
  602.                 case en_b_ref:
  603. case en_cb:
  604.                 case en_uw_ref:
  605. case en_cuw:
  606.                 case en_cw:
  607.                 case en_w_ref:
  608.                 case en_eq:     case en_ne:
  609.                 case en_lt:     case en_le:
  610.                 case en_gt:     case en_ge:
  611. case en_ugt: case en_uge: case en_ult: case en_ule:
  612.                         return 0;
  613. case en_fcall: case en_pfcall:
  614. case en_fcallb: case en_pfcallb:
  615. case en_callblock:
  616. return(floatrecurse(node->v.p[1]));
  617.                 case en_not:    case en_compl:
  618.                 case en_uminus: 
  619.                 case en_ainc:   case en_adec:
  620. case en_moveblock: case en_stackblock:
  621.                         return floatrecurse(node->v.p[0]);
  622. case en_refassign: case en_assign:
  623.                 case en_add:    case en_sub:
  624. case en_umul: case en_udiv: case en_umod: case en_pmul:
  625.                 case en_mul:    case en_div:
  626.                 case en_mod:    case en_and:
  627.                 case en_or:     case en_xor:
  628. case en_asalsh: case en_asarsh: case en_alsh: case en_arsh:
  629.                 case en_lsh:    case en_rsh:
  630.                 case en_land:   case en_lor:
  631.                 case en_asadd:  case en_assub:
  632.                 case en_asmul:  case en_asdiv:
  633.                 case en_asmod:  case en_asand:
  634. case en_asumod: case en_asudiv: case en_asumul:
  635.                 case en_asor:   case en_aslsh: case en_asxor:
  636.                 case en_asrsh:
  637.                         return(floatrecurse(node->v.p[0]) || floatrecurse(node->v.p[1]));
  638.                 case en_void:   case en_cond:
  639.                         return floatrecurse(node->v.p[1]);
  640. }
  641. return(0);
  642. }
  643. void floatcheck(ENODE *node)
  644. /*
  645.  * Error if node will be promoted to type float
  646.  */
  647. {
  648. if (floatrecurse(node))
  649. generror(ERR_INVFLOAT,0,0);
  650. }
  651. int     castbegin(int st)
  652. /*
  653.  *      return 1 if st in set of [ kw_char, kw_short, kw_long, kw_int,
  654.  *      kw_float, kw_double, kw_struct, kw_union, kw_float, or is typedef ]
  655.  */
  656. {      
  657. SYM *sp;
  658. switch(st) {
  659. case kw_void:
  660. case kw_char: case kw_short: case kw_int: case kw_long:
  661. case kw_float: case kw_double:
  662. case kw_struct: case kw_union: case kw_signed:
  663. case kw_unsigned: case kw_volatile: case kw_const:
  664. return 1;
  665. default:
  666. if (st != id)
  667. return 0;
  668. } 
  669. nm = lastid;
  670. sp = gsearch(lastid);
  671. if (!sp)
  672. sp = search(lastid,&lsyms);
  673. if (sp && sp->storage_class == sc_type)
  674. return 1 ;
  675. return 0;
  676. }
  678. int tostring()
  679. {
  680. short string[2048];
  681. int st = lastst;
  682. string[0] = 0;
  683. while (lastst == st) {
  684. if (st == lsconst) {
  685. if (pstrlen(string) +pstrlen(laststr) > 2040)
  686. generror(ERR_STRINGTOOBIG,0,0);
  687. else
  688. pstrcat(string,laststr);
  689. }
  690. else {
  691. if (strlen(string) +strlen(laststr) > 4090)
  692. generror(ERR_STRINGTOOBIG,0,0);
  693. else
  694. strcat(string,laststr);
  695. }
  696. getsym();
  697. }
  698. return(stringlit(string,st == lsconst));
  699. }
  700. TYP     *primary(ENODE **node)
  701. /*
  702.  *      primary will parse a primary expression and set the node pointer
  703.  *      returning the type of the expression parsed. primary expressions
  704.  *      are any of:
  705.  *                      id
  706.  *                      constant
  707.  *                      string
  708.  *                      ( expression )
  709.  *                      primary++
  710.  *                      primary--
  711.  *                      primary[ expression ]
  712.  *                      primary.id
  713.  *                      primary->id
  714.  *                      primary( parameter list )
  715.  * (* expression)( parameter list )
  716.  *                      (typecast)primary
  717.  *                      (typecast)(unary)
  718.  */
  719. {       ENODE    *pnode, *qnode, *rnode;
  720.         SYM             *sp=0;
  721.         TYP             *tptr,*tp1,*tp2;
  722. int flag = 0;
  723. int gcode,gdf;
  724. int isstring = FALSE;
  725.         switch( lastst ) {
  726. /* This trap thing should be in stmt.c */
  727. case kw__trap:    
  728. getsym();
  729. if (needpunc(openpa,0)) {
  730. long num = intexpr(0);
  731. if (num > 15 || num < 0)
  732. generror(ERR_INVTRAP,0,0);
  733. if (lastst == comma) 
  734. getsym();
  735. tptr = gatherparms(&pnode);
  736. parmlist(&pnode,tptr,0);
  737. qnode = makenode(en_icon,0,0);
  738. pnode = makenode(en_void,makenode(en_icon,(char *)num,0),pnode);
  739. pnode = makenode(en_trapcall,qnode,pnode);
  740. }
  741. goodcode |= GF_ASSIGN;
  742. *node = pnode;
  743. return &stdint;
  745. case kw_D0:
  746. case kw_D1:
  747. case kw_D2:
  748. case kw_D3:
  749. case kw_D4:
  750. case kw_D5:
  751. case kw_D6:
  752. case kw_D7:
  753. case kw_D8:
  754. case kw_D9:
  755. case kw_DA:
  756. case kw_DB:
  757. case kw_DC:
  758. case kw_DD:
  759. case kw_DE:
  760. case kw_DF:
  761. tptr = xalloc(sizeof(TYP));
  762. *tptr = stduns;
  763. tptr->sname = regname;
  764. pnode = makenode(en_regref,(char *)(regdsize*256+lastst-kw_D0),0);
  765. pnode = makenode(en_ul_ref,pnode,0);
  766. *node = pnode;
  767. getsym();
  768. return tptr;
  769. case kw_A0:
  770. case kw_A1:
  771. case kw_A2:
  772. case kw_A3:
  773. case kw_A4:
  774. case kw_A5:
  775. case kw_A6:
  776. case kw_A7:
  777. case kw_A8:
  778. case kw_A9:
  779. case kw_AA:
  780. case kw_AB:
  781. case kw_AC:
  782. case kw_AD:
  783. case kw_AE:
  784. case kw_AF:
  785. tptr = xalloc(sizeof(TYP));
  786. *tptr = stduns;
  787. tptr->sname = regname;
  788. pnode = makenode(en_regref,(char *)(regasize*256+lastst-kw_D0),0);
  789. pnode = makenode(en_ul_ref,pnode,0);
  790. *node = pnode;
  791. getsym();
  792. return tptr;
  793. case kw_F0:
  794. case kw_F1:
  795. case kw_F2:
  796. case kw_F3:
  797. case kw_F4:
  798. case kw_F5:
  799. case kw_F6:
  800. case kw_F7:
  801. case kw_F8:
  802. case kw_F9:
  803. case kw_FA:
  804. case kw_FB:
  805. case kw_FC:
  806. case kw_FD:
  807. case kw_FE:
  808. case kw_FF:
  809. tptr = xalloc(sizeof(TYP));
  810. *tptr = stdlongdouble;
  811. tptr->sname = regname;
  812. pnode = makenode(en_regref,(char *)(regfsize *256+lastst-kw_D0),0);
  813. pnode = makenode(en_longdoubleref,pnode,0);
  814. *node = pnode;
  815. getsym();
  816. return tptr;
  817.             case id:  
  818.                         tptr = nameref(&pnode);
  819.                         break;
  820.                 case iconst:
  821.                         tptr = &stdint;
  822.                         pnode = makenode(en_icon,(char *)ival,0);
  823.                         getsym();
  824. *node = pnode;
  825. return tptr;
  826.                 case iuconst:
  827.                         tptr = &stduns;
  828.                         pnode = makenode(en_iucon,(char *)ival,0);
  829.                         getsym();
  830. *node = pnode;
  831. return tptr;
  832.                 case lconst:
  833.                         tptr = &stdlong;
  834.                         pnode = makenode(en_lcon,(char *)ival,0);
  835.                         getsym();
  836. *node = pnode;
  837. return tptr;
  838.                 case luconst:
  839.                         tptr = &stdunsigned;
  840.                         pnode = makenode(en_lucon,(char *)ival,0);
  841.                         getsym();
  842. *node = pnode;
  843. return tptr;
  844.                 case cconst:
  845.                         tptr = &stdchar;
  846.                         pnode = makenode(en_ccon,(char *)ival,0);
  847.                         getsym();
  848. *node = pnode;
  849. return tptr;
  850. case rconst:
  851. tptr = &stddouble;
  852.          pnode = xalloc(sizeof(ENODE));
  853.         pnode->nodetype = en_rcon;
  854. pnode->cflags = 0;
  855. pnode->v.f = rval;
  856. getsym();
  857. *node = pnode;
  858. return tptr;
  859. case lrconst:
  860. tptr = &stdlongdouble;
  861.          pnode = xalloc(sizeof(ENODE));
  862.         pnode->nodetype = en_lrcon;
  863. pnode->cflags = 0;
  864. pnode->v.f = rval;
  865. getsym();
  866. *node = pnode;
  867. return tptr;
  868. case fconst:
  869. tptr = &stdfloat;
  870.          pnode = xalloc(sizeof(ENODE));
  871.         pnode->nodetype = en_fcon;
  872. pnode->cflags = 0;
  873. pnode->v.f = rval;
  874. getsym();
  875. *node = pnode;
  876. return tptr;
  877.                 case sconst:
  878. isstring = TRUE;
  879.                         tptr = &stdstring;
  880.                         pnode = makenode(en_labcon,(char *)tostring(),0);
  881. *node = pnode;
  882. break;
  883.                 case lsconst:
  884. isstring = TRUE;
  885.                         tptr = &stdstring;
  886.                         pnode = makenode(en_labcon,(char *)tostring(),0);
  887. *node = pnode;
  888. break;
  889.                 case openpa:
  890.                         getsym();
  891. if (lastst == star) {
  892. /* function pointers */
  893. gcode = goodcode;
  894. goodcode &= ~(GF_AND | GF_SUPERAND);
  895.                                 getsym();
  896. gdf = globaldref;
  897. globaldref = 1;
  898. tptr = expression(&pnode);
  899. globaldref = gdf;
  900. if (needpunc(closepa, skm_closepa)) {
  901. if (tptr->type == bt_ptrfunc) {
  902. tptr = deref(&pnode,tptr);
  903. goodcode = gcode;
  904. if (needpunc(openpa,skm_closepa)) {
  905. goodcode |= GF_ASSIGN;
  906. tp1 = gatherparms(&qnode);
  907. tp1->sname = tptr->sname;
  908. parmlist(&qnode,tp1,tptr);
  909. rnode = makenode(en_icon,(char *)tptr->btp->size,0);
  910. pnode = makenode(en_void,pnode,qnode);
  911. if (tptr->cflags & DF_INT)
  912.                                pnode = makenode(en_intcall,rnode,pnode);
  913. else
  914. if (tptr->type == bt_union || tptr->type == bt_struct) {
  915. if (lastsym && lastsym->pascaldefn)
  916.                                pnode = makenode(en_pfcallb,rnode,pnode);
  917. else
  918.                                pnode = makenode(en_fcallb,rnode,pnode);
  919. pnode->size = tptr->size;
  920. }
  921. else
  922. if (lastsym && lastsym->pascaldefn)
  923.                                pnode = makenode(en_pfcall,rnode,pnode);
  924. else
  925.                                pnode = makenode(en_fcall,rnode,pnode);
  926. pnode->cflags = tptr->btp->cflags;
  927. tptr = tptr->btp;
  928. break;
  929. }
  930. }
  931. else {
  932. goodcode = gcode | (goodcode & GF_ASSIGN);
  933.                         break;
  934.   }
  935. }
  936. else
  937. goodcode = gcode | GF_ASSIGN;
  938. *node = pnode;
  939. return tptr;
  940. }
  941. else
  942. castcont:
  943.                           if( !castbegin(lastst) ) {
  944. /* an expression in parenthesis */
  945. gcode = goodcode;
  946. goodcode &= ~(GF_AND | GF_SUPERAND);
  947. gdf = globaldref;
  948. globaldref = 0;
  949. tptr = expression(&pnode);
  950. globaldref = gdf;
  951. goodcode = gcode | (goodcode & GF_ASSIGN);
  952.                                 needpuncexp(closepa,skm_closepa);
  953. goto contfor;
  954.                                 }
  955.                           else    {       /* cast operator */
  956. /* a cast */
  957. declid[0] = 0;
  958.                                 decl(0); /* do cast declaration */
  959.                                 decl1();
  960.                                 tptr = head;
  961.                                 if (needpunc(closepa, 0)) {
  962. gcode = goodcode;
  963. goodcode &= ~(GF_AND | GF_SUPERAND);
  964. gdf = globaldref;
  965. globaldref = 0;
  966.                                  if( (unary(&pnode)) == 0 ) {
  967.                                         generror(ERR_IDEXPECT,0,0);
  968.                                         tptr = 0;
  969.                                  }
  970. globaldref = gdf;
  971. goodcode = gcode | (goodcode & GF_ASSIGN);
  972. pnode->cflags = tptr->cflags;
  973. if (tptr) {
  974. promote_type(tptr, &pnode);
  975. }
  976. }
  977. else
  978. return(0);
  979. }
  980. *node = pnode;
  981. return tptr;
  982.                 default:
  983.                         return 0;
  984.                 }
  985. contfor:
  986. /* modifiers that can appear after an expression */
  987.         for(;;) {
  988. int i;
  989.                 switch( lastst ) {
  990.                         case autoinc:
  991. case autodec:
  992. if (isstring)
  993. generror(ERR_INVALIDSTRING,0,0);
  994.                                 if( tptr->type == bt_pointer )
  995.                                         i = tptr->btp->size;
  996.                                 else
  997.                                         i = 1;
  998. if (i == 0)
  999. generror(ERR_ZEROPTR,0,0);
  1000.                                 if(! lvalue(pnode) ) 
  1001.                                   generror(ERR_LVALUE,0,0);
  1002. if (pnode->cflags & DF_CONST)
  1003. generror(ERR_MODCONS,0,0);
  1005.                                 pnode = makenode(lastst==autoinc ? en_ainc : en_adec,pnode,(char *)i);
  1006. goodcode |= GF_ASSIGN;
  1007.                                 getsym();
  1008. break;
  1009.                         case openbr:    /* build a subscript reference */
  1010. flag = 1;
  1011.                                 if( tptr->type != bt_pointer )
  1012.                                         generrorexp(ERR_NOPOINTER,0,skm_closebr);
  1013.                                 else
  1014.                                         tptr = tptr->btp;
  1015.                                 getsym();
  1016.                                 qnode = makenode(en_icon,(char *)tptr->size,0);
  1017. gcode = goodcode;
  1018. goodcode &= ~(GF_AND | GF_SUPERAND);
  1019. gdf = globaldref;
  1020. globaldref = 0;
  1021. tp2 = expression(&rnode);
  1022. globaldref = gdf;
  1023. goodcode = gcode & ~GF_ASSIGN;
  1024. if (!isscalar(tp2) || tp2->type == bt_float || tp2->type == bt_double || tp2->type == bt_longdouble)
  1025.                                   generror(ERR_ARRAYMISMATCH,0,0);
  1026.                                 qnode = makenode(en_pmul,qnode,rnode);
  1027.                                 pnode = makenode(en_add,pnode,qnode);
  1028. pnode->cflags = tptr->cflags;
  1029.                                 if( tptr->val_flag == 0 )
  1030.                                         tptr = deref(&pnode,tptr);
  1031.                                 needpuncexp(closebr,skm_closebr);
  1032.                              break;
  1033.                         case pointsto: /* pointer reference */
  1034.                                 if( tptr->type != bt_pointer ) {
  1035.                                         generror(ERR_NOPOINTER,0,0);
  1036. while (lastst == pointsto || lastst == dot) {
  1037. getsym();
  1038. getsym();
  1039. }
  1040. break;
  1041. }
  1042.                                 else
  1043.                                         tptr = tptr->btp;
  1044. pnode->cflags = tptr->cflags;
  1045.                                 if( tptr->val_flag == 0 ) {
  1046.                                         pnode = makenode(en_l_ref,pnode,0);
  1047. pnode->cflags = tptr->cflags;
  1048. }
  1050. /*
  1051.  *      fall through to dot operation
  1052.  */
  1053.                         case dot:
  1054. if (isstring)
  1055. generror(ERR_INVALIDSTRING,0,0);
  1056.                                 getsym();       /* past -> or . */
  1057.                                 if( lastst != id )
  1058.                                         generror(ERR_IDEXPECT,0,0);
  1059.                                 else    {
  1060.                                         sp = search(nm=litlate(lastid),&tptr->lst);
  1061.                                         if( sp == 0 ) {
  1062.                          tptr = &stdmatch;
  1063. pnode = makenode(en_nacon,&undef,0);
  1064.                                                 gensymerror(ERR_UNDEFINED,nm);
  1065. getsym();
  1066. while (lastst == pointsto || lastst == dot) {
  1067. getsym();
  1068. getsym();
  1069. }
  1070. }
  1071.                                         else    {
  1073.                                                 tp2 = sp->tp;
  1074. if (pnode->nodetype == en_fcallb || pnode->nodetype == en_pfcallb) {
  1075. if (pnode->nodetype == en_pfcallb) 
  1076. pnode = makenode(en_pcallblock,dummyvar(pnode->size,tp2),pnode);
  1077. else
  1078. pnode = makenode(en_callblock,dummyvar(pnode->size,tp2),pnode);
  1080. }
  1081.                                                 qnode = makenode(en_icon,(char *)sp->value.i,0);
  1082.                                                 pnode = makenode(en_add,pnode,qnode);
  1083. pnode->cflags = tptr->cflags | pnode->v.p[0]->cflags;
  1084. tp2->uflags |= tptr->uflags;
  1085. tptr = tp2; 
  1086.                                                 if( tptr->val_flag == 0 )
  1087.                                                     tptr = deref(&pnode,tptr);
  1088. if (tp2->bits != -1) {
  1089. qnode = pnode;
  1090. pnode = makenode(en_bits,qnode,0);
  1091. pnode->bits = tp2->bits;
  1092. pnode->startbit = tp2->startbit;
  1093. pnode->cflags = tptr->cflags | pnode->v.p[0]->cflags;
  1094. }
  1095.                                         }
  1096.                                         getsym();       /* past id */
  1097.                                 }
  1098.                                 break;
  1099.                         case openpa:    /* function reference */
  1100. /* this SHOULD have been handled in nameref rather than here.  However
  1101.  * there are some weird cases like putting function names in parenthesis
  1102.  * or in hook expressions, so this has to be here too.
  1103.  */
  1104. flag = 1;
  1105. if (isstring)
  1106. generror(ERR_INVALIDSTRING,0,0);
  1107.                                 if( tptr->type != bt_func &&
  1108.                                         tptr->type != bt_ifunc && tptr->type != bt_ptrfunc) {
  1109.                                         gensymerrorexp(ERR_NOFUNC,nm);
  1110. expskim(skm_closepa);
  1111. }
  1112.                                 else {
  1113. #ifdef CPLUSPLUS
  1114. if (prm_cplusplus && !strcmp(nm,"main"))
  1115. generror(ERR_NOMAIN,0,0);
  1116. #endif
  1117. if (!sp && tptr->sname)
  1118. sp=gsearch(tptr->sname);
  1119. if (tptr->type == bt_ptrfunc)
  1120. tptr = deref(&pnode,tptr);
  1121.                                  getsym();
  1122. tp1 =gatherparms(&qnode);
  1123. parmlist(&qnode,tp1,tptr);
  1124. rnode = makenode(en_icon,(char *)tptr->btp->size,0);
  1125. pnode = makenode(en_void,pnode,qnode);
  1126.                                         tptr = tptr->btp;
  1127. if (sp && sp->intflag)
  1128.                                  pnode = makenode(en_intcall,rnode,pnode);
  1129. else
  1130. if (tptr->type == bt_union || tptr->type == bt_struct) {
  1131. if (lastsym && lastsym->pascaldefn)
  1132.                                pnode = makenode(en_pfcallb,rnode,pnode);
  1133. else
  1134.                                pnode = makenode(en_fcallb,rnode,pnode);
  1135. pnode->size = tptr->size;
  1136. }
  1137. else
  1138. if (lastsym && lastsym->pascaldefn)
  1139.                                pnode = makenode(en_pfcall,rnode,pnode);
  1140. else
  1141.                                pnode = makenode(en_fcall,rnode,pnode);
  1142. if (tptr)
  1143. pnode->cflags = tptr->cflags;
  1144. }
  1145. goodcode |= GF_ASSIGN;
  1146.                                 break;
  1147.                         default:
  1148.                                 goto fini;
  1149.                         }
  1150.                 }
  1151. fini:   *node = pnode;
  1152. /* symbol level error checking */
  1153. if (!flag && !isstring && !(goodcode & GF_AND) && lastsym && tptr->type != bt_func && tptr->type != bt_ifunc
  1154. &&!tptr->val_flag && lastsym->storage_class != sc_type 
  1155. && lastsym->storage_class != sc_static && lastsym->storage_class != sc_global
  1156. && lastsym->storage_class != sc_external && lastsym->storage_class != sc_externalfunc) {
  1157. if (!(lastsym->tp->uflags & UF_DEFINED) && lastst != assign
  1158. &&lastst != asplus && lastst != asminus && lastst != astimes
  1159. && lastst!= asdivide && lastst != asmodop && lastst != asrshift
  1160. && lastst != aslshift && lastst != asor && lastst != asxor && lastst != asand) {
  1161. gensymerror(ERR_SYMUNDEF,lastsym->name);
  1162. lastsym->tp->uflags |= UF_DEFINED;
  1163. }
  1164. lastsym->tp->uflags &=  ~UF_ASSIGNED;
  1165. }
  1166.         return tptr;
  1167. }
  1169. int castvalue(ENODE *node)
  1170. /*
  1171.  * See if this is a cast operator */
  1172. {
  1173. switch(node->nodetype) {
  1174. case en_cb: case en_cub: case en_bits:
  1175. case en_cw: case en_cuw:
  1176. case en_cl: case en_cul:
  1177. case en_cf: case en_cd: case en_cp: case en_cld:
  1178.                         return 1;
  1179.                 }
  1180.         return 0;
  1181. }
  1182. int     lvalue(ENODE *node)
  1183. /* See if this is an lvalue; that is has it been dereferenced?
  1184.  */
  1185. {       
  1186. if (!prm_cplusplus) {
  1187. while (castvalue(node))
  1188. node = node->v.p[0];
  1189. }
  1190. switch( node->nodetype ) {
  1191.                 case en_b_ref:
  1192.                 case en_w_ref:
  1193.                 case en_l_ref:
  1194.                 case en_ub_ref:
  1195.                 case en_uw_ref:
  1196.                 case en_ul_ref:
  1197. case en_floatref:
  1198. case en_doubleref:
  1199. case en_longdoubleref:
  1200.                         return 1;
  1201. case en_bits:
  1202.                         return lvalue(node->v.p[0]);
  1203.                 }
  1204.         return 0;
  1205. }
  1207. TYP     *unary(ENODE **node)
  1208. /*
  1209.  *      unary evaluates unary expressions and returns the type of the
  1210.  *      expression evaluated. unary expressions are any of:
  1211.  *
  1212.  *                      primary
  1213.  *                      ++unary
  1214.  *                      --unary
  1215.  *                      !unary
  1216.  *                      ~unary
  1217.  *                      &unary
  1218.  *                      -unary
  1219.  *                      *unary
  1220.  *                      sizeof(typecast)
  1221.  *
  1222.  */
  1223. {       TYP             *tp,*tp1;
  1224.         ENODE    *ep1, *ep2;
  1225.         int             flag, i,gdf;
  1226.         flag = 0;
  1227.         switch( lastst ) {
  1228.                 case autodec:
  1229.                         flag = 1;
  1230.                 /* fall through to common increment */
  1231.                 case autoinc:
  1232.                         getsym();
  1233. gdf = globaldref;
  1234. globaldref = 0;
  1235.                         tp = unary(&ep1);
  1236. globaldref = gdf;
  1237.                         if( tp == 0 ) {
  1238.                                 generror(ERR_IDEXPECT,0,0);
  1239.                                 return 0;
  1240.                                 }
  1241. goodcode |= GF_ASSIGN;
  1242.                         if( lvalue(ep1)) {
  1243.                                 if( tp->type == bt_pointer ) {
  1244. if (tp->btp->size == 0)
  1245. generror(ERR_ZEROPTR,0,0);
  1246.                                         ep2 = makenode(en_icon,(char *)tp->btp->size,0);
  1247. }
  1248.                                 else
  1249.                                         ep2 = makenode(en_icon,(char *)1,0);
  1250. if (ep1->cflags & DF_CONST)
  1251. generror(ERR_MODCONS,0,0);
  1252.                                 ep1 = makenode(flag ? en_assub : en_asadd,ep1,ep2);
  1253.                                 }
  1254.                         else {
  1255.                                 generror(ERR_LVALUE,0,0);
  1256. return(0);
  1257. }
  1258.                         break;
  1259.                 case minus:
  1260. case plus: {
  1261. int stt = lastst;
  1262.                         getsym();
  1263. gdf = globaldref;
  1264. globaldref = 0;
  1265.                         tp = unary(&ep1);
  1266. globaldref = gdf;
  1267. goodcode &= ~GF_ASSIGN;
  1268.                         if( tp == 0 ) {
  1269.                                 generror(ERR_IDEXPECT,0,0);
  1270.                                 return 0;
  1271.                                 }
  1272. if (stt == minus) 
  1273.                          ep1 = makenode(en_uminus,ep1,0);
  1274. }
  1275.                         break;
  1276.                 case not:
  1277.                         getsym();
  1278. gdf = globaldref;
  1279. globaldref = 0;
  1280.                         tp = unary(&ep1);
  1281. globaldref = gdf;
  1282. goodcode &= ~GF_ASSIGN;
  1283.                         if( tp == 0 ) {
  1284.                                 generror(ERR_IDEXPECT,0,0);
  1285.                                 return 0;
  1286.                                 }
  1287.                         ep1 = makenode(en_not,ep1,0);
  1288.                         break;
  1289.                 case compl:
  1290.                         getsym();
  1291. gdf = globaldref;
  1292. globaldref = 0;
  1293.                         tp = unary(&ep1);
  1294. globaldref = gdf;
  1295. goodcode &= ~GF_ASSIGN;
  1296.                         if( tp == 0 ) {
  1297.                                 generror(ERR_IDEXPECT,0,0);
  1298.                                 return 0;
  1299.                                 }
  1300. floatcheck(ep1);
  1301.                         ep1 = makenode(en_compl,ep1,0);
  1302.                         break;
  1303.                 case star:
  1304.                         getsym();
  1305. gdf = globaldref;
  1306. globaldref = 0;
  1307.                         tp = unary(&ep1);
  1308. globaldref = gdf;
  1309. goodcode &= ~GF_ASSIGN;
  1310.                         if( tp == 0 ) {
  1311.                                 generror(ERR_IDEXPECT,0,0);
  1312.                                 return 0;
  1313.                                 }
  1314.                         if( tp->btp == 0 ) {
  1315.                                 generror(ERR_DEREF,0,0);
  1316. }
  1317.                         else
  1318. if (tp->btp->type != bt_void)
  1319.                                 tp = tp->btp;
  1320. ep1->cflags = tp->cflags;
  1321.                         if( tp->val_flag == 0 )
  1322.                                 tp = deref(&ep1,tp);
  1323.                         break;
  1324.                 case and:
  1325.                         getsym();
  1326. if (!(goodcode & GF_INFUNCPARMS))
  1327. goodcode |= GF_AND;
  1328. gdf = globaldref;
  1329. globaldref = 0;
  1330.                         tp = unary(&ep1);
  1331. globaldref = gdf;
  1332. goodcode &= ~GF_AND;
  1333. goodcode &= ~GF_ASSIGN;
  1334.                         if( tp == 0 ) {
  1335.                                 generror(ERR_IDEXPECT,0,0);
  1336.                                 return 0;
  1337.                                 }
  1338. else 
  1339. if (tp->startbit != -1) 
  1340. generror(ERR_BFADDR,0,0);
  1341. else if (tp->cflags & DF_AUTOREG)
  1342. gensymerror(ERR_NOANDREG,tp->sname);
  1343. else if (tp->type == bt_pointer && tp->val_flag && !(goodcode & GF_SUPERAND))
  1344. generror(ERR_SUPERAND,0,0);
  1346.                         if( lvalue(ep1)) {
  1347.                                 ep1 = ep1->v.p[0];
  1348.   if (ep1->nodetype == en_regref)
  1349. gensymerror(ERR_NOANDREG,tp->sname);
  1350. }
  1351.                         tp1 = xalloc(sizeof(TYP));
  1352.                         tp1->size = 4;
  1353.                         tp1->type = bt_pointer;
  1354.                         tp1->btp = tp;
  1355.                         tp1->val_flag = 0;
  1356.                         tp1->lst.head = 0;
  1357.                         tp1->sname = 0;
  1358. tp = tp1;
  1359. break;
  1360.                 case kw_sizeof:
  1361.                         getsym();
  1362.                         needpunc(openpa,0);
  1363. if (castbegin(lastst)) {
  1364. sizeof_cast:
  1365.                          decl(0);
  1366. decl1();
  1367. }
  1368. else if (lastst == id) {
  1369. SYM *sp = gsearch(lastid);
  1370. if (!sp)
  1371. sp = search(lastid,&lsyms);
  1372. if (sp) {
  1373. goto sizeof_primary;
  1374. }
  1375. if ((sp = search(nm,&tagtable)) != 0) {
  1376. head = sp->tp;
  1377. getsym();
  1378. }
  1379. else {
  1380. generror(ERR_SIZE,0,0);
  1381. head = 0;
  1382. }
  1383. }
  1384. else if (lastst == kw_enum) {
  1385. getsym();
  1386. if (lastst == id) {
  1387. SYM *sp;
  1388. if ((sp = search(nm,&tagtable)) != 0) {
  1389. head = sp->tp;
  1390. getsym();
  1391. }
  1392. else goto sizeof_primary;
  1393. }
  1394. }
  1395. else  {
  1396. ENODE *node = 0;
  1397. sizeof_primary:
  1398. head = unary(&node);
  1399. }
  1400.                         if( head != 0 ) {
  1401. if (head->size == 0)
  1402. generror(ERR_SIZE,0,0);
  1403.                                 ep1 = makenode(en_icon,(char *)head->size,0);
  1404. }
  1405.                         else    {
  1406.                                 generror(ERR_IDEXPECT,0,0);
  1407.                                 ep1 = makenode(en_icon,(char *)0,0);
  1408.                                 }
  1409. goodcode &= ~GF_ASSIGN;
  1410.                         tp = &stdint;
  1411.                         needpunc(closepa,0);
  1412.                         break;
  1413.                 default:
  1414.                         tp = primary(&ep1);
  1415.                         break;
  1416.                 }
  1417. /* Dereference if necessary */
  1418. if (globaldref) {
  1419. globaldref = 0;
  1420. if (tp->type != bt_ptrfunc) {
  1421.   if( tp == 0 ) {
  1422.                generror(ERR_IDEXPECT,0,0);
  1423.        return 0;
  1424.           }
  1425. if( tp->btp == 0 ) {
  1426.        generror(ERR_DEREF,0,0);
  1427. }
  1428. else
  1429. if (tp->btp->type != bt_void)
  1430.           tp = tp->btp;
  1431. ep1->cflags = tp->cflags;
  1432.           if( tp->val_flag == 0 )
  1433.              tp = deref(&ep1,tp);
  1434. }
  1435. }
  1436.         *node = ep1;
  1437.         return tp;
  1438. }
  1439. TYP *maxsize(TYP *tp1, TYP *tp2)
  1440. /*
  1441.  * return the type that has the maximum size
  1442.  */
  1443. {
  1444. if (tp1->type > tp2->type)
  1445. return tp1;
  1446. return tp2;
  1447. }
  1448. TYP     *forcefit(ENODE **node1,TYP *tp1,ENODE **node2,TYP *tp2, int max, int allowpointers)
  1449. /*
  1450.  * compare two types and determine if they are compatible for purposes
  1451.  * of the current operation.  Return an appropriate type.  Also checks for
  1452.  * dangerous pointer conversions...
  1453.  */
  1454. { int error = ERR_MISMATCH;
  1455. TYP *tp3;
  1456.         switch( tp1->type ) {
  1457. case bt_void:
  1458. if (tp2->type != bt_void && tp2->type != bt_matchall)
  1459. break;
  1460. return tp1;
  1461.                 case bt_long:
  1462. if (isintconst((*node2)->nodetype)) {
  1463. if (isscalar(tp2) || (!prm_cplusplus && (tp2->type == bt_pointer || tp2 ->type == bt_ptrfunc)))
  1464. return tp2;
  1465. if (tp2->type != bt_matchall)
  1466. break;
  1467. }
  1468.                 case bt_matchall:
  1469.                         if( tp2->type == bt_matchall)
  1470. return(&stdint);
  1471.                         else if( tp2->type == bt_pointer)
  1472.                           return tp2;
  1473. else if  (allowpointers && (tp2->type == bt_pointer || tp2->type == bt_ptrfunc))
  1474. return &stdint;
  1475. else if (isscalar(tp2))
  1476. if (max)
  1477. return(maxsize(tp1,tp2));
  1478. else
  1479. return(tp1);
  1480.                         break;
  1481.                 case bt_pointer:
  1482. if (!prm_cplusplus && !max && (tp2->type == bt_short || tp2->type == bt_unsignedshort
  1483. || tp2->type == bt_char || tp2->type == bt_unsignedchar)) {
  1484. error = ERR_SHORTPOINTER;
  1485. break;
  1486. }
  1487.                         if( tp2->type == bt_pointer ||tp2->type == bt_ptrfunc) {
  1488.    if  (allowpointers) {
  1489.    while (tp1->type == bt_pointer && tp2->type == bt_pointer) {
  1490. tp1 = tp1->btp;
  1491. tp2 = tp2->btp;
  1492. }
  1493. if (tp1->type != tp2 ->type || tp1->size != tp2->size)
  1494. if (tp1->type != bt_void && tp2->type != bt_void)
  1495. generror(ERR_SUSPICIOUS,0,0);
  1496.   return &stdint;
  1497. }
  1498. else
  1499.                             return tp1;
  1500. }
  1501. if (!prm_cplusplus && isscalar(tp2))
  1502. if (max)
  1503. return(maxsize(tp1,tp2));
  1504. else
  1505. return(tp1);
  1506.                         break;
  1507. case bt_enum:
  1508.                 case bt_unsignedshort:
  1509.                 case bt_short:
  1510. if (isintconst((*node2)->nodetype)) {
  1511. if (!max && ((*node2)->v.i < -65536L || ((*node2)->v.i > 65535L))) {
  1512. error = ERR_LOSTCONV;
  1513. break;
  1514. }
  1515. return tp1;
  1516. }
  1517. else
  1518.   if (!max && (tp2->type == bt_long || tp2->type == bt_unsigned || (!prm_cplusplus && (tp2->type == bt_pointer) || tp2->type == bt_ptrfunc))) {
  1519.   error = ERR_LOSTCONV;
  1520.     break;
  1521. }
  1522.   if  (allowpointers && tp2->type == bt_pointer)
  1523. return &stdint;
  1524. else if (isscalar(tp2))
  1525. if (max)
  1526. return(maxsize(tp1,tp2));
  1527. else
  1528. return(tp1);
  1529. break;
  1530.                 case bt_char:
  1531.                 case bt_unsignedchar:
  1532. if (isintconst((*node2)->nodetype)) {
  1533. if (!max && ((*node2)->v.i < -256 || ((*node2)->v.i > 255))) {
  1534. error = ERR_LOSTCONV;
  1535. break;
  1536. }
  1537. return tp1;
  1538. }
  1539. else
  1540.   if (!max && (tp2->type == bt_long || tp2->type == bt_unsigned || ( !prm_cplusplus && tp2->type == bt_pointer)
  1541.   || tp2->type == bt_short || tp2->type == bt_unsignedshort)) {
  1542.   error = ERR_LOSTCONV;
  1543.     break;
  1544. }
  1545.   if  (allowpointers && (tp2->type == bt_pointer || tp2->type == bt_ptrfunc))
  1546. return &stdint;
  1547. else if (isscalar(tp2))
  1548. if (max)
  1549. return(maxsize(tp1,tp2));
  1550. else
  1551. return(tp1);
  1552. break;
  1553. case bt_float:
  1554. case bt_double:
  1555. case bt_longdouble:
  1556. if (isscalar(tp2))
  1557. return(tp1);
  1558. break;
  1559.                 case bt_unsigned:
  1560. if (isintconst((*node1)->nodetype)) {
  1561. if (isscalar(tp2) || (!prm_cplusplus && tp2->type == bt_pointer))
  1562. return tp2;
  1563. break;
  1564. }
  1565.                         if( !prm_cplusplus && (tp2->type == bt_pointer  || tp2->type == bt_ptrfunc))
  1566.    if  (allowpointers)
  1567. return &stdint;
  1568. else
  1569. return tp2;
  1570.   if (isscalar(tp2))
  1571.                           return tp2;
  1572.                         break;
  1573. case bt_ptrfunc:
  1574. if (!prm_cplusplus && (tp2->type == bt_short || tp2->type == bt_unsignedshort
  1575. || tp2->type == bt_char || tp2->type == bt_unsignedchar)) {
  1576. error = ERR_SHORTPOINTER;
  1577. break;
  1578. }
  1579. if (tp2->type == bt_pointer)
  1580. tp3 = tp2->btp;
  1581. else
  1582. tp3 = tp2;
  1583. if (tp3->type == bt_func || tp3->type == bt_ifunc || tp3->type == bt_ptrfunc
  1584. || (!prm_cplusplus && tp2->type == bt_pointer))
  1585.    if  (allowpointers)
  1586.   return &stdint;
  1587. else
  1588.                             return tp1;
  1589. break;
  1590. case bt_func:
  1591. case bt_ifunc:
  1592. if (tp2->type == bt_func || tp2->type == bt_ifunc)
  1593. return tp1;
  1594. break;
  1595.                 }
  1596. #ifdef CPLUSPLUS
  1597. if (error == ERR_MISMATCH && prm_cplusplus)
  1598. genmismatcherror(tp2,tp1);
  1599. else
  1600. #endif
  1601.          generror( error,0,0 );
  1602.         return tp1;
  1603. }
  1605. int     isscalar(TYP *tp)
  1606. /*
  1607.  * this is misnamed... it checks for ANY basic numeric type
  1608.  */
  1609. {       return  tp->type == bt_char ||  tp->type == bt_unsignedchar ||
  1610.                 tp->type == bt_short || tp->type == bt_unsignedshort ||
  1611.                 tp->type == bt_long || tp->type == bt_unsigned || tp->type == bt_enum
  1612. || tp->type == bt_float || tp->type == bt_double || tp->type == bt_longdouble;
  1613. }
  1614. void checknp(TYP *tp1,TYP*tp2,ENODE *ep1, ENODE *ep2)
  1615. /*
  1616.  * look for non-portable pointer conversions
  1617.  */
  1618. {
  1620. #ifdef CPLUSPLUS
  1621. if (prm_cplusplus)
  1622. return;
  1623. #endif
  1624. if (tp1->type == bt_pointer || tp2->type == bt_pointer)
  1625. if (tp1->type != tp2->type) 
  1626. if ((!isintconst(ep1->nodetype) || ep1->v.i != 0) && (!isintconst(ep2->nodetype) || ep2->v.i != 0))
  1627. generror(ERR_NONPORT,0,0);
  1628. }
  1629. TYP     *multops(ENODE **node)
  1630. /*
  1631.  *      multops parses the multiply priority operators. the syntax of
  1632.  *      this group is:
  1633.  *
  1634.  *              unary
  1635.  *              multop * unary
  1636.  *              multop / unary
  1637.  *              multop % unary
  1638.  */
  1639. {       ENODE    *ep1, *ep2;
  1640.         TYP             *tp1, *tp2;
  1641.         int       oper;
  1642.         tp1 = unary(&ep1);
  1643.         if( tp1 == 0 )
  1644.                 return 0;
  1645.         while( lastst == star || lastst == divide || lastst == modop ) {
  1646.                 oper = lastst;
  1647.                 getsym();       /* move on to next unary op */
  1648.                 tp2 = unary(&ep2);
  1649. goodcode &= ~GF_ASSIGN;
  1650.                 if( tp2 == 0 ) {
  1651.                         generror(ERR_IDEXPECT,0,0);
  1652.                         *node = ep1;
  1653.                         return tp1;
  1654.                         }
  1655.                 tp1 = forcefit(&ep1,tp1,&ep2,tp2,TRUE,FALSE);
  1656.                 switch( oper ) {
  1657.                         case star:
  1658.                                 if( tp1->type == bt_unsigned ||tp1->type == bt_unsignedchar || tp1->type == bt_unsignedshort)
  1659.                                         ep1 = makenode(en_umul,ep1,ep2);
  1660.                                 else
  1661.                                         ep1 = makenode(en_mul,ep1,ep2);
  1662.                                 break;
  1663.                         case divide:
  1664.                                 if( tp1->type == bt_unsigned ||tp1->type == bt_unsignedchar || tp1->type == bt_unsignedshort)
  1665.                                         ep1 = makenode(en_udiv,ep1,ep2);
  1666.                                 else
  1667.                                         ep1 = makenode(en_div,ep1,ep2);
  1668.                                 break;
  1669.                         case modop:
  1670.                                 if( tp1->type == bt_unsigned ||tp1->type == bt_unsignedchar || tp1->type == bt_unsignedshort)
  1671.                                         ep1 = makenode(en_umod,ep1,ep2);
  1672.                                 else
  1673.                                         ep1 = makenode(en_mod,ep1,ep2);
  1674. floatcheck(ep1);
  1675.                                 break;
  1676.                         }
  1677.                 }
  1678.         *node = ep1;
  1679.         return tp1;
  1680. }
  1682. TYP     *addops(ENODE **node)
  1683. /*
  1684.  *      addops handles the addition and subtraction operators.
  1685.  */
  1686. {       ENODE    *ep1, *ep2, *ep3;
  1687.         TYP             *tp1, *tp2;
  1688.         int             oper;
  1689.         tp1 = multops(&ep1);
  1690.         if( tp1 == 0 )
  1691.                 return 0;
  1692.         while( lastst == plus || lastst == minus ) {
  1693.                 oper = (lastst == plus);
  1694.                 getsym();
  1695.                 tp2 = multops(&ep2);
  1696. goodcode &= ~GF_ASSIGN;
  1697.                 if( tp2 == 0 ) {
  1698.                         generror(ERR_IDEXPECT,0,0);
  1699.                         *node = ep1;
  1700.                         return tp1;
  1701.                         }
  1702.                 if( tp1->type == bt_pointer ) {
  1703. if (tp2->type == bt_pointer) {
  1704.                  forcefit(&ep1,tp1,&ep2,tp2,TRUE,FALSE);
  1705.                  ep1 = makenode( oper ? en_add : en_sub,ep1,ep2);
  1706. ep1->cflags = ep1->v.p[0]->cflags | ep2->cflags;
  1707. if (tp1->btp->size == 0)
  1708. generror(ERR_ZEROPTR,0,0);
  1709. else
  1710. if (tp1->btp->size > 1)
  1711. ep1 = makenode(en_pdiv,ep1,makenode(en_icon,(char *)tp1->btp->size,0));
  1712. ep1->cflags = ep1->v.p[0]->cflags;
  1713.     tp1 = &stdint;
  1714. continue;
  1715. }
  1716. else {
  1717.                         tp2 = forcefit(0,&stdint,&ep2,tp2,TRUE,FALSE);
  1718. if (tp1->btp->size == 0)
  1719. generror(ERR_ZEROPTR,0,0);
  1720.                         ep3 = makenode(en_icon,(char *)tp1->btp->size,0);
  1721.                         ep2 = makenode(en_pmul,ep3,ep2);
  1722. ep2->cflags = ep2->v.p[1]->cflags;
  1723.                         }
  1724. }
  1725.                 else if( tp2->type == bt_pointer ) {
  1726.                         tp1 = forcefit(0,&stdint,&ep1,tp1,TRUE,FALSE);
  1727. if (tp2->btp->size == 0)
  1728. generror(ERR_ZEROPTR,0,0);
  1729.                         ep3 = makenode(en_icon,(char *)tp2->btp->size,0);
  1730.                         ep1 = makenode(en_pmul,ep3,ep1);
  1731. ep1->cflags = ep1->v.p[1]->cflags;
  1732.                         }
  1733.                 tp1 = forcefit(&ep1,tp1,&ep2,tp2,TRUE,FALSE);
  1734.                 ep1 = makenode( oper ? en_add : en_sub,ep1,ep2);
  1735. ep1->cflags = ep1->v.p[1]->cflags | ep2->cflags;
  1736.                 }
  1737. exit:
  1738.         *node = ep1;
  1739.         return tp1;
  1740. }
  1742. TYP     *shiftop(ENODE **node)
  1743. /*
  1744.  *      shiftop handles the shift operators << and >>.
  1745.  */
  1746. {       ENODE    *ep1, *ep2;
  1747.         TYP             *tp1, *tp2;
  1748.         int             oper;
  1749.         tp1 = addops(&ep1);
  1750.         if( tp1 == 0)
  1751.                 return 0;
  1752.         while( lastst == lshift || lastst == rshift) {
  1753.                 oper = (lastst == lshift);
  1754.                 getsym();
  1755.                 tp2 = addops(&ep2);
  1756. goodcode &= ~GF_ASSIGN;
  1757.                 if( tp2 == 0 )
  1758.                         generror(ERR_IDEXPECT,0,0);
  1759.                 else    {
  1760.                         tp1 = forcefit(&ep1,tp1,&ep2,tp2,TRUE,FALSE);
  1761. if (tp1->type == bt_unsigned ||
  1762. tp1->type == bt_unsignedchar ||
  1763. tp1->type == bt_unsignedshort)
  1764.                          ep1 = makenode(oper ? en_lsh : en_rsh,ep1,ep2);
  1765. else
  1766.                          ep1 = makenode(oper ? en_alsh : en_arsh,ep1,ep2);
  1767.                         }
  1768. floatcheck(ep1);
  1769.                 }
  1770.         *node = ep1;
  1771.         return tp1;
  1772. }
  1774. TYP     *relation(ENODE **node)
  1775. /*
  1776.  *      relation handles the relational operators < <= > and >=.
  1777.  */
  1778. {       ENODE    *ep1, *ep2;
  1779.         TYP             *tp1, *tp2;
  1780.         int             nt;
  1781.         tp1 = shiftop(&ep1);
  1782.         if( tp1 == 0 )
  1783.                 return 0;
  1784.         for(;;) {
  1785.                 switch( lastst ) {
  1787.                         case lt:
  1788.                                 if( tp1->type == bt_unsigned || tp1->type == bt_unsignedchar || tp1->type == bt_unsignedshort)
  1789.                                         nt = en_ult;
  1790.                                 else
  1791.                                         nt = en_lt;
  1792.                                 break;
  1793.                         case gt:
  1794.                                 if( tp1->type == bt_unsigned || tp1->type == bt_unsignedchar || tp1->type == bt_unsignedshort)
  1795.                                         nt = en_ugt;
  1796.                                 else
  1797.                                         nt = en_gt;
  1798.                                 break;
  1799.                         case leq:
  1800.                                 if( tp1->type == bt_unsigned || tp1->type == bt_unsignedchar || tp1->type == bt_unsignedshort)
  1801.                                         nt = en_ule;
  1802.                                 else
  1803.                                         nt = en_le;
  1804.                                 break;
  1805.                         case geq:
  1806.                                 if( tp1->type == bt_unsigned || tp1->type == bt_unsignedchar || tp1->type == bt_unsignedshort)
  1807.                                         nt = en_uge;
  1808.                                 else
  1809.                                         nt = en_ge;
  1810.                                 break;
  1811.                         default:
  1812.                                 goto fini;
  1813.                         }
  1814.                 getsym();
  1815.                 tp2 = shiftop(&ep2);
  1816. goodcode &= ~GF_ASSIGN;
  1817.                 if( tp2 == 0 )
  1818.                         generror(ERR_IDEXPECT,0,0);
  1819.                 else    {
  1820. checknp(tp1,tp2,ep1,ep2);
  1821.                         tp1 = forcefit(&ep1,tp1,&ep2,tp2,TRUE,TRUE);
  1822.                         ep1 = makenode(nt,ep1,ep2);
  1823.                         }
  1824.                 }
  1825. fini:   *node = ep1;
  1826.         return tp1;
  1827. }
  1829. TYP     *equalops(ENODE **node)
  1830. /*
  1831.  *      equalops handles the equality and inequality operators.
  1832.  */
  1833. {       ENODE    *ep1, *ep2;
  1834.         TYP             *tp1, *tp2;
  1835.         int             oper;
  1836.         tp1 = relation(&ep1);
  1837.         if( tp1 == 0 )
  1838.                 return 0;
  1839.         while( lastst == eq || lastst == neq ) {
  1840.                 oper = (lastst == eq);
  1841.                 getsym();
  1842.                 tp2 = relation(&ep2);
  1843. goodcode &= ~GF_ASSIGN;
  1844. checknp(tp1,tp2,ep1,ep2);
  1845.                 if( tp2 == 0 )
  1846.                         generror(ERR_IDEXPECT,0,0);
  1847.                 else    {
  1848.                         tp1 = forcefit(&ep1,tp1,&ep2,tp2,TRUE,TRUE);
  1849.                         ep1 = makenode( oper ? en_eq : en_ne,ep1,ep2);
  1850.                         }
  1851.                 }
  1852.         *node = ep1;
  1853.         return tp1;
  1854. }
  1856. TYP     *binop(ENODE **node,TYP *(*xfunc)(),int nt,int sy)
  1857. /*
  1858.  *      binop is a common routine to handle all of the legwork and
  1859.  *      error checking for bitand, bitor, bitxor, andop, and orop.
  1860.  */
  1861. {       ENODE    *ep1, *ep2;
  1862.         TYP             *tp1, *tp2;
  1863.         tp1 = (*xfunc)(&ep1);
  1864.         if( tp1 == 0 )
  1865.                 return 0;
  1866.         while( lastst == sy ) {
  1867.                 getsym();
  1868.                 tp2 = (*xfunc)(&ep2);
  1869. goodcode &= ~GF_ASSIGN;
  1870.                 if( tp2 == 0 )
  1871.                         generror(ERR_IDEXPECT,0,0);
  1872.                 else    {
  1873.                         tp1 = forcefit(&ep1,tp1,&ep2,tp2,TRUE,sy == lor || sy == land);
  1874.                         ep1 = makenode(nt,ep1,ep2);
  1875.                         }
  1876. floatcheck(ep1);
  1877.                 }
  1878.         *node = ep1;
  1879.         return tp1;
  1880. }
  1882. TYP     *bitand(ENODE **node)
  1883. /*
  1884.  *      the bitwise and operator...
  1885.  */
  1886. {       return binop(node,equalops,en_and,and);
  1887. }
  1889. TYP     *bitxor(ENODE **node)
  1890. {       return binop(node,bitand,en_xor,uparrow);
  1891. }
  1893. TYP     *bitor(ENODE **node)
  1894. {       return binop(node,bitxor,en_or,or);
  1895. }
  1897. TYP     *andop(ENODE **node)
  1898. {       return binop(node,bitor,en_land,land);
  1899. }
  1901. TYP     *orop(ENODE **node)
  1902. {       return binop(node,andop,en_lor,lor);
  1903. }
  1905. TYP     *conditional(ENODE **node)
  1906. /*
  1907.  *      this routine processes the hook operator.
  1908.  */
  1909. {       TYP             *tp1, *tp2, *tp3;
  1910.         ENODE    *ep1, *ep2, *ep3;
  1911.         tp1 = orop(&ep1);       /* get condition */
  1913.         if( tp1 == 0 )
  1914.                 return 0;
  1915.         if( lastst == hook ) {
  1916. int gcode1,gcode2;
  1917. goodcode &=~GF_ASSIGN;
  1918.                 getsym();
  1919.                 if( (tp2 = conditional(&ep2)) == 0) {
  1920.                         generror(ERR_IDEXPECT,0,0);
  1921. goodcode &= ~GF_ASSIGN;
  1922.                         goto cexit;
  1923.                         }
  1924.                 needpunc(colon,0);
  1925. gcode2 = goodcode;
  1926. goodcode &=~GF_ASSIGN;
  1927.                 if( (tp3 = conditional(&ep3)) == 0) {
  1928.                         generror(ERR_IDEXPECT,0,0);
  1929. goodcode &= ~GF_ASSIGN;
  1930.                         goto cexit;
  1931.                         }
  1932. gcode1 = gcode2 & goodcode;
  1933. goodcode = (goodcode &~GF_ASSIGN) | gcode1;
  1934.                 tp1 = forcefit(&ep2,tp2,&ep3,tp3,TRUE,FALSE);
  1935.                 ep2 = makenode(en_void,ep2,ep3);
  1936.                 ep1 = makenode(en_cond,ep1,ep2);
  1937.                 }
  1938. cexit:
  1939.   *node = ep1;
  1940.         return tp1;
  1941. }
  1942. TYP *autoasnop(ENODE **node, SYM *sp)
  1943. /*
  1944.  *  Handle assignment operators during auto init of local vars
  1945.  */
  1946. {       ENODE    *ep1, *ep2;
  1947.         TYP             *tp1, *tp2;
  1949.         if( (tp1 = sp->tp) == 0 ) {
  1950. tp1 = &stdmatch;
  1951. *node = makenode(en_nacon,&undef,0);
  1952. gensymerror(ERR_UNDEFINED,nm);
  1953.           tp1 = deref(&ep1,tp1);
  1954.           return tp1;       /* guard against untyped entries */
  1955.         }
  1956.         if( sp->storage_class != sc_auto && sp->storage_class != sc_autoreg)
  1957.           gensymerror(ERR_ILLCLASS2,sp->name);
  1958. if (sp->storage_class == sc_auto)
  1959.          ep1 = makenode(en_autocon,sp,0);
  1960. else if (sp->storage_class == sc_autoreg)
  1961.          ep1 = makenode(en_autoreg,sp,0);
  1962. if (tp1) {
  1963. tp1->uflags |= UF_DEFINED | UF_USED;
  1964. }
  1965. if ((tp1->uflags & UF_CANASSIGN) && !(goodcode & GF_INLOOP))
  1966. tp1->uflags |=  UF_ASSIGNED;
  1967.         if( tp1->val_flag == 0)
  1968.           tp1 = deref(&ep1,tp1);
  1969.         if( tp1 == 0 )
  1970.                 return 0;
  1971.         tp2 = asnop(&ep2,tp1);
  1972.         if( tp2 == 0) {
  1973.           generror(ERR_LVALUE,0,0);
  1974. *node = makenode(en_nacon,&undef,0);
  1975. }
  1976.         else    {
  1977. if (tp1->type == bt_struct || tp1->type == bt_union) {
  1978. if (!checktypeassign(tp1,tp2)) {
  1979.               generror(ERR_LVALUE,0,0);
  1980. *node = makenode(en_nacon,&undef,0);
  1981. }
  1982. else {
  1983. checknp(tp1,tp2,ep1,ep2);
  1984. if (ep2->nodetype == en_fcallb || ep2->nodetype == en_pfcallb)
  1985. if (ep2->nodetype == en_pfcallb) 
  1986. ep1 = makenode(en_pcallblock,ep1,ep2);
  1987. else
  1988. ep1 = makenode(en_callblock,ep1,ep2);
  1989. else
  1990. ep1 = makenode(en_moveblock,ep1,ep2);
  1991. ep1->size = tp1->size;
  1992. *node = ep1;
  1993. }
  1994. }
  1995.           else    {
  1996. if (tp1->type == bt_ref) {
  1997. if (lvalue(ep2)) {
  1998.   while (castvalue(ep2))
  1999.   ep2 = ep2->v.p[0];
  2000. ep2 = ep2->v.p[0];
  2001. tp1 = tp1->btp;
  2002. }
  2003. else {
  2004. tp1 = tp1->btp;
  2005. gensymerror(ERR_TEMPINIT,sp->name);
  2006. ep2 = makenode(en_refassign,dummyvar(tp1->size,tp1),ep2);
  2007. }
  2008. }
  2009. else if (tp1->val_flag) {
  2010. generror(ERR_LVALUE,0,0);
  2011. *node = makenode(en_nacon,&undef,0);
  2012. return tp1;
  2013. }
  2015. checknp(tp1,tp2,ep1,ep2);
  2016.            tp1 = forcefit(&ep1,tp1,&ep2,tp2,FALSE,FALSE);
  2017.            *node = makenode(en_assign,ep1,ep2);
  2018. }
  2019.         }
  2020. return(tp1);
  2021. }
  2022. void asncombine(ENODE **node)
  2023. /*
  2024.  * a simple optimization which turns an equate into a functional equate
  2025.  * if possible.  Code gen proceeds a little more cleanly if this info
  2026.  * is known.
  2027.  */
  2028. {
  2029. ENODE *var = (*node)->v.p[0];
  2030. ENODE *exp = (*node)->v.p[1];
  2031.   ENODE *var2 = exp->v.p[0];
  2032. int op = 0;
  2033. switch(exp->nodetype) {
  2034. case en_add:
  2035. if (equalnode(var,var2)) {
  2036. op = en_asadd;
  2037. break;
  2038. } else return;
  2039. case en_sub:
  2040. if (equalnode(var,var2)) {
  2041. op = en_assub;
  2042. break;
  2043. } else return;
  2044. case en_mul:
  2045. if (equalnode(var,var2)) {
  2046. op = en_asmul;
  2047. break;
  2048. } else return;
  2049. case en_umul:
  2050. if (equalnode(var,var2)) {
  2051. op = en_asumul;
  2052. break;
  2053. } else return;
  2054. case en_div:
  2055. if (equalnode(var,var2)) {
  2056. op = en_asdiv;
  2057. break;
  2058. } else return;
  2059. case en_udiv:
  2060. if (equalnode(var,var2)) {
  2061. op = en_asudiv;
  2062. break;
  2063. } else return;
  2064. case en_mod:
  2065. if (equalnode(var,var2)) {
  2066. op = en_asmod;
  2067. break;
  2068. } else return;
  2069. case en_umod:
  2070. if (equalnode(var,var2)) {
  2071. op = en_asumod;
  2072. break;
  2073. } else return;
  2074. case en_lsh:
  2075. if (equalnode(var,var2)) {
  2076. op = en_aslsh;
  2077. break;
  2078. } else return;
  2079. case en_alsh:
  2080. if (equalnode(var,var2)) {
  2081. op = en_asalsh;
  2082. break;
  2083. } else return;
  2084. case en_rsh:
  2085. if (equalnode(var,var2)) {
  2086. op = en_asrsh;
  2087. break;
  2088. } else return;
  2089. case en_arsh:
  2090. if (equalnode(var,var2)) {
  2091. op = en_asarsh;
  2092. break;
  2093. } else return;
  2094. case en_and:
  2095. if (equalnode(var,var2)) {
  2096. op = en_asand;
  2097. break;
  2098. } else return;
  2099. case en_or:
  2100. if (equalnode(var,var2)) {
  2101. op = en_asor;
  2102. break;
  2103. } else return;
  2104. case en_xor:
  2105. if (equalnode(var,var2)) {
  2106. op = en_asxor;
  2107. break;
  2108. } else return;
  2109. default:
  2110. return;
  2111. }
  2112. exp->nodetype = op;
  2113. (*node) = exp;
  2114. }
  2115. TYP     *asnop(ENODE **node,TYP *tptr)
  2116. /*
  2117.  *      asnop handles the assignment operators.
  2118.  */
  2119. {       ENODE    *ep1, *ep2, *ep3;
  2120.         TYP             *tp1, *tp2,*oldastyp;
  2121.         int             op;
  2122. oldastyp = asntyp;
  2123. if (tptr) 
  2124. asntyp = tptr;
  2125. else
  2126. asntyp = 0;
  2127.         tp1 = conditional(&ep1);
  2128. lastsym = 0;
  2129. if (!tptr)
  2130. asntyp = tp1;
  2131.         if( tp1 == 0 )
  2132.                 return 0;
  2133.         for(;;) {
  2134.                 switch( lastst ) {
  2135.                         case assign:
  2136.                                 op = en_assign;
  2137. ascomm:                         getsym();
  2138.                                 tp2 = asnop(&ep2,asntyp);
  2139. ascomm2:                        ep3 = ep1;
  2140. if (tp1) {
  2141. tp1->uflags |= UF_DEFINED;
  2142. }
  2143. goodcode |= GF_ASSIGN;
  2144. if ((tp1->uflags & UF_CANASSIGN) && !(goodcode & GF_INLOOP))
  2145. tp1->uflags |=  UF_ASSIGNED;
  2146. if( tp2 == 0 || tp1 == 0)
  2147.                                         generror(ERR_LVALUE,0,0);
  2148. else {
  2149. if (tp1->type == bt_struct || tp1->type == bt_union) {
  2150. if (!checktypeassign(tp1,tp2)) {
  2151.                                          generror(ERR_LVALUE,0,0);
  2152. }
  2153. else {
  2154. if (op != en_asadd && op != en_assub)
  2155. checknp(tp1,tp2,ep1,ep2);
  2156. if (ep2->nodetype == en_fcallb || ep2->nodetype == en_pfcallb)
  2157. if (ep2->nodetype == en_pfcallb) 
  2158. ep1 = makenode(en_pcallblock,ep1,ep2);
  2159. else
  2160. ep1 = makenode(en_callblock,ep1,ep2);
  2161. else
  2162. ep1 = makenode(en_moveblock,ep1,ep2);
  2163. ep1->size = tp1->size;
  2164. }
  2165. }
  2166.                                   else    {
  2167. if (!lvalue(ep1)) 
  2168.            generror(ERR_LVALUE,0,0);
  2169. if (op != en_asadd && op != en_assub)
  2170. checknp(tp1,tp2,ep1,ep2);
  2171.                                         tp1 = forcefit(&ep1,tp1,&ep2,tp2,FALSE,FALSE);
  2172.                                         ep1 = makenode(op,ep1,ep2);
  2173.                                         }
  2174. }
  2175.   if (ep3->cflags & DF_CONST)
  2176.   generror(ERR_MODCONS,0,0);
  2177.    if (op == en_assign) {
  2178.    asncombine(&ep1);
  2179. op = ep1->nodetype;
  2180. }
  2181.    if (op == en_asmod || op == en_asumod ||
  2182.    op ==en_aslsh || op== en_asrsh ||
  2183.    op == en_asalsh || op== en_asarsh ||
  2184.    op == en_asand || op== en_asor || op == en_asxor)
  2185.    floatcheck(ep1);
  2186.                                 break;
  2187.                         case asplus:
  2188.                                 op = en_asadd;
  2190. ascomm3: getsym();
  2191. tp2 = asnop(&ep2,asntyp);
  2192.                                 if( tp1->type == bt_pointer ) {
  2193. if (tp1->btp->size == 0)
  2194. generror(ERR_ZEROPTR,0,0);
  2195.                                         ep3 = makenode(en_icon,(char *)tp1->btp->size,0);
  2196.                                         ep2 = makenode(en_pmul,ep2,ep3);
  2197. tp2 = tp1;
  2198.                                         }
  2199.                                 goto ascomm2;
  2200.                         case asminus:
  2201.                                 op = en_assub;
  2202.                                 goto ascomm3;
  2203.                         case astimes:
  2204.                                 if( tp1->type == bt_unsigned ||tp1->type == bt_unsignedchar || tp1->type == bt_unsignedshort)
  2205.                                         op = en_asumul;
  2206.                                 else
  2207.                                         op =en_asmul;
  2208.                                 goto ascomm;
  2209.                         case asdivide:
  2210.                                 if( tp1->type == bt_unsigned ||tp1->type == bt_unsignedchar || tp1->type == bt_unsignedshort)
  2211.                                         op = en_asudiv;
  2212.                                 else
  2213.                                         op =en_asdiv;
  2214.                                 goto ascomm;
  2215.                         case asmodop:
  2216.                                 if( tp1->type == bt_unsigned ||tp1->type == bt_unsignedchar || tp1->type == bt_unsignedshort)
  2217.                                         op = en_asumod;
  2218.                                 else
  2219.                                         op =en_asmod;
  2220.                                 goto ascomm;
  2221.                         case aslshift:
  2222. if (tp1->type == bt_unsigned ||
  2223. tp1->type == bt_unsignedchar ||
  2224. tp1->type == bt_unsignedshort)
  2225. op = en_aslsh;
  2226. else
  2227.                               op = en_asalsh;
  2228.                                 goto ascomm;
  2229.                         case asrshift:
  2230. if (tp1->type == bt_unsigned ||
  2231. tp1->type == bt_unsignedchar ||
  2232. tp1->type == bt_unsignedshort)
  2233. op = en_asrsh;
  2234. else
  2235.                               op = en_asarsh;
  2236.                                 goto ascomm;
  2237.                         case asand:
  2238.                                 op = en_asand;
  2239.                                 goto ascomm;
  2240.                         case asor:
  2241.                                 op = en_asor;
  2242.                                 goto ascomm;
  2243.                         case asxor:
  2244.                                 op = en_asxor;
  2245.                                 goto ascomm;
  2246.                         default:
  2247.                                 goto asexit;
  2248.                         }
  2249.                 }
  2250. asexit: *node = ep1;
  2251. asntyp = oldastyp;
  2252.         return tp1;
  2253. }
  2255. TYP     *exprnc(ENODE **node)
  2256. /*
  2257.  *      evaluate an expression where the comma operator is not legal.
  2258.  * e.g. a function argument
  2259.  */
  2260. {       TYP     *tp;
  2261.         tp = asnop(node,0);
  2262.         if( tp == 0 )
  2263.                 *node = 0;
  2264. else if ((*node)->nodetype == en_fcallb || (*node)->nodetype == en_pfcallb) {
  2265. if ((*node)->nodetype == en_pfcallb) 
  2266. (*node) = makenode(en_pcallblock,dummyvar(tp->size,tp),(*node));
  2267.    else
  2268. (*node) = makenode(en_callblock,dummyvar(tp->size,tp),(*node));
  2269. }
  2270. if (tp && tp->type == bt_void)
  2271. goodcode |= GF_ASSIGN;
  2272.         return tp;
  2273. }
  2275. TYP     *commaop(ENODE **node)
  2276. /*
  2277.  *      evaluate the comma operator. comma operators are kept as
  2278.  *      void nodes.
  2279.  */
  2280. {       TYP             *tp1;
  2281.         ENODE    *ep1, *ep2;
  2282. int ocode;
  2283.         tp1 = asnop(&ep1,0);
  2284.         if( tp1 == 0 )
  2285.                 return 0;
  2286.         if( lastst == comma ) {
  2287. ocode = goodcode | ~GF_ASSIGN;
  2288. goodcode &= ~GF_ASSIGN;
  2289. getsym();
  2290.                 tp1 = commaop(&ep2);
  2291. goodcode &= ocode;
  2292.                 if( tp1 == 0 ) {
  2293.                         generror(ERR_IDEXPECT,0,0);
  2294.                         goto coexit;
  2295.                         }
  2296.                 ep1 = makenode(en_void,ep1,ep2);
  2297.                 }
  2298. coexit: *node = ep1;
  2299.         return tp1;
  2300. }
  2302. TYP     *expression(ENODE **node)
  2303. /*
  2304.  *      evaluate an expression where all operators are legal.
  2305.  */
  2306. {       TYP     *tp;
  2307.         tp = commaop(node);
  2308.         if( tp == 0 )
  2309.                 *node = 0;
  2310. else if ((*node)->nodetype == en_fcallb || (*node)->nodetype == en_pfcallb) {
  2311. if ((*node)->nodetype == en_pfcallb) 
  2312. (*node) = makenode(en_pcallblock,dummyvar(tp->size,tp),(*node));
  2313.    else
  2314. (*node) = makenode(en_callblock,dummyvar(tp->size,tp),(*node));
  2315. }
  2316. if (tp && tp->type == bt_void)
  2317. goodcode |= GF_ASSIGN;
  2318.         return tp;
  2319. }