One Level Up Top Level

userspace/kp_lex.c - ktap

Global variables defined

Functions defined

Macros defined

Source code

  1. /*
  2. * Lexical analyzer.
  3. *
  4. * This file is part of ktap by Jovi Zhangwei.
  5. *
  6. * Copyright (C) 2012-2014 Jovi Zhangwei <jovi.zhangwei@gmail.com>.
  7. *
  8. * Adapted from luajit and lua interpreter.
  9. * Copyright (C) 2005-2014 Mike Pall.
  10. * Copyright (C) 1994-2008 Lua.org, PUC-Rio.
  11. *
  12. * ktap is free software; you can redistribute it and/or modify it
  13. * under the terms and conditions of the GNU General Public License,
  14. * version 2, as published by the Free Software Foundation.
  15. *
  16. * ktap is distributed in the hope it will be useful, but WITHOUT
  17. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  19. * more details.
  20. *
  21. * You should have received a copy of the GNU General Public License along with
  22. * this program; if not, write to the Free Software Foundation, Inc.,
  23. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  24. */

  26. #include "../include/ktap_types.h"
  27. #include "../include/ktap_err.h"
  28. #include "kp_util.h"
  29. #include "kp_lex.h"
  30. #include "kp_parse.h"

  32. /* lexer token names. */
  33. ‌static const char *const tokennames[] = {
  34. ‌#define TKSTR1(name)        #name,
  35. ‌#define TKSTR2(name, sym)    #sym,
  36. TKDEF(TKSTR1, TKSTR2)
  37. ‌#undef TKSTR1
  38. ‌#undef TKSTR2
  39.   NULL
  40. };

  42. /* -- Buffer handling ----------------------------------------------------- */

  44. ‌#define LEX_EOF            (-1)
  45. ‌#define lex_iseol(ls)        (ls->c == '\n' || ls->c == '\r')

  47. /* Get next character. */
  48. ‌static inline LexChar lex_next(LexState *ls)
  49. {
  50.     return (ls->c = ls->p < ls->pe ? (LexChar)(uint8_t)*ls->p++ : LEX_EOF);
  51. }

  53. /* Save character. */
  54. ‌static inline void lex_save(LexState *ls, LexChar c)
  55. {
  56.     kp_buf_putb(&ls->sb, c);
  57. }

  59. /* Save previous character and get next character. */
  60. ‌static inline LexChar lex_savenext(LexState *ls)
  61. {
  62.     lex_save(ls, ls->c);
  63.     return lex_next(ls);
  64. }

  66. /* Skip line break. Handles "\n", "\r", "\r\n" or "\n\r". */
  67. ‌static void lex_newline(LexState *ls)
  68. {
  69.     LexChar old = ls->c;

  71.     kp_assert(lex_iseol(ls));
  72.     lex_next(ls);  /* Skip "\n" or "\r". */
  73.     if (lex_iseol(ls) && ls->c != old)
  74.         lex_next(ls);  /* Skip "\n\r" or "\r\n". */
  75.     if (++ls->linenumber >= KP_MAX_LINE)
  76.         kp_lex_error(ls, ls->tok, KP_ERR_XLINES);
  77. }

  79. /* -- Scanner for terminals ----------------------------------------------- */

  81. ‌static int kp_str2d(const char *s, size_t len, ktap_number *result)
  82. {
  83.     char *endptr;

  85.     if (strpbrk(s, "nN"))  /* reject 'inf' and 'nan' */
  86.         return 0;
  87.     else
  88.         *result = (long)strtoul(s, &endptr, 0);

  90.     if (endptr == s)
  91.         return 0;  /* nothing recognized */
  92.     while (kp_char_isspace((unsigned char)(*endptr)))
  93.         endptr++;
  94.     return (endptr == s + len);  /* OK if no trailing characters */
  95. }


  98. /* Parse a number literal. */
  99. ‌static void lex_number(LexState *ls, ktap_val_t *tv)
  100. {
  101.     LexChar c, xp = 'e';
  102.     ktap_number n = 0;

  104.     kp_assert(kp_char_isdigit(ls->c));
  105.     if ((c = ls->c) == '0' && (lex_savenext(ls) | 0x20) == 'x')
  106.         xp = 'p';
  107.     while (kp_char_isident(ls->c) || ls->c == '.' ||
  108.         ((ls->c == '-' || ls->c == '+') && (c | 0x20) == xp)) {
  109.         c = ls->c;
  110.         lex_savenext(ls);
  111.     }
  112.     lex_save(ls, '\0');
  113.     if (!kp_str2d(sbufB(&ls->sb), sbuflen(&ls->sb) - 1, &n))
  114.             kp_lex_error(ls, ls->tok, KP_ERR_XNUMBER);
  115.     set_number(tv, n);
  116. }

  118. /* Skip equal signs for "[=...=[" and "]=...=]" and return their count. */
  119. ‌static int lex_skipeq(LexState *ls)
  120. {
  121.     int count = 0;
  122.     LexChar s = ls->c;

  124.     kp_assert(s == '[' || s == ']');
  125.     while (lex_savenext(ls) == '=')
  126.         count++;
  127.     return (ls->c == s) ? count : (-count) - 1;
  128. }

  130. /* Parse a long string or long comment (tv set to NULL). */
  131. ‌static void lex_longstring(LexState *ls, ktap_val_t *tv, int sep)
  132. {
  133.     lex_savenext(ls);  /* Skip second '['. */
  134.     if (lex_iseol(ls))  /* Skip initial newline. */
  135.         lex_newline(ls);
  136.     for (;;) {
  137.         switch (ls->c) {
  138.         case LEX_EOF:
  139.             kp_lex_error(ls, TK_eof,
  140.                     tv ? KP_ERR_XLSTR : KP_ERR_XLCOM);
  141.             break;
  142.         case ']':
  143.             if (lex_skipeq(ls) == sep) {
  144.                 lex_savenext(ls);  /* Skip second ']'. */
  145.                 goto endloop;
  146.             }
  147.             break;
  148.         case '\n':
  149.         case '\r':
  150.             lex_save(ls, '\n');
  151.             lex_newline(ls);
  152.             if (!tv) /* Don't waste space for comments. */
  153.                 kp_buf_reset(&ls->sb);
  154.             break;
  155.         default:
  156.             lex_savenext(ls);
  157.             break;
  158.         }
  159.     }
  160. endloop:
  161.     if (tv) {
  162.         ktap_str_t *str = kp_parse_keepstr(ls,
  163.                     sbufB(&ls->sb) + (2 + (int)sep),
  164.                     sbuflen(&ls->sb) - 2*(2 + (int)sep));
  165.         set_string(tv, str);
  166.     }
  167. }

  169. /* Parse a string. */
  170. ‌static void lex_string(LexState *ls, ktap_val_t *tv)
  171. {
  172.     LexChar delim = ls->c;  /* Delimiter is '\'' or '"'. */

  174.     lex_savenext(ls);
  175.     while (ls->c != delim) {
  176.         switch (ls->c) {
  177.         case LEX_EOF:
  178.             kp_lex_error(ls, TK_eof, KP_ERR_XSTR);
  179.             continue;
  180.         case '\n':
  181.         case '\r':
  182.             kp_lex_error(ls, TK_string, KP_ERR_XSTR);
  183.             continue;
  184.         case '\\': {
  185.             LexChar c = lex_next(ls);  /* Skip the '\\'. */
  186.             switch (c) {
  187.             case 'a': c = '\a'; break;
  188.             case 'b': c = '\b'; break;
  189.             case 'f': c = '\f'; break;
  190.             case 'n': c = '\n'; break;
  191.             case 'r': c = '\r'; break;
  192.             case 't': c = '\t'; break;
  193.             case 'v': c = '\v'; break;
  194.             case 'x':  /* Hexadecimal escape '\xXX'. */
  195.                 c = (lex_next(ls) & 15u) << 4;
  196.                 if (!kp_char_isdigit(ls->c)) {
  197.                     if (!kp_char_isxdigit(ls->c))
  198.                         goto err_xesc;
  199.                     c += 9 << 4;
  200.                 }
  201.                 c += (lex_next(ls) & 15u);
  202.                 if (!kp_char_isdigit(ls->c)) {
  203.                     if (!kp_char_isxdigit(ls->c))
  204.                         goto err_xesc;
  205.                     c += 9;
  206.                 }
  207.                 break;
  208.             case 'z':  /* Skip whitespace. */
  209.                 lex_next(ls);
  210.                 while (kp_char_isspace(ls->c))
  211.                     if (lex_iseol(ls))
  212.                         lex_newline(ls);
  213.                     else
  214.                         lex_next(ls);
  215.                     continue;
  216.             case '\n': case '\r':
  217.                 lex_save(ls, '\n');
  218.                 lex_newline(ls);
  219.                 continue;
  220.             case '\\': case '\"': case '\'':
  221.                 break;
  222.             case LEX_EOF:
  223.                 continue;
  224.             default:
  225.                 if (!kp_char_isdigit(c))
  226.                     goto err_xesc;
  227.                 c -= '0';  /* Decimal escape '\ddd'. */
  228.                 if (kp_char_isdigit(lex_next(ls))) {
  229.                     c = c*10 + (ls->c - '0');
  230.                     if (kp_char_isdigit(lex_next(ls))) {
  231.                         c = c*10 + (ls->c - '0');
  232.                         if (c > 255) {
  233. err_xesc:
  234.                             kp_lex_error(ls,
  235.                                 TK_string,
  236.                                 KP_ERR_XESC);
  237.                         }
  238.                         lex_next(ls);
  239.                     }
  240.                 }
  241.                 lex_save(ls, c);
  242.                 continue;
  243.             }
  244.             lex_save(ls, c);
  245.             lex_next(ls);
  246.             continue;
  247.         }
  248.         default:
  249.             lex_savenext(ls);
  250.             break;
  251.         }
  252.     }
  253.     lex_savenext(ls);  /* Skip trailing delimiter. */
  254.     set_string(tv,
  255.         kp_parse_keepstr(ls, sbufB(&ls->sb)+1, sbuflen(&ls->sb)-2));
  256. }

  258. /* lex helper for parse_trace and parse_timer */
  259. ‌void kp_lex_read_string_until(LexState *ls, int c)
  260. {
  261.     ktap_str_t *ts;

  263.     kp_buf_reset(&ls->sb);

  265.     while (ls->c == ' ')
  266.         lex_next(ls);

  268.     do {
  269.         lex_savenext(ls);
  270.     } while (ls->c != c && ls->c != LEX_EOF);

  272.     if (ls->c != c)
  273.         kp_lex_error(ls, ls->tok, KP_ERR_XTOKEN, c);

  275.     ts = kp_parse_keepstr(ls, sbufB(&ls->sb), sbuflen(&ls->sb));
  276.     ls->tok = TK_string;
  277.     set_string(&ls->tokval, ts);
  278. }


  281. /* -- Main lexical scanner ------------------------------------------------ */

  283. /* Get next lexical token. */
  284. ‌static LexToken lex_scan(LexState *ls, ktap_val_t *tv)
  285. {
  286.     kp_buf_reset(&ls->sb);
  287.     for (;;) {
  288.         if (kp_char_isident(ls->c)) {
  289.             ktap_str_t *s;
  290.             if (kp_char_isdigit(ls->c)) {  /* Numeric literal. */
  291.                 lex_number(ls, tv);
  292.                 return TK_number;
  293.             }
  294.             /* Identifier or reserved word. */
  295.             do {
  296.                 lex_savenext(ls);
  297.             } while (kp_char_isident(ls->c));
  298.             s = kp_parse_keepstr(ls, sbufB(&ls->sb),
  299.                         sbuflen(&ls->sb));
  300.             set_string(tv, s);
  301.             if (s->reserved > 0)  /* Reserved word? */
  302.                 return TK_OFS + s->reserved;
  303.             return TK_name;
  304.         }

  306.         switch (ls->c) {
  307.         case '\n':
  308.         case '\r':
  309.             lex_newline(ls);
  310.             continue;
  311.         case ' ':
  312.         case '\t':
  313.         case '\v':
  314.         case '\f':
  315.             lex_next(ls);
  316.             continue;

  318.         case '#':
  319.             while (!lex_iseol(ls) && ls->c != LEX_EOF)
  320.                 lex_next(ls);
  321.             break;
  322.         case '-':
  323.             lex_next(ls);
  324.             if (ls->c != '-')
  325.                 return '-';
  326.             lex_next(ls);
  327.             if (ls->c == '[') { /* Long comment "--[=*[...]=*]". */
  328.                 int sep = lex_skipeq(ls);
  329.                 /* `lex_skipeq' may dirty the buffer */
  330.                 kp_buf_reset(&ls->sb);
  331.                 if (sep >= 0) {
  332.                     lex_longstring(ls, NULL, sep);
  333.                     kp_buf_reset(&ls->sb);
  334.                     continue;
  335.                 }
  336.             }
  337.             /* Short comment "--.*\n". */
  338.             while (!lex_iseol(ls) && ls->c != LEX_EOF)
  339.                 lex_next(ls);
  340.             continue;
  341.         case '[': {
  342.             int sep = lex_skipeq(ls);
  343.             if (sep >= 0) {
  344.                 lex_longstring(ls, tv, sep);
  345.                 return TK_string;
  346.             } else if (sep == -1) {
  347.                 return '[';
  348.             } else {
  349.                 kp_lex_error(ls, TK_string, KP_ERR_XLDELIM);
  350.                 continue;
  351.             }
  352.         }
  353.         case '+': {
  354.             lex_next(ls);
  355.             if (ls->c != '=')
  356.                 return '+';
  357.             else {
  358.                 lex_next(ls);
  359.                 return TK_incr;
  360.             }
  361.         }
  362.         case '=':
  363.             lex_next(ls);
  364.             if (ls->c != '=')
  365.                 return '=';
  366.             else {
  367.                 lex_next(ls);
  368.                 return TK_eq;
  369.             }
  370.         case '<':
  371.             lex_next(ls);
  372.             if (ls->c != '=')
  373.                 return '<';
  374.             else {
  375.                 lex_next(ls);
  376.                 return TK_le;
  377.             }
  378.         case '>':
  379.             lex_next(ls);
  380.             if (ls->c != '=')
  381.                 return '>';
  382.             else {
  383.                 lex_next(ls);
  384.                 return TK_ge;
  385.             }
  386.         case '!':
  387.                   lex_next(ls);
  388.             if (ls->c != '=')
  389.                 return TK_not;
  390.             else {
  391.                 lex_next(ls);
  392.                 return TK_ne;
  393.             }
  394.         case ':':
  395.             lex_next(ls);
  396.             if (ls->c != ':')
  397.                 return ':';
  398.             else {
  399.                 lex_next(ls);
  400.                 return TK_label;
  401.             }
  402.         case '"':
  403.         case '\'':
  404.             lex_string(ls, tv);
  405.             return TK_string;
  406.         case '.':
  407.             if (lex_savenext(ls) == '.') {
  408.                 lex_next(ls);
  409.                 if (ls->c == '.') {
  410.                     lex_next(ls);
  411.                     return TK_dots;   /* ... */
  412.                 }
  413.                 return TK_concat;   /* .. */
  414.             } else if (!kp_char_isdigit(ls->c)) {
  415.                 return '.';
  416.             } else {
  417.                 lex_number(ls, tv);
  418.                 return TK_number;
  419.             }
  420.         case LEX_EOF:
  421.             return TK_eof;
  422.         case '&':
  423.             lex_next(ls);
  424.             if (ls->c != '&')
  425.                 return '&';
  426.             else {
  427.                 lex_next(ls);
  428.                 return TK_and;
  429.             }
  430.         case '|':
  431.             lex_next(ls);
  432.             if (ls->c != '|')
  433.                 return '|';
  434.             else {
  435.                 lex_next(ls);
  436.                 return TK_or;
  437.             }
  438.         default: {
  439.             LexChar c = ls->c;
  440.             lex_next(ls);
  441.             return c;  /* Single-char tokens (+ - / ...). */
  442.         }
  443.         }
  444.     }
  445. }

  447. /* -- Lexer API ----------------------------------------------------------- */

  449. /* Setup lexer state. */
  450. ‌int kp_lex_setup(LexState *ls, const char *str)
  451. {
  452.     ls->fs = NULL;
  453.     ls->pe = ls->p = NULL;
  454.     ls->p = str;
  455.     ls->pe = str + strlen(str);
  456.     ls->vstack = NULL;
  457.     ls->sizevstack = 0;
  458.     ls->vtop = 0;
  459.     ls->bcstack = NULL;
  460.     ls->sizebcstack = 0;
  461.     ls->lookahead = TK_eof;  /* No look-ahead token. */
  462.     ls->linenumber = 1;
  463.     ls->lastline = 1;
  464.     lex_next(ls);  /* Read-ahead first char. */
  465.     if (ls->c == 0xef && ls->p + 2 <= ls->pe &&
  466.         (uint8_t)ls->p[0] == 0xbb &&
  467.         (uint8_t)ls->p[1] == 0xbf) {/* Skip UTF-8 BOM (if buffered). */
  468.         ls->p += 2;
  469.         lex_next(ls);
  470.     }
  471.     if (ls->c == '#') {  /* Skip POSIX #! header line. */
  472.         do {
  473.             lex_next(ls);
  474.             if (ls->c == LEX_EOF)
  475.                 return 0;
  476.         } while (!lex_iseol(ls));
  477.         lex_newline(ls);
  478.     }
  479.     return 0;
  480. }

  482. /* Cleanup lexer state. */
  483. ‌void kp_lex_cleanup(LexState *ls)
  484. {
  485.     free(ls->bcstack);
  486.     free(ls->vstack);
  487.     kp_buf_free(&ls->sb);
  488. }

  490. /* Return next lexical token. */
  491. ‌void kp_lex_next(LexState *ls)
  492. {
  493.     ls->lastline = ls->linenumber;
  494.     if (ls->lookahead == TK_eof) {  /* No lookahead token? */
  495.         ls->tok = lex_scan(ls, &ls->tokval);  /* Get next token. */
  496.     } else {  /* Otherwise return lookahead token. */
  497.         ls->tok = ls->lookahead;
  498.         ls->lookahead = TK_eof;
  499.         ls->tokval = ls->lookaheadval;
  500.     }
  501. }

  503. /* Look ahead for the next token. */
  504. ‌LexToken kp_lex_lookahead(LexState *ls)
  505. {
  506.     kp_assert(ls->lookahead == TK_eof);
  507.     ls->lookahead = lex_scan(ls, &ls->lookaheadval);
  508.     return ls->lookahead;
  509. }

  511. /* Convert token to string. */
  512. ‌const char *kp_lex_token2str(LexState *ls, LexToken tok)
  513. {
  514.     if (tok > TK_OFS)
  515.         return tokennames[tok-TK_OFS-1];
  516.     else if (!kp_char_iscntrl(tok))
  517.         return kp_sprintf("%c", tok);
  518.     else
  519.         return kp_sprintf("char(%d)", tok);
  520. }

  522. /* Lexer error. */
  523. ‌void kp_lex_error(LexState *ls, LexToken tok, ErrMsg em, ...)
  524. {
  525.     const char *tokstr;
  526.     va_list argp;

  528.     if (tok == 0) {
  529.         tokstr = NULL;
  530.     } else if (tok == TK_name || tok == TK_string || tok == TK_number) {
  531.         lex_save(ls, '\0');
  532.         tokstr = sbufB(&ls->sb);
  533.     } else {
  534.         tokstr = kp_lex_token2str(ls, tok);
  535.     }

  537.     va_start(argp, em);
  538.     kp_err_lex(ls->chunkname, tokstr, ls->linenumber, em, argp);
  539.     va_end(argp);
  540. }

  542. /* Initialize strings for reserved words. */
  543. ‌void kp_lex_init()
  544. {
  545.     uint32_t i;

  547.     for (i = 0; i < TK_RESERVED; i++) {
  548.         ktap_str_t *s = kp_str_newz(tokennames[i]);
  549.         s->reserved = (uint8_t)(i+1);
  550.     }
  551. }

One Level Up Top Level