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

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

编译器/解释器

开发平台：

Others

DECL.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.  * handle ALL declarative statements
  24.  */
  25. #include        <stdio.h>
  26. #include <limits.h>
  27. #include        "expr.h"
  28. #include        "c.h"
  29. #include        "errors.h"
  31. extern int stdinttype,stdunstype,stdintsize, stdldoublesize,stdaddrsize;
  32. extern int strucadd,strucmod;
  34. extern char laststr[];
  35. extern int global_flag;
  36. extern TABLE gsyms,lsyms;
  37. extern SNODE *cbautoinithead;
  38. extern int prm_packing;
  39. extern int prm_revbits;
  40. extern int prm_68020;
  41. extern int prm_ansi;
  42. extern HASHREC **globalhash;
  43. extern SYM *currentfunc;
  44. extern int prm_cplusplus;
  45. extern char * tn_unnamed;
  46. extern TYP stdconst;
  47. extern enum e_sym lastst;
  48. extern char lastid[];
  49. extern int block_nesting;
  50. extern long nextlabel;
  52. char *Cstr = "C";
  54. TABLE *active_table; /* This is so enums will not be put in structre tabs */
  56. int mangleflag;
  57. int skm_declopenpa[] = { semicolon, comma,openpa, eq,0 };
  58. int skm_declclosepa[] = { semicolon, comma,closepa, eq,0 };
  59. int skm_declclosebr[] = { comma,closebr, eq,0 };
  60. int skm_declend[] = { semicolon, comma, end, eq,0 };
  61. int skm_decl[] = {semicolon,kw_int, kw_long, kw_short, kw_char, kw_float,
  62. kw_double, kw_struct, kw_union, kw_enum, kw_unsigned, kw_signed, kw_auto,
  63. kw_extern, kw_static, kw_register, kw_typedef, id, kw_void, 0 };
  65. TYP             *head = 0;
  66. TYP             *tail = 0;
  67. char            declid[100];
  68. TABLE           tagtable = {0,0};
  69. int ispascal;
  71. static SYM *lastdecl;
  72. static  int pcount=0;
  73. static int bittype = -1;
  74. static int curbit = 0;
  75. static int curofs = 0;
  76. static int manglelevel;
  77. static int intflag;
  79. void declini(void)
  80. /*
  81.  * init
  82.  */
  83. {
  84. bittype = -1;
  85. head = tail = 0;
  86. declid[0] = 0;
  87. tagtable.head = tagtable.tail = 0;
  88. pcount = 0;
  89. mangleflag = TRUE;
  90. }
  92. int     imax(int i,int j)
  93. {       return (i > j) ? i : j;
  94. }
  96. char    *litlate(char *s)
  97. {       char    *p;
  98.         p = xalloc(strlen(s) + 1);
  99.         strcpy(p,s);
  100.         return p;
  101. }
  103. TYP     *maketype(int bt,int siz)
  104. /*
  105.  * Create a type list entry
  106.  */
  107. {       TYP     *tp;
  109.         tp = xalloc(sizeof(TYP));
  110.         tp->val_flag = 0;
  111. tp->bits = tp->startbit = -1;
  112.         tp->size = siz;
  113.         tp->type = bt;
  114.         tp->sname = 0;
  115. tp->cflags = 0;
  116. tp->uflags = 0;
  117.         tp->lst.head = tp->lst.tail = 0;
  118. tp->tdef = 0;
  119.         return tp;
  120. }
  121. TYP *cponetype(TYP *t)
  122. /*
  123.  * Copy a entry
  124.  */
  125. { TYP *tp;
  126. tp = xalloc(sizeof(TYP));
  127. tp->type = t->type;
  128. tp->val_flag = t->val_flag;
  129. tp->cflags = t->cflags;
  130. tp->bits = t->bits;
  131. tp->startbit = t->startbit;
  132. tp->size = t->size;
  133. tp->lst = t->lst;
  134. tp->btp = t->btp;
  135. tp->sname = t->sname;
  136. tp->uflags = t->uflags;
  137. tp->tdef = t->tdef;
  138. return tp;
  139. }
  140. TYP *copytype(TYP *itp, int flags)
  141. /*
  142.  * copy a type tree
  143.  */
  144. {
  145. TYP *head, *tail,*x=itp;
  146. while (x->type == bt_pointer)
  147. x = x->btp;
  148. if (x->type == bt_struct || x->type == bt_union)
  149. if (!x->lst.head) {
  150. itp->cflags = flags;
  151. return head = tail = itp;
  152. }
  153. head = tail = cponetype(itp);
  154. while (itp->type == bt_pointer) {
  155. tail = tail->btp = cponetype(itp->btp);
  156. itp = itp->btp;
  157. }
  158. if (itp->type == bt_func || itp->type == bt_ptrfunc || itp->type == bt_ifunc) {
  159. tail->btp = cponetype(itp->btp);
  160. }
  161. else {
  162. tail->cflags |= flags;
  163. }
  164. return head;
  165. }
  166. void     decl(TABLE *table)
  167. /*
  168.  * parse the declare keywords and create a basic type
  169.  */
  170. {
  171. int tp;
  172. SYM *sp;
  173. int flags = 0;
  174. while (lastst == kw_const || lastst == kw_volatile) {
  175. if (lastst == kw_const)
  176. flags |= DF_CONST;
  177. else
  178. flags |= DF_VOL;
  179. getsym();
  180. }
  181.         switch (lastst) {
  182. case kw_void:
  183.                         head = tail = maketype(bt_void,0);
  184. getsym();
  185. break;
  186.                 case kw_char:
  187.                         head = tail = maketype(bt_char,1);
  188.                         getsym();
  189.                         break;
  190.                 case kw_short:
  191. getsym();
  192. tp = bt_short;
  193. if (lastst == kw_unsigned) {
  194. tp = bt_unsignedshort;
  195. getsym();
  196. }
  197. if (lastst == kw_int)
  198. getsym();
  199.                         head = tail = maketype(tp,2);
  200.                         break;
  201.                 case kw_int: 
  202.                         head = tail = maketype(stdinttype,stdintsize);
  203.                         getsym();
  204.                         break;
  205.                 case kw_unsigned:
  206. getsym();
  207. switch (lastst) {
  208. case kw_char:
  209. getsym();
  210.                          head = tail = maketype(bt_unsignedchar,1);
  211. break;
  212. case kw_short:
  213. getsym();
  214. if (lastst == kw_int)
  215. getsym();
  216.                          head = tail = maketype(bt_unsignedshort,2);
  217. break;
  218. case kw_long:
  219. getsym();
  220. if (lastst == kw_long) {
  221. getsym();
  222. generror(ERR_LONGLONG,0,0);
  223. }
  224. if (lastst == kw_int)
  225. getsym();
  226.                          head = tail = maketype(bt_unsigned,4);
  227. break;
  228. case kw_int:
  229. getsym();
  230. default:
  231.                          head = tail = maketype(stdunstype,stdintsize);
  232. break;
  233. }
  234.                         break;
  235.                 case kw_signed:
  236. getsym();
  237. switch (lastst) {
  238. case kw_char:
  239. getsym();
  240.                          head = tail = maketype(bt_char,1);
  241. break;
  242. case kw_short:
  243. getsym();
  244. if (lastst == kw_int)
  245. getsym();
  246.                          head = tail = maketype(bt_short,2);
  247. break;
  248. case kw_long:
  249. getsym();
  250. if (lastst == kw_long) {
  251. getsym();
  252. generror(ERR_LONGLONG,0,0);
  253. }
  254. if (lastst == kw_int)
  255. getsym();
  256.                          head = tail = maketype(bt_long,4);
  257. break;
  258. case kw_int:
  259. getsym();
  260. default:
  261.                          head = tail = maketype(stdinttype,stdintsize);
  262. break;
  263. }
  264.                         break;
  265.                 case id:                /* no type declarator */
  266. if ((sp = gsearch(lastid)) != 0 && sp->storage_class == sc_type) {
  267. head = tail = copytype(sp->tp,flags);
  268. getsym();
  269. }
  270. else
  271.                         head = tail = maketype(bt_long,4);
  272.                         break;
  273.                 case kw_float:
  274.                         head = tail = maketype(bt_float,4);
  275.                         getsym();
  276.                         break;
  277. case kw_long:
  278. getsym();
  279. if (lastst==kw_double) {
  280. getsym();
  281.                          head = tail = maketype(bt_longdouble,stdldoublesize);
  282. break;
  283. }
  284. if (lastst==kw_float) {
  285. getsym();
  286.                          head = tail = maketype(bt_double,8);
  287. break;
  288. }
  289. if (lastst == kw_long) {
  290. getsym();
  291. generror(ERR_LONGLONG,0,0);
  292. }
  293. tp = bt_long;
  294. if (lastst == kw_unsigned) {
  295. tp = bt_unsigned;
  296. getsym();
  297. }
  298. if (lastst == kw_long) {
  299. getsym();
  300. generror(ERR_LONGLONG,0,0);
  301. }
  302. if (lastst == kw_int)
  303. getsym();
  304.                         head = tail = maketype(tp,4);
  305.                         break;
  306.                 case kw_double:
  307.                         head = tail = maketype(bt_double,8);
  308.                         getsym();
  309.                         break;
  310.                 case kw_enum:
  311.                         getsym();
  312.                         declenum(table);
  313.                         break;
  314.                 case kw_struct:
  315.                         getsym();
  316.                         declstruct(table, bt_struct,flags);
  317.                         break;
  318.                 case kw_union:
  319.                         getsym();
  320.                         declstruct(table, bt_union,flags);
  321.                         break;
  322.                 }
  323. head->cflags |= flags;
  324. head->uflags |= UF_CANASSIGN;
  325. }
  327. void decl1(void)
  328. /*
  329.  * Modifiers that could occur BEFORE the name of the var
  330.  */
  331. {       TYP     *temp1, *temp2, *temp3, *temp4;
  332. lp:
  333.         switch (lastst) {
  334. case kw_const:
  335. head->cflags |= DF_CONST;
  336. getsym();
  337. goto lp;
  338. case kw_volatile:
  339. head->cflags |= DF_VOL;
  340. getsym();
  341. goto lp;
  342. case kw__pascal:
  343. ispascal = TRUE;
  344. getsym();
  345. goto lp;
  346.                 case id:
  347. strcpy(declid,lastid);
  348.                         getsym();
  349.                         decl2();
  350.                         break;
  351. case and:
  352. #ifdef CPLUSPLUS
  353. if (prm_cplusplus) {
  354. getsym();
  355. if (prm_cplusplus) {
  356. decl1();
  357. if (head->type == bt_ref || head->type == bt_pointer)
  358. generror(ERR_CANTREF,0,0);
  359. else {
  360. temp1 = maketype(bt_ref,4);
  361. temp1->btp = head;
  362. head = temp1;
  363. if (tail == NULL)
  364. tail = head;
  365. }
  366. }
  367. else 
  368. generror(ERR_NOREF,0,0);
  369. }
  370. else
  371. #endif
  372. {
  373. decl2();
  374. break;
  375. }
  376. break;
  377.                 case star:
  378. head->uflags &= ~UF_CANASSIGN;
  379.                         temp1 = maketype(bt_pointer,4);
  380.                         temp1->btp = head;
  381.                         head = temp1;
  382. head->uflags |= UF_CANASSIGN;
  383.                         if(tail == NULL)
  384.                                 tail = head;
  385.                         getsym();
  386.                         decl1();
  387.                         break;
  388.                 case openpa:
  389.                         getsym();
  390.                       temp1 = head;
  391.                        temp2 = tail;
  392. /* Check here for function pointer */
  393. if (lastst == star) {
  394. getsym();
  395. {
  396.                        head = tail = maketype(bt_ptrfunc,4);
  397.                         head->btp = temp1;
  399. decl1();
  400. if (needpunc(closepa,skm_declclosepa)) {
  401. char temp[40];
  402. /* in case we have a pointer type in
  403.  * parenthesis
  404.  * Isn't C grand? */
  405. if (lastst != openpa) {
  406. /* change the pointerfunc to a pointer */
  407. if (head->type == bt_ptrfunc) 
  408. head->type = bt_pointer;
  409. else {
  410. temp3 = head;
  411. while (temp3->type != bt_ptrfunc)
  412. temp3 = temp3->btp;
  413. temp3->type = bt_pointer;
  414. }
  415. tail = temp2;
  416. decl2();
  417. break;
  418. }
  419. strcpy(temp,declid);
  420. if (head->type == bt_func) {
  421. declid[0] = 0;
  422. temp1 = head;
  423. head = head->btp;
  424. }
  425. else
  426. temp1 = 0;
  427. getsym();
  428. declfuncarg(intflag);
  429. if (temp1) {
  430. strcpy(declid,temp);
  431. temp1->btp = head;
  432. head = temp1;
  433. }
  434. if (lastst == begin) {
  435. temp1->type = bt_ifunc;
  436. break;
  437. }
  438. }
  439. else getsym();
  440. }
  442. }
  443. else {
  444. /* (In case a declaration is in parenthesis */
  445.                          decl1();
  446.                          needpunc(closepa,0);
  447. decl2();
  448. }
  449.                         break;
  450.                 default:
  451.                         decl2();
  452.                         break;
  453.                 }
  454. }
  456. void decl2(void)
  457. /*
  458.  * type modifiers that come AFTER the name of the variable
  459.  */
  460. {       TYP     *temp1;
  461. lp:
  462.         switch (lastst) {
  463. case kw_const:
  464. head->cflags |= DF_CONST;
  465. getsym();
  466. goto lp;
  467. case kw_volatile:
  468. head->cflags |= DF_VOL;
  469. getsym();
  470. goto lp;
  471.                 case openbr:
  472. decl3();
  473. decl2();
  474.                         break;
  475.                 case openpa:
  476.                         getsym();
  477.                       temp1 = maketype(bt_func,0);
  478. head->uflags |= UF_DEFINED;
  479.                        temp1->val_flag = 1;
  480.                        temp1->btp = head;
  481.                        head = temp1;
  482. head->uflags |= UF_DEFINED;
  483. declfuncarg(intflag);
  484. if (lastst == begin) {
  485. temp1->type = bt_ifunc;
  486. break;
  487. }
  488.                         break;
  489. case colon:
  490. getsym();
  491. head->bits = intexpr(0);
  492. if (head->type != bt_long && head->type != bt_unsigned
  493. && head->type != bt_short && head->type != bt_unsignedshort
  494. && head->type != bt_char && head->type != bt_unsignedchar) {
  495. if (prm_ansi)
  496. generror(ERR_INTBITFIELDS,0,0);
  497. else
  498. generror(ERR_BFTYPE,0,0);
  499. head->bits = -1;
  500. }
  501. else
  502. if (prm_ansi && head->size != stdintsize) {
  503. generror(ERR_INTBITFIELDS,0,0);
  504. head->bits = -1;
  505. }
  506. break;
  507.                 }
  508. }
  510. void decl3(void)
  511. /*
  512.  * Array index handling
  513.  */
  514. {
  515.   TYP *temp1, *list[40];
  516. int count = 0,i;
  517. int mustsize = 0;
  518. head->uflags |= UF_DEFINED;
  519. head->uflags &= ~UF_CANASSIGN;
  520. while(lastst == openbr) {
  521.                         getsym();
  522.                         temp1 = maketype(bt_pointer,0);  
  523.                         temp1->val_flag = 1;
  524.                         if(lastst == closebr) {
  525.     if (mustsize)
  526. generror(ERR_SIZE,0,0);
  527.                                 temp1->size = 0;
  528.                                 getsym();
  529.                                 }
  530.                         else {
  531.                                 temp1->size = intexpr(0);
  532.                                 needpunc(closebr,skm_declclosebr);
  533.                                 }
  534. list[count++] = temp1;
  535. mustsize = 1;
  536. }
  537. if (head != NULL) {
  538. list[count-1]->size *= head->size;
  539. if (tail == NULL)
  540. tail = head;
  541. }
  542. for (i=count-1; i>0; i--) {
  543. list[i-1]->size *= list[i]->size;
  544. list[count-1]->uflags |= UF_DEFINED;
  545. }
  547. for (i=0; i < count-1; i++)
  548. list[i]->btp = list[i+1];
  549. list[count-1]->btp = head;
  551. head = list[0];
  552. if (tail == NULL)
  553. tail = list[count-1];
  554. }
  555. int bitsize(int type)
  556. /*
  557.  * Max bit field depends on the type
  558.  */
  559. {
  560. switch (type) {
  561. case bt_char:
  562. case bt_unsignedchar:
  563. return 8;
  564. case bt_short:
  565. case bt_unsignedshort:
  566. return 16;
  567. case bt_long:
  568. case bt_unsigned:
  569. return 32;
  570. }
  571. return 0;
  572. }
  573. int oksize(void)
  574. /*
  575.  * See if the size field is ok or if we should gen a message
  576.  */
  577. {
  578. TYP *q = head;
  579. while (q->type == bt_pointer) {
  580. if (q->val_flag)
  581. return 1;
  582. q = q->btp;
  583. }
  584. return head->size != 0;
  585. }
  586. int     basedeclare(TABLE *table,int al,long ilc,int ztype, int flags)
  587. /*
  588.  *  Once a type declarator is found we come here to get the remainder of the
  589.  * declaration and allocate spae
  590.  *
  591.  */
  592. {       SYM     *sp=0, *sp1;
  593.         TYP     *dhead;
  594.         int     nbytes,ufsave;
  595.         nbytes = 0;
  596.         dhead = head;
  597. ufsave = head->uflags;
  598.         for(;;) {
  599. sp1 = 0;
  600.                 declid[0] = 0;
  601.                 decl1();
  603. /* stupid C standard uses a proper function name
  604. ** as an alias for a pointer to a func when is a member...
  605. */
  606. if (al == sc_member)
  607.   if (head->type == bt_func) {
  608. head->type = bt_ptrfunc;
  609. head->size = 4;
  610. }
  611. else if (head->type == bt_ifunc)
  612. generror(ERR_NOFUNCSTRUCT,0,0);
  614. /* In case they put the extern tag on an ifunc */
  615. if (head->type == bt_ifunc && al == sc_external)
  616. al = sc_global;
  618. if (declid[0] == 0) {
  619. if ((flags & DF_FUNCPARMS)) {
  620. sprintf(declid,"**ARG%d**",pcount++);
  621. }
  622. }
  623. head->cflags |= flags;
  624.                 if( declid[0] != 0) {      /* otherwise just struct tag... */
  625.                     sp = xalloc(sizeof(SYM));
  626. if (head->type == bt_func || head->type == bt_ifunc)
  627. #ifdef CPLUSPLUS
  628. if (prm_cplusplus)
  629. if (!strcmp(declid,"_main")) {
  630. SYM *sp1;
  631. head->sname = sp->name = litlate(declid);
  632. sp1 = search(sp->name,&gsyms);
  633. if (sp1 && sp1->tp->type == bt_ifunc)
  634. generror(ERR_NOOVERMAIN,0,0);
  635. }
  636. else if (mangleflag && !ispascal)
  637. head->sname = sp->name = cppmangle(declid,head);
  638. else
  639. head->sname = sp->name = litlate(declid);
  640. else 
  641. #endif
  642. head->sname = sp->name = litlate(declid);
  643. else
  644. sp->name = litlate(declid);
  645. sp->defalt = 0;
  646.                     sp->storage_class = al;
  647.                     sp->tp = head;
  648. sp->extflag = FALSE;
  649. sp->absflag = (al == sc_abs);
  650. sp->intflag = flags &DF_INT;
  651. sp->pascaldefn = ispascal;
  652. sp->init = 0;
  653. sp->indecltable = 0;
  654. sp->funcparm = 0;
  655. sp->inreg = 0;
  656. sp->staticlabel = FALSE;
  657. if (al == sc_external && lastst == assign)
  658. sp->storage_class = sc_global;
  659. if (sp->intflag && ispascal)
  660. generror(ERR_PASCAL_NO_INT,0,0);
  661. if (al == sc_autoreg) {
  662. if (head->size > 4) {
  663. sp->storage_class = sc_auto;
  664. gensymerror(ERR_ILLREGISTER,sp->name);
  665. }
  666. head->sname = sp->name;
  667. }
  668. if (al != sc_type && (oksize() || sp->tp->type == bt_func || sp->tp->type == bt_ifunc)) {
  669. if (al == sc_abs)
  670. sp->value.i = ilc;
  671. else
  672. if (head->type != bt_func && head->type != bt_ifunc)
  673. if (sp->storage_class == sc_static && table == &lsyms) {
  674. sp->value.i = nextlabel++;
  675. sp->staticlabel = TRUE;
  676. }
  677. else
  678. sp->value.i = block_nesting;
  679. else
  680.   sp->value.i = 0;
  681. {
  682. int align = getalign(al,head);
  683. int noadj = FALSE;
  685. if (al != sc_member || (head->bits != -1 && bittype != head->type && head->bits +curbit > bitsize(head->type))) {
  686. bittype = head->type;
  687. curbit = 0;
  688. }
  689. else
  690. noadj = head->bits != -1;
  692. if (al == sc_member) {
  693. int val;
  694. if (!noadj) {
  695. val = (ilc + nbytes) %align;
  696. if (val)  val = align - val;
  697. nbytes += val;
  698. }
  699. sp->value.i = nbytes + ilc;
  700. if (!noadj)
  701.                          if(ztype == bt_union)
  702.                                nbytes = imax(nbytes,sp->tp->size);
  703.                           else if(al != sc_external)
  704.                                nbytes += sp->tp->size;
  705. }
  706. }
  707. if (head->bits != -1) {
  708. if (al != sc_member) {
  709. generror(ERR_BFILLEGAL,0,0);
  710. head->bits = -1;
  711. }
  712. else if (head->bits > bitsize(head->type)) {
  713. generror(ERR_BFTOOBIG,0,0);
  714. head->bits = -1;
  715. }
  716. else {
  717. if (prm_revbits)
  718. head->startbit = head->size*8-curbit-head->bits;
  719. else
  720. head->startbit = curbit;
  721. curbit+=head->bits;
  722. }
  723. }
  724. if (sp->absflag &&( sp->tp->type == bt_func || sp->tp->type == bt_ifunc))
  725. gensymerror(ERR_ILLCLASS,lastid);
  726. if (sp->intflag &&( sp->tp->type != bt_func && sp->tp->type != bt_ifunc))
  727. gensymerror(ERR_ILLCLASS,lastid);
  728.                       if( sp->tp->type == bt_func  && al != sc_static)
  729.                             sp->storage_class = sc_externalfunc;
  731.    sp1 = search(sp->name,table);
  732. if (sp->name[0] == '@' && !sp1)
  733. funcrefinsert(declid,sp->name,head,table);
  734.                       if (!sp1 || (sp1->tp->type != bt_func && sp1->tp->type != bt_ifunc)) {
  735. if (!sp1 || al == sc_auto || al == sc_autoreg)
  736.                           insert(sp,table);                                                                       
  737. else {
  738. if (!exactype(sp->tp,sp1->tp))
  739. gensymerror(ERR_DECLMISMATCH,sp->name);
  740. if (sp1->tp->size == 0)
  741. sp1->tp = sp->tp;
  742. if (sp1->storage_class == sc_external || sp1->storage_class == sc_externalfunc) {
  743. sp1->storage_class = sp->storage_class;
  744. sp1->tp = sp->tp;
  745. sp1->value.i = sp->value.i;
  746. }
  747. }
  748. }
  749. else 
  750. join:
  751. if (sp1->tp->type == bt_func && sp->tp->type == bt_ifunc){
  752. if (sp1->storage_class == sc_external || sp1->storage_class == sc_externalfunc || sp1->storage_class == sc_static)
  753. if (al == sc_static || sp1->storage_class == sc_static)
  754. sp->storage_class = sp1->storage_class = sc_static;
  755. else
  756. sp->storage_class = sp1->storage_class = sc_global;
  757. }
  758.                       if( sp->tp->type == bt_ifunc) { /* function body follows */
  759.  if (sp1)
  760.  if (sp1->tp->type == bt_ifunc)
  761.    gensymerror(ERR_MULTIPLEINIT,sp->name);
  762.  else
  763.      sp1->tp->type = bt_ifunc;
  764.                              funcbody(sp);
  765.  lastdecl = sp1;
  766.                              return nbytes;
  767.                              }
  768.                       if( (sp->storage_class == sc_global || sp->storage_class == sc_static) &&
  769.                             sp->tp->type != bt_func && sp->tp->type != bt_ifunc
  770. && !(flags & DF_FUNCPARMS)) {
  771. if (sp->tp->type == bt_ref && lastst != assign)
  772. gensymerror(ERR_REFMUSTINIT,lastid);
  773. if (!sp1)
  774. sp1 = sp;
  775.                           doinit(sp1);
  776. }
  777. else 
  778. if (al == sc_auto || al == sc_autoreg) {
  779. #ifdef CPLUSPLUS
  780. if (prm_cplusplus &&(flags & DF_FUNCPARMS)) {
  781. dodefaultinit(sp);
  782. }
  783. else{
  784. if (sp->tp->type == bt_ref && lastst != assign)
  785. gensymerror(ERR_REFMUSTINIT,lastid);
  786. }
  787. #endif
  788.   doautoinit(sp);
  789. }
  790. }
  791. else if (al != sc_type) {
  792. gensymerror(ERR_SIZE,declid);
  793. expskim(skm_declclosepa);
  794. }
  795. else if (sp->tp->type == bt_func || sp->tp->type == bt_ifunc) {
  796. gensymerror(ERR_ILLTYPE,declid);
  797. expskim(skm_declclosepa);
  798. }
  799. else {
  800. if (sp->tp->size) {
  801. sp->tp = copytype(sp->tp,0);
  802. sp->tp->sname = sp->name;
  803. }
  804.                             insert(sp,table);
  805. }
  806.                 }
  807. if (!(flags & DF_FUNCPARMS)) {
  808.                 if(lastst == semicolon)
  809.                         break;
  810. dhead = copytype(dhead,0);
  811.                  needpunc(comma,0);
  812. }
  813. else {
  814.                 if(lastst == comma)
  815. break;
  816. if (sp1)
  817. lastdecl = sp1;
  818. else
  819. lastdecl = sp;
  820.                   return(nbytes);
  821. }
  822.                 if(declbegin(lastst) == 0)
  823.                         break;
  824.                 head = dhead;
  825. head->uflags = ufsave;
  826.                 }
  827.         getsym();
  828. if (sp1)
  829. lastdecl = sp1;
  830. else
  831. lastdecl = sp;
  832.         return nbytes;
  833. }
  834. int     declare(TABLE *table,int al,int ztype, int flags)
  835. /*
  836.  * In this wrapper we do an ENTIRE declaration
  837.  */
  838. {
  839. int old_gf = global_flag,rv;
  840. if (al != sc_member)
  841. active_table = table;
  842. if (al == sc_static)
  843. global_flag ++;
  844.         decl(table);
  845. rv = basedeclare(table,al,0,ztype,flags);
  846. global_flag = old_gf;
  847. return rv;
  848. }
  849. int     declare2(TABLE *table,int al,int ztype, int flags, long val)
  850. /*
  851.  * In this wrapper we do an ENTIRE declaration
  852.  */
  853. {
  854. int old_gf = global_flag,rv;
  855. if (al != sc_member)
  856. active_table = table;
  857. if (al == sc_static)
  858. global_flag ++;
  859.         decl(table);
  860. rv = basedeclare(table,al,val,ztype,flags);
  861. global_flag = old_gf;
  862. return rv;
  863. }
  865. int     declbegin(int st)
  866. /*
  867.  * This determines if another variable is being declared of the same type
  868.  */
  869. {       return st == star || st == id || st == openpa ||
  870.                 st == openbr;
  871. }
  873. void declenum(TABLE *table)
  874. /*
  875.  * declare enums
  876.  */
  877. {       SYM     *sp;
  878.         TYP     *tp;
  879. char *nm;
  880.         if( lastst == id) {
  881. /* tagged */
  882.                 if((sp = search(nm = litlate(lastid),&tagtable)) == 0) {
  883.                         sp = xalloc(sizeof(SYM));
  884.                         sp->tp = xalloc(sizeof(TYP));
  885.                         sp->tp->type = bt_enum;
  886.                         sp->tp->size = 2;
  887.                         sp->tp->lst.head = sp->tp->btp = 0;
  888.                         sp->storage_class = sc_type;
  889.                         sp->name = nm;
  890.                         sp->tp->sname = sp->name;
  891. sp->tp->bits = sp->tp->startbit = -1;
  892. #ifdef CPLUSPLUS
  893. /* tags are also typedefs in C++ */
  894. if (prm_cplusplus)
  895. insert(sp,active_table);
  896. #endif
  897.                         getsym();
  898.                         if( lastst != begin)
  899.                                 generror(ERR_PUNCT,begin,skm_declend);
  900.                         else    {
  901.                                 insert(sp,&tagtable);
  902.                                 getsym();
  903.                                 enumbody(table);
  904.                                 }
  905.                         }
  906.                 else
  907.                         getsym();
  908.                 head = sp->tp;
  909.                 }
  910.         else    {
  911. /* untagged */
  912.                 tp = xalloc(sizeof(TYP));
  913.                 tp->type = bt_enum;
  914.                 tp->lst.head = tp->btp = 0;
  915. tp->size = 2;
  916. tp->bits = tp->startbit = -1;
  917. tp->sname = 0;
  918.                 if( lastst != begin)
  919.                         generror(ERR_PUNCT,begin,skm_declend);
  920.                 else    {
  921.                         getsym();
  922.                         enumbody(table);
  923.                         }
  924.                 head = tp;
  925.                 }
  926. }
  928. void enumbody(TABLE *table)
  929. /*
  930.  * read the enumeration constants in
  931.  */
  932. {       long     evalue;
  933.         SYM     *sp;
  934.         evalue = 0;
  935.         while(lastst == id) {
  936.                 sp = xalloc(sizeof(SYM));
  937.                 sp->value.i = evalue++;
  938.                 sp->name = litlate(lastid);
  939.                 sp->storage_class = sc_const;
  940.                 sp->tp = &stdconst;
  941.                 insert(sp,active_table);
  942.                 getsym();
  943. if (lastst == assign) {
  944. getsym();
  945. evalue = sp->value.i = intexpr(0);
  946. sp->value.i = evalue++;
  947. if (sp->value.i < SHRT_MIN || sp->value.i >SHRT_MAX)
  948. generror(ERR_CONSTTOOLARGE,0,0);
  949. }
  950.                 if( lastst == comma)
  951.                         getsym();
  952.                 else if(lastst != end)
  953.                         break;
  954.                 }
  955.         needpunc(end,skm_declend);
  956. }
  958. void declstruct(TABLE *table, int ztype, int flags)
  959. /*
  960.  * declare a structure or union type
  961.  */
  962. {       SYM     *sp;
  963.         TYP     *tp;
  964. char *nm = litlate(lastid);
  965.         if(lastst == id) {
  966. /* tagged */
  967.                 if((sp = search(nm,&tagtable)) == 0) {
  968. /* if tag was never defined */
  969.                         sp = xalloc(sizeof(SYM));
  970.                         sp->name = nm;
  971.                         sp->tp = xalloc(sizeof(TYP));
  972.                         sp->tp->type = ztype;
  973.                         sp->tp->lst.head = 0;
  974.                         sp->storage_class = sc_type;
  975.                         sp->tp->sname = sp->name;
  976. sp->tp->cflags = flags;
  977. sp->tp->uflags = UF_DEFINED;
  978. sp->tp->size = 0;
  979. #ifdef CPLUSPLUS
  980. /* tags are also typedefs in C++ */
  981. if (prm_cplusplus)
  982. insert(sp,table);
  983. #endif
  984.                         getsym();
  985.                         if(lastst != begin) {
  986.                                 insert(sp,&tagtable);
  987. /* if (lastst != semicolon)
  988. generror(ERR_PUNCT,semicolon,skm_declend);
  989. */ }
  990.                         else    {
  991.                                 insert(sp,&tagtable);
  992.                                 getsym();
  993.                                 structbody(sp->tp,sp->name,ztype);
  994.                                 }
  995.                         }
  996.                 else {
  997. /* Allow redefinition if it was forward declared */
  998.                         getsym();
  999. if (lastst == begin) {
  1000. getsym();
  1001. if (sp->tp->size == 0) 
  1002. structbody(sp->tp,sp->name,ztype);
  1003. else {
  1004. gensymerror(ERR_DUPSYM,sp->name);
  1005. expskim(skm_declclosebr);
  1006. }
  1007. }
  1008. }
  1009. if (flags & (DF_CONST | DF_VOL))
  1010. head = copytype(sp->tp,flags);
  1011. else
  1012.                  head = sp->tp;
  1013. head->bits = head->startbit = -1;
  1014.                 }
  1015.         else    {
  1016. /* untagged */
  1017.                 tp = xalloc(sizeof(TYP));
  1018.                 tp->type = ztype;
  1019. tp->cflags = flags;
  1020. tp->uflags = UF_DEFINED;
  1021.                 tp->sname = 0;
  1022.                 tp->lst.head = 0;
  1023. tp->bits = tp->startbit =-1;
  1024.                 if( lastst != begin)
  1025.                         generror(ERR_PUNCT,begin,skm_declend);
  1026.                 else    {
  1027.                         getsym();
  1028.                         structbody(tp,tn_unnamed,ztype);
  1029.                         }
  1030.                 head = tp;
  1031.                 }
  1032. }
  1034. void structbody(TYP *tp,char  *name,int ztype)
  1035. /*
  1036.  * read in the structure/union elements and calculate the total size
  1037.  */
  1038. {       int     slc;
  1039.         slc = 0;
  1040.         tp->val_flag = 1;
  1041. tp->uflags &= ~UF_CANASSIGN;
  1042.         while( lastst != end) {
  1043. int flags=0;
  1044.                 if(ztype == bt_struct)
  1045.                         slc += declare2(&tp->lst,sc_member,ztype,flags,slc);
  1046.                 else
  1047.                         slc = imax(slc,declare2(&tp->lst,sc_member,ztype,flags,0));
  1048. if (tp->lst.tail->tp->type == bt_ref)
  1049. genclasserror(ERR_REFNOCONS,name,tp->lst.tail->name);
  1050. tp->lst.tail->tp->uflags |= UF_DEFINED;
  1051.                 }
  1052. if (!prm_packing)
  1053.          tp->size = (slc+strucadd)&strucmod;
  1054. else
  1055. tp->size = slc;
  1056.         getsym();
  1057. }
  1058. void check_used(void)
  1059. /*
  1060.  * At the end of compilition we check for some common cases where 
  1061.  * module-scoped variables are either missing or unused
  1062.  */
  1063. {
  1064. int i;
  1065. SYM *sp;
  1066. for (i=0; i < HASHTABLESIZE; i++) {
  1067. if ((sp=(SYM *) globalhash[i]) != 0) {
  1068. while (sp) {
  1069. if (sp->storage_class == sc_static)
  1070. if (sp->tp->uflags & UF_USED) {
  1071. if (sp->tp->type == bt_func)
  1072. gensymerror(ERR_NOSTATICFUNC,sp->name);
  1073. }
  1074. else
  1075. if (sp->tp->type == bt_ifunc || sp->tp->type == bt_func)
  1076. gensymerror(ERR_FUNCUNUSED,sp->name);
  1077. else
  1078. gensymerror(ERR_STATICSYMUNUSED,sp->name);
  1079. sp = sp->next;
  1080. }
  1081. }
  1082. }
  1083. sp = tagtable.head;
  1084. while (sp) {
  1085. if (sp->tp->size == 0) 
  1086. gensymerror(ERR_NEVERSTRUCT,sp->name);
  1087. sp = sp->next;
  1088. }
  1089. }
  1090. void compile(void)
  1091. /*
  1092.  * Main compiler routine
  1093.  */
  1094. {       while(lastst != eof) {
  1095.                 dodecl(sc_global);
  1096. if (lastst != eof) {
  1097. generror(ERR_DECLEXPECT,0,0);
  1098. getsym();
  1099. }
  1100.         }
  1101.         flush_peep();
  1102. dumplits();
  1103. initrundown();
  1104. dumpstartups();
  1105. check_used();
  1106. putexterns();
  1107. }
  1109. void dodecl(int defclass)
  1110. /*
  1111.  * Declarations come here, ALWAYS
  1112.  */
  1113. {
  1114. SYM *sp;
  1115. int flags = 0;
  1116. long val;
  1117. char *nm;
  1118. cbautoinithead = 0;
  1119.         for(;;) {
  1120. ispascal = FALSE;
  1121.             switch(lastst) {
  1122. case semicolon:
  1123. getsym();
  1124. break;
  1125. case kw_typedef:
  1126. getsym();
  1127. if (defclass == sc_global)
  1128. declare(&gsyms,sc_type,bt_struct, 0);
  1129. else
  1130. declare(&lsyms,sc_type,bt_struct, 0);
  1131. break;
  1132.                 case kw_register:
  1133.                         if( defclass != sc_auto || flags & DF_VOL) {
  1134.                           gensymerror(ERR_ILLCLASS,lastid);
  1135.                          getsym();
  1136. }
  1137. else  {
  1138.                          getsym();
  1139.                              declare(&lsyms,sc_autoreg,bt_struct,flags | DF_AUTOREG);
  1140. };
  1141. break;
  1142.                 case id:
  1143. if (defclass == sc_auto)
  1144. if (!(((sp = search(nm = litlate(lastid),&gsyms)) != 0 && sp->storage_class == sc_type)
  1145.      || ((sp = search(nm,&lsyms)) != 0 && sp->storage_class == sc_type)))
  1146. return;
  1147. case kw_volatile:
  1148. case kw_const:
  1149.                 case kw_char: case kw_int: case kw_short: case kw_unsigned:
  1150.                 case kw_long: case kw_struct: case kw_union: case kw_signed:
  1151.                 case kw_enum: case kw_void:
  1152.                 case kw_float: case kw_double:
  1153.                     if( defclass == sc_global)
  1154.                             declare(&gsyms,sc_global,bt_struct,flags | DF_GLOBAL);
  1155.                     else if( defclass == sc_auto)
  1156.                             declare(&lsyms,sc_auto,bt_struct,flags);
  1157.                     else
  1158.                         declare(&lsyms,sc_auto,bt_struct,flags);
  1159.                     break;
  1160.                 case kw_static:
  1161.                         if( defclass == sc_member) {
  1162.                            gensymerror(ERR_ILLCLASS,lastid);
  1163. getsym();
  1164. break;
  1165. }
  1166. getsym();
  1167. if( defclass == sc_auto)
  1168. declare(&lsyms,sc_static,bt_struct,flags | DF_GLOBAL);
  1169. else
  1170. declare(&gsyms,sc_static,bt_struct,flags | DF_GLOBAL);
  1171.                         break;
  1172.                 case kw_extern: {
  1173. int thismangle = FALSE;
  1174.                         getsym();
  1175. #ifdef CPLUSPLUS
  1176. if (prm_cplusplus && lastst == sconst) {
  1177. if (!strcmp(laststr,Cstr)) {
  1178. mangleflag = FALSE;
  1179. manglelevel++;
  1180. getsym();
  1181. if (lastst == begin) {
  1182. getsym();
  1183.   thismangle = FALSE;
  1184. }
  1185. else thismangle = TRUE;
  1186. }
  1187. }
  1188. #endif
  1189.                         if( defclass == sc_member) {
  1190.                             gensymerror(ERR_ILLCLASS,lastid);
  1191. break;
  1192. }
  1193.                         ++global_flag;
  1194.                         declare(&gsyms,sc_external,bt_struct,flags);
  1195.                         --global_flag;
  1196. if (thismangle && !--manglelevel)
  1197. mangleflag = TRUE;
  1198. }
  1199.                         break;
  1200. case end:
  1201. #ifdef CPLUSPLUS
  1202. if (prm_cplusplus && manglelevel) {
  1203. mangleflag = (!--manglelevel);
  1204. getsym();
  1205. continue;
  1206. }
  1207. #endif
  1208. return;
  1209. case kw__interrupt:
  1210. intflag = 1;
  1211. flags |= DF_INT;
  1212. getsym();
  1213. continue;
  1214. case kw__abs:
  1215. ++global_flag;
  1216. getsym();
  1217. if (lastst != openpa) {
  1218. generror(ERR_PUNCT,openpa,0);
  1219. }
  1220. else {
  1221. getsym();
  1222. val = intexpr(0);
  1223. if (lastst != closepa)
  1224. generror(ERR_PUNCT,closepa,skm_declclosepa);
  1225. }
  1226. getsym();
  1227. declare2(&gsyms,sc_abs,bt_struct,flags,val);
  1228. --global_flag;
  1229. break;
  1230.                 default:
  1231.                         return;
  1232.                 }
  1233. flags = 0;
  1234. intflag = 0;
  1235.             }
  1236. }
  1237. void doargdecl(int defclass, char *names[], int *nparms, TABLE *table, int isinline)
  1238. /*
  1239.  * Function arguments are declared here
  1240.  */
  1241. {
  1242. SYM *sp;
  1243. int flags = isinline ? DF_FUNCPARMS : 0;
  1244.         for(;;) {
  1245.             switch(lastst) {
  1246. case ellipse: {
  1247. sprintf(declid,"**ELLIPSE%d**",pcount++);
  1248. sp = xalloc(sizeof(SYM));
  1249. sp->name = litlate(declid);
  1250.                   sp->storage_class = sc_auto;
  1251. sp->tp = maketype(bt_ellipse,0);
  1252. sp->tp->uflags |= UF_DEFINED | UF_USED;
  1253. insert(sp,table);
  1254. if (ispascal)
  1255. generror(ERR_PASCAL_NO_ELLIPSE,0,0);
  1256. getsym();
  1257. goto exit;
  1258. }
  1259. case kw_const:
  1260. case id:
  1261.                 case kw_char: case kw_int: case kw_short: case kw_unsigned:
  1262.                 case kw_long: case kw_struct: case kw_union: case kw_signed:
  1263.                 case kw_enum: case kw_void:
  1264.                 case kw_float: case kw_double:
  1265.                     declare(table,sc_auto,bt_struct,flags);
  1266.                     break;
  1267.                 case kw_static:
  1268. case kw_auto:
  1269. case kw_register:
  1270.                         gensymerror(ERR_ILLCLASS,lastid);
  1271.                         getsym();
  1272. continue;
  1273.                 default:
  1274. goto exit;
  1275.                 }
  1276. if (isinline) {
  1277. names[(*nparms)++] = litlate(declid);
  1278. }
  1280. flags &= ~DF_CONST;
  1281. }
  1282. exit:
  1283. #ifdef CPLUSPLUS
  1284. if (prm_cplusplus) {
  1285. SYM *sp = table->head;
  1286. int found = FALSE;
  1287. while (sp) {
  1288. if (sp->defalt)
  1289. found = TRUE;
  1290. else 
  1291. if (found)
  1292. gensymerror(ERR_MISSINGDEFAULT,sp->name);
  1293. sp = sp->next;
  1294. }
  1295. }
  1296. #endif
  1297. }