From eee31cc921bfc4764c495c891705d516dca46c82 Mon Sep 17 00:00:00 2001 From: "Michael D. Lowis" Date: Sun, 28 Jun 2015 17:32:47 -0400 Subject: [PATCH] updated libc --- modules/libc | 2 +- source/parser.c | 264 ++++++++++++++++++++++-------------------------- 2 files changed, 119 insertions(+), 147 deletions(-) diff --git a/modules/libc b/modules/libc index 7118835..f77cbda 160000 --- a/modules/libc +++ b/modules/libc @@ -1 +1 @@ -Subproject commit 71188357ccc74a381f48d4747a2e4a8fedb1626b +Subproject commit f77cbdabec0d6312323c5635d704b06a473c9222 diff --git a/source/parser.c b/source/parser.c index 462b134..85f16f1 100644 --- a/source/parser.c +++ b/source/parser.c @@ -3,12 +3,8 @@ */ //#include "parser.h" -#include -#include -#include -#include -#include -#include +#include +#include #define UNKNOWN 0 #define SYMBOL 1 @@ -32,23 +28,23 @@ #define RBRACE 19 #define OPERATOR 20 -#define ARRAY 100 -#define OBJECT 101 -#define HASHMAP 102 -#define HASHSET 103 -#define PAIR 104 -#define UNARY_MSG 105 -#define BINARY_MSG 106 -#define KEYWORD_MSG 107 -#define KEYWORD_PAIR 108 +#define ARRAY 100 +#define OBJECT 101 +#define HASHMAP 102 +#define HASHSET 103 +#define PAIR 104 +#define UNARY_MSG 105 +#define BINARY_MSG 106 +#define KEYWORD_MSG 107 +#define SELECTOR 108 /* Table of Contents *****************************************************************************/ // Types typedef struct AST { int type; - int num_children; - struct AST* children[]; + slist_node_t link; + slist_t children; } AST; typedef struct strbuf_t { @@ -64,20 +60,18 @@ static int Line = 1; static int Column = 0; static int CurrTok = UNKNOWN; static strbuf_t Token = {0,0,0}; -static intptr_t Token_Buffer[1024]; -static intptr_t* Token_Stack = Token_Buffer-1; // Parsing Rules -static void expression(void); -static void keyword_send(void); -static void binary_send(void); -static void unary_send(void); -static void operand(void); -static void literal(void); -static void array(void); -static void hashmap(void); -static void hashset(void); -static void object(void); +static AST* expression(void); +static AST* keyword_send(void); +static AST* binary_send(void); +static AST* unary_send(void); +static AST* operand(void); +static AST* literal(void); +static AST* array(void); +static AST* hashmap(void); +static AST* hashset(void); +static AST* object(void); // Parsing Helpers static void error(const char* msg); @@ -105,156 +99,157 @@ static void lex_error(void); static void fetch(void); // Tree Routines -static AST* Tree(int type, int num_children); -static void PrintTree(AST* tree, int depth); -static void shift(int type); -static void reduce(int count); -static void shift_reduce(int type, int nchildren); -static void push_reduce(int type, int nchildren); +static AST* ast_new(int type); +static AST* ast_tok(int type); +static void ast_add_child(AST* parent, AST* child); +static void ast_print(AST* tree, int depth); // String Buffer static void strbuf_init(strbuf_t* buf); static void strbuf_putc(strbuf_t* buf, int ch); -//static void strbuf_print(strbuf_t* buf, const char* str); -static char* strbuf_string(strbuf_t* buf); - /* *****************************************************************************/ void exec_file(FILE* file, const char* prompt) { File = file; - printf("%s", prompt); while(true) { - expression(); - printf("stack: %du\n", (int)((Token_Stack - Token_Buffer) + 1)); - /* Print and clear */ - PrintTree((AST*)*Token_Stack, 0); - Token_Stack = Token_Buffer-1; - free(strbuf_string(&Token)); + printf("%s", prompt); + ast_print(expression(), 0); } } /* Parsing Rules *****************************************************************************/ -static void expression(void) +static AST* expression(void) { - keyword_send(); + AST* expr = keyword_send(); optional(SEMICOLON); + return expr; } -static void keyword_send(void) +static AST* keyword_send(void) { - int count = 0; - binary_send(); + AST* expr = binary_send(); + AST* sel = NULL; while (accept(KEYWORD)) { - shift_reduce(KEYWORD,0); - binary_send(); - push_reduce(KEYWORD_PAIR, 2); - count++; - } - if (count > 0) { - push_reduce(KEYWORD_MSG, count); + if (sel == NULL) { + sel = ast_new(SELECTOR); + ast_add_child(expr, sel); + } + ast_add_child(sel, ast_tok(KEYWORD)); + ast_add_child(expr, binary_send()); } + return expr; } -static void binary_send(void) +static AST* binary_send(void) { - unary_send(); + AST* expr = unary_send(); if (accept(OPERATOR)) { - shift_reduce(OPERATOR,0); - unary_send(); - push_reduce(BINARY_MSG, 3); + AST* msg = ast_new(BINARY_MSG); + ast_add_child(msg, expr); + ast_add_child(msg, ast_new(OPERATOR)); + ast_add_child(msg, unary_send()); + expr = msg; } + return expr; } -static void unary_send(void) +static AST* unary_send(void) { - operand(); + AST* expr = operand(); while (accept(IDENTIFIER)) { - shift_reduce(IDENTIFIER, 0); - push_reduce(UNARY_MSG, 2); + AST* msg = ast_new(UNARY_MSG); + ast_add_child(msg, expr); + ast_add_child(msg, ast_tok(IDENTIFIER)); + printf("%d\n", (int)slist_size(&msg->children)); + expr = msg; } + return expr; } -static void operand(void) +static AST* operand(void) { + AST* obj = NULL; if (accept(LPAR)) { expect(LPAR); - expression(); + obj = expression(); expect(RPAR); } else { - literal(); + obj = literal(); } + return obj; } -static void literal(void) +static AST* literal(void) { + AST* obj = NULL; switch (CurrTok) { - case IDENTIFIER: shift_reduce(IDENTIFIER, 0u); push_reduce(UNARY_MSG, 1); break; - case NUMBER: shift_reduce(NUMBER, 0u); break; - case STRING: shift_reduce(STRING, 0u); break; - case SYMBOL: shift_reduce(SYMBOL, 0u); break; - case CHARACTER: shift_reduce(CHARACTER, 0u); break; - case LBRACK: array(); break; - case LBRACE: object(); break; - case AT_LBRACE: hashmap(); break; - case AT_LBRACK: hashset(); break; + case IDENTIFIER: obj = ast_tok(IDENTIFIER); break; + case NUMBER: obj = ast_tok(NUMBER); break; + case STRING: obj = ast_tok(STRING); break; + case SYMBOL: obj = ast_tok(SYMBOL); break; + case CHARACTER: obj = ast_tok(CHARACTER); break; + case LBRACK: obj = array(); break; + case LBRACE: obj = object(); break; + case AT_LBRACE: obj = hashmap(); break; + case AT_LBRACK: obj = hashset(); break; default: error("Invalid literal"); } + return obj; } -static void array(void) +static AST* array(void) { - int count = 0; + AST* array_obj = ast_new(ARRAY); expect(LBRACK); while (!accept(RBRACK)) { - expression(); - count++; + ast_add_child(array_obj, expression()); } expect(RBRACK); - push_reduce(ARRAY, count); + return array_obj; } -static void hashmap(void) +static AST* hashmap(void) { - int count = 0; + AST* hashmap = ast_new(HASHMAP); expect(AT_LBRACE); while (!accept(RBRACE)) { - shift_reduce(STRING, 0); + AST* pair = ast_new(PAIR); + expect(STRING); expect(COLON); - expression(); - push_reduce(PAIR, 2); - count++; + ast_add_child(pair, expression()); + ast_add_child(hashmap, pair); } expect(RBRACE); - push_reduce(HASHMAP, count); + return hashmap; } -static void hashset(void) +static AST* hashset(void) { - int count = 0; + AST* hashset = ast_new(HASHSET); expect(AT_LBRACK); while (!accept(RBRACK)) { - expression(); - count++; + ast_add_child(hashset, expression()); } expect(RBRACK); - push_reduce(HASHSET, count); + return hashset; } -static void object(void) +static AST* object(void) { + AST* object = ast_new(OBJECT); expect(LBRACE); if (accept(PIPE)) { expect(PIPE); expect(PIPE); } while (!accept(RBRACE)) { - expression(); + ast_add_child(object, expression()); } expect(RBRACE); - push_reduce(OBJECT, 0); + return object; } /* Parsing Helpers @@ -464,63 +459,40 @@ static void fetch(void) /* Tree Routines *****************************************************************************/ -static AST* Tree(int type, int num_children) +static AST* ast_new(int type) { - AST* tree = (AST*)calloc(1, sizeof(AST) * (num_children * sizeof(AST*))); - tree->type = type; - tree->num_children = num_children; + AST* tree = (AST*)calloc(1,sizeof(AST)); + tree->type = type; return tree; } -static void PrintTree(AST* tree, int depth) +static AST* ast_tok(int type) +{ + expect(type); + return ast_new(type); +} + +static void ast_add_child(AST* parent, AST* child) +{ + slist_push_back(&(parent->children), &(child->link)); +} + +static void ast_print(AST* tree, int depth) { int indent = depth * 2; printf("%*s(", indent, ""); printf("%d", tree->type); - if (tree->num_children == 0) { + if (slist_size(&tree->children) == 0) { printf(")\n"); } else { printf("\n"); - for (int child = 0; child < tree->num_children; child++) { - PrintTree(tree->children[child], depth+1); + slist_foreach(elem, &(tree->children)) { + ast_print(container_of(elem, AST, link), depth+1); } - printf("%*s)\n", indent, ""); } } -static void shift(int type) -{ - int curr = CurrTok; - if (expect(type)) { - *(++Token_Stack) = curr; - } -} - -static void reduce(int count) -{ - int type = *(Token_Stack--); - AST* tree = Tree(type, count); - intptr_t* stack = Token_Stack - (count-1); - for (int i = 0; i < count; i++) { - tree->children[i] = (void*)stack[i]; - } - Token_Stack -= count ; - *(++Token_Stack) = (intptr_t)tree; -} - -static void shift_reduce(int type, int nchildren) -{ - shift(type); - reduce(nchildren); -} - -static void push_reduce(int type, int nchildren) -{ - *(++Token_Stack) = type; - reduce(nchildren); -} - /* String Buffer *****************************************************************************/ static void strbuf_init(strbuf_t* buf) @@ -549,10 +521,10 @@ static void strbuf_putc(strbuf_t* buf, int ch) // strbuf_putc(buf, *str++); //} -static char* strbuf_string(strbuf_t* buf) -{ - char* str = buf->string; - strbuf_init(buf); - return str; -} +//static char* strbuf_string(strbuf_t* buf) +//{ +// char* str = buf->string; +// strbuf_init(buf); +// return str; +//} -- 2.54.0