home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d1xx / d170 / dis6502.lha / Dis6502 / lex.c < prev    next >
C/C++ Source or Header  |  1988-11-22  |  9KB  |  485 lines
  1. # include "stdio.h"
  2. # define U(x) x
  3. # define NLSTATE yyprevious=YYNEWLINE
  4. # define BEGIN yybgin = yysvec + 1 +
  5. # define INITIAL 0
  6. # define YYLERR yysvec
  7. # define YYSTATE (yyestate-yysvec-1)
  8. # define YYOPTIM 1
  9. # define YYLMAX BUFSIZ
  10. # define output(c) putc(c,yyout)
  11. # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  12. # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  13. # define yymore() (yymorfg=1)
  14. # define ECHO fprintf(yyout, "%s",yytext)
  15. # define REJECT { nstr = yyreject(); goto yyfussy;}
  16. int yyleng; extern char yytext[];
  17. int yymorfg;
  18. extern char *yysptr, yysbuf[];
  19. int yytchar;
  20. FILE *yyin = {stdin}, *yyout = {stdout};
  21. extern int yylineno;
  22. struct yysvf { 
  23.     struct yywork *yystoff;
  24.     struct yysvf *yyother;
  25.     int *yystops;};
  26. struct yysvf *yyestate;
  27. extern struct yysvf yysvec[], *yybgin;
  28. #undef ECHO
  29. #include "dis.h"
  30. #ifndef AMIGA
  31. int lineno = 0;
  32. #endif
  33. char *strcpy();
  34. # define YYNEWLINE 10
  35. yylex(){
  36. int nstr; extern int yyprevious;
  37. while((nstr = yylook()) >= 0)
  38. yyfussy: switch(nstr){
  39. case 0:
  40. if(yywrap()) return(0); break;
  41. case 1:
  42. { ; }
  43. break;
  44. case 2:
  45. {    lineno++;
  46.                 return '\n';
  47. }
  48. break;
  49. case 3:
  50. { 
  51.                 return EQ;
  52. }
  53. break;
  54. case 4:
  55. { 
  56.                 return LI;
  57. }
  58. break;
  59. case 5:
  60. { 
  61.                 return EQ;
  62. }
  63. break;
  64. case 6:
  65. { 
  66.                 return LI;
  67. }
  68. break;
  69. case 7:
  70. {
  71.                 return TSTART;
  72. }
  73. break;
  74. case 8:
  75. {
  76.                 return TSTOP;
  77. }
  78. break;
  79. case 9:
  80. {
  81.                 (void)sscanf(yytext, "%d", &token.ival); 
  82.                 return NUMBER;
  83. }
  84. break;
  85. case 10:
  86. {
  87.                 (void)sscanf(yytext+1, "%x", &token.ival);
  88.                 return NUMBER;
  89. }
  90. break;
  91. case 11:
  92. {
  93.                 token.sval = emalloc((unsigned) strlen(yytext)+1);
  94.                 (void)strcpy((char *)token.sval, (char *)yytext);
  95.                 return NAME;
  96. }
  97. break;
  98. case 12:
  99. {
  100.                 return COMMENT;
  101. }
  102. break;
  103. case 13:
  104.         { return yytext[0]; }
  105. break;
  106. case -1:
  107. break;
  108. default:
  109. fprintf(yyout,"bad switch yylook %d",nstr);
  110. } return(0); }
  111. /* end of yylex */
  112.  
  113. char *
  114. emalloc(n)
  115. unsigned n;
  116. {
  117.     char *ptr, *malloc();
  118.  
  119.     if ((ptr = malloc(n)) == (char *) 0) {
  120.         (void) fprintf(stderr,"out of core");
  121.         exit(1);
  122.     }
  123.     return ptr;
  124. }
  125. int yyvstop[] = {
  126. 0,
  127.  
  128. 13,
  129. 0,
  130.  
  131. 1,
  132. 13,
  133. 0,
  134.  
  135. 2,
  136. 0,
  137.  
  138. 13,
  139. 0,
  140.  
  141. 12,
  142. 13,
  143. 0,
  144.  
  145. 13,
  146. 0,
  147.  
  148. 9,
  149. 13,
  150. 0,
  151.  
  152. 11,
  153. 13,
  154. 0,
  155.  
  156. 10,
  157. 0,
  158.  
  159. 12,
  160. 0,
  161.  
  162. 9,
  163. 0,
  164.  
  165. 11,
  166. 0,
  167.  
  168. 3,
  169. 0,
  170.  
  171. 4,
  172. 0,
  173.  
  174. 5,
  175. 0,
  176.  
  177. 6,
  178. 0,
  179.  
  180. 8,
  181. 0,
  182.  
  183. 7,
  184. 0,
  185. 0};
  186. # define YYTYPE char
  187. struct yywork { YYTYPE verify, advance; } yycrank[] = {
  188. 0,0,    0,0,    1,3,    0,0,    
  189. 0,0,    0,0,    0,0,    0,0,    
  190. 0,0,    0,0,    1,4,    1,5,    
  191. 0,0,    0,0,    0,0,    0,0,    
  192. 0,0,    0,0,    0,0,    0,0,    
  193. 7,12,    0,0,    0,0,    0,0,    
  194. 0,0,    0,0,    0,0,    0,0,    
  195. 7,12,    7,0,    12,0,    0,0,    
  196. 0,0,    0,0,    0,0,    0,0,    
  197. 0,0,    1,6,    2,6,    0,0,    
  198. 0,0,    0,0,    0,0,    1,7,    
  199. 2,7,    0,0,    0,0,    1,8,    
  200. 2,8,    1,9,    0,0,    0,0,    
  201. 0,0,    0,0,    0,0,    0,0,    
  202. 6,11,    6,11,    6,11,    6,11,    
  203. 6,11,    6,11,    6,11,    6,11,    
  204. 6,11,    6,11,    1,10,    7,12,    
  205. 0,0,    0,0,    0,0,    0,0,    
  206. 1,10,    6,11,    6,11,    6,11,    
  207. 6,11,    6,11,    6,11,    8,13,    
  208. 0,0,    0,0,    0,0,    0,0,    
  209. 7,12,    0,0,    8,14,    0,0,    
  210. 0,0,    0,0,    7,12,    0,0,    
  211. 0,0,    14,22,    0,0,    0,0,    
  212. 1,3,    0,0,    0,0,    0,0,    
  213. 0,0,    13,21,    0,0,    0,0,    
  214. 0,0,    6,11,    6,11,    6,11,    
  215. 6,11,    6,11,    6,11,    8,15,    
  216. 0,0,    0,0,    7,12,    0,0,    
  217. 0,0,    0,0,    8,16,    0,0,    
  218. 0,0,    0,0,    26,28,    0,0,    
  219. 0,0,    8,17,    8,18,    9,19,    
  220. 9,19,    9,19,    9,19,    9,19,    
  221. 9,19,    9,19,    9,19,    9,19,    
  222. 9,19,    10,20,    10,20,    10,20,    
  223. 10,20,    10,20,    10,20,    10,20,    
  224. 10,20,    10,20,    10,20,    15,23,    
  225. 16,24,    17,25,    18,26,    25,27,    
  226. 27,29,    28,30,    10,20,    10,20,    
  227. 10,20,    10,20,    10,20,    10,20,    
  228. 10,20,    10,20,    10,20,    10,20,    
  229. 10,20,    10,20,    10,20,    10,20,    
  230. 10,20,    10,20,    10,20,    10,20,    
  231. 10,20,    10,20,    10,20,    10,20,    
  232. 10,20,    10,20,    10,20,    10,20,    
  233. 30,31,    0,0,    0,0,    0,0,    
  234. 10,20,    0,0,    10,20,    10,20,    
  235. 10,20,    10,20,    10,20,    10,20,    
  236. 10,20,    10,20,    10,20,    10,20,    
  237. 10,20,    10,20,    10,20,    10,20,    
  238. 10,20,    10,20,    10,20,    10,20,    
  239. 10,20,    10,20,    10,20,    10,20,    
  240. 10,20,    10,20,    10,20,    10,20,    
  241. 0,0};
  242. struct yysvf yysvec[] = {
  243. 0,    0,    0,
  244. yycrank+-1,    0,        0,    
  245. yycrank+-2,    yysvec+1,    0,    
  246. yycrank+0,    0,        yyvstop+1,
  247. yycrank+0,    0,        yyvstop+3,
  248. yycrank+0,    0,        yyvstop+6,
  249. yycrank+8,    0,        yyvstop+8,
  250. yycrank+-19,    0,        yyvstop+10,
  251. yycrank+10,    0,        yyvstop+13,
  252. yycrank+79,    0,        yyvstop+15,
  253. yycrank+89,    0,        yyvstop+18,
  254. yycrank+0,    yysvec+6,    yyvstop+21,
  255. yycrank+-20,    yysvec+7,    yyvstop+23,
  256. yycrank+20,    0,        0,    
  257. yycrank+20,    0,        0,    
  258. yycrank+34,    0,        0,    
  259. yycrank+43,    0,        0,    
  260. yycrank+33,    0,        0,    
  261. yycrank+36,    0,        0,    
  262. yycrank+0,    yysvec+9,    yyvstop+25,
  263. yycrank+0,    yysvec+10,    yyvstop+27,
  264. yycrank+0,    0,        yyvstop+29,
  265. yycrank+0,    0,        yyvstop+31,
  266. yycrank+0,    0,        yyvstop+33,
  267. yycrank+0,    0,        yyvstop+35,
  268. yycrank+40,    0,        0,    
  269. yycrank+25,    0,        0,    
  270. yycrank+40,    0,        0,    
  271. yycrank+54,    0,        0,    
  272. yycrank+0,    0,        yyvstop+37,
  273. yycrank+79,    0,        0,    
  274. yycrank+0,    0,        yyvstop+39,
  275. 0,    0,    0};
  276. struct yywork *yytop = yycrank+211;
  277. struct yysvf *yybgin = yysvec+1;
  278. char yymatch[] = {
  279. 00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  280. 01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
  281. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  282. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  283. 011 ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  284. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  285. '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
  286. '0' ,'0' ,01  ,01  ,01  ,01  ,01  ,01  ,
  287. 01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'G' ,
  288. 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
  289. 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
  290. 'G' ,'G' ,'G' ,01  ,01  ,01  ,01  ,'_' ,
  291. 01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'G' ,
  292. 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
  293. 'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,'G' ,
  294. 'G' ,'G' ,'G' ,01  ,01  ,01  ,01  ,01  ,
  295. 0};
  296. char yyextra[] = {
  297. 0,0,0,0,0,0,0,0,
  298. 0,0,0,0,0,0,0,0,
  299. 0};
  300. #ifndef lint
  301. static    char ncform_sccsid[] = "@(#)ncform 1.2 86/10/08 SMI"; /* from S5R2 1.2 */
  302. #endif
  303.  
  304. int yylineno =1;
  305. # define YYU(x) x
  306. # define NLSTATE yyprevious=YYNEWLINE
  307. char yytext[YYLMAX];
  308. struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  309. char yysbuf[YYLMAX];
  310. char *yysptr = yysbuf;
  311. int *yyfnd;
  312. extern struct yysvf *yyestate;
  313. int yyprevious = YYNEWLINE;
  314. yylook(){
  315.     register struct yysvf *yystate, **lsp;
  316.     register struct yywork *yyt;
  317.     struct yysvf *yyz;
  318.     int yych, yyfirst;
  319.     struct yywork *yyr;
  320. # ifdef LEXDEBUG
  321.     int debug;
  322. # endif
  323.     char *yylastch;
  324.     /* start off machines */
  325. # ifdef LEXDEBUG
  326.     debug = 0;
  327. # endif
  328.     yyfirst=1;
  329.     if (!yymorfg)
  330.         yylastch = yytext;
  331.     else {
  332.         yymorfg=0;
  333.         yylastch = yytext+yyleng;
  334.         }
  335.     for(;;){
  336.         lsp = yylstate;
  337.         yyestate = yystate = yybgin;
  338.         if (yyprevious==YYNEWLINE) yystate++;
  339.         for (;;){
  340. # ifdef LEXDEBUG
  341.             if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  342. # endif
  343.             yyt = yystate->yystoff;
  344.             if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
  345.                 yyz = yystate->yyother;
  346.                 if(yyz == 0)break;
  347.                 if(yyz->yystoff == yycrank)break;
  348.                 }
  349.             *yylastch++ = yych = input();
  350.             yyfirst=0;
  351.         tryagain:
  352. # ifdef LEXDEBUG
  353.             if(debug){
  354.                 fprintf(yyout,"char ");
  355.                 allprint(yych);
  356.                 putchar('\n');
  357.                 }
  358. # endif
  359.             yyr = yyt;
  360.             if ( (int)yyt > (int)yycrank){
  361.                 yyt = yyr + yych;
  362.                 if (yyt <= yytop && yyt->verify+yysvec == yystate){
  363.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  364.                         {unput(*--yylastch);break;}
  365.                     *lsp++ = yystate = yyt->advance+yysvec;
  366.                     goto contin;
  367.                     }
  368.                 }
  369. # ifdef YYOPTIM
  370.             else if((int)yyt < (int)yycrank) {        /* r < yycrank */
  371.                 yyt = yyr = yycrank+(yycrank-yyt);
  372. # ifdef LEXDEBUG
  373.                 if(debug)fprintf(yyout,"compressed state\n");
  374. # endif
  375.                 yyt = yyt + yych;
  376.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  377.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  378.                         {unput(*--yylastch);break;}
  379.                     *lsp++ = yystate = yyt->advance+yysvec;
  380.                     goto contin;
  381.                     }
  382.                 yyt = yyr + YYU(yymatch[yych]);
  383. # ifdef LEXDEBUG
  384.                 if(debug){
  385.                     fprintf(yyout,"try fall back character ");
  386.                     allprint(YYU(yymatch[yych]));
  387.                     putchar('\n');
  388.                     }
  389. # endif
  390.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  391.                     if(yyt->advance+yysvec == YYLERR)    /* error transition */
  392.                         {unput(*--yylastch);break;}
  393.                     *lsp++ = yystate = yyt->advance+yysvec;
  394.                     goto contin;
  395.                     }
  396.                 }
  397.             if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  398. # ifdef LEXDEBUG
  399.                 if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  400. # endif
  401.                 goto tryagain;
  402.                 }
  403. # endif
  404.             else
  405.                 {unput(*--yylastch);break;}
  406.         contin:
  407. # ifdef LEXDEBUG
  408.             if(debug){
  409.                 fprintf(yyout,"state %d char ",yystate-yysvec-1);
  410.                 allprint(yych);
  411.                 putchar('\n');
  412.                 }
  413. # endif
  414.             ;
  415.             }
  416. # ifdef LEXDEBUG
  417.         if(debug){
  418.             fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  419.             allprint(yych);
  420.             putchar('\n');
  421.             }
  422. # endif
  423.         while (lsp-- > yylstate){
  424.             *yylastch-- = 0;
  425.             if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  426.                 yyolsp = lsp;
  427.                 if(yyextra[*yyfnd]){        /* must backup */
  428.                     while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  429.                         lsp--;
  430.                         unput(*yylastch--);
  431.                         }
  432.                     }
  433.                 yyprevious = YYU(*yylastch);
  434.                 yylsp = lsp;
  435.                 yyleng = yylastch-yytext+1;
  436.                 yytext[yyleng] = 0;
  437. # ifdef LEXDEBUG
  438.                 if(debug){
  439.                     fprintf(yyout,"\nmatch ");
  440.                     sprint(yytext);
  441.                     fprintf(yyout," action %d\n",*yyfnd);
  442.                     }
  443. # endif
  444.                 return(*yyfnd++);
  445.                 }
  446.             unput(*yylastch);
  447.             }
  448.         if (yytext[0] == 0  /* && feof(yyin) */)
  449.             {
  450.             yysptr=yysbuf;
  451.             return(0);
  452.             }
  453.         yyprevious = yytext[0] = input();
  454.         if (yyprevious>0)
  455.             output(yyprevious);
  456.         yylastch=yytext;
  457. # ifdef LEXDEBUG
  458.         if(debug)putchar('\n');
  459. # endif
  460.         }
  461.     }
  462. yyback(p, m)
  463.     int *p;
  464. {
  465. if (p==0) return(0);
  466. while (*p)
  467.     {
  468.     if (*p++ == m)
  469.         return(1);
  470.     }
  471. return(0);
  472. }
  473.     /* the following are only used in the lex library */
  474. yyinput(){
  475.     return(input());
  476.     }
  477. yyoutput(c)
  478.   int c; {
  479.     output(c);
  480.     }
  481. yyunput(c)
  482.    int c; {
  483.     unput(c);
  484.     }
  485.