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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
wslexer.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：33k
源码类别：

手机WAP编程

开发平台：

WINDOWS

wslexer.c：源码内容
  1. /*
  2.  *
  3.  * wslexer.c
  4.  *
  5.  * Author: Markku Rossi <mtr@iki.fi>
  6.  *
  7.  * Copyright (c) 1999-2000 WAPIT OY LTD.
  8.  *  All rights reserved.
  9.  *
  10.  * Lexical analyzer.
  11.  *
  12.  */
  14. #include "wsint.h"
  15. #include "wsstree.h"
  16. #include "wsgram.h"
  18. /********************* Types and definitions ****************************/
  20. /* A predicate to check whether the character `ch' is a decimal
  21.    digit. */
  22. #define WS_IS_DECIMAL_DIGIT(ch) ('0' <= (ch) && (ch) <= '9')
  24. /* Convert the decimal digit `ch' to an integer number. */
  25. #define WS_DECIMAL_TO_INT(ch) ((ch) - '0')
  27. /* A predicate to check whether the character `ch' is a non-zero
  28.    decimal digit. */
  29. #define WS_IS_NON_ZERO_DIGIT(ch) ('1' <= (ch) && (ch) <= '9')
  31. /* A predicate to check whether the character `ch' is an octal digit. */
  32. #define WS_IS_OCTAL_DIGIT(ch) ('0' <= (ch) && (ch) <= '7')
  34. /* Convert the octal digit `ch' to an integer number. */
  35. #define WS_OCTAL_TO_INT(ch) ((ch) - '0')
  37. /* A predicate to check whether the character `ch' is a hex digit. */
  38. #define WS_IS_HEX_DIGIT(ch) (('0' <= (ch) && (ch) <= '9')
  39.                              || ('a' <= (ch) && (ch) <= 'f')
  40.                              || ('A' <= (ch) && (ch) <= 'F'))
  42. /* Convert the hex digit `ch' to an integer number. */
  43. #define WS_HEX_TO_INT(ch)
  44.     ('0' <= (ch) && (ch) <= '9'
  45.      ? ((ch) - '0')
  46.      : ('a' <= (ch) && (ch) <= 'f'
  47.        ? ((ch) - 'a' + 10)
  48.        : (ch) - 'A' + 10))
  50. /* A predicate to check whether the character `ch' is an identifier
  51.    starter letter. */
  52. #define WS_IS_IDENTIFIER_LETTER(ch)
  53.     (('a' <= (ch) && (ch) <= 'z')
  54.      || ('A' <= (ch) && (ch) <= 'Z')
  55.      || (ch) == '_')
  57. /********************* Prototypes for static functions ******************/
  59. /* Check whether the identifier `id', `len' is a keyword.  If the
  60.    identifier is a keyword, the function returns WS_TRUE and sets the
  61.    keywords token ID to `token_return'.  Otherwise the function
  62.    returns WS_FALSE. */
  63. static WsBool lookup_keyword(char *id, size_t len, int *token_return);
  65. /* Convert literal integer number, stored to the buffer `buffer', into
  66.    a 32 bit integer number.  The function will report possible integer
  67.    overflows to the compiler `compiler'.  The function modifies the
  68.    contents of the buffer `buffer' but it does not free it. */
  69. static WsUInt32 buffer_to_int(WsCompilerPtr compiler, WsBuffer *buffer);
  71. /* Read a floating point number from the decimal point to the buffer
  72.    `buffer'.  The buffer `buffer' might already contain some leading
  73.    digits of the number and it always contains the decimal point.  If
  74.    the operation is successful, the function returns WS_TRUE and it
  75.    returns the resulting floating point number in `result'.  Otherwise
  76.    the function returns WS_FALSE.  The buffer `buffer' must be
  77.    initialized before this function is called and it must be
  78.    uninitialized by the caller. */
  79. static WsBool read_float_from_point(WsCompiler *compiler, WsBuffer *buffer,
  80.                                     WsFloat *result);
  82. /* Read a floating point number from the exponent part to the buffer
  83.    `buffer'.  The buffer might already contain some leading digits and
  84.    fields of the floating poit number.  Otherwise, the function works
  85.    like read_float_from_point(). */
  86. static WsBool read_float_from_exp(WsCompiler *compiler, WsBuffer *buffer,
  87.                                   WsFloat *result);
  89. /********************* Static variables *********************************/
  91. /* A helper macro which expands to a strings and its length excluding
  92.    the trailing '' character. */
  93. #define N(n) n, sizeof(n) - 1
  95. /* They keywords of the WMLScript language.  This array must be sorted
  96.    by the keyword names. */
  97. static struct
  98. {
  99.     char *name;
  100.     size_t name_len;
  101.     int token;
  102. } keywords[] = {
  103.         {N("access"), tACCESS},
  104.         {N("agent"), tAGENT},
  105.         {N("break"), tBREAK},
  106.         {N("case"), tCASE},
  107.         {N("catch"), tCATCH},
  108.         {N("class"), tCLASS},
  109.         {N("const"), tCONST},
  110.         {N("continue"), tCONTINUE},
  111.         {N("debugger"), tDEBUGGER},
  112.         {N("default"), tDEFAULT},
  113.         {N("delete"), tDELETE},
  114.         {N("div"), tIDIV},
  115.         {N("do"), tDO},
  116.         {N("domain"), tDOMAIN},
  117.         {N("else"), tELSE},
  118.         {N("enum"), tENUM},
  119.         {N("equiv"), tEQUIV},
  120.         {N("export"), tEXPORT},
  121.         {N("extends"), tEXTENDS},
  122.         {N("extern"), tEXTERN},
  123.         {N("false"), tFALSE},
  124.         {N("finally"), tFINALLY},
  125.         {N("for"), tFOR},
  126.         {N("function"), tFUNCTION},
  127.         {N("header"), tHEADER},
  128.         {N("http"), tHTTP},
  129.         {N("if"), tIF},
  130.         {N("import"), tIMPORT},
  131.         {N("in"), tIN},
  132.         {N("invalid"), tINVALID},
  133.         {N("isvalid"), tISVALID},
  134.         {N("lib"), tLIB},
  135.         {N("meta"), tMETA},
  136.         {N("name"), tNAME},
  137.         {N("new"), tNEW},
  138.         {N("null"), tNULL},
  139.         {N("path"), tPATH},
  140.         {N("private"), tPRIVATE},
  141.         {N("public"), tPUBLIC},
  142.         {N("return"), tRETURN},
  143.         {N("sizeof"), tSIZEOF},
  144.         {N("struct"), tSTRUCT},
  145.         {N("super"), tSUPER},
  146.         {N("switch"), tSWITCH},
  147.         {N("this"), tTHIS},
  148.         {N("throw"), tTHROW},
  149.         {N("true"), tTRUE},
  150.         {N("try"), tTRY},
  151.         {N("typeof"), tTYPEOF},
  152.         {N("url"), tURL},
  153.         {N("use"), tUSE},
  154.         {N("user"), tUSER},
  155.         {N("var"), tVAR},
  156.         {N("void"), tVOID},
  157.         {N("while"), tWHILE},
  158.         {N("with"), tWITH},
  159. };
  161. static int num_keywords = sizeof(keywords) / sizeof(keywords[0]);
  163. /********************* Global functions *********************************/
  165. int ws_yy_lex(YYSTYPE *yylval, YYLTYPE *yylloc, void *context)
  166. {
  167.     WsCompiler *compiler = (WsCompiler *) context;
  168.     WsUInt32 ch, ch2;
  169.     WsBuffer buffer;
  170.     unsigned char *p;
  171.     WsBool success;
  173.     /* Just check that we get the correct amount of arguments. */
  174.     gw_assert(compiler->magic == COMPILER_MAGIC);
  176.     while (ws_stream_getc(compiler->input, &ch)) {
  177.         /* Save the token's line number. */
  178.         yylloc->first_line = compiler->linenum;
  180.         switch (ch) {
  181.         case 't':  /* Whitespace characters. */
  182.         case 'v':
  183.         case 'f':
  184.         case ' ':
  185.             continue;
  187.         case 'n':  /* Line terminators. */
  188.         case 'r':
  189.             if (ch == 'r' && ws_stream_getc(compiler->input, &ch2)) {
  190.                 if (ch2 != 'n')
  191.                     ws_stream_ungetc(compiler->input, ch2);
  192.             }
  193.             compiler->linenum++;
  194.             continue;
  196.         case '!':  /* !, != */
  197.             if (ws_stream_getc(compiler->input, &ch2)) {
  198.                 if (ch2 == '=')
  199.                     return tNE;
  201.                 ws_stream_ungetc(compiler->input, ch2);
  202.             }
  203.             return '!';
  205.         case '%':  /* %, %= */
  206.             if (ws_stream_getc(compiler->input, &ch2)) {
  207.                 if (ch2 == '=')
  208.                     return tREMA;
  210.                 ws_stream_ungetc(compiler->input, ch2);
  211.             }
  212.             return '%';
  214.         case '&':  /* &, &&, &= */
  215.             if (ws_stream_getc(compiler->input, &ch2)) {
  216.                 if (ch2 == '&')
  217.                     return tAND;
  218.                 if (ch2 == '=')
  219.                     return tANDA;
  221.                 ws_stream_ungetc(compiler->input, ch2);
  222.             }
  223.             return '&';
  225.         case '*':  /* *, *= */
  226.             if (ws_stream_getc(compiler->input, &ch2)) {
  227.                 if (ch2 == '=')
  228.                     return tMULA;
  230.                 ws_stream_ungetc(compiler->input, ch2);
  231.             }
  232.             return '*';
  234.         case '+':  /* +, ++, += */
  235.             if (ws_stream_getc(compiler->input, &ch2)) {
  236.                 if (ch2 == '+')
  237.                     return tPLUSPLUS;
  238.                 if (ch2 == '=')
  239.                     return tADDA;
  241.                 ws_stream_ungetc(compiler->input, ch2);
  242.             }
  243.             return '+';
  245.         case '-':  /* -, --, -= */
  246.             if (ws_stream_getc(compiler->input, &ch2)) {
  247.                 if (ch2 == '-')
  248.                     return tMINUSMINUS;
  249.                 if (ch2 == '=')
  250.                     return tSUBA;
  252.                 ws_stream_ungetc(compiler->input, ch2);
  253.             }
  254.             return '-';
  256.         case '.':
  257.             if (ws_stream_getc(compiler->input, &ch2)) {
  258.                 if (WS_IS_DECIMAL_DIGIT(ch2)) {
  259.                     /* DecimalFloatLiteral. */
  260.                     ws_buffer_init(&buffer);
  262.                     if (!ws_buffer_append_space(&buffer, &p, 2)) {
  263.                         ws_error_memory(compiler);
  264.                         ws_buffer_uninit(&buffer);
  265.                         return EOF;
  266.                     }
  268.                     p[0] = '.';
  269.                     p[1] = (unsigned char) ch2;
  271.                     success = read_float_from_point(compiler, &buffer,
  272.                                                     &yylval->vfloat);
  273.                     ws_buffer_uninit(&buffer);
  275.                     if (!success)
  276.                         return EOF;
  278.                     return tFLOAT;
  279.                 }
  281.                 ws_stream_ungetc(compiler->input, ch2);
  282.             }
  283.             return '.';
  285.         case '/':  /* /, /=, block or a single line comment */
  286.             if (ws_stream_getc(compiler->input, &ch2)) {
  287.                 if (ch2 == '*') {
  288.                     /* Block comment. */
  289.                     while (1) {
  290.                         if (!ws_stream_getc(compiler->input, &ch)) {
  291.                             ws_src_error(compiler, 0, "EOF in comment");
  292.                             return EOF;
  293.                         }
  295.                         if (ch == 'n' || ch == 'r') {
  296.                             /* Line terminators. */
  297.                             if (ch == 'r' && ws_stream_getc(compiler->input,
  298.                                                              &ch2)) {
  299.                                 if (ch2 != 'n')
  300.                                     ws_stream_ungetc(compiler->input, ch2);
  301.                             }
  302.                             compiler->linenum++;
  304.                             /* Continue reading the block comment. */
  305.                             continue;
  306.                         }
  308.                         if (ch == '*' && ws_stream_getc(compiler->input, &ch2)) {
  309.                             if (ch2 == '/')
  310.                                 /* The end of the comment found. */
  311.                                 break;
  312.                             ws_stream_ungetc(compiler->input, ch2);
  313.                         }
  314.                     }
  315.                     /* Continue after the comment. */
  316.                     continue;
  317.                 }
  318.                 if (ch2 == '/') {
  319.                     /* Single line comment. */
  320.                     while (1) {
  321.                         if (!ws_stream_getc(compiler->input, &ch))
  322.                             /* The end of input stream reached.  We accept
  323.                                this as a valid comment terminator. */
  324.                             break;
  326.                         if (ch == 'n' || ch == 'r') {
  327.                             /* Line terminators. */
  328.                             if (ch == 'r' && ws_stream_getc(compiler->input,
  329.                                                              &ch2)) {
  330.                                 if (ch2 != 'n')
  331.                                     ws_stream_ungetc(compiler->input, ch2);
  332.                             }
  333.                             /* The end of the line (and the comment)
  334.                                                     reached. */
  335.                             compiler->linenum++;
  336.                             break;
  337.                         }
  338.                     }
  339.                     /* Continue after the comment. */
  340.                     continue;
  341.                 }
  342.                 if (ch2 == '=')
  343.                     return tDIVA;
  345.                 ws_stream_ungetc(compiler->input, ch2);
  346.             }
  347.             return '/';
  349.         case '<':  /* <, <<, <<=, <= */
  350.             if (ws_stream_getc(compiler->input, &ch2)) {
  351.                 if (ch2 == '<') {
  352.                     if (ws_stream_getc(compiler->input, &ch2)) {
  353.                         if (ch2 == '=')
  354.                             return tLSHIFTA;
  356.                         ws_stream_ungetc(compiler->input, ch2);
  357.                     }
  358.                     return tLSHIFT;
  359.                 }
  360.                 if (ch2 == '=')
  361.                     return tLE;
  363.                 ws_stream_ungetc(compiler->input, ch2);
  364.             }
  365.             return '<';
  367.         case '=':  /* =, == */
  368.             if (ws_stream_getc(compiler->input, &ch2)) {
  369.                 if (ch2 == '=')
  370.                     return tEQ;
  372.                 ws_stream_ungetc(compiler->input, ch2);
  373.             }
  374.             return '=';
  376.         case '>':  /* >, >=, >>, >>=, >>>, >>>= */
  377.             if (ws_stream_getc(compiler->input, &ch2)) {
  378.                 if (ch2 == '>') {
  379.                     if (ws_stream_getc(compiler->input, &ch2)) {
  380.                         if (ch2 == '>') {
  381.                             if (ws_stream_getc(compiler->input, &ch2)) {
  382.                                 if (ch2 == '=')
  383.                                     return tRSZSHIFTA;
  385.                                 ws_stream_ungetc(compiler->input, ch2);
  386.                             }
  387.                             return tRSZSHIFT;
  388.                         }
  389.                         if (ch2 == '=')
  390.                             return tRSSHIFTA;
  392.                         ws_stream_ungetc(compiler->input, ch2);
  393.                     }
  394.                     return tRSSHIFT;
  395.                 }
  396.                 if (ch2 == '=')
  397.                     return tGE;
  399.                 ws_stream_ungetc(compiler->input, ch2);
  400.             }
  401.             return '>';
  403.         case '^':  /* ^, ^= */
  404.             if (ws_stream_getc(compiler->input, &ch2)) {
  405.                 if (ch2 == '=')
  406.                     return tXORA;
  408.                 ws_stream_ungetc(compiler->input, ch2);
  409.             }
  410.             return '^';
  412.         case '|':  /* |, |=, || */
  413.             if (ws_stream_getc(compiler->input, &ch2)) {
  414.                 if (ch2 == '=')
  415.                     return tORA;
  416.                 if (ch2 == '|')
  417.                     return tOR;
  419.                 ws_stream_ungetc(compiler->input, ch2);
  420.             }
  421.             return '|';
  423.         case '#':  /* The simple cases. */
  424.         case '(':
  425.         case ')':
  426.         case ',':
  427.         case ':':
  428.         case ';':
  429.         case '?':
  430.         case '{':
  431.         case '}':
  432.         case '~':
  433.             return (int) ch;
  435.         case ''':  /* String literals. */
  436.         case '"':
  437.             {
  438.                 WsUInt32 string_end_ch = ch;
  439.                 WsUtf8String *str = ws_utf8_alloc();
  441.                 if (str == NULL) {
  442.                     ws_error_memory(compiler);
  443.                     return EOF;
  444.                 }
  446.                 while (1) {
  447.                     if (!ws_stream_getc(compiler->input, &ch)) {
  448. eof_in_string_literal:
  449.                         ws_src_error(compiler, 0, "EOF in string literal");
  450.                         ws_utf8_free(str);
  451.                         return EOF;
  452.                     }
  453.                     if (ch == string_end_ch)
  454.                         /* The end of string reached. */
  455.                         break;
  457.                     if (ch == '\') {
  458.                         /* An escape sequence. */
  459.                         if (!ws_stream_getc(compiler->input, &ch))
  460.                             goto eof_in_string_literal;
  462.                         switch (ch) {
  463.                         case ''':
  464.                         case '"':
  465.                         case '\':
  466.                         case '/':
  467.                             /* The character as-is. */
  468.                             break;
  470.                         case 'b':
  471.                             ch = 'b';
  472.                             break;
  474.                         case 'f':
  475.                             ch = 'f';
  476.                             break;
  478.                         case 'n':
  479.                             ch = 'n';
  480.                             break;
  482.                         case 'r':
  483.                             ch = 'r';
  484.                             break;
  486.                         case 't':
  487.                             ch = 't';
  488.                             break;
  490.                         case 'x':
  491.                         case 'u':
  492.                             {
  493.                                 int i, len;
  494.                                 int type = ch;
  496.                                 if (ch == 'x')
  497.                                     len = 2;
  498.                                 else
  499.                                     len = 4;
  501.                                 ch = 0;
  502.                                 for (i = 0; i < len; i++) {
  503.                                     if (!ws_stream_getc(compiler->input, &ch2))
  504.                                         goto eof_in_string_literal;
  505.                                     if (!WS_IS_HEX_DIGIT(ch2)) {
  506.                                         ws_src_error(compiler, 0,
  507.                                                      "malformed `\%c' escape in "
  508.                                                      "string literal", (char) type);
  509.                                         ch = 0;
  510.                                         break;
  511.                                     }
  512.                                     ch *= 16;
  513.                                     ch += WS_HEX_TO_INT(ch2);
  514.                                 }
  515.                             }
  516.                             break;
  518.                         default:
  519.                             if (WS_IS_OCTAL_DIGIT(ch)) {
  520.                                 int i;
  521.                                 int limit = 3;
  523.                                 ch = WS_OCTAL_TO_INT(ch);
  524.                                 if (ch > 3)
  525.                                     limit = 2;
  527.                                 for (i = 1; i < limit; i++) {
  528.                                     if (!ws_stream_getc(compiler->input, &ch2))
  529.                                         goto eof_in_string_literal;
  530.                                     if (!WS_IS_OCTAL_DIGIT(ch2)) {
  531.                                         ws_stream_ungetc(compiler->input, ch2);
  532.                                         break;
  533.                                     }
  535.                                     ch *= 8;
  536.                                     ch += WS_OCTAL_TO_INT(ch2);
  537.                                 }
  538.                             } else {
  539.                                 ws_src_error(compiler, 0,
  540.                                              "unknown escape sequence `\%c' in "
  541.                                              "string literal", (char) ch);
  542.                                 ch = 0;
  543.                             }
  544.                             break;
  545.                         }
  546.                         /* FALLTHROUGH */
  547.                     }
  549.                     if (!ws_utf8_append_char(str, ch)) {
  550.                         ws_error_memory(compiler);
  551.                         ws_utf8_free(str);
  552.                         return EOF;
  553.                     }
  554.                 }
  556.                 if (!ws_lexer_register_utf8(compiler, str)) {
  557.                     ws_error_memory(compiler);
  558.                     ws_utf8_free(str);
  559.                     return EOF;
  560.                 }
  562.                 gw_assert(str != NULL);
  563.                 yylval->string = str;
  565.                 return tSTRING;
  566.             }
  567.             break;
  569.         default:
  570.             /* Identifiers, keywords and number constants. */
  572.             if (WS_IS_IDENTIFIER_LETTER(ch)) {
  573.                 WsBool got;
  574.                 int token;
  575.                 unsigned char *p;
  576.                 unsigned char *np;
  577.                 size_t len = 0;
  579.                 /* An identifier or a keyword.  We start with a 256
  580.                  * bytes long buffer but it is expanded dynamically if
  581.                  * needed.  However, 256 should be enought for most
  582.                  * cases since the byte-code format limits the function
  583.                  * names to 255 characters. */
  584.                 p = ws_malloc(256);
  585.                 if (p == NULL) {
  586.                     ws_error_memory(compiler);
  587.                     return EOF;
  588.                 }
  590.                 do {
  591.                     /* Add one extra for the possible terminator
  592.                        character. */
  593.                     np = ws_realloc(p, len + 2);
  594.                     if (np == NULL) {
  595.                         ws_error_memory(compiler);
  596.                         ws_free(p);
  597.                         return EOF;
  598.                     }
  600.                     p = np;
  602.                     /* This is ok since the only valid identifier names
  603.                      * can be written in 7 bit ASCII. */
  604.                     p[len++] = (unsigned char) ch;
  605.                 } while ((got = ws_stream_getc(compiler->input, &ch))
  606.                          && (WS_IS_IDENTIFIER_LETTER(ch)
  607.                              || WS_IS_DECIMAL_DIGIT(ch)));
  609.                 if (got)
  610.                     /* Put back the terminator character. */
  611.                     ws_stream_ungetc(compiler->input, ch);
  613.                 /* Is it a keyword? */
  614.                 if (lookup_keyword((char *) p, len, &token)) {
  615.                     /* Yes it is... */
  616.                     ws_free(p);
  618.                     /* ...except one case: `div='. */
  619.                     if (token == tIDIV) {
  620.                         if (ws_stream_getc(compiler->input, &ch)) {
  621.                             if (ch == '=')
  622.                                 return tIDIVA;
  624.                             ws_stream_ungetc(compiler->input, ch);
  625.                         }
  626.                     }
  628.                     /* Return the token value. */
  629.                     return token;
  630.                 }
  632.                 /* It is a normal identifier.  Let's pad the name with a
  633.                           null-character.  We have already allocated space for
  634.                           it. */
  635.                 p[len] = '';
  637.                 if (!ws_lexer_register_block(compiler, p)) {
  638.                     ws_error_memory(compiler);
  639.                     ws_free(p);
  640.                     return EOF;
  641.                 }
  643.                 gw_assert(p != NULL);
  644.                 yylval->identifier = (char *) p;
  646.                 return tIDENTIFIER;
  647.             }
  649.             if (WS_IS_NON_ZERO_DIGIT(ch)) {
  650.                 /* A decimal integer literal or a decimal float
  651.                           literal. */
  653.                 ws_buffer_init(&buffer);
  654.                 if (!ws_buffer_append_space(&buffer, &p, 1)) {
  655. number_error_memory:
  656.                     ws_error_memory(compiler);
  657.                     ws_buffer_uninit(&buffer);
  658.                     return EOF;
  659.                 }
  660.                 p[0] = ch;
  662.                 while (ws_stream_getc(compiler->input, &ch)) {
  663.                     if (WS_IS_DECIMAL_DIGIT(ch)) {
  664.                         if (!ws_buffer_append_space(&buffer, &p, 1))
  665.                             goto number_error_memory;
  666.                         p[0] = ch;
  667.                     } else if (ch == '.' || ch == 'e' || ch == 'E') {
  668.                         /* DecimalFloatLiteral. */
  669.                         if (ch == '.') {
  670.                             if (!ws_buffer_append_space(&buffer, &p, 1))
  671.                                 goto number_error_memory;
  672.                             p[0] = '.';
  674.                             success = read_float_from_point(compiler, &buffer,
  675.                                                             &yylval->vfloat);
  676.                         } else {
  677.                             ws_stream_ungetc(compiler->input, ch);
  679.                             success = read_float_from_exp(compiler, &buffer,
  680.                                                           &yylval->vfloat);
  681.                         }
  682.                         ws_buffer_uninit(&buffer);
  684.                         if (!success)
  685.                             return EOF;
  687.                         return tFLOAT;
  688.                     } else {
  689.                         ws_stream_ungetc(compiler->input, ch);
  690.                         break;
  691.                     }
  692.                 }
  694.                 /* Now the buffer contains an integer number as a
  695.                           string.  Let's convert it to an integer number. */
  696.                 yylval->integer = buffer_to_int(compiler, &buffer);
  697.                 ws_buffer_uninit(&buffer);
  699.                 /* Read a DecimalIntegerLiteral. */
  700.                 return tINTEGER;
  701.             }
  703.             if (ch == '0') {
  704.                 /* The integer constant 0, an octal number or a
  705.                    HexIntegerLiteral. */
  706.                 if (ws_stream_getc(compiler->input, &ch2)) {
  707.                     if (ch2 == 'x' || ch2 == 'X') {
  708.                         /* HexIntegerLiteral. */
  710.                         ws_buffer_init(&buffer);
  711.                         if (!ws_buffer_append_space(&buffer, &p, 2))
  712.                             goto number_error_memory;
  714.                         p[0] = '0';
  715.                         p[1] = 'x';
  717.                         while (ws_stream_getc(compiler->input, &ch)) {
  718.                             if (WS_IS_HEX_DIGIT(ch)) {
  719.                                 if (!ws_buffer_append_space(&buffer, &p, 1))
  720.                                     goto number_error_memory;
  721.                                 p[0] = ch;
  722.                             } else {
  723.                                 ws_stream_ungetc(compiler->input, ch);
  724.                                 break;
  725.                             }
  726.                         }
  728.                         if (ws_buffer_len(&buffer) == 2) {
  729.                             ws_buffer_uninit(&buffer);
  730.                             ws_src_error(compiler, 0,
  731.                                          "numeric constant with no digits");
  732.                             yylval->integer = 0;
  733.                             return tINTEGER;
  734.                         }
  736.                         /* Now the buffer contains an integer number as
  737.                          * a string.  Let's convert it to an integer
  738.                          * number. */
  739.                         yylval->integer = buffer_to_int(compiler, &buffer);
  740.                         ws_buffer_uninit(&buffer);
  742.                         /* Read a HexIntegerLiteral. */
  743.                         return tINTEGER;
  744.                     }
  745.                     if (WS_IS_OCTAL_DIGIT(ch2)) {
  746.                         /* OctalIntegerLiteral. */
  748.                         ws_buffer_init(&buffer);
  749.                         if (!ws_buffer_append_space(&buffer, &p, 2))
  750.                             goto number_error_memory;
  752.                         p[0] = '0';
  753.                         p[1] = ch2;
  755.                         while (ws_stream_getc(compiler->input, &ch)) {
  756.                             if (WS_IS_OCTAL_DIGIT(ch)) {
  757.                                 if (!ws_buffer_append_space(&buffer, &p, 1))
  758.                                     goto number_error_memory;
  759.                                 p[0] = ch;
  760.                             } else {
  761.                                 ws_stream_ungetc(compiler->input, ch);
  762.                                 break;
  763.                             }
  764.                         }
  766.                         /* Convert the buffer into an intger number. */
  767.                         yylval->integer = buffer_to_int(compiler, &buffer);
  768.                         ws_buffer_uninit(&buffer);
  770.                         /* Read an OctalIntegerLiteral. */
  771.                         return tINTEGER;
  772.                     }
  773.                     if (ch2 == '.' || ch2 == 'e' || ch2 == 'E') {
  774.                         /* DecimalFloatLiteral. */
  775.                         ws_buffer_init(&buffer);
  777.                         if (ch2 == '.') {
  778.                             if (!ws_buffer_append_space(&buffer, &p, 1))
  779.                                 goto number_error_memory;
  780.                             p[0] = '.';
  782.                             success = read_float_from_point(compiler, &buffer,
  783.                                                             &yylval->vfloat);
  784.                         } else {
  785.                             ws_stream_ungetc(compiler->input, ch);
  787.                             success = read_float_from_exp(compiler, &buffer,
  788.                                                           &yylval->vfloat);
  789.                         }
  790.                         ws_buffer_uninit(&buffer);
  792.                         if (!success)
  793.                             return EOF;
  795.                         return tFLOAT;
  796.                     }
  798.                     ws_stream_ungetc(compiler->input, ch2);
  799.                 }
  801.                 /* Integer literal 0. */
  802.                 yylval->integer = 0;
  803.                 return tINTEGER;
  804.             }
  806.             /* Garbage found from the input stream. */
  807.             ws_src_error(compiler, 0,
  808.                          "garbage found from the input stream: character=0x%x",
  809.                          ch);
  810.             return EOF;
  811.             break;
  812.         }
  813.     }
  815.     return EOF;
  816. }
  818. /********************* Static functions *********************************/
  820. static WsBool lookup_keyword(char *id, size_t len, int *token_return)
  821. {
  822.     int left = 0, center, right = num_keywords;
  824.     while (left < right) {
  825.         size_t l;
  826.         int result;
  828.         center = left + (right - left) / 2;
  830.         l = keywords[center].name_len;
  831.         if (len < l)
  832.             l = len;
  834.         result = memcmp(id, keywords[center].name, l);
  835.         if (result < 0 || (result == 0 && len < keywords[center].name_len))
  836.             /* The possible match is smaller. */
  837.             right = center;
  838.         else if (result > 0 || (result == 0 && len > keywords[center].name_len))
  839.             /* The possible match is bigger. */
  840.             left = center + 1;
  841.         else {
  842.             /* Found a match. */
  843.             *token_return = keywords[center].token;
  844.             return WS_TRUE;
  845.         }
  846.     }
  848.     /* No match. */
  849.     return WS_FALSE;
  850. }
  853. static WsUInt32 buffer_to_int(WsCompilerPtr compiler, WsBuffer *buffer)
  854. {
  855.     unsigned char *p;
  856.     unsigned long value;
  858.     /* Terminate the string. */
  859.     if (!ws_buffer_append_space(buffer, &p, 1)) {
  860.         ws_error_memory(compiler);
  861.         return 0;
  862.     }
  863.     p[0] = '';
  865.     /* Convert the buffer into an integer number.  The base is taken
  866.        from the bufer. */
  867.     errno = 0;
  868.     value = strtoul((char *) ws_buffer_ptr(buffer), NULL, 0);
  870.     /* Check for overflow.  We accept WS_INT32_MAX + 1 because we might
  871.      * be parsing the numeric part of '-2147483648'. */
  872.     if (errno == ERANGE || value > (WsUInt32) WS_INT32_MAX + 1)
  873.         ws_src_error(compiler, 0, "integer literal too large");
  875.     /* All done. */
  876.     return (WsUInt32) value;
  877. }
  880. static WsBool read_float_from_point(WsCompiler *compiler, WsBuffer *buffer,
  881.                                     WsFloat *result)
  882. {
  883.     WsUInt32 ch;
  884.     unsigned char *p;
  886.     while (ws_stream_getc(compiler->input, &ch)) {
  887.         if (WS_IS_DECIMAL_DIGIT(ch)) {
  888.             if (!ws_buffer_append_space(buffer, &p, 1)) {
  889.                 ws_error_memory(compiler);
  890.                 return WS_FALSE;
  891.             }
  892.             p[0] = (unsigned char) ch;
  893.         } else {
  894.             ws_stream_ungetc(compiler->input, ch);
  895.             break;
  896.         }
  897.     }
  899.     return read_float_from_exp(compiler, buffer, result);
  900. }
  903. static WsBool read_float_from_exp(WsCompiler *compiler, WsBuffer *buffer,
  904.                                   WsFloat *result)
  905. {
  906.     WsUInt32 ch;
  907.     unsigned char *p;
  908.     int sign = '+';
  909.     unsigned char buf[4];
  911.     /* Do we have an exponent part. */
  912.     if (!ws_stream_getc(compiler->input, &ch))
  913.         goto done;
  914.     if (ch != 'e' && ch != 'E') {
  915.         /* No exponent part. */
  916.         ws_stream_ungetc(compiler->input, ch);
  917.         goto done;
  918.     }
  920.     /* Sign. */
  921.     if (!ws_stream_getc(compiler->input, &ch)) {
  922.         /* This is an error. */
  923.         ws_src_error(compiler, 0, "truncated float literal");
  924.         return WS_FALSE;
  925.     }
  926.     if (ch == '-')
  927.         sign = '-';
  928.     else if (ch == '+')
  929.         sign = '+';
  930.     else
  931.         ws_stream_ungetc(compiler->input, ch);
  933.     /* DecimalDigits. */
  934.     if (!ws_stream_getc(compiler->input, &ch)) {
  935.         ws_src_error(compiler, 0, "truncated float literal");
  936.         return WS_FALSE;
  937.     }
  938.     if (!WS_IS_DECIMAL_DIGIT(ch)) {
  939.         ws_src_error(compiler, 0, "no decimal digits in exponent part");
  940.         return WS_FALSE;
  941.     }
  943.     /* Append exponent part read so far. */
  944.     if (!ws_buffer_append_space(buffer, &p, 2)) {
  945.         ws_error_memory(compiler);
  946.         return WS_FALSE;
  947.     }
  948.     p[0] = 'e';
  949.     p[1] = sign;
  951.     /* Read decimal digits. */
  952.     while (WS_IS_DECIMAL_DIGIT(ch)) {
  953.         if (!ws_buffer_append_space(buffer, &p, 1)) {
  954.             ws_error_memory(compiler);
  955.             return WS_FALSE;
  956.         }
  957.         p[0] = (unsigned char) ch;
  959.         if (!ws_stream_getc(compiler->input, &ch))
  960.             /* EOF.  This is ok. */
  961.             goto done;
  962.     }
  963.     /* Unget the extra character. */
  964.     ws_stream_ungetc(compiler->input, ch);
  966.     /* FALLTHROUGH */
  968. done:
  970.     if (!ws_buffer_append_space(buffer, &p, 1)) {
  971.         ws_error_memory(compiler);
  972.         return WS_FALSE;
  973.     }
  974.     p[0] = 0;
  976.     /* Now the buffer contains a valid floating point number. */
  977.     *result = (WsFloat) strtod((char *) ws_buffer_ptr(buffer), NULL);
  979.     /* Check that the generated floating point number fits to
  980.        `float32'. */
  981.     if (*result == HUGE_VAL || *result == -HUGE_VAL
  982.         || ws_ieee754_encode_single(*result, buf) != WS_IEEE754_OK)
  983.         ws_src_error(compiler, 0, "floating point literal too large");
  985.     return WS_TRUE;
  986. }