code / tomo

   1 // Parsing logic for parsing files
   2 
   3 #include <gc.h>
   4 #include <setjmp.h>
   5 #include <stdarg.h>
   6 #include <stdbool.h>
   7 #include <string.h>
   8 
   9 #include "../ast.h"
  10 #include "../stdlib/datatypes.h"
  11 #include "../stdlib/paths.h"
  12 #include "../stdlib/stdlib.h"
  13 #include "../stdlib/tables.h"
  14 #include "../stdlib/text.h"
  15 #include "../stdlib/util.h"
  16 #include "context.h"
  17 #include "errors.h"
  18 #include "expressions.h"
  19 #include "files.h"
  20 #include "functions.h"
  21 #include "path.h"
  22 #include "statements.h"
  23 #include "text.h"
  24 #include "typedefs.h"
  25 #include "utils.h"
  26 
  27 // The cache of {filename -> parsed AST} will hold at most this many entries:
  28 #ifndef PARSE_CACHE_SIZE
  29 #define PARSE_CACHE_SIZE 100
  30 #endif
  31 
  32 static ast_t *parse_top_declaration(parse_ctx_t *ctx, const char *pos) {
  33     ast_t *declaration = parse_declaration(ctx, pos);
  34     if (declaration) declaration->__data.Declare.top_level = true;
  35     return declaration;
  36 }
  37 
  38 static ast_t *parse_metadata(parse_ctx_t *ctx, const char *pos) {
  39     const char *start = pos;
  40     const char *key = get_id(&pos);
  41     if (!key) return NULL;
  42     spaces(&pos);
  43     if (!match(&pos, ":")) return NULL;
  44     spaces(&pos);
  45     ast_t *value = parse_text(ctx, pos, false);
  46     Text_t value_text = EMPTY_TEXT;
  47     if (value) {
  48         for (ast_list_t *child = Match(value, TextJoin)->children; child; child = child->next) {
  49             if (child->ast->tag != TextLiteral)
  50                 parser_err(ctx, child->ast->start, child->ast->end, "Text interpolations are not allowed in metadata");
  51             value_text = Texts(value_text, Match(child->ast, TextLiteral)->text);
  52         }
  53     } else {
  54         value = parse_path(ctx, pos);
  55         if (!value) return NULL;
  56         Path_t path = Path$from_str(Match(value, Path)->path);
  57         path = Path$resolved(path, Path$parent(Path$from_str(ctx->file->filename)));
  58         OptionalText_t contents = Path$read(path);
  59         if (contents.tag == TEXT_NONE) parser_err(ctx, value->start, value->end, "File not found: ", path);
  60         value_text = Text$trim(contents, Text("\r\n\t "), true, true);
  61     }
  62     pos = value->end;
  63 
  64     return NewAST(ctx->file, start, pos, Metadata, .key = Text$from_str(key), .value = value_text);
  65 }
  66 
  67 ast_t *parse_file_body(parse_ctx_t *ctx, const char *pos) {
  68     const char *start = pos;
  69     whitespace(ctx, &pos);
  70     ast_list_t *statements = NULL;
  71     for (;;) {
  72         const char *next = pos;
  73         whitespace(ctx, &next);
  74         if (get_indent(ctx, next) != 0) break;
  75         ast_t *stmt;
  76         if ((stmt = optional(ctx, &pos, parse_metadata)) || (stmt = optional(ctx, &pos, parse_struct_def))
  77             || (stmt = optional(ctx, &pos, parse_func_def)) || (stmt = optional(ctx, &pos, parse_enum_def))
  78             || (stmt = optional(ctx, &pos, parse_lang_def)) || (stmt = optional(ctx, &pos, parse_convert_def))
  79             || (stmt = optional(ctx, &pos, parse_use)) || (stmt = optional(ctx, &pos, parse_inline_c))
  80             || (stmt = optional(ctx, &pos, parse_top_declaration))) {
  81             statements = new (ast_list_t, .ast = stmt, .next = statements);
  82             pos = stmt->end;
  83             whitespace(ctx, &pos); // TODO: check for newline
  84         } else {
  85             break;
  86         }
  87     }
  88     whitespace(ctx, &pos);
  89     if (pos < ctx->file->text + ctx->file->len && *pos != '\0') {
  90         parser_err(ctx, pos, eol(pos), "I expect all top-level statements to be declarations of some kind");
  91     }
  92     REVERSE_LIST(statements);
  93     return NewAST(ctx->file, start, pos, Block, .statements = statements);
  94 }
  95 
  96 public
  97 ast_t *parse_file(const char *path, jmp_buf *on_err) {
  98     if (path[0] != '<' && path[0] != '/') fail("Path is not fully resolved: ", path);
  99     // NOTE: this cache leaks a bounded amount of memory. The cache will never
 100     // hold more than PARSE_CACHE_SIZE entries (see below), but each entry's
 101     // AST holds onto a reference to the file it came from, so they could
 102     // potentially be somewhat large.
 103     static Table_t cached = EMPTY_TABLE;
 104     ast_t *ast = Table$str_get(cached, path);
 105     if (ast) return ast;
 106 
 107     file_t *file;
 108     if (path[0] == '<') {
 109         const char *endbracket = strchr(path, '>');
 110         if (!endbracket) return NULL;
 111         file = spoof_file(GC_strndup(path, (size_t)(endbracket + 1 - path)), endbracket + 1);
 112     } else {
 113         file = load_file(path);
 114         if (!file) return NULL;
 115     }
 116 
 117     parse_ctx_t ctx = {
 118         .file = file,
 119         .on_err = on_err,
 120     };
 121 
 122     const char *pos = file->text;
 123     if (match(&pos, "#!")) // shebang
 124         some_not(&pos, "\r\n");
 125 
 126     whitespace(&ctx, &pos);
 127     ast = parse_file_body(&ctx, pos);
 128     pos = ast->end;
 129     whitespace(&ctx, &pos);
 130     if (pos < file->text + file->len && *pos != '\0') {
 131         parser_err(&ctx, pos, pos + strlen(pos), "I couldn't parse this part of the file");
 132     }
 133 
 134     // If cache is getting too big, evict a random entry:
 135     if (cached.entries.length > PARSE_CACHE_SIZE) {
 136         // FIXME: this currently evicts the first entry, but it should be more like
 137         // an LRU cache
 138         struct {
 139             const char *path;
 140             ast_t *ast;
 141         } *to_remove = Table$entry(cached, 1);
 142         assert(to_remove);
 143         Table$str_remove(&cached, to_remove->path);
 144     }
 145 
 146     // Save the AST in the cache:
 147     Table$str_set(&cached, path, ast);
 148     return ast;
 149 }
 150 
 151 ast_t *parse_use(parse_ctx_t *ctx, const char *pos) {
 152     const char *start = pos;
 153 
 154     ast_t *var = parse_var(ctx, pos);
 155     if (var) {
 156         pos = var->end;
 157         spaces(&pos);
 158         if (!match(&pos, ":=")) return NULL;
 159         spaces(&pos);
 160     }
 161 
 162     if (!match_word(&pos, "use")) return NULL;
 163     spaces(&pos);
 164     size_t name_len = strcspn(pos, " \t\r\n;");
 165     if (name_len < 1) parser_err(ctx, start, pos, "There is no module name here to use");
 166     char *name = GC_strndup(pos, name_len);
 167     pos += name_len;
 168     while (match(&pos, ";"))
 169         continue;
 170     int what;
 171     if (name[0] == '<' || ends_with(name, ".h")) {
 172         what = USE_HEADER;
 173     } else if (starts_with(name, "-l")) {
 174         what = USE_SHARED_OBJECT;
 175     } else if (ends_with(name, ".c")) {
 176         what = USE_C_CODE;
 177     } else if (ends_with(name, ".S") || ends_with(name, ".s")) {
 178         what = USE_ASM;
 179     } else if (starts_with(name, "./") || starts_with(name, "/") || starts_with(name, "../")
 180                || starts_with(name, "~/")) {
 181         what = USE_LOCAL;
 182     } else {
 183         what = USE_PACKAGE;
 184     }
 185     return NewAST(ctx->file, start, pos, Use, .var = var, .path = name, .what = what);
 186 }
 187 
 188 public
 189 ast_t *parse_file_str(const char *str) {
 190     file_t *file = spoof_file("<string>", str);
 191     parse_ctx_t ctx = {
 192         .file = file,
 193         .on_err = NULL,
 194     };
 195 
 196     const char *pos = file->text;
 197     whitespace(&ctx, &pos);
 198     ast_t *ast = parse_file_body(&ctx, pos);
 199     pos = ast->end;
 200     whitespace(&ctx, &pos);
 201     if (pos < file->text + file->len && *pos != '\0')
 202         parser_err(&ctx, pos, pos + strlen(pos), "I couldn't parse this part of the string");
 203     return ast;
 204 }