home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V7 / usr / src / cmd / awk / awk.lx.l < prev    next >
Encoding:
Text File  |  1979-05-11  |  4.4 KB  |  170 lines

  1. %Start A str chc sc reg comment
  2.  
  3. %{
  4. #include    "awk.h"
  5. #include    "awk.def"
  6. #undef    input    /* defeat lex */
  7. extern int    yylval;
  8. extern int    mustfld;
  9.  
  10. int    lineno    1;
  11. #ifdef    DEBUG
  12. #    define    RETURN(x)    {if (dbg) ptoken(x); return(x); }
  13. #else
  14. #    define    RETURN(x)    return(x)
  15. #endif
  16. #define    CADD    cbuf[clen++]=yytext[0]; if(clen>=CBUFLEN-1) {yyerror("string too long", cbuf); BEGIN A;}
  17. #define    CBUFLEN    150
  18. char    cbuf[CBUFLEN];
  19. int    clen, cflag;
  20. %}
  21.  
  22. A    [a-zA-Z]
  23. B    [a-zA-Z0-9]
  24. D    [0-9]
  25. WS    [ \t]
  26.  
  27. %%
  28.     switch (yybgin-yysvec-1) {    /* witchcraft */
  29.     case 0:
  30.         BEGIN A;
  31.         break;
  32.     case sc:
  33.         BEGIN A;
  34.         RETURN('}');
  35.     }
  36.  
  37. <A>^\n        lineno++;
  38. <A>^{WS}*#.*\n    lineno++;    /* strip comment lines */
  39. <A>{WS}        ;
  40. <A,reg>"\\"\n    lineno++;
  41. <A>"||"        RETURN(BOR);
  42. <A>BEGIN    RETURN(XBEGIN);
  43. <A>END        RETURN(XEND);
  44. <A>PROGEND    RETURN(EOF);
  45. <A>"&&"        RETURN(AND);
  46. <A>"!"        RETURN(NOT);
  47. <A>"!="        { yylval = NE; RETURN(RELOP); }
  48. <A>"~"        { yylval = MATCH; RETURN(MATCHOP); }
  49. <A>"!~"        { yylval = NOTMATCH; RETURN(MATCHOP); }
  50. <A>"<"        { yylval = LT; RETURN(RELOP); }
  51. <A>"<="        { yylval = LE; RETURN(RELOP); }
  52. <A>"=="        { yylval = EQ; RETURN(RELOP); }
  53. <A>">="        { yylval = GE; RETURN(RELOP); }
  54. <A>">"        { yylval = GT; RETURN(RELOP); }
  55. <A>">>"        { yylval = APPEND; RETURN(RELOP); }
  56. <A>"++"        { yylval = INCR; RETURN(INCR); }
  57. <A>"--"        { yylval = DECR; RETURN(DECR); }
  58. <A>"+="        { yylval = ADDEQ; RETURN(ASGNOP); }
  59. <A>"-="        { yylval = SUBEQ; RETURN(ASGNOP); }
  60. <A>"*="        { yylval = MULTEQ; RETURN(ASGNOP); }
  61. <A>"/="        { yylval = DIVEQ; RETURN(ASGNOP); }
  62. <A>"%="        { yylval = MODEQ; RETURN(ASGNOP); }
  63. <A>"="        { yylval = ASSIGN; RETURN(ASGNOP); }
  64.  
  65. <A>"$"{D}+    {    if (atoi(yytext+1)==0) {
  66.                 yylval = lookup("$record", symtab);
  67.                 RETURN(STRING);
  68.             } else {
  69.                 yylval = fieldadr(atoi(yytext+1));
  70.                 RETURN(FIELD);
  71.             }
  72.         }
  73. <A>"$"{WS}*    { RETURN(INDIRECT); }
  74. <A>NF        { mustfld=1; yylval = setsymtab(yytext, NULL, 0.0, NUM, symtab); RETURN(VAR); }
  75. <A>({D}+("."?){D}*|"."{D}+)((e|E)("+"|-)?{D}+)?    {
  76.         yylval = setsymtab(yytext, NULL, atof(yytext), CON|NUM, symtab); RETURN(NUMBER); }
  77. <A>"}"{WS}*\n    { BEGIN sc; lineno++; RETURN(';'); }
  78. <A>"}"        { BEGIN sc; RETURN(';'); }
  79. <A>;\n        { lineno++; RETURN(';'); }
  80. <A>\n        { lineno++; RETURN(NL); }
  81. <A>while    RETURN(WHILE);
  82. <A>for        RETURN(FOR);
  83. <A>if        RETURN(IF);
  84. <A>else        RETURN(ELSE);
  85. <A>next        RETURN(NEXT);
  86. <A>exit        RETURN(EXIT);
  87. <A>break    RETURN(BREAK);
  88. <A>continue    RETURN(CONTINUE);
  89. <A>print    { yylval = PRINT; RETURN(PRINT); }
  90. <A>printf    { yylval = PRINTF; RETURN(PRINTF); }
  91. <A>sprintf    { yylval = SPRINTF; RETURN(SPRINTF); }
  92. <A>split    { yylval = SPLIT; RETURN(SPLIT); }
  93. <A>substr    RETURN(SUBSTR);
  94. <A>index    RETURN(INDEX);
  95. <A>in        RETURN(IN);
  96. <A>length    { yylval = FLENGTH; RETURN(FNCN); }
  97. <A>log        { yylval = FLOG; RETURN(FNCN); }
  98. <A>int        { yylval = FINT; RETURN(FNCN); }
  99. <A>exp        { yylval = FEXP; RETURN(FNCN); }
  100. <A>sqrt        { yylval = FSQRT; RETURN(FNCN); }
  101. <A>{A}{B}*    { yylval = setsymtab(yytext, tostring(""), 0.0, STR, symtab); RETURN(VAR); }
  102. <A>\"        { BEGIN str; clen=0; }
  103.  
  104. <A>#        { BEGIN comment; }
  105. <comment>\n    { BEGIN A; lineno++; RETURN(NL); }
  106. <comment>.    ;
  107.  
  108. <A>.        { yylval = yytext[0]; RETURN(yytext[0]); }
  109.  
  110. <reg>"["    { BEGIN chc; clen=0; cflag=0; }
  111. <reg>"[^"    { BEGIN chc; clen=0; cflag=1; }
  112.  
  113. <reg>"?"    RETURN(QUEST);
  114. <reg>"+"    RETURN(PLUS);
  115. <reg>"*"    RETURN(STAR);
  116. <reg>"|"    RETURN(OR);
  117. <reg>"."    RETURN(DOT);
  118. <reg>"("    RETURN('(');
  119. <reg>")"    RETURN(')');
  120. <reg>"^"    RETURN('^');
  121. <reg>"$"    RETURN('$');
  122. <reg>\\.    {    if (yytext[1]=='n') yylval = '\n';
  123.             else if (yytext[1] == 't') yylval = '\t';
  124.             else yylval = yytext[1];
  125.             RETURN(CHAR);
  126.         }
  127. <reg>"/"    { BEGIN A; unput('/'); }
  128. <reg>\n        { yyerror("newline in regular expression"); lineno++; BEGIN A; }
  129. <reg>.        { yylval = yytext[0]; RETURN(CHAR); }
  130.  
  131. <str>\"        { BEGIN A; cbuf[clen]=0; yylval = setsymtab(cbuf, tostring(cbuf), 0.0, CON|STR, symtab); RETURN(STRING); }
  132. <str>\n        { yyerror("newline in string"); lineno++; BEGIN A; }
  133. <str>"\\\""    { cbuf[clen++]='"'; }
  134. <str,chc>"\\"n    { cbuf[clen++]='\n'; }
  135. <str,chc>"\\"t    { cbuf[clen++]='\t'; }
  136. <str,chc>"\\\\"    { cbuf[clen++]='\\'; }
  137. <str>.        { CADD; }
  138.  
  139. <chc>"\\""]"    { cbuf[clen++]=']'; }
  140. <chc>"]"    { BEGIN reg; cbuf[clen]=0; yylval = tostring(cbuf);
  141.         if (cflag==0) { RETURN(CCL); }
  142.         else { RETURN(NCCL); } }
  143. <chc>\n        { yyerror("newline in character class"); lineno++; BEGIN A; }
  144. <chc>.        { CADD; }
  145.  
  146. %%
  147.  
  148. input()
  149. {
  150.     register c;
  151.     extern char *lexprog;
  152.  
  153.     if (yysptr > yysbuf)
  154.         c = U(*--yysptr);
  155.     else if (yyin == NULL)
  156.         c = *lexprog++;
  157.     else
  158.         c = getc(yyin);
  159.     if (c == '\n')
  160.         yylineno++;
  161.     else if (c == EOF)
  162.         c = 0;
  163.     return(c);
  164. }
  165.  
  166. startreg()
  167. {
  168.     BEGIN reg;
  169. }
  170.