From 6fd244cb04cf1972e9d7dcc5635bf5cfe8194402 Mon Sep 17 00:00:00 2001 From: Bad Diode Date: Fri, 22 Oct 2021 13:38:52 +0200 Subject: Add more keyword token types --- src/bytecode/lexer.c | 93 ++++++++++++++++++++++++++++++++++------------------ src/bytecode/lexer.h | 38 ++++++++++++++++++--- src/bytecode/main.c | 4 +++ src/bytecode/vm.h | 4 +-- 4 files changed, 100 insertions(+), 39 deletions(-) (limited to 'src/bytecode') diff --git a/src/bytecode/lexer.c b/src/bytecode/lexer.c index 38ca37c..82cdf22 100644 --- a/src/bytecode/lexer.c +++ b/src/bytecode/lexer.c @@ -1,44 +1,55 @@ #include "lexer.h" +static const char* token_str[] = { + [TOKEN_UNKNOWN] = "TOKEN_UNKNOWN", + [TOKEN_LPAREN] = "TOKEN_LPAREN", + [TOKEN_RPAREN] = "TOKEN_RPAREN", + [TOKEN_FIXNUM] = "TOKEN_FIXNUM", + [TOKEN_SYMBOL] = "TOKEN_SYMBOL", + [TOKEN_STRING] = "TOKEN_STRING", + [TOKEN_NIL] = "TOKEN_NIL", + [TOKEN_QUOTE] = "TOKEN_QUOTE", + [TOKEN_TRUE] = "TOKEN_TRUE", + [TOKEN_FALSE] = "TOKEN_FALSE", + [TOKEN_IF] = "TOKEN_IF", + [TOKEN_ELSE] = "TOKEN_ELSE", + [TOKEN_DEF] = "TOKEN_DEF", + [TOKEN_FUN] = "TOKEN_FUN", + [TOKEN_LAMBDA] = "TOKEN_LAMBDA", + [TOKEN_ADD] = "TOKEN_ADD", + [TOKEN_MIN] = "TOKEN_MIN", + [TOKEN_MUL] = "TOKEN_MUL", + [TOKEN_DIV] = "TOKEN_DIV", + [TOKEN_MOD] = "TOKEN_MOD", + [TOKEN_NOT] = "TOKEN_NOT", + [TOKEN_AND] = "TOKEN_AND", + [TOKEN_OR] = "TOKEN_OR", + [TOKEN_EQUAL] = "TOKEN_EQUAL", + [TOKEN_LESS_THAN] = "TOKEN_LESS_THAN", + [TOKEN_GREATER_THAN] = "TOKEN_GREATER_THAN", + [TOKEN_LESS_EQUAL_THAN] = "TOKEN_LESS_EQUAL_THAN", + [TOKEN_GREATER_EQUAL_THAN] = "TOKEN_GREATER_EQUAL_THAN", + [TOKEN_EOF] = "TOKEN_EOF", +}; + void print_token(Token tok) { printf("LINE: %3ld COL: %3ld ", tok.line, tok.column); + printf("%s", token_str[tok.type]); switch (tok.type) { - case TOKEN_LPAREN: { - printf("TOKEN_LPAREN"); - } break; - case TOKEN_RPAREN: { - printf("TOKEN_RPAREN"); - } break; - case TOKEN_QUOTE: { - printf("TOKEN_QUOTE"); - } break; - case TOKEN_TRUE: { - printf("TOKEN_TRUE"); - } break; - case TOKEN_FALSE: { - printf("TOKEN_FALSE"); - } break; - case TOKEN_NIL: { - printf("TOKEN_NIL"); - } break; case TOKEN_FIXNUM: { - printf("TOKEN_FIXNUM -> "); + printf(" -> "); sv_write(&tok.value, stdout); } break; case TOKEN_SYMBOL: { - printf("TOKEN_SYMBOL -> "); + printf(" -> "); sv_write(&tok.value, stdout); } break; case TOKEN_STRING: { - printf("TOKEN_STRING -> "); + printf(" -> "); sv_write(&tok.value, stdout); } break; - case TOKEN_EOF: { - printf("TOKEN_EOF"); - } break; - case TOKEN_UNKNOWN: { - printf("TOKEN_UNKNOWN"); + default: { } break; } printf("\n"); @@ -109,6 +120,9 @@ is_delimiter(char c) { return false; } +#define TOKEN_IS_KEYWORD(VAL, KEYWORD) \ + sv_equal(&(VAL), &(StringView){(KEYWORD), sizeof(KEYWORD) - 1}) + TokenType find_primitive_type(const StringView value) { bool is_fixnum = true; @@ -125,12 +139,27 @@ find_primitive_type(const StringView value) { if (is_fixnum) { return TOKEN_FIXNUM; } - if (sv_equal(&value, &(StringView){"true", 4})) { - return TOKEN_TRUE; - } - if (sv_equal(&value, &(StringView){"false", 5})) { - return TOKEN_FALSE; - } + if (TOKEN_IS_KEYWORD(value, "true")) { return TOKEN_TRUE; } + if (TOKEN_IS_KEYWORD(value, "false")) { return TOKEN_FALSE; } + if (TOKEN_IS_KEYWORD(value, "if")) { return TOKEN_IF; } + if (TOKEN_IS_KEYWORD(value, "else")) { return TOKEN_ELSE; } + if (TOKEN_IS_KEYWORD(value, "def")) { return TOKEN_DEF; } + if (TOKEN_IS_KEYWORD(value, "fun")) { return TOKEN_FUN; } + if (TOKEN_IS_KEYWORD(value, "lambda")) { return TOKEN_LAMBDA; } + if (TOKEN_IS_KEYWORD(value, "+")) { return TOKEN_ADD; } + if (TOKEN_IS_KEYWORD(value, "-")) { return TOKEN_MIN; } + if (TOKEN_IS_KEYWORD(value, "*")) { return TOKEN_MUL; } + if (TOKEN_IS_KEYWORD(value, "/")) { return TOKEN_DIV; } + if (TOKEN_IS_KEYWORD(value, "%")) { return TOKEN_MOD; } + if (TOKEN_IS_KEYWORD(value, "not")) { return TOKEN_NOT; } + if (TOKEN_IS_KEYWORD(value, "and")) { return TOKEN_AND; } + if (TOKEN_IS_KEYWORD(value, "or")) { return TOKEN_OR; } + if (TOKEN_IS_KEYWORD(value, "=")) { return TOKEN_EQUAL; } + if (TOKEN_IS_KEYWORD(value, "<")) { return TOKEN_LESS_THAN; } + if (TOKEN_IS_KEYWORD(value, ">")) { return TOKEN_GREATER_THAN; } + if (TOKEN_IS_KEYWORD(value, "<=")) { return TOKEN_LESS_EQUAL_THAN; } + if (TOKEN_IS_KEYWORD(value, ">=")) { return TOKEN_GREATER_EQUAL_THAN; } + return TOKEN_SYMBOL; } diff --git a/src/bytecode/lexer.h b/src/bytecode/lexer.h index e58dd05..a19ac11 100644 --- a/src/bytecode/lexer.h +++ b/src/bytecode/lexer.h @@ -3,18 +3,46 @@ #include "string_view.h" - typedef enum TokenType { TOKEN_UNKNOWN = 0, + + // Parentheses. TOKEN_LPAREN, TOKEN_RPAREN, - TOKEN_QUOTE, - TOKEN_TRUE, - TOKEN_FALSE, - TOKEN_NIL, + + // Primitive types. TOKEN_FIXNUM, TOKEN_SYMBOL, TOKEN_STRING, + + // Keywords. + TOKEN_NIL, + TOKEN_QUOTE, + TOKEN_TRUE, + TOKEN_FALSE, + TOKEN_IF, + TOKEN_ELSE, + TOKEN_DEF, + TOKEN_FUN, + TOKEN_LAMBDA, + + // Arithmetic. + TOKEN_ADD, + TOKEN_MIN, + TOKEN_MUL, + TOKEN_DIV, + TOKEN_MOD, + + // Boolean comparisons. + TOKEN_NOT, + TOKEN_AND, + TOKEN_OR, + TOKEN_EQUAL, + TOKEN_LESS_THAN, + TOKEN_GREATER_THAN, + TOKEN_LESS_EQUAL_THAN, + TOKEN_GREATER_EQUAL_THAN, + TOKEN_EOF, } TokenType; diff --git a/src/bytecode/main.c b/src/bytecode/main.c index 66089c0..5661747 100644 --- a/src/bytecode/main.c +++ b/src/bytecode/main.c @@ -38,6 +38,10 @@ process_source(const StringView *source) { return; } + for (size_t i = 0; i < array_size(tokens); i++) { + print_token(tokens[i]); + } + size_t const_a = add_constant(vm.chunk, 7); add_code(vm.chunk, OP_CONSTANT, 1, 1); add_code(vm.chunk, const_a, 1, 1); diff --git a/src/bytecode/vm.h b/src/bytecode/vm.h index cc9f846..6c5dfa7 100644 --- a/src/bytecode/vm.h +++ b/src/bytecode/vm.h @@ -102,8 +102,8 @@ vm_interpret(VM vm) { error_push((Error){ .type = ERR_TYPE_RUNTIME, .value = ERR_NOT_IMPLEMENTED, - .line = vm.chunk->lines[0].line, - .col = vm.chunk->lines[0].col, + .line = vm.chunk->lines[(vm.pc - vm.chunk->code) - 1].line, + .col = vm.chunk->lines[(vm.pc - vm.chunk->code) - 1].col, }); return; } break; -- cgit v1.2.1