home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / ast_comp / ora-sql.shr / scn1.l next >
Encoding:
Lex Description  |  1993-07-04  |  3.5 KB  |  177 lines
  1. %{
  2. /*
  3.  * AT&T lex can't handle this lexer due to lex bugs.  It works with flex
  4.  * 2.3.7, pclex 2.0.5, and MKS lex 3.1a.
  5.  */
  6.  
  7. #include "sql1.h"
  8. #include <string.h>
  9.  
  10. int lineno = 1;
  11. void yyerror(char *s);
  12. %}
  13.     /* MKS needs the next line to increase the NFA table */
  14. %e 1200
  15.  
  16. %%
  17.  
  18.     /* literal keyword tokens */
  19.  
  20. ADA        { return ADA; }
  21. ALL        { return ALL; }
  22. AND        { return AND; }
  23. AVG        { return AMMSC; }
  24. MIN        { return AMMSC; }
  25. MAX        { return AMMSC; }
  26. SUM        { return AMMSC; }
  27. COUNT        { return AMMSC; }
  28. ANY        { return ANY; }
  29. AS        { return AS; }
  30. ASC        { return ASC; }
  31. AUTHORIZATION    { return AUTHORIZATION; }
  32. BETWEEN        { return BETWEEN; }
  33. BY        { return BY; }
  34. C        { return C; }
  35. CHAR(ACTER)?    { return CHARACTER; }
  36. CHECK        { return CHECK; }
  37. CLOSE        { return CLOSE; }
  38. COBOL        { return COBOL; }
  39. COMMIT        { return COMMIT; }
  40. CONTINUE    { return CONTINUE; }
  41. CREATE        { return CREATE; }
  42. CURRENT        { return CURRENT; }
  43. CURSOR        { return CURSOR; }
  44. DECIMAL        { return DECIMAL; }
  45. DECLARE        { return DECLARE; }
  46. DEFAULT        { return DEFAULT; }
  47. DELETE        { return DELETE; }
  48. DESC        { return DESC; }
  49. DISTINCT    { return DISTINCT; }
  50. DOUBLE        { return DOUBLE; }
  51. ESCAPE        { return ESCAPE; }
  52. EXISTS        { return EXISTS; }
  53. FETCH        { return FETCH; }
  54. FLOAT        { return FLOAT; }
  55. FOR        { return FOR; }
  56. FOREIGN        { return FOREIGN; }
  57. FORTRAN        { return FORTRAN; }
  58. FOUND        { return FOUND; }
  59. FROM        { return FROM; }
  60. GO[ \t]*TO    { return GOTO; }
  61. GRANT        { return GRANT; }
  62. GROUP        { return GROUP; }
  63. HAVING        { return HAVING; }
  64. IN        { return IN; }
  65. INDICATOR    { return INDICATOR; }
  66. INSERT        { return INSERT; }
  67. INT(EGER)?    { return INTEGER; }
  68. INTO        { return INTO; }
  69. IS        { return IS; }
  70. KEY        { return KEY; }
  71. LANGUAGE    { return LANGUAGE; }
  72. LIKE        { return LIKE; }
  73. MODULE        { return MODULE; }
  74. NOT        { return NOT; }
  75. NULL        { return NULLX; }
  76. NUMERIC        { return NUMERIC; }
  77. OF        { return OF; }
  78. ON        { return ON; }
  79. OPEN        { return OPEN; }
  80. OPTION        { return OPTION; }
  81. OR        { return OR; }
  82. ORDER        { return ORDER; }
  83. PASCAL        { return PASCAL; }
  84. PLI        { return PLI; }
  85. PRECISION    { return PRECISION; }
  86. PRIMARY        { return PRIMARY; }
  87. PRIVILEGES    { return PRIVILEGES; }
  88. PROCEDURE    { return PROCEDURE; }
  89. PUBLIC        { return PUBLIC; }
  90. REAL        { return REAL; }
  91. REFERENCES    { return REFERENCES; }
  92. ROLLBACK    { return ROLLBACK; }
  93. SCHEMA        { return SCHEMA; }
  94. SELECT        { return SELECT; }
  95. SET        { return SET; }
  96. SMALLINT    { return SMALLINT; }
  97. SOME        { return SOME; }
  98. SQLCODE        { return SQLCODE; }
  99. TABLE        { return TABLE; }
  100. TO        { return TO; }
  101. UNION        { return UNION; }
  102. UNIQUE        { return UNIQUE; }
  103. UPDATE        { return UPDATE; }
  104. USER        { return USER; }
  105. VALUES        { return VALUES; }
  106. VIEW        { return VIEW; }
  107. WHENEVER    { return WHENEVER; }
  108. WHERE        { return WHERE; }
  109. WITH        { return WITH; }
  110. WORK        { return WORK; }
  111.  
  112.     /* punctuation */
  113.  
  114. "="    |
  115. "<>"     |
  116. "<"    |
  117. ">"    |
  118. "<="    |
  119. ">="        { return COMPARISON; }
  120.  
  121. [-+*/:(),.;]    { return yytext[0]; }
  122.  
  123.     /* names */
  124.  
  125. [A-Za-z][A-Za-z0-9_]*    { return NAME; }
  126.  
  127.     /* numbers */
  128.  
  129. [0-9]+    |
  130. [0-9]+"."[0-9]* |
  131. "."[0-9]*    { return INTNUM; }
  132.  
  133. [0-9]+[eE][+-]?[0-9]+    |
  134. [0-9]+"."[0-9]*[eE][+-]?[0-9]+ |
  135. "."[0-9]*[eE][+-]?[0-9]+    { return APPROXNUM; }
  136.  
  137.     /* strings */
  138.  
  139. '[^'\n]*'    {
  140.         int c = input();
  141.  
  142.         unput(c);    /* just peeking */
  143.         if(c != '\'') {
  144.             return STRING;
  145.         } else
  146.             yymore();
  147.     }
  148.         
  149. '[^'\n]*$    { yyerror("Unterminated string"); }
  150.  
  151. \n        lineno++;
  152.  
  153. [ \t\r]+    ;    /* white space */
  154.  
  155. "--".*$        ;    /* comment */
  156.  
  157. %%
  158.  
  159. void
  160. yyerror(char *s)
  161. {
  162.     printf("%d: %s at %s\n", lineno, s, yytext);
  163. }
  164.  
  165. main(int ac, char **av)
  166. {
  167.     if(ac > 1 && (yyin = fopen(av[1], "r")) == NULL) {
  168.         perror(av[1]);
  169.         exit(1);
  170.     }
  171.  
  172.     if(!yyparse())
  173.         printf("SQL parse worked\n");
  174.     else
  175.         printf("SQL parse failed\n");
  176. } /* main */
  177.