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

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

编译器/解释器

开发平台：

Others

GETSYM.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. /* scanner
  23.  */
  24. /* Trigraphs implemented, won't work for token pasting though */
  25. #include        <stdio.h>
  26. #include <ctype.h>
  27. #include <limits.h>
  28. #include "list.h"
  29. #include        "expr.h"
  30. #include        "c.h"
  31. #include        "errors.h"
  32. #include "utype.h"
  33. #include "interp.h"
  35. extern int prm_errfile;
  36. extern int version;
  37. extern LIST *clist;
  38. extern FILE *cppFile, *listFile, *inputFile;
  39. extern int prm_cplusplus,prm_cmangle,prm_ansi;
  40. extern int ifskip,elsetaken;
  41. extern IFSTRUCT *ifs;
  42. extern char *errfile;
  43. extern int errlineno;
  44. extern int phiused;
  46. extern char *infile;
  47. extern short            *lptr;          /* shared with preproc */
  48. extern FILE            *inclfile[10];  /* shared with preproc */
  49. extern char            *inclfname[10];  /* shared with preproc */
  50. extern IFSTRUCT  *ifshold[10];
  51. extern int             inclline[10];   /* shared with preproc */
  52. extern int             incldepth;      /* shared with preproc */
  53. extern int prm_listfile;
  54. int lineno;
  55. short     inputline[4096];
  56. int             lastch;
  57. enum e_sym      lastst;
  58. char            lastid[100] = "";
  59. char            laststr[MAX_STRLEN + 1] = "";
  60. long            ival = 0;
  61. long double          rval = 0.0;
  62. char            *linstack[20];  /* stack for substitutions */
  63. char            chstack[20];    /* place to save lastch */
  64. int             lstackptr = 0;  /* substitution stack pointer */
  65. int cantnewline = FALSE;
  66. int incconst = FALSE;
  68. int backupchar = -1;
  70. static int phiputcpp,phiputlist,phiputerror;
  71. static int commentlevel;
  73. void initsym(void)
  74. {       lptr = inputline;
  75.         inputline[0] = 0;
  76.         lineno = 0; errlineno = 0;
  77. lastid[0] = 0;
  78. laststr[0] = 0;
  79. ival = 0;
  80. rval = 0.0;
  81. cantnewline=FALSE;
  82. incconst = FALSE;
  83. backupchar = -1;
  84. phiputcpp=phiputlist = phiputerror = FALSE;
  85. }
  87. void lineToCpp(void)
  88. /*
  89.  * line has been preprocessed, dump it to a file
  90.  */
  91. {
  92. if (cppFile) {
  93. char buf[100],*q=buf;
  94. short *p = inputline;
  95. *q = 0;
  96. if (!phiputcpp) {
  97. phiputcpp = TRUE;
  98. if (phiused)
  99. fputc('x1f',cppFile);
  100. fprintf(cppFile,"/* LADsoft C compiler Version %d.%02d */nn",version / 100, version %100);
  101. }
  102. while (*p) {
  103. int i;
  104. if (*q) {
  105. buf[0] = *q;
  106. i = 1;
  107. }
  108. else
  109. i = 0;
  110. i+=installphichar(*p++,buf,i);
  111. buf[i] = 0;
  112. q = buf;
  113. while (*q && (*(q+1) || ((*q &0xf0) != 0x90)))
  114. fputc(*q++,cppFile);
  115. }
  116. }
  117. }
  118. /* Strips comments and also the newline char at the end of the line */
  119. static void stripcomment (short *line)
  120. {
  121. short *s = line, *e = s;
  122. while (*e) {
  123. if (*e == '/' && (!commentlevel || !prm_ansi || prm_cplusplus)) {
  124. if (*(e+1) == '*') {
  125. e++;
  126. commentlevel++;
  127. }
  128. else if (*(e+1) == '/' && !commentlevel && (!prm_ansi || prm_cplusplus)) {
  129. *s = 0;
  130. return;
  131. }
  132. else if (!commentlevel)
  133. *s++ = *e;
  134. }
  135. else if (commentlevel && *e == '*' && *(e+1) == '/') {
  136. commentlevel--;
  137. e++;
  138. if (commentlevel == 0) {
  139. *s++ = ' '; /* Comments are whitespace */
  140. }
  141. }
  142. else if (!commentlevel)
  143. *s++ = *e;
  144.     e++;
  145. }
  146. *s = 0;
  147. }
  148. /* strip trigraphs */
  149. void striptrigraph(short *buf)
  150. {
  151. short *cp = buf;
  152. while (*cp) {
  153. if (*cp == '?' && *(cp+1) == '?') {
  154. cp +=2;
  155. switch (*cp++) {
  156. case '=':
  157. *buf++='#';
  158. break;
  159. case '(':
  160. *buf++='[';
  161. break;
  162. case '/':
  163. *buf++='\';
  164. break;
  165. case ')':
  166. *buf++=']';
  167. break;
  168. case ''':
  169. *buf++='^';
  170. break;
  171. case '<':
  172. *buf++='{';
  173. break;
  174. case '!':
  175. *buf++='|';
  176. break;
  177. case '>':
  178. *buf++='}';
  179. break;
  180. case '-':
  181. *buf++='~';
  182. break;
  183. default:
  184. cp-=2;
  185. break;
  186. }
  187. }
  188. else *buf++ = *cp++;
  189. }
  190. *buf = 0;
  191. }
  192. int     getline(int listflag)
  193. /*
  194.  * Read in a line, preprocess it, and dump it to the list and preproc files
  195.  * Also strip comments and alter trigraphs
  196.  */
  197. {       int     rv,rvc,i,prepping,temp;
  199. char ibuf[4096];
  200. int *ptr = ibuf;
  201. if (cantnewline) {
  202. return(0);
  203. }
  204. do {
  205. rv = FALSE;
  206. prepping = FALSE;
  207. rvc = 0;
  208.         if( lineno > 0 && listflag && prm_listfile) {
  209. if (!phiputlist) {
  210. if (phiused) {
  211. fputc('x1f',listFile);
  212. }
  213. phiputlist = TRUE;
  214. }
  215.         }
  216.         if( lineno > 0 && prm_errfile) {
  217. if (!phiputerror) {
  218. if (phiused) {
  219. fputc('x1f',listFile);
  220. }
  221. phiputerror = TRUE;
  222. }
  223.         }
  224. lferror();
  225. while(rvc +131 < 4096 && !rv) {
  226.         ++lineno; ++errlineno;
  227.          rv = (philine(ibuf+rvc,200,inputFile) == NULL);
  228. if (rv)
  229. break;
  230. rvc = strlen(ibuf);
  231. if (ibuf[rvc-1] != 'n') {
  232. ibuf[rvc++] = 'n';
  233. ibuf[rvc] = 0;
  234. }
  235. rvc-=2;
  236. while (ibuf[rvc]==' ')
  237. rvc--;
  238. if (ibuf[rvc] != '\')
  239. break;
  240. }
  241. if (rvc)
  242. rv = FALSE;
  243.         if(prm_listfile) {
  244. if (!phiputlist) {
  245. if (phiused) {
  246. fputc('x1f',listFile);
  247. }
  248. fprintf(listFile,"LADsoft C compiler Version %d.%02d - %snn",version / 100, version % 100,clist->data);
  249. phiputlist = TRUE;
  250. }
  251. fprintf(listFile,"%5d: %s",lineno, ibuf);
  252.         }
  253.         if( rv) {
  254. if (ifs)
  255. generror(ERR_PREPROCMATCH,0,0);
  256. if (commentlevel)
  257. generror(ERR_COMMENTMATCH,0,0);
  258. if (incldepth > 0) {
  259.                 fclose(inputFile);
  260.                  inputFile = inclfile[--incldepth];
  261.                  lineno = inclline[incldepth];
  262. infile = inclfname[incldepth];
  263. errlineno = lineno;
  264. errfile = infile;
  265. ifs = ifshold[incldepth];
  266. commentlevel = 0;
  267. popif();
  268.                  return getline(0);
  269. }
  270.         }
  271.         if( rv )
  272.                 return 1;
  273. lptr = inputline;
  274. ptr = ibuf;
  275. while((temp = parsechar(&ptr)) != 0)
  276. *lptr++ = temp;
  277. *lptr = 0;
  278. stripcomment(inputline);
  279. striptrigraph(inputline);
  280.         lptr = inputline;
  281. while (iswhitespacechar(*lptr))
  282. lptr++;
  283.         if(lptr[0] == '#') {
  284.           listflag = preprocess();
  285. prepping = TRUE;
  286. }
  287. } while (ifskip || prepping);
  288. defcheck(inputline);
  289. lineToCpp();
  290.     return 0;
  291. }
  293. /*
  294.  *      getch - basic get character routine.
  295.  */
  296. int     getch(void)
  297. {       while( (lastch = *lptr++) == '') {
  298.                 if( lstackptr > 0 ) {
  299.                         lptr = linstack[--lstackptr];
  300.                         lastch = chstack[lstackptr];
  301.                         return lastch;
  302.                         }
  303. if (cantnewline) {
  304. lptr--;
  305. return lastch = ' ';
  306. }
  307.                 if(getline(incldepth == 0))
  308.                         return lastch = -1;
  309.                 }
  310.         return lastch;
  311. }
  312.  
  313. /*
  314.  *      getid - get an identifier.
  315.  *
  316.  *      identifiers are any isidch conglomerate
  317.  *      that doesn't start with a numeric character.
  318.  *      this set INCLUDES keywords.
  319.  */
  320. void     getid()
  321. {       register int    i;
  322.         i = 0;
  323. if (prm_cmangle)
  324. lastid[i++] = '_'; /* Mangling */
  325. if (lastch == 'L') {
  326. lastid[i++] = 'L';
  327. getch();
  328. if (lastch == '"') {
  329. getch();
  330. i=0;
  331. while (lastch != '"' && lastch) {
  332. *(((short*)(laststr))+i++) = lastch;
  333. getch();
  334. }
  335. if ((lastch & 0x7f) != '"')
  336.                                  generror(ERR_NEEDCHAR,'"',0);
  337.                          else
  338.                                  getch();
  339. *(((short*)(laststr))+i) = 0;
  340. lastst = lsconst;
  341. return;
  342. }
  343. }
  345. while(issymchar(lastch)) {
  346. if (i < 100)
  347. i+=installphichar(lastch,lastid,i);
  348. getch();
  349.         }
  350. if ((lastid[i-1] & 0xf0) == 0x90)
  351. lastid[i-1] = 0x90;
  352.         lastid[i] = '';
  353.         lastst = id;
  354. }
  355.  
  356. /*
  357.  *      getsch - get a character in a quoted string.
  358.  *
  359.  *      this routine handles all of the escape mechanisms
  360.  *      for characters in strings and character constants.
  361.  */
  362. int     getsch(void)        /* return an in-quote character */
  363. {       register int    i, j;
  364.         if(lastch == 'n')
  365.                 return -1;
  366.         if(lastch != '\') {
  367.                 i = lastch;
  368.                 getch();
  369.                 return i;
  370.                 }
  371.         getch();        /* get an escaped character */
  372.         if(isdigit(lastch)) {
  373.                 for(i = 0,j=0;j < 3;++j) {
  374.                         if(lastch <= '7' && lastch >= '0')
  375.                                 i = (i << 3) + lastch - '0';
  376.                         else
  377.                                 break;
  378.                         getch();
  379.                         }
  380.                 return i;
  381.                 }
  382.         i = lastch;
  383.         getch();
  384.         switch(i) {
  385.                 case 'n':
  386.                         getch();
  387.                         return getsch();
  388. case 'a':
  389. return 'a';
  390.                 case 'b':
  391.                         return 'b';
  392.                 case 'f':
  393.                         return 'f';
  394.                 case 'n':
  395.                         return 'n';
  396.                 case 'r':
  397.                         return 'r';
  398. case 't':
  399. return 't';
  400. case ''':
  401. return ''';
  402. case '"':
  403. return '"';
  404. case '\':
  405. return '\';
  406. case 'x':
  407. {
  408. int n=0,count=0;
  409.   while (isxdigit(lastch)) {
  410. count++;
  411.   lastch-=0x30;
  412. if (lastch > 10) lastch -=7;
  413. if (lastch > 10) lastch -=32;
  414. n*=16;
  415. n+=lastch;
  416. getch();
  417. }
  418. if (count > 2)
  419. generror(ERR_CONSTTOOLARGE,0,0);
  420. return n;
  421. }
  422.                 default:
  423. if (isdigit(i) && i < '9') {
  424. int n = 0;
  425. while (isdigit(i) && i < '9') {
  426. n = n * 8 + (lastch - '0');
  427. getch();
  428. }
  429. return n;
  430. }
  431.                         return i;
  432.                 }
  433. }
  435. int     radix36(char c)
  436. {       if(isdigit(c))
  437.                 return c - '0';
  438.         if(c >= 'a' && c <= 'z')
  439.                 return c - 'a' + 10;
  440.         if(c >= 'A' && c <= 'Z')
  441.                 return c - 'A' + 10;
  442.         return -1;
  443. }
  444.  
  445. /*
  446.  *      getbase - get an integer in any base.
  447.  */
  448. void getbase(int b,char **ptr)
  449. {       register long    i, j;
  450. int errd = 0;
  451.         i = 0;
  452.         while(isalnum(**ptr)) {
  453.                 if((j = radix36(*(*ptr)++)) < b) {
  454. if (i > (ULONG_MAX-j)/b)
  455. if (!errd) {
  456. generror(ERR_CONSTTOOLARGE,0,0);
  457. errd++;
  458. }
  459.                         i = i * b + j;
  460.                         }
  461.                 else break;
  462.                 }
  463.         ival = i;
  464.         lastst = iconst;
  465. }
  466.  
  467. /*
  468.  *      getfrac - get fraction part of a floating number.
  469.  */
  470. void getfrac(char **ptr)
  471. {       double  frmul;
  472.         frmul = 0.1;
  473.         while(isdigit(**ptr)) {
  474.                 rval += frmul * (*(*ptr)++ - '0');
  475.                 frmul *= 0.1;
  476.                 }
  477. }
  478.  
  479. /*
  480.  *      getexp - get exponent part of floating number.
  481.  *
  482.  *      this algorithm is primative but usefull.  Floating
  483.  *      exponents are limited to +/-255 but most hardware
  484.  *      won't support more anyway.
  485.  */
  486. void getexp(char **ptr)
  487. {       double  expo, exmul;
  488.         expo = 1.0;
  489.         if(lastst != rconst)
  490.                 rval = ival;
  491.         if(**ptr == '-') {
  492.                 exmul = 0.1;
  493.                 (*ptr)++;
  494.                 }
  495.         else {
  496.                 exmul = 10.0;
  497. if (**ptr == '+')
  498. (*ptr)++;
  499. }
  500.         getbase(10,ptr);
  501.         if(ival > 255)
  502.                 generror(ERR_FPCON,0,0);
  503.         else
  504.                 while(ival--)
  505.                         expo *= exmul;
  506.         rval *= expo;
  507. lastst = rconst;
  508. }
  509.  
  510. /*
  511.  *      getnum - get a number from input.
  512.  *
  513.  *      getnum handles all of the numeric input. it accepts
  514.  *      decimal, octal, hexidecimal, and floating point numbers.
  515.  */
  516. void getnum(void)
  517. {
  518. int isfloat=FALSE;
  519. char buf[50],*ptr = buf;
  520. while (isxdigit(lastch) || lastch == 'x' || lastch == 'X') {
  521. *ptr++ = lastch;
  522. getch();
  523. }
  524. if (lastch == '.') {
  525. isfloat = TRUE;
  526. *ptr++=lastch;
  527. getch();
  528. while (isdigit(lastch)) {
  529. *ptr++ = lastch;
  530. getch();
  531. }
  532. }
  533. if (lastch == 'e' || lastch == 'E') {
  534. isfloat = TRUE;
  535. *ptr++ = lastch;
  536. getch();
  537. if (lastch == '+' || lastch == '-') {
  538. *ptr++=lastch;
  539. getch();
  540. }
  541. while (isdigit(lastch)) {
  542. *ptr++ = lastch;
  543. getch();
  544. }
  545. }
  546. if (lastch == 'F') {
  547. isfloat = TRUE;
  548. }
  549. *ptr = 0;
  550. ptr = buf;
  551. if (!isfloat) {
  552. if (*ptr == '0') {
  553. ptr++;
  554.       if(*ptr == 'x' || *ptr == 'X') {
  555.        ptr++;
  556.        getbase(16,&ptr);
  557.      }
  558.      else getbase(8,&ptr);
  559.     }
  560. else
  561. getbase(10,&ptr);
  562. if (lastch == 'U') {
  563. lastst = iuconst;
  564. getch();
  565. if (lastch == 'L') {
  566. lastst = luconst;
  567. getch();
  568. }
  569. }
  570. else if (lastch == 'L') {
  571. lastst = iconst;
  572. getch();
  573. if (lastch == 'U') {
  574. lastst = luconst;
  575. getch();
  576. }
  577. }
  578. }
  579.   else    {
  580.                 getbase(10,&ptr);
  581.                 if(*ptr == '.') {
  582. ptr++;
  583.                         rval = ival;    /* float the integer part */
  584.                         getfrac(&ptr);      /* add the fractional part */
  585.                         lastst = rconst;
  586.                      }
  587.                  if(*ptr == 'e' || *ptr == 'E') {
  588.                         ptr++;
  589.                         getexp(&ptr);       /* get the exponent */
  590.                         }
  591. if (lastch == 'F') {
  592. if (lastst != rconst) {
  593. rval = ival;
  594. }
  595. lastst = fconst;
  596. getch();
  597. }
  598. else if (lastch == 'L') {
  599. if (lastst != rconst) {
  600. rval = ival;
  601. }
  602. lastst = lrconst;
  603. getch();
  604. }
  605. }
  606. }
  607.  
  608. int getsym2(void) 
  609. /*
  610.  * translate character sequences to appropriate token names
  611.  */
  612. {       register int    i, j;
  613. int size;
  614. swlp:
  615.  switch(lastch) {
  616.                 case '+':
  617.                         getch();
  618.                         if(lastch == '+') {
  619.                                 getch();
  620.                                 lastst = autoinc;
  621.                                 }
  622.                         else if(lastch == '=') {
  623.                                 getch();
  624.                                 lastst = asplus;
  625.                                 }
  626.                         else lastst = plus;
  627.                         break;
  628.                 case '-':
  629.                         getch();
  630.                         if(lastch == '-') {
  631.                                 getch();
  632.                                 lastst = autodec;
  633.                                 }
  634.                         else if(lastch == '=') {
  635.                                 getch();
  636.                                 lastst = asminus;
  637.                                 }
  638.                         else if(lastch == '>') {
  639.                                 getch();
  640. #ifdef CPLUSPLUS
  641. if (prm_cplusplus && lastch == '*') {
  642. getch();
  643. lastst = pointstar;
  644. }
  645. else
  646. #endif
  647.                                  lastst = pointsto;
  648.                                 }
  649.                         else lastst = minus;
  650.                         break;
  651.                 case '*':
  652.                         getch();
  653.                         if(lastch == '=') {
  654.                                 getch();
  655.                                 lastst = astimes;
  656.                                 }
  657.                         else lastst = star;
  658.                         break;
  659.                 case '/':
  660.                         getch();
  661.                         if(lastch == '=') {
  662.                                 getch();
  663.                                 lastst = asdivide;
  664.                                 }
  665.                         else lastst = divide;
  666.                         break;
  667.                 case '^':
  668.                         getch();
  669.                         if(lastch == '=') {
  670.                                 getch();
  671.                                 lastst = asxor;
  672.                                 }
  673.                         else lastst = uparrow;
  674.                         break;
  675.                 case ';':
  676.                         getch();
  677.                         lastst = semicolon;
  678.                         break;
  679.                 case ':':
  680.                         getch();
  681. #ifdef CPLUSPLUS
  682. if (prm_cplusplus && lastch == ':') {
  683. lastst = classsel;
  684. getch();
  685. }
  686. else
  687. #endif
  688.                          lastst = colon;
  689.                         break;
  690.                 case '=':
  691.                         getch();
  692.                         if(lastch == '=') {
  693.                                 getch();
  694.                                 lastst = eq;
  695.                                 }
  696.                         else lastst = assign;
  697.                         break;
  698.                 case '>':
  699.                         getch();
  700.                         if(lastch == '=') {
  701.                                 getch();
  702.                                 lastst = geq;
  703.                                 }
  704.                         else if(lastch == '>') {
  705.                                 getch();
  706.                                 if(lastch == '=') {
  707.                                         getch();
  708.                                         lastst = asrshift;
  709.                                         }
  710.                                 else lastst = rshift;
  711.                                 }
  712.                         else lastst = gt;
  713.                         break;
  714.                 case '<':
  715.                         getch();
  716. if (incconst) {
  717.                          for(i = 0;i < MAX_STRLEN;++i) {
  718.                                 if(lastch == '>')
  719.                                         break;
  720.                                 if((j = getsch()) == -1)
  721.                                         break;
  722.                                 else
  723.                                         laststr[i] = j;
  724.                               }
  725.                          laststr[i] = 0;
  726.                          lastst = sconst;
  727.                          if(lastch != '>')
  728.                                  generror(ERR_NEEDCHAR,'>',0);
  729.                          else
  730.                                  getch();
  731. } else
  732.                          if(lastch == '=') {
  733.                                 getch();
  734.                                 lastst = leq;
  735.                                 }
  736.                          else if(lastch == '<') {
  737.                                 getch();
  738.                                 if(lastch == '=') {
  739.                                         getch();
  740.                                         lastst = aslshift;
  741.                                         }
  742.                                 else lastst = lshift;
  743.                                 }
  744.                          else lastst = lt;
  745.                         break;
  746.                 case ''':
  747.                         getch();
  748.                         ival = getsch();        /* get a string char */
  749.                         if(lastch != ''')
  750.                                 generror(ERR_NEEDCHAR,''',0);
  751.                         else
  752.                                 getch();
  753.                         lastst = cconst;
  754.                         break;
  755. case 0x2d4:
  756. getch();
  757. i=0;
  758. while (lastch != '"' && lastch)
  759. i=installphichar(lastch,laststr,i);
  760. if ((lastch & 0x7f) != '"')
  761.                                  generror(ERR_NEEDCHAR,'"',0);
  762.                          else
  763.                                  getch();
  764. size = strlen(laststr);
  765. lastst = sconst;
  766. break;
  767.                 case '"':
  768.   size = 0;
  769. while (lastch == '"') {
  770.                          getch();
  771.                          for(i = size;i < MAX_STRLEN;++i) {
  772.                                 if(lastch == '"')
  773.                                         break;
  774.                                 if((j = getsch()) == -1)
  775.                                         break;
  776.                                 else
  777.                                         laststr[i] = j;
  778.                                 }
  779.                         laststr[i] = 0;
  780. size = i;
  781.                          lastst = sconst;
  782.                          if(lastch != '"')
  783.                                  generror(ERR_NEEDCHAR,'"',0);
  784.                          else
  785.                                  getch();
  786. }
  787.                         break;
  788.                 case '!':
  789.                         getch();
  790.                         if(lastch == '=') {
  791.                                 getch();
  792.                                 lastst = neq;
  793.                                 }
  794.                         else lastst = not;
  795.                         break;
  796.                 case '%':
  797.                         getch();
  798.                         if(lastch == '=') {
  799.                                 getch();
  800.                                 lastst = asmodop;
  801.                                 }
  802.                         else lastst = modop;
  803.                         break;
  804.                 case '~':
  805.                         getch();
  806.                         lastst = compl;
  807.                         break;
  808.                 case '.':
  809. if (isdigit(*lptr))
  810. getnum();
  811. else {
  812.                         getch();
  813. #ifdef CPLUSPLUS
  814. if (prm_cplusplus && lastch == '*') {
  815. getch();
  816. lastst = dotstar;
  817. }
  818. else 
  819. #endif
  820.   if (lastch == '.') {
  821.    getch();
  822. if (lastch == '.') {
  823. getch();
  824. lastst = ellipse;
  825. break;
  826. }
  827. else {
  828.                              generror(ERR_ILLCHAR,lastch,0);
  829. }
  830. }
  831.                          lastst = dot;
  832. }
  833.                         break;
  834.                 case ',':
  835.                         getch();
  836.                         lastst = comma;
  837.                         break;
  838.                 case '&':
  839.                         getch();
  840.                         if( lastch == '&') {
  841.                                 lastst = land;
  842.                                 getch();
  843.                                 }
  844.                         else if( lastch == '=') {
  845.                                 lastst = asand;
  846.                                 getch();
  847.                                 }
  848.                         else
  849.                                 lastst = and;
  850.                         break;
  851.                 case '|':
  852.                         getch();
  853.                         if(lastch == '|') {
  854.                                 lastst = lor;
  855.                                 getch();
  856.                                 }
  857.                         else if( lastch == '=') {
  858.                                 lastst = asor;
  859.                                 getch();
  860.                                 }
  861.                         else
  862.                                 lastst = or;
  863.                         break;
  864.                 case '(':
  865.                         getch();
  866.                         lastst = openpa;
  867.                         break;
  868.                 case ')':
  869.                         getch();
  870.                         lastst = closepa;
  871.                         break;
  872.                 case '[':
  873.                         getch();
  874.                         lastst = openbr;
  875.                         break;
  876.                 case ']':
  877.                         getch();
  878.                         lastst = closebr;
  879.                         break;
  880.                 case '{':
  881.                         getch();
  882.                         lastst = begin;
  883.                         break;
  884.                 case '}':
  885.                         getch();
  886.                         lastst = end;
  887.                         break;
  888.                 case '?':
  889.                         getch();
  890.                         lastst = hook;
  891.                         break;
  892.                 default:
  893. if (iscommentchar(lastch)) {
  894. do {
  895. getch();
  896. } while (!iscommentchar(lastch) && lastch != 'n');
  897. }
  898. else
  899.                          generror(ERR_ILLCHAR,lastch,0);
  900.                         getch();
  901. return 1;
  902.                 }
  903. return 0;
  904. }
  905. /*
  906.  *      getsym - get next symbol from input stream.
  907.  *
  908.  *      getsym is the basic lexical analyzer.  It builds
  909.  *      basic tokens out of the characters on the input
  910.  *      stream and sets the following global variables:
  911.  *
  912.  *      lastch:         A look behind buffer.
  913.  *      lastst:         type of last symbol read.
  914.  *      laststr:        last string constant read.
  915.  *      lastid:         last identifier read.
  916.  *      ival:           last integer constant read.
  917.  *      rval:           last real constant read.
  918.  *
  919.  *      getsym should be called for all your input needs...
  920.  */
  921. void     getsym(void)
  922. {
  924. if (backupchar != -1) {
  925. lastst = backupchar;
  926. backupchar = -1;
  927. return;
  928. }
  929. if (cantnewline && !*lptr) {
  930. lastst = eol;
  931. return;
  932. }
  933.         while(iswhitespacechar(lastch)) {
  934.           getch();
  935. if (cantnewline && !*lptr) {
  936. lastst = eol;
  937. return;
  938. }
  939. }
  940.         if( lastch == -1)
  941.                 lastst = eof;
  942.         else if(isdigit(lastch))
  943.                 getnum();
  944.         else if(isstartchar(lastch)) {
  945.                 getid();
  946.                 searchkw();
  947. }
  948.         else getsym2();
  949. }
  950. /*
  951.  * when we need specific punctuation, call one of these routines
  952.  */
  953. int needpunc(enum e_sym p, int *skimlist)
  954. {       if( lastst == p) {
  955.                 getsym();
  956. return(TRUE);
  957. }
  958.         else
  959.                 expecttoken(p,skimlist);
  960. return(FALSE);
  961. }
  962. int needpuncexp(enum e_sym p, int *skimlist)
  963. {       if( lastst == p) {
  964.                 getsym();
  965. return(TRUE);
  966. }
  967.         else
  968.                 expecttokenexp(p,skimlist);
  969. return(FALSE);
  970. }
  971. /*
  972.  * having to back up a character is rare, but sometimes...
  973.  */
  974. void backup(int st)
  975. {
  976.   backupchar = lastst;
  977.   lastst = st;
  978. }