home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Trees / V7 / usr / src / cmd / struct / lextab.l < prev    next >
Encoding:
Lex Description  |  1979-01-10  |  4.5 KB  |  217 lines
  1. %{
  2. #include "y.tab.h"
  3. #include "b.h"
  4. #undef    input
  5. #define input()    ninput()
  6. #undef    unput
  7. #define unput(c)    nunput(c)
  8. extern int yylval;
  9. #define xxbpmax    1700
  10. char xxbuf[xxbpmax + 2];
  11. int xxbp = -1;
  12. #define xxunmax    200
  13. char xxunbuf[xxunmax + 2];
  14. int xxunbp = -1;
  15.  
  16.  
  17. int blflag;
  18. %}
  19.  
  20. D    [0-9]
  21. A    [0-9a-z]
  22. L    [a-z]
  23. SP    [^0-9a-z]
  24.  
  25. %%
  26.  
  27. %{
  28. char *xxtbuff;
  29. int xxj, xxn, xxk;
  30. char *xxp;
  31. %}
  32. [=/,(]{D}+[h]            {
  33.                 blflag = 1;
  34.                 sscanf(&yytext[1],"%d",&xxn);
  35.                 xxtbuff = malloc(2*xxn+3);
  36.                 for (xxj = xxk = 1; xxj <= xxn; ++xxj)
  37.                     {
  38.                     xxtbuff[xxk] = ninput();
  39.                     if (xxtbuff[xxk] == '"')
  40.                         xxtbuff[++xxk] = '"';
  41.                     ++xxk;
  42.                     }
  43.                 xxtbuff[0] = xxtbuff[xxk++] = '"';
  44.                 xxtbuff[xxk] = '\0';
  45.                 putback(xxtbuff);
  46.                 free(xxtbuff);
  47.  
  48.                 backup(yytext[0]);
  49.                 blflag = 0;
  50.                 xxbp = -1;
  51.                 }
  52. IF            {fixval(); xxbp = -1; return(xxif);}
  53. ELSE            {fixval(); xxbp = -1; return(xxelse);}
  54. REPEAT            {fixval(); xxbp = -1; return(xxrept); }
  55. WHILE            {fixval(); xxbp = -1; return(xxwhile); }
  56. UNTIL            { fixval(); xxbp = -1; return(xxuntil); }
  57. DO            {fixval(); xxbp = -1; return(xxdo); }
  58. SWITCH            {fixval(); xxbp = -1; return(xxswitch); }
  59. CASE            {fixval(); xxbp = -1; return(xxcase); }
  60. DEFAULT            {fixval(); xxbp = -1; return(xxdefault); }
  61. END            {fixval(); xxbp = -1; return(xxend); }
  62.  
  63. ".true."        |
  64. ".false."        |
  65.  
  66. {L}{A}*        {fixval(); xxbp = -1; return(xxident); }
  67. ~{D}+            {xxbuf[0] = ' '; fixval(); xxbp = -1; return(xxnum); }
  68. {D}+/"."(ge|gt|le|lt|eq|ne|not|or|and)"."    |
  69. {D}+\.?            |
  70. {D}+\.?[de][+-]?{D}+        |
  71. {D}*\.{D}+[de][+-]?{D}+        |
  72. {D}*\.{D}+            {fixval(); xxbp = -1; return(xxnum); }
  73.  
  74. ".gt."            { putback(">"); xxbp = -1; }
  75. ".ge."            { putback(">=");xxbp = -1; }
  76. ".lt."            { putback("<"); xxbp = -1; }
  77. ".le."            { putback("<="); xxbp = -1; }
  78. ".eq."            { putback("=="); xxbp = -1; }
  79. ".ne."            { putback("!="); xxbp = -1; }
  80. ".not."            { putback("!"); xxbp = -1; }
  81. ".or."            { putback("||"); xxbp = -1; }
  82. ".and."            { putback("&&"); xxbp = -1; }
  83. ">="        {fixval(); xxbp = -1;  return(xxge);  }
  84. "<="        {fixval(); xxbp = -1;  return(xxle); }
  85. ==            {fixval(); xxbp = -1; return(xxeq); }
  86. !=            {fixval(); xxbp = -1; return(xxne); }
  87. "||"            {fixval(); xxbp = -1; return('|'); }
  88. "&&"            {fixval(); xxbp = -1;  return('&'); }
  89. "**"            {fixval(); xxbp = -1; return('^'); }
  90.  
  91. #.*            {fixval(); xxbp = -1; return(xxcom); }
  92. \"([^"]|\"\")*\"        {fixval(); xxbp = -1; return(xxstring); }
  93. '([^']|'')*'                {
  94.                     fixval();
  95.                     xxp = yylval;
  96.                     xxn = slength(xxp);
  97.                     xxtbuff = malloc(2*xxn+1);
  98.                     xxtbuff[0] = '"';
  99.                     for (xxj = xxk = 1; xxj < xxn-1; ++xxj)
  100.                         {
  101.                         if (xxp[xxj] == '\'' && xxp[++xxj] == '\'')
  102.                             xxtbuff[xxk++] = '\'';
  103.                         else if (xxp[xxj] == '"')
  104.                             {
  105.                             xxtbuff[xxk++] = '"';
  106.                             xxtbuff[xxk++] = '"';
  107.                             }
  108.                         else
  109.                             xxtbuff[xxk++] = xxp[xxj];
  110.                         }
  111.                     xxtbuff[xxk++] = '"';
  112.                     xxtbuff[xxk] = '\0';
  113.                     free(xxp);
  114.                     yylval = xxtbuff;
  115.                     xxbp = -1;
  116.                     return(xxstring);
  117.                     }
  118.  
  119. ^\n        xxbp = -1;
  120. \n        {xxbp = -1; if (newflag) {fixval(); return('\n'); }  }
  121. {SP}        {fixval(); xxbp = -1; return(yytext[0]); }
  122.  
  123. %%
  124.  
  125. rdchar()
  126.     {
  127.     int c;
  128.     if (xxunbp >= 0)
  129.         return(xxunbuf[xxunbp--]);
  130.     c = getchar();
  131.     if (c == EOF) return('\0');
  132.     else return((char)c);
  133.     }
  134.  
  135. backup(c)
  136. char c;
  137.     {
  138.     if (++xxunbp > xxunmax)
  139.         {
  140.         xxunbuf[xxunmax + 1] = '\0';
  141.         error("RATFOR beautifying; input backed up too far during lex:\n",
  142.             xxunbuf,"\n");
  143.         }
  144.     xxunbuf[xxunbp] = c;
  145.     }
  146.  
  147. nunput(c)
  148. char c;
  149.     {
  150.     backup(c);
  151.     if (xxbp < 0) return;
  152.     if (c != xxbuf[xxbp])
  153.         {
  154.         xxbuf[xxbp + 1] = '\0';
  155.         error("RATFOR beautifying; lex call of nunput with wrong char:\n",
  156.             xxbuf,"\n");
  157.         }
  158.     for ( --xxbp; xxbp >= 0 && (xxbuf[xxbp] == ' ' || xxbuf[xxbp] == '\t'); --xxbp)
  159.         backup(xxbuf[xxbp]);
  160.     xxbuf[xxbp+1] = '\0';
  161.     }
  162.  
  163. ninput()
  164.     {
  165.     char c,d;
  166.     if (blflag) c = rdchar();
  167.     else
  168.         while ( (c = rdchar()) == ' ' || c == '\t')
  169.         addbuf(c);
  170.     if (c != '\n')
  171.         return(addbuf(c));
  172.     while ( (d = rdchar()) == ' ' || d == '\t');
  173.     if (d == '&')
  174.         return(ninput());
  175.     backup(d);
  176.     return(addbuf('\n'));
  177.     }
  178.  
  179. addbuf(c)
  180. char c;
  181.     {
  182.     if (++xxbp > xxbpmax)
  183.         {
  184.         xxbuf[xxbpmax +1] = '\0';
  185.         error("RATFOR beautifying; buffer xxbuf too small for token beginning:\n",
  186.             xxbuf,"\n");
  187.         }
  188.     xxbuf[xxbp] = c;
  189.     xxbuf[xxbp + 1] = '\0';
  190.     return(c);
  191.     }
  192.  
  193.  
  194. fixval()
  195.     {
  196.     int i, j, k;
  197.     for (j = 0; xxbuf[j] == ' ' || xxbuf[j] == '\t'; ++j);
  198.     for (k = j; xxbuf[k] != '\0'; ++k);
  199.     for (--k; k > j && xxbuf[k] == ' ' || xxbuf[k]  == '\t'; --k);
  200.     xxbuf[k+1] = '\0';
  201.     i = slength(&xxbuf[j]) + 1;
  202.     yylval = malloc(i);
  203.     str_copy(&xxbuf[j],yylval,i);
  204.     }
  205.  
  206.  
  207.  
  208. putback(str)
  209. char *str;
  210.     {
  211.     int i;
  212.     for (i = 0; str[i] != '\0'; ++i);
  213.     for (--i; i >= 0; --i)
  214.         backup(str[i]);
  215.     }
  216.  
  217.