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/**/'] + [
@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 {
}
}
-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);
}
#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 */
#include <stdlib.h>
#include <errno.h>
-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);
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])) {
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;
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",
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
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);
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);
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));
}
}
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;
+}
+
+
#ifndef LEXER_H
#define LEXER_H
-#include "scanner.h"
+#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <assert.h>
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);
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);
}
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;
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, "<file>:%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;
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;
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);
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);
}
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 */
+++ /dev/null
-#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;
-}
-
+++ /dev/null
-/**
- @file scanner.h
- @brief TODO: Describe this file
- $Revision$
- $HeadURL$
- */
-#ifndef SCANNER_H
-#define SCANNER_H
-
-#include <stdio.h>
-#include <stdbool.h>
-
-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 */
#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:
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);
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);
}
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))
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;
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;
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);
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,
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 */
#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));
}
}
}
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);
}
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)) {
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, ", ");
}
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));
}
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;
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, ", ");
}
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);
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);
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);
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));
}
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);
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 {
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);
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);
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";
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;
}
}
-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);
}
-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) {
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);
#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 */
projects / proto / sclpl.git / commitdiff