code / tomo

   1 // Recursive descent parser for parsing code
   2 
   3 #include <stdbool.h>
   4 #include <string.h>
   5 
   6 #include "../ast.h"
   7 #include "../stdlib/util.h"
   8 #include "binops.h"
   9 #include "containers.h"
  10 #include "context.h"
  11 #include "controlflow.h"
  12 #include "errors.h"
  13 #include "expressions.h"
  14 #include "functions.h"
  15 #include "numbers.h"
  16 #include "path.h"
  17 #include "suffixes.h"
  18 #include "text.h"
  19 #include "utils.h"
  20 
  21 ast_t *parse_parens(parse_ctx_t *ctx, const char *pos) {
  22     const char *start = pos;
  23     spaces(&pos);
  24     if (!match(&pos, "(")) return NULL;
  25     whitespace(ctx, &pos);
  26     ast_t *expr = optional(ctx, &pos, parse_extended_expr);
  27     if (!expr) return NULL;
  28 
  29     ast_t *comprehension = parse_comprehension_suffix(ctx, expr);
  30     while (comprehension) {
  31         expr = comprehension;
  32         pos = comprehension->end;
  33         comprehension = parse_comprehension_suffix(ctx, expr);
  34     }
  35 
  36     whitespace(ctx, &pos);
  37     expect_closing(ctx, &pos, ")", "I wasn't able to parse the rest of this expression");
  38 
  39     // Update the span to include the parens:
  40     return new (ast_t, .file = (ctx)->file, .start = start, .end = pos, .tag = expr->tag, .__data = expr->__data);
  41 }
  42 
  43 ast_t *parse_reduction(parse_ctx_t *ctx, const char *pos) {
  44     const char *start = pos;
  45     if (!match(&pos, "(")) return NULL;
  46 
  47     whitespace(ctx, &pos);
  48     ast_e op = match_binary_operator(&pos);
  49     if (op == Unknown) return NULL;
  50 
  51     const char *op_str = binop_info[op].operator;
  52     assert(op_str);
  53     ast_t *key = NewAST(ctx->file, pos, pos, Var, .name = op_str);
  54     for (bool progress = true; progress;) {
  55         ast_t *new_term;
  56         progress = (false || (new_term = parse_index_suffix(ctx, key))
  57                     || (new_term = parse_method_call_suffix(ctx, key)) || (new_term = parse_field_suffix(ctx, key))
  58                     || (new_term = parse_fncall_suffix(ctx, key)) || (new_term = parse_non_optional_suffix(ctx, key)));
  59         if (progress) key = new_term;
  60     }
  61     if (key && key->tag == Var) key = NULL;
  62     else if (key) pos = key->end;
  63 
  64     whitespace(ctx, &pos);
  65     if (!match(&pos, ":")) return NULL;
  66 
  67     ast_t *iter = optional(ctx, &pos, parse_extended_expr);
  68     if (!iter) return NULL;
  69     ast_t *suffixed = parse_comprehension_suffix(ctx, iter);
  70     while (suffixed) {
  71         iter = suffixed;
  72         pos = suffixed->end;
  73         suffixed = parse_comprehension_suffix(ctx, iter);
  74     }
  75 
  76     whitespace(ctx, &pos);
  77     expect_closing(ctx, &pos, ")", "I wasn't able to parse the rest of this reduction");
  78 
  79     return NewAST(ctx->file, start, pos, Reduction, .iter = iter, .op = op, .key = key);
  80 }
  81 
  82 ast_t *parse_heap_alloc(parse_ctx_t *ctx, const char *pos) {
  83     const char *start = pos;
  84     if (!match(&pos, "@")) return NULL;
  85     spaces(&pos);
  86     ast_t *val = expect(ctx, start, &pos, parse_term_no_suffix, "I expected an expression for this '@'");
  87 
  88     for (;;) {
  89         ast_t *new_term;
  90         if ((new_term = parse_index_suffix(ctx, val)) || (new_term = parse_fncall_suffix(ctx, val))
  91             || (new_term = parse_method_call_suffix(ctx, val)) || (new_term = parse_field_suffix(ctx, val))) {
  92             val = new_term;
  93         } else break;
  94     }
  95     pos = val->end;
  96 
  97     ast_t *ast = NewAST(ctx->file, start, pos, HeapAllocate, .value = val);
  98     for (;;) {
  99         ast_t *next = parse_non_optional_suffix(ctx, ast);
 100         if (!next) break;
 101         ast = next;
 102     }
 103     return ast;
 104 }
 105 
 106 ast_t *parse_stack_reference(parse_ctx_t *ctx, const char *pos) {
 107     const char *start = pos;
 108     if (!match(&pos, "&")) return NULL;
 109     spaces(&pos);
 110     ast_t *val = expect(ctx, start, &pos, parse_term_no_suffix, "I expected an expression for this '&'");
 111 
 112     for (;;) {
 113         ast_t *new_term;
 114         if ((new_term = parse_index_suffix(ctx, val)) || (new_term = parse_fncall_suffix(ctx, val))
 115             || (new_term = parse_method_call_suffix(ctx, val)) || (new_term = parse_field_suffix(ctx, val))) {
 116             val = new_term;
 117         } else break;
 118     }
 119     pos = val->end;
 120 
 121     ast_t *ast = NewAST(ctx->file, start, pos, StackReference, .value = val);
 122     for (;;) {
 123         ast_t *next = parse_non_optional_suffix(ctx, ast);
 124         if (!next) break;
 125         ast = next;
 126     }
 127     return ast;
 128 }
 129 
 130 ast_t *parse_not(parse_ctx_t *ctx, const char *pos) {
 131     const char *start = pos;
 132     if (!match_word(&pos, "not")) return NULL;
 133     spaces(&pos);
 134     ast_t *val = expect(ctx, start, &pos, parse_term, "I expected an expression for this 'not'");
 135     return NewAST(ctx->file, start, pos, Not, .value = val);
 136 }
 137 
 138 ast_t *parse_negative(parse_ctx_t *ctx, const char *pos) {
 139     const char *start = pos;
 140     if (!match(&pos, "-")) return NULL;
 141     spaces(&pos);
 142     ast_t *val = expect(ctx, start, &pos, parse_term, "I expected an expression for this '-'");
 143     return NewAST(ctx->file, start, pos, Negative, .value = val);
 144 }
 145 
 146 ast_t *parse_bool(parse_ctx_t *ctx, const char *pos) {
 147     const char *start = pos;
 148     if (match_word(&pos, "yes")) return NewAST(ctx->file, start, pos, Bool, .b = true);
 149     else if (match_word(&pos, "no")) return NewAST(ctx->file, start, pos, Bool, .b = false);
 150     else return NULL;
 151 }
 152 
 153 ast_t *parse_none(parse_ctx_t *ctx, const char *pos) {
 154     const char *start = pos;
 155     if (!match_word(&pos, "none")) return NULL;
 156     return NewAST(ctx->file, start, pos, None);
 157 }
 158 
 159 ast_t *parse_var(parse_ctx_t *ctx, const char *pos) {
 160     const char *start = pos;
 161     const char *name = get_id(&pos);
 162     if (!name) return NULL;
 163     return NewAST(ctx->file, start, pos, Var, .name = name);
 164 }
 165 
 166 ast_t *parse_term_no_suffix(parse_ctx_t *ctx, const char *pos) {
 167     spaces(&pos);
 168     ast_t *term = NULL;
 169     (void)(false || (term = parse_none(ctx, pos)) || (term = parse_num(ctx, pos)) // Must come before int
 170            || (term = parse_int(ctx, pos)) || (term = parse_negative(ctx, pos)) // Must come after num/int
 171            || (term = parse_heap_alloc(ctx, pos)) || (term = parse_stack_reference(ctx, pos))
 172            || (term = parse_bool(ctx, pos)) || (term = parse_text(ctx, pos, true)) || (term = parse_path(ctx, pos))
 173            || (term = parse_lambda(ctx, pos)) || (term = parse_parens(ctx, pos)) || (term = parse_table(ctx, pos))
 174            || (term = parse_var(ctx, pos)) || (term = parse_list(ctx, pos)) || (term = parse_reduction(ctx, pos))
 175            || (term = parse_pass(ctx, pos)) || (term = parse_defer(ctx, pos)) || (term = parse_skip(ctx, pos))
 176            || (term = parse_stop(ctx, pos)) || (term = parse_return(ctx, pos)) || (term = parse_not(ctx, pos))
 177            || (term = parse_inline_c(ctx, pos)));
 178     return term;
 179 }
 180 
 181 ast_t *parse_term(parse_ctx_t *ctx, const char *pos) {
 182     const char *start = pos;
 183     if (match(&pos, "???")) parser_err(ctx, start, pos, "This value needs to be filled in!");
 184 
 185     ast_t *term = parse_term_no_suffix(ctx, pos);
 186     if (!term) return NULL;
 187 
 188     for (bool progress = true; progress;) {
 189         ast_t *new_term;
 190         progress =
 191             (false || (new_term = parse_index_suffix(ctx, term)) || (new_term = parse_method_call_suffix(ctx, term))
 192              || (new_term = parse_field_suffix(ctx, term)) || (new_term = parse_fncall_suffix(ctx, term))
 193              || (new_term = parse_non_optional_suffix(ctx, term)));
 194         if (progress) term = new_term;
 195     }
 196     return term;
 197 }
 198 
 199 ast_t *parse_expr(parse_ctx_t *ctx, const char *pos) {
 200     return parse_infix_expr(ctx, pos, 0);
 201 }
 202 
 203 ast_t *parse_extended_expr(parse_ctx_t *ctx, const char *pos) {
 204     ast_t *expr = NULL;
 205 
 206     if (false || (expr = optional(ctx, &pos, parse_for)) || (expr = optional(ctx, &pos, parse_while))
 207         || (expr = optional(ctx, &pos, parse_if)) || (expr = optional(ctx, &pos, parse_when))
 208         || (expr = optional(ctx, &pos, parse_repeat)) || (expr = optional(ctx, &pos, parse_do)))
 209         return expr;
 210 
 211     return parse_expr(ctx, pos);
 212 }
 213 
 214 ast_t *parse_expr_str(const char *str) {
 215     file_t *file = spoof_file("<string>", str);
 216     parse_ctx_t ctx = {
 217         .file = file,
 218         .on_err = NULL,
 219     };
 220 
 221     const char *pos = file->text;
 222     whitespace(&ctx, &pos);
 223     ast_t *ast = parse_extended_expr(&ctx, pos);
 224     pos = ast->end;
 225     whitespace(&ctx, &pos);
 226     if (pos < file->text + file->len && *pos != '\0')
 227         parser_err(&ctx, pos, pos + strlen(pos), "I couldn't parse this part of the string");
 228     return ast;
 229 }