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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 汇编语言 > 查看源码
scan.c
资源名称：C语言编译器.rar　[点击查看]
上传用户：wqdrylgs
上传日期：2007-02-09
资源大小：65k
文件大小：13k
源码类别：

汇编语言

开发平台：

WINDOWS

scan.c：源码内容
  1. /****************************************************************************
  2. *                     U N R E G I S T E R E D   C O P Y
  3. * 
  4. * You are on day 85 of your 30 day trial period.
  5. * 
  6. * This file was produced by an UNREGISTERED COPY of Parser Generator. It is
  7. * for evaluation purposes only. If you continue to use Parser Generator 30
  8. * days after installation then you are required to purchase a license. For
  9. * more information see the online help or go to the Bumble-Bee Software
  10. * homepage at:
  11. * 
  12. * http://www.bumblebeesoftware.com
  13. * 
  14. * This notice must remain present in the file. It cannot be removed.
  15. ****************************************************************************/
  17. /****************************************************************************
  18. * scan.c
  19. * C source file generated from scan.l.
  20. * 
  21. * Date: 06/24/03
  22. * Time: 17:07:53
  23. * 
  24. * ALex Version: 2.05
  25. ****************************************************************************/
  27. #include <yylex.h>
  29. /* namespaces */
  30. #if defined(__cplusplus) && defined(YYSTDCPPLIB)
  31. using namespace std;
  32. #endif
  33. #if defined(__cplusplus) && defined(YYNAMESPACE)
  34. using namespace yl;
  35. #endif
  37. #define YYFASTLEXER
  39. #line 6 ".\scan.l"
  41. #include "globals.h"
  42. #include "util.h"
  43. #include "scan.h"
  44. #include "parse.h"
  46. char tokenString[MAXTOKENLEN+1];
  48. #line 49 "scan.c"
  49. /* repeated because of possible precompiled header */
  50. #include <yylex.h>
  52. /* namespaces */
  53. #if defined(__cplusplus) && defined(YYSTDCPPLIB)
  54. using namespace std;
  55. #endif
  56. #if defined(__cplusplus) && defined(YYNAMESPACE)
  57. using namespace yl;
  58. #endif
  60. #define YYFASTLEXER
  62. #include ".scan.h"
  64. #ifndef YYTEXT_SIZE
  65. #define YYTEXT_SIZE 100
  66. #endif
  67. #ifndef YYUNPUT_SIZE
  68. #define YYUNPUT_SIZE YYTEXT_SIZE
  69. #endif
  70. #ifndef YYTEXT_MAX
  71. #define YYTEXT_MAX 0
  72. #endif
  73. #ifndef YYUNPUT_MAX
  74. #define YYUNPUT_MAX YYTEXT_MAX
  75. #endif
  77. /* yytext */
  78. static char YYNEAR yysatext[(YYTEXT_SIZE) + 1]; /* extra char for  */
  79. char YYFAR *YYNEAR YYDCDECL yystext = yysatext;
  80. char YYFAR *YYNEAR YYDCDECL yytext = yysatext;
  81. int YYNEAR YYDCDECL yystext_size = (YYTEXT_SIZE);
  82. int YYNEAR YYDCDECL yytext_size = (YYTEXT_SIZE);
  83. int YYNEAR YYDCDECL yytext_max = (YYTEXT_MAX);
  85. /* yystatebuf */
  86. #if (YYTEXT_SIZE) != 0
  87. static int YYNEAR yysastatebuf[(YYTEXT_SIZE)];
  88. int YYFAR *YYNEAR YYDCDECL yysstatebuf = yysastatebuf;
  89. int YYFAR *YYNEAR YYDCDECL yystatebuf = yysastatebuf;
  90. #else
  91. int YYFAR *YYNEAR YYDCDECL yysstatebuf = NULL;
  92. int YYFAR *YYNEAR YYDCDECL yystatebuf = NULL;
  93. #endif
  95. /* yyunputbuf */
  96. #if (YYUNPUT_SIZE) != 0
  97. static int YYNEAR yysaunputbuf[(YYUNPUT_SIZE)];
  98. int YYFAR *YYNEAR YYDCDECL yysunputbufptr = yysaunputbuf;
  99. int YYFAR *YYNEAR YYDCDECL yyunputbufptr = yysaunputbuf;
  100. #else
  101. int YYFAR *YYNEAR YYDCDECL yysunputbufptr = NULL;
  102. int YYFAR *YYNEAR YYDCDECL yyunputbufptr = NULL;
  103. #endif
  104. int YYNEAR YYDCDECL yysunput_size = (YYUNPUT_SIZE);
  105. int YYNEAR YYDCDECL yyunput_size = (YYUNPUT_SIZE);
  106. int YYNEAR YYDCDECL yyunput_max = (YYUNPUT_MAX);
  108. /* backwards compatability with lex */
  109. #ifdef input
  110. #ifdef YYPROTOTYPE
  111. int YYCDECL yyinput(void)
  112. #else
  113. int YYCDECL yyinput()
  114. #endif
  115. {
  116. return input();
  117. }
  118. #else
  119. #define input yyinput
  120. #endif
  122. #ifdef output
  123. #ifdef YYPROTOTYPE
  124. void YYCDECL yyoutput(int ch)
  125. #else
  126. void YYCDECL yyoutput(ch)
  127. int ch;
  128. #endif
  129. {
  130. output(ch);
  131. }
  132. #else
  133. #define output yyoutput
  134. #endif
  136. #ifdef unput
  137. #ifdef YYPROTOTYPE
  138. void YYCDECL yyunput(int ch)
  139. #else
  140. void YYCDECL yyunput(ch)
  141. int ch;
  142. #endif
  143. {
  144. unput(ch);
  145. }
  146. #else
  147. #define unput yyunput
  148. #endif
  150. #ifndef YYNBORLANDWARN
  151. #ifdef __BORLANDC__
  152. #pragma warn -rch /* <warning: unreachable code> off */
  153. #endif
  154. #endif
  156. #ifdef YYPROTOTYPE
  157. int YYCDECL yylexeraction(int action)
  158. #else
  159. int YYCDECL yylexeraction(action)
  160. int action;
  161. #endif
  162. {
  163. yyreturnflg = YYTRUE;
  164. switch (action) {
  165. case 1:
  166. {
  167. #line 41 ".\scan.l"
  168. return INT;
  169. #line 170 "scan.c"
  170. }
  171. break;
  172. case 2:
  173. {
  174. #line 42 ".\scan.l"
  175. return FLOAT;
  176. #line 177 "scan.c"
  177. }
  178. break;
  179. case 3:
  180. {
  181. #line 43 ".\scan.l"
  182. return CHAR;
  183. #line 184 "scan.c"
  184. }
  185. break;
  186. case 4:
  187. {
  188. #line 44 ".\scan.l"
  189. return VOID;
  190. #line 191 "scan.c"
  191. }
  192. break;
  193. case 5:
  194. {
  195. #line 45 ".\scan.l"
  196. return IF;
  197. #line 198 "scan.c"
  198. }
  199. break;
  200. case 6:
  201. {
  202. #line 46 ".\scan.l"
  203. return ELSE;
  204. #line 205 "scan.c"
  205. }
  206. break;
  207. case 7:
  208. {
  209. #line 47 ".\scan.l"
  210. return WHILE;
  211. #line 212 "scan.c"
  212. }
  213. break;
  214. case 8:
  215. {
  216. #line 48 ".\scan.l"
  217. return CONTINUE;
  218. #line 219 "scan.c"
  219. }
  220. break;
  221. case 9:
  222. {
  223. #line 49 ".\scan.l"
  224. return BREAK;
  225. #line 226 "scan.c"
  226. }
  227. break;
  228. case 10:
  229. {
  230. #line 50 ".\scan.l"
  231. return RETURN;
  232. #line 233 "scan.c"
  233. }
  234. break;
  235. case 11:
  236. {
  237. #line 51 ".\scan.l"
  238. return PLUS;
  239. #line 240 "scan.c"
  240. }
  241. break;
  242. case 12:
  243. {
  244. #line 52 ".\scan.l"
  245. return SUB;
  246. #line 247 "scan.c"
  247. }
  248. break;
  249. case 13:
  250. {
  251. #line 53 ".\scan.l"
  252. return MUT;
  253. #line 254 "scan.c"
  254. }
  255. break;
  256. case 14:
  257. {
  258. #line 54 ".\scan.l"
  259. return DIV;
  260. #line 261 "scan.c"
  261. }
  262. break;
  263. case 15:
  264. {
  265. #line 55 ".\scan.l"
  266. return LT;
  267. #line 268 "scan.c"
  268. }
  269. break;
  270. case 16:
  271. {
  272. #line 56 ".\scan.l"
  273. return LE;
  274. #line 275 "scan.c"
  275. }
  276. break;
  277. case 17:
  278. {
  279. #line 57 ".\scan.l"
  280. return GT;
  281. #line 282 "scan.c"
  282. }
  283. break;
  284. case 18:
  285. {
  286. #line 58 ".\scan.l"
  287. return GE;
  288. #line 289 "scan.c"
  289. }
  290. break;
  291. case 19:
  292. {
  293. #line 59 ".\scan.l"
  294. return EQ;
  295. #line 296 "scan.c"
  296. }
  297. break;
  298. case 20:
  299. {
  300. #line 60 ".\scan.l"
  301. return NEQ;
  302. #line 303 "scan.c"
  303. }
  304. break;
  305. case 21:
  306. {
  307. #line 61 ".\scan.l"
  308. return AND;
  309. #line 310 "scan.c"
  310. }
  311. break;
  312. case 22:
  313. {
  314. #line 62 ".\scan.l"
  315. return OR;
  316. #line 317 "scan.c"
  317. }
  318. break;
  319. case 23:
  320. {
  321. #line 63 ".\scan.l"
  322. return NOT;
  323. #line 324 "scan.c"
  324. }
  325. break;
  326. case 24:
  327. {
  328. #line 64 ".\scan.l"
  329. return ASSIGN;
  330. #line 331 "scan.c"
  331. }
  332. break;
  333. case 25:
  334. {
  335. #line 65 ".\scan.l"
  336. return SEMI;
  337. #line 338 "scan.c"
  338. }
  339. break;
  340. case 26:
  341. {
  342. #line 66 ".\scan.l"
  343. return COMMA;
  344. #line 345 "scan.c"
  345. }
  346. break;
  347. case 27:
  348. {
  349. #line 67 ".\scan.l"
  350. return LP;
  351. #line 352 "scan.c"
  352. }
  353. break;
  354. case 28:
  355. {
  356. #line 68 ".\scan.l"
  357. return RP;
  358. #line 359 "scan.c"
  359. }
  360. break;
  361. case 29:
  362. {
  363. #line 69 ".\scan.l"
  364. return LSP;
  365. #line 366 "scan.c"
  366. }
  367. break;
  368. case 30:
  369. {
  370. #line 70 ".\scan.l"
  371. return RSP;
  372. #line 373 "scan.c"
  373. }
  374. break;
  375. case 31:
  376. {
  377. #line 71 ".\scan.l"
  378. return LFP;
  379. #line 380 "scan.c"
  380. }
  381. break;
  382. case 32:
  383. {
  384. #line 72 ".\scan.l"
  385. return RFP;
  386. #line 387 "scan.c"
  387. }
  388. break;
  389. case 33:
  390. {
  391. #line 73 ".\scan.l"
  392. return ID;
  393. #line 394 "scan.c"
  394. }
  395. break;
  396. case 34:
  397. {
  398. #line 74 ".\scan.l"
  399. return NUM;
  400. #line 401 "scan.c"
  401. }
  402. break;
  403. case 35:
  404. {
  405. #line 75 ".\scan.l"
  406. return FNUM;
  407. #line 408 "scan.c"
  408. }
  409. break;
  410. case 36:
  411. {
  412. #line 76 ".\scan.l"
  413. return SCHAR;
  414. #line 415 "scan.c"
  415. }
  416. break;
  417. case 37:
  418. {
  419. #line 77 ".\scan.l"
  420. lineno++;
  421. #line 422 "scan.c"
  422. }
  423. break;
  424. case 38:
  425. {
  426. #line 78 ".\scan.l"
  428. #line 429 "scan.c"
  429. }
  430. break;
  431. case 39:
  432. {
  433. #line 79 ".\scan.l"
  434.  char c;
  435.   while ((c = yyinput()) != 'n')
  436.     if (c == EOF) return ENDFILE;
  437.   yyunput(c);
  439. #line 440 "scan.c"
  440. }
  441. break;
  442. case 40:
  443. {
  444. #line 84 ".\scan.l"
  445.  char c;
  446.                   int done = FALSE;
  447.                   do {
  448.                     while ((c = yyinput()) != '*')
  449.                       if (c == EOF) return ERROR;
  450.                     while ((c = yyinput()) == '*');
  451.                     if (c == '/') done = TRUE;
  452.                   } while (!done);
  453.                 
  454. #line 455 "scan.c"
  455. }
  456. break;
  457. case 41:
  458. {
  459. #line 93 ".\scan.l"
  460. return ERROR;
  461. #line 462 "scan.c"
  462. }
  463. break;
  464. default:
  465. yyassert(0);
  466. break;
  467. }
  468. yyreturnflg = YYFALSE;
  469. return 0;
  470. }
  472. #ifndef YYNBORLANDWARN
  473. #ifdef __BORLANDC__
  474. #pragma warn .rch /* <warning: unreachable code> to the old state */
  475. #endif
  476. #endif
  477. YYCONST yymatch_t YYNEARFAR YYBASED_CODE YYDCDECL yymatch[] = {
  478. 0
  479. };
  481. int YYNEAR YYDCDECL yytransitionmax = 218;
  482. YYCONST yytransition_t YYNEARFAR YYBASED_CODE YYDCDECL yytransition[] = {
  483. { 0, 0 },
  484. { 4, 1 },
  485. { 5, 1 },
  486. { 4, 4 },
  487. { 40, 16 },
  488. { 42, 19 },
  489. { 16, 16 },
  490. { 16, 16 },
  491. { 16, 16 },
  492. { 16, 16 },
  493. { 16, 16 },
  494. { 16, 16 },
  495. { 16, 16 },
  496. { 16, 16 },
  497. { 16, 16 },
  498. { 16, 16 },
  499. { 45, 25 },
  500. { 38, 15 },
  501. { 43, 20 },
  502. { 49, 28 },
  503. { 44, 24 },
  504. { 0, 8 },
  505. { 39, 15 },
  506. { 46, 25 },
  507. { 4, 1 },
  508. { 6, 1 },
  509. { 4, 4 },
  510. { 50, 28 },
  511. { 47, 26 },
  512. { 48, 27 },
  513. { 7, 1 },
  514. { 8, 1 },
  515. { 9, 1 },
  516. { 10, 1 },
  517. { 11, 1 },
  518. { 12, 1 },
  519. { 13, 1 },
  520. { 14, 1 },
  521. { 35, 6 },
  522. { 15, 1 },
  523. { 16, 1 },
  524. { 16, 1 },
  525. { 16, 1 },
  526. { 16, 1 },
  527. { 16, 1 },
  528. { 16, 1 },
  529. { 16, 1 },
  530. { 16, 1 },
  531. { 16, 1 },
  532. { 16, 1 },
  533. { 51, 29 },
  534. { 17, 1 },
  535. { 18, 1 },
  536. { 19, 1 },
  537. { 20, 1 },
  538. { 52, 30 },
  539. { 53, 31 },
  540. { 21, 1 },
  541. { 21, 1 },
  542. { 21, 1 },
  543. { 21, 1 },
  544. { 21, 1 },
  545. { 21, 1 },
  546. { 21, 1 },
  547. { 21, 1 },
  548. { 21, 1 },
  549. { 21, 1 },
  550. { 21, 1 },
  551. { 21, 1 },
  552. { 21, 1 },
  553. { 21, 1 },
  554. { 21, 1 },
  555. { 21, 1 },
  556. { 21, 1 },
  557. { 21, 1 },
  558. { 21, 1 },
  559. { 21, 1 },
  560. { 21, 1 },
  561. { 21, 1 },
  562. { 21, 1 },
  563. { 21, 1 },
  564. { 21, 1 },
  565. { 21, 1 },
  566. { 22, 1 },
  567. { 54, 33 },
  568. { 23, 1 },
  569. { 55, 37 },
  570. { 21, 1 },
  571. { 57, 44 },
  572. { 21, 1 },
  573. { 24, 1 },
  574. { 25, 1 },
  575. { 21, 1 },
  576. { 26, 1 },
  577. { 27, 1 },
  578. { 21, 1 },
  579. { 21, 1 },
  580. { 28, 1 },
  581. { 21, 1 },
  582. { 21, 1 },
  583. { 21, 1 },
  584. { 21, 1 },
  585. { 21, 1 },
  586. { 21, 1 },
  587. { 21, 1 },
  588. { 21, 1 },
  589. { 29, 1 },
  590. { 21, 1 },
  591. { 21, 1 },
  592. { 21, 1 },
  593. { 30, 1 },
  594. { 31, 1 },
  595. { 21, 1 },
  596. { 21, 1 },
  597. { 21, 1 },
  598. { 32, 1 },
  599. { 33, 1 },
  600. { 34, 1 },
  601. { 21, 82 },
  602. { 21, 82 },
  603. { 21, 82 },
  604. { 21, 82 },
  605. { 21, 82 },
  606. { 21, 82 },
  607. { 21, 82 },
  608. { 21, 82 },
  609. { 21, 82 },
  610. { 21, 82 },
  611. { 58, 45 },
  612. { 59, 46 },
  613. { 60, 47 },
  614. { 61, 48 },
  615. { 62, 50 },
  616. { 63, 51 },
  617. { 64, 52 },
  618. { 21, 82 },
  619. { 21, 82 },
  620. { 21, 82 },
  621. { 21, 82 },
  622. { 21, 82 },
  623. { 21, 82 },
  624. { 21, 82 },
  625. { 21, 82 },
  626. { 21, 82 },
  627. { 21, 82 },
  628. { 21, 82 },
  629. { 21, 82 },
  630. { 21, 82 },
  631. { 21, 82 },
  632. { 21, 82 },
  633. { 21, 82 },
  634. { 21, 82 },
  635. { 21, 82 },
  636. { 21, 82 },
  637. { 21, 82 },
  638. { 21, 82 },
  639. { 21, 82 },
  640. { 21, 82 },
  641. { 21, 82 },
  642. { 21, 82 },
  643. { 21, 82 },
  644. { 65, 53 },
  645. { 36, 7 },
  646. { 66, 57 },
  647. { 67, 58 },
  648. { 21, 82 },
  649. { 68, 59 },
  650. { 21, 82 },
  651. { 21, 82 },
  652. { 21, 82 },
  653. { 21, 82 },
  654. { 21, 82 },
  655. { 21, 82 },
  656. { 21, 82 },
  657. { 21, 82 },
  658. { 21, 82 },
  659. { 21, 82 },
  660. { 21, 82 },
  661. { 21, 82 },
  662. { 21, 82 },
  663. { 21, 82 },
  664. { 21, 82 },
  665. { 21, 82 },
  666. { 21, 82 },
  667. { 21, 82 },
  668. { 21, 82 },
  669. { 21, 82 },
  670. { 21, 82 },
  671. { 21, 82 },
  672. { 21, 82 },
  673. { 21, 82 },
  674. { 21, 82 },
  675. { 21, 82 },
  676. { 56, 56 },
  677. { 56, 56 },
  678. { 56, 56 },
  679. { 56, 56 },
  680. { 56, 56 },
  681. { 56, 56 },
  682. { 56, 56 },
  683. { 56, 56 },
  684. { 56, 56 },
  685. { 56, 56 },
  686. { 69, 60 },
  687. { 70, 61 },
  688. { 71, 63 },
  689. { 72, 64 },
  690. { 73, 65 },
  691. { 74, 66 },
  692. { 75, 68 },
  693. { 76, 70 },
  694. { 77, 71 },
  695. { 78, 73 },
  696. { 79, 75 },
  697. { 80, 77 },
  698. { 81, 79 },
  699. { 82, 81 },
  700. { 41, 18 }
  701. };
  703. YYCONST yystate_t YYNEARFAR YYBASED_CODE YYDCDECL yystate[] = {
  704. { 0, 0, 0 },
  705. { -3, -8, 0 },
  706. { 1, 0, 0 },
  707. { 0, 0, 41 },
  708. { 0, -6, 38 },
  709. { 0, 0, 37 },
  710. { 0, -23, 23 },
  711. { 0, 124, 41 },
  712. { -37, 11, 41 },
  713. { 0, 0, 27 },
  714. { 0, 0, 28 },
  715. { 0, 0, 13 },
  716. { 0, 0, 11 },
  717. { 0, 0, 26 },
  718. { 0, 0, 12 },
  719. { 0, -25, 14 },
  720. { 0, -42, 34 },
  721. { 0, 0, 25 },
  722. { 0, 156, 15 },
  723. { 0, -56, 24 },
  724. { 0, -43, 17 },
  725. { 82, 0, 33 },
  726. { 0, 0, 29 },
  727. { 0, 0, 30 },
  728. { 82, -94, 33 },
  729. { 82, -88, 33 },
  730. { 82, -80, 33 },
  731. { 82, -79, 33 },
  732. { 82, -83, 33 },
  733. { 82, -51, 33 },
  734. { 82, -56, 33 },
  735. { 82, -48, 33 },
  736. { 0, 0, 31 },
  737. { 0, -40, 41 },
  738. { 0, 0, 32 },
  739. { 0, 0, 20 },
  740. { 0, 0, 21 },
  741. { 0, 47, 0 },
  742. { 0, 0, 40 },
  743. { 0, 0, 39 },
  744. { 56, 0, 0 },
  745. { 0, 0, 16 },
  746. { 0, 0, 19 },
  747. { 0, 0, 18 },
  748. { 82, -13, 33 },
  749. { 82, 31, 33 },
  750. { 82, 19, 33 },
  751. { 82, 15, 33 },
  752. { 82, 20, 33 },
  753. { 82, 0, 5 },
  754. { 82, 16, 33 },
  755. { 82, 17, 33 },
  756. { 82, 29, 33 },
  757. { 82, 56, 33 },
  758. { 0, 0, 22 },
  759. { 0, 0, 36 },
  760. { 0, 145, 35 },
  761. { 82, 66, 33 },
  762. { 82, 50, 33 },
  763. { 82, 50, 33 },
  764. { 82, 102, 33 },
  765. { 82, 107, 33 },
  766. { 82, 0, 1 },
  767. { 82, 88, 33 },
  768. { 82, 106, 33 },
  769. { 82, 99, 33 },
  770. { 82, 101, 33 },
  771. { 82, 0, 3 },
  772. { 82, 104, 33 },
  773. { 82, 0, 6 },
  774. { 82, 94, 33 },
  775. { 82, 97, 33 },
  776. { 82, 0, 4 },
  777. { 82, 111, 33 },
  778. { 82, 0, 9 },
  779. { 82, 103, 33 },
  780. { 82, 0, 2 },
  781. { 82, 104, 33 },
  782. { 82, 0, 7 },
  783. { 82, 98, 33 },
  784. { 82, 0, 10 },
  785. { 82, 115, 33 },
  786. { 0, 70, 8 }
  787. };
  789. YYCONST yybackup_t YYNEARFAR YYBASED_CODE YYDCDECL yybackup[] = {
  790. 0,
  791. 0,
  792. 0,
  793. 0,
  794. 0,
  795. 0,
  796. 0,
  797. 0,
  798. 0,
  799. 0,
  800. 0,
  801. 0,
  802. 0,
  803. 0,
  804. 0,
  805. 0,
  806. 0,
  807. 0,
  808. 0,
  809. 0,
  810. 0,
  811. 0,
  812. 0,
  813. 0,
  814. 0,
  815. 0,
  816. 0,
  817. 0,
  818. 0,
  819. 0,
  820. 0,
  821. 0,
  822. 0,
  823. 0,
  824. 0,
  825. 0,
  826. 0,
  827. 0,
  828. 0,
  829. 0,
  830. 0,
  831. 0
  832. };
  834. #line 96 ".\scan.l"
  837. /////////////////////////////////////////////////////////////////////////////
  838. // programs section
  840. TokenType getToken(void)
  841. {
  842.     static int firstTime = TRUE;
  843.     TokenType currentToken;
  844.     if (firstTime) {
  845.         firstTime = FALSE;
  846.         lineno++;
  847.         yyin = source;
  848.         yyout = listing;
  849.     }
  850.     currentToken = yylex();
  851.     strncpy(tokenString, yytext, MAXTOKENLEN);
  852.     if (TraceScan) {
  853. lineno = yylineno;
  854.         fprintf(listing,"t%d: ",lineno);
  855.         printToken(currentToken,tokenString);
  856.     }
  857.     return currentToken;
  858. }