slash

lex.c (4269B)

---

 /*
  * lex.c -- simple enough dfa-based parser
  */
 
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
 
 #include "lex.h"
 #include "stat.h"
 
 #define MAX_STACK_SIZE 100
 
 typedef struct {
     tok_t stack[MAX_STACK_SIZE];
     int top;
 } token_stack_t;
 
 token_stack_t tokstack;
 
 static const int nkeyws = sizeof(kws) / sizeof(kws[0]);
 
 toktype_t
 lu_kw(const char *str)
 {
     for (int i = 0; i < nkeyws; i++) {
         if (strcmp(str, kws[i].name) == 0)
             return kws[i].type;
     }
     return TOK_IDENT;
 }
 
 static int cur = EOF;
 static int next = EOF;
 
 void
 lex_init(void)
 {
     cur = fgetc(stat.i_fstream);
     next = fgetc(stat.i_fstream);
     tokstack.top = -1;
 }
 
 int
 peek(void)
 {
     return cur;
 }
 
 int
 peek2(void)
 {
     return next;
 }
 
 int
 consume(void)
 {
     int c = cur;
     cur = next;
     next = fgetc(stat.i_fstream);
     return c;
 }
 
 static void
 skip_ws_c(void)
 {
     while (1) {
         /* whitespace */
         while (isspace(peek()))
             consume();
 
         /* line comment */
         if (peek() == '/' && peek2() == '/') {
             consume(); /* / */
             consume(); /* / */
             while (peek() != '\n' && peek() != EOF)
                 consume();
             continue;
         }
 
         /* block comment */
         if (peek() == '/' && peek2() == '*') {
             consume(); /* / */
             consume(); /* * */
 
             while (peek() != EOF) {
                 if (peek() == '*' && peek2() == '/') {
                     consume(); /* * */
                     consume(); /* / */
                     break;
                 }
                 consume();
             }
             continue;
         }
 
         break;
     }
 }
 
 tok_t
 id(void)
 {
     tok_t t = {0};
     int len = 0;
     int c;
 
     while ((c = peek()) != EOF && (isalnum(c) || c == '_')) {
         if (len < (int)sizeof(t.lexeme) - 1)
             t.lexeme[len++] = (char)consume();
         else
             consume();
     }
 
     t.lexeme[len] = '\0';
     t.type = lu_kw(t.lexeme);
 
     return t;
 }
 
 void
 pushtok(tok_t t)
 {
     if (tokstack.top < MAX_STACK_SIZE - 1) {
         tokstack.stack[++tokstack.top] = t;
     } else {
         fprintf(stderr, "slash: token stack overflow\n");
     }
 }
 
 tok_t
 poptok(void)
 {
     if (tokstack.top >= 0) {
         return tokstack.stack[tokstack.top--];
     } else {
         fprintf(stderr, "slash: token stack underflow\n");
         tok_t empty_token = {0};
         return empty_token;
     }
 }
 
 tok_t
 peekstack(void)
 {
     if (tokstack.top >= 0) {
         return tokstack.stack[tokstack.top];
     } else {
         fprintf(stderr, "slash: token stack is empty\n");
         tok_t empty_token = {0};
         return empty_token;
     }
 }
 
 tok_t
 nexttok(void)
 {
     tok_t t = {0};
     int c;
 
     skip_ws_c();
 
     c = peek();
 
     /* EOF */
     if (c == EOF) {
         t.type = TOK_EOF;
         pushtok(t);
         return t;
     }
 
     /* identifier or keyword */
     if (isalpha(c) || c == '_') {
         t = id();
         pushtok(t);
         return t;
     }
 
     consume();
 
     switch (c) {
     case '{':
         t.type = TOK_LBRACE;
         break;
     case '}':
         t.type = TOK_RBRACE;
         break;
     case '(':
         t.type = TOK_LPAREN;
         break;
     case ')':
         t.type = TOK_RPAREN;
         break;
     case ',':
         t.type = TOK_COMMA;
         break;
     case '.':
         t.type = TOK_PERIOD;
         break;
     default:
         t.type = TOK_UNKNOWN;
         t.lexeme[0] = (char)c;
         t.lexeme[1] = '\0';
         break;
     }
 
     pushtok(t);
     return t;
 }
 
 const char *
 tokname(toktype_t t)
 {
     switch (t) {
     case TOK_CLASS:  return "CLASS";
     case TOK_FC:     return "FC";
     case TOK_AS:     return "AS";
 
     case TOK_F32:    return "F32";
     case TOK_F64:    return "F64";
 
     case TOK_I16:    return "I16";
     case TOK_I32:    return "I32";
 
     case TOK_U16:    return "U16";
     case TOK_U64:    return "U64";
 
     case TOK_IDENT:  return "IDENT";
 
     case TOK_PERIOD: return "PERIOD";
     case TOK_LBRACE: return "LBRACE";
     case TOK_RBRACE: return "RBRACE";
     case TOK_LPAREN: return "LPAREN";
     case TOK_RPAREN: return "RPAREN";
     case TOK_COMMA:  return "COMMA";
 
     case TOK_EOF:    return "EOF";
 
     default:         return "UNKNOWN";
     }
 }