From: Mike D. Lowis Date: Fri, 2 Oct 2015 16:18:55 +0000 (-0400) Subject: Refeactored the sclpl parsing library X-Git-Url: https://git.mdlowis.com/?a=commitdiff_plain;h=5ec856dae112945331638088ef881913d88a21a5;p=proto%2Fsclpl.git Refeactored the sclpl parsing library --- diff --git a/build.rb b/build.rb index 5394293..88cedf5 100755 --- a/build.rb +++ b/build.rb @@ -45,12 +45,6 @@ base_env = BuildEnv.new do |env| target if (is_dir ? Dir.exists?(target) : File.exists?(target)) end - # CMake Configuration - env['CMAKE_GENERATOR'] = ENV['CMAKE_GENERATOR'] || "#{windows? ? 'NMake' : 'Unix'} Makefiles" - env['CMAKE_FLAGS'] = [] - env['CMAKE_CMD'] = ['cmake', '-G', '${CMAKE_GENERATOR}', '${CMAKE_FLAGS}', '${_SOURCES}'] - env['MAKE_CMD'] = [windows? ? 'nmake' : 'make'] - # Compiler options env["CFLAGS"] += ['-DLEAK_DETECT_LEVEL=1', '--std=c99', '-Wall', '-Wextra']#, '-Werror'] env["CPPPATH"] += Dir['modules/libcds/source/**/'] + [ diff --git a/source/libparse/grammar.c b/source/libparse/grammar.c index 7b63a5c..d12cf7a 100644 --- a/source/libparse/grammar.c +++ b/source/libparse/grammar.c @@ -3,120 +3,120 @@ @brief See header for details $Revision$ $HeadURL$ - */ +*/ #include "grammar.h" #include "lexer.h" #include "exn.h" -tree_t* grammar_toplevel(parser_t* p) +AST* grammar_toplevel(Parser* p) { - tree_t* p_tree = NULL; + AST* p_tree = NULL; try { - if (parser_accept_str(p, T_ID, "require")) + if (accept_str(p, T_ID, "require")) grammar_require(p); - else if (parser_accept_str(p, T_ID, "type")) + else if (accept_str(p, T_ID, "type")) grammar_type_definition(p); - else if (parser_accept_str(p, T_ID, "ann")) + else if (accept_str(p, T_ID, "ann")) grammar_type_annotation(p); - else if (parser_accept_str(p, T_ID, "def")) + else if (accept_str(p, T_ID, "def")) grammar_definition(p); else grammar_expression(p); - p_tree = parser_get_tree(p); + p_tree = get_tree(p); } catch(ParseException) { /* Do nothing, the tree is bad */ } return p_tree; } -void grammar_require(parser_t* p) +void grammar_require(Parser* p) { - size_t mark = parser_mark(p); - parser_expect(p, T_STRING); - parser_expect(p, T_END); - parser_reduce(p, mark); + size_t mrk = mark(p); + expect(p, T_STRING); + expect(p, T_END); + reduce(p, mrk); } -void grammar_type_annotation(parser_t* p) +void grammar_type_annotation(Parser* p) { - size_t mark = parser_mark(p); - parser_expect(p, T_ID); + size_t mrk = mark(p); + expect(p, T_ID); grammar_type(p); - parser_expect(p, T_END); - parser_reduce(p, mark); + expect(p, T_END); + reduce(p, mrk); } -void grammar_type_definition(parser_t* p) +void grammar_type_definition(Parser* p) { - size_t mark = parser_mark(p); - parser_expect(p, T_ID); - parser_expect_str(p, T_ID, "is"); + size_t mrk = mark(p); + expect(p, T_ID); + expect_str(p, T_ID, "is"); grammar_type(p); - parser_expect(p, T_END); - parser_reduce(p, mark); + expect(p, T_END); + reduce(p, mrk); } -void grammar_type(parser_t* p) { - if (parser_accept(p, T_LBRACE)) { +void grammar_type(Parser* p) { + if (accept(p, T_LBRACE)) { grammar_tuple(p); } else { - parser_expect(p, T_ID); - if (parser_accept(p, T_LPAR)) { + expect(p, T_ID); + if (accept(p, T_LPAR)) { grammar_function(p); } } } -void grammar_tuple(parser_t* p) { - size_t mark = parser_mark(p); - parser_insert(p, T_ID, lexer_dup("tuple")); +void grammar_tuple(Parser* p) { + size_t mrk = mark(p); + insert(p, T_ID, lexer_dup("tuple")); do { grammar_type(p); - } while (parser_accept(p, T_COMMA)); - parser_expect(p, T_RBRACE); - parser_reduce(p, mark); + } while (accept(p, T_COMMA)); + expect(p, T_RBRACE); + reduce(p, mrk); } -void grammar_function(parser_t* p) { - size_t mark1 = parser_mark(p) - 1; - size_t mark2 = parser_mark(p); - while (!parser_accept(p, T_RPAR)) { +void grammar_function(Parser* p) { + size_t mark1 = mark(p) - 1; + size_t mark2 = mark(p); + while (!accept(p, T_RPAR)) { grammar_type(p); - if (T_RPAR != parser_peek(p)->type) - parser_expect(p, T_COMMA); + if (T_RPAR != peek(p)->type) + expect(p, T_COMMA); } - parser_reduce(p, mark2); - parser_reduce(p, mark1); + reduce(p, mark2); + reduce(p, mark1); } -void grammar_definition(parser_t* p) +void grammar_definition(Parser* p) { - size_t mark = parser_mark(p); - parser_expect(p,T_ID); - if (parser_peek(p)->type == T_LPAR) { - parser_insert(p, T_ID, lexer_dup("fn")); + size_t mrk = mark(p); + expect(p,T_ID); + if (peek(p)->type == T_LPAR) { + insert(p, T_ID, lexer_dup("fn")); grammar_fn_stmnt(p); } else { grammar_expression(p); - parser_expect(p,T_END); + expect(p,T_END); } - parser_reduce(p, mark); + reduce(p, mrk); } -void grammar_expression(parser_t* p) +void grammar_expression(Parser* p) { - if (parser_accept(p, T_LPAR)) { - size_t mark = parser_mark(p); + if (accept(p, T_LPAR)) { + size_t mrk = mark(p); grammar_expression(p); - parser_expect(p, T_RPAR); - parser_reduce(p, mark); - } else if (parser_accept_str(p, T_ID, "if")) { + expect(p, T_RPAR); + reduce(p, mrk); + } else if (accept_str(p, T_ID, "if")) { grammar_if_stmnt(p); - } else if (parser_accept_str(p, T_ID, "fn")) { + } else if (accept_str(p, T_ID, "fn")) { grammar_fn_stmnt(p); - } else if (parser_peek(p)->type == T_ID) { - parser_expect(p, T_ID); - if (parser_peek(p)->type == T_LPAR) { + } else if (peek(p)->type == T_ID) { + expect(p, T_ID); + if (peek(p)->type == T_LPAR) { grammar_arglist(p); } } else { @@ -124,63 +124,63 @@ void grammar_expression(parser_t* p) } } -void grammar_literal(parser_t* p) +void grammar_literal(Parser* p) { - switch (parser_peek(p)->type) { + switch (peek(p)->type) { case T_BOOL: case T_CHAR: case T_STRING: case T_INT: case T_FLOAT: - parser_accept(p, parser_peek(p)->type); + accept(p, peek(p)->type); break; default: - parser_error(p, "Expected a literal"); + error(p, "Expected a literal"); } } -void grammar_arglist(parser_t* p) +void grammar_arglist(Parser* p) { - size_t mark = parser_mark(p); - parser_expect(p, T_LPAR); - while(parser_peek(p)->type != T_RPAR) { + size_t mrk = mark(p); + expect(p, T_LPAR); + while(peek(p)->type != T_RPAR) { grammar_expression(p); - if(parser_peek(p)->type != T_RPAR) - parser_expect(p, T_COMMA); + if(peek(p)->type != T_RPAR) + expect(p, T_COMMA); } - parser_expect(p, T_RPAR); - parser_reduce(p, mark); + expect(p, T_RPAR); + reduce(p, mrk); } -void grammar_if_stmnt(parser_t* p) +void grammar_if_stmnt(Parser* p) { - size_t mark = parser_mark(p); + size_t mrk = mark(p); grammar_expression(p); grammar_expression(p); - if (parser_accept_str(p, T_ID, "else")) { + if (accept_str(p, T_ID, "else")) { grammar_expression(p); } - parser_expect(p,T_END); - parser_reduce(p, mark); + expect(p,T_END); + reduce(p, mrk); } -void grammar_fn_stmnt(parser_t* p) +void grammar_fn_stmnt(Parser* p) { - size_t mark1 = parser_mark(p); - parser_expect(p, T_LPAR); - size_t mark2 = parser_mark(p); - while(parser_peek(p)->type != T_RPAR) { - parser_expect(p, T_ID); - if(parser_peek(p)->type != T_RPAR) - parser_expect(p, T_COMMA); + size_t mark1 = mark(p); + expect(p, T_LPAR); + size_t mark2 = mark(p); + while(peek(p)->type != T_RPAR) { + expect(p, T_ID); + if(peek(p)->type != T_RPAR) + expect(p, T_COMMA); } - parser_expect(p, T_RPAR); - parser_reduce(p, mark2); - while(parser_peek(p)->type != T_END) { + expect(p, T_RPAR); + reduce(p, mark2); + while(peek(p)->type != T_END) { grammar_expression(p); } - parser_expect(p, T_END); - parser_reduce(p, mark1); + expect(p, T_END); + reduce(p, mark1); } diff --git a/source/libparse/grammar.h b/source/libparse/grammar.h index 942c3f0..962f456 100644 --- a/source/libparse/grammar.h +++ b/source/libparse/grammar.h @@ -7,18 +7,18 @@ #include "parser.h" -tree_t* grammar_toplevel(parser_t* p); -void grammar_require(parser_t* p); -void grammar_type_annotation(parser_t* p); -void grammar_type_definition(parser_t* p); -void grammar_type(parser_t* p); -void grammar_tuple(parser_t* p); -void grammar_function(parser_t* p); -void grammar_definition(parser_t* p); -void grammar_expression(parser_t* p); -void grammar_literal(parser_t* p); -void grammar_arglist(parser_t* p); -void grammar_if_stmnt(parser_t* p); -void grammar_fn_stmnt(parser_t* p); +AST* grammar_toplevel(Parser* p); +void grammar_require(Parser* p); +void grammar_type_annotation(Parser* p); +void grammar_type_definition(Parser* p); +void grammar_type(Parser* p); +void grammar_tuple(Parser* p); +void grammar_function(Parser* p); +void grammar_definition(Parser* p); +void grammar_expression(Parser* p); +void grammar_literal(Parser* p); +void grammar_arglist(Parser* p); +void grammar_if_stmnt(Parser* p); +void grammar_fn_stmnt(Parser* p); #endif /* GRAMMAR_H */ diff --git a/source/libparse/lexer.c b/source/libparse/lexer.c index 2bd31f5..75879f3 100644 --- a/source/libparse/lexer.c +++ b/source/libparse/lexer.c @@ -10,47 +10,62 @@ #include #include -static lex_tok_t* lexer_make_token(size_t line, size_t col, char* text); -static lex_tok_t* lexer_punc(char* text); -static lex_tok_t* lexer_char(char* text); -static lex_tok_t* lexer_radix_int(char* text); -static lex_tok_t* lexer_number(char* text); -static lex_tok_t* lexer_integer(char* text, int base); -static lex_tok_t* lexer_float(char* text); -static lex_tok_t* lexer_bool(char* text); -static lex_tok_t* lexer_var(char* text); +static char* read(Lexer* ctx, size_t* line, size_t* col); +static bool eof(Lexer* ctx); +static bool eol(Lexer* ctx); +static void getline(Lexer* ctx); +static void skip_ws(Lexer* ctx); +static char current(Lexer* ctx); +static bool oneof(Lexer* ctx, const char* p_set); +static char* dup(Lexer* ctx, size_t start_idx, size_t len); +static char* read_string(Lexer* ctx); + +static Token* lexer_make_token(size_t line, size_t col, char* text); +static Token* lexer_punc(char* text); +static Token* lexer_char(char* text); +static Token* lexer_radix_int(char* text); +static Token* lexer_number(char* text); +static Token* lexer_integer(char* text, int base); +static Token* lexer_float(char* text); +static Token* lexer_bool(char* text); +static Token* lexer_var(char* text); static bool lexer_oneof(const char* class, char c); static bool is_float(char* text); static int read_radix(char ch); static void lex_tok_free(void* p_obj) { - lex_tok_t* p_tok = (lex_tok_t*)p_obj; + Token* p_tok = (Token*)p_obj; if ((p_tok->type != T_BOOL) && (p_tok->type != T_CHAR) && (NULL != p_tok->value)) mem_release(p_tok->value); } -lex_tok_t* lex_tok_new(lex_tok_type_t type, void* val) { - lex_tok_t* p_tok = (lex_tok_t*)mem_allocate(sizeof(lex_tok_t), &lex_tok_free); +Token* lex_tok_new(TokenType type, void* val) { + Token* p_tok = (Token*)mem_allocate(sizeof(Token), &lex_tok_free); p_tok->type = type; p_tok->value = val; return p_tok; } static void lexer_free(void* p_obj) { - mem_release(((lexer_t*)p_obj)->scanner); } -lexer_t* lexer_new(char* p_prompt, FILE* p_input) { - lexer_t* p_lexer = (lexer_t*)mem_allocate(sizeof(lexer_t), &lexer_free); - p_lexer->scanner = scanner_new(p_prompt, p_input); +Lexer* lexer_new(char* p_prompt, FILE* p_input) { + Lexer* p_lexer = (Lexer*)mem_allocate(sizeof(Lexer), &lexer_free); + + p_lexer->p_line = NULL; + p_lexer->index = 0; + p_lexer->lineno = 0; + p_lexer->p_input = p_input; + p_lexer->p_prompt = p_prompt; + return p_lexer; } -lex_tok_t* lexer_read(lexer_t* p_lexer) { - lex_tok_t* p_tok = NULL; +Token* lexer_read(Lexer* p_lexer) { + Token* p_tok = NULL; size_t line; size_t col; - char* text = scanner_read(p_lexer->scanner, &line, &col); + char* text = read(p_lexer, &line, &col); if (NULL != text) { p_tok = lexer_make_token(line, col, text); free(text); @@ -58,12 +73,12 @@ lex_tok_t* lexer_read(lexer_t* p_lexer) { return p_tok; } -void lexer_skipline(lexer_t* p_lexer) { - scanner_getline(p_lexer->scanner); +void lexer_skipline(Lexer* p_lexer) { + getline(p_lexer); } -static lex_tok_t* lexer_make_token(size_t line, size_t col, char* text) { - lex_tok_t* p_tok = NULL; +static Token* lexer_make_token(size_t line, size_t col, char* text) { + Token* p_tok = NULL; if (0 == strcmp(text,"end")) { p_tok = lex_tok_new(T_END, NULL); } else if (lexer_oneof("()[]{};,'", text[0])) { @@ -90,9 +105,9 @@ static lex_tok_t* lexer_make_token(size_t line, size_t col, char* text) { return p_tok; } -static lex_tok_t* lexer_punc(char* text) +static Token* lexer_punc(char* text) { - lex_tok_t* p_tok = NULL; + Token* p_tok = NULL; switch (text[0]) { case '(': p_tok = lex_tok_new(T_LPAR, NULL); break; case ')': p_tok = lex_tok_new(T_RPAR, NULL); break; @@ -107,9 +122,9 @@ static lex_tok_t* lexer_punc(char* text) return p_tok; } -static lex_tok_t* lexer_char(char* text) +static Token* lexer_char(char* text) { - lex_tok_t* p_tok = NULL; + Token* p_tok = NULL; static const char* lookup_table[5] = { " \0space", "\n\0newline", @@ -132,17 +147,17 @@ static lex_tok_t* lexer_char(char* text) return p_tok; } -static lex_tok_t* lexer_radix_int(char* text) +static Token* lexer_radix_int(char* text) { - lex_tok_t* ret = lexer_integer(&text[2], read_radix(text[1])); + Token* ret = lexer_integer(&text[2], read_radix(text[1])); if (NULL == ret) ret = lexer_var(text); return ret; } -static lex_tok_t* lexer_number(char* text) +static Token* lexer_number(char* text) { - lex_tok_t* p_tok = NULL; + Token* p_tok = NULL; if (is_float(text)) p_tok = lexer_float(text); else @@ -150,7 +165,7 @@ static lex_tok_t* lexer_number(char* text) return (NULL == p_tok) ? lexer_var(text) : p_tok; } -static lex_tok_t* lexer_integer(char* text, int base) +static Token* lexer_integer(char* text, int base) { char* end; long* p_int = (long*)mem_allocate(sizeof(long), NULL); @@ -160,7 +175,7 @@ static lex_tok_t* lexer_integer(char* text, int base) return (end[0] == '\0') ? lex_tok_new(T_INT, p_int) : NULL; } -static lex_tok_t* lexer_float(char* text) +static Token* lexer_float(char* text) { char* end; double* p_dbl = (double*)mem_allocate(sizeof(double), NULL); @@ -170,12 +185,12 @@ static lex_tok_t* lexer_float(char* text) return (end[0] == '\0') ? lex_tok_new(T_FLOAT, p_dbl) : NULL; } -static lex_tok_t* lexer_bool(char* text) +static Token* lexer_bool(char* text) { return lex_tok_new(T_BOOL, (void*)((intptr_t)((0 == strcmp(text,"true")) ? true : false))); } -static lex_tok_t* lexer_var(char* text) +static Token* lexer_var(char* text) { return lex_tok_new(T_ID, lexer_dup(text)); } @@ -219,3 +234,157 @@ static int read_radix(char ch) { } return ret; } + +/*****************************************************************************/ + +char* read(Lexer* ctx, size_t* line, size_t* column) { + char* p_tok = NULL; + skip_ws(ctx); + *line = ctx->lineno; + *column = ctx->index+1; + if (!eof(ctx)) { + if (oneof(ctx, "()[]{};,'")) { + p_tok = dup(ctx, ctx->index, 1); + ctx->index++; + } else if (current(ctx) == '"') { + p_tok = read_string(ctx); + } else { + size_t start = ctx->index; + while(!oneof(ctx," \t\r\n()[]{};,'\"") && + (current(ctx) != '\0')) { + ctx->index++; + } + p_tok = dup(ctx, start, ctx->index - start); + } + } + return p_tok; +} + +static char* read_string(Lexer* ctx) { + size_t capacity = 8; + size_t index = 0; + char* tok = (char*)malloc(capacity); + + /* Skip the first " */ + tok[index++] = current(ctx); + tok[index] = '\0'; + ctx->index++; + + /* Read the contents of the string */ + while ('"' != current(ctx)) { + /* Resize the buffer if necessary */ + if ((index+2) >= capacity) { + capacity = capacity << 1; + tok = (char*)realloc(tok, capacity); + } + + /* EOF results in an assertion (don't do) */ + if (eof(ctx)) + assert(false); + + /* Read the char */ + tok[index++] = current(ctx); + tok[index] = '\0'; + ctx->index++; + + /* Get the next line if necessary */ + if ('\n' == tok[index-1]) + getline(ctx); + } + + /* Skip the last " */ + tok[index++] = current(ctx); + tok[index] = '\0'; + ctx->index++; + + return tok; +} + +bool eof(Lexer* ctx) +{ + return (eol(ctx) && feof(ctx->p_input)); +} + +bool eol(Lexer* ctx) +{ + bool ret = true; + size_t index = ctx->index; + char ch; + while((NULL != ctx->p_line) && ('\0' != (ch = ctx->p_line[index]))) { + if((' '!=ch) && ('\t'!=ch) && ('\r'!=ch) && ('\n'!=ch)) { + ret = false; + break; + } + index++; + } + return ret; +} + +void getline(Lexer* ctx) { + int c; + size_t capacity = 8; + size_t index = 0; + /* Reallocate and clear the line buffer */ + ctx->p_line = realloc(ctx->p_line, capacity); + ctx->p_line[0] = '\0'; + ctx->index = 0; + + /* If we have not yet reached the end of the file, read the next line */ + if (!eof(ctx)) { + if (NULL != ctx->p_prompt) + printf("%s", ctx->p_prompt); + while(('\n' != (c = fgetc(ctx->p_input))) && (EOF != c)) { + if (index+2 == capacity) { + capacity <<= 1u; + ctx->p_line = realloc(ctx->p_line, capacity); + } + ctx->p_line[index++] = c; + } + ctx->p_line[index++] = (c == EOF) ? '\0' : c; + ctx->p_line[index++] = '\0'; + ctx->index = 0; + /* Increment line count */ + ctx->lineno++; + } +} + +static void skip_ws(Lexer* ctx) { + /* If we haven't read a line yet, read one now */ + if (NULL == ctx->p_line) + getline(ctx); + /* Fast forward past whitespace and read a newline if necessary */ + while(!eof(ctx)) { + if ('\0' == current(ctx)) { + getline(ctx); + } else if (oneof(ctx, " \t\r\n")) { + ctx->index++; + } else { + break; + } + } +} + +static char current(Lexer* ctx) { + return ctx->p_line[ctx->index]; +} + +static bool oneof(Lexer* ctx, const char* p_set) { + bool ret = false; + size_t sz = strlen(p_set); + for (size_t idx = 0; idx < sz; idx++) { + if (current(ctx) == p_set[idx]) { + ret = true; + break; + } + } + return ret; +} + +static char* dup(Lexer* ctx, size_t start_idx, size_t len) { + char* p_str = (char*)malloc(len+1); + memcpy(p_str, &(ctx->p_line[start_idx]), len); + p_str[len] = '\0'; + return p_str; +} + + diff --git a/source/libparse/lexer.h b/source/libparse/lexer.h index 04fa117..c80579b 100644 --- a/source/libparse/lexer.h +++ b/source/libparse/lexer.h @@ -7,35 +7,39 @@ #ifndef LEXER_H #define LEXER_H -#include "scanner.h" +#include #include #include #include typedef struct { - scanner_t* scanner; -} lexer_t; + char* p_line; + size_t index; + size_t lineno; + FILE* p_input; + char* p_prompt; +} Lexer; typedef enum { T_ID, T_CHAR, T_INT, T_FLOAT, T_BOOL, T_STRING, T_LBRACE, T_RBRACE, T_LBRACK, T_RBRACK, T_LPAR, T_RPAR, T_COMMA, T_SQUOTE, T_DQUOTE, T_END, T_END_FILE -} lex_tok_type_t; +} TokenType; typedef struct { - lex_tok_type_t type; + TokenType type; const char* file; size_t line; size_t col; void* value; -} lex_tok_t; +} Token; -lexer_t* lexer_new(char* p_prompt, FILE* p_input); +Lexer* lexer_new(char* p_prompt, FILE* p_input); -lex_tok_t* lex_tok_new(lex_tok_type_t type, void* val); +Token* lex_tok_new(TokenType type, void* val); -lex_tok_t* lexer_read(lexer_t* p_lexer); +Token* lexer_read(Lexer* p_lexer); -void lexer_skipline(lexer_t* p_lexer); +void lexer_skipline(Lexer* p_lexer); char* lexer_dup(const char* p_old); diff --git a/source/libparse/parser.c b/source/libparse/parser.c index 5930d18..44b4575 100644 --- a/source/libparse/parser.c +++ b/source/libparse/parser.c @@ -9,10 +9,10 @@ DEFINE_EXCEPTION(ParseException, &RuntimeException); -lex_tok_t tok_eof = { T_END_FILE, NULL, 0, 0, NULL }; +Token tok_eof = { T_END_FILE, NULL, 0, 0, NULL }; static void parser_free(void* p_obj) { - parser_t* p_parser = (parser_t*)p_obj; + Parser* p_parser = (Parser*)p_obj; if ((NULL != p_parser->p_tok) && (&tok_eof != p_parser->p_tok)) { mem_release(p_parser->p_tok); } @@ -20,34 +20,34 @@ static void parser_free(void* p_obj) { mem_release(p_parser->p_tok_buf); } -parser_t* parser_new(char* p_prompt, FILE* input) +Parser* parser_new(char* p_prompt, FILE* input) { - parser_t* p_parser = (parser_t*)mem_allocate(sizeof(parser_t), &parser_free); + Parser* p_parser = (Parser*)mem_allocate(sizeof(Parser), &parser_free); p_parser->p_lexer = lexer_new(p_prompt, input); p_parser->p_tok = NULL; p_parser->p_tok_buf = vec_new(0); return p_parser; } -void parser_fetch(parser_t* p_parser) +void fetch(Parser* p_parser) { p_parser->p_tok = lexer_read(p_parser->p_lexer); if (NULL == p_parser->p_tok) p_parser->p_tok = &tok_eof; } -lex_tok_t* parser_peek(parser_t* p_parser) +Token* peek(Parser* p_parser) { if (NULL == p_parser->p_tok) - parser_fetch(p_parser); + fetch(p_parser); return p_parser->p_tok; } -bool parser_eof(parser_t* p_parser) { - return (parser_peek(p_parser)->type == T_END_FILE); +bool parser_eof(Parser* p_parser) { + return (peek(p_parser)->type == T_END_FILE); } -void parser_resume(parser_t* p_parser) { +void parser_resume(Parser* p_parser) { if ((NULL != p_parser->p_tok) && (&tok_eof != p_parser->p_tok)) { mem_release(p_parser->p_tok); p_parser->p_tok = NULL; @@ -56,18 +56,18 @@ void parser_resume(parser_t* p_parser) { lexer_skipline(p_parser->p_lexer); } -void parser_error(parser_t* p_parser, const char* p_text) +void error(Parser* p_parser, const char* p_text) { (void)p_parser; - lex_tok_t* tok = parser_peek(p_parser); + Token* tok = peek(p_parser); fprintf(stderr, ":%zu:%zu:Error: %s\n", tok->line, tok->col, p_text); throw_msg(ParseException, p_text); } -bool parser_accept(parser_t* p_parser, lex_tok_type_t type) +bool accept(Parser* p_parser, TokenType type) { bool ret = false; - if (parser_peek(p_parser)->type == type) { + if (peek(p_parser)->type == type) { vec_push_back(p_parser->p_tok_buf, tree_new(ATOM, p_parser->p_tok)); p_parser->p_tok = NULL; ret = true; @@ -75,10 +75,10 @@ bool parser_accept(parser_t* p_parser, lex_tok_type_t type) return ret; } -bool parser_accept_str(parser_t* p_parser, lex_tok_type_t type, const char* p_text) +bool accept_str(Parser* p_parser, TokenType type, const char* p_text) { bool ret = false; - if ((parser_peek(p_parser)->type == type) && (0 == strcmp((char*)(p_parser->p_tok->value), p_text))) { + if ((peek(p_parser)->type == type) && (0 == strcmp((char*)(p_parser->p_tok->value), p_text))) { vec_push_back(p_parser->p_tok_buf, tree_new(ATOM, p_parser->p_tok)); p_parser->p_tok = NULL; ret = true; @@ -86,47 +86,47 @@ bool parser_accept_str(parser_t* p_parser, lex_tok_type_t type, const char* p_te return ret; } -bool parser_expect(parser_t* p_parser, lex_tok_type_t type) +bool expect(Parser* p_parser, TokenType type) { bool ret = false; - if (parser_accept(p_parser, type)) { + if (accept(p_parser, type)) { ret = true; } else { - parser_error(p_parser, "Unexpected token"); + error(p_parser, "Unexpected token"); } return ret; } -bool parser_expect_str(parser_t* p_parser, lex_tok_type_t type, const char* p_text) +bool expect_str(Parser* p_parser, TokenType type, const char* p_text) { bool ret = false; - if (parser_accept_str(p_parser, type, p_text)) { + if (accept_str(p_parser, type, p_text)) { ret = true; } else { - parser_error(p_parser, "Unexpected token"); + error(p_parser, "Unexpected token"); } return ret; } -size_t parser_mark(parser_t* p_parser) +size_t mark(Parser* p_parser) { return (vec_size(p_parser->p_tok_buf) - 1); } -void parser_reduce(parser_t* p_parser, size_t mark) +void reduce(Parser* p_parser, size_t mark) { vec_t* p_buf = p_parser->p_tok_buf; vec_t* p_form = vec_new(0); for(size_t idx = mark; idx < vec_size(p_buf); idx++) { - tree_t* p_tree = mem_retain(vec_at(p_buf, idx)); + AST* p_tree = mem_retain(vec_at(p_buf, idx)); vec_push_back(p_form, p_tree); } vec_erase(p_buf, mark, vec_size(p_buf)-1); vec_push_back(p_buf, tree_new(TREE, p_form)); } -tree_t* parser_get_tree(parser_t* p_parser) { - tree_t* p_tree = NULL; +AST* get_tree(Parser* p_parser) { + AST* p_tree = NULL; if (1 == vec_size(p_parser->p_tok_buf)) { p_tree = mem_retain(vec_at(p_parser->p_tok_buf, 0)); vec_clear(p_parser->p_tok_buf); @@ -137,9 +137,9 @@ tree_t* parser_get_tree(parser_t* p_parser) { return p_tree; } -void parser_insert(parser_t* p_parser, lex_tok_type_t type, void* value) { - lex_tok_t* p_tok = lex_tok_new(type, value); - tree_t* p_tree = tree_new(ATOM, p_tok); +void insert(Parser* p_parser, TokenType type, void* value) { + Token* p_tok = lex_tok_new(type, value); + AST* p_tree = tree_new(ATOM, p_tok); vec_push_back(p_parser->p_tok_buf, p_tree); } diff --git a/source/libparse/parser.h b/source/libparse/parser.h index 980e7f5..3e447ad 100644 --- a/source/libparse/parser.h +++ b/source/libparse/parser.h @@ -15,37 +15,37 @@ DECLARE_EXCEPTION(ParseException); typedef struct { - lexer_t* p_lexer; - lex_tok_t* p_tok; + Lexer* p_lexer; + Token* p_tok; vec_t* p_tok_buf; -} parser_t; +} Parser; -parser_t* parser_new(char* p_prompt, FILE* input); +Parser* parser_new(char* p_prompt, FILE* input); -void parser_fetch(parser_t* p_parser); +void fetch(Parser* p_parser); -lex_tok_t* parser_peek(parser_t* p_parser); +Token* peek(Parser* p_parser); -bool parser_eof(parser_t* p_parser); +bool parser_eof(Parser* p_parser); -void parser_resume(parser_t* p_parser); +void parser_resume(Parser* p_parser); -void parser_error(parser_t* p_parser, const char* p_text); +void error(Parser* p_parser, const char* p_text); -bool parser_accept(parser_t* p_parser, lex_tok_type_t type); +bool accept(Parser* p_parser, TokenType type); -bool parser_accept_str(parser_t* p_parser, lex_tok_type_t type, const char* p_text); +bool accept_str(Parser* p_parser, TokenType type, const char* p_text); -bool parser_expect(parser_t* p_parser, lex_tok_type_t type); +bool expect(Parser* p_parser, TokenType type); -bool parser_expect_str(parser_t* p_parser, lex_tok_type_t type, const char* p_text); +bool expect_str(Parser* p_parser, TokenType type, const char* p_text); -size_t parser_mark(parser_t* p_parser); +size_t mark(Parser* p_parser); -void parser_reduce(parser_t* p_parser, size_t mark); +void reduce(Parser* p_parser, size_t mark); -tree_t* parser_get_tree(parser_t* p_parser); +AST* get_tree(Parser* p_parser); -void parser_insert(parser_t* p_parser, lex_tok_type_t type, void* value); +void insert(Parser* p_parser, TokenType type, void* value); #endif /* PARSER_H */ diff --git a/source/libparse/scanner.c b/source/libparse/scanner.c deleted file mode 100644 index 5000534..0000000 --- a/source/libparse/scanner.c +++ /dev/null @@ -1,175 +0,0 @@ -#include "scanner.h" -#include "mem.h" - -static void scanner_skip_ws(scanner_t* p_scanner); -static char scanner_current(scanner_t* p_scanner); -static bool scanner_oneof(scanner_t* p_scanner, const char* p_set); -static char* scanner_dup(scanner_t* p_scanner, size_t start_idx, size_t len); -static char* scanner_read_string(scanner_t* p_scanner); - -void scanner_free(void* p_obj) { - scanner_t* p_scanner = (scanner_t*)p_obj; - if (p_scanner->p_line) - free(p_scanner->p_line); -} - -scanner_t* scanner_new(char* p_prompt, FILE* p_file) { - scanner_t* p_scanner = (scanner_t*)mem_allocate(sizeof(scanner_t), &scanner_free); - p_scanner->p_line = NULL; - p_scanner->index = 0; - p_scanner->line = 0; - p_scanner->p_input = p_file; - p_scanner->p_prompt = p_prompt; - return p_scanner; -} - -char* scanner_read(scanner_t* p_scanner, size_t* line, size_t* column) { - char* p_tok = NULL; - scanner_skip_ws(p_scanner); - *line = p_scanner->line; - *column = p_scanner->index+1; - if (!scanner_eof(p_scanner)) { - if (scanner_oneof(p_scanner, "()[]{};,'")) { - p_tok = scanner_dup(p_scanner, p_scanner->index, 1); - p_scanner->index++; - } else if (scanner_current(p_scanner) == '"') { - p_tok = scanner_read_string(p_scanner); - } else { - size_t start = p_scanner->index; - while(!scanner_oneof(p_scanner," \t\r\n()[]{};,'\"") && - (scanner_current(p_scanner) != '\0')) { - p_scanner->index++; - } - p_tok = scanner_dup(p_scanner, start, p_scanner->index - start); - } - } - return p_tok; -} - -static char* scanner_read_string(scanner_t* p_scanner) { - size_t capacity = 8; - size_t index = 0; - char* tok = (char*)malloc(capacity); - - /* Skip the first " */ - tok[index++] = scanner_current(p_scanner); - tok[index] = '\0'; - p_scanner->index++; - - /* Read the contents of the string */ - while ('"' != scanner_current(p_scanner)) { - /* Resize the buffer if necessary */ - if ((index+2) >= capacity) { - capacity = capacity << 1; - tok = (char*)realloc(tok, capacity); - } - - /* EOF results in an assertion (don't do) */ - if (scanner_eof(p_scanner)) - assert(false); - - /* Read the char */ - tok[index++] = scanner_current(p_scanner); - tok[index] = '\0'; - p_scanner->index++; - - /* Get the next line if necessary */ - if ('\n' == tok[index-1]) - scanner_getline(p_scanner); - } - - /* Skip the last " */ - tok[index++] = scanner_current(p_scanner); - tok[index] = '\0'; - p_scanner->index++; - - return tok; -} - -bool scanner_eof(scanner_t* p_scanner) -{ - return (scanner_eol(p_scanner) && feof(p_scanner->p_input)); -} - -bool scanner_eol(scanner_t* p_scanner) -{ - bool ret = true; - size_t index = p_scanner->index; - char ch; - while((NULL != p_scanner->p_line) && ('\0' != (ch = p_scanner->p_line[index]))) { - if((' '!=ch) && ('\t'!=ch) && ('\r'!=ch) && ('\n'!=ch)) { - ret = false; - break; - } - index++; - } - return ret; -} - -void scanner_getline(scanner_t* p_scanner) { - int c; - size_t capacity = 8; - size_t index = 0; - /* Reallocate and clear the line buffer */ - p_scanner->p_line = realloc(p_scanner->p_line, capacity); - p_scanner->p_line[0] = '\0'; - p_scanner->index = 0; - - /* If we have not yet reached the end of the file, read the next line */ - if (!scanner_eof(p_scanner)) { - if (NULL != p_scanner->p_prompt) - printf("%s", p_scanner->p_prompt); - while(('\n' != (c = fgetc(p_scanner->p_input))) && (EOF != c)) { - if (index+2 == capacity) { - capacity <<= 1u; - p_scanner->p_line = realloc(p_scanner->p_line, capacity); - } - p_scanner->p_line[index++] = c; - } - p_scanner->p_line[index++] = (c == EOF) ? '\0' : c; - p_scanner->p_line[index++] = '\0'; - p_scanner->index = 0; - /* Increment line count */ - p_scanner->line++; - } -} - -static void scanner_skip_ws(scanner_t* p_scanner) { - /* If we haven't read a line yet, read one now */ - if (NULL == p_scanner->p_line) - scanner_getline(p_scanner); - /* Fast forward past whitespace and read a newline if necessary */ - while(!scanner_eof(p_scanner)) { - if ('\0' == scanner_current(p_scanner)) { - scanner_getline(p_scanner); - } else if (scanner_oneof(p_scanner, " \t\r\n")) { - p_scanner->index++; - } else { - break; - } - } -} - -static char scanner_current(scanner_t* p_scanner) { - return p_scanner->p_line[p_scanner->index]; -} - -static bool scanner_oneof(scanner_t* p_scanner, const char* p_set) { - bool ret = false; - size_t sz = strlen(p_set); - for (size_t idx = 0; idx < sz; idx++) { - if (scanner_current(p_scanner) == p_set[idx]) { - ret = true; - break; - } - } - return ret; -} - -static char* scanner_dup(scanner_t* p_scanner, size_t start_idx, size_t len) { - char* p_str = (char*)malloc(len+1); - memcpy(p_str, &(p_scanner->p_line[start_idx]), len); - p_str[len] = '\0'; - return p_str; -} - diff --git a/source/libparse/scanner.h b/source/libparse/scanner.h deleted file mode 100644 index 1d05285..0000000 --- a/source/libparse/scanner.h +++ /dev/null @@ -1,31 +0,0 @@ -/** - @file scanner.h - @brief TODO: Describe this file - $Revision$ - $HeadURL$ - */ -#ifndef SCANNER_H -#define SCANNER_H - -#include -#include - -typedef struct { - char* p_line; - size_t index; - size_t line; - FILE* p_input; - char* p_prompt; -} scanner_t; - -scanner_t* scanner_new(char* p_prompt, FILE* p_file); - -char* scanner_read(scanner_t* p_scanner, size_t* line, size_t* col); - -bool scanner_eof(scanner_t* p_scanner); - -bool scanner_eol(scanner_t* p_scanner); - -void scanner_getline(scanner_t* p_scanner); - -#endif /* SCANNER_H */ diff --git a/source/libparse/tree.c b/source/libparse/tree.c index 7a4373f..87e2a8e 100644 --- a/source/libparse/tree.c +++ b/source/libparse/tree.c @@ -7,13 +7,13 @@ #include "tree.h" static void tree_free(void* p_obj) { - tree_t* p_tree = ((tree_t*)p_obj); + AST* p_tree = ((AST*)p_obj); if (NULL != p_tree->ptr.tok) { mem_release(p_tree->ptr.tok); } } -static bool is_punctuation(lex_tok_t* p_tok) { +static bool is_punctuation(Token* p_tok) { bool ret = false; switch(p_tok->type) { case T_END: @@ -31,8 +31,8 @@ static bool is_punctuation(lex_tok_t* p_tok) { return ret; } -tree_t* tree_convert(tree_t* p_tree) { - tree_t* p_newtree = NULL; +AST* tree_convert(AST* p_tree) { + AST* p_newtree = NULL; if (p_tree->tag == ATOM) { if (!is_punctuation(p_tree->ptr.tok)) p_newtree = mem_retain(p_tree); @@ -41,7 +41,7 @@ tree_t* tree_convert(tree_t* p_tree) { vec_t* p_newvec = vec_new(0); p_newtree = tree_new(TREE, p_newvec); for(size_t idx = 0; idx < vec_size(p_vec); idx++) { - tree_t* p_item = tree_convert(vec_at(p_vec,idx)); + AST* p_item = tree_convert(vec_at(p_vec,idx)); if (NULL != p_item) vec_push_back(p_newvec, p_item); } @@ -49,15 +49,15 @@ tree_t* tree_convert(tree_t* p_tree) { return p_newtree; } -tree_t* tree_new(tree_tag_t tag, void* p_obj) { - tree_t* p_tree = (tree_t*)mem_allocate(sizeof(tree_t), &tree_free); +AST* tree_new(ASTTag tag, void* p_obj) { + AST* p_tree = (AST*)mem_allocate(sizeof(AST), &tree_free); p_tree->tag = tag; - p_tree->ptr.tok = (lex_tok_t*)p_obj; + p_tree->ptr.tok = (Token*)p_obj; return p_tree; } -tree_t* tree_get_child(tree_t* p_tree, size_t idx) { - tree_t* child = NULL; +AST* tree_get_child(AST* p_tree, size_t idx) { + AST* child = NULL; if (p_tree->tag == TREE) { vec_t* vec = p_tree->ptr.vec; if (idx < vec_size(vec)) @@ -66,7 +66,7 @@ tree_t* tree_get_child(tree_t* p_tree, size_t idx) { return child; } -void* tree_get_val(tree_t* p_tree) { +void* tree_get_val(AST* p_tree) { void* ret = NULL; if (p_tree->tag == ATOM) { ret = p_tree->ptr.tok->value; @@ -74,20 +74,20 @@ void* tree_get_val(tree_t* p_tree) { return ret; } -void* tree_get_child_val(tree_t* p_tree, size_t idx) { +void* tree_get_child_val(AST* p_tree, size_t idx) { void* ret = NULL; - tree_t* child = tree_get_child(p_tree,idx); + AST* child = tree_get_child(p_tree,idx); if (child != NULL) { ret = tree_get_val(child); } return ret; } -bool tree_is_formtype(tree_t* p_tree, const char* val) { +bool tree_is_formtype(AST* p_tree, const char* val) { bool ret = false; - tree_t* child = tree_get_child(p_tree, 0); + AST* child = tree_get_child(p_tree, 0); if ((NULL != child) && (child->tag == ATOM)) { - lex_tok_t* token = child->ptr.tok; + Token* token = child->ptr.tok; if ((token->type == T_ID) && (0 == strcmp(val, (char*)token->value))) { ret = true; @@ -96,14 +96,14 @@ bool tree_is_formtype(tree_t* p_tree, const char* val) { return ret; } -void tree_walk(tree_t* tree, tree_walker_t* walker) +void tree_walk(AST* tree, tree_walker_t* walker) { size_t idx; walker->fn(walker->env, tree, PRE_NODE); if (tree->tag == TREE) { walker->fn(walker->env, tree, PRE_CHILDREN); for (idx = 0; idx < vec_size(tree->ptr.vec); idx++) { - tree_t* child = (tree_t*)vec_at(tree->ptr.vec, idx); + AST* child = (AST*)vec_at(tree->ptr.vec, idx); walker->fn(walker->env, tree, PRE_CHILD); tree_walk( child, walker ); walker->fn(walker->env, tree, POST_CHILD); diff --git a/source/libparse/tree.h b/source/libparse/tree.h index 9e7c003..c40d64a 100644 --- a/source/libparse/tree.h +++ b/source/libparse/tree.h @@ -13,15 +13,15 @@ typedef enum { ATOM, TREE -} tree_tag_t; +} ASTTag; typedef struct { - tree_tag_t tag; + ASTTag tag; union { - lex_tok_t* tok; + Token* tok; vec_t* vec; } ptr; -} tree_t; +} AST; typedef enum { PRE_NODE, @@ -32,20 +32,20 @@ typedef enum { POST_CHILD, } tree_walk_pos_t; -typedef tree_t* (*tree_walk_fn_t)(void* env, tree_t* node, tree_walk_pos_t pos); +typedef AST* (*tree_walk_fn_t)(void* env, AST* node, tree_walk_pos_t pos); typedef struct { void* env; tree_walk_fn_t fn; } tree_walker_t; -tree_t* tree_convert(tree_t* p_tree); -tree_t* tree_new(tree_tag_t tag, void* p_obj); -tree_t* tree_get_child(tree_t* p_tree, size_t idx); -void* tree_get_val(tree_t* p_tree); -void* tree_get_child_val(tree_t* p_tree, size_t idx); -bool tree_is_formtype(tree_t* p_tree, const char* val); -void tree_walk(tree_t* tree, tree_walker_t* walker); +AST* tree_convert(AST* p_tree); +AST* tree_new(ASTTag tag, void* p_obj); +AST* tree_get_child(AST* p_tree, size_t idx); +void* tree_get_val(AST* p_tree); +void* tree_get_child_val(AST* p_tree, size_t idx); +bool tree_is_formtype(AST* p_tree, const char* val); +void tree_walk(AST* tree, tree_walker_t* walker); tree_walker_t* tree_walker(void* env, tree_walk_fn_t fn); #endif /* TREE_H */ diff --git a/source/sclpl/codegen.c b/source/sclpl/codegen.c index 37aa423..1ce9656 100644 --- a/source/sclpl/codegen.c +++ b/source/sclpl/codegen.c @@ -2,14 +2,14 @@ #include "codegen.h" #include "pprint.h" -static void lift_funcs(vec_t* fnlst, tree_t* tree) { +static void lift_funcs(vec_t* fnlst, AST* tree) { if (tree_is_formtype(tree, "fn")) vec_push_back(fnlst, mem_retain(tree)); if (tree->tag == TREE) { vec_t* p_vec = tree->ptr.vec; for(size_t idx = 0; idx < vec_size(p_vec); idx++) { - lift_funcs(fnlst, (tree_t*)vec_at(p_vec, idx)); + lift_funcs(fnlst, (AST*)vec_at(p_vec, idx)); } } } @@ -17,7 +17,7 @@ static void lift_funcs(vec_t* fnlst, tree_t* tree) { static vec_t* find_fn_literals(vec_t* prgrm) { vec_t* fnlst = vec_new(0); for (size_t idx = 0; idx < vec_size(prgrm); idx++) { - tree_t* tree = (tree_t*)vec_at(prgrm, idx); + AST* tree = (AST*)vec_at(prgrm, idx); if (!tree_is_formtype(tree, "require")) { lift_funcs(fnlst, tree); } @@ -25,7 +25,7 @@ static vec_t* find_fn_literals(vec_t* prgrm) { return fnlst; } -static size_t get_fn_id(vec_t* funcs, tree_t* fn) { +static size_t get_fn_id(vec_t* funcs, AST* fn) { size_t idx; for (idx = 0; idx < vec_size(funcs); idx++) { if (fn == vec_at(funcs,idx)) { @@ -74,11 +74,11 @@ static void emit_header(FILE* file) { fputs("#include \"sclpl.h\"\n\n", file); } -static void emit_fn_signature(FILE* file, char* name, tree_t* fnval) { +static void emit_fn_signature(FILE* file, char* name, AST* fnval) { fprintf(file, "_Value %s(", name); vec_t* params = tree_get_child(fnval, 1)->ptr.vec; for (size_t i = 0; i < vec_size(params); i++) { - fprintf(file, "_Value %s", (char*)tree_get_val((tree_t*)vec_at(params,i))); + fprintf(file, "_Value %s", (char*)tree_get_val((AST*)vec_at(params,i))); if (i+1 < vec_size(params)) fprintf(file, ", "); } @@ -87,7 +87,7 @@ static void emit_fn_signature(FILE* file, char* name, tree_t* fnval) { static void emit_def_placeholders(FILE* file, vec_t* prgrm) { for (size_t idx = 0; idx < vec_size(prgrm); idx++) { - tree_t* p_tree = (tree_t*)vec_at(prgrm, idx); + AST* p_tree = (AST*)vec_at(prgrm, idx); if (tree_is_formtype(p_tree, "def")) { fprintf(file, "_Value %s;\n", (char*)tree_get_child_val(p_tree,1)); } @@ -95,9 +95,9 @@ static void emit_def_placeholders(FILE* file, vec_t* prgrm) { fputs("\n", file); } -static void emit_expression(FILE* file, vec_t* fnlst, tree_t* p_tree, int depth) { +static void emit_expression(FILE* file, vec_t* fnlst, AST* p_tree, int depth) { if (p_tree->tag == ATOM) { - lex_tok_t* tok = p_tree->ptr.tok; + Token* tok = p_tree->ptr.tok; switch (tok->type) { case T_STRING: print_string(file, ((char*)tok->value)); break; case T_CHAR: print_char(file, ((char)(intptr_t)tok->value)); break; @@ -137,7 +137,7 @@ static void emit_expression(FILE* file, vec_t* fnlst, tree_t* p_tree, int depth) fprintf(file, "__calln(%s, n, ", (char*)tree_get_val(vec_at(vec,0))); /* Print out the arguments */ for (size_t idx = 1; idx < vec_size(vec); idx++) { - emit_expression(file, fnlst, (tree_t*)vec_at(vec,idx), depth); + emit_expression(file, fnlst, (AST*)vec_at(vec,idx), depth); if (idx+1 < vec_size(vec)) fprintf(file, ", "); } @@ -150,7 +150,7 @@ static void emit_fn_declarations(FILE* file, vec_t* fnlst) { for (size_t idx = 0; idx < vec_size(fnlst); idx++) { sprintf(name,"fn%d", (int)idx); fprintf(file, "static "); - emit_fn_signature(file, name, (tree_t*)vec_at(fnlst,idx)); + emit_fn_signature(file, name, (AST*)vec_at(fnlst,idx)); fputs(";\n", file); } fputs("\n", file); @@ -159,7 +159,7 @@ static void emit_fn_declarations(FILE* file, vec_t* fnlst) { static void emit_fn_definitions(FILE* file, vec_t* fnlst) { char name[64]; for (size_t idx = 0; idx < vec_size(fnlst); idx++) { - tree_t* func = (tree_t*)vec_at(fnlst,idx); + AST* func = (AST*)vec_at(fnlst,idx); sprintf(name,"fn%d", (int)idx); fprintf(file, "static "); emit_fn_signature(file, name, func); @@ -170,7 +170,7 @@ static void emit_fn_definitions(FILE* file, vec_t* fnlst) { fprintf(file, " "); if (i+1 == vec_size(body)) fprintf(file, "return "); - emit_expression(file, fnlst, (tree_t*)vec_at(body,i), 1); + emit_expression(file, fnlst, (AST*)vec_at(body,i), 1); fprintf(file, ";\n"); } fputs("}\n\n", file); @@ -180,7 +180,7 @@ static void emit_fn_definitions(FILE* file, vec_t* fnlst) { static void emit_toplevel(FILE* file, vec_t* fnlst, vec_t* prgrm) { fputs("void toplevel(void) {\n", file); for (size_t idx = 0; idx < vec_size(prgrm); idx++) { - tree_t* p_tree = (tree_t*)vec_at(prgrm, idx); + AST* p_tree = (AST*)vec_at(prgrm, idx); if (tree_is_formtype(p_tree, "require")) { fprintf(file, " extern void %s_toplevel(void);\n", (char*)tree_get_child_val(p_tree,1)); fprintf(file, " %s_toplevel();\n", (char*)tree_get_child_val(p_tree,1)); diff --git a/source/sclpl/main.c b/source/sclpl/main.c index 44f458b..87436b0 100644 --- a/source/sclpl/main.c +++ b/source/sclpl/main.c @@ -118,11 +118,11 @@ static int emit_csource(void) { } static int exec_repl(void) { - parser_t* p_parser = parser_new(":> ", stdin); + Parser* p_parser = parser_new(":> ", stdin); while(!parser_eof(p_parser)) { - tree_t* p_tree = grammar_toplevel(p_parser); + AST* p_tree = grammar_toplevel(p_parser); if (NULL != p_tree) { - tree_t* p_ast = tree_convert(p_tree); + AST* p_ast = tree_convert(p_tree); pprint_tree(stdout, p_ast, 0); mem_release(p_tree); mem_release(p_ast); diff --git a/source/sclpl/ops.c b/source/sclpl/ops.c index dc2770f..253c3a6 100644 --- a/source/sclpl/ops.c +++ b/source/sclpl/ops.c @@ -16,12 +16,12 @@ vec_t* ops_parse_file(str_t* in) { bool failed = false; FILE* input = (NULL == in) ? stdin : fopen(str_cstr(in), "r"); - parser_t* p_parser = parser_new(NULL, input); + Parser* p_parser = parser_new(NULL, input); vec_t* p_vec = vec_new(0); while(!parser_eof(p_parser)) { - tree_t* p_tree = grammar_toplevel(p_parser); + AST* p_tree = grammar_toplevel(p_parser); if (NULL != p_tree) { - tree_t* p_ast = tree_convert(p_tree); + AST* p_ast = tree_convert(p_tree); mem_release(p_tree); vec_push_back(p_vec, p_ast); } else { @@ -51,8 +51,8 @@ str_t* ops_token_file(str_t* in) { output = fopen(str_cstr(ofname), "w"); } - lexer_t* p_lexer = lexer_new(NULL, input); - lex_tok_t* token; + Lexer* p_lexer = lexer_new(NULL, input); + Token* token; while(NULL != (token = lexer_read(p_lexer))) { pprint_token(output, token, true); mem_release(token); @@ -74,7 +74,7 @@ str_t* ops_syntax_file(str_t* in) { vec_t* program = ops_parse_file(in); if (NULL != program) { for (size_t idx = 0; idx < vec_size(program); idx++) { - pprint_tree(output, (tree_t*)vec_at(program, idx), 0); + pprint_tree(output, (AST*)vec_at(program, idx), 0); } mem_release(program); fclose(output); diff --git a/source/sclpl/pprint.c b/source/sclpl/pprint.c index 6c3c146..6f5d0c5 100644 --- a/source/sclpl/pprint.c +++ b/source/sclpl/pprint.c @@ -11,7 +11,7 @@ static void print_indent(FILE* file, int depth) { fprintf(file, "%c", ' '); } -static const char* token_type_to_string(lex_tok_type_t type) { +static const char* token_type_to_string(TokenType type) { switch(type) { case T_STRING: return "T_STRING"; case T_CHAR: return "T_CHAR"; @@ -52,11 +52,11 @@ static void print_char(FILE* file, char ch) { if (i == 5) fprintf(file, "\\%c", ch); } -void pprint_token_type(FILE* file, lex_tok_t* token) { +void pprint_token_type(FILE* file, Token* token) { fprintf(file, "%s", token_type_to_string(token->type)); } -void pprint_token_value(FILE* file, lex_tok_t* token) { +void pprint_token_value(FILE* file, Token* token) { void* value = token->value; switch(token->type) { case T_STRING: fprintf(file, "\"%s\"", ((char*)value)); break; @@ -69,7 +69,7 @@ void pprint_token_value(FILE* file, lex_tok_t* token) { } } -void pprint_token(FILE* file, lex_tok_t* token, bool print_loc) +void pprint_token(FILE* file, Token* token, bool print_loc) { if (print_loc) { fprintf(file, "%zu:", token->line); @@ -84,7 +84,7 @@ void pprint_token(FILE* file, lex_tok_t* token, bool print_loc) } -void pprint_tree(FILE* file, tree_t* tree, int depth) +void pprint_tree(FILE* file, AST* tree, int depth) { print_indent(file, depth); if (tree->tag == ATOM) { @@ -93,7 +93,7 @@ void pprint_tree(FILE* file, tree_t* tree, int depth) fputs("(tree", file); vec_t* p_vec = tree->ptr.vec; for(size_t idx = 0; idx < vec_size(p_vec); idx++) { - pprint_tree(file, (tree_t*)vec_at(p_vec, idx), depth+1); + pprint_tree(file, (AST*)vec_at(p_vec, idx), depth+1); } print_indent(file, depth); fputs(")\n", file); diff --git a/source/sclpl/pprint.h b/source/sclpl/pprint.h index 2693ff4..6b45690 100644 --- a/source/sclpl/pprint.h +++ b/source/sclpl/pprint.h @@ -10,12 +10,12 @@ #include "parser.h" #include "lexer.h" -void pprint_token_type(FILE* file, lex_tok_t* token); +void pprint_token_type(FILE* file, Token* token); -void pprint_token_value(FILE* file, lex_tok_t* token); +void pprint_token_value(FILE* file, Token* token); -void pprint_token(FILE* file, lex_tok_t* token, bool print_loc); +void pprint_token(FILE* file, Token* token, bool print_loc); -void pprint_tree(FILE* file, tree_t* tree, int depth); +void pprint_tree(FILE* file, AST* tree, int depth); #endif /* PPRINT_H */