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

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

编译器/解释器

开发平台：

Others

INIT.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.  * handles initialization of module-scoped declarations
  24.  */
  25. #include        <stdio.h>
  26. #include <limits.h>
  27. #include        "expr.h"
  28. #include        "c.h"
  29. #include        "errors.h"
  31. extern int stdldoublesize;
  32. extern enum e_sym lastst;
  33. extern char lastid[], laststr[];
  34. extern TABLE gsyms;
  35. extern int skm_declend[];
  36. extern long bittab[];
  37. extern int nextlabel;
  38. extern TYP stdmatch;
  39. extern int skm_closebr[];
  40. extern int prm_cplusplus;
  41. extern SYM *currentfunc;
  42. extern int prm_bss;
  43. static SYM *locsp;
  44. static short cursize;
  45. static short startbit,bits;
  46. static long totbits;
  47. static int allocated;
  48. static ENODE *cpprefhead;
  49. static ENODE **cppreftail;
  50. static int baseoffs = 0;
  52. static struct decldata **sptr;
  54. static struct declares {
  55. struct declares *link;
  56. SYM *sp;
  57. } *declarations, *decltail;
  59. void initini(void)
  60. {
  61. cpprefhead = 0;
  62. declarations = decltail = 0;
  63. }
  64. void initrundown(void)
  65. /*
  66.  * Dump out C++ pointer and reference initializations functions 
  67.  */
  68. {
  69. struct declares *q;
  70. long nbytes,obytes,val,onbytes;
  72. #ifdef CPLUSPLUS
  73. if (cpprefhead) {
  74. int lbl = nextlabel++;
  75. SNODE stmt;
  76. currentfunc = xalloc(sizeof(SYM));
  77. currentfunc->tp = maketype(bt_func,0);
  78. currentfunc->tp->btp = maketype(bt_void,0);
  79. currentfunc->tp->lst.head = 0;
  80. currentfunc->intflag = 0;
  81. stmt.stype = st_expr;
  82. stmt.next = 0;
  83. stmt.exp = cpprefhead;
  84. cseg();
  86. gen_label(lbl);
  87. genfunc(&stmt);
  88. flush_peep();
  89. cppseg();
  90. gen_labref(lbl);
  91. currentfunc = 0;
  92. cpprefhead = 0;
  93. }
  94. #endif
  95. nl();
  96. dseg();
  97. q = declarations;
  98. nbytes = 0;
  99. while (q) {
  100. SYM *sp = q->sp;
  101. if ((sp->init || !prm_bss) && !sp->absflag) {
  102. int align = getalign(sc_global,sp->tp);
  103. val = align - (nbytes % align);
  104. if (val != align) {
  105. genstorage(val);
  106. nbytes += val;
  107. nl();
  108. }
  109. onbytes = nbytes;
  110. nbytes += gen(sp);
  111. sp->value.i = onbytes;
  112. }
  113. q = q->link;
  114. }
  115. if (prm_bss) {
  116. obytes  = nbytes;
  117. nbytes = 0;
  118. bssseg();
  119. q = declarations;
  120. while (q) {
  121. SYM *sp = q->sp;
  122. if (!sp->init && !sp->absflag) {
  123. int align = getalign(sc_global,sp->tp);
  124. val = align - (nbytes % align);
  125. if (val != align) {
  126. genstorage(val);
  127. nbytes += val;
  128. nl();
  129. }
  130. onbytes = nbytes;
  131. nbytes += gen(sp);
  132. sp->value.i = onbytes + obytes;
  133. }
  134. q = q->link;
  135. }
  136. }
  137. }
  138. static long gen(SYM *sp)
  139. {
  140. struct decldata *decldata = sp->init;
  141. long nbytes=0;
  142. if (sp->storage_class == sc_global) {
  143. globaldef(sp);
  144. }
  145. if (sp->staticlabel)
  146. put_staticlabel(sp->value.i);
  147. else
  148. gen_strlab(sp);
  149. if (decldata) {
  150. while (decldata) {
  151. switch (decldata->mode) {
  152. case dd_byte: 
  153. genbyte(decldata->val.i);
  154. nbytes++;;
  155. break;
  156. case dd_word:
  157. genword(decldata->val.i);
  158. nbytes += 2;
  159. break;
  160. case dd_long:
  161. genlong(decldata->val.i);
  162. nbytes += 4;
  163. break;
  164. case dd_float:
  165. genfloat(decldata->val.f);
  166. nbytes += 4;
  167. break;
  168. case dd_double:
  169. gendouble(decldata->val.f);
  170. nbytes += 8;
  171. break;
  172. case dd_ldouble:
  173. genlongdouble(decldata->val.f);
  174. nbytes += stdldoublesize;
  175. break;
  176. case dd_pcname:
  177. genpcref(decldata->val.sp,decldata->offset);
  178. nbytes += 4;
  179. break;
  180. case dd_dataname:
  181. genref(decldata->val.sp,decldata->offset);
  182. nbytes += 4;
  183. break;
  184. case dd_storage:
  185. genstorage(decldata->val.i);
  186. nbytes += decldata->val.i;
  187. break;
  188. case dd_label:
  189. gen_labref(decldata->val.i);
  190. nbytes += 4;
  191. break;
  192. }
  193. decldata = decldata->link;
  194. }
  195. }
  196. else {
  197. if (sp->tp->size == 0)
  198. gensymerror(ERR_ZEROSTORAGE,sp->name);
  199. else
  200. genstorage(nbytes += sp->tp->size);
  201. }
  202. nl();
  203. return nbytes;
  204. }
  205. #ifdef CPLUSPLUS
  206. void cppinitinsert(ENODE *node)
  207. /*
  208.  * insert an initialization function on the list
  209.  */
  210. {
  211. if (!cpprefhead) {
  212. cpprefhead = node;
  213. cppreftail = &cpprefhead;
  214. }
  215. else {
  216. *cppreftail = makenode(en_void,*cppreftail,node);
  217. cppreftail = & (*cppreftail)->v.p[1];
  218. }
  219. }
  220. #endif
  221. void doinit(SYM *sp)
  222. /*
  223.  * Handle static variable initialize
  224.  */
  225. {
  226. sp->tp->uflags |= UF_DEFINED;
  227. allocated = FALSE;
  228. baseoffs = 0;
  229. totbits = 0;
  230. cursize = -1;
  231. bits = -1;
  232. locsp = sp;
  233. sptr = &sp->init;
  234. if (!sp->indecltable) {
  235.   struct declares * p = xalloc(sizeof(struct declares));
  236. p -> sp = sp;
  237. p->link = 0;
  238. if (declarations)
  239. decltail = decltail->link = p;
  240. else
  241. decltail = declarations = p;
  242. sp->indecltable = TRUE;
  243. }
  244.         if( lastst == assign) {
  245. if (sp->init)
  246. gensymerror(ERR_MULTIPLEINIT,sp->name);
  247. if (sp->absflag) {
  248. generror(ERR_NOINIT,0,skm_declend);
  249.           return;
  250. }
  251.                 getsym();
  252.                 inittype(sp->tp);
  253. *sptr = 0;
  254.         }
  255.         endinit();
  256. }
  258. int     inittype(TYP *tp)
  259. /*
  260.  * Init for basic types
  261.  */
  262. {       int     nbytes;
  263.         switch(tp->type) {
  265. case bt_float:
  266. nbytes = initfloat();
  267. break;
  268. case bt_longdouble:
  269. nbytes = initlongdouble();
  270. break;
  271. case bt_double:
  272. nbytes = initdouble();
  273. break;
  274.                 case bt_char:
  275.                         nbytes = initchar();
  276.                         break;
  277.                 case bt_unsignedchar:
  278.                         nbytes = inituchar();
  279.                         break;
  280.                 case bt_unsignedshort:
  281.                         nbytes = initushort();
  282.                         break;
  283.                 case bt_short:
  284.                 case bt_enum:
  285.                         nbytes = initshort();
  286.                         break;
  287.                 case bt_ptrfunc:
  288.                         nbytes = initpointerfunc();
  289.                         break;
  290.                 case bt_pointer:
  291.                         if( tp->val_flag)
  292.                                 nbytes = initarray(tp);
  293.                         else
  294.                                 nbytes = initpointer();
  295.                         break;
  296. #ifdef CPLUSPLUS
  297. case bt_ref:
  298. nbytes = initref(tp->btp);
  299. break;
  300. #endif
  301.                 case bt_unsigned:
  302.                         nbytes = initulong();
  303.                         break;
  304.                 case bt_long:
  305.                 case bt_matchall:
  306.                         nbytes = initlong();
  307.                         break;
  308.                 case bt_struct:
  309.                         nbytes = initstruct(tp);
  310.                         break;
  311.                 default:
  312.    gensymerror(ERR_NOINIT,locsp->name);
  313.                         nbytes = 0;
  314.                 }
  315. baseoffs+=nbytes;
  316.         return nbytes;
  317. }
  319. int initarray(TYP *tp)
  320. /*
  321.  * Init for arrays
  322.  */
  323. {       int     nbytes;
  324. int canpad = FALSE;
  325.         char    *p;
  326. int needend = FALSE;
  327.         nbytes = 0;
  328.         if( lastst == begin) {
  329.                 getsym();               /* skip past the brace */
  330. needend = TRUE;
  331. if ((tp->btp->type == bt_char  || tp->btp->type ==bt_unsignedchar)&& lastst == sconst)
  332. goto grabchar;
  333. if ((tp->btp->type == bt_short  || tp->btp->type ==bt_unsignedshort)&& lastst == lsconst)
  334. goto grabchar;
  335.                 while(lastst != end) {
  336.                         nbytes += inittype(tp->btp);
  337.                         if( lastst == comma)
  338.                                 getsym();
  339.                         else if( lastst != end) {
  340.                                 expecttoken(end,0);
  341. break;
  342. }
  343.                         }
  344.                 getsym();               /* skip closing brace */
  345.                 }
  346.         else { 
  347. grabchar:
  348. allocated = TRUE;
  349. nbytes = 0;
  350. if ((tp->btp->type == bt_char  || tp->btp->type ==bt_unsignedchar)&& lastst == sconst) {
  351. canpad = TRUE;
  352. while (lastst == sconst) {
  353.                 p = laststr;
  354. while (*p) {
  355. nbytes++;
  356. agflush(1,*p++);
  357. }
  358.                 getsym();
  359. }
  360. if (needend)
  361. needpunc(end,skm_declend);
  362. agflush(1,0);
  363. nbytes++;
  364.   } else if ((tp->btp->type == bt_short  || tp->btp->type ==bt_unsignedshort)&& lastst == lsconst) {
  365. while (lastst == lsconst) {
  366.                 p = laststr;
  367. while (*p) {
  368. nbytes+=2;
  369. agflush(2,*p++);
  370. }
  371.                 getsym();
  372. }
  373. if (needend)
  374. needpunc(end,skm_declend);
  375. agflush(2,0);
  376. nbytes +=2;
  377.             }
  378.             else generror(ERR_PUNCT,semicolon,0);
  379. }
  380.         if( nbytes < tp->size) {
  381. nl();
  382.                 makestorage( tp->size - nbytes);
  383.                 nbytes = tp->size;
  384.                 }
  385.         else if (tp->size == 0)
  386. tp->size = nbytes;
  387. else if( nbytes > tp->size && (!canpad || nbytes > tp->size+1))
  388.                 generror(ERR_INITSIZE,0,0);    /* too many initializers */
  389.         return nbytes;
  390. }
  392. int initstruct(TYP *tp)
  393. /*
  394.  * Init for structures
  395.  */
  396. {       SYM     *sp;
  397.         int     nbytes;
  398.         needpunc(begin,0);
  399.         nbytes = 0;
  400.         sp = tp->lst.head;      /* start at top of symbol table */
  401.         while(sp != 0 && lastst != end) {
  402. startbit = sp->tp->startbit;
  403. bits = sp->tp->bits;
  404. if (nbytes < sp->value.i)
  405. makestorage(sp->value.i - nbytes);
  406. nbytes = sp->value.i;
  407.                 nbytes += inittype(sp->tp);
  408.                 if( lastst == comma)
  409.                         getsym();
  410.                 else if(lastst == end)
  411.                         break;
  412.                 else
  413.                         expecttoken(end,0);
  414.                 sp = sp->next;
  415.                 }
  416. nbytes += agbits(-1,0);
  417.         if( nbytes < tp->size) {
  418. makestorage(tp->size - nbytes);
  419. }
  420.         needpunc(end,skm_declend);
  421.         return tp->size;
  422. }
  424. int makelabel(void)
  425. {
  426. struct decldata *q = *sptr = xalloc(sizeof(struct decldata));
  427. q->val.i = tostring();
  428. sptr = &(*sptr)->link;
  429. q->mode = dd_label;
  430. }
  431. int makeref(int ispc, SYM *sp, long val)
  432. {
  433. struct decldata *q = *sptr = xalloc(sizeof(struct decldata));
  434. sp->extflag = TRUE;
  435. q->val.sp = sp;
  436. q->offset = val;
  437. sptr = &(*sptr)->link;
  438. q->mode = ispc ? dd_pcname : dd_dataname;
  439. }
  440. int makestorage(long val)
  441. {
  442. struct decldata *q = *sptr = xalloc(sizeof(struct decldata));
  443. q->val.i = val;
  444. sptr = &(*sptr)->link;
  445. q->mode = dd_storage;
  446. }
  447. int agflush(int size, long val)
  448. /*
  449.  * flush a bit field when it is full
  450.  */
  451. {
  452. struct decldata *q = *sptr = xalloc(sizeof(struct decldata));
  453. q->val.i = val;
  454. sptr = &(*sptr)->link;
  455. switch (size) {
  456. case 1:
  457. q->mode = dd_byte;
  458. return 1;
  459. case 2:
  460. q->mode = dd_word;
  461. return 2;
  462. case 4:
  463. q->mode = dd_long;
  464. return 4;
  465. default:
  466. q->mode = dd_byte;
  467. return 0;
  468. }
  469. }
  470. /* Aggregate bits */
  471. int agbits(int size, long value)
  472. /*
  473.  * ombine bit declarations into a bit field
  474.  */
  475. {
  476. long rv = 0;
  477. if (cursize != -1 && (size != cursize || bits == -1 || (bits != -1 &&startbit==0))) {
  478. rv = agflush(cursize,totbits);
  479. cursize = -1;
  480. totbits = 0;
  481. }
  482. if (bits != -1) {
  483. totbits |= (value & bittab[bits-1]) << startbit;
  484. cursize = size;
  485. }
  486. else {
  487. if (size != -1)
  488. rv+= agflush(size,value);
  489. cursize = -1;
  490. totbits = 0;
  491. }
  492. startbit = -1;
  493. return(rv);
  494. }
  495. /* Basic type subroutines */
  496. int initfloat(void)
  497. {
  498. struct decldata *q = *sptr = xalloc(sizeof(struct decldata));
  499. q->val.f = floatexpr();
  500. sptr = &(*sptr)->link;
  501. q->mode = dd_float;
  502. allocated = TRUE;
  503. return(4);
  504. }
  505. int initlongdouble(void)
  506. {
  507. struct decldata *q = *sptr = xalloc(sizeof(struct decldata));
  508. q->val.f = floatexpr();
  509. sptr = &(*sptr)->link;
  510. q->mode = dd_ldouble;
  511. allocated = TRUE;
  512. return(stdldoublesize);
  513. }
  514. int initdouble(void)
  515. {
  516. struct decldata *q = *sptr = xalloc(sizeof(struct decldata));
  517. allocated = TRUE;
  518. q->val.f = floatexpr();
  519. sptr = &(*sptr)->link;
  520. q->mode = dd_double;
  521. return(8);
  522. }
  523. int initchar(void)
  524. {       
  525. long t;
  526. int rv;
  527. allocated = TRUE;
  528. rv = agbits(1,t = intexpr(0));
  529. if (t < SCHAR_MIN || t > SCHAR_MAX)
  530. generror(ERR_CONSTTOOLARGE,0,0);
  531. return rv;
  532. }
  533. int initshort(void)
  534. {   
  535. long t;
  536. int rv;
  537. allocated = TRUE;
  538. rv = agbits(2,t = intexpr(0));
  539. if (t < SHRT_MIN || t > SHRT_MAX)
  540. generror(ERR_CONSTTOOLARGE,0,0);
  541. return rv;
  542. }
  543. int inituchar(void)
  544. {       
  545. long t;
  546. int rv;
  547. allocated = TRUE;
  548. rv = agbits(1,t = intexpr(0));
  549. if (t < 0 || t > UCHAR_MAX)
  550. generror(ERR_CONSTTOOLARGE,0,0);
  551. return rv;
  552. }
  553. int initushort(void)
  554. {   
  555. long t;
  556. int rv;
  557. allocated = TRUE;
  558. rv = agbits(2,t = intexpr(0));
  559. if (t < 0 || t > USHRT_MAX)
  560. generror(ERR_CONSTTOOLARGE,0,0);
  561. return rv;
  562. }
  563. int initlong(void)
  564. {       
  565. long t;
  566. int rv;
  567. allocated = TRUE;
  568. rv = agbits(4,t = intexpr(0));
  569. if (t < LONG_MIN || t > LONG_MAX)
  570. generror(ERR_CONSTTOOLARGE,0,0);
  571. return rv;
  572. }
  573. int initulong(void)
  574. {   
  575. long t;
  576. int rv;
  577. allocated = TRUE;
  578. rv = agbits(4,t = intexpr(0));
  579. if (t < 0 || t > ULONG_MAX)
  580. generror(ERR_CONSTTOOLARGE,0,0);
  581. return rv;
  582. }
  583. void getreflvalue(ENODE **node, TYP **tp,int pointer)
  584. /*
  585.  * create a node tree for pointer and references that are going in as data
  586.  */
  587. {
  588. SYM *sp;
  589. ENODE *pnode=0;
  590. sp = 0;
  591. while (lastst == star) {
  592. getsym();
  593. getreflvalue(&pnode,tp,pointer);
  594. if ((*tp)->type == bt_pointer) {
  595. *tp = (*tp)->btp;
  596. pnode = makenode(en_l_ref,pnode,0);
  597. }
  598. else {
  599. generror(ERR_DEREF,0,0);
  600. }
  601. *node = pnode;
  602. return;
  603. }
  604. if (lastst == and && pointer) {
  605. getsym();
  606. getreflvalue(&pnode,tp,pointer);
  607. if (!((*tp)->type == bt_ifunc) && !((*tp)->type == bt_func) && !(*tp)->val_flag) {
  608. TYP *tp1 = maketype(bt_pointer,4);
  609. tp1->btp = *tp;
  610. *tp = tp1;
  611. if (pnode)
  612. pnode = pnode->v.p[0];
  613. }
  614. *node = pnode;
  615. return;
  616. }
  617. if (lastst != id) {
  618. long temp;
  619. getsym();
  620. temp = intexpr(tp);
  621. (*node) = makenode(en_icon,(char *)temp,0);
  622. return;
  623. }
  624. if ((sp = search(lastid,&gsyms)) == 0) {
  625. gensymerror(ERR_UNDEFINED,lastid);
  626. return;
  627. }
  628. pnode = makenode(en_nacon,(char *)sp->name,0);
  629. if (pointer && !sp->tp->val_flag)
  630. pnode = makenode(en_l_ref,pnode,0);
  631. *tp = sp->tp;
  632. getsym();
  633. while (TRUE) {
  634. long temp;
  635. switch(lastst) {
  636.     case openbr:    /* build a subscript reference */
  637. getsym();
  638. temp = intexpr(0);
  639.        if( (*tp)->type != bt_pointer )
  640.          generrorexp(ERR_NOPOINTER,0,skm_closebr);
  641.       else {
  642.          (*tp) = (*tp)->btp;
  643. pnode = makenode(en_add,pnode,makenode(en_icon,(char *)(temp*(*tp)->size),0));
  644. }
  645.        needpuncexp(closebr,skm_closebr);
  646.        break;
  647.       case pointsto:
  648.         if( (*tp)->type != bt_pointer ) {
  649.          generror(ERR_NOPOINTER,0,0);
  650. while (lastst == pointsto || lastst == dot) {
  651. getsym();
  652. getsym();
  653. }
  654. break;
  655. }
  656.         else {
  657.          (*tp) = (*tp)->btp;
  658. pnode = makenode(en_l_ref,pnode,0);
  659. }
  660. /*
  661.  *      fall through to dot operation
  662.  */
  663.       case dot:
  664.         getsym();       /* past -> or . */
  665.       if( lastst != id )
  666.          generror(ERR_IDEXPECT,0,0);
  667.        else    {
  668.          sp = search(lastid,&(*tp)->lst);
  669.          if( sp == 0 ) {
  670. (*tp) = &stdmatch;
  671.           gensymerror(ERR_UNDEFINED,lastid);
  672. getsym();
  673. while (lastst == pointsto || lastst == dot) {
  674. getsym();
  675. getsym();
  676. }
  677. }
  678.          else    {
  679. pnode = makenode(en_add,pnode,makenode(en_icon,(char *)sp->value.i,0));
  680.            (*tp) = sp->tp;
  681.            getsym();       /* past id */
  682.          }
  683.          break;
  685. }
  686. case plus:
  687. getsym();
  688. pnode = makenode(en_add,pnode,makenode(en_icon,(char *)intexpr(0),0));
  689. break;
  690. case minus:
  691. getsym();
  692. pnode = makenode(en_add,pnode,makenode(en_icon,(char *)(-intexpr(0)),0));
  693. break;
  694. default:
  695. *node =pnode;
  696. return;
  697. }
  698. }
  699. }
  700. int checkrefeval(ENODE *node)
  701. /*
  702.  * see if a reference node can be evaluated at compile time
  703.  */
  704. {
  705. switch(node->nodetype) {
  706. case en_add:
  707. return(checkrefeval(node->v.p[0]) || checkrefeval(node->v.p[1]));
  708. case en_l_ref:
  709. return 1;
  710. case en_nacon:
  711. case en_icon:
  712. case en_lcon:
  713. case en_lucon:
  714. case en_iucon:
  715. return 0;
  716. default:
  717. return 1;
  718. }
  719. }
  720. int refeval(ENODE *one, ENODE **two)
  721. /*
  722.  * compile time evaluation of references and pointers */
  723. {
  724. while (1) {
  725. switch (one->nodetype) {
  726. case en_add:
  727. return(refeval(one->v.p[0],two) + refeval(one->v.p[1],two));
  728. case en_icon:
  729. case en_lcon:
  730. case en_lucon:
  731. case en_iucon:
  732. return(one->v.i);
  733. case en_nacon:
  734. *two = one;
  735. return 0;
  736. default:
  737. return 0;
  738. }
  739. }
  740. }
  741. #ifdef CPLUSPLUS
  742. int initref(TYP *tp)
  743. /*
  744.  * init for reference variables
  745.  */
  746. {
  747. SYM *sp;
  748. TYP *tp1;
  749. ENODE *node=0,*node1;
  750. int ofs;
  751. allocated = TRUE;
  752. getreflvalue(&node,&tp1,0);
  753. if (!node || !checktype(tp,tp1)) {
  754. genstorage(4);
  755. generror(ERR_REFLVALUE,0,0);
  756. }
  757. else {
  758. if (!checkrefeval(node)) {
  759. ofs = refeval(node,&node1);
  760. sp = search(node1->v.sp,&gsyms);
  761. makeref(FALSE,sp,ofs);
  762. sp->tp->uflags |= UF_USED;
  763. }
  764. else  {
  765. node1 = makenode(en_l_ref,makenode(en_nacon,locsp->name,0),0);
  766. node1 = makenode(en_assign,node1,node);
  767. cppinitinsert(node1);
  768. genstorage(4);
  769. }
  770. }
  771. endinit();
  772. return 4;
  773. }
  774. #endif
  775. int initpointer(void)
  776. {       SYM     *sp;
  777. ENODE *node=0,*node1;
  778. TYP *tp1;
  779. allocated = TRUE;
  780.         if(lastst == sconst) {
  781.                 makelabel();
  782.                 }
  783.         else if(lastst == lsconst) {
  784.                 makelabel();
  785.                 }
  786. else if (lastst == iconst || lastst == lconst || lastst == iuconst || lastst == luconst) {
  787. long temp;
  788. TYP *tp;
  789.                 agflush(4,temp = intexpr(&tp));
  790. if (temp && (tp->type != bt_pointer && tp->type != bt_ptrfunc))
  791. generror(ERR_NONPORT,0,0);
  792. }
  793. else {
  794. getreflvalue(&node,&tp1,1);
  795. if (!node || (tp1->type != bt_pointer && tp1->type != bt_func && tp1->type != bt_ifunc && !tp1->val_flag))
  796. gensymerror(ERR_NOINIT,locsp->name);
  797. else {
  798. if (!checkrefeval(node)) {
  799. int ofs = refeval(node,&node1);
  800. sp = search(node1->v.sp,&gsyms);
  801. if (sp->tp->type == bt_func || sp->tp->type == bt_ifunc) {
  802.                makeref(TRUE,sp,ofs);
  803. }
  804. else
  805.                makeref(FALSE,sp,ofs);
  806. sp->tp->uflags |= UF_USED;
  807. }
  808. else  {
  809. if (!prm_cplusplus) 
  810. gensymerror(ERR_NOINIT,locsp->name);
  811. #ifdef CPLUSPLUS
  812. else {
  813. node1 = makenode(en_l_ref,makenode(en_nacon,locsp->name,0),0);
  814. node1 = makenode(en_assign,node1,node);
  815. cppinitinsert(node1);
  816. }
  817. #endif
  818. makestorage(4);
  819. }
  820.  }
  821. }
  822.         endinit();
  823.         return 4;       /* pointers are 4 bytes long */
  824. }
  825. int initpointerfunc(void)
  826. {       SYM     *sp;
  827. char *nm;
  828. allocated = TRUE;
  829.         if(lastst == and)     /* address of a variable */
  830.                 getsym();
  831.         if(lastst != id) {
  832. long temp;
  833. TYP *tp;
  834.                 agflush(4,temp = intexpr(&tp));
  835. if (temp && (tp->type != bt_pointer && tp->type != bt_ptrfunc))
  836. generror(ERR_NONPORT,0,0);
  837. endinit();
  838. return(4);
  839.  }
  840.         else  {
  841. #ifdef CPLUSPLUS
  842. if (prm_cplusplus)
  843. nm = cppmangle(lastid,locsp->tp);
  844. else
  845. #endif
  846. nm = lastid;
  847. if( (sp = gsearch(nm)) == 0)
  848.   gensymerror(ERR_UNDEFINED,nm);
  849.          else
  850.            getsym();
  851. }
  852.         makeref(TRUE,sp,0);
  853. if (sp)
  854. sp->tp->uflags |= UF_USED;
  855.         endinit();
  856.         return 4;       /* pointers are 4 bytes long */
  857. }
  858. /* Finish init */
  859. void endinit(void)
  860. {       if( lastst != comma && lastst != semicolon && lastst != end) {
  861.                 expecttoken(end,0);
  862.                 while( lastst != comma && lastst != semicolon && lastst != end && lastst != eof)
  863.                         getsym();
  864.                 }
  865. }