home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume6 / yaccref / yyref-lex < prev    next >
Encoding:
Text File  |  1986-11-30  |  2.3 KB  |  174 lines
  1.  
  2.     /*******************************************************\
  3.     *                            *
  4.     *    X_ref for YACC - LEX file            *
  5.     *    ~~~~~~~~~~~~~~~~~~~~~~~~~            *
  6.     *    Date: Tue Jul  1 03:36:21 BST 1986        *
  7.     *                            *
  8.     \*******************************************************/
  9.  
  10. %{
  11.  
  12. # include    <stdio.h>
  13. # include    "yyref-line.h"
  14.  
  15. #define        TRUE 1
  16. #define         FALSE 0
  17.  
  18. int    recognised;
  19. char    c;
  20.  
  21. %}
  22.  
  23.     /* abbreviations */
  24.  
  25. digit        [0-9]
  26. u_case        [A-Z]
  27. l_case        [a-z]
  28. id_char        [A-Za-z0-9_]
  29. letter        [A-Za-z]
  30. white        [\t ]
  31.  
  32.  
  33. %%
  34.  
  35. "/*"            {
  36.                 ECHO;
  37.                 recognised = FALSE;
  38.                 c = nextchar();
  39.                 while (recognised == FALSE)
  40.                 {
  41.                     while (c != '*')
  42.                         c = nextchar();
  43.                     c = nextchar();
  44.                     if (c == '\/')
  45.                         recognised = TRUE;
  46.                 }
  47.             }
  48. "%{"            {
  49.                 ECHO;
  50.                 recognised = FALSE;
  51.                 c = nextchar();
  52.                 while (recognised == FALSE)
  53.                 {
  54.                     while (c != '\%')
  55.                         c = nextchar();
  56.                     c = nextchar();
  57.                     if (c == '\}')
  58.                         recognised = TRUE;
  59.                 }
  60.                 return(PERCURL);
  61.             }
  62. "{"            {
  63.  
  64. /*
  65. *    Although LEX can cope with the full definition,
  66. *    ( "{"[^\}]*"}" ) this may overrun the lex buffer (200 chars).
  67. *    Thus this routine.
  68. */
  69.  
  70.                 ECHO;
  71.                 c = nextchar();
  72.                 while (c != '\}')
  73.                     c = nextchar();
  74.                 return(ACT);
  75.             }
  76. {letter}{id_char}*    {
  77.                 ECHO;
  78.                 return(IDENTIFIER);
  79.             }
  80. "'"\\?[^']+"'"        {
  81.                 ECHO;
  82.                 return(CHARACTER);
  83.             }
  84. {white}+        {    
  85.                 ECHO;
  86.             }
  87. {digit}+        {
  88.                 ECHO;
  89.                 return(NUMBER);
  90.             }
  91. "%"{white}*"left"    {
  92.                 ECHO;
  93.                 return(LEFT);
  94.             }
  95. "%"{white}*"right"    {
  96.                 ECHO;
  97.                 return(RIGHT);
  98.             }
  99. "%"{white}*"nonassoc"    {
  100.                 ECHO;
  101.                 return(NONASSOC);
  102.             }
  103. "%"{white}*"token"    {
  104.                 ECHO;
  105.                 return(TOKEN);
  106.             }
  107. "%"{white}*"prec"    {
  108.                 ECHO;
  109.                 return(PREC);
  110.             }
  111. "%"{white}*"type"    {
  112.                 ECHO;
  113.                 return(TYPE);
  114.             }
  115. "%"{white}*"start"    {
  116.                 ECHO;
  117.                 return(START);
  118.             }
  119. "%"{white}*"union"    {
  120.                 ECHO;
  121.                 return(UNION);
  122.             }
  123. "%%"            {
  124.                 ECHO;
  125.                 return(PER);
  126.             }
  127. ":"            {
  128.                 ECHO;
  129.                 return(COLON);
  130.             }
  131. ";"            {
  132.                 ECHO;
  133.                 return(SEMICOLON);
  134.             }
  135. ","            {
  136.                 ECHO;
  137.                 return(COMMA);
  138.             }
  139. "|"            {
  140.                 ECHO;
  141.                 return(OR);
  142.             }
  143. "<"            {
  144.                 ECHO;
  145.                 return(LESS);
  146.             }
  147. ">"            {
  148.                 ECHO;
  149.                 return(GREATER);
  150.             }
  151. "\n"            {
  152.                 ECHO;
  153.                 nline(++line);
  154.             }
  155.  
  156. %%
  157.  
  158. yywrap()
  159. {
  160.     /* wrap-up procedure */
  161.     return(1);
  162. }
  163.  
  164. nextchar()
  165. {
  166.     char    c;
  167.     
  168.     c = input();
  169.     printf("%c",c);
  170.     if (c == '\n')
  171.         nline(++line);
  172.     return(c);
  173. }
  174.