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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
clex.c
资源名称：parse.tar.Z　[点击查看]
上传用户：hbdengju
上传日期：2007-01-06
资源大小：11k
文件大小：15k
源码类别：

编译器/解释器

开发平台：

C/C++

clex.c：源码内容
  2. #ifndef INCLUDED_STREAM
  3. #include <stream.h>
  4. #endif
  5. #ifndef INCLUDED_STRING
  6. #include <string.h>
  7. #endif
  8. #ifndef INCLUDED_STDLIB
  9. #include <stdlib.h>
  10. #endif
  11. #ifndef INCLUDED_ASSERT
  12. #include <assert.h>
  13. #endif
  14. #ifndef INCLUDED_CTYPE
  15. #include <ctype.h>
  16. #endif
  18. #include "clex.h"
  20. // get string value tables, sym_str[] and keyword[] :
  21. #define CLEX_IMPLEMENTATION 1
  22. #include "clex_sym.h"
  24. /******************************************************************************
  25. *                                                                             *
  26. *  KWTABLE -- keyword hash table (internal use only)                          *
  27. *     KWtable implements a collision-free hash table of C++ keywords.  The    *
  28. *     table size and hash function are computed by use of a standalone C      *
  29. *     program, kwhash.c, included in this directory.                          *
  30. *                                                                             *
  31. ******************************************************************************/
  33. #define U_short unsigned short
  34. #define U_char  unsigned char
  36. struct KWtable
  37.     {
  38.     enum { HASHSIZE = 131 };  // as computed by kwhash.c, for a=9,b=2,c=2
  40.     struct  {
  41.             char* kwp;
  42.             Clex_sym sym;
  43.             } kwhash[HASHSIZE];
  45.     KWtable(char**);
  46.     U_short hash(const U_char*, U_short len);
  47.     void insert(char*, Clex_sym);
  48.     Clex_sym lookup(char*, short len);
  49.     };
  51. static KWtable kwt = KWtable(keywords); // keywords[] defined in Clex_sym.h
  53. KWtable::
  54. KWtable (char** kwl)
  55.     {
  56.     short int i;
  57.     for (i = 0; i < HASHSIZE; ++i)
  58.         kwhash[i].kwp = NULL;
  59.     for (i = 0; i < CLEX_NUMKEYS; ++i)
  60.         insert(kwl[i], KEYWORD_S + i);
  61.     // rely on assert() to prevent hash collisions -- may need
  62.     //  a new hash function or table size when keyword added.
  63.     }
  65. // the values used in the following hash function, and HASHSIZE, were
  66. // determined by use of the standalone C program kwhash.c, to
  67. // ensure that no collisions occur.
  69. inline
  70. U_short KWtable::
  71. hash (const U_char* cp, U_short len)
  72.     {
  73.     return (((U_short)cp[0]         ) ^
  74.             ((U_short)cp[1]     << 9) ^
  75.             ((U_short)cp[len-1] << 2) ^
  76.             (len                << 2) ) % HASHSIZE;
  77.     }
  79. void KWtable::
  80. insert (char* cp, Clex_sym s)
  81.     {
  82.     U_short h = hash(cp, strlen(cp));
  83.     assert(kwt.kwhash[h].kwp == NULL);  // collisions not permitted.
  84.     kwt.kwhash[h].kwp = cp;
  85.     kwt.kwhash[h].sym = s;
  86.     }
  88. Clex_sym KWtable::
  89. lookup (char* cp, short len)
  90.     {
  91.     if (len < 2 || len > 9) return (IDENT_S);
  92.     short h = hash(cp, len);
  93.     if (kwt.kwhash[h].kwp == NULL) return (IDENT_S);
  94.     if (strcmp(kwt.kwhash[h].kwp, cp)) return (IDENT_S);
  95.     return (kwt.kwhash[h].sym);
  96.     }
  98. /******************************************************************************
  99. *                                                                             *
  100. *  CLEX -- c++ lexical scanner                                               *
  101. *                                                                             *
  102. ******************************************************************************/
  104. // CONSTRUCTOR Clex:
  105. //   The argument block_brack, if TRUE, dictates that the contents
  106. //   of square brackets "[]" be returned as a string in the string
  107. //   buffer.  If false, square brackets are treated as simple tokens.
  109. Clex::
  110. Clex (FILE* f, Boolean b)
  111.     {
  112.     fp = f;
  113.     block_brack = b;
  114.     filename[0] = '';
  115.     bufsiz = 0; buf[0] = '';
  116.     // prime the pipeline:
  117.     line_num = 0;
  118.     look = 'n';    // be prepared to handle '#' as first char
  119.     }
  121. Clex_sym Clex::
  122. num (char c)
  123.     {
  124.     Clex_sym s = NUM_S;
  126.     bufsiz = 0;
  127.     put_in_buf(c);
  128.     while (isdigit(look))
  129.         buf_one();
  131.     // hexadecimal
  132.     if (bufsiz == 1 && *buf == '0' && (look == 'x' || look == 'X'))
  133.         {
  134.         do { buf_one(); }
  135.             while (isxdigit(look));
  136.         if (look == 'L' || look == 'l' || look == 'U' || look == 'u')
  137.             buf_one();
  138.         return terminate(s);
  139.         }
  141.     // long or unsigned
  142.     if (look == 'L' || look == 'l' || look == 'U' || look == 'u')
  143.         { buf_one(); return terminate(NUM_S); }
  145.     // floating point
  146.     else if (look == '.')
  147.         {
  148.         s = FLOATNUM_S;
  149.         do { buf_one(); }
  150.             while (isdigit(look));
  151.         }
  153.     // scientific notation
  154.     if (look == 'e' || look == 'E')
  155.          {
  156.          s = FLOATNUM_S;
  157.          do { buf_one(); }
  158.             while (isdigit(look));
  159.          }
  160.     else
  161.         return terminate(s);
  163.     if (look == '+' || look == '-')
  164.          do { buf_one(); }
  165.             while (isdigit(look));
  166.     return terminate(s);
  167.     }
  169. Clex_sym Clex::
  170. ident (char first)
  171.     {
  172.     register Boolean maybe_kw = TRUE;
  173.     register short bs = 0;
  174.     buf[bs++] = first;
  175.     while (isalnum(look) || look == '_' || look == '$')
  176.         {
  177.         // note: this function accounts for 30% of the total scan time
  178.         if (maybe_kw && (isupper(look) || look == '_' ))
  179.             maybe_kw = FALSE;
  180.         buf[bs++] = look;       // don't worry about overflow
  181.         eat_one();
  182.         }
  183.     buf[bs] = '';
  184.     bufsiz = bs;
  186.     if (maybe_kw)
  187.         return kwt.lookup(buf, bufsiz);
  188.     return IDENT_S;
  189.     }
  191. Clex_sym Clex::
  192. quote (char c, Clex_sym s, Clex_mode m)
  193.     {
  194.     if (m == CL_NONE)
  195.         bufsiz = 0;
  196.     while (look != c)
  197.         {
  198.         if (look == EOF)
  199.             { return terminate(ERROR_EOF_S); }
  200.         else if (look == 'n')
  201.             { return terminate(ERROR_EOLN_S); }
  202.         else if (look == '\')
  203.             {
  204.             eat_one();
  205.             if (look == 'n')
  206.                 { eat_one(); eoln(m|CL_QUOTE); continue; }
  207.             else if (look == EOF)
  208.                 { return terminate(ERROR_EOF_S); }
  209.             else
  210.                 put_in_buf('\');   // this handles ' and " too.
  211.             }
  212.         buf_one();
  213.         }
  214.     eat_one();  // eat the closing quote
  215.     return terminate(s);
  216.     }
  219. // lbrack() accumulates the contents between "[" and "]" into
  220. //  the string buffer, handling syntactically quoted strings,
  221. //  comments, and nested brackets.  Note that lbrack() is
  222. //  called recursively in the case of nested brackets.
  224. Clex_sym Clex::
  225. lbrack (Clex_mode m)
  226.     {
  227.     if (m == CL_NONE)
  228.         bufsiz = 0;
  229.     while (look != ']')
  230.         {
  231.         if (look == EOF)
  232.             return terminate(ERROR_EOF_S);
  234.         else if (look == 'n')
  235.             { eat_one(); eoln(m|CL_BRACK); }
  236.         else if (look == '[')
  237.             {
  238.             buf_one();
  239.             if (lbrack(m|CL_BRACK) == ERROR_EOF_S)
  240.                 return ERROR_EOF_S;     // already cleaned up.
  241.             else put_in_buf(']');
  242.             }
  243.         else if (look == ''' || look == '"')
  244.             {
  245.             char c = look;
  246.             buf_one();
  247.             (void) quote(c, NONE_S, m|CL_BRACK);
  248.             put_in_buf(c);
  249.             }
  250.         else if (look == '/')           // maybe a comment
  251.             {
  252.             eat_one();
  253.             if (look == '/')
  254.                 line_comment();
  255.             else if (look == '*')
  256.                 {
  257.                 block_comment(m|CL_BRACK);
  258.                 if (look == EOF) return terminate(ERROR_EOF_S);
  259.                 }
  260.             else                        // stash the '/' and the char after
  261.                 { put_in_buf('/'); buf_one(); }
  262.             }
  263.         else                            // just a character to save
  264.             buf_one();
  265.         }
  267.     eat_one(); // eat the ']'.
  268.     return terminate(LBRACK_S);
  269.     }
  272. void Clex::
  273. block_comment(Clex_mode m)
  274.     {
  275.     eat_one(); // eat the '*'
  276.     while (! (look == '*' && (eat_one(), look == '/')) )
  277.         {
  278.         if (look == EOF) return;
  279.         if (look == 'n') { eat_one(); eoln(m|CL_COMMENT); }
  280.         else if (look != '*') eat_one();
  281.         }
  282.     eat_one(); // eat the '/'
  283.     }
  285. void Clex::
  286. line_comment()
  287.     {
  288.     do { eat_one(); }
  289.      while (look != 'n' && look != EOF);
  290.     }
  292. // eat_return() is intended to save space in Clex::next() -- the
  293. //  inline function eat_one() produces quite a lot of code.
  294. Clex_sym Clex::
  295. eat_return(Clex_sym s)
  296.     { eat_one(); return s; }
  298. Clex_sym Clex::
  299. next()
  300.     {
  301.     short val;
  302.     while (val = look, eat_one(), val != EOF)
  303.         {
  304.         char ch = char(val);
  305.         switch (ch)
  306.             {
  307.         case ' ' : continue;
  309.         case '_' :
  310.         case '$' : return ident(ch);
  312.         case '0' : case '1' : case '2' : case '3' : case '4' :
  313.         case '5' : case '6' : case '7' : case '8' : case '9' :
  314.                    return num(ch);
  316.         case ',' : return COMMA_S;
  317.         case ';' : return SEMI_S;
  318.         case '[' : if (block_brack) return lbrack(CL_NONE);
  319.                    else             return LBRACK_S;
  320.         case ']' : return RBRACK_S;
  321.         case '{' : return LBRACE_S;
  322.         case '}' : return RBRACE_S;
  323.         case '(' : return LPAR_S;
  324.         case ')' : return RPAR_S;
  325.         case '~' : return TILDE_S;
  326.         case '?' : return QUEST_S;
  327.         case '"' : return quote(ch, QUOTE_S, CL_NONE);
  328.         case ''': return quote(ch, APOS_S, CL_NONE);
  330.         case '=' :                              // '=', '=='
  331.             if (look != '=') return AS_S;
  332.             else  return eat_return(EQ_S);
  334.         case ':' :                              // ":", "::"
  335.             if (look != ':') return COLON_S;
  336.             else  return eat_return(SCOPE_S);
  338.         case '!' :                              // "!", "!="
  339.             if (look != '=') return BANG_S;
  340.             else  return eat_return(NE_S);
  342.         case '^' :                              // "^", "^="
  343.             if (look != '=') return CARET_S;
  344.             else  return eat_return(XORAS_S);
  346.         case '*' :                              // '*', '*='
  347.             if (look != '=') return STAR_S;
  348.             else  return eat_return(MULAS_S);
  350.         case '%' :                              // '%', '%='
  351.             if (look != '=') return MOD_S;
  352.             else  return eat_return(MODAS_S);
  354.         case '|' :                              //  "|=", "||", "|"
  355.             if      (look == '|') return eat_return(LOR_S);
  356.             else if (look == '=') return eat_return(ORAS_S);
  357.             else                             return VBAR_S;
  359.         case '&' :                              // "&", "&=", "&&"
  360.             if      (look == '&') return eat_return(LAND_S);
  361.             else if (look == '=') return eat_return(ANDAS_S);
  362.             else                             return AMPER_S;
  364.         case '+' :                              // '+', '++', '+='
  365.             if      (look == '+') return eat_return(INCRE_S);
  366.             else if (look == '=') return eat_return(ADDAS_S);
  367.             else                             return PLUS_S;
  369.         case '-' :                              // '--', '-=', '->', '-', 
  370.             if      (look == '-') return eat_return(DECRE_S);
  371.             else if (look == '=') return eat_return(SUBAS_S);
  372.             else if (look == '>') return eat_return(DEREF_S);
  373.             else                             return MINUS_S;
  375.         case '/' :                              // '/*', '//', '/=', '/'
  376.             if (look == '*')
  377.                 {
  378.                 block_comment(CL_NONE);
  379.                 if (look == EOF)       // almost certainly a mistake:
  380.                     return ERROR_EOF_S;
  381.                 else continue;
  382.                 }
  383.             else if (look == '/')
  384.                 { line_comment(); continue; }
  385.             else if (look == '=') return eat_return(DIVAS_S);
  386.             else                             return SLASH_S;
  388.         case '.' :                              // ".", "..."
  389.             if (isdigit(look))      return num(ch);
  390.             else if (look == '.')
  391.                 {
  392.                 eat_one();          // check for "..", undefined.
  393.                 if (look != '.')    return ERROR_UNKN_S;
  394.                 else    return  eat_return(ELLIP_S);
  395.                 }
  396.             else                    return DOT_S;
  398.         case '<' :                              // '<=', '<', '<<', '<<='
  399.             if      (look == '=')   return eat_return(LE_S);
  400.             else if (look == '<')
  401.                 {
  402.                 eat_one();
  403.                 if  (look != '=')   return SHL_S;
  404.                 else     return eat_return(SHLAS_S);
  405.                 }
  406.             else                    return LT_S;
  408.         case '>' :                              // '>=', '>', '>>', '>>='
  409.             if      (look == '=')   return eat_return(GE_S);
  410.             else if (look == '>')
  411.                 {
  412.                 eat_one();
  413.                 if  (look != '=')   return SHR_S;
  414.                 else     return eat_return(SHRAS_S);
  415.                 }
  416.             else                    return GT_S;
  418.         default:
  419.             if (isalpha(ch))
  420.                 return ident(ch);
  421.             if (ch == 'n')
  422.                 eoln(CL_NONE);
  423.             else if (iscntrl(ch))
  424.                 continue;
  425.             else
  426.                 return ERROR_UNKN_S;
  427.             }
  428.         }
  430.     return EOF_S;
  431.     }
  433. struct Quickbuf
  434.     {
  435.     short len;
  436.     char line[10240];
  437.     void put_in(char c) { if (len < sizeof(line)-1) line[len++] = c; }
  438.     void terminate()    { line[len] = ''; }
  439.     Quickbuf() { len = 0; }
  440.     };
  442. void Clex::
  443. eoln(Clex_mode m)
  444.     {
  445.     // assume NL character already eaten.
  446.     ++line_num;
  447.     // don't process '#' lines in quotes, comments, or '#' continuations.
  448.     if (m & (CL_QUOTE|CL_POUND|CL_COMMENT))
  449.         return;
  451.     // eat whitespace
  452.     while (look != EOF && look != 'n')
  453.         {
  454.         if (look == ' ' || iscntrl(char(look))) eat_one();
  455.         else break;
  456.         }
  457.     if (look != '#')
  458.         return;
  460.     // eat the '#' and subsequent whitespace
  461.     do { eat_one(); if (look == EOF || look == 'n') break; }
  462.        while (look == ' ' || iscntrl(char(look)));
  464.     // collect the '#' line
  465.     Quickbuf b;
  466.     do  {   // record line
  467.         if (look == '\')       // check for continuation line
  468.             {
  469.             eat_one();
  470.             if (look == 'n') { eat_one(); eoln(m|CL_POUND); }
  471.             else { b.put_in('\'); }
  472.             }
  473.         else if (look == '/')   // check for comment in '#' line
  474.             {
  475.             eat_one();
  476.             if (look == '*')
  477.                 {
  478.                 block_comment(m|CL_POUND);
  479.                 if (look == EOF) break;
  480.                 }
  481.             else if (look == '/') line_comment();
  482.             else { b.put_in('/'); }
  483.             }
  484.         else
  485.             {
  486.             if (iscntrl(char(look))) look = ' ';
  487.             b.put_in(look);
  488.             eat_one();
  489.             }
  490.  
  491.         } while (look != 'n' && look != EOF);
  492.     b.terminate();
  494.     (void) pound(m, b.line, b.len);     // call virtual handler
  495.     }
  497. Boolean Clex::
  498. pound (Clex_mode m, char* line, short len)
  499.     {
  500.     void(m);                // to keep cfront blissful
  501.     char* cp = line;
  502.     if (!isdigit(*cp))
  503.         {
  504.         if (len < 5) return FALSE;
  505.         if (strncmp(cp, "line ", 5) != 0)
  506.             return FALSE;   // don't know what it is
  507.         cp += 4;
  508.         while (*cp == ' ') ++cp;
  509.         if (!isdigit(*cp))
  510.             return FALSE;
  511.         }
  513.     // # <line> "<filename>"   or    #line <line> "<filename>"
  514.     line_num = atoi(cp) - 1;    // will be incremented by eoln() later
  515.     while (isdigit(*cp)) ++cp;
  516.     while (*cp == ' ')   ++cp;
  517.     if (*cp == '"')
  518.         {
  519.         char* cpq = cp;
  520.         do { ++cpq; }
  521.            while (*cpq != '"' && *cpq != '');
  522.         strncpy(filename, cp+1, cpq - cp - 1);
  523.         filename[cpq - cp - 1] = '';
  524.         }
  526.     return TRUE;
  527.     }
  529. const char* Clex::
  530. debug (Clex_sym s)
  531.     {
  532.     return (s >= KEYWORD_S) ? keywords[s - KEYWORD_S] : sym_str[s] ;
  533.     }