From 3756806674da909ec6dc10ad25862b592792604e Mon Sep 17 00:00:00 2001 From: Jo-Philipp Wich Date: Wed, 23 Dec 2020 20:54:05 +0100 Subject: treewide: rewrite ucode interpreter Replace the former AST walking interpreter implementation with a single pass bytecode compiler and a corresponding virtual machine. The rewrite lays the groundwork for a couple of improvements with will be subsequently implemented: - Ability to precompile ucode sources into binary byte code - Strippable debug information - Reduced runtime memory usage Signed-off-by: Jo-Philipp Wich --- CMakeLists.txt | 18 +- ast.c | 694 ----- ast.h | 359 --- chunk.c | 211 ++ chunk.h | 63 + compiler.c | 2590 ++++++++++++++++++ compiler.h | 120 + contrib/lemon.c | 5040 ------------------------------------ contrib/lempar.c | 851 ------ eval.c | 1832 ------------- eval.h | 42 - lexer.c | 1152 +++++---- lexer.h | 150 +- lib.c | 1220 +++++---- lib.h | 184 +- lib/fs.c | 286 +- lib/math.c | 155 +- lib/ubus.c | 101 +- lib/uci.c | 282 +- main.c | 249 +- module.h | 51 +- object.c | 432 ++++ object.h | 200 ++ parser.y | 476 ---- source.c | 118 + source.h | 44 + tests/00_syntax/05_block_nesting | 7 + tests/00_syntax/13_object_literals | 1 + tests/00_syntax/16_for_loop | 23 +- tests/00_syntax/17_while_loop | 2 +- tests/00_syntax/19_arrow_functions | 6 +- tests/00_syntax/21_regex_literals | 2 +- tests/01_arithmetic/04_inc_dec | 4 +- tests/02_runtime/00_scoping | 14 +- tests/02_runtime/02_this | 7 +- tests/02_runtime/03_try_catch | 107 + tests/02_runtime/04_switch_case | 48 +- tests/02_runtime/06_recursion | 6 +- util.h | 248 ++ value.c | 716 +++++ value.h | 81 + vm.c | 2233 ++++++++++++++++ vm.h | 177 ++ 43 files changed, 9482 insertions(+), 11120 deletions(-) delete mode 100644 ast.c delete mode 100644 ast.h create mode 100644 chunk.c create mode 100644 chunk.h create mode 100644 compiler.c create mode 100644 compiler.h delete mode 100644 contrib/lemon.c delete mode 100644 contrib/lempar.c delete mode 100644 eval.c delete mode 100644 eval.h create mode 100644 object.c create mode 100644 object.h delete mode 100644 parser.y create mode 100644 source.c create mode 100644 source.h create mode 100644 util.h create mode 100644 value.c create mode 100644 value.h create mode 100644 vm.c create mode 100644 vm.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 9edfc6a..2046392 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -32,23 +32,7 @@ IF(JSONC_FOUND) INCLUDE_DIRECTORIES(${JSONC_INCLUDE_DIRS}) ENDIF() -ADD_CUSTOM_COMMAND( - OUTPUT contrib/lemon - DEPENDS contrib/lemon.c contrib/lempar.c - COMMAND gcc -o contrib/lemon contrib/lemon.c - COMMENT "Generating lemon parser generator" -) - -ADD_CUSTOM_COMMAND( - OUTPUT parser.c - DEPENDS parser.y contrib/lemon - COMMAND ./contrib/lemon parser.y - COMMENT "Generating parser.c" -) - -SET_PROPERTY(DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES "lemon;parser.h;parser.out") -SET_SOURCE_FILES_PROPERTIES("parser.c" PROPERTIES GENERATED TRUE COMPILE_FLAGS -Wno-error=unused-but-set-variable) -ADD_EXECUTABLE(ucode main.c ast.c lexer.c parser.c eval.c lib.c) +ADD_EXECUTABLE(ucode main.c lexer.c lib.c vm.c chunk.c value.c object.c compiler.c source.c) TARGET_LINK_LIBRARIES(ucode ${json}) CHECK_FUNCTION_EXISTS(dlopen DLOPEN_FUNCTION_EXISTS) diff --git a/ast.c b/ast.c deleted file mode 100644 index 5715afb..0000000 --- a/ast.c +++ /dev/null @@ -1,694 +0,0 @@ -/* - * Copyright (C) 2020 Jo-Philipp Wich - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "ast.h" -#include "lib.h" -#include "lexer.h" -#include "parser.h" - -#include -#include -#include -#include -#include -#include - -static size_t uc_ext_types_count = 0; -static struct uc_extended_type *uc_ext_types = NULL; - -uint32_t -uc_new_op(struct uc_state *s, int type, struct json_object *val, ...) -{ - struct uc_op *newop; - uint32_t child; - int n_op = 0; - va_list ap; - - if ((s->poolsize + 1) == UINT32_MAX) { - fprintf(stderr, "Program too large\n"); - exit(127); - } - - s->pool = xrealloc(s->pool, (s->poolsize + 1) * sizeof(*newop)); - - newop = &s->pool[s->poolsize]; - memset(newop, 0, sizeof(*newop)); - - newop->is_first = !s->poolsize; - newop->is_op = true; - newop->type = type; - newop->val = val; - - va_start(ap, val); - - while (n_op < OPn_NUM && (child = va_arg(ap, uint32_t)) != UINT32_MAX) - newop->tree.operand[n_op++] = child; - - va_end(ap); - - return s->poolsize++; -} - -uint32_t -uc_wrap_op(struct uc_state *state, uint32_t parent, ...) -{ - uint32_t child; - int n_op = 0; - va_list ap; - - va_start(ap, parent); - - while (n_op < OPn_NUM && (child = va_arg(ap, uint32_t)) != UINT32_MAX) - OPn(parent, n_op++) = child; - - va_end(ap); - - return parent; -} - -uint32_t -uc_append_op(struct uc_state *state, uint32_t a, uint32_t b) -{ - uint32_t tail_off, next_off; - - for (tail_off = a, next_off = OP_NEXT(tail_off); - next_off != 0; - tail_off = next_off, next_off = OP_NEXT(next_off)) - ; - - OP_NEXT(tail_off) = b; - - return a; -} - -static int -double_rounded_to_string(struct json_object *v, struct printbuf *pb, int level, int flags) -{ - bool strict = (level > 0) || (flags & JSON_C_TO_STRING_STRICT); - double d = json_object_get_double(v); - - if (isnan(d)) - return sprintbuf(pb, strict ? "\"NaN\"" : "NaN"); - - if (d == INFINITY) - return sprintbuf(pb, strict ? "1e309" : "Infinity"); - - if (d == -INFINITY) - return sprintbuf(pb, strict ? "-1e309" : "-Infinity"); - - return sprintbuf(pb, "%g", d); -} - -struct json_object * -uc_new_double(double v) -{ - struct json_object *d = json_object_new_double(v); - - if (!d) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - json_object_set_serializer(d, double_rounded_to_string, NULL, NULL); - - return d; -} - -static int -null_obj_to_string(struct json_object *v, struct printbuf *pb, int level, int flags) -{ - return sprintbuf(pb, "null"); -} - -struct json_object * -uc_new_null(void) -{ - struct json_object *d = json_object_new_boolean(false); - - if (!d) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - json_object_set_serializer(d, null_obj_to_string, NULL, NULL); - - return d; -} - -static void -obj_free(struct json_object *v, void *ud) -{ - struct uc_op *op = json_object_get_userdata(v); - - json_object_put(op->tag.proto); - free(ud); -} - -struct json_object * -uc_new_object(struct json_object *proto) { - struct json_object *val = xjs_new_object(); - struct uc_op *op = xalloc(sizeof(*op)); - - op->val = val; - op->type = T_LBRACE; - op->tag.proto = json_object_get(proto); - - json_object_set_serializer(val, NULL, op, obj_free); - - return op->val; -} - -static void -re_free(struct json_object *v, void *ud) -{ - struct uc_op *op = ud; - - regfree((regex_t *)op->tag.data); - free(op); -} - -static int -re_to_string(struct json_object *v, struct printbuf *pb, int level, int flags) -{ - bool strict = (level > 0) || (flags & JSON_C_TO_STRING_STRICT); - struct uc_op *op = json_object_get_userdata(v); - struct json_object *s; - const char *p; - size_t len; - - sprintbuf(pb, "%s/", strict ? "\"" : ""); - - s = xjs_new_string((char *)op + sizeof(*op) + sizeof(regex_t)); - - if (strict) - for (p = json_object_to_json_string(s) + 1, len = strlen(p) - 1; len > 0; len--, p++) - sprintbuf(pb, "%c", *p); - else - sprintbuf(pb, "%s", json_object_get_string(s)); - - json_object_put(s); - - return sprintbuf(pb, "/%s%s%s%s", - op->is_reg_global ? "g" : "", - op->is_reg_icase ? "i" : "", - op->is_reg_newline ? "s" : "", - strict ? "\"" : ""); -} - -struct json_object * -uc_new_regexp(const char *source, bool icase, bool newline, bool global, char **err) { - int cflags = REG_EXTENDED, res; - struct uc_op *op; - regex_t *re; - size_t len; - - op = xalloc(sizeof(*op) + sizeof(*re) + strlen(source) + 1); - re = (regex_t *)((char *)op + sizeof(*op)); - strcpy((char *)op + sizeof(*op) + sizeof(*re), source); - - if (icase) - cflags |= REG_ICASE; - - if (newline) - cflags |= REG_NEWLINE; - - op->type = T_REGEXP; - op->tag.data = re; - op->is_reg_icase = icase; - op->is_reg_global = global; - op->is_reg_newline = newline; - - res = regcomp(re, source, cflags); - - if (res != 0) { - len = regerror(res, re, NULL, 0); - *err = xalloc(len); - - regerror(res, re, *err, len); - free(op); - - return NULL; - } - - op->val = xjs_new_object(); - - if (!op->val) { - free(op); - - return NULL; - } - - json_object_set_serializer(op->val, re_to_string, op, re_free); - - return op->val; -} - -static void -func_free(struct json_object *v, void *ud) -{ - struct uc_op *op = ud; - struct uc_function *fn = op->tag.data; - - json_object_put(fn->args); - uc_release_scope(fn->parent_scope); - - free(op); -} - -static int -func_to_string(struct json_object *v, struct printbuf *pb, int level, int flags) -{ - bool strict = (level > 0) || (flags & JSON_C_TO_STRING_STRICT), rest; - struct uc_op *op = json_object_get_userdata(v); - struct uc_function *fn = op->tag.data; - size_t i, len; - - if (op->is_arrow) - sprintbuf(pb, "%s(", strict ? "\"" : ""); - else - sprintbuf(pb, "%sfunction%s%s(", - strict ? "\"" : "", - fn->name ? " " : "", - fn->name ? fn->name : ""); - - if (fn->args) { - len = json_object_array_length(fn->args); - rest = (len > 1) && json_object_is_type(json_object_array_get_idx(fn->args, len - 1), json_type_null); - - for (i = 0; i < len - rest; i++) { - sprintbuf(pb, "%s%s%s", - i ? ", " : "", - rest && i == len - 2 ? "..." : "", - json_object_get_string(json_object_array_get_idx(fn->args, i))); - } - } - - return sprintbuf(pb, ") %s{ ... }%s", - op->is_arrow ? "=> " : "", - strict ? "\"" : ""); -} - -struct json_object * -uc_new_func(struct uc_state *state, uint32_t decl, struct uc_scope *scope) -{ - struct json_object *val = xjs_new_object(); - uint32_t name_off, args_off, arg_off; - struct uc_function *fn; - struct uc_op *op; - size_t sz; - - sz = ALIGN(sizeof(*op)) + ALIGN(sizeof(*fn)); - - name_off = OPn(decl, 0); - args_off = OPn(decl, 1); - - if (name_off) - sz += ALIGN(json_object_get_string_len(OP_VAL(name_off)) + 1); - - op = xalloc(sz); - - fn = (void *)op + ALIGN(sizeof(*op)); - fn->entry = OPn(decl, 2); - - if (name_off) - fn->name = strcpy((char *)fn + ALIGN(sizeof(*fn)), json_object_get_string(OP_VAL(name_off))); - - if (args_off) { - fn->args = xjs_new_array(); - - for (arg_off = args_off; arg_off != 0; arg_off = OP_NEXT(arg_off)) { - json_object_array_add(fn->args, json_object_get(OP_VAL(arg_off))); - - /* if the last argument is a rest one (...arg), add extra null entry */ - if (OP_IS_ELLIP(arg_off)) { - json_object_array_add(fn->args, NULL); - break; - } - } - } - - fn->source = state->function ? state->function->source : NULL; - fn->parent_scope = uc_acquire_scope(scope); - - op->val = val; - op->type = T_FUNC; - op->is_arrow = (OP_TYPE(decl) == T_ARROW); - op->tag.data = fn; - - json_object_set_serializer(val, func_to_string, op, func_free); - - return op->val; -} - -static void -exception_free(struct json_object *v, void *ud) -{ - free(ud); -} - -static int -exception_to_string(struct json_object *v, struct printbuf *pb, int level, int flags) -{ - return sprintbuf(pb, "%s", json_object_get_string(json_object_object_get(v, "message"))); -} - -static void -add_stacktrace(struct json_object *a, struct uc_function *function, size_t off) { - struct json_object *o = xjs_new_object(); - size_t line = 1, rlen = 0, len; - bool truncated = false; - char buf[256]; - - if (function->source->filename) - json_object_object_add(o, "filename", xjs_new_string(function->source->filename)); - - if (function->name) - json_object_object_add(o, "function", xjs_new_string(function->name)); - - if (function->source->fp) { - fseek(function->source->fp, 0, SEEK_SET); - - while (fgets(buf, sizeof(buf), function->source->fp)) { - len = strlen(buf); - rlen += len; - - if (rlen > off) { - json_object_object_add(o, "line", xjs_new_int64(line)); - json_object_object_add(o, "byte", xjs_new_int64(len - (rlen - off) + (truncated ? sizeof(buf) : 0) + 1)); - break; - } - - truncated = (len > 0 && buf[len-1] != '\n'); - line += !truncated; - } - } - - json_object_array_add(a, o); -} - -__attribute__((format(printf, 3, 4))) struct json_object * -uc_new_exception(struct uc_state *s, uint32_t off, const char *fmt, ...) -{ - struct uc_callstack *callstack, *prevcall, here = {}; - struct json_object *a; - struct uc_op *op; - va_list ap; - char *p; - int len; - - op = xalloc(sizeof(*op)); - op->type = T_EXCEPTION; - op->val = xjs_new_object(); - op->off = off; - op->tag.data = s->function ? s->function->source : s->source; - - a = xjs_new_array(); - - here.next = s->callstack; - here.function = s->function; - here.off = off; - - for (callstack = &here, prevcall = NULL; callstack != NULL; - prevcall = callstack, callstack = callstack->next) - if (callstack->off && callstack->function && callstack->function->source && - (!prevcall || callstack->function != prevcall->function || callstack->off != prevcall->off)) - add_stacktrace(a, callstack->function, callstack->off); - - json_object_object_add(op->val, "stacktrace", a); - - va_start(ap, fmt); - len = xvasprintf(&p, fmt, ap); - va_end(ap); - - json_object_object_add(op->val, "message", xjs_new_string_len(p, len)); - free(p); - - if (s->exception) - json_object_put(s->exception); - - s->exception = op->val; - - json_object_set_serializer(op->val, exception_to_string, op, exception_free); - - return json_object_get(op->val); -} - -static void -scope_free(struct json_object *v, void *ud) -{ - struct uc_scope *sc = ud; - - if (sc->parent) { - uc_release_scope(json_object_get_userdata(sc->parent)); - sc->parent = NULL; - } - - sc->scope = NULL; -} - -void -uc_release_scope(struct uc_scope *sc) -{ - if (sc->refs == 0) - abort(); - - sc->refs--; - - if (sc->refs == 0) - json_object_put(sc->scope); -} - -struct uc_scope * -uc_acquire_scope(struct uc_scope *sc) -{ - sc->refs++; - - return sc; -} - -struct uc_scope * -uc_new_scope(struct uc_state *s, struct uc_scope *parent) -{ - struct uc_scope *sc; - - sc = xalloc(sizeof(*sc)); - sc->scope = xjs_new_object(); - - if (parent) - sc->parent = uc_acquire_scope(parent)->scope; - - json_object_set_userdata(sc->scope, sc, scope_free); - - sc->next = s->scopelist; - s->scopelist = sc; - - return uc_acquire_scope(sc); -} - -struct uc_scope * -uc_parent_scope(struct uc_scope *scope) -{ - return json_object_get_userdata(scope->parent); -} - -static void -uc_reset(struct uc_state *s) -{ - json_object_put(s->exception); - s->exception = NULL; - - free(s->lex.lookbehind); - free(s->lex.buf); - memset(&s->lex, 0, sizeof(s->lex)); -} - -void -uc_free(struct uc_state *s) -{ - struct uc_source *src, *src_next; - struct uc_scope *sc, *sc_next; - struct json_object *scj; - size_t n; - - if (s) { - json_object_put(s->ctx); - - for (n = 0; n < s->poolsize; n++) - json_object_put(s->pool[n].val); - - free(s->pool); - - s->pool = NULL; - s->poolsize = 0; - - uc_reset(s); - - json_object_put(s->rval); - - for (sc = s->scopelist; sc; sc = sc->next) { - scj = sc->scope; - sc->scope = NULL; - json_object_put(scj); - } - - for (sc = s->scopelist; sc; sc = sc_next) { - sc_next = sc->next; - free(sc); - } - - for (src = s->sources; src; src = src_next) { - src_next = src->next; - - if (src->fp) - fclose(src->fp); - - free(src->filename); - free(src); - } - } - - while (uc_ext_types_count > 0) - json_object_put(uc_ext_types[--uc_ext_types_count].proto); - - free(uc_ext_types); - free(s); -} - -struct json_object * -uc_parse(struct uc_state *state, FILE *fp) -{ - void *pParser; - uint32_t off; - - uc_reset(state); - - pParser = ParseAlloc(xalloc); - - while (state->lex.state != UT_LEX_EOF) { - off = uc_get_token(state, fp); - - if (state->exception) - goto out; - - if (off) - Parse(pParser, OP_TYPE(off), off, state); - - if (state->exception) - goto out; - } - - Parse(pParser, 0, 0, state); - -out: - ParseFree(pParser, free); - - return state->exception; -} - -bool -uc_register_extended_type(const char *name, struct json_object *proto, void (*freefn)(void *)) -{ - uc_ext_types = xrealloc(uc_ext_types, (uc_ext_types_count + 1) * sizeof(*uc_ext_types)); - uc_ext_types[uc_ext_types_count].name = name; - uc_ext_types[uc_ext_types_count].free = freefn; - uc_ext_types[uc_ext_types_count].proto = proto; - uc_ext_types_count++; - - return true; -} - -static int -uc_extended_type_to_string(struct json_object *v, struct printbuf *pb, int level, int flags) -{ - bool strict = (level > 0) || (flags & JSON_C_TO_STRING_STRICT); - struct uc_op *op = json_object_get_userdata(v); - struct uc_extended_type *et; - - if (!op) - return 0; - - et = &uc_ext_types[op->tag.type - 1]; - - return sprintbuf(pb, "%s<%s %p>%s", - strict ? "\"" : "", - et->name, op->tag.data, - strict ? "\"" : ""); -} - -static void -uc_extended_type_free(struct json_object *v, void *ud) -{ - struct uc_op *op = json_object_get_userdata(v); - struct uc_extended_type *et; - - if (!op) - return; - - et = &uc_ext_types[op->tag.type - 1]; - - if (et->free && op->tag.data) - et->free(op->tag.data); - - json_object_put(op->tag.proto); - free(ud); -} - -struct json_object * -uc_set_extended_type(struct json_object *v, const char *name, void *data) -{ - struct uc_extended_type *et = NULL; - struct uc_op *op; - size_t n; - - for (n = 0; n < uc_ext_types_count; n++) { - if (!strcmp(name, uc_ext_types[n].name)) { - et = &uc_ext_types[n]; - break; - } - } - - if (!et) - return NULL; - - op = xalloc(sizeof(*op)); - op->val = v; - op->type = T_RESSOURCE; - op->tag.proto = json_object_get(et->proto); - op->tag.type = n + 1; - op->tag.data = data; - - json_object_set_serializer(op->val, uc_extended_type_to_string, op, uc_extended_type_free); - - return op->val; -} - -void ** -uc_get_extended_type(struct json_object *v, const char *name) -{ - struct uc_op *op = json_object_get_userdata(v); - size_t n = op ? op->tag.type : 0; - struct uc_extended_type *et; - - if (!op || op->type != T_RESSOURCE || n == 0 || n > uc_ext_types_count) - return NULL; - - et = &uc_ext_types[n - 1]; - - if (name && strcmp(et->name, name)) - return NULL; - - return &op->tag.data; -} diff --git a/ast.h b/ast.h deleted file mode 100644 index ecc67b3..0000000 --- a/ast.h +++ /dev/null @@ -1,359 +0,0 @@ -/* - * Copyright (C) 2020 Jo-Philipp Wich - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef __AST_H_ -#define __AST_H_ - -#include -#include -#include -#include -#include -#include -#include - -#ifdef JSONC - #include -#else - #include -#endif - -#define ALIGN(x) (((x) + sizeof(size_t) - 1) & -sizeof(size_t)) - -#ifndef ARRAY_SIZE -#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) -#endif - -#define JSON_C_TO_STRING_STRICT (1<<31) - -enum uc_lex_state { - UT_LEX_IDENTIFY_BLOCK, - UT_LEX_BLOCK_COMMENT_START, - UT_LEX_BLOCK_EXPRESSION_START, - UT_LEX_BLOCK_EXPRESSION_EMIT_TAG, - UT_LEX_BLOCK_STATEMENT_START, - UT_LEX_BLOCK_COMMENT, - UT_LEX_IDENTIFY_TOKEN, - UT_LEX_PARSE_TOKEN, - UT_LEX_EOF -}; - -struct uc_op { - uint16_t type; - uint16_t is_first:1; - uint16_t is_op:1; - uint16_t is_overflow:1; - uint16_t is_postfix:1; - uint16_t is_for_in:1; - uint16_t is_list:1; - uint16_t is_reg_icase:1; - uint16_t is_reg_newline:1; - uint16_t is_reg_global:1; - uint16_t is_ellip:1; - uint16_t is_arrow:1; - uint32_t off; - struct json_object *val; - union { - struct { - struct json_object *proto; - size_t type; - void *data; - uint32_t off; - } tag; - struct { - uint32_t next; - uint32_t operand[4]; - } tree; - }; -}; - -struct uc_scope { - struct uc_scope *next; - struct json_object *scope, *parent; - size_t refs; -}; - -struct uc_source { - struct uc_source *next; - char *filename; - uint32_t off; - FILE *fp; -}; - -struct uc_function { - char *name; - union { - struct json_object *args; - void *cfn; - }; - struct uc_scope *parent_scope; - struct uc_source *source; - uint32_t entry; -}; - -struct uc_callstack { - struct uc_callstack *next; - struct uc_function *function; - struct uc_scope *scope; - struct json_object *ctx; - uint32_t off; -}; - -struct uc_state { - struct uc_op *pool; - uint32_t poolsize; - uint32_t main; - uint8_t srand_called:1; - uint8_t trim_blocks:1; - uint8_t lstrip_blocks:1; - uint8_t strict_declarations:1; - struct { - enum uc_lex_state state; - uint8_t eof:1; - uint8_t skip_leading_whitespace:1; - uint8_t skip_leading_newline:1; - uint8_t within_expression_block:1; - uint8_t within_statement_block:1; - uint8_t semicolon_emitted:1; - uint8_t expect_div:1; - uint8_t is_escape:1; - size_t buflen; - char *buf, *bufstart, *bufend; - size_t lookbehindlen; - char *lookbehind; - const void *tok; - char esc[5]; - uint8_t esclen; - int lead_surrogate; - size_t lastoff; - } lex; - struct json_object *ctx, *rval, *exception; - struct uc_scope *scopelist, *scope; - struct uc_source *sources, *source; - struct uc_callstack *callstack; - struct uc_function *function; - size_t calldepth; -}; - -struct uc_extended_type { - const char *name; - struct json_object *proto; - void (*free)(void *); -}; - -static inline bool uc_is_type(struct json_object *val, int type) { - struct uc_op *tag = json_object_get_userdata(val); - - return (tag && tag->type == type); -}; - -#define OP(idx) (&state->pool[idx]) -#define OP_POS(idx) OP(idx)->off -#define OP_VAL(idx) OP(idx)->val -#define OP_TYPE(idx) OP(idx)->type -#define OP_NEXT(idx) OP(idx)->tree.next -#define OP_IS_LIST(idx) OP(idx)->is_list -#define OP_IS_ELLIP(idx) OP(idx)->is_ellip -#define OP_IS_FOR_IN(idx) OP(idx)->is_for_in -#define OP_IS_POSTFIX(idx) OP(idx)->is_postfix - -#define OPn_NUM ARRAY_SIZE(((struct uc_op *)NULL)->tree.operand) -#define OPn(idx, n) OP(idx)->tree.operand[n] -#define OPn_POS(idx, n) OP(OPn(idx, n))->off -#define OPn_VAL(idx, n) OP(OPn(idx, n))->val -#define OPn_TYPE(idx, n) OP(OPn(idx, n))->type -#define OPn_IS_LIST(idx, n) OP(OPn(idx, n))->is_list -#define OPn_IS_OVERFLOW(idx, n) OP(OPn(idx, n))->is_overflow - - - -uint32_t uc_new_op(struct uc_state *s, int type, struct json_object *val, ...); -uint32_t uc_wrap_op(struct uc_state *s, uint32_t parent, ...); -uint32_t uc_append_op(struct uc_state *s, uint32_t a, uint32_t b); -struct json_object *uc_parse(struct uc_state *s, FILE *fp); -void uc_free(struct uc_state *s); - -struct json_object *uc_new_func(struct uc_state *s, uint32_t decl, struct uc_scope *scope); -struct json_object *uc_new_object(struct json_object *proto); -struct json_object *uc_new_double(double v); -struct json_object *uc_new_null(void); -struct json_object *uc_new_regexp(const char *source, bool icase, bool newline, bool global, char **err); - -__attribute__((format(printf, 3, 0))) -struct json_object *uc_new_exception(struct uc_state *s, uint32_t off, const char *fmt, ...); - -struct uc_scope *uc_new_scope(struct uc_state *s, struct uc_scope *parent); -struct uc_scope *uc_parent_scope(struct uc_scope *scope); -struct uc_scope *uc_acquire_scope(struct uc_scope *scope); -void uc_release_scope(struct uc_scope *scope); - -bool uc_register_extended_type(const char *name, struct json_object *proto, void (*freefn)(void *)); -struct json_object *uc_set_extended_type(struct json_object *v, const char *name, void *data); -void **uc_get_extended_type(struct json_object *val, const char *name); - -void *ParseAlloc(void *(*mfunc)(size_t)); -void Parse(void *pParser, int type, uint32_t off, struct uc_state *s); -void ParseFree(void *pParser, void (*ffunc)(void *)); - - -static inline uint32_t getrefcnt(struct json_object *v) { - struct { - enum json_type o_type; - uint32_t _ref_count; - } *spy = (void *)v; - - return spy ? spy->_ref_count : 0; -} - -static inline void *xalloc(size_t size) { - void *ptr = calloc(1, size); - - if (!ptr) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return ptr; -} - -static inline void *xrealloc(void *ptr, size_t size) { - ptr = realloc(ptr, size); - - if (!ptr) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return ptr; -} - -static inline char *xstrdup(const char *s) { - char *ptr = strdup(s); - - if (!ptr) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return ptr; -} - -static inline struct json_object *xjs_new_object(void) { - struct json_object *ptr = json_object_new_object(); - - if (!ptr) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return ptr; -} - -static inline struct json_object *xjs_new_array(void) { - struct json_object *ptr = json_object_new_array(); - - if (!ptr) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return ptr; -} - -static inline struct json_object *xjs_new_int64(int64_t n) { - struct json_object *ptr = json_object_new_int64(n); - - if (!ptr) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return ptr; -} - -static inline struct json_object *xjs_new_string(const char *s) { - struct json_object *ptr = json_object_new_string(s); - - if (!ptr) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return ptr; -} - -static inline struct json_object *xjs_new_string_len(const char *s, size_t len) { - struct json_object *ptr = json_object_new_string_len(s, len); - - if (!ptr) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return ptr; -} - -static inline struct json_object *xjs_new_boolean(bool v) { - struct json_object *ptr = json_object_new_boolean(v); - - if (!ptr) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return ptr; -} - - -static inline struct json_tokener *xjs_new_tokener(void) { - struct json_tokener *tok = json_tokener_new(); - - if (!tok) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return tok; -} - -static inline int xasprintf(char **strp, const char *fmt, ...) { - va_list ap; - int len; - - va_start(ap, fmt); - len = vasprintf(strp, fmt, ap); - va_end(ap); - - if (len == -1) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return len; -} - -static inline int xvasprintf(char **strp, const char *fmt, va_list ap) { - int len = vasprintf(strp, fmt, ap); - - if (len == -1) { - fprintf(stderr, "Out of memory\n"); - abort(); - } - - return len; -} - -#endif /* __AST_H_ */ diff --git a/chunk.c b/chunk.c new file mode 100644 index 0000000..66c24af --- /dev/null +++ b/chunk.c @@ -0,0 +1,211 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +#include "chunk.h" +#include "util.h" + +#define OFFSETINFO_BITS (sizeof(((uc_offsetinfo *)NULL)->entries[0]) * 8) +#define OFFSETINFO_BYTE_BITS 3 +#define OFFSETINFO_INSN_BITS (OFFSETINFO_BITS - OFFSETINFO_BYTE_BITS) +#define OFFSETINFO_MAX_BYTES ((1 << OFFSETINFO_BYTE_BITS) - 1) +#define OFFSETINFO_MAX_INSNS ((1 << OFFSETINFO_INSN_BITS) - 1) +#define OFFSETINFO_NUM_BYTES(n) ((n) & OFFSETINFO_MAX_BYTES) +#define OFFSETINFO_NUM_INSNS(n) ((n) >> OFFSETINFO_BYTE_BITS) +#define OFFSETINFO_ENCODE(line, insns) ((line & OFFSETINFO_MAX_BYTES) | (((insns) << OFFSETINFO_BYTE_BITS) & ~OFFSETINFO_MAX_BYTES)) + + +void +uc_chunk_init(uc_chunk *chunk) +{ + chunk->count = 0; + chunk->entries = NULL; + + chunk->ehranges.count = 0; + chunk->ehranges.entries = NULL; + + chunk->debuginfo.offsets.count = 0; + chunk->debuginfo.offsets.entries = NULL; + + chunk->debuginfo.variables.count = 0; + chunk->debuginfo.variables.entries = NULL; + + uc_vallist_init(&chunk->constants); + uc_vallist_init(&chunk->debuginfo.varnames); +} + +void +uc_chunk_free(uc_chunk *chunk) +{ + uc_vector_clear(chunk); + uc_vector_clear(&chunk->ehranges); + uc_vallist_free(&chunk->constants); + + uc_vector_clear(&chunk->debuginfo.offsets); + uc_vector_clear(&chunk->debuginfo.variables); + uc_vallist_free(&chunk->debuginfo.varnames); + + uc_chunk_init(chunk); +} + +size_t +uc_chunk_add(uc_chunk *chunk, uint8_t byte, size_t offset) +{ + uc_offsetinfo *offsets = &chunk->debuginfo.offsets; + size_t i; + + uc_vector_grow(chunk); + + chunk->entries[chunk->count] = byte; + + /* offset info is encoded in bytes, for each byte, the first three bits + * specify the number of source text bytes to advance since the last entry + * and the remaining five bits specify the amount of instructions belonging + * to any given source text offset */ + if (offset > 0 || offsets->count == 0) { + /* if this offset is farther than seven (2 ** 3 - 1) bytes apart from + * the last one, we need to emit intermediate "jump" bytes with zero + * instructions each */ + for (i = offset; i > OFFSETINFO_MAX_BYTES; i -= OFFSETINFO_MAX_BYTES) { + /* advance by 7 bytes */ + uc_vector_grow(offsets); + offsets->entries[offsets->count++] = OFFSETINFO_ENCODE(OFFSETINFO_MAX_BYTES, 0); + } + + /* advance by `i` bytes, count one instruction */ + uc_vector_grow(offsets); + offsets->entries[offsets->count++] = OFFSETINFO_ENCODE(i, 1); + } + + /* update instruction count at current offset entry */ + else { + /* since we encode the per-offset instruction count in five bits, we + * can only count up to 31 instructions. If we exceed that limit, + * emit another offset entry with the initial three bits set to zero */ + if (OFFSETINFO_NUM_INSNS(offsets->entries[offsets->count - 1]) >= OFFSETINFO_MAX_INSNS) { + /* advance by 0 bytes, count one instruction */ + uc_vector_grow(offsets); + offsets->entries[offsets->count++] = OFFSETINFO_ENCODE(0, 1); + } + else { + offsets->entries[offsets->count - 1] = OFFSETINFO_ENCODE( + OFFSETINFO_NUM_BYTES(offsets->entries[offsets->count - 1]), + OFFSETINFO_NUM_INSNS(offsets->entries[offsets->count - 1]) + 1 + ); + } + } + + return chunk->count++; +} + +void +uc_chunk_pop(uc_chunk *chunk) +{ + uc_offsetinfo *offsets = &chunk->debuginfo.offsets; + int n_insns; + + assert(chunk->count > 0); + + chunk->count--; + + n_insns = OFFSETINFO_NUM_INSNS(offsets->entries[offsets->count - 1]); + + if (n_insns > 0) { + offsets->entries[offsets->count - 1] = OFFSETINFO_ENCODE( + OFFSETINFO_NUM_BYTES(offsets->entries[offsets->count - 1]), + n_insns - 1 + ); + } + else { + offsets->count--; + } +} + +struct json_object * +uc_chunk_get_constant(uc_chunk *chunk, size_t idx) +{ + return uc_vallist_get(&chunk->constants, idx); +} + +ssize_t +uc_chunk_add_constant(uc_chunk *chunk, struct json_object *val) +{ + return uc_vallist_add(&chunk->constants, val); +} + +size_t +uc_chunk_debug_get_srcpos(uc_chunk *chunk, size_t off) +{ + uc_offsetinfo *offsets = &chunk->debuginfo.offsets; + size_t i, inum = 0, lnum = 0; + + if (!offsets->count) + return 0; + + for (i = 0; i < offsets->count && inum < off; i++) { + lnum += OFFSETINFO_NUM_BYTES(offsets->entries[i]); + inum += OFFSETINFO_NUM_INSNS(offsets->entries[i]); + } + + return lnum; +} + +void +uc_chunk_debug_add_variable(uc_chunk *chunk, size_t from, size_t to, size_t slot, bool upval, json_object *name) +{ + uc_variables *variables = &chunk->debuginfo.variables; + uc_value_list *varnames = &chunk->debuginfo.varnames; + + assert(slot <= ((size_t)-1 / 2)); + + if (upval) + slot += (size_t)-1 / 2; + + uc_vector_grow(variables); + + variables->entries[variables->count].nameidx = uc_vallist_add(varnames, name); + variables->entries[variables->count].slot = slot; + variables->entries[variables->count].from = from; + variables->entries[variables->count].to = to; + + variables->count++; +} + +json_object * +uc_chunk_debug_get_variable(uc_chunk *chunk, size_t off, size_t slot, bool upval) +{ + uc_variables *variables = &chunk->debuginfo.variables; + uc_value_list *varnames = &chunk->debuginfo.varnames; + json_object *name = NULL; + size_t i; + + assert(slot <= ((size_t)-1 / 2)); + + if (upval) + slot += (size_t)-1 / 2; + + for (i = 0; i < variables->count; i++) { + if (variables->entries[i].slot != slot || + variables->entries[i].from > off || + variables->entries[i].to < off) + continue; + + name = uc_vallist_get(varnames, variables->entries[i].nameidx); + } + + return name; +} diff --git a/chunk.h b/chunk.h new file mode 100644 index 0000000..a3eed0e --- /dev/null +++ b/chunk.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef __CHUNK_H_ +#define __CHUNK_H_ + +#include +#include + +#include "value.h" +#include "util.h" + + +typedef struct { + size_t from, to, target, slot; +} uc_ehrange; + +typedef struct { + size_t from, to, slot, nameidx; +} uc_varrange; + +uc_declare_vector(uc_ehranges, uc_ehrange); +uc_declare_vector(uc_variables, uc_varrange); +uc_declare_vector(uc_offsetinfo, uint8_t); + +typedef struct { + size_t count; + uint8_t *entries; + uc_value_list constants; + uc_ehranges ehranges; + struct { + uc_variables variables; + uc_value_list varnames; + uc_offsetinfo offsets; + } debuginfo; +} uc_chunk; + +void uc_chunk_init(uc_chunk *chunk); +void uc_chunk_free(uc_chunk *chunk); +size_t uc_chunk_add(uc_chunk *chunk, uint8_t byte, size_t line); + +ssize_t uc_chunk_add_constant(uc_chunk *chunk, struct json_object *value); +struct json_object *uc_chunk_get_constant(uc_chunk *chunk, size_t idx); +void uc_chunk_pop(uc_chunk *chunk); + +size_t uc_chunk_debug_get_srcpos(uc_chunk *chunk, size_t off); +void uc_chunk_debug_add_variable(uc_chunk *chunk, size_t from, size_t to, size_t slot, bool upval, json_object *name); +json_object *uc_chunk_debug_get_variable(uc_chunk *chunk, size_t off, size_t slot, bool upval); + +#endif /* __CHUNK_H_ */ diff --git a/compiler.c b/compiler.c new file mode 100644 index 0000000..e1e9f06 --- /dev/null +++ b/compiler.c @@ -0,0 +1,2590 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +#include "compiler.h" +#include "chunk.h" +#include "vm.h" /* I_* */ +#include "source.h" +#include "lib.h" /* format_error_context() */ + +static void uc_compiler_compile_unary(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_binary(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_paren(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_call(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_post_inc(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_constant(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_comma(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_labelexpr(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_function(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_and(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_or(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_dot(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_subscript(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_ternary(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_array(uc_compiler *compiler, bool assignable); +static void uc_compiler_compile_object(uc_compiler *compiler, bool assignable); + +static void uc_compiler_compile_declaration(uc_compiler *compiler); +static void uc_compiler_compile_statement(uc_compiler *compiler); +static void uc_compiler_compile_expstmt(uc_compiler *compiler); + +static uc_parse_rule +uc_compiler_parse_rules[TK_ERROR + 1] = { + [TK_LPAREN] = { uc_compiler_compile_paren, uc_compiler_compile_call, P_CALL }, + [TK_SUB] = { uc_compiler_compile_unary, uc_compiler_compile_binary, P_ADD }, + [TK_ADD] = { uc_compiler_compile_unary, uc_compiler_compile_binary, P_ADD }, + [TK_COMPL] = { uc_compiler_compile_unary, NULL, P_UNARY }, + [TK_NOT] = { uc_compiler_compile_unary, NULL, P_UNARY }, + [TK_INC] = { uc_compiler_compile_unary, uc_compiler_compile_post_inc, P_INC }, + [TK_DEC] = { uc_compiler_compile_unary, uc_compiler_compile_post_inc, P_INC }, + [TK_DIV] = { NULL, uc_compiler_compile_binary, P_MUL }, + [TK_MUL] = { NULL, uc_compiler_compile_binary, P_MUL }, + [TK_MOD] = { NULL, uc_compiler_compile_binary, P_MUL }, + [TK_NUMBER] = { uc_compiler_compile_constant, NULL, P_NONE }, + [TK_DOUBLE] = { uc_compiler_compile_constant, NULL, P_NONE }, + [TK_STRING] = { uc_compiler_compile_constant, NULL, P_NONE }, + [TK_BOOL] = { uc_compiler_compile_constant, NULL, P_NONE }, + [TK_NULL] = { uc_compiler_compile_constant, NULL, P_NONE }, + [TK_THIS] = { uc_compiler_compile_constant, NULL, P_NONE }, + [TK_REGEXP] = { uc_compiler_compile_constant, NULL, P_NONE }, + [TK_COMMA] = { NULL, uc_compiler_compile_comma, P_COMMA }, + [TK_LABEL] = { uc_compiler_compile_labelexpr, NULL, P_NONE }, + [TK_FUNC] = { uc_compiler_compile_function, NULL, P_NONE }, + [TK_AND] = { NULL, uc_compiler_compile_and, P_AND }, + [TK_OR] = { NULL, uc_compiler_compile_or, P_OR }, + [TK_BOR] = { NULL, uc_compiler_compile_binary, P_BOR }, + [TK_BXOR] = { NULL, uc_compiler_compile_binary, P_BXOR }, + [TK_BAND] = { NULL, uc_compiler_compile_binary, P_BAND }, + [TK_EQ] = { NULL, uc_compiler_compile_binary, P_EQUAL }, + [TK_EQS] = { NULL, uc_compiler_compile_binary, P_EQUAL }, + [TK_NE] = { NULL, uc_compiler_compile_binary, P_EQUAL }, + [TK_NES] = { NULL, uc_compiler_compile_binary, P_EQUAL }, + [TK_LT] = { NULL, uc_compiler_compile_binary, P_COMPARE }, + [TK_LE] = { NULL, uc_compiler_compile_binary, P_COMPARE }, + [TK_GT] = { NULL, uc_compiler_compile_binary, P_COMPARE }, + [TK_GE] = { NULL, uc_compiler_compile_binary, P_COMPARE }, + [TK_IN] = { NULL, uc_compiler_compile_binary, P_COMPARE }, + [TK_LSHIFT] = { NULL, uc_compiler_compile_binary, P_SHIFT }, + [TK_RSHIFT] = { NULL, uc_compiler_compile_binary, P_SHIFT }, + [TK_DOT] = { NULL, uc_compiler_compile_dot, P_CALL }, + [TK_LBRACK] = { uc_compiler_compile_array, uc_compiler_compile_subscript, P_CALL }, + [TK_QMARK] = { NULL, uc_compiler_compile_ternary, P_TERNARY }, + [TK_LBRACE] = { uc_compiler_compile_object, NULL, P_NONE }, +}; + +static ssize_t +uc_compiler_declare_local(uc_compiler *compiler, json_object *name); + +static ssize_t +uc_compiler_initialize_local(uc_compiler *compiler); + +static void +uc_compiler_init(uc_compiler *compiler, const char *name, size_t srcpos, uc_source *source) +{ + json_object *varname = xjs_new_string("(callee)"); + + compiler->scope_depth = 0; + + compiler->function = uc_function_new(name, srcpos, source); + + compiler->locals.count = 0; + compiler->locals.entries = NULL; + + compiler->upvals.count = 0; + compiler->upvals.entries = NULL; + + compiler->patchlist = NULL; + + compiler->parent = NULL; + + compiler->current_srcpos = srcpos; + + /* reserve stack slot 0 */ + uc_compiler_declare_local(compiler, varname); + uc_compiler_initialize_local(compiler); + uc_value_put(varname); +} + +static uc_chunk * +uc_compiler_current_chunk(uc_compiler *compiler) +{ + return &compiler->function->chunk; +} + +__attribute__((format(printf, 3, 0))) static void +uc_compiler_syntax_error(uc_compiler *compiler, size_t off, const char *fmt, ...) +{ + size_t line = 0, byte = 0, len = 0; + char *context = NULL; + char *s, *tmp; + va_list ap; + + if (compiler->parser->synchronizing) + return; + + compiler->parser->synchronizing = true; + + if (!off) + off = uc_function_get_srcpos(compiler->function, + uc_compiler_current_chunk(compiler)->count); + + if (off) { + byte = off; + line = uc_source_get_line(compiler->function->source, &byte); + + format_error_context(&context, &len, compiler->function->source, NULL, off); + } + + va_start(ap, fmt); + xvasprintf(&s, fmt, ap); + va_end(ap); + + xasprintf(&tmp, "Syntax error: %s\n", s); + free(s); + s = tmp; + + if (line) { + xasprintf(&tmp, "%sIn line %zu, byte %zu:\n", s, line, byte); + free(s); + s = tmp; + } + + if (context) { + xasprintf(&tmp, "%s%s\n\n", s, context); + free(context); + free(s); + s = tmp; + } + + if (compiler->parser->error) { + xasprintf(&tmp, "%s%s", compiler->parser->error, s); + free(compiler->parser->error); + free(s); + compiler->parser->error = tmp; + } + else { + compiler->parser->error = s; + } +} + +static size_t +uc_compiler_set_srcpos(uc_compiler *compiler, size_t srcpos) +{ + size_t delta; + + /* ensure that lines counts are strictly increasing */ + assert(srcpos == 0 || srcpos >= compiler->current_srcpos); + + delta = srcpos ? srcpos - compiler->current_srcpos : 0; + compiler->current_srcpos += delta; + + return delta; +} + +static void +uc_compiler_parse_advance(uc_compiler *compiler) +{ + uc_value_put(compiler->parser->prev.val); + compiler->parser->prev = compiler->parser->curr; + + while (true) { + compiler->parser->curr = *uc_lexer_next_token(&compiler->parser->lex); + + if (compiler->parser->curr.type != TK_ERROR) + break; + + uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "%s", + json_object_get_string(compiler->parser->curr.val)); + + uc_value_put(compiler->parser->curr.val); + compiler->parser->curr.val = NULL; + } +} + +static void +uc_compiler_parse_consume(uc_compiler *compiler, uc_tokentype_t type) +{ + if (compiler->parser->curr.type == type) { + uc_compiler_parse_advance(compiler); + + return; + } + + uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, + "Unexpected token\nExpecting %s", uc_get_tokenname(type)); +} + +static bool +uc_compiler_parse_check(uc_compiler *compiler, uc_tokentype_t type) +{ + return (compiler->parser->curr.type == type); +} + +static bool +uc_compiler_parse_match(uc_compiler *compiler, uc_tokentype_t type) +{ + if (!uc_compiler_parse_check(compiler, type)) + return false; + + uc_compiler_parse_advance(compiler); + + return true; +} + +static void +uc_compiler_parse_synchronize(uc_compiler *compiler) +{ + compiler->parser->synchronizing = false; + + while (compiler->parser->curr.type != TK_EOF) { + if (compiler->parser->prev.type == TK_SCOL) + return; + + switch (compiler->parser->curr.type) { + case TK_IF: + case TK_FOR: + case TK_WHILE: + case TK_SWITCH: + case TK_FUNC: + case TK_TRY: + case TK_RETURN: + case TK_BREAK: + case TK_CONTINUE: + case TK_LOCAL: + return; + + default: + break; + } + + uc_compiler_parse_advance(compiler); + } +} + +static uc_parse_rule * +uc_compiler_parse_rule(uc_tokentype_t type) +{ + return &uc_compiler_parse_rules[type]; +} + +static bool +uc_compiler_parse_at_assignment_op(uc_compiler *compiler) +{ + switch (compiler->parser->curr.type) { + case TK_ASBAND: + case TK_ASBXOR: + case TK_ASBOR: + case TK_ASLEFT: + case TK_ASRIGHT: + case TK_ASMUL: + case TK_ASDIV: + case TK_ASMOD: + case TK_ASADD: + case TK_ASSUB: + case TK_ASSIGN: + return true; + + default: + return false; + } +} + +static void +uc_compiler_parse_precedence(uc_compiler *compiler, uc_precedence_t precedence) +{ + uc_parse_rule *rule; + bool assignable; + + uc_compiler_parse_advance(compiler); + + rule = uc_compiler_parse_rule(compiler->parser->prev.type); + + if (!rule->prefix) { + uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, "Expecting expression"); + + return; + } + + assignable = (precedence <= P_ASSIGN); + rule->prefix(compiler, assignable); + + while (precedence <= uc_compiler_parse_rule(compiler->parser->curr.type)->precedence) { + uc_compiler_parse_advance(compiler); + uc_compiler_parse_rule(compiler->parser->prev.type)->infix(compiler, assignable); + } + + if (assignable && uc_compiler_parse_at_assignment_op(compiler)) + uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, "Invalid left-hand side expression for assignment"); +} + +static size_t +uc_compiler_reladdr(uc_compiler *compiler, size_t from, size_t to) +{ + ssize_t delta = to - from; + + if (delta < -0x7fffffff || delta > 0x7fffffff) { + uc_compiler_syntax_error(compiler, 0, "Jump address too far"); + + return 0; + } + + return (size_t)(delta + 0x7fffffff); +} + +static size_t +uc_compiler_emit_insn(uc_compiler *compiler, size_t srcpos, enum insn_type insn) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos); + + compiler->last_insn = uc_chunk_add(chunk, (uint8_t)insn, lineoff); + + return compiler->last_insn; +} + +static size_t +uc_compiler_emit_u8(uc_compiler *compiler, size_t srcpos, uint8_t n) +{ + return uc_chunk_add( + uc_compiler_current_chunk(compiler), + n, + uc_compiler_set_srcpos(compiler, srcpos)); +} + +static size_t +uc_compiler_emit_s8(uc_compiler *compiler, size_t srcpos, int8_t n) +{ + return uc_chunk_add( + uc_compiler_current_chunk(compiler), + n + 0x7f, + uc_compiler_set_srcpos(compiler, srcpos)); +} + +static size_t +uc_compiler_emit_u16(uc_compiler *compiler, size_t srcpos, uint16_t n) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos); + + uc_chunk_add(chunk, n / 0x100, lineoff); + uc_chunk_add(chunk, n % 0x100, 0); + + return chunk->count - 2; +} + +static size_t +uc_compiler_emit_s16(uc_compiler *compiler, size_t srcpos, int16_t n) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos); + uint16_t v = n + 0x7fff; + + uc_chunk_add(chunk, v / 0x100, lineoff); + uc_chunk_add(chunk, v % 0x100, 0); + + return chunk->count - 2; +} + +static size_t +uc_compiler_emit_u32(uc_compiler *compiler, size_t srcpos, uint32_t n) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos); + + uc_chunk_add(chunk, n / 0x1000000, lineoff); + uc_chunk_add(chunk, (n / 0x10000) % 0x100, 0); + uc_chunk_add(chunk, (n / 0x100) % 0x100, 0); + uc_chunk_add(chunk, n % 0x100, 0); + + return chunk->count - 4; +} + +static size_t +uc_compiler_emit_s32(uc_compiler *compiler, size_t srcpos, int32_t n) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos); + uint32_t v = n + 0x7fffffff; + + uc_chunk_add(chunk, v / 0x1000000, lineoff); + uc_chunk_add(chunk, (v / 0x10000) % 0x100, 0); + uc_chunk_add(chunk, (v / 0x100) % 0x100, 0); + uc_chunk_add(chunk, v % 0x100, 0); + + return chunk->count - 4; +} + +static uint32_t +uc_compiler_get_u32(uc_compiler *compiler, size_t off) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + + return chunk->entries[off + 0] * 0x1000000 + + chunk->entries[off + 1] * 0x10000 + + chunk->entries[off + 2] * 0x100 + + chunk->entries[off + 3]; +} + +static void +uc_compiler_set_u32(uc_compiler *compiler, size_t off, uint32_t n) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + + chunk->entries[off + 0] = n / 0x1000000; + chunk->entries[off + 1] = (n / 0x10000) % 0x100; + chunk->entries[off + 2] = (n / 0x100) % 0x100; + chunk->entries[off + 3] = n % 0x100; +} + +static size_t +uc_compiler_emit_constant(uc_compiler *compiler, size_t srcpos, json_object *val) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t cidx = uc_chunk_add_constant(chunk, val); + + uc_compiler_emit_insn(compiler, srcpos, I_LOAD); + uc_compiler_emit_u32(compiler, 0, cidx); + + return cidx; +} + +static size_t +uc_compiler_emit_regexp(uc_compiler *compiler, size_t srcpos, json_object *val) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t cidx = uc_chunk_add_constant(chunk, val); + + uc_compiler_emit_insn(compiler, srcpos, I_LREXP); + uc_compiler_emit_u32(compiler, 0, cidx); + + return cidx; +} + +static size_t +uc_compiler_emit_jmp(uc_compiler *compiler, size_t srcpos, uint32_t dest) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + + uc_compiler_emit_insn(compiler, srcpos, I_JMP); + uc_compiler_emit_u32(compiler, 0, dest ? uc_compiler_reladdr(compiler, chunk->count - 1, dest) : 0); + + return chunk->count - 5; +} + +static size_t +uc_compiler_emit_jmpz(uc_compiler *compiler, size_t srcpos, uint32_t dest) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + + uc_compiler_emit_insn(compiler, srcpos, I_JMPZ); + uc_compiler_emit_u32(compiler, 0, dest ? uc_compiler_reladdr(compiler, chunk->count - 1, dest) : 0); + + return chunk->count - 5; +} + +static ssize_t +uc_compiler_get_jmpaddr(uc_compiler *compiler, size_t off) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + + assert(chunk->entries[off] == I_JMP || chunk->entries[off] == I_JMPZ); + assert(off + 4 < chunk->count); + + return ( + chunk->entries[off + 1] * 0x1000000 + + chunk->entries[off + 2] * 0x10000 + + chunk->entries[off + 3] * 0x100 + + chunk->entries[off + 4] + ) - 0x7fffffff; +} + +static void +uc_compiler_set_jmpaddr(uc_compiler *compiler, size_t off, uint32_t dest) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t addr = uc_compiler_reladdr(compiler, off, dest); + + assert(chunk->entries[off] == I_JMP || chunk->entries[off] == I_JMPZ); + assert(off + 4 < chunk->count); + + chunk->entries[off + 1] = addr / 0x1000000; + chunk->entries[off + 2] = (addr / 0x10000) % 0x100; + chunk->entries[off + 3] = (addr / 0x100) % 0x100; + chunk->entries[off + 4] = addr % 0x100; +} + +static uc_function * +uc_compiler_finish(uc_compiler *compiler) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + uc_locals *locals = &compiler->locals; + uc_upvals *upvals = &compiler->upvals; + size_t i; + + uc_compiler_emit_insn(compiler, 0, I_LNULL); + uc_compiler_emit_insn(compiler, 0, I_RETURN); + + for (i = 0; i < locals->count; i++) { + uc_chunk_debug_add_variable(chunk, + locals->entries[i].from, + chunk->count, + i, + false, + locals->entries[i].name); + + uc_value_put(locals->entries[i].name); + } + + for (i = 0; i < upvals->count; i++) { + uc_chunk_debug_add_variable(chunk, + 0, + chunk->count, + i, + true, + upvals->entries[i].name); + + uc_value_put(upvals->entries[i].name); + } + + uc_vector_clear(locals); + uc_vector_clear(upvals); + + if (compiler->parser->error) { + uc_value_put(compiler->function->header.jso); + + return NULL; + } + + return compiler->function; +} + +static void +uc_compiler_enter_scope(uc_compiler *compiler) +{ + compiler->scope_depth++; +} + +static void +uc_compiler_leave_scope(uc_compiler *compiler) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + uc_locals *locals = &compiler->locals; + + compiler->scope_depth--; + + while (locals->count > 0 && locals->entries[locals->count - 1].depth > compiler->scope_depth) { + locals->count--; + + uc_chunk_debug_add_variable(chunk, + locals->entries[locals->count].from, + chunk->count, + locals->count, + false, + locals->entries[locals->count].name); + + uc_value_put(locals->entries[locals->count].name); + locals->entries[locals->count].name = NULL; + + uc_compiler_emit_insn(compiler, 0, + locals->entries[locals->count].captured ? I_CUPV : I_POP); + } +} + +static ssize_t +uc_compiler_declare_local(uc_compiler *compiler, json_object *name) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + uc_locals *locals = &compiler->locals; + const char *str1, *str2; + size_t i, len1, len2; + + //if (compiler->scope_depth == 0) + // return; + + if (locals->count >= 0x00FFFFFF) { + uc_compiler_syntax_error(compiler, 0, "Too many local variables"); + + return -1; + } + + str1 = json_object_get_string(name); + len1 = json_object_get_string_len(name); + + for (i = locals->count; i > 0; i--) { + if (locals->entries[i - 1].depth != -1 && locals->entries[i - 1].depth < compiler->scope_depth) + break; + + str2 = json_object_get_string(locals->entries[i - 1].name); + len2 = json_object_get_string_len(locals->entries[i - 1].name); + + if (len1 == len2 && !strcmp(str1, str2)) { + if (compiler->parser->config && + compiler->parser->config->strict_declarations) { + uc_compiler_syntax_error(compiler, 0, "Variable '%s' redeclared", str2); + + return -1; + } + + return i - 1; + } + } + + uc_vector_grow(locals); + + locals->entries[locals->count].name = uc_value_get(name); + locals->entries[locals->count].depth = -1; + locals->entries[locals->count].captured = false; + locals->entries[locals->count].from = chunk->count; + locals->count++; + + return -1; +} + +static ssize_t +uc_compiler_initialize_local(uc_compiler *compiler) +{ + uc_locals *locals = &compiler->locals; + + locals->entries[locals->count - 1].depth = compiler->scope_depth; + + return locals->count - 1; +} + +static ssize_t +uc_compiler_resolve_local(uc_compiler *compiler, json_object *name) +{ + uc_locals *locals = &compiler->locals; + const char *str1, *str2; + size_t i, len1, len2; + + str1 = json_object_get_string(name); + len1 = json_object_get_string_len(name); + + for (i = locals->count; i > 0; i--) { + str2 = json_object_get_string(locals->entries[i - 1].name); + len2 = json_object_get_string_len(locals->entries[i - 1].name); + + if (len1 != len2 || strcmp(str1, str2)) + continue; + + if (locals->entries[i - 1].depth == -1) { + uc_compiler_syntax_error(compiler, 0, + "Can't access lexical declaration '%s' before initialization", str2); + + return -1; + } + + return i - 1; + } + + return -1; +} + +static ssize_t +uc_compiler_add_upval(uc_compiler *compiler, ssize_t idx, bool local, json_object *name) +{ + uc_function *function = compiler->function; + uc_upvals *upvals = &compiler->upvals; + uc_upval *uv; + size_t i; + + for (i = 0, uv = upvals->entries; i < upvals->count; i++, uv = upvals->entries + i) + if (uv->index == idx && uv->local == local) + return i; + + /* XXX: encoding... */ + if (upvals->count >= (2 << 14)) { + uc_compiler_syntax_error(compiler, 0, "Too many upvalues"); + + return -1; + } + + uc_vector_grow(upvals); + + upvals->entries[upvals->count].local = local; + upvals->entries[upvals->count].index = idx; + upvals->entries[upvals->count].name = uc_value_get(name); + + function->nupvals++; + + return upvals->count++; +} + +static ssize_t +uc_compiler_resolve_upval(uc_compiler *compiler, json_object *name) +{ + ssize_t idx; + + if (!compiler->parent) + return -1; + + idx = uc_compiler_resolve_local(compiler->parent, name); + + if (idx > -1) { + compiler->parent->locals.entries[idx].captured = true; + + return uc_compiler_add_upval(compiler, idx, true, name); + } + + idx = uc_compiler_resolve_upval(compiler->parent, name); + + if (idx > -1) + return uc_compiler_add_upval(compiler, idx, false, name); + + return -1; +} + +static void +uc_compiler_backpatch(uc_compiler *compiler, size_t break_addr, size_t next_addr) +{ + uc_patchlist *pl = compiler->patchlist; + uc_patchlist *pp = pl->parent; + volatile ssize_t jmpaddr; + size_t i; + + for (i = 0; i < pl->count; i++) { + jmpaddr = uc_compiler_get_jmpaddr(compiler, pl->entries[i]); + + switch (jmpaddr) { + case TK_BREAK: + /* if we have a break addr, patch instruction */ + if (break_addr) { + uc_compiler_set_jmpaddr(compiler, pl->entries[i], break_addr); + continue; + } + + break; + + case TK_CONTINUE: + /* if we have a continue addr, patch instruction */ + if (next_addr) { + uc_compiler_set_jmpaddr(compiler, pl->entries[i], next_addr); + continue; + } + + break; + } + + /* propagate unhandled patch instructions to parent patch list */ + if (pp) { + uc_vector_grow(pp); + pp->entries[pp->count++] = pl->entries[i]; + } + } + + free(pl->entries); + + compiler->patchlist = pl->parent; +} + +static void +uc_compiler_emit_inc_dec(uc_compiler *compiler, uc_tokentype_t toktype, bool is_postfix) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + enum insn_type type; + uint32_t cidx = 0; + + /* determine kind of emitted load instruction and operand value (if any) */ + type = chunk->entries[compiler->last_insn]; + + if (type == I_LVAR || type == I_LLOC || type == I_LUPV) { + cidx = uc_compiler_get_u32(compiler, compiler->last_insn + 1); + + uc_chunk_pop(chunk); + uc_chunk_pop(chunk); + uc_chunk_pop(chunk); + uc_chunk_pop(chunk); + uc_chunk_pop(chunk); + } + + /* if we're mutating an object or array field, pop the last lval instruction + * to leave object + last field name value on stack */ + else if (type == I_LVAL) { + uc_chunk_pop(chunk); + } + else { + uc_compiler_syntax_error(compiler, 0, "Invalid increment/decrement operand"); + + return; + } + + /* add / substract 1 */ + uc_compiler_emit_insn(compiler, 0, I_LOAD8); + uc_compiler_emit_s8(compiler, 0, (toktype == TK_INC) ? 1 : -1); + + /* depending on variable type, emit corresponding increment instruction */ + switch (type) { + case I_LVAR: + uc_compiler_emit_insn(compiler, 0, I_UVAR); + uc_compiler_emit_u32(compiler, 0, (I_PLUS << 24) | cidx); + break; + + case I_LLOC: + uc_compiler_emit_insn(compiler, 0, I_ULOC); + uc_compiler_emit_u32(compiler, 0, (I_PLUS << 24) | cidx); + break; + + case I_LUPV: + uc_compiler_emit_insn(compiler, 0, I_UUPV); + uc_compiler_emit_u32(compiler, 0, (I_PLUS << 24) | cidx); + break; + + case I_LVAL: + uc_compiler_emit_insn(compiler, 0, I_UVAL); + uc_compiler_emit_u8(compiler, 0, I_PLUS); + break; + + default: + break; + } + + /* for post increment or decrement, add/substract 1 to yield final value */ + if (is_postfix) { + uc_compiler_emit_insn(compiler, 0, I_LOAD8); + uc_compiler_emit_s8(compiler, 0, 1); + + uc_compiler_emit_insn(compiler, 0, (toktype == TK_INC) ? I_SUB : I_ADD); + } +} + + +static void +uc_compiler_compile_unary(uc_compiler *compiler, bool assignable) +{ + uc_tokentype_t type = compiler->parser->prev.type; + + uc_compiler_parse_precedence(compiler, P_UNARY); + + switch (type) { + case TK_SUB: + uc_compiler_emit_insn(compiler, 0, I_MINUS); + break; + + case TK_ADD: + uc_compiler_emit_insn(compiler, 0, I_PLUS); + break; + + case TK_NOT: + uc_compiler_emit_insn(compiler, 0, I_NOT); + break; + + case TK_COMPL: + uc_compiler_emit_insn(compiler, 0, I_COMPL); + break; + + case TK_INC: + case TK_DEC: + uc_compiler_emit_inc_dec(compiler, type, false); + break; + + default: + return; + } +} + +static void +uc_compiler_compile_binary(uc_compiler *compiler, bool assignable) +{ + uc_tokentype_t type = compiler->parser->prev.type; + + uc_compiler_parse_precedence(compiler, uc_compiler_parse_rule(type)->precedence + 1); + + switch (type) { + case TK_ADD: uc_compiler_emit_insn(compiler, 0, I_ADD); break; + case TK_SUB: uc_compiler_emit_insn(compiler, 0, I_SUB); break; + case TK_MUL: uc_compiler_emit_insn(compiler, 0, I_MUL); break; + case TK_DIV: uc_compiler_emit_insn(compiler, 0, I_DIV); break; + case TK_MOD: uc_compiler_emit_insn(compiler, 0, I_MOD); break; + case TK_LSHIFT: uc_compiler_emit_insn(compiler, 0, I_LSHIFT); break; + case TK_RSHIFT: uc_compiler_emit_insn(compiler, 0, I_RSHIFT); break; + case TK_BAND: uc_compiler_emit_insn(compiler, 0, I_BAND); break; + case TK_BXOR: uc_compiler_emit_insn(compiler, 0, I_BXOR); break; + case TK_BOR: uc_compiler_emit_insn(compiler, 0, I_BOR); break; + case TK_LT: uc_compiler_emit_insn(compiler, 0, I_LT); break; + case TK_LE: + uc_compiler_emit_insn(compiler, 0, I_GT); + uc_compiler_emit_insn(compiler, 0, I_NOT); + break; + case TK_GT: uc_compiler_emit_insn(compiler, 0, I_GT); break; + case TK_GE: + uc_compiler_emit_insn(compiler, 0, I_LT); + uc_compiler_emit_insn(compiler, 0, I_NOT); + break; + case TK_EQ: uc_compiler_emit_insn(compiler, 0, I_EQ); break; + case TK_NE: uc_compiler_emit_insn(compiler, 0, I_NE); break; + case TK_EQS: uc_compiler_emit_insn(compiler, 0, I_EQS); break; + case TK_NES: uc_compiler_emit_insn(compiler, 0, I_NES); break; + case TK_IN: uc_compiler_emit_insn(compiler, 0, I_IN); break; + default: + return; + } +} + +static enum insn_type +uc_compiler_emit_variable_rw(uc_compiler *compiler, json_object *varname, uc_tokentype_t type) +{ + enum insn_type insn; + uint32_t sub_insn; + ssize_t idx; + + switch (type) { + case TK_ASADD: sub_insn = I_ADD; break; + case TK_ASSUB: sub_insn = I_SUB; break; + case TK_ASMUL: sub_insn = I_MUL; break; + case TK_ASDIV: sub_insn = I_DIV; break; + case TK_ASMOD: sub_insn = I_MOD; break; + case TK_ASBAND: sub_insn = I_BAND; break; + case TK_ASBXOR: sub_insn = I_BXOR; break; + case TK_ASBOR: sub_insn = I_BOR; break; + case TK_ASLEFT: sub_insn = I_LSHIFT; break; + case TK_ASRIGHT: sub_insn = I_RSHIFT; break; + default: sub_insn = 0; break; + } + + if (!varname) { + insn = sub_insn ? I_UVAL : (type ? I_SVAL : I_LVAL); + + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn); + + if (sub_insn) + uc_compiler_emit_u8(compiler, compiler->parser->prev.pos, sub_insn); + } + else if ((idx = uc_compiler_resolve_local(compiler, varname)) > -1) { + insn = sub_insn ? I_ULOC : (type ? I_SLOC : I_LLOC); + + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn); + uc_compiler_emit_u32(compiler, compiler->parser->prev.pos, + ((sub_insn & 0xff) << 24) | idx); + } + else if ((idx = uc_compiler_resolve_upval(compiler, varname)) > -1) { + insn = sub_insn ? I_UUPV : (type ? I_SUPV : I_LUPV); + + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn); + uc_compiler_emit_u32(compiler, compiler->parser->prev.pos, + ((sub_insn & 0xff) << 24) | idx); + } + else { + idx = uc_chunk_add_constant(uc_compiler_current_chunk(compiler), varname); + insn = sub_insn ? I_UVAR : (type ? I_SVAR : I_LVAR); + + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn); + uc_compiler_emit_u32(compiler, compiler->parser->prev.pos, + ((sub_insn & 0xff) << 24) | idx); + } + + return insn; +} + +static void +uc_compiler_compile_expression(uc_compiler *compiler) +{ + uc_compiler_parse_precedence(compiler, P_COMMA); +} + +static bool +uc_compiler_compile_assignment(uc_compiler *compiler, json_object *var) +{ + uc_tokentype_t type = compiler->parser->curr.type; + + if (uc_compiler_parse_at_assignment_op(compiler)) { + uc_compiler_parse_advance(compiler); + uc_compiler_parse_precedence(compiler, P_ASSIGN); + uc_compiler_emit_variable_rw(compiler, var, type); + + return true; + } + + return false; +} + +static bool +uc_compiler_compile_arrowfn(uc_compiler *compiler, json_object *args, bool restarg) +{ + bool array = json_object_is_type(args, json_type_array); + uc_compiler fncompiler = {}; + size_t i, pos, load_off; + uc_function *fn; + ssize_t slot; + + if (!uc_compiler_parse_match(compiler, TK_ARROW)) + return false; + + pos = compiler->parser->prev.pos; + + uc_compiler_init(&fncompiler, NULL, compiler->parser->prev.pos, + compiler->function->source); + + fncompiler.parent = compiler; + fncompiler.parser = compiler->parser; + + fncompiler.function->arrow = true; + fncompiler.function->vararg = args ? restarg : false; + fncompiler.function->nargs = array ? json_object_array_length(args) : !!args; + + uc_compiler_enter_scope(&fncompiler); + + /* declare local variables for arguments */ + for (i = 0; i < fncompiler.function->nargs; i++) { + slot = uc_compiler_declare_local(&fncompiler, + array ? json_object_array_get_idx(args, i) : args); + + if (slot != -1) + uc_compiler_syntax_error(&fncompiler, pos, + "Duplicate argument names are not allowed in this context"); + + uc_compiler_initialize_local(&fncompiler); + } + + /* parse and compile body */ + if (uc_compiler_parse_match(&fncompiler, TK_LBRACE)) { + while (!uc_compiler_parse_check(&fncompiler, TK_RBRACE) && + !uc_compiler_parse_check(&fncompiler, TK_EOF)) + uc_compiler_compile_declaration(&fncompiler); + + uc_compiler_parse_consume(&fncompiler, TK_RBRACE); + + /* overwrite last pop result with return */ + if (fncompiler.function->chunk.count) { + uc_chunk_pop(&fncompiler.function->chunk); + uc_compiler_emit_insn(&fncompiler, 0, I_RETURN); + } + } + else { + uc_compiler_compile_expression(&fncompiler); + uc_compiler_emit_insn(&fncompiler, 0, I_RETURN); + } + + /* emit load instruction for function value */ + uc_compiler_emit_insn(compiler, pos, I_ARFN); + load_off = uc_compiler_emit_u32(compiler, 0, 0); + + /* encode upvalue information */ + for (i = 0; i < fncompiler.function->nupvals; i++) + uc_compiler_emit_s32(compiler, 0, + fncompiler.upvals.entries[i].local + ? -(fncompiler.upvals.entries[i].index + 1) + : fncompiler.upvals.entries[i].index); + + /* finalize function compiler */ + fn = uc_compiler_finish(&fncompiler); + + if (fn) + uc_compiler_set_u32(compiler, load_off, + uc_chunk_add_constant(uc_compiler_current_chunk(compiler), + fn->header.jso)); + + return true; +} + +static uc_tokentype_t +uc_compiler_compile_var_or_arrowfn(uc_compiler *compiler, bool assignable, json_object *name) +{ + uc_tokentype_t rv; + + if (assignable && uc_compiler_compile_assignment(compiler, name)) { + rv = TK_ASSIGN; + } + else if (uc_compiler_compile_arrowfn(compiler, name, false)) { + rv = TK_ARROW; + } + else { + uc_compiler_emit_variable_rw(compiler, name, 0); + rv = TK_LABEL; + } + + return rv; +} + +static void +uc_compiler_compile_paren(uc_compiler *compiler, bool assignable) +{ + json_object *varnames = NULL, *varname; + bool maybe_arrowfn = false; + bool restarg = false; + + /* First try to parse a complete parameter expression and remember the + * consumed label tokens as we go. */ + while (true) { + if (uc_compiler_parse_match(compiler, TK_LABEL)) { + if (!varnames) + varnames = xjs_new_array(); + + json_object_array_add(varnames, uc_value_get(compiler->parser->prev.val)); + } + else if (uc_compiler_parse_match(compiler, TK_ELLIP)) { + uc_compiler_parse_consume(compiler, TK_LABEL); + + if (!varnames) + varnames = xjs_new_array(); + + json_object_array_add(varnames, uc_value_get(compiler->parser->prev.val)); + + uc_compiler_parse_consume(compiler, TK_RPAREN); + + maybe_arrowfn = true; + restarg = true; + + break; + } + else if (uc_compiler_parse_check(compiler, TK_COMMA)) { + /* Reject consecutive commas */ + if (compiler->parser->prev.type == TK_COMMA) + uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, + "Expecting expression"); + + uc_compiler_parse_advance(compiler); + + continue; + } + else { + maybe_arrowfn = uc_compiler_parse_match(compiler, TK_RPAREN); + break; + } + } + + /* The lhs we parsed so far is elligible for an arrow function arg list, + * try to continue compiling into arrow function... */ + if (maybe_arrowfn) { + /* If we can parse the remainder as arrow function, we're done */ + if (uc_compiler_compile_arrowfn(compiler, varnames, restarg)) + goto out; + + /* ... otherwise disallow the `...` spread operator and empty + * parenthesized expressions */ + if (restarg || !varnames) { + uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, + "Expecting '=>' after parameter list"); + + goto out; + } + } + + /* If we reach this, the expression we parsed so far cannot be a parameter + * list for an arrow function and we might have consumed one or multiple + * consecutive labels. */ + if (varnames) { + /* Get last variable name */ + varname = json_object_array_get_idx(varnames, + json_object_array_length(varnames) - 1); + + /* If we consumed the right paren, the expression is complete and we + * only need to emit a variable read operation for the last parsed + * label since previous read operations are shadowed by subsequent ones + * in comma expressions and since pure variable reads are without + * side effects. */ + if (maybe_arrowfn) { + uc_compiler_emit_variable_rw(compiler, varname, 0); + + goto out; + } + + /* ... otherwise if the last token was a label, try continue parsing as + * assignment or arrow function expression and if that fails, as + * relational one */ + if (compiler->parser->prev.type == TK_LABEL) { + if (uc_compiler_compile_var_or_arrowfn(compiler, true, varname) == TK_LABEL) { + /* parse operand and rhs */ + while (P_TERNARY <= uc_compiler_parse_rule(compiler->parser->curr.type)->precedence) { + uc_compiler_parse_advance(compiler); + uc_compiler_parse_rule(compiler->parser->prev.type)->infix(compiler, true); + } + } + + /* If we're not at the end of the expression, we require a comma. + * Also pop intermediate result in this case. */ + if (!uc_compiler_parse_check(compiler, TK_RPAREN)) { + uc_compiler_emit_insn(compiler, 0, I_POP); + uc_compiler_parse_consume(compiler, TK_COMMA); + } + } + } + + /* When we reach this point, all already complete expression possibilities + * have been eliminated and we either need to compile the next, non-label + * expression or reached the closing paren. If neither applies, we have a + * syntax error. */ + if (!uc_compiler_parse_check(compiler, TK_RPAREN)) + uc_compiler_compile_expression(compiler); + + /* At this point we expect the end of the parenthesized expression, anything + * else is a syntax error */ + uc_compiler_parse_consume(compiler, TK_RPAREN); + +out: + uc_value_put(varnames); +} + +static void +uc_compiler_compile_call(uc_compiler *compiler, bool assignable) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + uc_jmplist spreads = {}; + enum insn_type type; + size_t i, nargs = 0; + + /* determine the kind of the lhs */ + type = chunk->entries[compiler->last_insn]; + + /* if lhs is a dot or bracket expression, pop the LVAL instruction */ + if (type == I_LVAL) + uc_chunk_pop(chunk); + + /* compile arguments */ + if (!uc_compiler_parse_check(compiler, TK_RPAREN)) { + do { + /* if this is a spread arg, remember the argument index */ + if (uc_compiler_parse_match(compiler, TK_ELLIP)) { + uc_vector_grow(&spreads); + spreads.entries[spreads.count++] = nargs; + } + + /* compile argument expression */ + uc_compiler_parse_precedence(compiler, P_ASSIGN); + nargs++; + } + while (uc_compiler_parse_match(compiler, TK_COMMA)); + } + + uc_compiler_parse_consume(compiler, TK_RPAREN); + + /* if lhs is a dot or bracket expression, emit a method call */ + if (type == I_LVAL) + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_MCALL); + /* else ordinary call */ + else + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_CALL); + + if (nargs > 0xffff || spreads.count > 0xffff) + uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, + "Too many function call arguments"); + + /* encode ordinary (low 16 bit) and spread argument (high 16 bit) count */ + uc_compiler_emit_u32(compiler, 0, ((spreads.count & 0xffff) << 16) | nargs); + + /* encode spread arg positions */ + for (i = 0; i < spreads.count; i++) + uc_compiler_emit_u16(compiler, 0, nargs - spreads.entries[i] - 1); + + uc_vector_clear(&spreads); +} + +static void +uc_compiler_compile_post_inc(uc_compiler *compiler, bool assignable) +{ + uc_compiler_emit_inc_dec(compiler, compiler->parser->prev.type, true); +} + +static void +uc_compiler_compile_constant(uc_compiler *compiler, bool assignable) +{ + int64_t n; + + switch (compiler->parser->prev.type) { + case TK_THIS: + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LTHIS); + break; + + case TK_NULL: + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL); + break; + + case TK_BOOL: + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, + json_object_get_boolean(compiler->parser->prev.val) ? I_LTRUE : I_LFALSE); + break; + + case TK_DOUBLE: + case TK_STRING: + uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.val); + break; + + case TK_REGEXP: + uc_compiler_emit_regexp(compiler, compiler->parser->prev.pos, compiler->parser->prev.val); + break; + + case TK_NUMBER: + n = json_object_get_int64(compiler->parser->prev.val); + + if (n >= -0x7f && n <= 0x7f) { + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LOAD8); + uc_compiler_emit_s8(compiler, compiler->parser->prev.pos, n); + } + else if (n >= -0x7fff && n <= 0x7fff) { + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LOAD16); + uc_compiler_emit_s16(compiler, compiler->parser->prev.pos, n); + } + else if (n >= -0x7fffffff && n <= 0x7fffffff) { + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LOAD32); + uc_compiler_emit_s32(compiler, compiler->parser->prev.pos, n); + } + else { + uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.val); + } + + break; + + default: + break; + } +} + +static void +uc_compiler_compile_comma(uc_compiler *compiler, bool assignable) +{ + uc_compiler_emit_insn(compiler, 0, I_POP); + uc_compiler_parse_precedence(compiler, P_ASSIGN); +} + +static void +uc_compiler_compile_labelexpr(uc_compiler *compiler, bool assignable) +{ + json_object *label = uc_value_get(compiler->parser->prev.val); + + uc_compiler_compile_var_or_arrowfn(compiler, assignable, label); + uc_value_put(label); +} + +static bool +uc_compiler_compile_delimitted_block(uc_compiler *compiler, uc_tokentype_t endtype) +{ + while (!uc_compiler_parse_check(compiler, endtype) && + !uc_compiler_parse_check(compiler, TK_EOF)) + uc_compiler_compile_declaration(compiler); + + return uc_compiler_parse_check(compiler, endtype); +} + +static void +uc_compiler_compile_function(uc_compiler *compiler, bool assignable) +{ + uc_compiler fncompiler = {}; + json_object *name = NULL; + ssize_t slot = -1, pos; + uc_tokentype_t type; + size_t i, load_off; + uc_function *fn; + + pos = compiler->parser->prev.pos; + type = compiler->parser->prev.type; + + if (uc_compiler_parse_match(compiler, TK_LABEL)) { + name = compiler->parser->prev.val; + + /* Named functions are syntactic sugar for local variable declaration + * with function value assignment. If a name token was encountered, + * initialize a local variable for it... */ + slot = uc_compiler_declare_local(compiler, name); + + if (slot == -1) + uc_compiler_initialize_local(compiler); + } + + uc_compiler_init(&fncompiler, + name ? json_object_get_string(name) : NULL, compiler->parser->prev.pos, + compiler->function->source); + + fncompiler.parent = compiler; + fncompiler.parser = compiler->parser; + + uc_compiler_parse_consume(&fncompiler, TK_LPAREN); + + uc_compiler_enter_scope(&fncompiler); + + /* compile argument specification */ + while (true) { + if (uc_compiler_parse_check(&fncompiler, TK_RPAREN)) + break; + + if (uc_compiler_parse_match(&fncompiler, TK_ELLIP)) + fncompiler.function->vararg = true; + + if (uc_compiler_parse_match(&fncompiler, TK_LABEL)) { + fncompiler.function->nargs++; + + uc_compiler_declare_local(&fncompiler, fncompiler.parser->prev.val); + uc_compiler_initialize_local(&fncompiler); + + if (fncompiler.function->vararg || + !uc_compiler_parse_match(&fncompiler, TK_COMMA)) + break; + } + else { + uc_compiler_syntax_error(&fncompiler, fncompiler.parser->curr.pos, + "Expecting Label"); + + return; + } + } + + uc_compiler_parse_consume(&fncompiler, TK_RPAREN); + + /* parse and compile function body */ + if (uc_compiler_parse_match(&fncompiler, TK_COLON)) { + uc_compiler_compile_delimitted_block(&fncompiler, TK_ENDFUNC); + uc_compiler_parse_consume(&fncompiler, TK_ENDFUNC); + } + else if (uc_compiler_parse_match(&fncompiler, TK_LBRACE)) { + uc_compiler_compile_delimitted_block(&fncompiler, TK_RBRACE); + uc_compiler_parse_consume(&fncompiler, TK_RBRACE); + } + else { + uc_compiler_syntax_error(&fncompiler, fncompiler.parser->curr.pos, + "Expecting '{' or ':' after function parameters"); + } + + /* emit load instruction for function value */ + uc_compiler_emit_insn(compiler, pos, (type == TK_ARROW) ? I_ARFN : I_CLFN); + load_off = uc_compiler_emit_u32(compiler, 0, 0); + + /* encode upvalue information */ + for (i = 0; i < fncompiler.function->nupvals; i++) + uc_compiler_emit_s32(compiler, 0, + fncompiler.upvals.entries[i].local + ? -(fncompiler.upvals.entries[i].index + 1) + : fncompiler.upvals.entries[i].index); + + /* finalize function compiler */ + fn = uc_compiler_finish(&fncompiler); + + if (fn) + uc_compiler_set_u32(compiler, load_off, + uc_chunk_add_constant(uc_compiler_current_chunk(compiler), + fn->header.jso)); + + /* if a local variable of the same name already existed, overwrite its value + * with the compiled function here */ + if (slot != -1) { + uc_compiler_emit_insn(compiler, 0, I_SLOC); + uc_compiler_emit_u32(compiler, 0, slot); + uc_compiler_emit_insn(compiler, 0, I_POP); + } +} + +static void +uc_compiler_compile_and(uc_compiler *compiler, bool assignable) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t jmpz_off; + + uc_compiler_emit_insn(compiler, 0, I_COPY); + uc_compiler_emit_u8(compiler, 0, 0); + jmpz_off = uc_compiler_emit_jmpz(compiler, 0, 0); + uc_compiler_emit_insn(compiler, 0, I_POP); + uc_compiler_parse_precedence(compiler, P_AND); + uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); +} + +static void +uc_compiler_compile_or(uc_compiler *compiler, bool assignable) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t jmpz_off, jmp_off; + + uc_compiler_emit_insn(compiler, 0, I_COPY); + uc_compiler_emit_u8(compiler, 0, 0); + jmpz_off = uc_compiler_emit_jmpz(compiler, 0, 0); + jmp_off = uc_compiler_emit_jmp(compiler, 0, 0); + uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); + uc_compiler_emit_insn(compiler, 0, I_POP); + uc_compiler_parse_precedence(compiler, P_OR); + uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count); +} + +static void +uc_compiler_compile_dot(uc_compiler *compiler, bool assignable) +{ + /* parse label lhs */ + uc_compiler_parse_consume(compiler, TK_LABEL); + uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.val); + + /* depending on context, compile into I_UVAL, I_SVAL or I_LVAL operation */ + if (!assignable || !uc_compiler_compile_assignment(compiler, NULL)) + uc_compiler_emit_variable_rw(compiler, NULL, 0); +} + +static void +uc_compiler_compile_subscript(uc_compiler *compiler, bool assignable) +{ + /* compile lhs */ + uc_compiler_compile_expression(compiler); + uc_compiler_parse_consume(compiler, TK_RBRACK); + + /* depending on context, compile into I_UVAL, I_SVAL or I_LVAL operation */ + if (!assignable || !uc_compiler_compile_assignment(compiler, NULL)) + uc_compiler_emit_variable_rw(compiler, NULL, 0); +} + +static void +uc_compiler_compile_ternary(uc_compiler *compiler, bool assignable) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t jmpz_off, jmp_off; + + /* jump to false branch */ + jmpz_off = uc_compiler_emit_jmpz(compiler, 0, 0); + + /* compile true branch */ + uc_compiler_parse_precedence(compiler, P_ASSIGN); + + /* jump after false branch */ + jmp_off = uc_compiler_emit_jmp(compiler, 0, 0); + + uc_compiler_parse_consume(compiler, TK_COLON); + + /* compile false branch */ + uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); + uc_compiler_parse_precedence(compiler, P_TERNARY); + uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count); +} + +static void +uc_compiler_compile_array(uc_compiler *compiler, bool assignable) +{ + size_t hint_off, hint_count = 0, len = 0; + + /* create empty array on stack */ + uc_compiler_emit_insn(compiler, 0, I_NARR); + hint_off = uc_compiler_emit_u32(compiler, 0, 0); + + /* parse initializer values */ + do { + if (uc_compiler_parse_check(compiler, TK_RBRACK)) { + break; + } + else if (uc_compiler_parse_match(compiler, TK_ELLIP)) { + /* push items on stack so far... */ + if (len > 0) { + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_PARR); + uc_compiler_emit_u32(compiler, 0, len); + len = 0; + } + + /* compile spread value expression */ + uc_compiler_parse_precedence(compiler, P_ASSIGN); + + /* emit merge operation */ + uc_compiler_emit_insn(compiler, 0, I_MARR); + } + else { + /* push items on stack so far... */ + if (len >= 0xffffffff) { + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_PARR); + uc_compiler_emit_u32(compiler, 0, len); + len = 0; + } + + /* compile item value expression */ + uc_compiler_parse_precedence(compiler, P_ASSIGN); + + hint_count++; + len++; + } + } + while (uc_compiler_parse_match(compiler, TK_COMMA)); + + uc_compiler_parse_consume(compiler, TK_RBRACK); + + /* push items on stack */ + if (len > 0) { + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_PARR); + uc_compiler_emit_u32(compiler, 0, len); + } + + /* set initial size hint */ + uc_compiler_set_u32(compiler, hint_off, hint_count); +} + +static void +uc_compiler_compile_object(uc_compiler *compiler, bool assignable) +{ + size_t hint_off, hint_count = 0, len = 0; + + /* create empty object on stack */ + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_NOBJ); + hint_off = uc_compiler_emit_u32(compiler, 0, 0); + + /* parse initializer values */ + do { + if (uc_compiler_parse_check(compiler, TK_RBRACE)) { + break; + } + else if (uc_compiler_parse_match(compiler, TK_ELLIP)) { + /* set items on stack so far... */ + if (len > 0) { + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_SOBJ); + uc_compiler_emit_u32(compiler, 0, len); + len = 0; + } + + /* compile spread value expression */ + uc_compiler_parse_precedence(compiler, P_ASSIGN); + + /* emit merge operation */ + uc_compiler_emit_insn(compiler, 0, I_MOBJ); + } + else { + /* parse key expression */ + if (!uc_compiler_parse_match(compiler, TK_LABEL) && + !uc_compiler_parse_match(compiler, TK_STRING)) + uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, + "Expecting label"); + + /* load label */ + uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, + compiler->parser->prev.val); + + uc_compiler_parse_consume(compiler, TK_COLON); + + /* parse value expression */ + uc_compiler_parse_precedence(compiler, P_ASSIGN); + + /* set items on stack so far... */ + if (len >= 0xfffffffe) { + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_SOBJ); + uc_compiler_emit_u32(compiler, 0, len); + len = 0; + } + + hint_count += 2; + len += 2; + } + } + while (uc_compiler_parse_match(compiler, TK_COMMA)); + + uc_compiler_parse_consume(compiler, TK_RBRACE); + + /* set items on stack */ + if (len > 0) { + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_SOBJ); + uc_compiler_emit_u32(compiler, 0, len); + len = 0; + } + + /* set initial size hint */ + uc_compiler_set_u32(compiler, hint_off, hint_count); +} + + +static void +uc_compiler_declare_local_null(uc_compiler *compiler, size_t srcpos, json_object *varname) +{ + ssize_t existing_slot = uc_compiler_declare_local(compiler, varname); + + uc_compiler_emit_insn(compiler, srcpos, I_LNULL); + + if (existing_slot == -1) { + uc_compiler_initialize_local(compiler); + } + else { + uc_compiler_emit_insn(compiler, 0, I_SLOC); + uc_compiler_emit_u32(compiler, 0, existing_slot); + uc_compiler_emit_insn(compiler, 0, I_POP); + } +} + +static size_t +uc_compiler_declare_internal(uc_compiler *compiler, size_t srcpos, const char *name) +{ +#if 0 + ssize_t existing_slot; + json_object *n; + bool strict; + + n = xjs_new_string(name); + strict = compiler->strict_declarations; + compiler->strict_declarations = false; + existing_slot = uc_compiler_declare_local(compiler, n); + compiler->strict_declarations = strict; + + uc_compiler_emit_insn(compiler, srcpos, I_LNULL); + + if (existing_slot == -1) { + uc_value_put(n); + + return uc_compiler_initialize_local(compiler); + } + else { + uc_value_put(n); + + uc_compiler_emit_insn(compiler, 0, I_SLOC); + uc_compiler_emit_u32(compiler, 0, existing_slot); + uc_compiler_emit_insn(compiler, 0, I_POP); + + return existing_slot; + } +#else + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + uc_locals *locals = &compiler->locals; + + //uc_compiler_emit_insn(compiler, srcpos, I_LNULL); + + uc_vector_grow(locals); + + locals->entries[locals->count].name = xjs_new_string(name); + locals->entries[locals->count].depth = compiler->scope_depth; + locals->entries[locals->count].captured = false; + locals->entries[locals->count].from = chunk->count; + + return locals->count++; +#endif +} + +static void +uc_compiler_compile_local(uc_compiler *compiler) +{ + ssize_t slot; + + do { + /* parse variable name */ + uc_compiler_parse_consume(compiler, TK_LABEL); + + /* declare local variable */ + slot = uc_compiler_declare_local(compiler, compiler->parser->prev.val); + + /* if followed by '=', parse initializer expression */ + if (uc_compiler_parse_match(compiler, TK_ASSIGN)) + uc_compiler_parse_precedence(compiler, P_ASSIGN); + /* otherwise load implicit null */ + else + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL); + + /* initialize local */ + if (slot == -1) { + uc_compiler_initialize_local(compiler); + } + /* if the variable was redeclared, overwrite it */ + else { + uc_compiler_emit_insn(compiler, 0, I_SLOC); + uc_compiler_emit_u32(compiler, 0, slot); + uc_compiler_emit_insn(compiler, 0, I_POP); + } + } + while (uc_compiler_parse_match(compiler, TK_COMMA)); + + uc_compiler_parse_consume(compiler, TK_SCOL); +} + +static uc_tokentype_t +uc_compiler_compile_altifblock(uc_compiler *compiler) +{ + while (true) { + switch (compiler->parser->curr.type) { + case TK_ELIF: + case TK_ELSE: + case TK_ENDIF: + case TK_EOF: + return compiler->parser->curr.type; + + default: + uc_compiler_compile_declaration(compiler); + break; + } + } + + return 0; +} + +static void +uc_compiler_compile_if(uc_compiler *compiler) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t jmpz_off, jmp_off, i; + bool expect_endif = false; + uc_jmplist elifs = {}; + uc_tokentype_t type; + + /* parse & compile condition expression */ + uc_compiler_parse_consume(compiler, TK_LPAREN); + uc_compiler_compile_expression(compiler); + uc_compiler_parse_consume(compiler, TK_RPAREN); + + /* conditional jump to else/elif branch */ + jmpz_off = uc_compiler_emit_jmpz(compiler, 0, 0); + + if (uc_compiler_parse_match(compiler, TK_COLON)) { + while (true) { + /* compile elsif or else branch */ + type = uc_compiler_compile_altifblock(compiler); + + /* we just compiled an elsif block */ + if (!expect_endif && type == TK_ELIF) { + /* emit jump to skip to the end */ + uc_vector_grow(&elifs); + elifs.entries[elifs.count++] = uc_compiler_emit_jmp(compiler, 0, 0); + + /* point previous conditional jump to beginning of branch */ + uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); + + /* parse & compile elsif condition */ + uc_compiler_parse_advance(compiler); + uc_compiler_parse_consume(compiler, TK_LPAREN); + uc_compiler_compile_expression(compiler); + uc_compiler_parse_consume(compiler, TK_RPAREN); + uc_compiler_parse_consume(compiler, TK_COLON); + + /* conditional jump to else/elif branch */ + jmpz_off = uc_compiler_emit_jmpz(compiler, 0, 0); + } + else if (!expect_endif && type == TK_ELSE) { + /* emit jump to skip to the end */ + uc_vector_grow(&elifs); + elifs.entries[elifs.count++] = uc_compiler_emit_jmp(compiler, 0, 0); + + /* point previous conditional jump to beginning of branch */ + uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); + jmpz_off = 0; + + /* skip "else" keyword */ + uc_compiler_parse_advance(compiler); + + expect_endif = true; + } + else if (type == TK_ENDIF) { + /* if no else clause, point previous conditional jump after block */ + if (jmpz_off) + uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); + + /* patch the elif branch jumps to point here after the else */ + for (i = 0; i < elifs.count; i++) + uc_compiler_set_jmpaddr(compiler, elifs.entries[i], + chunk->count); + + /* skip the "endif" keyword */ + uc_compiler_parse_advance(compiler); + break; + } + else { + uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, + expect_endif + ? "Expecting 'endif'" + : "Expecting 'elif', 'else' or 'endif'"); + + break; + } + } + + uc_vector_clear(&elifs); + } + else { + /* compile true branch */ + uc_compiler_compile_statement(compiler); + + /* ... when present, handle false branch */ + if (uc_compiler_parse_match(compiler, TK_ELSE)) { + /* jump to skip else branch */ + jmp_off = uc_compiler_emit_jmp(compiler, 0, 0); + + /* set conditional jump address */ + uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); + + /* compile false branch */ + uc_compiler_compile_statement(compiler); + + /* set else skip jump address */ + uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count); + } + /* ... otherwise point the conditional jump after the true branch */ + else { + uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); + } + } +} + +static void +uc_compiler_compile_while(uc_compiler *compiler) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t cond_off, jmpz_off, end_off; + uc_patchlist p = {}; + + p.parent = compiler->patchlist; + compiler->patchlist = &p; + + cond_off = chunk->count; + + /* parse & compile loop condition */ + uc_compiler_parse_consume(compiler, TK_LPAREN); + uc_compiler_compile_expression(compiler); + uc_compiler_parse_consume(compiler, TK_RPAREN); + + /* conditional jump to end */ + jmpz_off = uc_compiler_emit_jmpz(compiler, 0, 0); + + /* compile loop body */ + if (uc_compiler_parse_match(compiler, TK_COLON)) { + if (!uc_compiler_compile_delimitted_block(compiler, TK_ENDWHILE)) + uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, + "Expecting 'endwhile'"); + else + uc_compiler_parse_advance(compiler); + } + else { + uc_compiler_compile_statement(compiler); + } + + end_off = chunk->count; + + /* jump back to condition */ + uc_compiler_emit_jmp(compiler, 0, cond_off); + + /* set conditional jump target */ + uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); + + /* patch up break/continue */ + uc_compiler_backpatch(compiler, chunk->count, end_off); +} + +static void +uc_compiler_compile_for_in(uc_compiler *compiler, bool local, uc_token *kvar, uc_token *vvar) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t skip_jmp, test_jmp, key_slot, val_slot; + uc_patchlist p = {}; + + p.parent = compiler->patchlist; + compiler->patchlist = &p; + + uc_compiler_enter_scope(compiler); + + /* declare internal loop variables */ + uc_compiler_emit_insn(compiler, 0, I_LNULL); + key_slot = uc_compiler_declare_internal(compiler, 0, "(for in key)"); + + uc_compiler_emit_insn(compiler, 0, I_LNULL); + val_slot = uc_compiler_declare_internal(compiler, 0, "(for in value)"); + + /* declare loop variables */ + if (local) { + uc_compiler_declare_local_null(compiler, kvar->pos, kvar->val); + + if (vvar) + uc_compiler_declare_local_null(compiler, vvar->pos, vvar->val); + } + + /* value to iterate */ + uc_compiler_compile_expression(compiler); + uc_compiler_parse_consume(compiler, TK_RPAREN); + uc_compiler_emit_insn(compiler, 0, I_SLOC); + uc_compiler_emit_u32(compiler, 0, val_slot); + + /* initial key value */ + uc_compiler_emit_insn(compiler, 0, I_LNULL); + uc_compiler_emit_insn(compiler, 0, I_SLOC); + uc_compiler_emit_u32(compiler, 0, key_slot); + + /* jump over variable read for first cycle */ + skip_jmp = uc_compiler_emit_jmp(compiler, 0, 0); + + /* read value */ + uc_compiler_emit_insn(compiler, 0, I_LLOC); + uc_compiler_emit_u32(compiler, 0, val_slot); + + /* read key */ + uc_compiler_emit_insn(compiler, 0, I_LLOC); + uc_compiler_emit_u32(compiler, 0, key_slot); + + /* backpatch skip jump */ + uc_compiler_set_jmpaddr(compiler, skip_jmp, chunk->count); + + /* load loop variable and get next key from object */ + uc_compiler_emit_insn(compiler, 0, vvar ? I_NEXTKV : I_NEXTK); + + /* set internal key variable */ + uc_compiler_emit_insn(compiler, 0, I_SLOC); + uc_compiler_emit_u32(compiler, 0, key_slot); + + /* test for != null */ + uc_compiler_emit_insn(compiler, 0, I_LNULL); + uc_compiler_emit_insn(compiler, 0, I_NES); + + /* jump after loop body if no next key */ + test_jmp = uc_compiler_emit_jmpz(compiler, 0, 0); + + /* set key and value variables */ + if (vvar) { + uc_compiler_emit_variable_rw(compiler, vvar->val, TK_ASSIGN); + uc_compiler_emit_insn(compiler, 0, I_POP); + } + + /* set key variable */ + uc_compiler_emit_variable_rw(compiler, kvar->val, TK_ASSIGN); + uc_compiler_emit_insn(compiler, 0, I_POP); + + /* compile loop body */ + if (uc_compiler_parse_match(compiler, TK_COLON)) { + if (!uc_compiler_compile_delimitted_block(compiler, TK_ENDFOR)) + uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, + "Expecting 'endfor'"); + else + uc_compiler_parse_advance(compiler); + } + else { + uc_compiler_compile_statement(compiler); + } + + /* jump back to retrieve next key */ + uc_compiler_emit_jmp(compiler, 0, skip_jmp + 5); + + /* back patch conditional jump */ + uc_compiler_set_jmpaddr(compiler, test_jmp, chunk->count); + + /* patch up break/continue */ + uc_compiler_backpatch(compiler, chunk->count, skip_jmp + 5); + + /* pop loop variables */ + uc_compiler_emit_insn(compiler, 0, I_POP); + + if (vvar) + uc_compiler_emit_insn(compiler, 0, I_POP); + + uc_compiler_leave_scope(compiler); +} + +static void +uc_compiler_compile_for_count(uc_compiler *compiler, bool local, uc_token *var) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t test_off = 0, incr_off, skip_off, cond_off = 0; + uc_patchlist p = {}; + + p.parent = compiler->patchlist; + compiler->patchlist = &p; + + uc_compiler_enter_scope(compiler); + + /* Initializer ---------------------------------------------------------- */ + + /* We parsed a `local x` or `local x, y` expression, so (re)declare + * last label as local initializer variable */ + if (local) + uc_compiler_declare_local_null(compiler, var->pos, var->val); + + /* If we parsed at least on label, try continue parsing as variable + * expression... */ + if (var) { + uc_compiler_compile_labelexpr(compiler, true); + uc_compiler_emit_insn(compiler, 0, I_POP); + + /* If followed by a comma, continue parsing expression */ + if (uc_compiler_parse_match(compiler, TK_COMMA)) { + uc_compiler_compile_expression(compiler); + uc_compiler_emit_insn(compiler, 0, I_POP); + } + } + /* ... otherwise try parsing an entire expression (which might be absent) */ + else if (!uc_compiler_parse_check(compiler, TK_SCOL)) { + uc_compiler_compile_expression(compiler); + uc_compiler_emit_insn(compiler, 0, I_POP); + } + + uc_compiler_parse_consume(compiler, TK_SCOL); + + + /* Condition ------------------------------------------------------------ */ + if (!uc_compiler_parse_check(compiler, TK_SCOL)) { + cond_off = chunk->count; + + uc_compiler_compile_expression(compiler); + + test_off = uc_compiler_emit_jmpz(compiler, 0, 0); + } + + uc_compiler_parse_consume(compiler, TK_SCOL); + + /* jump over incrementer */ + skip_off = uc_compiler_emit_jmp(compiler, 0, 0); + + + /* Incrementer ---------------------------------------------------------- */ + incr_off = chunk->count; + + if (!uc_compiler_parse_check(compiler, TK_RPAREN)) { + uc_compiler_compile_expression(compiler); + uc_compiler_emit_insn(compiler, 0, I_POP); + } + + uc_compiler_parse_consume(compiler, TK_RPAREN); + + /* if we have a condition, jump back to it, else continue to the loop body */ + if (cond_off) + uc_compiler_emit_jmp(compiler, 0, cond_off); + + /* back patch skip address */ + uc_compiler_set_jmpaddr(compiler, skip_off, chunk->count); + + + /* Body ----------------------------------------------------------------- */ + if (uc_compiler_parse_match(compiler, TK_COLON)) { + if (!uc_compiler_compile_delimitted_block(compiler, TK_ENDFOR)) + uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, + "Expecting 'endfor'"); + else + uc_compiler_parse_advance(compiler); + } + else { + uc_compiler_compile_statement(compiler); + } + + /* jump back to incrementer */ + uc_compiler_emit_jmp(compiler, 0, incr_off); + + /* back patch conditional jump */ + if (test_off) + uc_compiler_set_jmpaddr(compiler, test_off, chunk->count); + + /* patch up break/continue */ + uc_compiler_backpatch(compiler, chunk->count, incr_off); + + uc_compiler_leave_scope(compiler); +} + +static void +uc_compiler_compile_for(uc_compiler *compiler) +{ + uc_token keyvar = {}, valvar = {}; + bool local; + + uc_compiler_parse_consume(compiler, TK_LPAREN); + + /* check the next few tokens and see if we have either a + * `let x in` / `let x, y` expression or an ordinary initializer + * statement */ + + local = uc_compiler_parse_match(compiler, TK_LOCAL); + + if (local && !uc_compiler_parse_check(compiler, TK_LABEL)) + uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, + "Expecting label after 'local'"); + + if (uc_compiler_parse_match(compiler, TK_LABEL)) { + keyvar = compiler->parser->prev; + uc_value_get(keyvar.val); + + if (uc_compiler_parse_match(compiler, TK_COMMA)) { + uc_compiler_parse_consume(compiler, TK_LABEL); + + valvar = compiler->parser->prev; + uc_value_get(valvar.val); + } + + /* is a for-in loop */ + if (uc_compiler_parse_match(compiler, TK_IN)) { + uc_compiler_compile_for_in(compiler, local, &keyvar, + valvar.type ? &valvar : NULL); + + goto out; + } + } + + /* + * The previous expression ruled out a for-in loop, so continue parsing + * as counting for loop... + */ + uc_compiler_compile_for_count(compiler, local, + valvar.val ? &valvar : (keyvar.val ? &keyvar : NULL)); + +out: + uc_value_put(keyvar.val); + uc_value_put(valvar.val); +} + +static void +uc_compiler_compile_switch(uc_compiler *compiler) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t i, first_jmp, skip_jmp, next_jmp, default_jmp = 0; + bool in_case = false; + uc_jmplist jmps = {}; + uc_patchlist p = {}; + + p.parent = compiler->patchlist; + compiler->patchlist = &p; + + uc_compiler_enter_scope(compiler); + + /* parse and compile match value */ + uc_compiler_parse_consume(compiler, TK_LPAREN); + uc_compiler_compile_expression(compiler); + uc_compiler_parse_consume(compiler, TK_RPAREN); + uc_compiler_parse_consume(compiler, TK_LBRACE); + uc_compiler_declare_internal(compiler, 0, "(switch value)"); + + /* skip over first condition */ + first_jmp = uc_compiler_emit_jmp(compiler, 0, 0); + + /* parse and compile case matches */ + while (!uc_compiler_parse_check(compiler, TK_RBRACE) && + !uc_compiler_parse_check(compiler, TK_EOF)) { + /* handle `default:` */ + if (uc_compiler_parse_match(compiler, TK_DEFAULT)) { + if (default_jmp) { + uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, + "more than one switch default case"); + + return; + } + + uc_compiler_parse_consume(compiler, TK_COLON); + + /* jump over default case, can only be reached by fallthrough or + * conditional jump after last failed case condition */ + default_jmp = uc_compiler_emit_jmp(compiler, 0, 0); + + in_case = true; + } + + /* handle `case …:` */ + else if (uc_compiler_parse_match(compiler, TK_CASE)) { + /* jump over `case …:` label */ + uc_vector_grow(&jmps); + jmps.entries[jmps.count++] = uc_compiler_emit_jmp(compiler, 0, 0); + + /* copy condition value */ + uc_compiler_emit_insn(compiler, 0, I_COPY); + uc_compiler_emit_u8(compiler, 0, 0); + + /* compile case value expression */ + uc_compiler_compile_expression(compiler); + uc_compiler_parse_consume(compiler, TK_COLON); + + /* strict equality test */ + uc_compiler_emit_insn(compiler, 0, I_EQS); + + /* on inequality, jump to next condition */ + uc_vector_grow(&jmps); + jmps.entries[jmps.count++] = uc_compiler_emit_jmpz(compiler, 0, 0); + + in_case = true; + } + + /* handle interleaved statement */ + else if (in_case) { + uc_compiler_compile_declaration(compiler); + } + + /* a statement or expression preceeding any `default` or `case` is a + * syntax error */ + else { + uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, + "Expecting 'case' or 'default'"); + + return; + } + } + + uc_compiler_parse_consume(compiler, TK_RBRACE); + + /* patch jump targets for cases */ + for (i = 0; i < jmps.count; i += 2) { + skip_jmp = jmps.entries[i + 0]; + next_jmp = jmps.entries[i + 1]; + + uc_compiler_set_jmpaddr(compiler, skip_jmp, next_jmp + 5); + + /* have a subsequent case, patch next jump to it */ + if (i + 2 < jmps.count) + uc_compiler_set_jmpaddr(compiler, next_jmp, jmps.entries[i + 2] + 5); + /* case was last in switch, jump to default */ + else if (default_jmp) + uc_compiler_set_jmpaddr(compiler, next_jmp, default_jmp + 5); + /* if no default, jump to end */ + else + uc_compiler_set_jmpaddr(compiler, next_jmp, chunk->count); + } + + /* if we have a default case, set target for the skip jump */ + if (default_jmp) { + /* if we have cases, jump to the first one */ + if (jmps.count) + uc_compiler_set_jmpaddr(compiler, default_jmp, jmps.entries[0] + 5); + /* ... otherwise turn jump into no-op */ + else + uc_compiler_set_jmpaddr(compiler, default_jmp, default_jmp + 5); + } + + /* if we have cases, patch initial jump after the first case condition */ + if (jmps.count) + uc_compiler_set_jmpaddr(compiler, first_jmp, jmps.entries[0] + 5); + /* ... otherwise jump into default */ + else if (default_jmp) + uc_compiler_set_jmpaddr(compiler, first_jmp, default_jmp + 5); + /* ... otherwise if no defualt, turn into no-op */ + else + uc_compiler_set_jmpaddr(compiler, first_jmp, first_jmp + 5); + + uc_vector_clear(&jmps); + + uc_compiler_leave_scope(compiler); + + uc_compiler_backpatch(compiler, chunk->count, 0); + +} + +static void +uc_compiler_compile_try(uc_compiler *compiler) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t try_from = 0, try_to = 0, jmp_off = 0, ehvar_slot = 0; + uc_ehranges *ranges = &chunk->ehranges; + + try_from = chunk->count; + ehvar_slot = compiler->locals.count; + + /* Try block ------------------------------------------------------------ */ + uc_compiler_enter_scope(compiler); + + uc_compiler_parse_consume(compiler, TK_LBRACE); + + while (!uc_compiler_parse_check(compiler, TK_RBRACE) && + !uc_compiler_parse_check(compiler, TK_EOF)) + uc_compiler_compile_declaration(compiler); + + /* jump beyond catch branch */ + try_to = chunk->count; + jmp_off = uc_compiler_emit_jmp(compiler, 0, 0); + + uc_compiler_parse_consume(compiler, TK_RBRACE); + + uc_compiler_leave_scope(compiler); + + + /* Catch block ---------------------------------------------------------- */ + if (try_to > try_from) { + uc_vector_grow(ranges); + + ranges->entries[ranges->count].from = try_from; + ranges->entries[ranges->count].to = try_to; + ranges->entries[ranges->count].target = chunk->count; + ranges->entries[ranges->count].slot = ehvar_slot; + ranges->count++; + } + + uc_compiler_enter_scope(compiler); + + uc_compiler_parse_consume(compiler, TK_CATCH); + + /* have exception variable */ + if (uc_compiler_parse_match(compiler, TK_LPAREN)) { + uc_compiler_parse_consume(compiler, TK_LABEL); + + uc_compiler_declare_local(compiler, compiler->parser->prev.val); + uc_compiler_initialize_local(compiler); + + uc_compiler_parse_consume(compiler, TK_RPAREN); + } + /* ... else pop exception object from stack */ + else { + uc_compiler_emit_insn(compiler, 0, I_POP); + } + + uc_compiler_parse_consume(compiler, TK_LBRACE); + + while (!uc_compiler_parse_check(compiler, TK_RBRACE) && + !uc_compiler_parse_check(compiler, TK_EOF)) + uc_compiler_compile_declaration(compiler); + + uc_compiler_parse_consume(compiler, TK_RBRACE); + + uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count); + + uc_compiler_leave_scope(compiler); +} + +static void +uc_compiler_compile_control(uc_compiler *compiler) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + uc_tokentype_t type = compiler->parser->prev.type; + uc_patchlist *p = compiler->patchlist; + uc_locals *locals = &compiler->locals; + size_t i, pos = compiler->parser->prev.pos; + + if (!p) { + uc_compiler_syntax_error(compiler, pos, + (type == TK_BREAK) + ? "break must be inside loop or switch" + : "continue must be inside loop"); + + return; + } + + /* pop locals in scope up to this point */ + for (i = locals->count; i > 0 && locals->entries[i - 1].depth == compiler->scope_depth; i--) + uc_compiler_emit_insn(compiler, 0, I_POP); + + uc_vector_grow(p); + + p->entries[p->count++] = + uc_compiler_emit_jmp(compiler, pos, chunk->count + type); + + uc_compiler_parse_consume(compiler, TK_SCOL); +} + +static void +uc_compiler_compile_return(uc_compiler *compiler) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t off = chunk->count; + + uc_compiler_compile_expstmt(compiler); + + /* if we compiled an empty expression statement (`;`), load implicit null */ + if (chunk->count == off) + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL); + /* otherwise overwrite the final I_POP instruction with I_RETURN */ + else + uc_chunk_pop(chunk); + + uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_RETURN); +} + +static void +uc_compiler_compile_tplexp(uc_compiler *compiler) +{ + uc_chunk *chunk = uc_compiler_current_chunk(compiler); + size_t off = chunk->count; + + uc_compiler_compile_expression(compiler); + + /* XXX: the lexer currently emits a superfluous trailing semicolon... */ + uc_compiler_parse_match(compiler, TK_SCOL); + + uc_compiler_parse_consume(compiler, TK_REXP); + + if (chunk->count > off) + uc_compiler_emit_insn(compiler, 0, I_PRINT); +} + +static void +uc_compiler_compile_text(uc_compiler *compiler) +{ + uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.val); + uc_compiler_emit_insn(compiler, 0, I_PRINT); +} + +static void +uc_compiler_compile_block(uc_compiler *compiler) +{ + uc_compiler_enter_scope(compiler); + + while (!uc_compiler_parse_check(compiler, TK_RBRACE) && + !uc_compiler_parse_check(compiler, TK_EOF)) + uc_compiler_compile_declaration(compiler); + + uc_compiler_parse_consume(compiler, TK_RBRACE); + + uc_compiler_leave_scope(compiler); +} + +static void +uc_compiler_compile_expstmt(uc_compiler *compiler) +{ + /* empty statement */ + if (uc_compiler_parse_match(compiler, TK_SCOL)) + return; + + uc_compiler_compile_expression(compiler); + + /* allow omitting final semicolon */ + switch (compiler->parser->curr.type) { + case TK_RBRACE: + case TK_ELSE: /* fixme: only in altblockmode */ + case TK_ELIF: + case TK_ENDIF: + case TK_ENDFOR: + case TK_ENDWHILE: + case TK_ENDFUNC: + case TK_EOF: + break; + + default: + uc_compiler_parse_consume(compiler, TK_SCOL); + + break; + } + + uc_compiler_emit_insn(compiler, 0, I_POP); +} + +static void +uc_compiler_compile_statement(uc_compiler *compiler) +{ + if (uc_compiler_parse_match(compiler, TK_IF)) + uc_compiler_compile_if(compiler); + else if (uc_compiler_parse_match(compiler, TK_WHILE)) + uc_compiler_compile_while(compiler); + else if (uc_compiler_parse_match(compiler, TK_FOR)) + uc_compiler_compile_for(compiler); + else if (uc_compiler_parse_match(compiler, TK_SWITCH)) + uc_compiler_compile_switch(compiler); + else if (uc_compiler_parse_match(compiler, TK_TRY)) + uc_compiler_compile_try(compiler); + else if (uc_compiler_parse_match(compiler, TK_FUNC)) + uc_compiler_compile_function(compiler, false); + else if (uc_compiler_parse_match(compiler, TK_BREAK)) + uc_compiler_compile_control(compiler); + else if (uc_compiler_parse_match(compiler, TK_CONTINUE)) + uc_compiler_compile_control(compiler); + else if (uc_compiler_parse_match(compiler, TK_RETURN)) + uc_compiler_compile_return(compiler); + else if (uc_compiler_parse_match(compiler, TK_TEXT)) + uc_compiler_compile_text(compiler); + else if (uc_compiler_parse_match(compiler, TK_LEXP)) + uc_compiler_compile_tplexp(compiler); + else if (uc_compiler_parse_match(compiler, TK_LBRACE)) + uc_compiler_compile_block(compiler); + else + uc_compiler_compile_expstmt(compiler); +} + +static void +uc_compiler_compile_declaration(uc_compiler *compiler) +{ + if (uc_compiler_parse_match(compiler, TK_LOCAL)) + uc_compiler_compile_local(compiler); + else + uc_compiler_compile_statement(compiler); + + if (compiler->parser->synchronizing) + uc_compiler_parse_synchronize(compiler); +} + +uc_function * +uc_compile(uc_parse_config *config, uc_source *source, char **errp) +{ + uc_parser parser = { .config = config }; + uc_compiler compiler = { .parser = &parser }; + uc_function *fn; + + uc_lexer_init(&parser.lex, config, source); + uc_compiler_init(&compiler, "main", 0, source); + + uc_compiler_parse_advance(&compiler); + + while (!uc_compiler_parse_match(&compiler, TK_EOF)) + uc_compiler_compile_declaration(&compiler); + + fn = uc_compiler_finish(&compiler); + + if (errp) + *errp = parser.error; + + uc_lexer_free(&parser.lex); + + return fn; +} diff --git a/compiler.h b/compiler.h new file mode 100644 index 0000000..53ff987 --- /dev/null +++ b/compiler.h @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef __COMPILER_H_ +#define __COMPILER_H_ + +#include +#include +#include + +#ifdef JSONC + #include +#else + #include +#endif + +#include "source.h" +#include "object.h" +#include "lexer.h" +#include "util.h" + +typedef enum { + P_NONE, + + P_COMMA, /* , */ + + P_ASSIGN, /* = += -= *= /= %= <<= >>= &= ^= |= */ + + P_TERNARY, /* ?: */ + + P_OR, /* || */ + P_AND, /* && */ + P_BOR, /* | */ + P_BXOR, /* ^ */ + P_BAND, /* & */ + + P_EQUAL, /* === !== == != */ + P_COMPARE, /* < <= > >= in */ + + P_SHIFT, /* << >> */ + + P_ADD, /* + - */ + P_MUL, /* * / % */ + + P_UNARY, /* ! ~ +… -… ++… --… */ + + P_INC, /* …++ …-- */ + + P_CALL, /* ….…, …[…], …(…) */ + + P_PRIMARY /* (…) */ +} uc_precedence_t; + +struct uc_patchlist { + struct uc_patchlist *parent; + size_t count, *entries; +}; + +typedef struct uc_patchlist uc_patchlist; + +typedef struct { + json_object *name; + ssize_t depth; + size_t from; + bool captured; +} uc_local; + +typedef struct { + json_object *name; + size_t index; + bool local; +} uc_upval; + +uc_declare_vector(uc_locals, uc_local); +uc_declare_vector(uc_upvals, uc_upval); +uc_declare_vector(uc_jmplist, size_t); + +typedef struct { + uc_parse_config *config; + uc_lexer lex; + uc_token prev, curr; + bool synchronizing; + char *error; +} uc_parser; + +struct uc_compiler { + struct uc_compiler *parent; + uc_locals locals; + uc_upvals upvals; + uc_patchlist *patchlist; + uc_function *function; + uc_parser *parser; + size_t scope_depth, current_srcpos, last_insn; + bool statement_emitted; +}; + +typedef struct uc_compiler uc_compiler; + +typedef struct { + void (*prefix)(uc_compiler *, bool); + void (*infix)(uc_compiler *, bool); + uc_precedence_t precedence; +} uc_parse_rule; + +uc_function *uc_compile(uc_parse_config *config, uc_source *source, char **errp); + +#endif /* __COMPILER_H_ */ diff --git a/contrib/lemon.c b/contrib/lemon.c deleted file mode 100644 index 85e94f7..0000000 --- a/contrib/lemon.c +++ /dev/null @@ -1,5040 +0,0 @@ -/* -** This file contains all sources (including headers) to the LEMON -** LALR(1) parser generator. The sources have been combined into a -** single file to make it easy to include LEMON in the source tree -** and Makefile of another program. -** -** The author of this program disclaims copyright. -*/ -#include -#include -#include -#include -#include -#include - -#ifndef __WIN32__ -# if defined(_WIN32) || defined(WIN32) -# define __WIN32__ -# endif -#endif - -#ifdef __WIN32__ -#ifdef __cplusplus -extern "C" { -#endif -extern int access(const char *path, int mode); -#ifdef __cplusplus -} -#endif -#else -#include -#endif - -/* #define PRIVATE static */ -#define PRIVATE - -#ifdef TEST -#define MAXRHS 5 /* Set low to exercise exception code */ -#else -#define MAXRHS 1000 -#endif - -static int showPrecedenceConflict = 0; -static char *msort(char*,char**,int(*)(const char*,const char*)); - -/* -** Compilers are getting increasingly pedantic about type conversions -** as C evolves ever closer to Ada.... To work around the latest problems -** we have to define the following variant of strlen(). -*/ -#define lemonStrlen(X) ((int)strlen(X)) - -/* -** Compilers are starting to complain about the use of sprintf() and strcpy(), -** saying they are unsafe. So we define our own versions of those routines too. -** -** There are three routines here: lemon_sprintf(), lemon_vsprintf(), and -** lemon_addtext(). The first two are replacements for sprintf() and vsprintf(). -** The third is a helper routine for vsnprintf() that adds texts to the end of a -** buffer, making sure the buffer is always zero-terminated. -** -** The string formatter is a minimal subset of stdlib sprintf() supporting only -** a few simply conversions: -** -** %d -** %s -** %.*s -** -*/ -static void lemon_addtext( - char *zBuf, /* The buffer to which text is added */ - int *pnUsed, /* Slots of the buffer used so far */ - const char *zIn, /* Text to add */ - int nIn, /* Bytes of text to add. -1 to use strlen() */ - int iWidth /* Field width. Negative to left justify */ -){ - if( nIn<0 ) for(nIn=0; zIn[nIn]; nIn++){} - while( iWidth>nIn ){ zBuf[(*pnUsed)++] = ' '; iWidth--; } - if( nIn==0 ) return; - memcpy(&zBuf[*pnUsed], zIn, nIn); - *pnUsed += nIn; - while( (-iWidth)>nIn ){ zBuf[(*pnUsed)++] = ' '; iWidth++; } - zBuf[*pnUsed] = 0; -} -static int lemon_vsprintf(char *str, const char *zFormat, va_list ap){ - int i, j, k, c; - int nUsed = 0; - const char *z; - char zTemp[50]; - str[0] = 0; - for(i=j=0; (c = zFormat[i])!=0; i++){ - if( c=='%' ){ - int iWidth = 0; - lemon_addtext(str, &nUsed, &zFormat[j], i-j, 0); - c = zFormat[++i]; - if( isdigit(c) || (c=='-' && isdigit(zFormat[i+1])) ){ - if( c=='-' ) i++; - while( isdigit(zFormat[i]) ) iWidth = iWidth*10 + zFormat[i++] - '0'; - if( c=='-' ) iWidth = -iWidth; - c = zFormat[i]; - } - if( c=='d' ){ - int v = va_arg(ap, int); - if( v<0 ){ - lemon_addtext(str, &nUsed, "-", 1, iWidth); - v = -v; - }else if( v==0 ){ - lemon_addtext(str, &nUsed, "0", 1, iWidth); - } - k = 0; - while( v>0 ){ - k++; - zTemp[sizeof(zTemp)-k] = (v%10) + '0'; - v /= 10; - } - lemon_addtext(str, &nUsed, &zTemp[sizeof(zTemp)-k], k, iWidth); - }else if( c=='s' ){ - z = va_arg(ap, const char*); - lemon_addtext(str, &nUsed, z, -1, iWidth); - }else if( c=='.' && memcmp(&zFormat[i], ".*s", 3)==0 ){ - i += 2; - k = va_arg(ap, int); - z = va_arg(ap, const char*); - lemon_addtext(str, &nUsed, z, k, iWidth); - }else if( c=='%' ){ - lemon_addtext(str, &nUsed, "%", 1, 0); - }else{ - fprintf(stderr, "illegal format\n"); - exit(1); - } - j = i+1; - } - } - lemon_addtext(str, &nUsed, &zFormat[j], i-j, 0); - return nUsed; -} -static int lemon_sprintf(char *str, const char *format, ...){ - va_list ap; - int rc; - va_start(ap, format); - rc = lemon_vsprintf(str, format, ap); - va_end(ap); - return rc; -} -static void lemon_strcpy(char *dest, const char *src){ - while( (*(dest++) = *(src++))!=0 ){} -} -static void lemon_strcat(char *dest, const char *src){ - while( *dest ) dest++; - lemon_strcpy(dest, src); -} - - -/* a few forward declarations... */ -struct rule; -struct lemon; -struct action; - -static struct action *Action_new(void); -static struct action *Action_sort(struct action *); - -/********** From the file "build.h" ************************************/ -void FindRulePrecedences(); -void FindFirstSets(); -void FindStates(); -void FindLinks(); -void FindFollowSets(); -void FindActions(); - -/********* From the file "configlist.h" *********************************/ -void Configlist_init(void); -struct config *Configlist_add(struct rule *, int); -struct config *Configlist_addbasis(struct rule *, int); -void Configlist_closure(struct lemon *); -void Configlist_sort(void); -void Configlist_sortbasis(void); -struct config *Configlist_return(void); -struct config *Configlist_basis(void); -void Configlist_eat(struct config *); -void Configlist_reset(void); - -/********* From the file "error.h" ***************************************/ -void ErrorMsg(const char *, int,const char *, ...); - -/****** From the file "option.h" ******************************************/ -enum option_type { OPT_FLAG=1, OPT_INT, OPT_DBL, OPT_STR, - OPT_FFLAG, OPT_FINT, OPT_FDBL, OPT_FSTR}; -struct s_options { - enum option_type type; - const char *label; - char *arg; - const char *message; -}; -int OptInit(char**,struct s_options*,FILE*); -int OptNArgs(void); -char *OptArg(int); -void OptErr(int); -void OptPrint(void); - -/******** From the file "parse.h" *****************************************/ -void Parse(struct lemon *lemp); - -/********* From the file "plink.h" ***************************************/ -struct plink *Plink_new(void); -void Plink_add(struct plink **, struct config *); -void Plink_copy(struct plink **, struct plink *); -void Plink_delete(struct plink *); - -/********** From the file "report.h" *************************************/ -void Reprint(struct lemon *); -void ReportOutput(struct lemon *); -void ReportTable(struct lemon *, int); -void ReportHeader(struct lemon *); -void CompressTables(struct lemon *); -void ResortStates(struct lemon *); - -/********** From the file "set.h" ****************************************/ -void SetSize(int); /* All sets will be of size N */ -char *SetNew(void); /* A new set for element 0..N */ -void SetFree(char*); /* Deallocate a set */ -int SetAdd(char*,int); /* Add element to a set */ -int SetUnion(char *,char *); /* A <- A U B, thru element N */ -#define SetFind(X,Y) (X[Y]) /* True if Y is in set X */ - -/********** From the file "struct.h" *************************************/ -/* -** Principal data structures for the LEMON parser generator. -*/ - -typedef enum {LEMON_FALSE=0, LEMON_TRUE} Boolean; - -/* Symbols (terminals and nonterminals) of the grammar are stored -** in the following: */ -enum symbol_type { - TERMINAL, - NONTERMINAL, - MULTITERMINAL -}; -enum e_assoc { - LEFT, - RIGHT, - NONE, - UNK -}; -struct symbol { - const char *name; /* Name of the symbol */ - int index; /* Index number for this symbol */ - enum symbol_type type; /* Symbols are all either TERMINALS or NTs */ - struct rule *rule; /* Linked list of rules of this (if an NT) */ - struct symbol *fallback; /* fallback token in case this token doesn't parse */ - int prec; /* Precedence if defined (-1 otherwise) */ - enum e_assoc assoc; /* Associativity if precedence is defined */ - char *firstset; /* First-set for all rules of this symbol */ - Boolean lambda; /* True if NT and can generate an empty string */ - int useCnt; /* Number of times used */ - char *destructor; /* Code which executes whenever this symbol is - ** popped from the stack during error processing */ - int destLineno; /* Line number for start of destructor */ - char *datatype; /* The data type of information held by this - ** object. Only used if type==NONTERMINAL */ - int dtnum; /* The data type number. In the parser, the value - ** stack is a union. The .yy%d element of this - ** union is the correct data type for this object */ - /* The following fields are used by MULTITERMINALs only */ - int nsubsym; /* Number of constituent symbols in the MULTI */ - struct symbol **subsym; /* Array of constituent symbols */ -}; - -/* Each production rule in the grammar is stored in the following -** structure. */ -struct rule { - struct symbol *lhs; /* Left-hand side of the rule */ - const char *lhsalias; /* Alias for the LHS (NULL if none) */ - int lhsStart; /* True if left-hand side is the start symbol */ - int ruleline; /* Line number for the rule */ - int nrhs; /* Number of RHS symbols */ - struct symbol **rhs; /* The RHS symbols */ - const char **rhsalias; /* An alias for each RHS symbol (NULL if none) */ - int line; /* Line number at which code begins */ - const char *code; /* The code executed when this rule is reduced */ - struct symbol *precsym; /* Precedence symbol for this rule */ - int index; /* An index number for this rule */ - Boolean canReduce; /* True if this rule is ever reduced */ - struct rule *nextlhs; /* Next rule with the same LHS */ - struct rule *next; /* Next rule in the global list */ -}; - -/* A configuration is a production rule of the grammar together with -** a mark (dot) showing how much of that rule has been processed so far. -** Configurations also contain a follow-set which is a list of terminal -** symbols which are allowed to immediately follow the end of the rule. -** Every configuration is recorded as an instance of the following: */ -enum cfgstatus { - COMPLETE, - INCOMPLETE -}; -struct config { - struct rule *rp; /* The rule upon which the configuration is based */ - int dot; /* The parse point */ - char *fws; /* Follow-set for this configuration only */ - struct plink *fplp; /* Follow-set forward propagation links */ - struct plink *bplp; /* Follow-set backwards propagation links */ - struct state *stp; /* Pointer to state which contains this */ - enum cfgstatus status; /* used during followset and shift computations */ - struct config *next; /* Next configuration in the state */ - struct config *bp; /* The next basis configuration */ -}; - -enum e_action { - SHIFT, - ACCEPT, - REDUCE, - ERROR, - SSCONFLICT, /* A shift/shift conflict */ - SRCONFLICT, /* Was a reduce, but part of a conflict */ - RRCONFLICT, /* Was a reduce, but part of a conflict */ - SH_RESOLVED, /* Was a shift. Precedence resolved conflict */ - RD_RESOLVED, /* Was reduce. Precedence resolved conflict */ - NOT_USED /* Deleted by compression */ -}; - -/* Every shift or reduce operation is stored as one of the following */ -struct action { - struct symbol *sp; /* The look-ahead symbol */ - enum e_action type; - union { - struct state *stp; /* The new state, if a shift */ - struct rule *rp; /* The rule, if a reduce */ - } x; - struct action *next; /* Next action for this state */ - struct action *collide; /* Next action with the same hash */ -}; - -/* Each state of the generated parser's finite state machine -** is encoded as an instance of the following structure. */ -struct state { - struct config *bp; /* The basis configurations for this state */ - struct config *cfp; /* All configurations in this set */ - int statenum; /* Sequential number for this state */ - struct action *ap; /* Array of actions for this state */ - int nTknAct, nNtAct; /* Number of actions on terminals and nonterminals */ - int iTknOfst, iNtOfst; /* yy_action[] offset for terminals and nonterms */ - int iDflt; /* Default action */ -}; -#define NO_OFFSET (-2147483647) - -/* A followset propagation link indicates that the contents of one -** configuration followset should be propagated to another whenever -** the first changes. */ -struct plink { - struct config *cfp; /* The configuration to which linked */ - struct plink *next; /* The next propagate link */ -}; - -/* The state vector for the entire parser generator is recorded as -** follows. (LEMON uses no global variables and makes little use of -** static variables. Fields in the following structure can be thought -** of as begin global variables in the program.) */ -struct lemon { - struct state **sorted; /* Table of states sorted by state number */ - struct rule *rule; /* List of all rules */ - int nstate; /* Number of states */ - int nrule; /* Number of rules */ - int nsymbol; /* Number of terminal and nonterminal symbols */ - int nterminal; /* Number of terminal symbols */ - struct symbol **symbols; /* Sorted array of pointers to symbols */ - int errorcnt; /* Number of errors */ - struct symbol *errsym; /* The error symbol */ - struct symbol *wildcard; /* Token that matches anything */ - char *name; /* Name of the generated parser */ - char *arg; /* Declaration of the 3th argument to parser */ - char *tokentype; /* Type of terminal symbols in the parser stack */ - char *vartype; /* The default type of non-terminal symbols */ - char *start; /* Name of the start symbol for the grammar */ - char *stacksize; /* Size of the parser stack */ - char *include; /* Code to put at the start of the C file */ - char *error; /* Code to execute when an error is seen */ - char *overflow; /* Code to execute on a stack overflow */ - char *failure; /* Code to execute on parser failure */ - char *accept; /* Code to execute when the parser excepts */ - char *extracode; /* Code appended to the generated file */ - char *tokendest; /* Code to execute to destroy token data */ - char *vardest; /* Code for the default non-terminal destructor */ - char *filename; /* Name of the input file */ - char *outname; /* Name of the current output file */ - char *tokenprefix; /* A prefix added to token names in the .h file */ - int nconflict; /* Number of parsing conflicts */ - int tablesize; /* Size of the parse tables */ - int basisflag; /* Print only basis configurations */ - int has_fallback; /* True if any %fallback is seen in the grammar */ - int nolinenosflag; /* True if #line statements should not be printed */ - char *argv0; /* Name of the program */ -}; - -#define MemoryCheck(X) if((X)==0){ \ - extern void memory_error(); \ - memory_error(); \ -} - -/**************** From the file "table.h" *********************************/ -/* -** All code in this file has been automatically generated -** from a specification in the file -** "table.q" -** by the associative array code building program "aagen". -** Do not edit this file! Instead, edit the specification -** file, then rerun aagen. -*/ -/* -** Code for processing tables in the LEMON parser generator. -*/ -/* Routines for handling a strings */ - -const char *Strsafe(const char *); - -void Strsafe_init(void); -int Strsafe_insert(const char *); -const char *Strsafe_find(const char *); - -/* Routines for handling symbols of the grammar */ - -struct symbol *Symbol_new(const char *); -int Symbolcmpp(const void *, const void *); -void Symbol_init(void); -int Symbol_insert(struct symbol *, const char *); -struct symbol *Symbol_find(const char *); -struct symbol *Symbol_Nth(int); -int Symbol_count(void); -struct symbol **Symbol_arrayof(void); - -/* Routines to manage the state table */ - -int Configcmp(const char *, const char *); -struct state *State_new(void); -void State_init(void); -int State_insert(struct state *, struct config *); -struct state *State_find(struct config *); -struct state **State_arrayof(/* */); - -/* Routines used for efficiency in Configlist_add */ - -void Configtable_init(void); -int Configtable_insert(struct config *); -struct config *Configtable_find(struct config *); -void Configtable_clear(int(*)(struct config *)); - -/****************** From the file "action.c" *******************************/ -/* -** Routines processing parser actions in the LEMON parser generator. -*/ - -/* Allocate a new parser action */ -static struct action *Action_new(void){ - static struct action *freelist = 0; - struct action *newaction; - - if( freelist==0 ){ - int i; - int amt = 100; - freelist = (struct action *)calloc(amt, sizeof(struct action)); - if( freelist==0 ){ - fprintf(stderr,"Unable to allocate memory for a new parser action."); - exit(1); - } - for(i=0; inext; - return newaction; -} - -/* Compare two actions for sorting purposes. Return negative, zero, or -** positive if the first action is less than, equal to, or greater than -** the first -*/ -static int actioncmp( - struct action *ap1, - struct action *ap2 -){ - int rc; - rc = ap1->sp->index - ap2->sp->index; - if( rc==0 ){ - rc = (int)ap1->type - (int)ap2->type; - } - if( rc==0 && ap1->type==REDUCE ){ - rc = ap1->x.rp->index - ap2->x.rp->index; - } - if( rc==0 ){ - rc = (int) (ap2 - ap1); - } - return rc; -} - -/* Sort parser actions */ -static struct action *Action_sort( - struct action *ap -){ - ap = (struct action *)msort((char *)ap,(char **)&ap->next, - (int(*)(const char*,const char*))actioncmp); - return ap; -} - -void Action_add( - struct action **app, - enum e_action type, - struct symbol *sp, - char *arg -){ - struct action *newaction; - newaction = Action_new(); - newaction->next = *app; - *app = newaction; - newaction->type = type; - newaction->sp = sp; - if( type==SHIFT ){ - newaction->x.stp = (struct state *)arg; - }else{ - newaction->x.rp = (struct rule *)arg; - } -} -/********************** New code to implement the "acttab" module ***********/ -/* -** This module implements routines use to construct the yy_action[] table. -*/ - -/* -** The state of the yy_action table under construction is an instance of -** the following structure. -** -** The yy_action table maps the pair (state_number, lookahead) into an -** action_number. The table is an array of integers pairs. The state_number -** determines an initial offset into the yy_action array. The lookahead -** value is then added to this initial offset to get an index X into the -** yy_action array. If the aAction[X].lookahead equals the value of the -** of the lookahead input, then the value of the action_number output is -** aAction[X].action. If the lookaheads do not match then the -** default action for the state_number is returned. -** -** All actions associated with a single state_number are first entered -** into aLookahead[] using multiple calls to acttab_action(). Then the -** actions for that single state_number are placed into the aAction[] -** array with a single call to acttab_insert(). The acttab_insert() call -** also resets the aLookahead[] array in preparation for the next -** state number. -*/ -struct lookahead_action { - int lookahead; /* Value of the lookahead token */ - int action; /* Action to take on the given lookahead */ -}; -typedef struct acttab acttab; -struct acttab { - int nAction; /* Number of used slots in aAction[] */ - int nActionAlloc; /* Slots allocated for aAction[] */ - struct lookahead_action - *aAction, /* The yy_action[] table under construction */ - *aLookahead; /* A single new transaction set */ - int mnLookahead; /* Minimum aLookahead[].lookahead */ - int mnAction; /* Action associated with mnLookahead */ - int mxLookahead; /* Maximum aLookahead[].lookahead */ - int nLookahead; /* Used slots in aLookahead[] */ - int nLookaheadAlloc; /* Slots allocated in aLookahead[] */ -}; - -/* Return the number of entries in the yy_action table */ -#define acttab_size(X) ((X)->nAction) - -/* The value for the N-th entry in yy_action */ -#define acttab_yyaction(X,N) ((X)->aAction[N].action) - -/* The value for the N-th entry in yy_lookahead */ -#define acttab_yylookahead(X,N) ((X)->aAction[N].lookahead) - -/* Free all memory associated with the given acttab */ -void acttab_free(acttab *p){ - free( p->aAction ); - free( p->aLookahead ); - free( p ); -} - -/* Allocate a new acttab structure */ -acttab *acttab_alloc(void){ - acttab *p = (acttab *) calloc( 1, sizeof(*p) ); - if( p==0 ){ - fprintf(stderr,"Unable to allocate memory for a new acttab."); - exit(1); - } - memset(p, 0, sizeof(*p)); - return p; -} - -/* Add a new action to the current transaction set. -** -** This routine is called once for each lookahead for a particular -** state. -*/ -void acttab_action(acttab *p, int lookahead, int action){ - if( p->nLookahead>=p->nLookaheadAlloc ){ - p->nLookaheadAlloc += 25; - p->aLookahead = (struct lookahead_action *) realloc( p->aLookahead, - sizeof(p->aLookahead[0])*p->nLookaheadAlloc ); - if( p->aLookahead==0 ){ - fprintf(stderr,"malloc failed\n"); - exit(1); - } - } - if( p->nLookahead==0 ){ - p->mxLookahead = lookahead; - p->mnLookahead = lookahead; - p->mnAction = action; - }else{ - if( p->mxLookaheadmxLookahead = lookahead; - if( p->mnLookahead>lookahead ){ - p->mnLookahead = lookahead; - p->mnAction = action; - } - } - p->aLookahead[p->nLookahead].lookahead = lookahead; - p->aLookahead[p->nLookahead].action = action; - p->nLookahead++; -} - -/* -** Add the transaction set built up with prior calls to acttab_action() -** into the current action table. Then reset the transaction set back -** to an empty set in preparation for a new round of acttab_action() calls. -** -** Return the offset into the action table of the new transaction. -*/ -int acttab_insert(acttab *p){ - int i, j, k, n; - assert( p->nLookahead>0 ); - - /* Make sure we have enough space to hold the expanded action table - ** in the worst case. The worst case occurs if the transaction set - ** must be appended to the current action table - */ - n = p->mxLookahead + 1; - if( p->nAction + n >= p->nActionAlloc ){ - int oldAlloc = p->nActionAlloc; - p->nActionAlloc = p->nAction + n + p->nActionAlloc + 20; - p->aAction = (struct lookahead_action *) realloc( p->aAction, - sizeof(p->aAction[0])*p->nActionAlloc); - if( p->aAction==0 ){ - fprintf(stderr,"malloc failed\n"); - exit(1); - } - for(i=oldAlloc; inActionAlloc; i++){ - p->aAction[i].lookahead = -1; - p->aAction[i].action = -1; - } - } - - /* Scan the existing action table looking for an offset that is a - ** duplicate of the current transaction set. Fall out of the loop - ** if and when the duplicate is found. - ** - ** i is the index in p->aAction[] where p->mnLookahead is inserted. - */ - for(i=p->nAction-1; i>=0; i--){ - if( p->aAction[i].lookahead==p->mnLookahead ){ - /* All lookaheads and actions in the aLookahead[] transaction - ** must match against the candidate aAction[i] entry. */ - if( p->aAction[i].action!=p->mnAction ) continue; - for(j=0; jnLookahead; j++){ - k = p->aLookahead[j].lookahead - p->mnLookahead + i; - if( k<0 || k>=p->nAction ) break; - if( p->aLookahead[j].lookahead!=p->aAction[k].lookahead ) break; - if( p->aLookahead[j].action!=p->aAction[k].action ) break; - } - if( jnLookahead ) continue; - - /* No possible lookahead value that is not in the aLookahead[] - ** transaction is allowed to match aAction[i] */ - n = 0; - for(j=0; jnAction; j++){ - if( p->aAction[j].lookahead<0 ) continue; - if( p->aAction[j].lookahead==j+p->mnLookahead-i ) n++; - } - if( n==p->nLookahead ){ - break; /* An exact match is found at offset i */ - } - } - } - - /* If no existing offsets exactly match the current transaction, find an - ** an empty offset in the aAction[] table in which we can add the - ** aLookahead[] transaction. - */ - if( i<0 ){ - /* Look for holes in the aAction[] table that fit the current - ** aLookahead[] transaction. Leave i set to the offset of the hole. - ** If no holes are found, i is left at p->nAction, which means the - ** transaction will be appended. */ - for(i=0; inActionAlloc - p->mxLookahead; i++){ - if( p->aAction[i].lookahead<0 ){ - for(j=0; jnLookahead; j++){ - k = p->aLookahead[j].lookahead - p->mnLookahead + i; - if( k<0 ) break; - if( p->aAction[k].lookahead>=0 ) break; - } - if( jnLookahead ) continue; - for(j=0; jnAction; j++){ - if( p->aAction[j].lookahead==j+p->mnLookahead-i ) break; - } - if( j==p->nAction ){ - break; /* Fits in empty slots */ - } - } - } - } - /* Insert transaction set at index i. */ - for(j=0; jnLookahead; j++){ - k = p->aLookahead[j].lookahead - p->mnLookahead + i; - p->aAction[k] = p->aLookahead[j]; - if( k>=p->nAction ) p->nAction = k+1; - } - p->nLookahead = 0; - - /* Return the offset that is added to the lookahead in order to get the - ** index into yy_action of the action */ - return i - p->mnLookahead; -} - -/********************** From the file "build.c" *****************************/ -/* -** Routines to construction the finite state machine for the LEMON -** parser generator. -*/ - -/* Find a precedence symbol of every rule in the grammar. -** -** Those rules which have a precedence symbol coded in the input -** grammar using the "[symbol]" construct will already have the -** rp->precsym field filled. Other rules take as their precedence -** symbol the first RHS symbol with a defined precedence. If there -** are not RHS symbols with a defined precedence, the precedence -** symbol field is left blank. -*/ -void FindRulePrecedences(struct lemon *xp) -{ - struct rule *rp; - for(rp=xp->rule; rp; rp=rp->next){ - if( rp->precsym==0 ){ - int i, j; - for(i=0; inrhs && rp->precsym==0; i++){ - struct symbol *sp = rp->rhs[i]; - if( sp->type==MULTITERMINAL ){ - for(j=0; jnsubsym; j++){ - if( sp->subsym[j]->prec>=0 ){ - rp->precsym = sp->subsym[j]; - break; - } - } - }else if( sp->prec>=0 ){ - rp->precsym = rp->rhs[i]; - } - } - } - } - return; -} - -/* Find all nonterminals which will generate the empty string. -** Then go back and compute the first sets of every nonterminal. -** The first set is the set of all terminal symbols which can begin -** a string generated by that nonterminal. -*/ -void FindFirstSets(struct lemon *lemp) -{ - int i, j; - struct rule *rp; - int progress; - - for(i=0; insymbol; i++){ - lemp->symbols[i]->lambda = LEMON_FALSE; - } - for(i=lemp->nterminal; insymbol; i++){ - lemp->symbols[i]->firstset = SetNew(); - } - - /* First compute all lambdas */ - do{ - progress = 0; - for(rp=lemp->rule; rp; rp=rp->next){ - if( rp->lhs->lambda ) continue; - for(i=0; inrhs; i++){ - struct symbol *sp = rp->rhs[i]; - assert( sp->type==NONTERMINAL || sp->lambda==LEMON_FALSE ); - if( sp->lambda==LEMON_FALSE ) break; - } - if( i==rp->nrhs ){ - rp->lhs->lambda = LEMON_TRUE; - progress = 1; - } - } - }while( progress ); - - /* Now compute all first sets */ - do{ - struct symbol *s1, *s2; - progress = 0; - for(rp=lemp->rule; rp; rp=rp->next){ - s1 = rp->lhs; - for(i=0; inrhs; i++){ - s2 = rp->rhs[i]; - if( s2->type==TERMINAL ){ - progress += SetAdd(s1->firstset,s2->index); - break; - }else if( s2->type==MULTITERMINAL ){ - for(j=0; jnsubsym; j++){ - progress += SetAdd(s1->firstset,s2->subsym[j]->index); - } - break; - }else if( s1==s2 ){ - if( s1->lambda==LEMON_FALSE ) break; - }else{ - progress += SetUnion(s1->firstset,s2->firstset); - if( s2->lambda==LEMON_FALSE ) break; - } - } - } - }while( progress ); - return; -} - -/* Compute all LR(0) states for the grammar. Links -** are added to between some states so that the LR(1) follow sets -** can be computed later. -*/ -PRIVATE struct state *getstate(struct lemon *); /* forward reference */ -void FindStates(struct lemon *lemp) -{ - struct symbol *sp; - struct rule *rp; - - Configlist_init(); - - /* Find the start symbol */ - if( lemp->start ){ - sp = Symbol_find(lemp->start); - if( sp==0 ){ - ErrorMsg(lemp->filename,0, -"The specified start symbol \"%s\" is not \ -in a nonterminal of the grammar. \"%s\" will be used as the start \ -symbol instead.",lemp->start,lemp->rule->lhs->name); - lemp->errorcnt++; - sp = lemp->rule->lhs; - } - }else{ - sp = lemp->rule->lhs; - } - - /* Make sure the start symbol doesn't occur on the right-hand side of - ** any rule. Report an error if it does. (YACC would generate a new - ** start symbol in this case.) */ - for(rp=lemp->rule; rp; rp=rp->next){ - int i; - for(i=0; inrhs; i++){ - if( rp->rhs[i]==sp ){ /* FIX ME: Deal with multiterminals */ - ErrorMsg(lemp->filename,0, -"The start symbol \"%s\" occurs on the \ -right-hand side of a rule. This will result in a parser which \ -does not work properly.",sp->name); - lemp->errorcnt++; - } - } - } - - /* The basis configuration set for the first state - ** is all rules which have the start symbol as their - ** left-hand side */ - for(rp=sp->rule; rp; rp=rp->nextlhs){ - struct config *newcfp; - rp->lhsStart = 1; - newcfp = Configlist_addbasis(rp,0); - SetAdd(newcfp->fws,0); - } - - /* Compute the first state. All other states will be - ** computed automatically during the computation of the first one. - ** The returned pointer to the first state is not used. */ - (void)getstate(lemp); - return; -} - -/* Return a pointer to a state which is described by the configuration -** list which has been built from calls to Configlist_add. -*/ -PRIVATE void buildshifts(struct lemon *, struct state *); /* Forwd ref */ -PRIVATE struct state *getstate(struct lemon *lemp) -{ - struct config *cfp, *bp; - struct state *stp; - - /* Extract the sorted basis of the new state. The basis was constructed - ** by prior calls to "Configlist_addbasis()". */ - Configlist_sortbasis(); - bp = Configlist_basis(); - - /* Get a state with the same basis */ - stp = State_find(bp); - if( stp ){ - /* A state with the same basis already exists! Copy all the follow-set - ** propagation links from the state under construction into the - ** preexisting state, then return a pointer to the preexisting state */ - struct config *x, *y; - for(x=bp, y=stp->bp; x && y; x=x->bp, y=y->bp){ - Plink_copy(&y->bplp,x->bplp); - Plink_delete(x->fplp); - x->fplp = x->bplp = 0; - } - cfp = Configlist_return(); - Configlist_eat(cfp); - }else{ - /* This really is a new state. Construct all the details */ - Configlist_closure(lemp); /* Compute the configuration closure */ - Configlist_sort(); /* Sort the configuration closure */ - cfp = Configlist_return(); /* Get a pointer to the config list */ - stp = State_new(); /* A new state structure */ - MemoryCheck(stp); - stp->bp = bp; /* Remember the configuration basis */ - stp->cfp = cfp; /* Remember the configuration closure */ - stp->statenum = lemp->nstate++; /* Every state gets a sequence number */ - stp->ap = 0; /* No actions, yet. */ - State_insert(stp,stp->bp); /* Add to the state table */ - buildshifts(lemp,stp); /* Recursively compute successor states */ - } - return stp; -} - -/* -** Return true if two symbols are the same. -*/ -int same_symbol(struct symbol *a, struct symbol *b) -{ - int i; - if( a==b ) return 1; - if( a->type!=MULTITERMINAL ) return 0; - if( b->type!=MULTITERMINAL ) return 0; - if( a->nsubsym!=b->nsubsym ) return 0; - for(i=0; insubsym; i++){ - if( a->subsym[i]!=b->subsym[i] ) return 0; - } - return 1; -} - -/* Construct all successor states to the given state. A "successor" -** state is any state which can be reached by a shift action. -*/ -PRIVATE void buildshifts(struct lemon *lemp, struct state *stp) -{ - struct config *cfp; /* For looping thru the config closure of "stp" */ - struct config *bcfp; /* For the inner loop on config closure of "stp" */ - struct config *newcfg; /* */ - struct symbol *sp; /* Symbol following the dot in configuration "cfp" */ - struct symbol *bsp; /* Symbol following the dot in configuration "bcfp" */ - struct state *newstp; /* A pointer to a successor state */ - - /* Each configuration becomes complete after it contibutes to a successor - ** state. Initially, all configurations are incomplete */ - for(cfp=stp->cfp; cfp; cfp=cfp->next) cfp->status = INCOMPLETE; - - /* Loop through all configurations of the state "stp" */ - for(cfp=stp->cfp; cfp; cfp=cfp->next){ - if( cfp->status==COMPLETE ) continue; /* Already used by inner loop */ - if( cfp->dot>=cfp->rp->nrhs ) continue; /* Can't shift this config */ - Configlist_reset(); /* Reset the new config set */ - sp = cfp->rp->rhs[cfp->dot]; /* Symbol after the dot */ - - /* For every configuration in the state "stp" which has the symbol "sp" - ** following its dot, add the same configuration to the basis set under - ** construction but with the dot shifted one symbol to the right. */ - for(bcfp=cfp; bcfp; bcfp=bcfp->next){ - if( bcfp->status==COMPLETE ) continue; /* Already used */ - if( bcfp->dot>=bcfp->rp->nrhs ) continue; /* Can't shift this one */ - bsp = bcfp->rp->rhs[bcfp->dot]; /* Get symbol after dot */ - if( !same_symbol(bsp,sp) ) continue; /* Must be same as for "cfp" */ - bcfp->status = COMPLETE; /* Mark this config as used */ - newcfg = Configlist_addbasis(bcfp->rp,bcfp->dot+1); - Plink_add(&newcfg->bplp,bcfp); - } - - /* Get a pointer to the state described by the basis configuration set - ** constructed in the preceding loop */ - newstp = getstate(lemp); - - /* The state "newstp" is reached from the state "stp" by a shift action - ** on the symbol "sp" */ - if( sp->type==MULTITERMINAL ){ - int i; - for(i=0; insubsym; i++){ - Action_add(&stp->ap,SHIFT,sp->subsym[i],(char*)newstp); - } - }else{ - Action_add(&stp->ap,SHIFT,sp,(char *)newstp); - } - } -} - -/* -** Construct the propagation links -*/ -void FindLinks(struct lemon *lemp) -{ - int i; - struct config *cfp, *other; - struct state *stp; - struct plink *plp; - - /* Housekeeping detail: - ** Add to every propagate link a pointer back to the state to - ** which the link is attached. */ - for(i=0; instate; i++){ - stp = lemp->sorted[i]; - for(cfp=stp->cfp; cfp; cfp=cfp->next){ - cfp->stp = stp; - } - } - - /* Convert all backlinks into forward links. Only the forward - ** links are used in the follow-set computation. */ - for(i=0; instate; i++){ - stp = lemp->sorted[i]; - for(cfp=stp->cfp; cfp; cfp=cfp->next){ - for(plp=cfp->bplp; plp; plp=plp->next){ - other = plp->cfp; - Plink_add(&other->fplp,cfp); - } - } - } -} - -/* Compute all followsets. -** -** A followset is the set of all symbols which can come immediately -** after a configuration. -*/ -void FindFollowSets(struct lemon *lemp) -{ - int i; - struct config *cfp; - struct plink *plp; - int progress; - int change; - - for(i=0; instate; i++){ - for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){ - cfp->status = INCOMPLETE; - } - } - - do{ - progress = 0; - for(i=0; instate; i++){ - for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){ - if( cfp->status==COMPLETE ) continue; - for(plp=cfp->fplp; plp; plp=plp->next){ - change = SetUnion(plp->cfp->fws,cfp->fws); - if( change ){ - plp->cfp->status = INCOMPLETE; - progress = 1; - } - } - cfp->status = COMPLETE; - } - } - }while( progress ); -} - -static int resolve_conflict(struct action *,struct action *); - -/* Compute the reduce actions, and resolve conflicts. -*/ -void FindActions(struct lemon *lemp) -{ - int i,j; - struct config *cfp; - struct state *stp; - struct symbol *sp; - struct rule *rp; - - /* Add all of the reduce actions - ** A reduce action is added for each element of the followset of - ** a configuration which has its dot at the extreme right. - */ - for(i=0; instate; i++){ /* Loop over all states */ - stp = lemp->sorted[i]; - for(cfp=stp->cfp; cfp; cfp=cfp->next){ /* Loop over all configurations */ - if( cfp->rp->nrhs==cfp->dot ){ /* Is dot at extreme right? */ - for(j=0; jnterminal; j++){ - if( SetFind(cfp->fws,j) ){ - /* Add a reduce action to the state "stp" which will reduce by the - ** rule "cfp->rp" if the lookahead symbol is "lemp->symbols[j]" */ - Action_add(&stp->ap,REDUCE,lemp->symbols[j],(char *)cfp->rp); - } - } - } - } - } - - /* Add the accepting token */ - if( lemp->start ){ - sp = Symbol_find(lemp->start); - if( sp==0 ) sp = lemp->rule->lhs; - }else{ - sp = lemp->rule->lhs; - } - /* Add to the first state (which is always the starting state of the - ** finite state machine) an action to ACCEPT if the lookahead is the - ** start nonterminal. */ - Action_add(&lemp->sorted[0]->ap,ACCEPT,sp,0); - - /* Resolve conflicts */ - for(i=0; instate; i++){ - struct action *ap, *nap; - struct state *stp; - stp = lemp->sorted[i]; - /* assert( stp->ap ); */ - stp->ap = Action_sort(stp->ap); - for(ap=stp->ap; ap && ap->next; ap=ap->next){ - for(nap=ap->next; nap && nap->sp==ap->sp; nap=nap->next){ - /* The two actions "ap" and "nap" have the same lookahead. - ** Figure out which one should be used */ - lemp->nconflict += resolve_conflict(ap,nap); - } - } - } - - /* Report an error for each rule that can never be reduced. */ - for(rp=lemp->rule; rp; rp=rp->next) rp->canReduce = LEMON_FALSE; - for(i=0; instate; i++){ - struct action *ap; - for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){ - if( ap->type==REDUCE ) ap->x.rp->canReduce = LEMON_TRUE; - } - } - for(rp=lemp->rule; rp; rp=rp->next){ - if( rp->canReduce ) continue; - ErrorMsg(lemp->filename,rp->ruleline,"This rule can not be reduced.\n"); - lemp->errorcnt++; - } -} - -/* Resolve a conflict between the two given actions. If the -** conflict can't be resolved, return non-zero. -** -** NO LONGER TRUE: -** To resolve a conflict, first look to see if either action -** is on an error rule. In that case, take the action which -** is not associated with the error rule. If neither or both -** actions are associated with an error rule, then try to -** use precedence to resolve the conflict. -** -** If either action is a SHIFT, then it must be apx. This -** function won't work if apx->type==REDUCE and apy->type==SHIFT. -*/ -static int resolve_conflict( - struct action *apx, - struct action *apy -){ - struct symbol *spx, *spy; - int errcnt = 0; - assert( apx->sp==apy->sp ); /* Otherwise there would be no conflict */ - if( apx->type==SHIFT && apy->type==SHIFT ){ - apy->type = SSCONFLICT; - errcnt++; - } - if( apx->type==SHIFT && apy->type==REDUCE ){ - spx = apx->sp; - spy = apy->x.rp->precsym; - if( spy==0 || spx->prec<0 || spy->prec<0 ){ - /* Not enough precedence information. */ - apy->type = SRCONFLICT; - errcnt++; - }else if( spx->prec>spy->prec ){ /* higher precedence wins */ - apy->type = RD_RESOLVED; - }else if( spx->precprec ){ - apx->type = SH_RESOLVED; - }else if( spx->prec==spy->prec && spx->assoc==RIGHT ){ /* Use operator */ - apy->type = RD_RESOLVED; /* associativity */ - }else if( spx->prec==spy->prec && spx->assoc==LEFT ){ /* to break tie */ - apx->type = SH_RESOLVED; - }else{ - assert( spx->prec==spy->prec && spx->assoc==NONE ); - apx->type = ERROR; - } - }else if( apx->type==REDUCE && apy->type==REDUCE ){ - spx = apx->x.rp->precsym; - spy = apy->x.rp->precsym; - if( spx==0 || spy==0 || spx->prec<0 || - spy->prec<0 || spx->prec==spy->prec ){ - apy->type = RRCONFLICT; - errcnt++; - }else if( spx->prec>spy->prec ){ - apy->type = RD_RESOLVED; - }else if( spx->precprec ){ - apx->type = RD_RESOLVED; - } - }else{ - assert( - apx->type==SH_RESOLVED || - apx->type==RD_RESOLVED || - apx->type==SSCONFLICT || - apx->type==SRCONFLICT || - apx->type==RRCONFLICT || - apy->type==SH_RESOLVED || - apy->type==RD_RESOLVED || - apy->type==SSCONFLICT || - apy->type==SRCONFLICT || - apy->type==RRCONFLICT - ); - /* The REDUCE/SHIFT case cannot happen because SHIFTs come before - ** REDUCEs on the list. If we reach this point it must be because - ** the parser conflict had already been resolved. */ - } - return errcnt; -} -/********************* From the file "configlist.c" *************************/ -/* -** Routines to processing a configuration list and building a state -** in the LEMON parser generator. -*/ - -static struct config *freelist = 0; /* List of free configurations */ -static struct config *current = 0; /* Top of list of configurations */ -static struct config **currentend = 0; /* Last on list of configs */ -static struct config *basis = 0; /* Top of list of basis configs */ -static struct config **basisend = 0; /* End of list of basis configs */ - -/* Return a pointer to a new configuration */ -PRIVATE struct config *newconfig(){ - struct config *newcfg; - if( freelist==0 ){ - int i; - int amt = 3; - freelist = (struct config *)calloc( amt, sizeof(struct config) ); - if( freelist==0 ){ - fprintf(stderr,"Unable to allocate memory for a new configuration."); - exit(1); - } - for(i=0; inext; - return newcfg; -} - -/* The configuration "old" is no longer used */ -PRIVATE void deleteconfig(struct config *old) -{ - old->next = freelist; - freelist = old; -} - -/* Initialized the configuration list builder */ -void Configlist_init(){ - current = 0; - currentend = ¤t; - basis = 0; - basisend = &basis; - Configtable_init(); - return; -} - -/* Initialized the configuration list builder */ -void Configlist_reset(){ - current = 0; - currentend = ¤t; - basis = 0; - basisend = &basis; - Configtable_clear(0); - return; -} - -/* Add another configuration to the configuration list */ -struct config *Configlist_add( - struct rule *rp, /* The rule */ - int dot /* Index into the RHS of the rule where the dot goes */ -){ - struct config *cfp, model; - - assert( currentend!=0 ); - model.rp = rp; - model.dot = dot; - cfp = Configtable_find(&model); - if( cfp==0 ){ - cfp = newconfig(); - cfp->rp = rp; - cfp->dot = dot; - cfp->fws = SetNew(); - cfp->stp = 0; - cfp->fplp = cfp->bplp = 0; - cfp->next = 0; - cfp->bp = 0; - *currentend = cfp; - currentend = &cfp->next; - Configtable_insert(cfp); - } - return cfp; -} - -/* Add a basis configuration to the configuration list */ -struct config *Configlist_addbasis(struct rule *rp, int dot) -{ - struct config *cfp, model; - - assert( basisend!=0 ); - assert( currentend!=0 ); - model.rp = rp; - model.dot = dot; - cfp = Configtable_find(&model); - if( cfp==0 ){ - cfp = newconfig(); - cfp->rp = rp; - cfp->dot = dot; - cfp->fws = SetNew(); - cfp->stp = 0; - cfp->fplp = cfp->bplp = 0; - cfp->next = 0; - cfp->bp = 0; - *currentend = cfp; - currentend = &cfp->next; - *basisend = cfp; - basisend = &cfp->bp; - Configtable_insert(cfp); - } - return cfp; -} - -/* Compute the closure of the configuration list */ -void Configlist_closure(struct lemon *lemp) -{ - struct config *cfp, *newcfp; - struct rule *rp, *newrp; - struct symbol *sp, *xsp; - int i, dot; - - assert( currentend!=0 ); - for(cfp=current; cfp; cfp=cfp->next){ - rp = cfp->rp; - dot = cfp->dot; - if( dot>=rp->nrhs ) continue; - sp = rp->rhs[dot]; - if( sp->type==NONTERMINAL ){ - if( sp->rule==0 && sp!=lemp->errsym ){ - ErrorMsg(lemp->filename,rp->line,"Nonterminal \"%s\" has no rules.", - sp->name); - lemp->errorcnt++; - } - for(newrp=sp->rule; newrp; newrp=newrp->nextlhs){ - newcfp = Configlist_add(newrp,0); - for(i=dot+1; inrhs; i++){ - xsp = rp->rhs[i]; - if( xsp->type==TERMINAL ){ - SetAdd(newcfp->fws,xsp->index); - break; - }else if( xsp->type==MULTITERMINAL ){ - int k; - for(k=0; knsubsym; k++){ - SetAdd(newcfp->fws, xsp->subsym[k]->index); - } - break; - }else{ - SetUnion(newcfp->fws,xsp->firstset); - if( xsp->lambda==LEMON_FALSE ) break; - } - } - if( i==rp->nrhs ) Plink_add(&cfp->fplp,newcfp); - } - } - } - return; -} - -/* Sort the configuration list */ -void Configlist_sort(){ - current = (struct config *)msort((char *)current,(char **)&(current->next),Configcmp); - currentend = 0; - return; -} - -/* Sort the basis configuration list */ -void Configlist_sortbasis(){ - basis = (struct config *)msort((char *)current,(char **)&(current->bp),Configcmp); - basisend = 0; - return; -} - -/* Return a pointer to the head of the configuration list and -** reset the list */ -struct config *Configlist_return(){ - struct config *old; - old = current; - current = 0; - currentend = 0; - return old; -} - -/* Return a pointer to the head of the configuration list and -** reset the list */ -struct config *Configlist_basis(){ - struct config *old; - old = basis; - basis = 0; - basisend = 0; - return old; -} - -/* Free all elements of the given configuration list */ -void Configlist_eat(struct config *cfp) -{ - struct config *nextcfp; - for(; cfp; cfp=nextcfp){ - nextcfp = cfp->next; - assert( cfp->fplp==0 ); - assert( cfp->bplp==0 ); - if( cfp->fws ) SetFree(cfp->fws); - deleteconfig(cfp); - } - return; -} -/***************** From the file "error.c" *********************************/ -/* -** Code for printing error message. -*/ - -void ErrorMsg(const char *filename, int lineno, const char *format, ...){ - va_list ap; - fprintf(stderr, "%s:%d: ", filename, lineno); - va_start(ap, format); - vfprintf(stderr,format,ap); - va_end(ap); - fprintf(stderr, "\n"); -} -/**************** From the file "main.c" ************************************/ -/* -** Main program file for the LEMON parser generator. -*/ - -/* Report an out-of-memory condition and abort. This function -** is used mostly by the "MemoryCheck" macro in struct.h -*/ -void memory_error(){ - fprintf(stderr,"Out of memory. Aborting...\n"); - exit(1); -} - -static int nDefine = 0; /* Number of -D options on the command line */ -static char **azDefine = 0; /* Name of the -D macros */ - -/* This routine is called with the argument to each -D command-line option. -** Add the macro defined to the azDefine array. -*/ -static void handle_D_option(char *z){ - char **paz; - nDefine++; - azDefine = (char **) realloc(azDefine, sizeof(azDefine[0])*nDefine); - if( azDefine==0 ){ - fprintf(stderr,"out of memory\n"); - exit(1); - } - paz = &azDefine[nDefine-1]; - *paz = (char *) malloc( lemonStrlen(z)+1 ); - if( *paz==0 ){ - fprintf(stderr,"out of memory\n"); - exit(1); - } - lemon_strcpy(*paz, z); - for(z=*paz; *z && *z!='='; z++){} - *z = 0; -} - -static char *user_templatename = NULL; -static void handle_T_option(char *z){ - user_templatename = (char *) malloc( lemonStrlen(z)+1 ); - if( user_templatename==0 ){ - memory_error(); - } - lemon_strcpy(user_templatename, z); -} - -/* The main program. Parse the command line and do it... */ -int main(int argc, char **argv) -{ - static int version = 0; - static int rpflag = 0; - static int basisflag = 0; - static int compress = 0; - static int quiet = 0; - static int statistics = 0; - static int mhflag = 0; - static int nolinenosflag = 0; - static int noResort = 0; - static struct s_options options[] = { - {OPT_FLAG, "b", (char*)&basisflag, "Print only the basis in report."}, - {OPT_FLAG, "c", (char*)&compress, "Don't compress the action table."}, - {OPT_FSTR, "D", (char*)handle_D_option, "Define an %ifdef macro."}, - {OPT_FSTR, "T", (char*)handle_T_option, "Specify a template file."}, - {OPT_FLAG, "g", (char*)&rpflag, "Print grammar without actions."}, - {OPT_FLAG, "m", (char*)&mhflag, "Output a makeheaders compatible file."}, - {OPT_FLAG, "l", (char*)&nolinenosflag, "Do not print #line statements."}, - {OPT_FLAG, "p", (char*)&showPrecedenceConflict, - "Show conflicts resolved by precedence rules"}, - {OPT_FLAG, "q", (char*)&quiet, "(Quiet) Don't print the report file."}, - {OPT_FLAG, "r", (char*)&noResort, "Do not sort or renumber states"}, - {OPT_FLAG, "s", (char*)&statistics, - "Print parser stats to standard output."}, - {OPT_FLAG, "x", (char*)&version, "Print the version number."}, - {OPT_FLAG,0,0,0} - }; - int i; - int exitcode; - struct lemon lem; - - OptInit(argv,options,stderr); - if( version ){ - printf("Lemon version 1.0\n"); - exit(0); - } - if( OptNArgs()!=1 ){ - fprintf(stderr,"Exactly one filename argument is required.\n"); - exit(1); - } - memset(&lem, 0, sizeof(lem)); - lem.errorcnt = 0; - - /* Initialize the machine */ - Strsafe_init(); - Symbol_init(); - State_init(); - lem.argv0 = argv[0]; - lem.filename = OptArg(0); - lem.basisflag = basisflag; - lem.nolinenosflag = nolinenosflag; - Symbol_new("$"); - lem.errsym = Symbol_new("error"); - lem.errsym->useCnt = 0; - - /* Parse the input file */ - Parse(&lem); - if( lem.errorcnt ) exit(lem.errorcnt); - if( lem.nrule==0 ){ - fprintf(stderr,"Empty grammar.\n"); - exit(1); - } - - /* Count and index the symbols of the grammar */ - Symbol_new("{default}"); - lem.nsymbol = Symbol_count(); - lem.symbols = Symbol_arrayof(); - for(i=0; iindex = i; - qsort(lem.symbols,lem.nsymbol,sizeof(struct symbol*), Symbolcmpp); - for(i=0; iindex = i; - while( lem.symbols[i-1]->type==MULTITERMINAL ){ i--; } - assert( strcmp(lem.symbols[i-1]->name,"{default}")==0 ); - lem.nsymbol = i - 1; - for(i=1; isupper(lem.symbols[i]->name[0]); i++); - lem.nterminal = i; - - /* Generate a reprint of the grammar, if requested on the command line */ - if( rpflag ){ - Reprint(&lem); - }else{ - /* Initialize the size for all follow and first sets */ - SetSize(lem.nterminal+1); - - /* Find the precedence for every production rule (that has one) */ - FindRulePrecedences(&lem); - - /* Compute the lambda-nonterminals and the first-sets for every - ** nonterminal */ - FindFirstSets(&lem); - - /* Compute all LR(0) states. Also record follow-set propagation - ** links so that the follow-set can be computed later */ - lem.nstate = 0; - FindStates(&lem); - lem.sorted = State_arrayof(); - - /* Tie up loose ends on the propagation links */ - FindLinks(&lem); - - /* Compute the follow set of every reducible configuration */ - FindFollowSets(&lem); - - /* Compute the action tables */ - FindActions(&lem); - - /* Compress the action tables */ - if( compress==0 ) CompressTables(&lem); - - /* Reorder and renumber the states so that states with fewer choices - ** occur at the end. This is an optimization that helps make the - ** generated parser tables smaller. */ - if( noResort==0 ) ResortStates(&lem); - - /* Generate a report of the parser generated. (the "y.output" file) */ - if( !quiet ) ReportOutput(&lem); - - /* Generate the source code for the parser */ - ReportTable(&lem, mhflag); - - /* Produce a header file for use by the scanner. (This step is - ** omitted if the "-m" option is used because makeheaders will - ** generate the file for us.) */ - if( !mhflag ) ReportHeader(&lem); - } - if( statistics ){ - printf("Parser statistics: %d terminals, %d nonterminals, %d rules\n", - lem.nterminal, lem.nsymbol - lem.nterminal, lem.nrule); - printf(" %d states, %d parser table entries, %d conflicts\n", - lem.nstate, lem.tablesize, lem.nconflict); - } - if( lem.nconflict > 0 ){ - fprintf(stderr,"%d parsing conflicts.\n",lem.nconflict); - } - - /* return 0 on success, 1 on failure. */ - exitcode = ((lem.errorcnt > 0) || (lem.nconflict > 0)) ? 1 : 0; - exit(exitcode); - return (exitcode); -} -/******************** From the file "msort.c" *******************************/ -/* -** A generic merge-sort program. -** -** USAGE: -** Let "ptr" be a pointer to some structure which is at the head of -** a null-terminated list. Then to sort the list call: -** -** ptr = msort(ptr,&(ptr->next),cmpfnc); -** -** In the above, "cmpfnc" is a pointer to a function which compares -** two instances of the structure and returns an integer, as in -** strcmp. The second argument is a pointer to the pointer to the -** second element of the linked list. This address is used to compute -** the offset to the "next" field within the structure. The offset to -** the "next" field must be constant for all structures in the list. -** -** The function returns a new pointer which is the head of the list -** after sorting. -** -** ALGORITHM: -** Merge-sort. -*/ - -/* -** Return a pointer to the next structure in the linked list. -*/ -#define NEXT(A) (*(char**)(((char*)A)+offset)) - -/* -** Inputs: -** a: A sorted, null-terminated linked list. (May be null). -** b: A sorted, null-terminated linked list. (May be null). -** cmp: A pointer to the comparison function. -** offset: Offset in the structure to the "next" field. -** -** Return Value: -** A pointer to the head of a sorted list containing the elements -** of both a and b. -** -** Side effects: -** The "next" pointers for elements in the lists a and b are -** changed. -*/ -static char *merge( - char *a, - char *b, - int (*cmp)(const char*,const char*), - int offset -){ - char *ptr, *head; - - if( a==0 ){ - head = b; - }else if( b==0 ){ - head = a; - }else{ - if( (*cmp)(a,b)<=0 ){ - ptr = a; - a = NEXT(a); - }else{ - ptr = b; - b = NEXT(b); - } - head = ptr; - while( a && b ){ - if( (*cmp)(a,b)<=0 ){ - NEXT(ptr) = a; - ptr = a; - a = NEXT(a); - }else{ - NEXT(ptr) = b; - ptr = b; - b = NEXT(b); - } - } - if( a ) NEXT(ptr) = a; - else NEXT(ptr) = b; - } - return head; -} - -/* -** Inputs: -** list: Pointer to a singly-linked list of structures. -** next: Pointer to pointer to the second element of the list. -** cmp: A comparison function. -** -** Return Value: -** A pointer to the head of a sorted list containing the elements -** orginally in list. -** -** Side effects: -** The "next" pointers for elements in list are changed. -*/ -#define LISTSIZE 30 -static char *msort( - char *list, - char **next, - int (*cmp)(const char*,const char*) -){ - unsigned long offset; - char *ep; - char *set[LISTSIZE]; - int i; - offset = (unsigned long)next - (unsigned long)list; - for(i=0; istate = WAITING_FOR_DECL_KEYWORD; - }else if( islower(x[0]) ){ - psp->lhs = Symbol_new(x); - psp->nrhs = 0; - psp->lhsalias = 0; - psp->state = WAITING_FOR_ARROW; - }else if( x[0]=='{' ){ - if( psp->prevrule==0 ){ - ErrorMsg(psp->filename,psp->tokenlineno, -"There is no prior rule upon which to attach the code \ -fragment which begins on this line."); - psp->errorcnt++; - }else if( psp->prevrule->code!=0 ){ - ErrorMsg(psp->filename,psp->tokenlineno, -"Code fragment beginning on this line is not the first \ -to follow the previous rule."); - psp->errorcnt++; - }else{ - psp->prevrule->line = psp->tokenlineno; - psp->prevrule->code = &x[1]; - } - }else if( x[0]=='[' ){ - psp->state = PRECEDENCE_MARK_1; - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "Token \"%s\" should be either \"%%\" or a nonterminal name.", - x); - psp->errorcnt++; - } - break; - case PRECEDENCE_MARK_1: - if( !isupper(x[0]) ){ - ErrorMsg(psp->filename,psp->tokenlineno, - "The precedence symbol must be a terminal."); - psp->errorcnt++; - }else if( psp->prevrule==0 ){ - ErrorMsg(psp->filename,psp->tokenlineno, - "There is no prior rule to assign precedence \"[%s]\".",x); - psp->errorcnt++; - }else if( psp->prevrule->precsym!=0 ){ - ErrorMsg(psp->filename,psp->tokenlineno, -"Precedence mark on this line is not the first \ -to follow the previous rule."); - psp->errorcnt++; - }else{ - psp->prevrule->precsym = Symbol_new(x); - } - psp->state = PRECEDENCE_MARK_2; - break; - case PRECEDENCE_MARK_2: - if( x[0]!=']' ){ - ErrorMsg(psp->filename,psp->tokenlineno, - "Missing \"]\" on precedence mark."); - psp->errorcnt++; - } - psp->state = WAITING_FOR_DECL_OR_RULE; - break; - case WAITING_FOR_ARROW: - if( x[0]==':' && x[1]==':' && x[2]=='=' ){ - psp->state = IN_RHS; - }else if( x[0]=='(' ){ - psp->state = LHS_ALIAS_1; - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "Expected to see a \":\" following the LHS symbol \"%s\".", - psp->lhs->name); - psp->errorcnt++; - psp->state = RESYNC_AFTER_RULE_ERROR; - } - break; - case LHS_ALIAS_1: - if( isalpha(x[0]) ){ - psp->lhsalias = x; - psp->state = LHS_ALIAS_2; - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "\"%s\" is not a valid alias for the LHS \"%s\"\n", - x,psp->lhs->name); - psp->errorcnt++; - psp->state = RESYNC_AFTER_RULE_ERROR; - } - break; - case LHS_ALIAS_2: - if( x[0]==')' ){ - psp->state = LHS_ALIAS_3; - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias); - psp->errorcnt++; - psp->state = RESYNC_AFTER_RULE_ERROR; - } - break; - case LHS_ALIAS_3: - if( x[0]==':' && x[1]==':' && x[2]=='=' ){ - psp->state = IN_RHS; - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "Missing \"->\" following: \"%s(%s)\".", - psp->lhs->name,psp->lhsalias); - psp->errorcnt++; - psp->state = RESYNC_AFTER_RULE_ERROR; - } - break; - case IN_RHS: - if( x[0]=='.' ){ - struct rule *rp; - rp = (struct rule *)calloc( sizeof(struct rule) + - sizeof(struct symbol*)*psp->nrhs + sizeof(char*)*psp->nrhs, 1); - if( rp==0 ){ - ErrorMsg(psp->filename,psp->tokenlineno, - "Can't allocate enough memory for this rule."); - psp->errorcnt++; - psp->prevrule = 0; - }else{ - int i; - rp->ruleline = psp->tokenlineno; - rp->rhs = (struct symbol**)&rp[1]; - rp->rhsalias = (const char**)&(rp->rhs[psp->nrhs]); - for(i=0; inrhs; i++){ - rp->rhs[i] = psp->rhs[i]; - rp->rhsalias[i] = psp->alias[i]; - } - rp->lhs = psp->lhs; - rp->lhsalias = psp->lhsalias; - rp->nrhs = psp->nrhs; - rp->code = 0; - rp->precsym = 0; - rp->index = psp->gp->nrule++; - rp->nextlhs = rp->lhs->rule; - rp->lhs->rule = rp; - rp->next = 0; - if( psp->firstrule==0 ){ - psp->firstrule = psp->lastrule = rp; - }else{ - psp->lastrule->next = rp; - psp->lastrule = rp; - } - psp->prevrule = rp; - } - psp->state = WAITING_FOR_DECL_OR_RULE; - }else if( isalpha(x[0]) ){ - if( psp->nrhs>=MAXRHS ){ - ErrorMsg(psp->filename,psp->tokenlineno, - "Too many symbols on RHS of rule beginning at \"%s\".", - x); - psp->errorcnt++; - psp->state = RESYNC_AFTER_RULE_ERROR; - }else{ - psp->rhs[psp->nrhs] = Symbol_new(x); - psp->alias[psp->nrhs] = 0; - psp->nrhs++; - } - }else if( (x[0]=='|' || x[0]=='/') && psp->nrhs>0 ){ - struct symbol *msp = psp->rhs[psp->nrhs-1]; - if( msp->type!=MULTITERMINAL ){ - struct symbol *origsp = msp; - msp = (struct symbol *) calloc(1,sizeof(*msp)); - memset(msp, 0, sizeof(*msp)); - msp->type = MULTITERMINAL; - msp->nsubsym = 1; - msp->subsym = (struct symbol **) calloc(1,sizeof(struct symbol*)); - msp->subsym[0] = origsp; - msp->name = origsp->name; - psp->rhs[psp->nrhs-1] = msp; - } - msp->nsubsym++; - msp->subsym = (struct symbol **) realloc(msp->subsym, - sizeof(struct symbol*)*msp->nsubsym); - msp->subsym[msp->nsubsym-1] = Symbol_new(&x[1]); - if( islower(x[1]) || islower(msp->subsym[0]->name[0]) ){ - ErrorMsg(psp->filename,psp->tokenlineno, - "Cannot form a compound containing a non-terminal"); - psp->errorcnt++; - } - }else if( x[0]=='(' && psp->nrhs>0 ){ - psp->state = RHS_ALIAS_1; - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "Illegal character on RHS of rule: \"%s\".",x); - psp->errorcnt++; - psp->state = RESYNC_AFTER_RULE_ERROR; - } - break; - case RHS_ALIAS_1: - if( isalpha(x[0]) ){ - psp->alias[psp->nrhs-1] = x; - psp->state = RHS_ALIAS_2; - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "\"%s\" is not a valid alias for the RHS symbol \"%s\"\n", - x,psp->rhs[psp->nrhs-1]->name); - psp->errorcnt++; - psp->state = RESYNC_AFTER_RULE_ERROR; - } - break; - case RHS_ALIAS_2: - if( x[0]==')' ){ - psp->state = IN_RHS; - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias); - psp->errorcnt++; - psp->state = RESYNC_AFTER_RULE_ERROR; - } - break; - case WAITING_FOR_DECL_KEYWORD: - if( isalpha(x[0]) ){ - psp->declkeyword = x; - psp->declargslot = 0; - psp->decllinenoslot = 0; - psp->insertLineMacro = 1; - psp->state = WAITING_FOR_DECL_ARG; - if( strcmp(x,"name")==0 ){ - psp->declargslot = &(psp->gp->name); - psp->insertLineMacro = 0; - }else if( strcmp(x,"include")==0 ){ - psp->declargslot = &(psp->gp->include); - }else if( strcmp(x,"code")==0 ){ - psp->declargslot = &(psp->gp->extracode); - }else if( strcmp(x,"token_destructor")==0 ){ - psp->declargslot = &psp->gp->tokendest; - }else if( strcmp(x,"default_destructor")==0 ){ - psp->declargslot = &psp->gp->vardest; - }else if( strcmp(x,"token_prefix")==0 ){ - psp->declargslot = &psp->gp->tokenprefix; - psp->insertLineMacro = 0; - }else if( strcmp(x,"syntax_error")==0 ){ - psp->declargslot = &(psp->gp->error); - }else if( strcmp(x,"parse_accept")==0 ){ - psp->declargslot = &(psp->gp->accept); - }else if( strcmp(x,"parse_failure")==0 ){ - psp->declargslot = &(psp->gp->failure); - }else if( strcmp(x,"stack_overflow")==0 ){ - psp->declargslot = &(psp->gp->overflow); - }else if( strcmp(x,"extra_argument")==0 ){ - psp->declargslot = &(psp->gp->arg); - psp->insertLineMacro = 0; - }else if( strcmp(x,"token_type")==0 ){ - psp->declargslot = &(psp->gp->tokentype); - psp->insertLineMacro = 0; - }else if( strcmp(x,"default_type")==0 ){ - psp->declargslot = &(psp->gp->vartype); - psp->insertLineMacro = 0; - }else if( strcmp(x,"stack_size")==0 ){ - psp->declargslot = &(psp->gp->stacksize); - psp->insertLineMacro = 0; - }else if( strcmp(x,"start_symbol")==0 ){ - psp->declargslot = &(psp->gp->start); - psp->insertLineMacro = 0; - }else if( strcmp(x,"left")==0 ){ - psp->preccounter++; - psp->declassoc = LEFT; - psp->state = WAITING_FOR_PRECEDENCE_SYMBOL; - }else if( strcmp(x,"right")==0 ){ - psp->preccounter++; - psp->declassoc = RIGHT; - psp->state = WAITING_FOR_PRECEDENCE_SYMBOL; - }else if( strcmp(x,"nonassoc")==0 ){ - psp->preccounter++; - psp->declassoc = NONE; - psp->state = WAITING_FOR_PRECEDENCE_SYMBOL; - }else if( strcmp(x,"destructor")==0 ){ - psp->state = WAITING_FOR_DESTRUCTOR_SYMBOL; - }else if( strcmp(x,"type")==0 ){ - psp->state = WAITING_FOR_DATATYPE_SYMBOL; - }else if( strcmp(x,"fallback")==0 ){ - psp->fallback = 0; - psp->state = WAITING_FOR_FALLBACK_ID; - }else if( strcmp(x,"wildcard")==0 ){ - psp->state = WAITING_FOR_WILDCARD_ID; - }else if( strcmp(x,"token_class")==0 ){ - psp->state = WAITING_FOR_CLASS_ID; - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "Unknown declaration keyword: \"%%%s\".",x); - psp->errorcnt++; - psp->state = RESYNC_AFTER_DECL_ERROR; - } - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "Illegal declaration keyword: \"%s\".",x); - psp->errorcnt++; - psp->state = RESYNC_AFTER_DECL_ERROR; - } - break; - case WAITING_FOR_DESTRUCTOR_SYMBOL: - if( !isalpha(x[0]) ){ - ErrorMsg(psp->filename,psp->tokenlineno, - "Symbol name missing after %%destructor keyword"); - psp->errorcnt++; - psp->state = RESYNC_AFTER_DECL_ERROR; - }else{ - struct symbol *sp = Symbol_new(x); - psp->declargslot = &sp->destructor; - psp->decllinenoslot = &sp->destLineno; - psp->insertLineMacro = 1; - psp->state = WAITING_FOR_DECL_ARG; - } - break; - case WAITING_FOR_DATATYPE_SYMBOL: - if( !isalpha(x[0]) ){ - ErrorMsg(psp->filename,psp->tokenlineno, - "Symbol name missing after %%type keyword"); - psp->errorcnt++; - psp->state = RESYNC_AFTER_DECL_ERROR; - }else{ - struct symbol *sp = Symbol_find(x); - if((sp) && (sp->datatype)){ - ErrorMsg(psp->filename,psp->tokenlineno, - "Symbol %%type \"%s\" already defined", x); - psp->errorcnt++; - psp->state = RESYNC_AFTER_DECL_ERROR; - }else{ - if (!sp){ - sp = Symbol_new(x); - } - psp->declargslot = &sp->datatype; - psp->insertLineMacro = 0; - psp->state = WAITING_FOR_DECL_ARG; - } - } - break; - case WAITING_FOR_PRECEDENCE_SYMBOL: - if( x[0]=='.' ){ - psp->state = WAITING_FOR_DECL_OR_RULE; - }else if( isupper(x[0]) ){ - struct symbol *sp; - sp = Symbol_new(x); - if( sp->prec>=0 ){ - ErrorMsg(psp->filename,psp->tokenlineno, - "Symbol \"%s\" has already be given a precedence.",x); - psp->errorcnt++; - }else{ - sp->prec = psp->preccounter; - sp->assoc = psp->declassoc; - } - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "Can't assign a precedence to \"%s\".",x); - psp->errorcnt++; - } - break; - case WAITING_FOR_DECL_ARG: - if( x[0]=='{' || x[0]=='\"' || isalnum(x[0]) ){ - const char *zOld, *zNew; - char *zBuf, *z; - int nOld, n, nLine, nNew, nBack; - int addLineMacro; - char zLine[50]; - zNew = x; - if( zNew[0]=='"' || zNew[0]=='{' ) zNew++; - nNew = lemonStrlen(zNew); - if( *psp->declargslot ){ - zOld = *psp->declargslot; - }else{ - zOld = ""; - } - nOld = lemonStrlen(zOld); - n = nOld + nNew + 20; - addLineMacro = !psp->gp->nolinenosflag && psp->insertLineMacro && - (psp->decllinenoslot==0 || psp->decllinenoslot[0]!=0); - if( addLineMacro ){ - for(z=psp->filename, nBack=0; *z; z++){ - if( *z=='\\' ) nBack++; - } - lemon_sprintf(zLine, "#line %d ", psp->tokenlineno); - nLine = lemonStrlen(zLine); - n += nLine + lemonStrlen(psp->filename) + nBack; - } - *psp->declargslot = (char *) realloc(*psp->declargslot, n); - zBuf = *psp->declargslot + nOld; - if( addLineMacro ){ - if( nOld && zBuf[-1]!='\n' ){ - *(zBuf++) = '\n'; - } - memcpy(zBuf, zLine, nLine); - zBuf += nLine; - *(zBuf++) = '"'; - for(z=psp->filename; *z; z++){ - if( *z=='\\' ){ - *(zBuf++) = '\\'; - } - *(zBuf++) = *z; - } - *(zBuf++) = '"'; - *(zBuf++) = '\n'; - } - if( psp->decllinenoslot && psp->decllinenoslot[0]==0 ){ - psp->decllinenoslot[0] = psp->tokenlineno; - } - memcpy(zBuf, zNew, nNew); - zBuf += nNew; - *zBuf = 0; - psp->state = WAITING_FOR_DECL_OR_RULE; - }else{ - ErrorMsg(psp->filename,psp->tokenlineno, - "Illegal argument to %%%s: %s",psp->declkeyword,x); - psp->errorcnt++; - psp->state = RESYNC_AFTER_DECL_ERROR; - } - break; - case WAITING_FOR_FALLBACK_ID: - if( x[0]=='.' ){ - psp->state = WAITING_FOR_DECL_OR_RULE; - }else if( !isupper(x[0]) ){ - ErrorMsg(psp->filename, psp->tokenlineno, - "%%fallback argument \"%s\" should be a token", x); - psp->errorcnt++; - }else{ - struct symbol *sp = Symbol_new(x); - if( psp->fallback==0 ){ - psp->fallback = sp; - }else if( sp->fallback ){ - ErrorMsg(psp->filename, psp->tokenlineno, - "More than one fallback assigned to token %s", x); - psp->errorcnt++; - }else{ - sp->fallback = psp->fallback; - psp->gp->has_fallback = 1; - } - } - break; - case WAITING_FOR_WILDCARD_ID: - if( x[0]=='.' ){ - psp->state = WAITING_FOR_DECL_OR_RULE; - }else if( !isupper(x[0]) ){ - ErrorMsg(psp->filename, psp->tokenlineno, - "%%wildcard argument \"%s\" should be a token", x); - psp->errorcnt++; - }else{ - struct symbol *sp = Symbol_new(x); - if( psp->gp->wildcard==0 ){ - psp->gp->wildcard = sp; - }else{ - ErrorMsg(psp->filename, psp->tokenlineno, - "Extra wildcard to token: %s", x); - psp->errorcnt++; - } - } - break; - case WAITING_FOR_CLASS_ID: - if( !islower(x[0]) ){ - ErrorMsg(psp->filename, psp->tokenlineno, - "%%token_class must be followed by an identifier: ", x); - psp->errorcnt++; - psp->state = RESYNC_AFTER_DECL_ERROR; - }else if( Symbol_find(x) ){ - ErrorMsg(psp->filename, psp->tokenlineno, - "Symbol \"%s\" already used", x); - psp->errorcnt++; - psp->state = RESYNC_AFTER_DECL_ERROR; - }else{ - psp->tkclass = Symbol_new(x); - psp->tkclass->type = MULTITERMINAL; - psp->state = WAITING_FOR_CLASS_TOKEN; - } - break; - case WAITING_FOR_CLASS_TOKEN: - if( x[0]=='.' ){ - psp->state = WAITING_FOR_DECL_OR_RULE; - }else if( isupper(x[0]) || ((x[0]=='|' || x[0]=='/') && isupper(x[1])) ){ - struct symbol *msp = psp->tkclass; - msp->nsubsym++; - msp->subsym = (struct symbol **) realloc(msp->subsym, - sizeof(struct symbol*)*msp->nsubsym); - if( !isupper(x[0]) ) x++; - msp->subsym[msp->nsubsym-1] = Symbol_new(x); - }else{ - ErrorMsg(psp->filename, psp->tokenlineno, - "%%token_class argument \"%s\" should be a token", x); - psp->errorcnt++; - psp->state = RESYNC_AFTER_DECL_ERROR; - } - break; - case RESYNC_AFTER_RULE_ERROR: -/* if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE; -** break; */ - case RESYNC_AFTER_DECL_ERROR: - if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE; - if( x[0]=='%' ) psp->state = WAITING_FOR_DECL_KEYWORD; - break; - } -} - -/* Run the preprocessor over the input file text. The global variables -** azDefine[0] through azDefine[nDefine-1] contains the names of all defined -** macros. This routine looks for "%ifdef" and "%ifndef" and "%endif" and -** comments them out. Text in between is also commented out as appropriate. -*/ -static void preprocess_input(char *z){ - int i, j, k, n; - int exclude = 0; - int start = 0; - int lineno = 1; - int start_lineno = 1; - for(i=0; z[i]; i++){ - if( z[i]=='\n' ) lineno++; - if( z[i]!='%' || (i>0 && z[i-1]!='\n') ) continue; - if( strncmp(&z[i],"%endif",6)==0 && isspace(z[i+6]) ){ - if( exclude ){ - exclude--; - if( exclude==0 ){ - for(j=start; jfilename; - ps.errorcnt = 0; - ps.state = INITIALIZE; - - /* Begin by reading the input file */ - fp = fopen(ps.filename,"rb"); - if( fp==0 ){ - ErrorMsg(ps.filename,0,"Can't open this file for reading."); - gp->errorcnt++; - return; - } - fseek(fp,0,2); - filesize = ftell(fp); - rewind(fp); - filebuf = (char *)malloc( filesize+1 ); - if( filesize>100000000 || filebuf==0 ){ - ErrorMsg(ps.filename,0,"Input file too large."); - gp->errorcnt++; - fclose(fp); - return; - } - if( fread(filebuf,1,filesize,fp)!=filesize ){ - ErrorMsg(ps.filename,0,"Can't read in all %d bytes of this file.", - filesize); - free(filebuf); - gp->errorcnt++; - fclose(fp); - return; - } - fclose(fp); - filebuf[filesize] = 0; - - /* Make an initial pass through the file to handle %ifdef and %ifndef */ - preprocess_input(filebuf); - - /* Now scan the text of the input file */ - lineno = 1; - for(cp=filebuf; (c= *cp)!=0; ){ - if( c=='\n' ) lineno++; /* Keep track of the line number */ - if( isspace(c) ){ cp++; continue; } /* Skip all white space */ - if( c=='/' && cp[1]=='/' ){ /* Skip C++ style comments */ - cp+=2; - while( (c= *cp)!=0 && c!='\n' ) cp++; - continue; - } - if( c=='/' && cp[1]=='*' ){ /* Skip C style comments */ - cp+=2; - while( (c= *cp)!=0 && (c!='/' || cp[-1]!='*') ){ - if( c=='\n' ) lineno++; - cp++; - } - if( c ) cp++; - continue; - } - ps.tokenstart = cp; /* Mark the beginning of the token */ - ps.tokenlineno = lineno; /* Linenumber on which token begins */ - if( c=='\"' ){ /* String literals */ - cp++; - while( (c= *cp)!=0 && c!='\"' ){ - if( c=='\n' ) lineno++; - cp++; - } - if( c==0 ){ - ErrorMsg(ps.filename,startline, -"String starting on this line is not terminated before the end of the file."); - ps.errorcnt++; - nextcp = cp; - }else{ - nextcp = cp+1; - } - }else if( c=='{' ){ /* A block of C code */ - int level; - cp++; - for(level=1; (c= *cp)!=0 && (level>1 || c!='}'); cp++){ - if( c=='\n' ) lineno++; - else if( c=='{' ) level++; - else if( c=='}' ) level--; - else if( c=='/' && cp[1]=='*' ){ /* Skip comments */ - int prevc; - cp = &cp[2]; - prevc = 0; - while( (c= *cp)!=0 && (c!='/' || prevc!='*') ){ - if( c=='\n' ) lineno++; - prevc = c; - cp++; - } - }else if( c=='/' && cp[1]=='/' ){ /* Skip C++ style comments too */ - cp = &cp[2]; - while( (c= *cp)!=0 && c!='\n' ) cp++; - if( c ) lineno++; - }else if( c=='\'' || c=='\"' ){ /* String a character literals */ - int startchar, prevc; - startchar = c; - prevc = 0; - for(cp++; (c= *cp)!=0 && (c!=startchar || prevc=='\\'); cp++){ - if( c=='\n' ) lineno++; - if( prevc=='\\' ) prevc = 0; - else prevc = c; - } - } - } - if( c==0 ){ - ErrorMsg(ps.filename,ps.tokenlineno, -"C code starting on this line is not terminated before the end of the file."); - ps.errorcnt++; - nextcp = cp; - }else{ - nextcp = cp+1; - } - }else if( isalnum(c) ){ /* Identifiers */ - while( (c= *cp)!=0 && (isalnum(c) || c=='_') ) cp++; - nextcp = cp; - }else if( c==':' && cp[1]==':' && cp[2]=='=' ){ /* The operator "::=" */ - cp += 3; - nextcp = cp; - }else if( (c=='/' || c=='|') && isalpha(cp[1]) ){ - cp += 2; - while( (c = *cp)!=0 && (isalnum(c) || c=='_') ) cp++; - nextcp = cp; - }else{ /* All other (one character) operators */ - cp++; - nextcp = cp; - } - c = *cp; - *cp = 0; /* Null terminate the token */ - parseonetoken(&ps); /* Parse the token */ - *cp = c; /* Restore the buffer */ - cp = nextcp; - } - free(filebuf); /* Release the buffer after parsing */ - gp->rule = ps.firstrule; - gp->errorcnt = ps.errorcnt; -} -/*************************** From the file "plink.c" *********************/ -/* -** Routines processing configuration follow-set propagation links -** in the LEMON parser generator. -*/ -static struct plink *plink_freelist = 0; - -/* Allocate a new plink */ -struct plink *Plink_new(){ - struct plink *newlink; - - if( plink_freelist==0 ){ - int i; - int amt = 100; - plink_freelist = (struct plink *)calloc( amt, sizeof(struct plink) ); - if( plink_freelist==0 ){ - fprintf(stderr, - "Unable to allocate memory for a new follow-set propagation link.\n"); - exit(1); - } - for(i=0; inext; - return newlink; -} - -/* Add a plink to a plink list */ -void Plink_add(struct plink **plpp, struct config *cfp) -{ - struct plink *newlink; - newlink = Plink_new(); - newlink->next = *plpp; - *plpp = newlink; - newlink->cfp = cfp; -} - -/* Transfer every plink on the list "from" to the list "to" */ -void Plink_copy(struct plink **to, struct plink *from) -{ - struct plink *nextpl; - while( from ){ - nextpl = from->next; - from->next = *to; - *to = from; - from = nextpl; - } -} - -/* Delete every plink on the list */ -void Plink_delete(struct plink *plp) -{ - struct plink *nextpl; - - while( plp ){ - nextpl = plp->next; - plp->next = plink_freelist; - plink_freelist = plp; - plp = nextpl; - } -} -/*********************** From the file "report.c" **************************/ -/* -** Procedures for generating reports and tables in the LEMON parser generator. -*/ - -/* Generate a filename with the given suffix. Space to hold the -** name comes from malloc() and must be freed by the calling -** function. -*/ -PRIVATE char *file_makename(struct lemon *lemp, const char *suffix) -{ - char *name; - char *cp; - - name = (char*)malloc( lemonStrlen(lemp->filename) + lemonStrlen(suffix) + 5 ); - if( name==0 ){ - fprintf(stderr,"Can't allocate space for a filename.\n"); - exit(1); - } - lemon_strcpy(name,lemp->filename); - cp = strrchr(name,'.'); - if( cp ) *cp = 0; - lemon_strcat(name,suffix); - return name; -} - -/* Open a file with a name based on the name of the input file, -** but with a different (specified) suffix, and return a pointer -** to the stream */ -PRIVATE FILE *file_open( - struct lemon *lemp, - const char *suffix, - const char *mode -){ - FILE *fp; - - if( lemp->outname ) free(lemp->outname); - lemp->outname = file_makename(lemp, suffix); - fp = fopen(lemp->outname,mode); - if( fp==0 && *mode=='w' ){ - fprintf(stderr,"Can't open file \"%s\".\n",lemp->outname); - lemp->errorcnt++; - return 0; - } - return fp; -} - -/* Duplicate the input file without comments and without actions -** on rules */ -void Reprint(struct lemon *lemp) -{ - struct rule *rp; - struct symbol *sp; - int i, j, maxlen, len, ncolumns, skip; - printf("// Reprint of input file \"%s\".\n// Symbols:\n",lemp->filename); - maxlen = 10; - for(i=0; insymbol; i++){ - sp = lemp->symbols[i]; - len = lemonStrlen(sp->name); - if( len>maxlen ) maxlen = len; - } - ncolumns = 76/(maxlen+5); - if( ncolumns<1 ) ncolumns = 1; - skip = (lemp->nsymbol + ncolumns - 1)/ncolumns; - for(i=0; insymbol; j+=skip){ - sp = lemp->symbols[j]; - assert( sp->index==j ); - printf(" %3d %-*.*s",j,maxlen,maxlen,sp->name); - } - printf("\n"); - } - for(rp=lemp->rule; rp; rp=rp->next){ - printf("%s",rp->lhs->name); - /* if( rp->lhsalias ) printf("(%s)",rp->lhsalias); */ - printf(" ::="); - for(i=0; inrhs; i++){ - sp = rp->rhs[i]; - if( sp->type==MULTITERMINAL ){ - printf(" %s", sp->subsym[0]->name); - for(j=1; jnsubsym; j++){ - printf("|%s", sp->subsym[j]->name); - } - }else{ - printf(" %s", sp->name); - } - /* if( rp->rhsalias[i] ) printf("(%s)",rp->rhsalias[i]); */ - } - printf("."); - if( rp->precsym ) printf(" [%s]",rp->precsym->name); - /* if( rp->code ) printf("\n %s",rp->code); */ - printf("\n"); - } -} - -void ConfigPrint(FILE *fp, struct config *cfp) -{ - struct rule *rp; - struct symbol *sp; - int i, j; - rp = cfp->rp; - fprintf(fp,"%s ::=",rp->lhs->name); - for(i=0; i<=rp->nrhs; i++){ - if( i==cfp->dot ) fprintf(fp," *"); - if( i==rp->nrhs ) break; - sp = rp->rhs[i]; - if( sp->type==MULTITERMINAL ){ - fprintf(fp," %s", sp->subsym[0]->name); - for(j=1; jnsubsym; j++){ - fprintf(fp,"|%s",sp->subsym[j]->name); - } - }else{ - fprintf(fp," %s", sp->name); - } - } -} - -/* #define TEST */ -#if 0 -/* Print a set */ -PRIVATE void SetPrint(out,set,lemp) -FILE *out; -char *set; -struct lemon *lemp; -{ - int i; - char *spacer; - spacer = ""; - fprintf(out,"%12s[",""); - for(i=0; interminal; i++){ - if( SetFind(set,i) ){ - fprintf(out,"%s%s",spacer,lemp->symbols[i]->name); - spacer = " "; - } - } - fprintf(out,"]\n"); -} - -/* Print a plink chain */ -PRIVATE void PlinkPrint(out,plp,tag) -FILE *out; -struct plink *plp; -char *tag; -{ - while( plp ){ - fprintf(out,"%12s%s (state %2d) ","",tag,plp->cfp->stp->statenum); - ConfigPrint(out,plp->cfp); - fprintf(out,"\n"); - plp = plp->next; - } -} -#endif - -/* Print an action to the given file descriptor. Return FALSE if -** nothing was actually printed. -*/ -int PrintAction(struct action *ap, FILE *fp, int indent){ - int result = 1; - switch( ap->type ){ - case SHIFT: - fprintf(fp,"%*s shift %d",indent,ap->sp->name,ap->x.stp->statenum); - break; - case REDUCE: - fprintf(fp,"%*s reduce %d",indent,ap->sp->name,ap->x.rp->index); - break; - case ACCEPT: - fprintf(fp,"%*s accept",indent,ap->sp->name); - break; - case ERROR: - fprintf(fp,"%*s error",indent,ap->sp->name); - break; - case SRCONFLICT: - case RRCONFLICT: - fprintf(fp,"%*s reduce %-3d ** Parsing conflict **", - indent,ap->sp->name,ap->x.rp->index); - break; - case SSCONFLICT: - fprintf(fp,"%*s shift %-3d ** Parsing conflict **", - indent,ap->sp->name,ap->x.stp->statenum); - break; - case SH_RESOLVED: - if( showPrecedenceConflict ){ - fprintf(fp,"%*s shift %-3d -- dropped by precedence", - indent,ap->sp->name,ap->x.stp->statenum); - }else{ - result = 0; - } - break; - case RD_RESOLVED: - if( showPrecedenceConflict ){ - fprintf(fp,"%*s reduce %-3d -- dropped by precedence", - indent,ap->sp->name,ap->x.rp->index); - }else{ - result = 0; - } - break; - case NOT_USED: - result = 0; - break; - } - return result; -} - -/* Generate the "y.output" log file */ -void ReportOutput(struct lemon *lemp) -{ - int i; - struct state *stp; - struct config *cfp; - struct action *ap; - FILE *fp; - - fp = file_open(lemp,".out","wb"); - if( fp==0 ) return; - for(i=0; instate; i++){ - stp = lemp->sorted[i]; - fprintf(fp,"State %d:\n",stp->statenum); - if( lemp->basisflag ) cfp=stp->bp; - else cfp=stp->cfp; - while( cfp ){ - char buf[20]; - if( cfp->dot==cfp->rp->nrhs ){ - lemon_sprintf(buf,"(%d)",cfp->rp->index); - fprintf(fp," %5s ",buf); - }else{ - fprintf(fp," "); - } - ConfigPrint(fp,cfp); - fprintf(fp,"\n"); -#if 0 - SetPrint(fp,cfp->fws,lemp); - PlinkPrint(fp,cfp->fplp,"To "); - PlinkPrint(fp,cfp->bplp,"From"); -#endif - if( lemp->basisflag ) cfp=cfp->bp; - else cfp=cfp->next; - } - fprintf(fp,"\n"); - for(ap=stp->ap; ap; ap=ap->next){ - if( PrintAction(ap,fp,30) ) fprintf(fp,"\n"); - } - fprintf(fp,"\n"); - } - fprintf(fp, "----------------------------------------------------\n"); - fprintf(fp, "Symbols:\n"); - for(i=0; insymbol; i++){ - int j; - struct symbol *sp; - - sp = lemp->symbols[i]; - fprintf(fp, " %3d: %s", i, sp->name); - if( sp->type==NONTERMINAL ){ - fprintf(fp, ":"); - if( sp->lambda ){ - fprintf(fp, " "); - } - for(j=0; jnterminal; j++){ - if( sp->firstset && SetFind(sp->firstset, j) ){ - fprintf(fp, " %s", lemp->symbols[j]->name); - } - } - } - fprintf(fp, "\n"); - } - fclose(fp); - return; -} - -/* Search for the file "name" which is in the same directory as -** the exacutable */ -PRIVATE char *pathsearch(char *argv0, char *name, int modemask) -{ - const char *pathlist; - char *pathbufptr; - char *pathbuf; - char *path,*cp; - char c; - -#ifdef __WIN32__ - cp = strrchr(argv0,'\\'); -#else - cp = strrchr(argv0,'/'); -#endif - if( cp ){ - c = *cp; - *cp = 0; - path = (char *)malloc( lemonStrlen(argv0) + lemonStrlen(name) + 2 ); - if( path ) lemon_sprintf(path,"%s/%s",argv0,name); - *cp = c; - }else{ - pathlist = getenv("PATH"); - if( pathlist==0 ) pathlist = ".:/bin:/usr/bin"; - pathbuf = (char *) malloc( lemonStrlen(pathlist) + 1 ); - path = (char *)malloc( lemonStrlen(pathlist)+lemonStrlen(name)+2 ); - if( (pathbuf != 0) && (path!=0) ){ - pathbufptr = pathbuf; - lemon_strcpy(pathbuf, pathlist); - while( *pathbuf ){ - cp = strchr(pathbuf,':'); - if( cp==0 ) cp = &pathbuf[lemonStrlen(pathbuf)]; - c = *cp; - *cp = 0; - lemon_sprintf(path,"%s/%s",pathbuf,name); - *cp = c; - if( c==0 ) pathbuf[0] = 0; - else pathbuf = &cp[1]; - if( access(path,modemask)==0 ) break; - } - free(pathbufptr); - } - } - return path; -} - -/* Given an action, compute the integer value for that action -** which is to be put in the action table of the generated machine. -** Return negative if no action should be generated. -*/ -PRIVATE int compute_action(struct lemon *lemp, struct action *ap) -{ - int act; - switch( ap->type ){ - case SHIFT: act = ap->x.stp->statenum; break; - case REDUCE: act = ap->x.rp->index + lemp->nstate; break; - case ERROR: act = lemp->nstate + lemp->nrule; break; - case ACCEPT: act = lemp->nstate + lemp->nrule + 1; break; - default: act = -1; break; - } - return act; -} - -#define LINESIZE 1000 -/* The next cluster of routines are for reading the template file -** and writing the results to the generated parser */ -/* The first function transfers data from "in" to "out" until -** a line is seen which begins with "%%". The line number is -** tracked. -** -** if name!=0, then any word that begin with "Parse" is changed to -** begin with *name instead. -*/ -PRIVATE void tplt_xfer(char *name, FILE *in, FILE *out, int *lineno) -{ - int i, iStart; - char line[LINESIZE]; - while( fgets(line,LINESIZE,in) && (line[0]!='%' || line[1]!='%') ){ - (*lineno)++; - iStart = 0; - if( name ){ - for(i=0; line[i]; i++){ - if( line[i]=='P' && strncmp(&line[i],"Parse",5)==0 - && (i==0 || !isalpha(line[i-1])) - ){ - if( i>iStart ) fprintf(out,"%.*s",i-iStart,&line[iStart]); - fprintf(out,"%s",name); - i += 4; - iStart = i+1; - } - } - } - fprintf(out,"%s",&line[iStart]); - } -} - -/* The next function finds the template file and opens it, returning -** a pointer to the opened file. */ -PRIVATE FILE *tplt_open(struct lemon *lemp) -{ - static char templatename[] = "lempar.c"; - char buf[1000]; - FILE *in; - char *tpltname; - char *cp; - - /* first, see if user specified a template filename on the command line. */ - if (user_templatename != 0) { - if( access(user_templatename,004)==-1 ){ - fprintf(stderr,"Can't find the parser driver template file \"%s\".\n", - user_templatename); - lemp->errorcnt++; - return 0; - } - in = fopen(user_templatename,"rb"); - if( in==0 ){ - fprintf(stderr,"Can't open the template file \"%s\".\n",user_templatename); - lemp->errorcnt++; - return 0; - } - return in; - } - - cp = strrchr(lemp->filename,'.'); - if( cp ){ - lemon_sprintf(buf,"%.*s.lt",(int)(cp-lemp->filename),lemp->filename); - }else{ - lemon_sprintf(buf,"%s.lt",lemp->filename); - } - if( access(buf,004)==0 ){ - tpltname = buf; - }else if( access(templatename,004)==0 ){ - tpltname = templatename; - }else{ - tpltname = pathsearch(lemp->argv0,templatename,0); - } - if( tpltname==0 ){ - fprintf(stderr,"Can't find the parser driver template file \"%s\".\n", - templatename); - lemp->errorcnt++; - return 0; - } - in = fopen(tpltname,"rb"); - if( in==0 ){ - fprintf(stderr,"Can't open the template file \"%s\".\n",templatename); - lemp->errorcnt++; - return 0; - } - return in; -} - -/* Print a #line directive line to the output file. */ -PRIVATE void tplt_linedir(FILE *out, int lineno, char *filename) -{ - fprintf(out,"#line %d \"",lineno); - while( *filename ){ - if( *filename == '\\' ) putc('\\',out); - putc(*filename,out); - filename++; - } - fprintf(out,"\"\n"); -} - -/* Print a string to the file and keep the linenumber up to date */ -PRIVATE void tplt_print(FILE *out, struct lemon *lemp, char *str, int *lineno) -{ - if( str==0 ) return; - while( *str ){ - putc(*str,out); - if( *str=='\n' ) (*lineno)++; - str++; - } - if( str[-1]!='\n' ){ - putc('\n',out); - (*lineno)++; - } - if (!lemp->nolinenosflag) { - (*lineno)++; tplt_linedir(out,*lineno,lemp->outname); - } - return; -} - -/* -** The following routine emits code for the destructor for the -** symbol sp -*/ -void emit_destructor_code( - FILE *out, - struct symbol *sp, - struct lemon *lemp, - int *lineno -){ - char *cp = 0; - - if( sp->type==TERMINAL ){ - cp = lemp->tokendest; - if( cp==0 ) return; - fprintf(out,"{\n"); (*lineno)++; - }else if( sp->destructor ){ - cp = sp->destructor; - fprintf(out,"{\n"); (*lineno)++; - if (!lemp->nolinenosflag) { (*lineno)++; tplt_linedir(out,sp->destLineno,lemp->filename); } - }else if( lemp->vardest ){ - cp = lemp->vardest; - if( cp==0 ) return; - fprintf(out,"{\n"); (*lineno)++; - }else{ - assert( 0 ); /* Cannot happen */ - } - for(; *cp; cp++){ - if( *cp=='$' && cp[1]=='$' ){ - fprintf(out,"(yypminor->yy%d)",sp->dtnum); - cp++; - continue; - } - if( *cp=='\n' ) (*lineno)++; - fputc(*cp,out); - } - fprintf(out,"\n"); (*lineno)++; - if (!lemp->nolinenosflag) { - (*lineno)++; tplt_linedir(out,*lineno,lemp->outname); - } - fprintf(out,"}\n"); (*lineno)++; - return; -} - -/* -** Return TRUE (non-zero) if the given symbol has a destructor. -*/ -int has_destructor(struct symbol *sp, struct lemon *lemp) -{ - int ret; - if( sp->type==TERMINAL ){ - ret = lemp->tokendest!=0; - }else{ - ret = lemp->vardest!=0 || sp->destructor!=0; - } - return ret; -} - -/* -** Append text to a dynamically allocated string. If zText is 0 then -** reset the string to be empty again. Always return the complete text -** of the string (which is overwritten with each call). -** -** n bytes of zText are stored. If n==0 then all of zText up to the first -** \000 terminator is stored. zText can contain up to two instances of -** %d. The values of p1 and p2 are written into the first and second -** %d. -** -** If n==-1, then the previous character is overwritten. -*/ -PRIVATE char *append_str(const char *zText, int n, int p1, int p2){ - static char empty[1] = { 0 }; - static char *z = 0; - static int alloced = 0; - static int used = 0; - int c; - char zInt[40]; - if( zText==0 ){ - used = 0; - return z; - } - if( n<=0 ){ - if( n<0 ){ - used += n; - assert( used>=0 ); - } - n = lemonStrlen(zText); - } - if( (int) (n+sizeof(zInt)*2+used) >= alloced ){ - alloced = n + sizeof(zInt)*2 + used + 200; - z = (char *) realloc(z, alloced); - } - if( z==0 ) return empty; - while( n-- > 0 ){ - c = *(zText++); - if( c=='%' && n>0 && zText[0]=='d' ){ - lemon_sprintf(zInt, "%d", p1); - p1 = p2; - lemon_strcpy(&z[used], zInt); - used += lemonStrlen(&z[used]); - zText++; - n--; - }else{ - z[used++] = c; - } - } - z[used] = 0; - return z; -} - -/* -** zCode is a string that is the action associated with a rule. Expand -** the symbols in this string so that the refer to elements of the parser -** stack. -*/ -PRIVATE void translate_code(struct lemon *lemp, struct rule *rp){ - char *cp, *xp; - int i; - char lhsused = 0; /* True if the LHS element has been used */ - char used[MAXRHS]; /* True for each RHS element which is used */ - - for(i=0; inrhs; i++) used[i] = 0; - lhsused = 0; - - if( rp->code==0 ){ - static char newlinestr[2] = { '\n', '\0' }; - rp->code = newlinestr; - rp->line = rp->ruleline; - } - - append_str(0,0,0,0); - - /* This const cast is wrong but harmless, if we're careful. */ - for(cp=(char *)rp->code; *cp; cp++){ - if( isalpha(*cp) && (cp==rp->code || (!isalnum(cp[-1]) && cp[-1]!='_')) ){ - char saved; - for(xp= &cp[1]; isalnum(*xp) || *xp=='_'; xp++); - saved = *xp; - *xp = 0; - if( rp->lhsalias && strcmp(cp,rp->lhsalias)==0 ){ - append_str("yygotominor.yy%d",0,rp->lhs->dtnum,0); - cp = xp; - lhsused = 1; - }else{ - for(i=0; inrhs; i++){ - if( rp->rhsalias[i] && strcmp(cp,rp->rhsalias[i])==0 ){ - if( cp!=rp->code && cp[-1]=='@' ){ - /* If the argument is of the form @X then substituted - ** the token number of X, not the value of X */ - append_str("yymsp[%d].major",-1,i-rp->nrhs+1,0); - }else{ - struct symbol *sp = rp->rhs[i]; - int dtnum; - if( sp->type==MULTITERMINAL ){ - dtnum = sp->subsym[0]->dtnum; - }else{ - dtnum = sp->dtnum; - } - append_str("yymsp[%d].minor.yy%d",0,i-rp->nrhs+1, dtnum); - } - cp = xp; - used[i] = 1; - break; - } - } - } - *xp = saved; - } - append_str(cp, 1, 0, 0); - } /* End loop */ - - /* Check to make sure the LHS has been used */ - if( rp->lhsalias && !lhsused ){ - ErrorMsg(lemp->filename,rp->ruleline, - "Label \"%s\" for \"%s(%s)\" is never used.", - rp->lhsalias,rp->lhs->name,rp->lhsalias); - lemp->errorcnt++; - } - - /* Generate destructor code for RHS symbols which are not used in the - ** reduce code */ - for(i=0; inrhs; i++){ - if( rp->rhsalias[i] && !used[i] ){ - ErrorMsg(lemp->filename,rp->ruleline, - "Label %s for \"%s(%s)\" is never used.", - rp->rhsalias[i],rp->rhs[i]->name,rp->rhsalias[i]); - lemp->errorcnt++; - }else if( rp->rhsalias[i]==0 ){ - if( has_destructor(rp->rhs[i],lemp) ){ - append_str(" yy_destructor(yypParser,%d,&yymsp[%d].minor);\n", 0, - rp->rhs[i]->index,i-rp->nrhs+1); - }else{ - /* No destructor defined for this term */ - } - } - } - if( rp->code ){ - cp = append_str(0,0,0,0); - rp->code = Strsafe(cp?cp:""); - } -} - -/* -** Generate code which executes when the rule "rp" is reduced. Write -** the code to "out". Make sure lineno stays up-to-date. -*/ -PRIVATE void emit_code( - FILE *out, - struct rule *rp, - struct lemon *lemp, - int *lineno -){ - const char *cp; - - /* Generate code to do the reduce action */ - if( rp->code ){ - if (!lemp->nolinenosflag) { (*lineno)++; tplt_linedir(out,rp->line,lemp->filename); } - fprintf(out,"{%s",rp->code); - for(cp=rp->code; *cp; cp++){ - if( *cp=='\n' ) (*lineno)++; - } /* End loop */ - fprintf(out,"}\n"); (*lineno)++; - if (!lemp->nolinenosflag) { (*lineno)++; tplt_linedir(out,*lineno,lemp->outname); } - } /* End if( rp->code ) */ - - return; -} - -/* -** Print the definition of the union used for the parser's data stack. -** This union contains fields for every possible data type for tokens -** and nonterminals. In the process of computing and printing this -** union, also set the ".dtnum" field of every terminal and nonterminal -** symbol. -*/ -void print_stack_union( - FILE *out, /* The output stream */ - struct lemon *lemp, /* The main info structure for this parser */ - int *plineno, /* Pointer to the line number */ - int mhflag /* True if generating makeheaders output */ -){ - int lineno = *plineno; /* The line number of the output */ - char **types; /* A hash table of datatypes */ - int arraysize; /* Size of the "types" array */ - int maxdtlength; /* Maximum length of any ".datatype" field. */ - char *stddt; /* Standardized name for a datatype */ - int i,j; /* Loop counters */ - unsigned hash; /* For hashing the name of a type */ - const char *name; /* Name of the parser */ - - /* Allocate and initialize types[] and allocate stddt[] */ - arraysize = lemp->nsymbol * 2; - types = (char**)calloc( arraysize, sizeof(char*) ); - if( types==0 ){ - fprintf(stderr,"Out of memory.\n"); - exit(1); - } - for(i=0; ivartype ){ - maxdtlength = lemonStrlen(lemp->vartype); - } - for(i=0; insymbol; i++){ - int len; - struct symbol *sp = lemp->symbols[i]; - if( sp->datatype==0 ) continue; - len = lemonStrlen(sp->datatype); - if( len>maxdtlength ) maxdtlength = len; - } - stddt = (char*)malloc( maxdtlength*2 + 1 ); - if( stddt==0 ){ - fprintf(stderr,"Out of memory.\n"); - exit(1); - } - - /* Build a hash table of datatypes. The ".dtnum" field of each symbol - ** is filled in with the hash index plus 1. A ".dtnum" value of 0 is - ** used for terminal symbols. If there is no %default_type defined then - ** 0 is also used as the .dtnum value for nonterminals which do not specify - ** a datatype using the %type directive. - */ - for(i=0; insymbol; i++){ - struct symbol *sp = lemp->symbols[i]; - char *cp; - if( sp==lemp->errsym ){ - sp->dtnum = arraysize+1; - continue; - } - if( sp->type!=NONTERMINAL || (sp->datatype==0 && lemp->vartype==0) ){ - sp->dtnum = 0; - continue; - } - cp = sp->datatype; - if( cp==0 ) cp = lemp->vartype; - j = 0; - while( isspace(*cp) ) cp++; - while( *cp ) stddt[j++] = *cp++; - while( j>0 && isspace(stddt[j-1]) ) j--; - stddt[j] = 0; - if( lemp->tokentype && strcmp(stddt, lemp->tokentype)==0 ){ - sp->dtnum = 0; - continue; - } - hash = 0; - for(j=0; stddt[j]; j++){ - hash = hash*53 + stddt[j]; - } - hash = (hash & 0x7fffffff)%arraysize; - while( types[hash] ){ - if( strcmp(types[hash],stddt)==0 ){ - sp->dtnum = hash + 1; - break; - } - hash++; - if( hash>=(unsigned)arraysize ) hash = 0; - } - if( types[hash]==0 ){ - sp->dtnum = hash + 1; - types[hash] = (char*)malloc( lemonStrlen(stddt)+1 ); - if( types[hash]==0 ){ - fprintf(stderr,"Out of memory.\n"); - exit(1); - } - lemon_strcpy(types[hash],stddt); - } - } - - /* Print out the definition of YYTOKENTYPE and YYMINORTYPE */ - name = lemp->name ? lemp->name : "Parse"; - lineno = *plineno; - if( mhflag ){ fprintf(out,"#if INTERFACE\n"); lineno++; } - fprintf(out,"#define %sTOKENTYPE %s\n",name, - lemp->tokentype?lemp->tokentype:"void*"); lineno++; - if( mhflag ){ fprintf(out,"#endif\n"); lineno++; } - fprintf(out,"typedef union {\n"); lineno++; - fprintf(out," int yyinit;\n"); lineno++; - fprintf(out," %sTOKENTYPE yy0;\n",name); lineno++; - for(i=0; ierrsym->useCnt ){ - fprintf(out," int yy%d;\n",lemp->errsym->dtnum); lineno++; - } - free(stddt); - free(types); - fprintf(out,"} YYMINORTYPE;\n"); lineno++; - *plineno = lineno; -} - -/* -** Return the name of a C datatype able to represent values between -** lwr and upr, inclusive. -*/ -static const char *minimum_size_type(int lwr, int upr){ - if( lwr>=0 ){ - if( upr<=255 ){ - return "unsigned char"; - }else if( upr<65535 ){ - return "unsigned short int"; - }else{ - return "unsigned int"; - } - }else if( lwr>=-127 && upr<=127 ){ - return "signed char"; - }else if( lwr>=-32767 && upr<32767 ){ - return "short"; - }else{ - return "int"; - } -} - -/* -** Each state contains a set of token transaction and a set of -** nonterminal transactions. Each of these sets makes an instance -** of the following structure. An array of these structures is used -** to order the creation of entries in the yy_action[] table. -*/ -struct axset { - struct state *stp; /* A pointer to a state */ - int isTkn; /* True to use tokens. False for non-terminals */ - int nAction; /* Number of actions */ - int iOrder; /* Original order of action sets */ -}; - -/* -** Compare to axset structures for sorting purposes -*/ -static int axset_compare(const void *a, const void *b){ - struct axset *p1 = (struct axset*)a; - struct axset *p2 = (struct axset*)b; - int c; - c = p2->nAction - p1->nAction; - if( c==0 ){ - c = p2->iOrder - p1->iOrder; - } - assert( c!=0 || p1==p2 ); - return c; -} - -/* -** Write text on "out" that describes the rule "rp". -*/ -static void writeRuleText(FILE *out, struct rule *rp){ - int j; - fprintf(out,"%s ::=", rp->lhs->name); - for(j=0; jnrhs; j++){ - struct symbol *sp = rp->rhs[j]; - if( sp->type!=MULTITERMINAL ){ - fprintf(out," %s", sp->name); - }else{ - int k; - fprintf(out," %s", sp->subsym[0]->name); - for(k=1; knsubsym; k++){ - fprintf(out,"|%s",sp->subsym[k]->name); - } - } - } -} - - -/* Generate C source code for the parser */ -void ReportTable( - struct lemon *lemp, - int mhflag /* Output in makeheaders format if true */ -){ - FILE *out, *in; - char line[LINESIZE]; - int lineno; - struct state *stp; - struct action *ap; - struct rule *rp; - struct acttab *pActtab; - int i, j, n; - const char *name; - int mnTknOfst, mxTknOfst; - int mnNtOfst, mxNtOfst; - struct axset *ax; - - in = tplt_open(lemp); - if( in==0 ) return; - out = file_open(lemp,".c","wb"); - if( out==0 ){ - fclose(in); - return; - } - lineno = 1; - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate the include code, if any */ - tplt_print(out,lemp,lemp->include,&lineno); - if( mhflag ){ - char *name = file_makename(lemp, ".h"); - fprintf(out,"#include \"%s\"\n", name); lineno++; - free(name); - } - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate #defines for all tokens */ - if( mhflag ){ - const char *prefix; - fprintf(out,"#if INTERFACE\n"); lineno++; - if( lemp->tokenprefix ) prefix = lemp->tokenprefix; - else prefix = ""; - for(i=1; interminal; i++){ - fprintf(out,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i); - lineno++; - } - fprintf(out,"#endif\n"); lineno++; - } - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate the defines */ - fprintf(out,"#define YYCODETYPE %s\n", - minimum_size_type(0, lemp->nsymbol+1)); lineno++; - fprintf(out,"#define YYNOCODE %d\n",lemp->nsymbol+1); lineno++; - fprintf(out,"#define YYACTIONTYPE %s\n", - minimum_size_type(0, lemp->nstate+lemp->nrule+5)); lineno++; - if( lemp->wildcard ){ - fprintf(out,"#define YYWILDCARD %d\n", - lemp->wildcard->index); lineno++; - } - print_stack_union(out,lemp,&lineno,mhflag); - fprintf(out, "#ifndef YYSTACKDEPTH\n"); lineno++; - if( lemp->stacksize ){ - fprintf(out,"#define YYSTACKDEPTH %s\n",lemp->stacksize); lineno++; - }else{ - fprintf(out,"#define YYSTACKDEPTH 100\n"); lineno++; - } - fprintf(out, "#endif\n"); lineno++; - if( mhflag ){ - fprintf(out,"#if INTERFACE\n"); lineno++; - } - name = lemp->name ? lemp->name : "Parse"; - if( lemp->arg && lemp->arg[0] ){ - int i; - i = lemonStrlen(lemp->arg); - while( i>=1 && isspace(lemp->arg[i-1]) ) i--; - while( i>=1 && (isalnum(lemp->arg[i-1]) || lemp->arg[i-1]=='_') ) i--; - fprintf(out,"#define %sARG_SDECL %s;\n",name,lemp->arg); lineno++; - fprintf(out,"#define %sARG_PDECL ,%s\n",name,lemp->arg); lineno++; - fprintf(out,"#define %sARG_FETCH %s = yypParser->%s\n", - name,lemp->arg,&lemp->arg[i]); lineno++; - fprintf(out,"#define %sARG_STORE yypParser->%s = %s\n", - name,&lemp->arg[i],&lemp->arg[i]); lineno++; - }else{ - fprintf(out,"#define %sARG_SDECL\n",name); lineno++; - fprintf(out,"#define %sARG_PDECL\n",name); lineno++; - fprintf(out,"#define %sARG_FETCH\n",name); lineno++; - fprintf(out,"#define %sARG_STORE\n",name); lineno++; - } - if( mhflag ){ - fprintf(out,"#endif\n"); lineno++; - } - fprintf(out,"#define YYNSTATE %d\n",lemp->nstate); lineno++; - fprintf(out,"#define YYNRULE %d\n",lemp->nrule); lineno++; - if( lemp->errsym->useCnt ){ - fprintf(out,"#define YYERRORSYMBOL %d\n",lemp->errsym->index); lineno++; - fprintf(out,"#define YYERRSYMDT yy%d\n",lemp->errsym->dtnum); lineno++; - } - if( lemp->has_fallback ){ - fprintf(out,"#define YYFALLBACK 1\n"); lineno++; - } - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate the action table and its associates: - ** - ** yy_action[] A single table containing all actions. - ** yy_lookahead[] A table containing the lookahead for each entry in - ** yy_action. Used to detect hash collisions. - ** yy_shift_ofst[] For each state, the offset into yy_action for - ** shifting terminals. - ** yy_reduce_ofst[] For each state, the offset into yy_action for - ** shifting non-terminals after a reduce. - ** yy_default[] Default action for each state. - */ - - /* Compute the actions on all states and count them up */ - ax = (struct axset *) calloc(lemp->nstate*2, sizeof(ax[0])); - if( ax==0 ){ - fprintf(stderr,"malloc failed\n"); - exit(1); - } - for(i=0; instate; i++){ - stp = lemp->sorted[i]; - ax[i*2].stp = stp; - ax[i*2].isTkn = 1; - ax[i*2].nAction = stp->nTknAct; - ax[i*2+1].stp = stp; - ax[i*2+1].isTkn = 0; - ax[i*2+1].nAction = stp->nNtAct; - } - mxTknOfst = mnTknOfst = 0; - mxNtOfst = mnNtOfst = 0; - - /* Compute the action table. In order to try to keep the size of the - ** action table to a minimum, the heuristic of placing the largest action - ** sets first is used. - */ - for(i=0; instate*2; i++) ax[i].iOrder = i; - qsort(ax, lemp->nstate*2, sizeof(ax[0]), axset_compare); - pActtab = acttab_alloc(); - for(i=0; instate*2 && ax[i].nAction>0; i++){ - stp = ax[i].stp; - if( ax[i].isTkn ){ - for(ap=stp->ap; ap; ap=ap->next){ - int action; - if( ap->sp->index>=lemp->nterminal ) continue; - action = compute_action(lemp, ap); - if( action<0 ) continue; - acttab_action(pActtab, ap->sp->index, action); - } - stp->iTknOfst = acttab_insert(pActtab); - if( stp->iTknOfstiTknOfst; - if( stp->iTknOfst>mxTknOfst ) mxTknOfst = stp->iTknOfst; - }else{ - for(ap=stp->ap; ap; ap=ap->next){ - int action; - if( ap->sp->indexnterminal ) continue; - if( ap->sp->index==lemp->nsymbol ) continue; - action = compute_action(lemp, ap); - if( action<0 ) continue; - acttab_action(pActtab, ap->sp->index, action); - } - stp->iNtOfst = acttab_insert(pActtab); - if( stp->iNtOfstiNtOfst; - if( stp->iNtOfst>mxNtOfst ) mxNtOfst = stp->iNtOfst; - } - } - free(ax); - - /* Output the yy_action table */ - n = acttab_size(pActtab); - fprintf(out,"#define YY_ACTTAB_COUNT (%d)\n", n); lineno++; - fprintf(out,"static const YYACTIONTYPE yy_action[] = {\n"); lineno++; - for(i=j=0; instate + lemp->nrule + 2; - if( j==0 ) fprintf(out," /* %5d */ ", i); - fprintf(out, " %4d,", action); - if( j==9 || i==n-1 ){ - fprintf(out, "\n"); lineno++; - j = 0; - }else{ - j++; - } - } - fprintf(out, "};\n"); lineno++; - - /* Output the yy_lookahead table */ - fprintf(out,"static const YYCODETYPE yy_lookahead[] = {\n"); lineno++; - for(i=j=0; insymbol; - if( j==0 ) fprintf(out," /* %5d */ ", i); - fprintf(out, " %4d,", la); - if( j==9 || i==n-1 ){ - fprintf(out, "\n"); lineno++; - j = 0; - }else{ - j++; - } - } - fprintf(out, "};\n"); lineno++; - - /* Output the yy_shift_ofst[] table */ - fprintf(out, "#define YY_SHIFT_USE_DFLT (%d)\n", mnTknOfst-1); lineno++; - n = lemp->nstate; - while( n>0 && lemp->sorted[n-1]->iTknOfst==NO_OFFSET ) n--; - fprintf(out, "#define YY_SHIFT_COUNT (%d)\n", n-1); lineno++; - fprintf(out, "#define YY_SHIFT_MIN (%d)\n", mnTknOfst); lineno++; - fprintf(out, "#define YY_SHIFT_MAX (%d)\n", mxTknOfst); lineno++; - fprintf(out, "static const %s yy_shift_ofst[] = {\n", - minimum_size_type(mnTknOfst-1, mxTknOfst)); lineno++; - for(i=j=0; isorted[i]; - ofst = stp->iTknOfst; - if( ofst==NO_OFFSET ) ofst = mnTknOfst - 1; - if( j==0 ) fprintf(out," /* %5d */ ", i); - fprintf(out, " %4d,", ofst); - if( j==9 || i==n-1 ){ - fprintf(out, "\n"); lineno++; - j = 0; - }else{ - j++; - } - } - fprintf(out, "};\n"); lineno++; - - /* Output the yy_reduce_ofst[] table */ - fprintf(out, "#define YY_REDUCE_USE_DFLT (%d)\n", mnNtOfst-1); lineno++; - n = lemp->nstate; - while( n>0 && lemp->sorted[n-1]->iNtOfst==NO_OFFSET ) n--; - fprintf(out, "#define YY_REDUCE_COUNT (%d)\n", n-1); lineno++; - fprintf(out, "#define YY_REDUCE_MIN (%d)\n", mnNtOfst); lineno++; - fprintf(out, "#define YY_REDUCE_MAX (%d)\n", mxNtOfst); lineno++; - fprintf(out, "static const %s yy_reduce_ofst[] = {\n", - minimum_size_type(mnNtOfst-1, mxNtOfst)); lineno++; - for(i=j=0; isorted[i]; - ofst = stp->iNtOfst; - if( ofst==NO_OFFSET ) ofst = mnNtOfst - 1; - if( j==0 ) fprintf(out," /* %5d */ ", i); - fprintf(out, " %4d,", ofst); - if( j==9 || i==n-1 ){ - fprintf(out, "\n"); lineno++; - j = 0; - }else{ - j++; - } - } - fprintf(out, "};\n"); lineno++; - - /* Output the default action table */ - fprintf(out, "static const YYACTIONTYPE yy_default[] = {\n"); lineno++; - n = lemp->nstate; - for(i=j=0; isorted[i]; - if( j==0 ) fprintf(out," /* %5d */ ", i); - fprintf(out, " %4d,", stp->iDflt); - if( j==9 || i==n-1 ){ - fprintf(out, "\n"); lineno++; - j = 0; - }else{ - j++; - } - } - fprintf(out, "};\n"); lineno++; - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate the table of fallback tokens. - */ - if( lemp->has_fallback ){ - int mx = lemp->nterminal - 1; - while( mx>0 && lemp->symbols[mx]->fallback==0 ){ mx--; } - for(i=0; i<=mx; i++){ - struct symbol *p = lemp->symbols[i]; - if( p->fallback==0 ){ - fprintf(out, " 0, /* %10s => nothing */\n", p->name); - }else{ - fprintf(out, " %3d, /* %10s => %s */\n", p->fallback->index, - p->name, p->fallback->name); - } - lineno++; - } - } - tplt_xfer(lemp->name, in, out, &lineno); - - /* Generate a table containing the symbolic name of every symbol - */ - for(i=0; insymbol; i++){ - lemon_sprintf(line,"\"%s\",",lemp->symbols[i]->name); - fprintf(out," %-15s",line); - if( (i&3)==3 ){ fprintf(out,"\n"); lineno++; } - } - if( (i&3)!=0 ){ fprintf(out,"\n"); lineno++; } - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate a table containing a text string that describes every - ** rule in the rule set of the grammar. This information is used - ** when tracing REDUCE actions. - */ - for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){ - assert( rp->index==i ); - fprintf(out," /* %3d */ \"", i); - writeRuleText(out, rp); - fprintf(out,"\",\n"); lineno++; - } - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate code which executes every time a symbol is popped from - ** the stack while processing errors or while destroying the parser. - ** (In other words, generate the %destructor actions) - */ - if( lemp->tokendest ){ - int once = 1; - for(i=0; insymbol; i++){ - struct symbol *sp = lemp->symbols[i]; - if( sp==0 || sp->type!=TERMINAL ) continue; - if( once ){ - fprintf(out, " /* TERMINAL Destructor */\n"); lineno++; - once = 0; - } - fprintf(out," case %d: /* %s */\n", sp->index, sp->name); lineno++; - } - for(i=0; insymbol && lemp->symbols[i]->type!=TERMINAL; i++); - if( insymbol ){ - emit_destructor_code(out,lemp->symbols[i],lemp,&lineno); - fprintf(out," break;\n"); lineno++; - } - } - if( lemp->vardest ){ - struct symbol *dflt_sp = 0; - int once = 1; - for(i=0; insymbol; i++){ - struct symbol *sp = lemp->symbols[i]; - if( sp==0 || sp->type==TERMINAL || - sp->index<=0 || sp->destructor!=0 ) continue; - if( once ){ - fprintf(out, " /* Default NON-TERMINAL Destructor */\n"); lineno++; - once = 0; - } - fprintf(out," case %d: /* %s */\n", sp->index, sp->name); lineno++; - dflt_sp = sp; - } - if( dflt_sp!=0 ){ - emit_destructor_code(out,dflt_sp,lemp,&lineno); - } - fprintf(out," break;\n"); lineno++; - } - for(i=0; insymbol; i++){ - struct symbol *sp = lemp->symbols[i]; - if( sp==0 || sp->type==TERMINAL || sp->destructor==0 ) continue; - fprintf(out," case %d: /* %s */\n", sp->index, sp->name); lineno++; - - /* Combine duplicate destructors into a single case */ - for(j=i+1; jnsymbol; j++){ - struct symbol *sp2 = lemp->symbols[j]; - if( sp2 && sp2->type!=TERMINAL && sp2->destructor - && sp2->dtnum==sp->dtnum - && strcmp(sp->destructor,sp2->destructor)==0 ){ - fprintf(out," case %d: /* %s */\n", - sp2->index, sp2->name); lineno++; - sp2->destructor = 0; - } - } - - emit_destructor_code(out,lemp->symbols[i],lemp,&lineno); - fprintf(out," break;\n"); lineno++; - } - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate code which executes whenever the parser stack overflows */ - tplt_print(out,lemp,lemp->overflow,&lineno); - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate the table of rule information - ** - ** Note: This code depends on the fact that rules are number - ** sequentually beginning with 0. - */ - for(rp=lemp->rule; rp; rp=rp->next){ - fprintf(out," { %d, %d },\n",rp->lhs->index,rp->nrhs); lineno++; - } - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate code which execution during each REDUCE action */ - for(rp=lemp->rule; rp; rp=rp->next){ - translate_code(lemp, rp); - } - /* First output rules other than the default: rule */ - for(rp=lemp->rule; rp; rp=rp->next){ - struct rule *rp2; /* Other rules with the same action */ - if( rp->code==0 ) continue; - if( rp->code[0]=='\n' && rp->code[1]==0 ) continue; /* Will be default: */ - fprintf(out," case %d: /* ", rp->index); - writeRuleText(out, rp); - fprintf(out, " */\n"); lineno++; - for(rp2=rp->next; rp2; rp2=rp2->next){ - if( rp2->code==rp->code ){ - fprintf(out," case %d: /* ", rp2->index); - writeRuleText(out, rp2); - fprintf(out," */ yytestcase(yyruleno==%d);\n", rp2->index); lineno++; - rp2->code = 0; - } - } - emit_code(out,rp,lemp,&lineno); - fprintf(out," break;\n"); lineno++; - rp->code = 0; - } - /* Finally, output the default: rule. We choose as the default: all - ** empty actions. */ - fprintf(out," default:\n"); lineno++; - for(rp=lemp->rule; rp; rp=rp->next){ - if( rp->code==0 ) continue; - assert( rp->code[0]=='\n' && rp->code[1]==0 ); - fprintf(out," /* (%d) ", rp->index); - writeRuleText(out, rp); - fprintf(out, " */ yytestcase(yyruleno==%d);\n", rp->index); lineno++; - } - fprintf(out," break;\n"); lineno++; - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate code which executes if a parse fails */ - tplt_print(out,lemp,lemp->failure,&lineno); - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate code which executes when a syntax error occurs */ - tplt_print(out,lemp,lemp->error,&lineno); - tplt_xfer(lemp->name,in,out,&lineno); - - /* Generate code which executes when the parser accepts its input */ - tplt_print(out,lemp,lemp->accept,&lineno); - tplt_xfer(lemp->name,in,out,&lineno); - - /* Append any addition code the user desires */ - tplt_print(out,lemp,lemp->extracode,&lineno); - - fclose(in); - fclose(out); - return; -} - -/* Generate a header file for the parser */ -void ReportHeader(struct lemon *lemp) -{ - FILE *out, *in; - const char *prefix; - char line[LINESIZE]; - char pattern[LINESIZE]; - int i; - - if( lemp->tokenprefix ) prefix = lemp->tokenprefix; - else prefix = ""; - in = file_open(lemp,".h","rb"); - if( in ){ - int nextChar; - for(i=1; interminal && fgets(line,LINESIZE,in); i++){ - lemon_sprintf(pattern,"#define %s%-30s %3d\n", - prefix,lemp->symbols[i]->name,i); - if( strcmp(line,pattern) ) break; - } - nextChar = fgetc(in); - fclose(in); - if( i==lemp->nterminal && nextChar==EOF ){ - /* No change in the file. Don't rewrite it. */ - return; - } - } - out = file_open(lemp,".h","wb"); - if( out ){ - for(i=1; interminal; i++){ - fprintf(out,"#define %s%-30s %3d\n",prefix,lemp->symbols[i]->name,i); - } - fclose(out); - } - return; -} - -/* Reduce the size of the action tables, if possible, by making use -** of defaults. -** -** In this version, we take the most frequent REDUCE action and make -** it the default. Except, there is no default if the wildcard token -** is a possible look-ahead. -*/ -void CompressTables(struct lemon *lemp) -{ - struct state *stp; - struct action *ap, *ap2; - struct rule *rp, *rp2, *rbest; - int nbest, n; - int i; - int usesWildcard; - - for(i=0; instate; i++){ - stp = lemp->sorted[i]; - nbest = 0; - rbest = 0; - usesWildcard = 0; - - for(ap=stp->ap; ap; ap=ap->next){ - if( ap->type==SHIFT && ap->sp==lemp->wildcard ){ - usesWildcard = 1; - } - if( ap->type!=REDUCE ) continue; - rp = ap->x.rp; - if( rp->lhsStart ) continue; - if( rp==rbest ) continue; - n = 1; - for(ap2=ap->next; ap2; ap2=ap2->next){ - if( ap2->type!=REDUCE ) continue; - rp2 = ap2->x.rp; - if( rp2==rbest ) continue; - if( rp2==rp ) n++; - } - if( n>nbest ){ - nbest = n; - rbest = rp; - } - } - - /* Do not make a default if the number of rules to default - ** is not at least 1 or if the wildcard token is a possible - ** lookahead. - */ - if( nbest<1 || usesWildcard ) continue; - - - /* Combine matching REDUCE actions into a single default */ - for(ap=stp->ap; ap; ap=ap->next){ - if( ap->type==REDUCE && ap->x.rp==rbest ) break; - } - assert( ap ); - ap->sp = Symbol_new("{default}"); - for(ap=ap->next; ap; ap=ap->next){ - if( ap->type==REDUCE && ap->x.rp==rbest ) ap->type = NOT_USED; - } - stp->ap = Action_sort(stp->ap); - } -} - - -/* -** Compare two states for sorting purposes. The smaller state is the -** one with the most non-terminal actions. If they have the same number -** of non-terminal actions, then the smaller is the one with the most -** token actions. -*/ -static int stateResortCompare(const void *a, const void *b){ - const struct state *pA = *(const struct state**)a; - const struct state *pB = *(const struct state**)b; - int n; - - n = pB->nNtAct - pA->nNtAct; - if( n==0 ){ - n = pB->nTknAct - pA->nTknAct; - if( n==0 ){ - n = pB->statenum - pA->statenum; - } - } - assert( n!=0 ); - return n; -} - - -/* -** Renumber and resort states so that states with fewer choices -** occur at the end. Except, keep state 0 as the first state. -*/ -void ResortStates(struct lemon *lemp) -{ - int i; - struct state *stp; - struct action *ap; - - for(i=0; instate; i++){ - stp = lemp->sorted[i]; - stp->nTknAct = stp->nNtAct = 0; - stp->iDflt = lemp->nstate + lemp->nrule; - stp->iTknOfst = NO_OFFSET; - stp->iNtOfst = NO_OFFSET; - for(ap=stp->ap; ap; ap=ap->next){ - if( compute_action(lemp,ap)>=0 ){ - if( ap->sp->indexnterminal ){ - stp->nTknAct++; - }else if( ap->sp->indexnsymbol ){ - stp->nNtAct++; - }else{ - stp->iDflt = compute_action(lemp, ap); - } - } - } - } - qsort(&lemp->sorted[1], lemp->nstate-1, sizeof(lemp->sorted[0]), - stateResortCompare); - for(i=0; instate; i++){ - lemp->sorted[i]->statenum = i; - } -} - - -/***************** From the file "set.c" ************************************/ -/* -** Set manipulation routines for the LEMON parser generator. -*/ - -static int size = 0; - -/* Set the set size */ -void SetSize(int n) -{ - size = n+1; -} - -/* Allocate a new set */ -char *SetNew(){ - char *s; - s = (char*)calloc( size, 1); - if( s==0 ){ - extern void memory_error(); - memory_error(); - } - return s; -} - -/* Deallocate a set */ -void SetFree(char *s) -{ - free(s); -} - -/* Add a new element to the set. Return TRUE if the element was added -** and FALSE if it was already there. */ -int SetAdd(char *s, int e) -{ - int rv; - assert( e>=0 && esize = 1024; - x1a->count = 0; - x1a->tbl = (x1node*)calloc(1024, sizeof(x1node) + sizeof(x1node*)); - if( x1a->tbl==0 ){ - free(x1a); - x1a = 0; - }else{ - int i; - x1a->ht = (x1node**)&(x1a->tbl[1024]); - for(i=0; i<1024; i++) x1a->ht[i] = 0; - } - } -} -/* Insert a new record into the array. Return TRUE if successful. -** Prior data with the same key is NOT overwritten */ -int Strsafe_insert(const char *data) -{ - x1node *np; - unsigned h; - unsigned ph; - - if( x1a==0 ) return 0; - ph = strhash(data); - h = ph & (x1a->size-1); - np = x1a->ht[h]; - while( np ){ - if( strcmp(np->data,data)==0 ){ - /* An existing entry with the same key is found. */ - /* Fail because overwrite is not allows. */ - return 0; - } - np = np->next; - } - if( x1a->count>=x1a->size ){ - /* Need to make the hash table bigger */ - int i,size; - struct s_x1 array; - array.size = size = x1a->size*2; - array.count = x1a->count; - array.tbl = (x1node*)calloc(size, sizeof(x1node) + sizeof(x1node*)); - if( array.tbl==0 ) return 0; /* Fail due to malloc failure */ - array.ht = (x1node**)&(array.tbl[size]); - for(i=0; icount; i++){ - x1node *oldnp, *newnp; - oldnp = &(x1a->tbl[i]); - h = strhash(oldnp->data) & (size-1); - newnp = &(array.tbl[i]); - if( array.ht[h] ) array.ht[h]->from = &(newnp->next); - newnp->next = array.ht[h]; - newnp->data = oldnp->data; - newnp->from = &(array.ht[h]); - array.ht[h] = newnp; - } - free(x1a->tbl); - *x1a = array; - } - /* Insert the new data */ - h = ph & (x1a->size-1); - np = &(x1a->tbl[x1a->count++]); - np->data = data; - if( x1a->ht[h] ) x1a->ht[h]->from = &(np->next); - np->next = x1a->ht[h]; - x1a->ht[h] = np; - np->from = &(x1a->ht[h]); - return 1; -} - -/* Return a pointer to data assigned to the given key. Return NULL -** if no such key. */ -const char *Strsafe_find(const char *key) -{ - unsigned h; - x1node *np; - - if( x1a==0 ) return 0; - h = strhash(key) & (x1a->size-1); - np = x1a->ht[h]; - while( np ){ - if( strcmp(np->data,key)==0 ) break; - np = np->next; - } - return np ? np->data : 0; -} - -/* Return a pointer to the (terminal or nonterminal) symbol "x". -** Create a new symbol if this is the first time "x" has been seen. -*/ -struct symbol *Symbol_new(const char *x) -{ - struct symbol *sp; - - sp = Symbol_find(x); - if( sp==0 ){ - sp = (struct symbol *)calloc(1, sizeof(struct symbol) ); - MemoryCheck(sp); - sp->name = Strsafe(x); - sp->type = isupper(*x) ? TERMINAL : NONTERMINAL; - sp->rule = 0; - sp->fallback = 0; - sp->prec = -1; - sp->assoc = UNK; - sp->firstset = 0; - sp->lambda = LEMON_FALSE; - sp->destructor = 0; - sp->destLineno = 0; - sp->datatype = 0; - sp->useCnt = 0; - Symbol_insert(sp,sp->name); - } - sp->useCnt++; - return sp; -} - -/* Compare two symbols for sorting purposes. Return negative, -** zero, or positive if a is less then, equal to, or greater -** than b. -** -** Symbols that begin with upper case letters (terminals or tokens) -** must sort before symbols that begin with lower case letters -** (non-terminals). And MULTITERMINAL symbols (created using the -** %token_class directive) must sort at the very end. Other than -** that, the order does not matter. -** -** We find experimentally that leaving the symbols in their original -** order (the order they appeared in the grammar file) gives the -** smallest parser tables in SQLite. -*/ -int Symbolcmpp(const void *_a, const void *_b) -{ - const struct symbol *a = *(const struct symbol **) _a; - const struct symbol *b = *(const struct symbol **) _b; - int i1 = a->type==MULTITERMINAL ? 3 : a->name[0]>'Z' ? 2 : 1; - int i2 = b->type==MULTITERMINAL ? 3 : b->name[0]>'Z' ? 2 : 1; - return i1==i2 ? a->index - b->index : i1 - i2; -} - -/* There is one instance of the following structure for each -** associative array of type "x2". -*/ -struct s_x2 { - int size; /* The number of available slots. */ - /* Must be a power of 2 greater than or */ - /* equal to 1 */ - int count; /* Number of currently slots filled */ - struct s_x2node *tbl; /* The data stored here */ - struct s_x2node **ht; /* Hash table for lookups */ -}; - -/* There is one instance of this structure for every data element -** in an associative array of type "x2". -*/ -typedef struct s_x2node { - struct symbol *data; /* The data */ - const char *key; /* The key */ - struct s_x2node *next; /* Next entry with the same hash */ - struct s_x2node **from; /* Previous link */ -} x2node; - -/* There is only one instance of the array, which is the following */ -static struct s_x2 *x2a; - -/* Allocate a new associative array */ -void Symbol_init(){ - if( x2a ) return; - x2a = (struct s_x2*)malloc( sizeof(struct s_x2) ); - if( x2a ){ - x2a->size = 128; - x2a->count = 0; - x2a->tbl = (x2node*)calloc(128, sizeof(x2node) + sizeof(x2node*)); - if( x2a->tbl==0 ){ - free(x2a); - x2a = 0; - }else{ - int i; - x2a->ht = (x2node**)&(x2a->tbl[128]); - for(i=0; i<128; i++) x2a->ht[i] = 0; - } - } -} -/* Insert a new record into the array. Return TRUE if successful. -** Prior data with the same key is NOT overwritten */ -int Symbol_insert(struct symbol *data, const char *key) -{ - x2node *np; - unsigned h; - unsigned ph; - - if( x2a==0 ) return 0; - ph = strhash(key); - h = ph & (x2a->size-1); - np = x2a->ht[h]; - while( np ){ - if( strcmp(np->key,key)==0 ){ - /* An existing entry with the same key is found. */ - /* Fail because overwrite is not allows. */ - return 0; - } - np = np->next; - } - if( x2a->count>=x2a->size ){ - /* Need to make the hash table bigger */ - int i,size; - struct s_x2 array; - array.size = size = x2a->size*2; - array.count = x2a->count; - array.tbl = (x2node*)calloc(size, sizeof(x2node) + sizeof(x2node*)); - if( array.tbl==0 ) return 0; /* Fail due to malloc failure */ - array.ht = (x2node**)&(array.tbl[size]); - for(i=0; icount; i++){ - x2node *oldnp, *newnp; - oldnp = &(x2a->tbl[i]); - h = strhash(oldnp->key) & (size-1); - newnp = &(array.tbl[i]); - if( array.ht[h] ) array.ht[h]->from = &(newnp->next); - newnp->next = array.ht[h]; - newnp->key = oldnp->key; - newnp->data = oldnp->data; - newnp->from = &(array.ht[h]); - array.ht[h] = newnp; - } - free(x2a->tbl); - *x2a = array; - } - /* Insert the new data */ - h = ph & (x2a->size-1); - np = &(x2a->tbl[x2a->count++]); - np->key = key; - np->data = data; - if( x2a->ht[h] ) x2a->ht[h]->from = &(np->next); - np->next = x2a->ht[h]; - x2a->ht[h] = np; - np->from = &(x2a->ht[h]); - return 1; -} - -/* Return a pointer to data assigned to the given key. Return NULL -** if no such key. */ -struct symbol *Symbol_find(const char *key) -{ - unsigned h; - x2node *np; - - if( x2a==0 ) return 0; - h = strhash(key) & (x2a->size-1); - np = x2a->ht[h]; - while( np ){ - if( strcmp(np->key,key)==0 ) break; - np = np->next; - } - return np ? np->data : 0; -} - -/* Return the n-th data. Return NULL if n is out of range. */ -struct symbol *Symbol_Nth(int n) -{ - struct symbol *data; - if( x2a && n>0 && n<=x2a->count ){ - data = x2a->tbl[n-1].data; - }else{ - data = 0; - } - return data; -} - -/* Return the size of the array */ -int Symbol_count() -{ - return x2a ? x2a->count : 0; -} - -/* Return an array of pointers to all data in the table. -** The array is obtained from malloc. Return NULL if memory allocation -** problems, or if the array is empty. */ -struct symbol **Symbol_arrayof() -{ - struct symbol **array; - int i,size; - if( x2a==0 ) return 0; - size = x2a->count; - array = (struct symbol **)calloc(size, sizeof(struct symbol *)); - if( array ){ - for(i=0; itbl[i].data; - } - return array; -} - -/* Compare two configurations */ -int Configcmp(const char *_a,const char *_b) -{ - const struct config *a = (struct config *) _a; - const struct config *b = (struct config *) _b; - int x; - x = a->rp->index - b->rp->index; - if( x==0 ) x = a->dot - b->dot; - return x; -} - -/* Compare two states */ -PRIVATE int statecmp(struct config *a, struct config *b) -{ - int rc; - for(rc=0; rc==0 && a && b; a=a->bp, b=b->bp){ - rc = a->rp->index - b->rp->index; - if( rc==0 ) rc = a->dot - b->dot; - } - if( rc==0 ){ - if( a ) rc = 1; - if( b ) rc = -1; - } - return rc; -} - -/* Hash a state */ -PRIVATE unsigned statehash(struct config *a) -{ - unsigned h=0; - while( a ){ - h = h*571 + a->rp->index*37 + a->dot; - a = a->bp; - } - return h; -} - -/* Allocate a new state structure */ -struct state *State_new() -{ - struct state *newstate; - newstate = (struct state *)calloc(1, sizeof(struct state) ); - MemoryCheck(newstate); - return newstate; -} - -/* There is one instance of the following structure for each -** associative array of type "x3". -*/ -struct s_x3 { - int size; /* The number of available slots. */ - /* Must be a power of 2 greater than or */ - /* equal to 1 */ - int count; /* Number of currently slots filled */ - struct s_x3node *tbl; /* The data stored here */ - struct s_x3node **ht; /* Hash table for lookups */ -}; - -/* There is one instance of this structure for every data element -** in an associative array of type "x3". -*/ -typedef struct s_x3node { - struct state *data; /* The data */ - struct config *key; /* The key */ - struct s_x3node *next; /* Next entry with the same hash */ - struct s_x3node **from; /* Previous link */ -} x3node; - -/* There is only one instance of the array, which is the following */ -static struct s_x3 *x3a; - -/* Allocate a new associative array */ -void State_init(){ - if( x3a ) return; - x3a = (struct s_x3*)malloc( sizeof(struct s_x3) ); - if( x3a ){ - x3a->size = 128; - x3a->count = 0; - x3a->tbl = (x3node*)calloc(128, sizeof(x3node) + sizeof(x3node*)); - if( x3a->tbl==0 ){ - free(x3a); - x3a = 0; - }else{ - int i; - x3a->ht = (x3node**)&(x3a->tbl[128]); - for(i=0; i<128; i++) x3a->ht[i] = 0; - } - } -} -/* Insert a new record into the array. Return TRUE if successful. -** Prior data with the same key is NOT overwritten */ -int State_insert(struct state *data, struct config *key) -{ - x3node *np; - unsigned h; - unsigned ph; - - if( x3a==0 ) return 0; - ph = statehash(key); - h = ph & (x3a->size-1); - np = x3a->ht[h]; - while( np ){ - if( statecmp(np->key,key)==0 ){ - /* An existing entry with the same key is found. */ - /* Fail because overwrite is not allows. */ - return 0; - } - np = np->next; - } - if( x3a->count>=x3a->size ){ - /* Need to make the hash table bigger */ - int i,size; - struct s_x3 array; - array.size = size = x3a->size*2; - array.count = x3a->count; - array.tbl = (x3node*)calloc(size, sizeof(x3node) + sizeof(x3node*)); - if( array.tbl==0 ) return 0; /* Fail due to malloc failure */ - array.ht = (x3node**)&(array.tbl[size]); - for(i=0; icount; i++){ - x3node *oldnp, *newnp; - oldnp = &(x3a->tbl[i]); - h = statehash(oldnp->key) & (size-1); - newnp = &(array.tbl[i]); - if( array.ht[h] ) array.ht[h]->from = &(newnp->next); - newnp->next = array.ht[h]; - newnp->key = oldnp->key; - newnp->data = oldnp->data; - newnp->from = &(array.ht[h]); - array.ht[h] = newnp; - } - free(x3a->tbl); - *x3a = array; - } - /* Insert the new data */ - h = ph & (x3a->size-1); - np = &(x3a->tbl[x3a->count++]); - np->key = key; - np->data = data; - if( x3a->ht[h] ) x3a->ht[h]->from = &(np->next); - np->next = x3a->ht[h]; - x3a->ht[h] = np; - np->from = &(x3a->ht[h]); - return 1; -} - -/* Return a pointer to data assigned to the given key. Return NULL -** if no such key. */ -struct state *State_find(struct config *key) -{ - unsigned h; - x3node *np; - - if( x3a==0 ) return 0; - h = statehash(key) & (x3a->size-1); - np = x3a->ht[h]; - while( np ){ - if( statecmp(np->key,key)==0 ) break; - np = np->next; - } - return np ? np->data : 0; -} - -/* Return an array of pointers to all data in the table. -** The array is obtained from malloc. Return NULL if memory allocation -** problems, or if the array is empty. */ -struct state **State_arrayof() -{ - struct state **array; - int i,size; - if( x3a==0 ) return 0; - size = x3a->count; - array = (struct state **)calloc(size, sizeof(struct state *)); - if( array ){ - for(i=0; itbl[i].data; - } - return array; -} - -/* Hash a configuration */ -PRIVATE unsigned confighash(struct config *a) -{ - unsigned h=0; - h = h*571 + a->rp->index*37 + a->dot; - return h; -} - -/* There is one instance of the following structure for each -** associative array of type "x4". -*/ -struct s_x4 { - int size; /* The number of available slots. */ - /* Must be a power of 2 greater than or */ - /* equal to 1 */ - int count; /* Number of currently slots filled */ - struct s_x4node *tbl; /* The data stored here */ - struct s_x4node **ht; /* Hash table for lookups */ -}; - -/* There is one instance of this structure for every data element -** in an associative array of type "x4". -*/ -typedef struct s_x4node { - struct config *data; /* The data */ - struct s_x4node *next; /* Next entry with the same hash */ - struct s_x4node **from; /* Previous link */ -} x4node; - -/* There is only one instance of the array, which is the following */ -static struct s_x4 *x4a; - -/* Allocate a new associative array */ -void Configtable_init(){ - if( x4a ) return; - x4a = (struct s_x4*)malloc( sizeof(struct s_x4) ); - if( x4a ){ - x4a->size = 64; - x4a->count = 0; - x4a->tbl = (x4node*)calloc(64, sizeof(x4node) + sizeof(x4node*)); - if( x4a->tbl==0 ){ - free(x4a); - x4a = 0; - }else{ - int i; - x4a->ht = (x4node**)&(x4a->tbl[64]); - for(i=0; i<64; i++) x4a->ht[i] = 0; - } - } -} -/* Insert a new record into the array. Return TRUE if successful. -** Prior data with the same key is NOT overwritten */ -int Configtable_insert(struct config *data) -{ - x4node *np; - unsigned h; - unsigned ph; - - if( x4a==0 ) return 0; - ph = confighash(data); - h = ph & (x4a->size-1); - np = x4a->ht[h]; - while( np ){ - if( Configcmp((const char *) np->data,(const char *) data)==0 ){ - /* An existing entry with the same key is found. */ - /* Fail because overwrite is not allows. */ - return 0; - } - np = np->next; - } - if( x4a->count>=x4a->size ){ - /* Need to make the hash table bigger */ - int i,size; - struct s_x4 array; - array.size = size = x4a->size*2; - array.count = x4a->count; - array.tbl = (x4node*)calloc(size, sizeof(x4node) + sizeof(x4node*)); - if( array.tbl==0 ) return 0; /* Fail due to malloc failure */ - array.ht = (x4node**)&(array.tbl[size]); - for(i=0; icount; i++){ - x4node *oldnp, *newnp; - oldnp = &(x4a->tbl[i]); - h = confighash(oldnp->data) & (size-1); - newnp = &(array.tbl[i]); - if( array.ht[h] ) array.ht[h]->from = &(newnp->next); - newnp->next = array.ht[h]; - newnp->data = oldnp->data; - newnp->from = &(array.ht[h]); - array.ht[h] = newnp; - } - free(x4a->tbl); - *x4a = array; - } - /* Insert the new data */ - h = ph & (x4a->size-1); - np = &(x4a->tbl[x4a->count++]); - np->data = data; - if( x4a->ht[h] ) x4a->ht[h]->from = &(np->next); - np->next = x4a->ht[h]; - x4a->ht[h] = np; - np->from = &(x4a->ht[h]); - return 1; -} - -/* Return a pointer to data assigned to the given key. Return NULL -** if no such key. */ -struct config *Configtable_find(struct config *key) -{ - int h; - x4node *np; - - if( x4a==0 ) return 0; - h = confighash(key) & (x4a->size-1); - np = x4a->ht[h]; - while( np ){ - if( Configcmp((const char *) np->data,(const char *) key)==0 ) break; - np = np->next; - } - return np ? np->data : 0; -} - -/* Remove all data from the table. Pass each data to the function "f" -** as it is removed. ("f" may be null to avoid this step.) */ -void Configtable_clear(int(*f)(struct config *)) -{ - int i; - if( x4a==0 || x4a->count==0 ) return; - if( f ) for(i=0; icount; i++) (*f)(x4a->tbl[i].data); - for(i=0; isize; i++) x4a->ht[i] = 0; - x4a->count = 0; - return; -} diff --git a/contrib/lempar.c b/contrib/lempar.c deleted file mode 100644 index a4e3c07..0000000 --- a/contrib/lempar.c +++ /dev/null @@ -1,851 +0,0 @@ -/* Driver template for the LEMON parser generator. -** The author disclaims copyright to this source code. -*/ -/* First off, code is included that follows the "include" declaration -** in the input grammar file. */ -#include -%% -/* Next is all token values, in a form suitable for use by makeheaders. -** This section will be null unless lemon is run with the -m switch. -*/ -/* -** These constants (all generated automatically by the parser generator) -** specify the various kinds of tokens (terminals) that the parser -** understands. -** -** Each symbol here is a terminal symbol in the grammar. -*/ -%% -/* Make sure the INTERFACE macro is defined. -*/ -#ifndef INTERFACE -# define INTERFACE 1 -#endif -/* The next thing included is series of defines which control -** various aspects of the generated parser. -** YYCODETYPE is the data type used for storing terminal -** and nonterminal numbers. "unsigned char" is -** used if there are fewer than 250 terminals -** and nonterminals. "int" is used otherwise. -** YYNOCODE is a number of type YYCODETYPE which corresponds -** to no legal terminal or nonterminal number. This -** number is used to fill in empty slots of the hash -** table. -** YYFALLBACK If defined, this indicates that one or more tokens -** have fall-back values which should be used if the -** original value of the token will not parse. -** YYACTIONTYPE is the data type used for storing terminal -** and nonterminal numbers. "unsigned char" is -** used if there are fewer than 250 rules and -** states combined. "int" is used otherwise. -** ParseTOKENTYPE is the data type used for minor tokens given -** directly to the parser from the tokenizer. -** YYMINORTYPE is the data type used for all minor tokens. -** This is typically a union of many types, one of -** which is ParseTOKENTYPE. The entry in the union -** for base tokens is called "yy0". -** YYSTACKDEPTH is the maximum depth of the parser's stack. If -** zero the stack is dynamically sized using realloc() -** ParseARG_SDECL A static variable declaration for the %extra_argument -** ParseARG_PDECL A parameter declaration for the %extra_argument -** ParseARG_STORE Code to store %extra_argument into yypParser -** ParseARG_FETCH Code to extract %extra_argument from yypParser -** YYNSTATE the combined number of states. -** YYNRULE the number of rules in the grammar -** YYERRORSYMBOL is the code number of the error symbol. If not -** defined, then do no error processing. -*/ -%% -#define YY_NO_ACTION (YYNSTATE+YYNRULE+2) -#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1) -#define YY_ERROR_ACTION (YYNSTATE+YYNRULE) - -/* The yyzerominor constant is used to initialize instances of -** YYMINORTYPE objects to zero. */ -static const YYMINORTYPE yyzerominor = { 0 }; - -/* Define the yytestcase() macro to be a no-op if is not already defined -** otherwise. -** -** Applications can choose to define yytestcase() in the %include section -** to a macro that can assist in verifying code coverage. For production -** code the yytestcase() macro should be turned off. But it is useful -** for testing. -*/ -#ifndef yytestcase -# define yytestcase(X) -#endif - - -/* Next are the tables used to determine what action to take based on the -** current state and lookahead token. These tables are used to implement -** functions that take a state number and lookahead value and return an -** action integer. -** -** Suppose the action integer is N. Then the action is determined as -** follows -** -** 0 <= N < YYNSTATE Shift N. That is, push the lookahead -** token onto the stack and goto state N. -** -** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE. -** -** N == YYNSTATE+YYNRULE A syntax error has occurred. -** -** N == YYNSTATE+YYNRULE+1 The parser accepts its input. -** -** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused -** slots in the yy_action[] table. -** -** The action table is constructed as a single large table named yy_action[]. -** Given state S and lookahead X, the action is computed as -** -** yy_action[ yy_shift_ofst[S] + X ] -** -** If the index value yy_shift_ofst[S]+X is out of range or if the value -** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S] -** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table -** and that yy_default[S] should be used instead. -** -** The formula above is for computing the action when the lookahead is -** a terminal symbol. If the lookahead is a non-terminal (as occurs after -** a reduce action) then the yy_reduce_ofst[] array is used in place of -** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of -** YY_SHIFT_USE_DFLT. -** -** The following are the tables generated in this section: -** -** yy_action[] A single table containing all actions. -** yy_lookahead[] A table containing the lookahead for each entry in -** yy_action. Used to detect hash collisions. -** yy_shift_ofst[] For each state, the offset into yy_action for -** shifting terminals. -** yy_reduce_ofst[] For each state, the offset into yy_action for -** shifting non-terminals after a reduce. -** yy_default[] Default action for each state. -*/ -%% - -/* The next table maps tokens into fallback tokens. If a construct -** like the following: -** -** %fallback ID X Y Z. -** -** appears in the grammar, then ID becomes a fallback token for X, Y, -** and Z. Whenever one of the tokens X, Y, or Z is input to the parser -** but it does not parse, the type of the token is changed to ID and -** the parse is retried before an error is thrown. -*/ -#ifdef YYFALLBACK -static const YYCODETYPE yyFallback[] = { -%% -}; -#endif /* YYFALLBACK */ - -/* The following structure represents a single element of the -** parser's stack. Information stored includes: -** -** + The state number for the parser at this level of the stack. -** -** + The value of the token stored at this level of the stack. -** (In other words, the "major" token.) -** -** + The semantic value stored at this level of the stack. This is -** the information used by the action routines in the grammar. -** It is sometimes called the "minor" token. -*/ -struct yyStackEntry { - YYACTIONTYPE stateno; /* The state-number */ - YYCODETYPE major; /* The major token value. This is the code - ** number for the token at this stack level */ - YYMINORTYPE minor; /* The user-supplied minor token value. This - ** is the value of the token */ -}; -typedef struct yyStackEntry yyStackEntry; - -/* The state of the parser is completely contained in an instance of -** the following structure */ -struct yyParser { - int yyidx; /* Index of top element in stack */ -#ifdef YYTRACKMAXSTACKDEPTH - int yyidxMax; /* Maximum value of yyidx */ -#endif - int yyerrcnt; /* Shifts left before out of the error */ - ParseARG_SDECL /* A place to hold %extra_argument */ -#if YYSTACKDEPTH<=0 - int yystksz; /* Current side of the stack */ - yyStackEntry *yystack; /* The parser's stack */ -#else - yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ -#endif -}; -typedef struct yyParser yyParser; - -#ifndef NDEBUG -#include -static FILE *yyTraceFILE = 0; -static char *yyTracePrompt = 0; -#endif /* NDEBUG */ - -#ifndef NDEBUG -/* -** Turn parser tracing on by giving a stream to which to write the trace -** and a prompt to preface each trace message. Tracing is turned off -** by making either argument NULL -** -** Inputs: -**
    -**
  • A FILE* to which trace output should be written. -** If NULL, then tracing is turned off. -**
  • A prefix string written at the beginning of every -** line of trace output. If NULL, then tracing is -** turned off. -**
-** -** Outputs: -** None. -*/ -void ParseTrace(FILE *TraceFILE, char *zTracePrompt); -void ParseTrace(FILE *TraceFILE, char *zTracePrompt){ - yyTraceFILE = TraceFILE; - yyTracePrompt = zTracePrompt; - if( yyTraceFILE==0 ) yyTracePrompt = 0; - else if( yyTracePrompt==0 ) yyTraceFILE = 0; -} -#endif /* NDEBUG */ - -#ifndef NDEBUG -/* For tracing shifts, the names of all terminals and nonterminals -** are required. The following table supplies these names */ -static const char *const yyTokenName[] = { -%% -}; -#endif /* NDEBUG */ - -#ifndef NDEBUG -/* For tracing reduce actions, the names of all rules are required. -*/ -static const char *const yyRuleName[] = { -%% -}; -#endif /* NDEBUG */ - - -#if YYSTACKDEPTH<=0 -/* -** Try to increase the size of the parser stack. -*/ -static void yyGrowStack(yyParser *p){ - int newSize; - yyStackEntry *pNew; - - newSize = p->yystksz*2 + 100; - pNew = realloc(p->yystack, newSize*sizeof(pNew[0])); - if( pNew ){ - p->yystack = pNew; - p->yystksz = newSize; -#ifndef NDEBUG - if( yyTraceFILE ){ - fprintf(yyTraceFILE,"%sStack grows to %d entries!\n", - yyTracePrompt, p->yystksz); - } -#endif - } -} -#endif - -/* -** This function allocates a new parser. -** The only argument is a pointer to a function which works like -** malloc. -** -** Inputs: -** A pointer to the function used to allocate memory. -** -** Outputs: -** A pointer to a parser. This pointer is used in subsequent calls -** to Parse and ParseFree. -*/ -void *ParseAlloc(void *(*mallocProc)(size_t)){ - yyParser *pParser; - pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) ); - if( pParser ){ - pParser->yyidx = -1; -#ifdef YYTRACKMAXSTACKDEPTH - pParser->yyidxMax = 0; -#endif -#if YYSTACKDEPTH<=0 - pParser->yystack = NULL; - pParser->yystksz = 0; - yyGrowStack(pParser); -#endif - } - return pParser; -} - -/* The following function deletes the value associated with a -** symbol. The symbol can be either a terminal or nonterminal. -** "yymajor" is the symbol code, and "yypminor" is a pointer to -** the value. -*/ -static void yy_destructor( - yyParser *yypParser, /* The parser */ - YYCODETYPE yymajor, /* Type code for object to destroy */ - YYMINORTYPE *yypminor /* The object to be destroyed */ -){ - ParseARG_FETCH; - switch( yymajor ){ - /* Here is inserted the actions which take place when a - ** terminal or non-terminal is destroyed. This can happen - ** when the symbol is popped from the stack during a - ** reduce or during error processing or when a parser is - ** being destroyed before it is finished parsing. - ** - ** Note: during a reduce, the only symbols destroyed are those - ** which appear on the RHS of the rule, but which are not used - ** inside the C code. - */ -%% - default: break; /* If no destructor action specified: do nothing */ - } -} - -/* -** Pop the parser's stack once. -** -** If there is a destructor routine associated with the token which -** is popped from the stack, then call it. -** -** Return the major token number for the symbol popped. -*/ -static int yy_pop_parser_stack(yyParser *pParser){ - YYCODETYPE yymajor; - yyStackEntry *yytos = &pParser->yystack[pParser->yyidx]; - - if( pParser->yyidx<0 ) return 0; -#ifndef NDEBUG - if( yyTraceFILE && pParser->yyidx>=0 ){ - fprintf(yyTraceFILE,"%sPopping %s\n", - yyTracePrompt, - yyTokenName[yytos->major]); - } -#endif - yymajor = yytos->major; - yy_destructor(pParser, yymajor, &yytos->minor); - pParser->yyidx--; - return yymajor; -} - -/* -** Deallocate and destroy a parser. Destructors are all called for -** all stack elements before shutting the parser down. -** -** Inputs: -**
    -**
  • A pointer to the parser. This should be a pointer -** obtained from ParseAlloc. -**
  • A pointer to a function used to reclaim memory obtained -** from malloc. -**
-*/ -void ParseFree( - void *p, /* The parser to be deleted */ - void (*freeProc)(void*) /* Function used to reclaim memory */ -){ - yyParser *pParser = (yyParser*)p; - if( pParser==0 ) return; - while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser); -#if YYSTACKDEPTH<=0 - free(pParser->yystack); -#endif - (*freeProc)((void*)pParser); -} - -/* -** Return the peak depth of the stack for a parser. -*/ -#ifdef YYTRACKMAXSTACKDEPTH -int ParseStackPeak(void *p){ - yyParser *pParser = (yyParser*)p; - return pParser->yyidxMax; -} -#endif - -/* -** Find the appropriate action for a parser given the terminal -** look-ahead token iLookAhead. -** -** If the look-ahead token is YYNOCODE, then check to see if the action is -** independent of the look-ahead. If it is, return the action, otherwise -** return YY_NO_ACTION. -*/ -static int yy_find_shift_action( - yyParser *pParser, /* The parser */ - YYCODETYPE iLookAhead /* The look-ahead token */ -){ - int i; - int stateno = pParser->yystack[pParser->yyidx].stateno; - - if( stateno>YY_SHIFT_COUNT - || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){ - return yy_default[stateno]; - } - assert( iLookAhead!=YYNOCODE ); - i += iLookAhead; - if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ - if( iLookAhead>0 ){ -#ifdef YYFALLBACK - YYCODETYPE iFallback; /* Fallback token */ - if( iLookAhead %s\n", - yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); - } -#endif - return yy_find_shift_action(pParser, iFallback); - } -#endif -#ifdef YYWILDCARD - { - int j = i - iLookAhead + YYWILDCARD; - if( -#if YY_SHIFT_MIN+YYWILDCARD<0 - j>=0 && -#endif -#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT - j %s\n", - yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]); - } -#endif /* NDEBUG */ - return yy_action[j]; - } - } -#endif /* YYWILDCARD */ - } - return yy_default[stateno]; - }else{ - return yy_action[i]; - } -} - -/* -** Find the appropriate action for a parser given the non-terminal -** look-ahead token iLookAhead. -** -** If the look-ahead token is YYNOCODE, then check to see if the action is -** independent of the look-ahead. If it is, return the action, otherwise -** return YY_NO_ACTION. -*/ -static int yy_find_reduce_action( - int stateno, /* Current state number */ - YYCODETYPE iLookAhead /* The look-ahead token */ -){ - int i; -#ifdef YYERRORSYMBOL - if( stateno>YY_REDUCE_COUNT ){ - return yy_default[stateno]; - } -#else - assert( stateno<=YY_REDUCE_COUNT ); -#endif - i = yy_reduce_ofst[stateno]; - assert( i!=YY_REDUCE_USE_DFLT ); - assert( iLookAhead!=YYNOCODE ); - i += iLookAhead; -#ifdef YYERRORSYMBOL - if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){ - return yy_default[stateno]; - } -#else - assert( i>=0 && iyyidx--; -#ifndef NDEBUG - if( yyTraceFILE ){ - fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt); - } -#endif - while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); - /* Here code is inserted which will execute if the parser - ** stack every overflows */ -%% - ParseARG_STORE; /* Suppress warning about unused %extra_argument var */ -} - -/* -** Perform a shift action. -*/ -static void yy_shift( - yyParser *yypParser, /* The parser to be shifted */ - int yyNewState, /* The new state to shift in */ - int yyMajor, /* The major token to shift in */ - YYMINORTYPE *yypMinor /* Pointer to the minor token to shift in */ -){ - yyStackEntry *yytos; - yypParser->yyidx++; -#ifdef YYTRACKMAXSTACKDEPTH - if( yypParser->yyidx>yypParser->yyidxMax ){ - yypParser->yyidxMax = yypParser->yyidx; - } -#endif -#if YYSTACKDEPTH>0 - if( yypParser->yyidx>=YYSTACKDEPTH ){ - yyStackOverflow(yypParser, yypMinor); - return; - } -#else - if( yypParser->yyidx>=yypParser->yystksz ){ - yyGrowStack(yypParser); - if( yypParser->yyidx>=yypParser->yystksz ){ - yyStackOverflow(yypParser, yypMinor); - return; - } - } -#endif - yytos = &yypParser->yystack[yypParser->yyidx]; - yytos->stateno = (YYACTIONTYPE)yyNewState; - yytos->major = (YYCODETYPE)yyMajor; - yytos->minor = *yypMinor; -#ifndef NDEBUG - if( yyTraceFILE && yypParser->yyidx>0 ){ - int i; - fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState); - fprintf(yyTraceFILE,"%sStack:",yyTracePrompt); - for(i=1; i<=yypParser->yyidx; i++) - fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]); - fprintf(yyTraceFILE,"\n"); - } -#endif -} - -/* The following table contains information about every rule that -** is used during the reduce. -*/ -static const struct { - YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ - unsigned char nrhs; /* Number of right-hand side symbols in the rule */ -} yyRuleInfo[] = { -%% -}; - -static void yy_accept(yyParser*); /* Forward Declaration */ - -/* -** Perform a reduce action and the shift that must immediately -** follow the reduce. -*/ -static void yy_reduce( - yyParser *yypParser, /* The parser */ - int yyruleno /* Number of the rule by which to reduce */ -){ - int yygoto; /* The next state */ - int yyact; /* The next action */ - YYMINORTYPE yygotominor; /* The LHS of the rule reduced */ - yyStackEntry *yymsp; /* The top of the parser's stack */ - int yysize; /* Amount to pop the stack */ - ParseARG_FETCH; - yymsp = &yypParser->yystack[yypParser->yyidx]; -#ifndef NDEBUG - if( yyTraceFILE && yyruleno>=0 - && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ - fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt, - yyRuleName[yyruleno]); - } -#endif /* NDEBUG */ - - /* Silence complaints from purify about yygotominor being uninitialized - ** in some cases when it is copied into the stack after the following - ** switch. yygotominor is uninitialized when a rule reduces that does - ** not set the value of its left-hand side nonterminal. Leaving the - ** value of the nonterminal uninitialized is utterly harmless as long - ** as the value is never used. So really the only thing this code - ** accomplishes is to quieten purify. - ** - ** 2007-01-16: The wireshark project (www.wireshark.org) reports that - ** without this code, their parser segfaults. I'm not sure what there - ** parser is doing to make this happen. This is the second bug report - ** from wireshark this week. Clearly they are stressing Lemon in ways - ** that it has not been previously stressed... (SQLite ticket #2172) - */ - /*memset(&yygotominor, 0, sizeof(yygotominor));*/ - yygotominor = yyzerominor; - - - switch( yyruleno ){ - /* Beginning here are the reduction cases. A typical example - ** follows: - ** case 0: - ** #line - ** { ... } // User supplied code - ** #line - ** break; - */ -%% - }; - yygoto = yyRuleInfo[yyruleno].lhs; - yysize = yyRuleInfo[yyruleno].nrhs; - yypParser->yyidx -= yysize; - yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto); - if( yyact < YYNSTATE ){ -#ifdef NDEBUG - /* If we are not debugging and the reduce action popped at least - ** one element off the stack, then we can push the new element back - ** onto the stack here, and skip the stack overflow test in yy_shift(). - ** That gives a significant speed improvement. */ - if( yysize ){ - yypParser->yyidx++; - yymsp -= yysize-1; - yymsp->stateno = (YYACTIONTYPE)yyact; - yymsp->major = (YYCODETYPE)yygoto; - yymsp->minor = yygotominor; - }else -#endif - { - yy_shift(yypParser,yyact,yygoto,&yygotominor); - } - }else{ - assert( yyact == YYNSTATE + YYNRULE + 1 ); - yy_accept(yypParser); - } -} - -/* -** The following code executes when the parse fails -*/ -#ifndef YYNOERRORRECOVERY -static void yy_parse_failed( - yyParser *yypParser /* The parser */ -){ - ParseARG_FETCH; -#ifndef NDEBUG - if( yyTraceFILE ){ - fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); - } -#endif - while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); - /* Here code is inserted which will be executed whenever the - ** parser fails */ -%% - ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ -} -#endif /* YYNOERRORRECOVERY */ - -/* -** The following code executes when a syntax error first occurs. -*/ -static void yy_syntax_error( - yyParser *yypParser, /* The parser */ - int yymajor, /* The major type of the error token */ - YYMINORTYPE yyminor /* The minor type of the error token */ -){ - ParseARG_FETCH; -#define TOKEN (yyminor.yy0) -%% - ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ -} - -/* -** The following is executed when the parser accepts -*/ -static void yy_accept( - yyParser *yypParser /* The parser */ -){ - ParseARG_FETCH; -#ifndef NDEBUG - if( yyTraceFILE ){ - fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); - } -#endif - while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); - /* Here code is inserted which will be executed whenever the - ** parser accepts */ -%% - ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ -} - -/* The main parser program. -** The first argument is a pointer to a structure obtained from -** "ParseAlloc" which describes the current state of the parser. -** The second argument is the major token number. The third is -** the minor token. The fourth optional argument is whatever the -** user wants (and specified in the grammar) and is available for -** use by the action routines. -** -** Inputs: -**
    -**
  • A pointer to the parser (an opaque structure.) -**
  • The major token number. -**
  • The minor token number. -**
  • An option argument of a grammar-specified type. -**
-** -** Outputs: -** None. -*/ -void Parse( - void *yyp, /* The parser */ - int yymajor, /* The major token code number */ - ParseTOKENTYPE yyminor /* The value for the token */ - ParseARG_PDECL /* Optional %extra_argument parameter */ -){ - YYMINORTYPE yyminorunion; - int yyact; /* The parser action. */ - int yyendofinput; /* True if we are at the end of input */ -#ifdef YYERRORSYMBOL - int yyerrorhit = 0; /* True if yymajor has invoked an error */ -#endif - yyParser *yypParser; /* The parser */ - - /* (re)initialize the parser, if necessary */ - yypParser = (yyParser*)yyp; - if( yypParser->yyidx<0 ){ -#if YYSTACKDEPTH<=0 - if( yypParser->yystksz <=0 ){ - /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/ - yyminorunion = yyzerominor; - yyStackOverflow(yypParser, &yyminorunion); - return; - } -#endif - yypParser->yyidx = 0; - yypParser->yyerrcnt = -1; - yypParser->yystack[0].stateno = 0; - yypParser->yystack[0].major = 0; - } - yyminorunion.yy0 = yyminor; - yyendofinput = (yymajor==0); - ParseARG_STORE; - -#ifndef NDEBUG - if( yyTraceFILE ){ - fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]); - } -#endif - - do{ - yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor); - if( yyactyyerrcnt--; - yymajor = YYNOCODE; - }else if( yyact < YYNSTATE + YYNRULE ){ - yy_reduce(yypParser,yyact-YYNSTATE); - }else{ - assert( yyact == YY_ERROR_ACTION ); -#ifdef YYERRORSYMBOL - int yymx; -#endif -#ifndef NDEBUG - if( yyTraceFILE ){ - fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); - } -#endif -#ifdef YYERRORSYMBOL - /* A syntax error has occurred. - ** The response to an error depends upon whether or not the - ** grammar defines an error token "ERROR". - ** - ** This is what we do if the grammar does define ERROR: - ** - ** * Call the %syntax_error function. - ** - ** * Begin popping the stack until we enter a state where - ** it is legal to shift the error symbol, then shift - ** the error symbol. - ** - ** * Set the error count to three. - ** - ** * Begin accepting and shifting new tokens. No new error - ** processing will occur until three tokens have been - ** shifted successfully. - ** - */ - if( yypParser->yyerrcnt<0 ){ - yy_syntax_error(yypParser,yymajor,yyminorunion); - } - yymx = yypParser->yystack[yypParser->yyidx].major; - if( yymx==YYERRORSYMBOL || yyerrorhit ){ -#ifndef NDEBUG - if( yyTraceFILE ){ - fprintf(yyTraceFILE,"%sDiscard input token %s\n", - yyTracePrompt,yyTokenName[yymajor]); - } -#endif - yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion); - yymajor = YYNOCODE; - }else{ - while( - yypParser->yyidx >= 0 && - yymx != YYERRORSYMBOL && - (yyact = yy_find_reduce_action( - yypParser->yystack[yypParser->yyidx].stateno, - YYERRORSYMBOL)) >= YYNSTATE - ){ - yy_pop_parser_stack(yypParser); - } - if( yypParser->yyidx < 0 || yymajor==0 ){ - yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); - yy_parse_failed(yypParser); - yymajor = YYNOCODE; - }else if( yymx!=YYERRORSYMBOL ){ - YYMINORTYPE u2; - u2.YYERRSYMDT = 0; - yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2); - } - } - yypParser->yyerrcnt = 3; - yyerrorhit = 1; -#elif defined(YYNOERRORRECOVERY) - /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to - ** do any kind of error recovery. Instead, simply invoke the syntax - ** error routine and continue going as if nothing had happened. - ** - ** Applications can set this macro (for example inside %include) if - ** they intend to abandon the parse upon the first syntax error seen. - */ - yy_syntax_error(yypParser,yymajor,yyminorunion); - yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); - yymajor = YYNOCODE; - -#else /* YYERRORSYMBOL is not defined */ - /* This is what we do if the grammar does not define ERROR: - ** - ** * Report an error message, and throw away the input token. - ** - ** * If the input token is $, then fail the parse. - ** - ** As before, subsequent error messages are suppressed until - ** three input tokens have been successfully shifted. - */ - if( yypParser->yyerrcnt<=0 ){ - yy_syntax_error(yypParser,yymajor,yyminorunion); - } - yypParser->yyerrcnt = 3; - yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion); - if( yyendofinput ){ - yy_parse_failed(yypParser); - } - yymajor = YYNOCODE; -#endif - } - }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 ); - return; -} diff --git a/eval.c b/eval.c deleted file mode 100644 index 778a5f1..0000000 --- a/eval.c +++ /dev/null @@ -1,1832 +0,0 @@ -/* - * Copyright (C) 2020 Jo-Philipp Wich - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "lexer.h" -#include "parser.h" -#include "eval.h" -#include "lib.h" - -#include -#include -#include -#include -#include -#include - -bool -uc_val_is_truish(struct json_object *val) -{ - struct uc_op *tag = json_object_get_userdata(val); - double d; - - switch (tag ? tag->type : 0) { - case T_EXCEPTION: - return false; - - default: - switch (json_object_get_type(val)) { - case json_type_int: - return (json_object_get_int64(val) != 0); - - case json_type_double: - d = json_object_get_double(val); - - return (d != 0 && !isnan(d)); - - case json_type_boolean: - return (json_object_get_boolean(val) != false); - - case json_type_string: - return (json_object_get_string_len(val) > 0); - - case json_type_array: - case json_type_object: - return true; - - default: - return false; - } - } -} - -enum json_type -uc_cast_number(struct json_object *v, int64_t *n, double *d) -{ - bool is_double = false; - const char *s; - char *e; - - *d = 0.0; - *n = 0; - - switch (json_object_get_type(v)) { - case json_type_int: - *n = json_object_get_int64(v); - - return json_type_int; - - case json_type_double: - *d = json_object_get_double(v); - - return json_type_double; - - case json_type_null: - return json_type_int; - - case json_type_boolean: - *n = json_object_get_boolean(v) ? 1 : 0; - - return json_type_int; - - case json_type_string: - s = json_object_get_string(v); - - while (isspace(*s)) - s++; - - if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X') && isxdigit(s[2])) { - *n = strtoll(s, &e, 16); - } - else if (s[0] == '0' && isdigit(s[2])) { - *n = strtoll(s, &e, 8); - } - else { - *n = strtoll(s, &e, 10); - - if (*e == '.') { - *d = strtod(s, &e); - is_double = (e > s); - } - } - - while (isspace(*e)) - e++; - - if (*e) { - *d = NAN; - - return json_type_double; - } - - if (is_double) - return json_type_double; - - return json_type_int; - - default: - *d = NAN; - - return json_type_double; - } -} - -static struct json_object * -uc_execute_op(struct uc_state *state, uint32_t off); - -static struct json_object * -uc_execute_op_sequence(struct uc_state *state, uint32_t off); - -static struct json_object * -uc_execute_list(struct uc_state *state, uint32_t off); - -static char * -uc_ref_to_str(struct uc_state *state, uint32_t off) -{ - int child_type = OPn_TYPE(off, 1); - int op_type = OP_TYPE(off); - const char *l; - char *s, *p; - - switch (op_type) { - case T_DOT: - s = uc_ref_to_str(state, OPn(off, 0)); - l = (child_type == T_LABEL) ? json_object_get_string(OPn_VAL(off, 1)) : "???"; - - if (asprintf(&p, "%s.%s", s ? s : "(...)", l) == -1) - p = NULL; - - free(s); - - return p; - - case T_LBRACK: - if (!OP_IS_POSTFIX(off)) - return NULL; - - /* fall through */ - - case T_LPAREN: - s = uc_ref_to_str(state, OPn(off, 0)); - - switch (child_type) { - case T_STRING: - l = json_object_to_json_string_ext(OPn_VAL(off, 1), JSON_C_TO_STRING_NOSLASHESCAPE); - break; - - case T_NUMBER: - case T_LABEL: - case T_BOOL: - l = json_object_get_string(OPn_VAL(off, 1)); - break; - - default: - l = "..."; - } - - if (asprintf(&p, "%s%c%s%c", s ? s : "(...)", - (op_type == T_LPAREN) ? '(' : '[', l, - (op_type == T_LPAREN) ? ')' : ']') == -1) - p = NULL; - - free(s); - - return p; - - case T_LABEL: - return strdup(json_object_get_string(OP_VAL(off))); - - default: - return NULL; - } -} - -static struct json_object * -uc_getref(struct uc_state *state, uint32_t off, struct json_object **key) -{ - uint32_t off1 = OPn(off, 0); - uint32_t off2 = OPn(off, 1); - int type = OP_TYPE(off); - struct uc_scope *sc, *next; - struct json_object *val; - - if (key) - *key = NULL; - - if (type == T_DOT) { - if (key) - *key = off2 ? json_object_get(OP_VAL(off2)) : NULL; - - return uc_execute_op_sequence(state, off1); - } - else if (type == T_LBRACK && OP_IS_POSTFIX(off)) { - if (key) { - val = off2 ? uc_execute_op_sequence(state, off2) : NULL; - - if (uc_is_type(val, T_EXCEPTION)) - return val; - - *key = val; - } - - return uc_execute_op_sequence(state, off1); - } - else if (type == T_LABEL) { - sc = state->scope; - - while (true) { - if (json_object_object_get_ex(sc->scope, json_object_get_string(OP_VAL(off)), NULL)) - break; - - next = uc_parent_scope(sc); - - if (!next) { - if (state->strict_declarations) { - return uc_new_exception(state, OP_POS(off), - "Reference error: access to undeclared variable %s", - json_object_get_string(OP_VAL(off))); - } - - break; - } - - sc = next; - } - - if (key) - *key = json_object_get(OP_VAL(off)); - - return json_object_get(sc->scope); - } - else { - if (key) - *key = NULL; - - return NULL; - } -} - -static struct json_object * -uc_getref_required(struct uc_state *state, uint32_t off, struct json_object **key) -{ - uint32_t child_off = OPn(off, 0); - struct json_object *scope, *skey, *rv; - char *lhs; - - scope = uc_getref(state, off, &skey); - - if (!json_object_is_type(scope, json_type_array) && - !json_object_is_type(scope, json_type_object)) { - if (!uc_is_type(scope, T_EXCEPTION)) { - lhs = child_off ? uc_ref_to_str(state, child_off) : NULL; - - if (lhs) { - rv = uc_new_exception(state, OPn_POS(off, 0), - "Type error: `%s` is %s", - lhs, scope ? "not an array or object" : "null"); - free(lhs); - } - else { - rv = uc_new_exception(state, OPn_POS(off, 0), - "Type error: left-hand side is not an array or object"); - } - - json_object_put(scope); - } - else { - rv = scope; - } - - json_object_put(skey); - - *key = NULL; - return rv; - } - - *key = skey; - return scope; -} - -static struct json_object * -uc_getproto(struct json_object *obj) -{ - struct uc_op *tag = json_object_get_userdata(obj); - - if (!tag || (tag->type != T_LBRACE && tag->type <= __T_MAX) || !tag->val) - return NULL; - - return tag->tag.proto; -} - -static struct json_object * -uc_getval(struct json_object *scope, struct json_object *key) -{ - struct json_object *o, *v; - int64_t idx; - double d; - - if (!key) - return NULL; - - if (json_object_is_type(scope, json_type_array)) { - /* only consider doubles with integer values as array keys */ - if (json_object_is_type(key, json_type_double)) { - d = json_object_get_double(key); - - if ((double)(int64_t)(d) != d) - return NULL; - - idx = (int64_t)d; - } - else { - errno = 0; - idx = json_object_get_int64(key); - - if (errno != 0) - return NULL; - } - - return json_object_get(json_object_array_get_idx(scope, idx)); - } - - for (o = scope; o; o = uc_getproto(o)) { - if (!json_object_is_type(o, json_type_object)) - continue; - - if (json_object_object_get_ex(o, key ? json_object_get_string(key) : "null", &v)) - return json_object_get(v); - } - - return NULL; -} - -static struct json_object * -uc_setval(struct json_object *scope, struct json_object *key, struct json_object *val) -{ - int64_t idx; - - if (!key) - return NULL; - - if (json_object_is_type(scope, json_type_array)) { - errno = 0; - idx = json_object_get_int64(key); - - if (errno != 0) - return NULL; - - if (json_object_array_put_idx(scope, idx, val)) - return NULL; - - return json_object_get(val); - } - - if (json_object_object_add(scope, key ? json_object_get_string(key) : "null", val)) - return NULL; - - return json_object_get(val); -} - -static struct json_object * -uc_execute_assign(struct uc_state *state, uint32_t off) -{ - uint32_t label_off = OPn(off, 0); - uint32_t value_off = OPn(off, 1); - struct json_object *scope, *key, *val; - - scope = uc_getref_required(state, label_off, &key); - - if (!key) - return scope; - - val = uc_execute_op_sequence(state, value_off); - - if (!uc_is_type(val, T_EXCEPTION)) - uc_setval(scope, key, val); - - json_object_put(scope); - json_object_put(key); - - return val; -} - -static struct json_object * -uc_execute_local(struct uc_state *state, uint32_t off) -{ - struct json_object *val, *rv = NULL; - uint32_t assign_off, label_off; - - for (assign_off = OPn(off, 0); assign_off != 0; assign_off = OP_NEXT(assign_off)) { - switch (OP_TYPE(assign_off)) { - case T_ASSIGN: - label_off = OPn(assign_off, 0); - val = uc_execute_op_sequence(state, OPn(assign_off, 1)); - - if (uc_is_type(val, T_EXCEPTION)) - return val; - - break; - - case T_LABEL: - label_off = assign_off; - val = NULL; - break; - - default: - continue; - } - - if (label_off) { - json_object_put(rv); - rv = uc_setval(state->scope->scope, OP_VAL(label_off), val); - } - } - - return rv; -} - -static struct json_object * -uc_execute_op_sequence(struct uc_state *state, uint32_t off); - -static bool -uc_test_condition(struct uc_state *state, uint32_t off) -{ - struct json_object *val = uc_execute_op_sequence(state, off); - bool istrue = uc_val_is_truish(val); - - json_object_put(val); - - return istrue; -} - -static struct json_object * -uc_execute_if(struct uc_state *state, uint32_t off) -{ - uint32_t cond_off = OPn(off, 0); - uint32_t then_off = OPn(off, 1); - uint32_t else_off = OPn(off, 2); - bool res = uc_test_condition(state, cond_off); - - if (state->exception) - return json_object_get(state->exception); - else if (res) - return uc_execute_op_sequence(state, then_off); - else if (else_off) - return uc_execute_op_sequence(state, else_off); - - return NULL; -} - -static struct json_object * -uc_execute_for(struct uc_state *state, uint32_t off) -{ - struct json_object *kscope, *vscope, *val, *item, *ik, *iv = NULL, *rv = NULL; - uint32_t init_off = OPn(off, 0); - uint32_t cond_off = OPn(off, 1); - uint32_t step_off = OPn(off, 2); - uint32_t body_off = OPn(off, 3); - uint32_t ik_off, iv_off; - size_t arridx, arrlen; - bool local = false; - struct uc_op *tag; - - /* for (x in ...) loop variant */ - if (OP_IS_FOR_IN(off)) { - if (OP_TYPE(init_off) == T_LOCAL) { - local = true; - init_off = OPn(init_off, 0); - } - - ik_off = OPn(init_off, 0); - ik = OP_VAL(ik_off); - kscope = local ? state->scope->scope : uc_getref(state, ik_off, NULL); - - if (uc_is_type(kscope, T_EXCEPTION)) - return kscope; - - iv_off = OP_NEXT(ik_off); - - if (iv_off) { - iv = OP_VAL(iv_off); - vscope = local ? kscope : uc_getref(state, iv_off, NULL); - - if (uc_is_type(vscope, T_EXCEPTION)) - return vscope; - } - - val = uc_execute_op_sequence(state, OPn(init_off, 1)); - - if (uc_is_type(val, T_EXCEPTION)) - return val; - - if (json_object_is_type(val, json_type_array)) { - for (arridx = 0, arrlen = json_object_array_length(val); - arridx < arrlen; arridx++) { - item = json_object_array_get_idx(val, arridx); - - if (iv) { - uc_setval(kscope, ik, xjs_new_int64(arridx)); - uc_setval(vscope, iv, item); - } - else { - uc_setval(kscope, ik, item); - } - - json_object_put(rv); - - rv = uc_execute_op_sequence(state, body_off); - tag = json_object_get_userdata(rv); - - switch (tag ? tag->type : 0) { - case T_RETURN: - case T_EXCEPTION: - json_object_put(val); - - return rv; - - case T_BREAK: - json_object_put(val); - json_object_put(rv); - - return NULL; - } - } - } - else if (json_object_is_type(val, json_type_object)) { - json_object_object_foreach(val, key, item) { - json_object_put(uc_setval(kscope, ik, xjs_new_string(key))); - - if (iv) - uc_setval(vscope, iv, item); - - json_object_put(rv); - - rv = uc_execute_op_sequence(state, body_off); - tag = json_object_get_userdata(rv); - - switch (tag ? tag->type : 0) { - case T_RETURN: - case T_EXCEPTION: - json_object_put(val); - - return rv; - - case T_BREAK: - json_object_put(val); - json_object_put(rv); - - return NULL; - } - } - } - - json_object_put(val); - json_object_put(rv); - - return NULL; - } - - if (init_off) { - val = uc_execute_op_sequence(state, init_off); - - if (uc_is_type(val, T_EXCEPTION)) - return val; - - json_object_put(val); - } - - while (cond_off ? uc_test_condition(state, cond_off) : true) { - json_object_put(rv); - - rv = uc_execute_op_sequence(state, body_off); - tag = json_object_get_userdata(rv); - - switch (tag ? tag->type : 0) { - case T_RETURN: - case T_EXCEPTION: - return rv; - - case T_BREAK: - json_object_put(rv); - - return NULL; - } - - if (step_off) { - val = uc_execute_op_sequence(state, step_off); - - if (uc_is_type(val, T_EXCEPTION)) { - json_object_put(rv); - - return val; - } - - json_object_put(val); - } - } - - json_object_put(rv); - - return NULL; -} - -static struct json_object * -uc_execute_while(struct uc_state *state, uint32_t off) -{ - uint32_t test = OPn(off, 0); - uint32_t body = OPn(off, 1); - struct json_object *v, *rv = NULL; - struct uc_op *tag = NULL; - bool cond; - - while (1) { - json_object_put(rv); - - v = test ? uc_execute_op_sequence(state, test) : NULL; - cond = test ? uc_val_is_truish(v) : true; - - if (uc_is_type(v, T_EXCEPTION)) - return v; - - json_object_put(v); - - if (!cond) - return NULL; - - rv = uc_execute_op_sequence(state, body); - tag = json_object_get_userdata(rv); - - switch (tag ? tag->type : 0) { - case T_RETURN: - case T_EXCEPTION: - return rv; - - case T_BREAK: - json_object_put(rv); - - return NULL; - } - } - - json_object_put(rv); - - return NULL; -} - -static struct json_object * -uc_execute_and_or(struct uc_state *state, uint32_t off) -{ - bool is_or = (OP_TYPE(off) == T_OR); - struct json_object *val = NULL; - uint32_t op_off; - int i = 0; - - for (op_off = OPn(off, 0); op_off != 0 && i < OPn_NUM; op_off = OPn(off, ++i)) { - json_object_put(val); - - val = uc_execute_op_sequence(state, op_off); - - if (uc_is_type(val, T_EXCEPTION)) - break; - - if (uc_val_is_truish(val) == is_or) - break; - } - - return val; -} - -bool -uc_cmp(int how, struct json_object *v1, struct json_object *v2) -{ - enum json_type t1 = json_object_get_type(v1); - enum json_type t2 = json_object_get_type(v2); - int64_t n1, n2, delta; - double d1, d2; - - if (t1 == json_type_string && t2 == json_type_string) { - delta = strcmp(json_object_get_string(v1), json_object_get_string(v2)); - } - else { - if ((t1 == json_type_array && t2 == json_type_array) || - (t1 == json_type_object && t2 == json_type_object)) { - delta = (void *)v1 - (void *)v2; - } - else { - t1 = uc_cast_number(v1, &n1, &d1); - t2 = uc_cast_number(v2, &n2, &d2); - - if (t1 == json_type_double || t2 == json_type_double) { - d1 = (t1 == json_type_double) ? d1 : (double)n1; - d2 = (t2 == json_type_double) ? d2 : (double)n2; - - if (d1 == d2) - delta = 0; - else if (d1 < d2) - delta = -1; - else - delta = 1; - } - else { - delta = n1 - n2; - } - } - } - - switch (how) { - case T_LT: - return (delta < 0); - - case T_LE: - return (delta <= 0); - - case T_GT: - return (delta > 0); - - case T_GE: - return (delta >= 0); - - case T_EQ: - return (delta == 0); - - case T_NE: - return (delta != 0); - - default: - return false; - } -} - -static struct json_object * -_uc_get_operands(struct uc_state *state, uint32_t op_off, size_t n, struct json_object **v) -{ - struct json_object *ctx = NULL; - uint32_t child_off; - size_t i, j; - - for (i = 0; i < n; i++) { - child_off = OPn(op_off, i); - - if (child_off && OP_IS_LIST(child_off)) - v[i] = uc_execute_list(state, child_off); - else if (child_off) - v[i] = uc_execute_op_sequence(state, child_off); - else - v[i] = NULL; - - if (i == 0) - ctx = json_object_get(state->ctx); - - if (uc_is_type(v[i], T_EXCEPTION)) { - json_object_put(ctx); - - for (j = 0; j < i; j++) - json_object_put(v[j]); - - return v[i]; - } - } - - json_object_put(state->ctx); - state->ctx = ctx; - - return NULL; -} - -#define uc_get_operands(state, off, vals) \ - do { \ - struct json_object *ex = _uc_get_operands(state, off, ARRAY_SIZE(vals), vals); \ - if (ex) return ex; \ - } while(0) - -static struct json_object * -uc_execute_rel(struct uc_state *state, uint32_t off) -{ - struct json_object *v[2], *rv; - - uc_get_operands(state, off, v); - - rv = xjs_new_boolean(uc_cmp(OP_TYPE(off), v[0], v[1])); - - json_object_put(v[0]); - json_object_put(v[1]); - - return rv; -} - -static bool -uc_eq(struct json_object *v1, struct json_object *v2) -{ - struct uc_op *tag1 = json_object_get_userdata(v1); - struct uc_op *tag2 = json_object_get_userdata(v2); - enum json_type t1 = json_object_get_type(v1); - enum json_type t2 = json_object_get_type(v2); - - if ((tag1 ? tag1->type : 0) != (tag2 ? tag2->type : 0)) - return false; - - if (t1 != t2) - return false; - - switch (t1) { - case json_type_array: - case json_type_object: - return (v1 == v2); - - case json_type_boolean: - return (json_object_get_boolean(v1) == json_object_get_boolean(v2)); - - case json_type_double: - if (isnan(json_object_get_double(v1)) || isnan(json_object_get_double(v2))) - return false; - - return (json_object_get_double(v1) == json_object_get_double(v2)); - - case json_type_int: - return (json_object_get_int64(v1) == json_object_get_int64(v2)); - - case json_type_string: - return !strcmp(json_object_get_string(v1), json_object_get_string(v2)); - - case json_type_null: - return true; - } - - return false; -} - -static struct json_object * -uc_execute_equality(struct uc_state *state, uint32_t off) -{ - struct json_object *v[2], *rv; - bool equal = false; - - uc_get_operands(state, off, v); - - equal = uc_eq(v[0], v[1]); - rv = xjs_new_boolean((OP_TYPE(off) == T_EQS) ? equal : !equal); - - json_object_put(v[0]); - json_object_put(v[1]); - - return rv; -} - -static struct json_object * -uc_execute_in(struct uc_state *state, uint32_t off) -{ - struct json_object *v[2], *item; - size_t arrlen, arridx; - bool found = false; - const char *key; - - uc_get_operands(state, off, v); - - if (json_object_is_type(v[1], json_type_array)) { - for (arridx = 0, arrlen = json_object_array_length(v[1]); - arridx < arrlen; arridx++) { - item = json_object_array_get_idx(v[1], arridx); - - if (uc_cmp(T_EQ, v[0], item)) { - found = true; - break; - } - } - } - else if (json_object_is_type(v[1], json_type_object)) { - key = v[0] ? json_object_get_string(v[0]) : "null"; - found = json_object_object_get_ex(v[1], key, NULL); - } - - json_object_put(v[0]); - json_object_put(v[1]); - - return xjs_new_boolean(found); -} - -static struct json_object * -uc_execute_inc_dec(struct uc_state *state, uint32_t off) -{ - bool is_inc = (OP_TYPE(off) == T_INC); - struct json_object *val, *nval, *scope, *key; - int64_t n; - double d; - - scope = uc_getref_required(state, OPn(off, 0), &key); - - if (!key) - return scope; - - val = uc_getval(scope, key); - - json_object_put(scope); - json_object_put(key); - - if (uc_cast_number(val, &n, &d) == json_type_double) - nval = uc_new_double(d + (is_inc ? 1.0 : -1.0)); - else - nval = xjs_new_int64(n + (is_inc ? 1 : -1)); - - json_object_put(uc_setval(scope, key, nval)); - - /* postfix inc/dec, return old val */ - if (OP_IS_POSTFIX(off)) - return val; - - json_object_put(val); - - return json_object_get(nval); -} - -static struct json_object * -uc_execute_list(struct uc_state *state, uint32_t off) -{ - struct json_object *ex, *val, *arr = xjs_new_array(); - size_t i; - - while (off) { - val = uc_execute_op(state, off); - - if (uc_is_type(val, T_EXCEPTION)) { - json_object_put(arr); - - return val; - } - - if (OP_IS_ELLIP(off)) { - if (!json_object_is_type(val, json_type_array)) { - ex = uc_new_exception(state, OP_POS(off), - "Type error: (%s) is not iterable", - json_object_get_string(val)); - - json_object_put(arr); - json_object_put(val); - - return ex; - } - - for (i = 0; i < json_object_array_length(val); i++) - json_object_array_add(arr, json_object_get(json_object_array_get_idx(val, i))); - - json_object_put(val); - } - else { - json_object_array_add(arr, val); - } - - off = OP_NEXT(off); - } - - return arr; -} - -static struct json_object * -uc_execute_object(struct uc_state *state, uint32_t off) -{ - struct json_object *ex, *v, *obj = uc_new_object(NULL); - uint32_t key_off; - char *istr; - size_t i; - - for (key_off = OPn(off, 0); key_off != 0; key_off = OP_NEXT(key_off)) { - v = uc_execute_op_sequence(state, OPn(key_off, 0)); - - if (uc_is_type(v, T_EXCEPTION)) { - json_object_put(obj); - - return v; - } - - if (OP_TYPE(key_off) == T_ELLIP) { - switch (json_object_get_type(v)) { - case json_type_object: - ; /* a label can only be part of a statement and a declaration is not a statement */ - json_object_object_foreach(v, vk, vv) - json_object_object_add(obj, vk, json_object_get(vv)); - - json_object_put(v); - - break; - - case json_type_array: - for (i = 0; i < json_object_array_length(v); i++) { - xasprintf(&istr, "%zu", i); - json_object_object_add(obj, istr, json_object_get(json_object_array_get_idx(v, i))); - free(istr); - } - - json_object_put(v); - - break; - - default: - ex = uc_new_exception(state, OP_POS(key_off), - "Type error: (%s) is not iterable", - json_object_get_string(v)); - - json_object_put(obj); - json_object_put(v); - - return ex; - } - } - else { - json_object_object_add(obj, json_object_get_string(OP_VAL(key_off)), v); - } - } - - return obj; -} - -struct json_object * -uc_invoke(struct uc_state *state, uint32_t off, struct json_object *this, - struct json_object *func, struct json_object *argvals) -{ - struct uc_op *tag = json_object_get_userdata(func); - struct json_object *arr, *rv = NULL; - struct uc_callstack callstack = {}; - struct uc_function *fn, *prev_fn; - size_t arridx, arglen; - struct uc_scope *sc; - uint32_t tag_off; - uc_c_fn *fptr; - int tag_type; - bool rest; - - if (!tag) - return NULL; - - if (state->calldepth >= 1000) - return uc_new_exception(state, OP_POS(off), "Runtime error: Too much recursion"); - - callstack.next = state->callstack; - callstack.function = state->function; - callstack.off = OP_POS(off); - - if (tag->is_arrow) - callstack.ctx = state->callstack ? json_object_get(state->callstack->ctx) : NULL; - else - callstack.ctx = json_object_get(this ? this : state->ctx); - - state->callstack = &callstack; - state->calldepth++; - - fn = tag->tag.data; - - prev_fn = state->function; - state->function = fn; - - /* is native function */ - if (tag->type == T_CFUNC) { - fptr = (uc_c_fn *)fn->cfn; - rv = fptr ? fptr(state, off, argvals) : NULL; - } - - /* is ucode function */ - else { - callstack.scope = uc_new_scope(state, fn->parent_scope); - - sc = state->scope; - state->scope = uc_acquire_scope(callstack.scope); - - if (fn->args) { - arglen = json_object_array_length(fn->args); - rest = (arglen > 1) && json_object_is_type(json_object_array_get_idx(fn->args, arglen - 1), json_type_null); - - for (arridx = 0; arridx < arglen - rest; arridx++) { - /* if the last argument is a rest one (...arg), put all remaining parameter values in an array */ - if (rest && arridx == arglen - 2) { - arr = xjs_new_array(); - - uc_setval(callstack.scope->scope, - json_object_array_get_idx(fn->args, arridx), - arr); - - for (; argvals && arridx < json_object_array_length(argvals); arridx++) - json_object_array_add(arr, json_object_get(json_object_array_get_idx(argvals, arridx))); - - break; - } - - uc_setval(callstack.scope->scope, json_object_array_get_idx(fn->args, arridx), - argvals ? json_object_array_get_idx(argvals, arridx) : NULL); - } - } - - rv = uc_execute_op_sequence(state, fn->entry); - tag = json_object_get_userdata(rv); - tag_off = tag ? tag->off : 0; - tag_type = tag ? tag->type : 0; - - switch (tag_type) { - case T_BREAK: - case T_CONTINUE: - json_object_put(rv); - rv = uc_new_exception(state, OP_POS(tag_off), - "Syntax error: %s statement must be inside loop", - uc_get_tokenname(tag_type)); - break; - - case T_RETURN: - json_object_put(rv); - rv = json_object_get(state->rval); - break; - } - - /* we left the function, pop the function scope... */ - uc_release_scope(state->scope); - state->scope = sc; - - /* ... and release it */ - uc_release_scope(callstack.scope); - - } - - state->function = prev_fn; - - json_object_put(callstack.ctx); - state->callstack = callstack.next; - state->calldepth--; - - return rv; -} - -static struct json_object * -uc_execute_call(struct uc_state *state, uint32_t off) -{ - struct json_object *v[2], *rv; - struct uc_op *decl; - char *lhs; - - uc_get_operands(state, off, v); - - decl = json_object_get_userdata(v[0]); - - if (!decl || (decl->type != T_FUNC && decl->type != T_CFUNC)) { - lhs = uc_ref_to_str(state, OPn(off, 0)); - - rv = uc_new_exception(state, OPn_POS(off, 0), - "Type error: %s is not a function", - lhs ? lhs : "left-hand side expression"); - - free(lhs); - } - else { - if (v[1] == NULL) - v[1] = xjs_new_array(); - - rv = uc_invoke(state, off, NULL, v[0], v[1]); - } - - json_object_put(v[0]); - json_object_put(v[1]); - - return rv; -} - -static void -uc_write_str(struct json_object *v) -{ - const char *p; - size_t len; - - switch (json_object_get_type(v)) { - case json_type_object: - case json_type_array: - p = json_object_to_json_string_ext(v, JSON_C_TO_STRING_NOSLASHESCAPE|JSON_C_TO_STRING_SPACED); - len = strlen(p); - break; - - case json_type_string: - p = json_object_get_string(v); - len = json_object_get_string_len(v); - break; - - case json_type_null: - p = ""; - len = 0; - break; - - default: - p = json_object_get_string(v); - len = strlen(p); - } - - fwrite(p, 1, len, stdout); -} - -static struct json_object * -uc_execute_exp(struct uc_state *state, uint32_t off) -{ - struct json_object *val = uc_execute_op_sequence(state, OPn(off, 0)); - struct uc_op *tag = val ? json_object_get_userdata(val) : NULL; - - switch (tag ? tag->type : 0) { - case T_EXCEPTION: - printf("", json_object_get_string(val)); - break; - - default: - uc_write_str(val); - break; - } - - json_object_put(val); - - return NULL; -} - -static struct json_object * -uc_execute_unary_plus_minus(struct uc_state *state, uint32_t off) -{ - bool is_sub = (OP_TYPE(off) == T_SUB); - struct json_object *v[1]; - enum json_type t; - int64_t n; - double d; - - uc_get_operands(state, off, v); - - t = uc_cast_number(v[0], &n, &d); - - json_object_put(v[0]); - - switch (t) { - case json_type_int: - if (OPn_IS_OVERFLOW(off, 0)) - return xjs_new_int64(((n >= 0) == is_sub) ? INT64_MIN : INT64_MAX); - - return xjs_new_int64(is_sub ? -n : n); - - default: - return uc_new_double(is_sub ? -d : d); - } -} - -static struct json_object * -uc_execute_arith(struct uc_state *state, uint32_t off) -{ - int type = OP_TYPE(off); - struct json_object *v[2], *rv; - enum json_type t1, t2; - const char *s1, *s2; - size_t len1, len2; - int64_t n1, n2; - double d1, d2; - char *s; - - if (!OPn(off, 1)) - return uc_execute_unary_plus_minus(state, off); - - uc_get_operands(state, off, v); - - if (type == T_ADD && - (json_object_is_type(v[0], json_type_string) || - json_object_is_type(v[1], json_type_string))) { - s1 = v[0] ? json_object_get_string(v[0]) : "null"; - s2 = v[1] ? json_object_get_string(v[1]) : "null"; - len1 = strlen(s1); - len2 = strlen(s2); - s = xalloc(len1 + len2 + 1); - - snprintf(s, len1 + len2 + 1, "%s%s", s1, s2); - - rv = xjs_new_string(s); - - json_object_put(v[0]); - json_object_put(v[1]); - free(s); - - return rv; - } - - t1 = uc_cast_number(v[0], &n1, &d1); - t2 = uc_cast_number(v[1], &n2, &d2); - - json_object_put(v[0]); - json_object_put(v[1]); - - if (t1 == json_type_double || t2 == json_type_double) { - d1 = (t1 == json_type_double) ? d1 : (double)n1; - d2 = (t2 == json_type_double) ? d2 : (double)n2; - - switch (type) { - case T_ADD: - return uc_new_double(d1 + d2); - - case T_SUB: - return uc_new_double(d1 - d2); - - case T_MUL: - return uc_new_double(d1 * d2); - - case T_DIV: - if (d2 == 0.0) - return uc_new_double(INFINITY); - else if (isnan(d2)) - return uc_new_double(NAN); - else if (!isfinite(d2)) - return uc_new_double(isfinite(d1) ? 0.0 : NAN); - - return uc_new_double(d1 / d2); - - case T_MOD: - return uc_new_double(NAN); - } - } - - switch (type) { - case T_ADD: - return xjs_new_int64(n1 + n2); - - case T_SUB: - return xjs_new_int64(n1 - n2); - - case T_MUL: - return xjs_new_int64(n1 * n2); - - case T_DIV: - if (n2 == 0) - return uc_new_double(INFINITY); - - return xjs_new_int64(n1 / n2); - - case T_MOD: - return xjs_new_int64(n1 % n2); - } - - return uc_new_double(NAN); -} - -static struct json_object * -uc_execute_bitop(struct uc_state *state, uint32_t off) -{ - struct json_object *v[2]; - int64_t n1, n2; - double d; - - uc_get_operands(state, off, v); - - if (uc_cast_number(v[0], &n1, &d) == json_type_double) - n1 = isnan(d) ? 0 : (int64_t)d; - - if (uc_cast_number(v[1], &n2, &d) == json_type_double) - n2 = isnan(d) ? 0 : (int64_t)d; - - json_object_put(v[0]); - json_object_put(v[1]); - - switch (OP_TYPE(off)) { - case T_LSHIFT: - return xjs_new_int64(n1 << n2); - - case T_RSHIFT: - return xjs_new_int64(n1 >> n2); - - case T_BAND: - return xjs_new_int64(n1 & n2); - - case T_BXOR: - return xjs_new_int64(n1 ^ n2); - - case T_BOR: - return xjs_new_int64(n1 | n2); - - default: - return NULL; - } -} - -static struct json_object * -uc_execute_not(struct uc_state *state, uint32_t off) -{ - return xjs_new_boolean(!uc_test_condition(state, OPn(off, 0))); -} - -static struct json_object * -uc_execute_compl(struct uc_state *state, uint32_t off) -{ - struct json_object *v[1]; - int64_t n; - double d; - - uc_get_operands(state, off, v); - - if (uc_cast_number(v[0], &n, &d) == json_type_double) - n = isnan(d) ? 0 : (int64_t)d; - - json_object_put(v[0]); - - return xjs_new_int64(~n); -} - -static void -uc_free_tag(struct json_object *v, void *ud) -{ - free(ud); -} - -static struct json_object * -uc_execute_return(struct uc_state *state, uint32_t off) -{ - struct uc_op *cpy = xalloc(sizeof(*cpy)); - struct json_object *v[1], *rv; - - memcpy(cpy, OP(off), sizeof(*cpy)); - cpy->off = off; - - uc_get_operands(state, off, v); - - json_object_put(state->rval); - state->rval = v[0]; - - rv = xjs_new_boolean(false); - - json_object_set_userdata(rv, cpy, uc_free_tag); - - return rv; -} - -static struct json_object * -uc_execute_break_cont(struct uc_state *state, uint32_t off) -{ - struct uc_op *cpy = xalloc(sizeof(*cpy)); - struct json_object *rv = xjs_new_int64(0); - - memcpy(cpy, OP(off), sizeof(*cpy)); - cpy->off = off; - - json_object_set_userdata(rv, cpy, uc_free_tag); - - return rv; -} - -static struct json_object * -uc_execute_function(struct uc_state *state, uint32_t off) -{ - struct json_object *obj = uc_new_func(state, off, state->scope); - struct json_object *val = OPn_VAL(off, 0); - - if (val) - uc_setval(state->scope->scope, val, obj); - - return obj; -} - -static struct json_object * -uc_execute_this(struct uc_state *state, uint32_t off) -{ - return json_object_get(state->callstack->ctx); -} - -static struct json_object * -uc_execute_try_catch(struct uc_state *state, uint32_t off) -{ - struct json_object *evar, *rv; - struct uc_op *tag; - - rv = uc_execute_op_sequence(state, OPn(off, 0)); - - if (uc_is_type(rv, T_EXCEPTION)) { - evar = OPn_VAL(off, 1); - - if (evar) { - /* remove the T_EXCEPTION type from the object to avoid handling - * it as a new exception in the catch block */ - tag = json_object_get_userdata(rv); - tag->type = T_LBRACE; - - json_object_put(uc_setval(state->scope->scope, evar, - json_object_get(rv))); - } - - json_object_put(state->exception); - state->exception = NULL; - - json_object_put(rv); - rv = uc_execute_op_sequence(state, OPn(off, 2)); - } - - return rv; -} - -static bool -uc_match_case(struct uc_state *state, struct json_object *v, uint32_t case_off) -{ - struct json_object *caseval = uc_execute_op_sequence(state, OPn(case_off, 0)); - bool rv = uc_eq(v, caseval); - - json_object_put(caseval); - return rv; -} - -static struct json_object * -uc_execute_switch_case(struct uc_state *state, uint32_t off) -{ - uint32_t case_off, default_off = 0, jmp_off = 0; - struct json_object *v[1], *rv = NULL; - - uc_get_operands(state, off, v); - - /* First try to find matching case... */ - for (case_off = OPn(off, 1); case_off != 0; case_off = OP_NEXT(case_off)) { - /* remember default case and throw on dupes */ - if (OP_TYPE(case_off) == T_DEFAULT) { - if (default_off) { - json_object_put(v[0]); - - return uc_new_exception(state, OP_POS(case_off), - "Syntax error: more than one switch default case"); - } - - default_off = case_off; - continue; - } - - /* Found a matching case, remember jump offset */ - if (uc_match_case(state, v[0], case_off)) { - jmp_off = case_off; - break; - } - } - - /* jump to matching case (or default) and continue until break */ - for (case_off = jmp_off ? jmp_off : default_off; case_off != 0; case_off = OP_NEXT(case_off)) { - json_object_put(rv); - - if (OP_TYPE(case_off) == T_DEFAULT) - rv = uc_execute_op_sequence(state, OPn(case_off, 0)); - else - rv = uc_execute_op_sequence(state, OPn(case_off, 1)); - - if (uc_is_type(rv, T_BREAK)) { - json_object_put(rv); - rv = NULL; - break; - } - else if (uc_is_type(rv, T_RETURN) || uc_is_type(rv, T_EXCEPTION) || uc_is_type(rv, T_CONTINUE)) { - break; - } - } - - json_object_put(v[0]); - - return rv; -} - -static struct json_object * -uc_execute_atom(struct uc_state *state, uint32_t off) -{ - return json_object_get(OP_VAL(off)); -} - -static struct json_object * -uc_execute_text(struct uc_state *state, uint32_t off) -{ - printf("%s", json_object_get_string(OP_VAL(off))); - - return NULL; -} - -static struct json_object * -uc_execute_label(struct uc_state *state, uint32_t off) -{ - struct json_object *scope, *key, *val; - - scope = uc_getref(state, off, &key); - - json_object_put(state->ctx); - state->ctx = NULL; - - if (state->strict_declarations && scope == NULL) { - return uc_new_exception(state, OP_POS(off), - "Reference error: %s is not defined", - json_object_get_string(OP_VAL(off))); - } - - val = uc_getval(scope, key); - json_object_put(scope); - json_object_put(key); - - return val; -} - -static struct json_object * -uc_execute_dot(struct uc_state *state, uint32_t off) -{ - struct json_object *scope, *key, *val; - - scope = uc_getref_required(state, off, &key); - - json_object_put(state->ctx); - state->ctx = json_object_get(scope); - - if (!key) - return scope; - - val = uc_getval(scope, key); - json_object_put(scope); - json_object_put(key); - - return val; -} - -static struct json_object * -uc_execute_lbrack(struct uc_state *state, uint32_t off) -{ - /* postfix access */ - if (OP_IS_POSTFIX(off)) - return uc_execute_dot(state, off); - - return uc_execute_list(state, OPn(off, 0)); -} - -static struct json_object * -uc_execute_exp_list(struct uc_state *state, uint32_t off) -{ - return uc_execute_op_sequence(state, OPn(off, 0)); -} - -static struct json_object *(*fns[__T_MAX])(struct uc_state *, uint32_t) = { - [T_NUMBER] = uc_execute_atom, - [T_DOUBLE] = uc_execute_atom, - [T_STRING] = uc_execute_atom, - [T_REGEXP] = uc_execute_atom, - [T_BOOL] = uc_execute_atom, - [T_NULL] = uc_execute_atom, - [T_THIS] = uc_execute_this, - [T_FUNC] = uc_execute_function, - [T_ARROW] = uc_execute_function, - [T_TEXT] = uc_execute_text, - [T_ASSIGN] = uc_execute_assign, - [T_LOCAL] = uc_execute_local, - [T_LABEL] = uc_execute_label, - [T_DOT] = uc_execute_dot, - [T_LBRACK] = uc_execute_lbrack, - [T_LBRACE] = uc_execute_object, - [T_IF] = uc_execute_if, - [T_ELIF] = uc_execute_if, - [T_QMARK] = uc_execute_if, - [T_FOR] = uc_execute_for, - [T_WHILE] = uc_execute_while, - [T_AND] = uc_execute_and_or, - [T_OR] = uc_execute_and_or, - [T_LT] = uc_execute_rel, - [T_LE] = uc_execute_rel, - [T_GT] = uc_execute_rel, - [T_GE] = uc_execute_rel, - [T_EQ] = uc_execute_rel, - [T_NE] = uc_execute_rel, - [T_EQS] = uc_execute_equality, - [T_NES] = uc_execute_equality, - [T_IN] = uc_execute_in, - [T_INC] = uc_execute_inc_dec, - [T_DEC] = uc_execute_inc_dec, - [T_LPAREN] = uc_execute_call, - [T_LEXP] = uc_execute_exp, - [T_ADD] = uc_execute_arith, - [T_SUB] = uc_execute_arith, - [T_MUL] = uc_execute_arith, - [T_DIV] = uc_execute_arith, - [T_MOD] = uc_execute_arith, - [T_LSHIFT] = uc_execute_bitop, - [T_RSHIFT] = uc_execute_bitop, - [T_BAND] = uc_execute_bitop, - [T_BXOR] = uc_execute_bitop, - [T_BOR] = uc_execute_bitop, - [T_COMPL] = uc_execute_compl, - [T_NOT] = uc_execute_not, - [T_RETURN] = uc_execute_return, - [T_BREAK] = uc_execute_break_cont, - [T_CONTINUE] = uc_execute_break_cont, - [T_TRY] = uc_execute_try_catch, - [T_SWITCH] = uc_execute_switch_case, - [T_COMMA] = uc_execute_exp_list, -}; - -static struct json_object * -uc_execute_op(struct uc_state *state, uint32_t off) -{ - int type = OP_TYPE(off); - - if (!fns[type]) - return uc_new_exception(state, OP_POS(off), - "Runtime error: Unrecognized opcode %d", type); - - return fns[type](state, off); -} - -static struct json_object * -uc_execute_op_sequence(struct uc_state *state, uint32_t off) -{ - struct json_object *v = NULL; - struct uc_op *tag = NULL; - - while (off) { - json_object_put(v); - - v = uc_execute_op(state, off); - tag = v ? json_object_get_userdata(v) : NULL; - - switch (tag ? tag->type : 0) { - case T_BREAK: - case T_CONTINUE: - case T_RETURN: - case T_EXCEPTION: - return v; - } - - off = OP_NEXT(off); - } - - return v; -} - -static void -uc_globals_init(struct uc_state *state, struct json_object *scope) -{ - struct json_object *arr = xjs_new_array(); - const char *p, *last; - - for (p = last = LIB_SEARCH_PATH;; p++) { - if (*p == ':' || *p == '\0') { - json_object_array_add(arr, xjs_new_string_len(last, p - last)); - - if (!*p) - break; - - last = p + 1; - } - } - - json_object_object_add(scope, "REQUIRE_SEARCH_PATH", arr); -} - -static void -uc_register_variable(struct json_object *scope, const char *key, struct json_object *val) -{ - char *name = strdup(key); - char *p; - - if (!name) - return; - - for (p = name; *p; p++) - if (!isalnum(*p) && *p != '_') - *p = '_'; - - json_object_object_add(scope, name, val); - free(name); -} - -struct json_object * -uc_run(struct uc_state *state, struct json_object *env, struct json_object *modules) -{ - struct json_object *args, *rv; - struct uc_function fn = {}; - size_t i; - - state->scope = uc_new_scope(state, NULL); - state->ctx = NULL; - - fn.source = state->source; - state->function = &fn; - - if (env) { - json_object_object_foreach(env, key, val) - uc_register_variable(state->scope->scope, key, json_object_get(val)); - } - - uc_globals_init(state, state->scope->scope); - uc_lib_init(state, state->scope->scope); - - if (modules) { - args = xjs_new_array(); - - for (i = 0; i < json_object_array_length(modules); i++) { - json_object_array_put_idx(args, 0, json_object_get(json_object_array_get_idx(modules, i))); - - rv = uc_invoke(state, 0, NULL, - json_object_object_get(state->scope->scope, "require"), - args); - - if (uc_is_type(rv, T_EXCEPTION)) - goto out; - - uc_register_variable(state->scope->scope, - json_object_get_string(json_object_array_get_idx(modules, i)), - rv); - } - - json_object_put(args); - } - - rv = uc_execute_source(state, state->source, state->scope); - -out: - uc_release_scope(state->scope); - - return rv; -} diff --git a/eval.h b/eval.h deleted file mode 100644 index d18ec16..0000000 --- a/eval.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (C) 2020 Jo-Philipp Wich - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#ifndef __MATCHER_H_ -#define __MATCHER_H_ - -#include -#include -#include -#include - -#include "ast.h" - -bool -uc_cmp(int how, struct json_object *v1, struct json_object *v2); - -bool -uc_val_is_truish(struct json_object *val); - -enum json_type -uc_cast_number(struct json_object *v, int64_t *n, double *d); - -struct json_object * -uc_invoke(struct uc_state *, uint32_t, struct json_object *, struct json_object *, struct json_object *); - -struct json_object * -uc_run(struct uc_state *state, struct json_object *env, struct json_object *modules); - -#endif diff --git a/lexer.c b/lexer.c index 46692ec..a1ae73d 100644 --- a/lexer.c +++ b/lexer.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Jo-Philipp Wich + * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -25,11 +25,11 @@ #include #include -#include "ast.h" +#include "vm.h" #include "lib.h" #include "lexer.h" -#include "parser.h" +#define UC_LEX_CONTINUE_PARSING (void *)1 struct keyword { int type; @@ -48,7 +48,7 @@ struct token { char pat[4]; }; int plen; - uint32_t (*parse)(struct uc_state *s); + uc_token *(*parse)(uc_lexer *); }; #define dec(o) \ @@ -58,109 +58,110 @@ struct token { (((x) >= 'a') ? (10 + (x) - 'a') : \ (((x) >= 'A') ? (10 + (x) - 'A') : dec(x))) -static uint32_t parse_comment(struct uc_state *); -static uint32_t parse_string(struct uc_state *); -static uint32_t parse_regexp(struct uc_state *); -static uint32_t parse_number(struct uc_state *); -static uint32_t parse_label(struct uc_state *); +static uc_token *parse_comment(uc_lexer *); +static uc_token *parse_string(uc_lexer *); +static uc_token *parse_regexp(uc_lexer *); +static uc_token *parse_number(uc_lexer *); +static uc_token *parse_label(uc_lexer *); static const struct token tokens[] = { - { T_ASLEFT, { .pat = "<<=" }, 3 }, - { T_ASRIGHT, { .pat = ">>=" }, 3 }, - { T_LEXP, { .pat = "{{-" }, 3 }, - { T_REXP, { .pat = "-}}" }, 3 }, - { T_LSTM, { .pat = "{%+" }, 3 }, - { T_LSTM, { .pat = "{%-" }, 3 }, - { T_RSTM, { .pat = "-%}" }, 3 }, - { T_EQS, { .pat = "===" }, 3 }, - { T_NES, { .pat = "!==" }, 3 }, - { T_ELLIP, { .pat = "..." }, 3 }, - { T_AND, { .pat = "&&" }, 2 }, - { T_ASADD, { .pat = "+=" }, 2 }, - { T_ASBAND, { .pat = "&=" }, 2 }, - { T_ASBOR, { .pat = "|=" }, 2 }, - { T_ASBXOR, { .pat = "^=" }, 2 }, - //{ T_ASDIV, { .pat = "/=" }, 2 }, - { T_ASMOD, { .pat = "%=" }, 2 }, - { T_ASMUL, { .pat = "*=" }, 2 }, - { T_ASSUB, { .pat = "-=" }, 2 }, - { T_DEC, { .pat = "--" }, 2 }, - { T_INC, { .pat = "++" }, 2 }, - { T_EQ, { .pat = "==" }, 2 }, - { T_NE, { .pat = "!=" }, 2 }, - { T_LE, { .pat = "<=" }, 2 }, - { T_GE, { .pat = ">=" }, 2 }, - { T_LSHIFT, { .pat = "<<" }, 2 }, - { T_RSHIFT, { .pat = ">>" }, 2 }, + { TK_ASLEFT, { .pat = "<<=" }, 3 }, + { TK_ASRIGHT, { .pat = ">>=" }, 3 }, + { TK_LEXP, { .pat = "{{-" }, 3 }, + { TK_REXP, { .pat = "-}}" }, 3 }, + { TK_LSTM, { .pat = "{%+" }, 3 }, + { TK_LSTM, { .pat = "{%-" }, 3 }, + { TK_RSTM, { .pat = "-%}" }, 3 }, + { TK_EQS, { .pat = "===" }, 3 }, + { TK_NES, { .pat = "!==" }, 3 }, + { TK_ELLIP, { .pat = "..." }, 3 }, + { TK_AND, { .pat = "&&" }, 2 }, + { TK_ASADD, { .pat = "+=" }, 2 }, + { TK_ASBAND, { .pat = "&=" }, 2 }, + { TK_ASBOR, { .pat = "|=" }, 2 }, + { TK_ASBXOR, { .pat = "^=" }, 2 }, + //{ TK_ASDIV, { .pat = "/=" }, 2 }, + { TK_ASMOD, { .pat = "%=" }, 2 }, + { TK_ASMUL, { .pat = "*=" }, 2 }, + { TK_ASSUB, { .pat = "-=" }, 2 }, + { TK_DEC, { .pat = "--" }, 2 }, + { TK_INC, { .pat = "++" }, 2 }, + { TK_EQ, { .pat = "==" }, 2 }, + { TK_NE, { .pat = "!=" }, 2 }, + { TK_LE, { .pat = "<=" }, 2 }, + { TK_GE, { .pat = ">=" }, 2 }, + { TK_LSHIFT, { .pat = "<<" }, 2 }, + { TK_RSHIFT, { .pat = ">>" }, 2 }, { 0, { .pat = "//" }, 2, parse_comment }, { 0, { .pat = "/*" }, 2, parse_comment }, - { T_OR, { .pat = "||" }, 2 }, - { T_LEXP, { .pat = "{{" }, 2 }, - { T_REXP, { .pat = "}}" }, 2 }, - { T_LSTM, { .pat = "{%" }, 2 }, - { T_RSTM, { .pat = "%}" }, 2 }, - { T_ARROW, { .pat = "=>" }, 2 }, - { T_ADD, { .pat = "+" }, 1 }, - { T_ASSIGN, { .pat = "=" }, 1 }, - { T_BAND, { .pat = "&" }, 1 }, - { T_BOR, { .pat = "|" }, 1 }, - { T_LBRACK, { .pat = "[" }, 1 }, - { T_RBRACK, { .pat = "]" }, 1 }, - { T_BXOR, { .pat = "^" }, 1 }, - { T_LBRACE, { .pat = "{" }, 1 }, - { T_RBRACE, { .pat = "}" }, 1 }, - { T_COLON, { .pat = ":" }, 1 }, - { T_COMMA, { .pat = "," }, 1 }, - { T_COMPL, { .pat = "~" }, 1 }, - //{ T_DIV, { .pat = "/" }, 1 }, - { T_GT, { .pat = ">" }, 1 }, - { T_NOT, { .pat = "!" }, 1 }, - { T_LT, { .pat = "<" }, 1 }, - { T_MOD, { .pat = "%" }, 1 }, - { T_MUL, { .pat = "*" }, 1 }, - { T_LPAREN, { .pat = "(" }, 1 }, - { T_RPAREN, { .pat = ")" }, 1 }, - { T_QMARK, { .pat = "?" }, 1 }, - { T_SCOL, { .pat = ";" }, 1 }, - { T_SUB, { .pat = "-" }, 1 }, - { T_DOT, { .pat = "." }, 1 }, - { T_STRING, { .pat = "'" }, 1, parse_string }, - { T_STRING, { .pat = "\"" }, 1, parse_string }, - { T_REGEXP, { .pat = "/" }, 1, parse_regexp }, - { T_LABEL, { .pat = "_" }, 1, parse_label }, - { T_LABEL, { .pat = "az" }, 0, parse_label }, - { T_LABEL, { .pat = "AZ" }, 0, parse_label }, - { T_NUMBER, { .pat = "09" }, 0, parse_number }, + { TK_OR, { .pat = "||" }, 2 }, + { TK_LEXP, { .pat = "{{" }, 2 }, + { TK_REXP, { .pat = "}}" }, 2 }, + { TK_LSTM, { .pat = "{%" }, 2 }, + { TK_RSTM, { .pat = "%}" }, 2 }, + { TK_ARROW, { .pat = "=>" }, 2 }, + { TK_ADD, { .pat = "+" }, 1 }, + { TK_ASSIGN, { .pat = "=" }, 1 }, + { TK_BAND, { .pat = "&" }, 1 }, + { TK_BOR, { .pat = "|" }, 1 }, + { TK_LBRACK, { .pat = "[" }, 1 }, + { TK_RBRACK, { .pat = "]" }, 1 }, + { TK_BXOR, { .pat = "^" }, 1 }, + { TK_LBRACE, { .pat = "{" }, 1 }, + { TK_RBRACE, { .pat = "}" }, 1 }, + { TK_COLON, { .pat = ":" }, 1 }, + { TK_COMMA, { .pat = "," }, 1 }, + { TK_COMPL, { .pat = "~" }, 1 }, + //{ TK_DIV, { .pat = "/" }, 1 }, + { TK_GT, { .pat = ">" }, 1 }, + { TK_NOT, { .pat = "!" }, 1 }, + { TK_LT, { .pat = "<" }, 1 }, + { TK_MOD, { .pat = "%" }, 1 }, + { TK_MUL, { .pat = "*" }, 1 }, + { TK_LPAREN, { .pat = "(" }, 1 }, + { TK_RPAREN, { .pat = ")" }, 1 }, + { TK_QMARK, { .pat = "?" }, 1 }, + { TK_SCOL, { .pat = ";" }, 1 }, + //{ TK_SUB, { .pat = "-" }, 1 }, + { TK_DOT, { .pat = "." }, 1 }, + { TK_STRING, { .pat = "'" }, 1, parse_string }, + { TK_STRING, { .pat = "\"" }, 1, parse_string }, + { TK_REGEXP, { .pat = "/" }, 1, parse_regexp }, + { TK_LABEL, { .pat = "_" }, 1, parse_label }, + { TK_LABEL, { .pat = "az" }, 0, parse_label }, + { TK_LABEL, { .pat = "AZ" }, 0, parse_label }, + { TK_NUMBER, { .pat = "-" }, 1, parse_number }, + { TK_NUMBER, { .pat = "09" }, 0, parse_number }, }; static const struct keyword reserved_words[] = { - { T_ENDFUNC, "endfunction", 11 }, - { T_DOUBLE, "Infinity", 8, { .d = INFINITY } }, - { T_CONTINUE, "continue", 8 }, - { T_ENDWHILE, "endwhile", 8 }, - { T_FUNC, "function", 8 }, - { T_DEFAULT, "default", 7 }, - { T_RETURN, "return", 6 }, - { T_ENDFOR, "endfor", 6 }, - { T_SWITCH, "switch", 6 }, - { T_LOCAL, "local", 5 }, - { T_ENDIF, "endif", 5 }, - { T_WHILE, "while", 5 }, - { T_BREAK, "break", 5 }, - { T_CATCH, "catch", 5 }, - { T_BOOL, "false", 5, { .b = false } }, - { T_BOOL, "true", 4, { .b = true } }, - { T_ELIF, "elif", 4 }, - { T_ELSE, "else", 4 }, - { T_THIS, "this", 4 }, - { T_NULL, "null", 4 }, - { T_CASE, "case", 4 }, - { T_DOUBLE, "NaN", 3, { .d = NAN } }, - { T_TRY, "try", 3 }, - { T_FOR, "for", 3 }, - { T_LOCAL, "let", 3 }, - { T_IF, "if", 2 }, - { T_IN, "in", 2 }, + { TK_ENDFUNC, "endfunction", 11 }, + { TK_DOUBLE, "Infinity", 8, { .d = INFINITY } }, + { TK_CONTINUE, "continue", 8 }, + { TK_ENDWHILE, "endwhile", 8 }, + { TK_FUNC, "function", 8 }, + { TK_DEFAULT, "default", 7 }, + { TK_RETURN, "return", 6 }, + { TK_ENDFOR, "endfor", 6 }, + { TK_SWITCH, "switch", 6 }, + { TK_LOCAL, "local", 5 }, + { TK_ENDIF, "endif", 5 }, + { TK_WHILE, "while", 5 }, + { TK_BREAK, "break", 5 }, + { TK_CATCH, "catch", 5 }, + { TK_BOOL, "false", 5, { .b = false } }, + { TK_BOOL, "true", 4, { .b = true } }, + { TK_ELIF, "elif", 4 }, + { TK_ELSE, "else", 4 }, + { TK_THIS, "this", 4 }, + { TK_NULL, "null", 4 }, + { TK_CASE, "case", 4 }, + { TK_DOUBLE, "NaN", 3, { .d = NAN } }, + { TK_TRY, "try", 3 }, + { TK_FOR, "for", 3 }, + { TK_LOCAL, "let", 3 }, + { TK_IF, "if", 2 }, + { TK_IN, "in", 2 }, }; @@ -221,125 +222,216 @@ utf8enc(char **out, int *rem, int code) /* length of the longest token in our lookup table */ #define UT_LEX_MAX_TOKEN_LEN 3 -static uint32_t emit_op(struct uc_state *state, uint32_t pos, int type, struct json_object *val) +static uc_token * +emit_op(uc_lexer *lex, uint32_t pos, int type, struct json_object *val) { - uint32_t off = uc_new_op(state, type, val, UINT32_MAX); - - OP(off)->off = pos; + lex->curr.type = type; + lex->curr.val = val; + lex->curr.pos = pos; /* Follow JSLint logic and treat a slash after any of the * `(,=:[!&|?{};` characters as the beginning of a regex * literal... */ switch (type) { - case T_LPAREN: - case T_COMMA: - - case T_ASADD: - case T_ASBAND: - case T_ASBOR: - case T_ASBXOR: - case T_ASDIV: - case T_ASLEFT: - case T_ASMOD: - case T_ASMUL: - case T_ASRIGHT: - case T_ASSIGN: - case T_ASSUB: - case T_EQ: - case T_EQS: - case T_GE: - case T_LE: - case T_NE: - case T_NES: - - case T_COLON: - case T_LBRACK: - case T_NOT: - - case T_AND: - case T_BAND: - - case T_OR: - case T_BOR: - - case T_QMARK: - - case T_LBRACE: - case T_RBRACE: - - case T_LSTM: - case T_LEXP: - - case T_SCOL: - state->lex.expect_div = false; + case TK_LPAREN: + case TK_COMMA: + + case TK_ASADD: + case TK_ASBAND: + case TK_ASBOR: + case TK_ASBXOR: + case TK_ASDIV: + case TK_ASLEFT: + case TK_ASMOD: + case TK_ASMUL: + case TK_ASRIGHT: + case TK_ASSIGN: + case TK_ASSUB: + case TK_EQ: + case TK_EQS: + case TK_GE: + case TK_LE: + case TK_NE: + case TK_NES: + + case TK_COLON: + case TK_LBRACK: + case TK_NOT: + + case TK_AND: + case TK_BAND: + + case TK_OR: + case TK_BOR: + + case TK_QMARK: + + case TK_LBRACE: + case TK_RBRACE: + + case TK_LSTM: + case TK_LEXP: + + case TK_SCOL: + lex->expect_div = false; break; default: - state->lex.expect_div = true; + lex->expect_div = true; } - return off; + return &lex->curr; } -static void lookbehind_append(struct uc_state *s, const char *data, size_t len) +static void lookbehind_append(uc_lexer *lex, const char *data, size_t len) { if (len) { - s->lex.lookbehind = xrealloc(s->lex.lookbehind, s->lex.lookbehindlen + len); - memcpy(s->lex.lookbehind + s->lex.lookbehindlen, data, len); - s->lex.lookbehindlen += len; + lex->lookbehind = xrealloc(lex->lookbehind, lex->lookbehindlen + len); + memcpy(lex->lookbehind + lex->lookbehindlen, data, len); + lex->lookbehindlen += len; } } -static void lookbehind_reset(struct uc_state *s) { - free(s->lex.lookbehind); - s->lex.lookbehind = NULL; - s->lex.lookbehindlen = 0; +static void lookbehind_reset(uc_lexer *lex) { + free(lex->lookbehind); + lex->lookbehind = NULL; + lex->lookbehindlen = 0; } -static uint32_t lookbehind_to_text(struct uc_state *s, uint32_t pos, int type, const char *strip_trailing_chars) { - uint32_t rv = 0; +static uc_token * +lookbehind_to_text(uc_lexer *lex, uint32_t pos, int type, const char *strip_trailing_chars) { + uc_token *rv = NULL; - if (s->lex.lookbehind) { + if (lex->lookbehind) { if (strip_trailing_chars) { - while (s->lex.lookbehindlen > 0 && strchr(strip_trailing_chars, s->lex.lookbehind[s->lex.lookbehindlen-1])) - s->lex.lookbehindlen--; + while (lex->lookbehindlen > 0 && strchr(strip_trailing_chars, lex->lookbehind[lex->lookbehindlen-1])) + lex->lookbehindlen--; } - rv = emit_op(s, pos, type, xjs_new_string_len(s->lex.lookbehind, s->lex.lookbehindlen)); + rv = emit_op(lex, pos, type, xjs_new_string_len(lex->lookbehind, lex->lookbehindlen)); - lookbehind_reset(s); + lookbehind_reset(lex); } return rv; } -static inline size_t buf_remaining(struct uc_state *s) { - return (s->lex.bufend - s->lex.bufstart); +static inline size_t +buf_remaining(uc_lexer *lex) { + return (lex->bufend - lex->bufstart); } -static inline bool _buf_startswith(struct uc_state *s, const char *str, size_t len) { - return (buf_remaining(s) >= len && !strncmp(s->lex.bufstart, str, len)); +static inline bool +_buf_startswith(uc_lexer *lex, const char *str, size_t len) { + return (buf_remaining(lex) >= len && !strncmp(lex->bufstart, str, len)); } #define buf_startswith(s, str) _buf_startswith(s, str, sizeof(str) - 1) -static void buf_consume(struct uc_state *s, ssize_t len) { - s->lex.bufstart += len; - s->source->off += len; +#if 0 +static void add_lineinfo(struct uc_state *s, size_t off) +{ + uc_lineinfo *lines = &s->source->lineinfo; + size_t linelen; + + linelen = off - s->lex.lastlineoff; + + /* lineinfo is encoded in bytes: the most significant bit specifies whether + * to advance the line count by one or not, while the remaining 7 bits encode + * the amounts of bytes on the current line. + * + * If a line has more than 127 characters, the first byte will be set to + * 0xff (1 1111111) and subsequent bytes will encode the remaining characters + * in bits 1..7 while setting bit 8 to 0. A line with 400 characters will thus + * be encoded as 0xff 0x7f 0x7f 0x13 (1:1111111 + 0:1111111 + 0:1111111 + 0:1111111). + * + * The newline character itself is not counted, so an empty line is encoded as + * 0x80 (1:0000000). + */ + uc_vector_grow(lines); + lines->entries[lines->count++] = 0x80 + (linelen & 0x7f); + linelen -= (linelen & 0x7f); + + while (linelen > 0) { + uc_vector_grow(lines); + lines->entries[lines->count++] = (linelen & 0x7f); + linelen -= (linelen & 0x7f); + } + + s->lex.lastlineoff = off + 1; + s->lex.line++; } +#endif -static uint32_t -parse_comment(struct uc_state *s) +static void +next_lineinfo(uc_lexer *lex) { - const struct token *tok = s->lex.tok; - const char *ptr, *end; - size_t elen; + uc_lineinfo *lines = &lex->source->lineinfo; - if (!buf_remaining(s)) { - uc_new_exception(s, s->lex.lastoff, "Syntax error: Unterminated comment"); + uc_vector_grow(lines); + lines->entries[lines->count++] = 0x80; +} + +static void +update_lineinfo(uc_lexer *lex, size_t off) +{ + uc_lineinfo *lines = &lex->source->lineinfo; + uint8_t *entry; - return 0; + entry = uc_vector_last(lines); + + if ((entry[0] & 0x7f) + off <= 0x7f) { + entry[0] += off; } + else { + off -= (0x7f - (entry[0] & 0x7f)); + entry[0] |= 0x7f; + + while (off > 0) { + uc_vector_grow(lines); + entry = uc_vector_last(lines); + entry[1] = (off & 0x7f); + off -= (off & 0x7f); + lines->count++; + } + } +} + +static void +buf_consume(uc_lexer *lex, size_t len) { + size_t i, linelen; + + if (!lex->source->lineinfo.count) + next_lineinfo(lex); + + for (i = 0, linelen = 0; i < len; i++) { + if (lex->bufstart[i] == '\n') { + update_lineinfo(lex, linelen); + next_lineinfo(lex); + + linelen = 0; + } + else { + linelen++; + } + } + + if (linelen) + update_lineinfo(lex, linelen); + + lex->bufstart += len; + lex->source->off += len; +} + +static uc_token * +parse_comment(uc_lexer *lex) +{ + const struct token *tok = lex->tok; + const char *ptr, *end; + size_t elen; + + if (!buf_remaining(lex)) + return emit_op(lex, lex->lastoff, TK_ERROR, xjs_new_string("Unterminated comment")); if (!strcmp(tok->pat, "//")) { end = "\n"; @@ -350,20 +442,21 @@ parse_comment(struct uc_state *s) elen = 2; } - for (ptr = s->lex.bufstart; ptr < s->lex.bufend - elen; ptr++) { + for (ptr = lex->bufstart; ptr < lex->bufend - elen; ptr++) { if (!strncmp(ptr, end, elen)) { - buf_consume(s, (ptr - s->lex.bufstart) + elen); + buf_consume(lex, (ptr - lex->bufstart) + elen); - return UINT32_MAX; + return UC_LEX_CONTINUE_PARSING; } } - buf_consume(s, ptr - s->lex.bufstart); + buf_consume(lex, ptr - lex->bufstart); - return 0; + return NULL; } -static void append_utf8(struct uc_state *s, int code) { +static void +append_utf8(uc_lexer *lex, int code) { char ustr[8], *up; int rem; @@ -371,38 +464,35 @@ static void append_utf8(struct uc_state *s, int code) { rem = sizeof(ustr); if (utf8enc(&up, &rem, code)) - lookbehind_append(s, ustr, up - ustr); + lookbehind_append(lex, ustr, up - ustr); } -static uint32_t -parse_string(struct uc_state *s) +static uc_token * +parse_string(uc_lexer *lex) { - const struct token *tok = s->lex.tok; + const struct token *tok = lex->tok; char q = tok->pat[0]; char *ptr, *c; - uint32_t rv; + uc_token *rv; int code; - if (!buf_remaining(s)) { - uc_new_exception(s, s->lex.lastoff, "Syntax error: Unterminated string"); - - return 0; - } + if (!buf_remaining(lex)) + return emit_op(lex, lex->lastoff, TK_ERROR, xjs_new_string("Unterminated string")); - for (ptr = s->lex.bufstart; ptr < s->lex.bufend; ptr++) { + for (ptr = lex->bufstart; ptr < lex->bufend; ptr++) { /* continuation of escape sequence */ - if (s->lex.is_escape) { - if (s->lex.esclen == 0) { + if (lex->is_escape) { + if (lex->esclen == 0) { /* non-unicode escape following a lead surrogate, emit replacement... */ - if (s->lex.lead_surrogate && *ptr != 'u') { - append_utf8(s, 0xFFFD); - s->lex.lead_surrogate = 0; + if (lex->lead_surrogate && *ptr != 'u') { + append_utf8(lex, 0xFFFD); + lex->lead_surrogate = 0; } switch ((q == '/') ? 0 : *ptr) { case 'u': case 'x': - s->lex.esc[s->lex.esclen++] = *ptr; + lex->esc[lex->esclen++] = *ptr; break; case '0': @@ -413,65 +503,62 @@ parse_string(struct uc_state *s) case '5': case '6': case '7': - s->lex.esc[s->lex.esclen++] = 'o'; - s->lex.esc[s->lex.esclen++] = *ptr; + lex->esc[lex->esclen++] = 'o'; + lex->esc[lex->esclen++] = *ptr; break; default: - s->lex.is_escape = false; + lex->is_escape = false; c = strchr("a\ab\be\ef\fn\nr\rt\tv\v", *ptr); if (c && *c >= 'a') { - lookbehind_append(s, c + 1, 1); + lookbehind_append(lex, c + 1, 1); } else { /* regex mode => retain backslash */ if (q == '/') - lookbehind_append(s, "\\", 1); + lookbehind_append(lex, "\\", 1); - lookbehind_append(s, ptr, 1); + lookbehind_append(lex, ptr, 1); } - buf_consume(s, (ptr + 1) - s->lex.bufstart); + buf_consume(lex, (ptr + 1) - lex->bufstart); break; } } else { - switch (s->lex.esc[0]) { + switch (lex->esc[0]) { case 'u': - if (s->lex.esclen < 5) { - if (!isxdigit(*ptr)) { - uc_new_exception(s, s->source->off + s->lex.esclen + 1, "Syntax error: Invalid escape sequence"); + if (lex->esclen < 5) { + if (!isxdigit(*ptr)) + return emit_op(lex, lex->source->off + lex->esclen + 1, TK_ERROR, xjs_new_string("Invalid escape sequence")); - return 0; - } - - s->lex.esc[s->lex.esclen++] = *ptr; + lex->esc[lex->esclen++] = *ptr; } - if (s->lex.esclen == 5) { - code = hex(s->lex.esc[1]) * 16 * 16 * 16 + - hex(s->lex.esc[2]) * 16 * 16 + - hex(s->lex.esc[3]) * 16 + - hex(s->lex.esc[4]); + if (lex->esclen == 5) { + code = hex(lex->esc[1]) * 16 * 16 * 16 + + hex(lex->esc[2]) * 16 * 16 + + hex(lex->esc[3]) * 16 + + hex(lex->esc[4]); /* is a leading surrogate value */ if ((code & 0xFC00) == 0xD800) { /* found a subsequent leading surrogate, ignore and emit replacement char for previous one */ - if (s->lex.lead_surrogate) - append_utf8(s, 0xFFFD); + if (lex->lead_surrogate) + append_utf8(lex, 0xFFFD); /* store surrogate value and advance to next escape sequence */ - s->lex.lead_surrogate = code; + lex->lead_surrogate = code; } /* is a trailing surrogate value */ else if ((code & 0xFC00) == 0xDC00) { /* found a trailing surrogate following a leading one, combine and encode */ - if (s->lex.lead_surrogate) { - code = 0x10000 + ((s->lex.lead_surrogate & 0x3FF) << 10) + (code & 0x3FF); - s->lex.lead_surrogate = 0; + if (lex->lead_surrogate) { + code = 0x10000 + ((lex->lead_surrogate & 0x3FF) << 10) + (code & 0x3FF); + lex->lead_surrogate = 0; } /* trailing surrogate not following a leading one, ignore and use replacement char */ @@ -479,87 +566,81 @@ parse_string(struct uc_state *s) code = 0xFFFD; } - append_utf8(s, code); + append_utf8(lex, code); } /* is a normal codepoint */ else { - append_utf8(s, code); + append_utf8(lex, code); } - s->lex.esclen = 0; - s->lex.is_escape = false; - buf_consume(s, (ptr + 1) - s->lex.bufstart); + lex->esclen = 0; + lex->is_escape = false; + buf_consume(lex, (ptr + 1) - lex->bufstart); } break; case 'x': - if (s->lex.esclen < 3) { - if (!isxdigit(*ptr)) { - uc_new_exception(s, s->source->off + s->lex.esclen + 1, "Syntax error: Invalid escape sequence"); - - return 0; - } + if (lex->esclen < 3) { + if (!isxdigit(*ptr)) + return emit_op(lex, lex->source->off + lex->esclen + 1, TK_ERROR, xjs_new_string("Invalid escape sequence")); - s->lex.esc[s->lex.esclen++] = *ptr; + lex->esc[lex->esclen++] = *ptr; } - if (s->lex.esclen == 3) { - append_utf8(s, hex(s->lex.esc[1]) * 16 + hex(s->lex.esc[2])); + if (lex->esclen == 3) { + append_utf8(lex, hex(lex->esc[1]) * 16 + hex(lex->esc[2])); - s->lex.esclen = 0; - s->lex.is_escape = false; - buf_consume(s, (ptr + 1) - s->lex.bufstart); + lex->esclen = 0; + lex->is_escape = false; + buf_consume(lex, (ptr + 1) - lex->bufstart); } break; case 'o': - if (s->lex.esclen < 4) { + if (lex->esclen < 4) { /* found a non-octal char */ if (*ptr < '0' || *ptr > '7') { /* pad sequence to three chars */ - switch (s->lex.esclen) { + switch (lex->esclen) { case 3: - s->lex.esc[3] = s->lex.esc[2]; - s->lex.esc[2] = s->lex.esc[1]; - s->lex.esc[1] = '0'; + lex->esc[3] = lex->esc[2]; + lex->esc[2] = lex->esc[1]; + lex->esc[1] = '0'; break; case 2: - s->lex.esc[3] = s->lex.esc[1]; - s->lex.esc[2] = '0'; - s->lex.esc[1] = '0'; + lex->esc[3] = lex->esc[1]; + lex->esc[2] = '0'; + lex->esc[1] = '0'; break; } - s->lex.esclen = 4; - buf_consume(s, ptr-- - s->lex.bufstart); + lex->esclen = 4; + buf_consume(lex, ptr-- - lex->bufstart); } /* append */ else { - s->lex.esc[s->lex.esclen++] = *ptr; - buf_consume(s, (ptr + 1) - s->lex.bufstart); + lex->esc[lex->esclen++] = *ptr; + buf_consume(lex, (ptr + 1) - lex->bufstart); } } - if (s->lex.esclen == 4) { - code = dec(s->lex.esc[1]) * 8 * 8 + - dec(s->lex.esc[2]) * 8 + - dec(s->lex.esc[3]); + if (lex->esclen == 4) { + code = dec(lex->esc[1]) * 8 * 8 + + dec(lex->esc[2]) * 8 + + dec(lex->esc[3]); - if (code > 255) { - uc_new_exception(s, s->source->off + s->lex.esclen + 1, "Syntax error: Invalid escape sequence"); + if (code > 255) + return emit_op(lex, lex->source->off + lex->esclen + 1, TK_ERROR, xjs_new_string("Invalid escape sequence")); - return 0; - } - - append_utf8(s, code); + append_utf8(lex, code); - s->lex.esclen = 0; - s->lex.is_escape = false; + lex->esclen = 0; + lex->is_escape = false; } break; @@ -569,29 +650,29 @@ parse_string(struct uc_state *s) /* terminating char */ else if (*ptr == q) { - lookbehind_append(s, s->lex.bufstart, ptr - s->lex.bufstart); - buf_consume(s, (ptr + 1) - s->lex.bufstart); + lookbehind_append(lex, lex->bufstart, ptr - lex->bufstart); + buf_consume(lex, (ptr + 1) - lex->bufstart); - rv = lookbehind_to_text(s, s->lex.lastoff, T_STRING, NULL); + rv = lookbehind_to_text(lex, lex->lastoff, TK_STRING, NULL); if (!rv) - rv = emit_op(s, s->lex.lastoff, T_STRING, xjs_new_string_len("", 0)); + rv = emit_op(lex, lex->lastoff, TK_STRING, xjs_new_string_len("", 0)); return rv; } /* escape sequence start */ else if (*ptr == '\\') { - s->lex.is_escape = true; - lookbehind_append(s, s->lex.bufstart, ptr - s->lex.bufstart); - buf_consume(s, ptr - s->lex.bufstart); + lex->is_escape = true; + lookbehind_append(lex, lex->bufstart, ptr - lex->bufstart); + buf_consume(lex, ptr - lex->bufstart); } } - lookbehind_append(s, s->lex.bufstart, ptr - s->lex.bufstart); - buf_consume(s, ptr - s->lex.bufstart); + lookbehind_append(lex, lex->bufstart, ptr - lex->bufstart); + buf_consume(lex, ptr - lex->bufstart); - return 0; + return NULL; } @@ -614,90 +695,85 @@ enum { UT_LEX_PARSE_REGEX_FLAGS }; -static uint32_t -parse_regexp(struct uc_state *state) +static uc_token * +parse_regexp(uc_lexer *lex) { - struct json_object *pattern; - struct uc_op *op; - uint32_t rv; - char *err; + bool is_reg_global = false, is_reg_icase = false, is_reg_newline = false; + uc_token *rv; + size_t len; + char *s; - switch (state->lex.esc[0]) { + switch (lex->esc[0]) { case UT_LEX_PARSE_REGEX_INIT: - if (state->lex.expect_div) { - state->lex.expect_div = false; + if (lex->expect_div) { + lex->expect_div = false; - if (buf_startswith(state, "=")) { - buf_consume(state, 1); + if (buf_startswith(lex, "=")) { + buf_consume(lex, 1); - return emit_op(state, state->source->off, T_ASDIV, NULL); + return emit_op(lex, lex->source->off, TK_ASDIV, NULL); } - return emit_op(state, state->source->off, T_DIV, NULL); + return emit_op(lex, lex->source->off, TK_DIV, NULL); } - state->lex.esc[0] = UT_LEX_PARSE_REGEX_PATTERN; + lex->esc[0] = UT_LEX_PARSE_REGEX_PATTERN; break; case UT_LEX_PARSE_REGEX_PATTERN: - rv = parse_string(state); + rv = parse_string(lex); - if (rv != 0 && rv != UINT32_MAX) { - state->lex.lookbehind = (char *)OP(rv); - state->lex.esc[0] = UT_LEX_PARSE_REGEX_FLAGS; + if (rv && rv->type == TK_ERROR) + return rv; + + if (rv != NULL && rv != UC_LEX_CONTINUE_PARSING) { + lex->lookbehind = (char *)rv; + lex->esc[0] = UT_LEX_PARSE_REGEX_FLAGS; } break; case UT_LEX_PARSE_REGEX_FLAGS: - op = (struct uc_op *)state->lex.lookbehind; + rv = (uc_token *)lex->lookbehind; - while (state->lex.bufstart < state->lex.bufend) { - switch (state->lex.bufstart[0]) { + while (lex->bufstart < lex->bufend) { + switch (lex->bufstart[0]) { case 'g': - buf_consume(state, 1); - op->is_reg_global = true; + buf_consume(lex, 1); + is_reg_global = true; break; case 'i': - buf_consume(state, 1); - op->is_reg_icase = true; + buf_consume(lex, 1); + is_reg_icase = true; break; case 's': - buf_consume(state, 1); - op->is_reg_newline = true; + buf_consume(lex, 1); + is_reg_newline = true; break; default: - state->lex.lookbehind = NULL; - - pattern = uc_new_regexp(json_object_get_string(op->val), - op->is_reg_icase, - op->is_reg_newline, - op->is_reg_global, - &err); + lex->lookbehind = NULL; - json_object_put(op->val); + len = xasprintf(&s, "%c%*s", + (is_reg_global << 0) | (is_reg_icase << 1) | (is_reg_newline << 2), + json_object_get_string_len(rv->val), + json_object_get_string(rv->val)); - op->type = T_REGEXP; - op->val = pattern; + json_object_set_string_len(rv->val, s, len); + free(s); - if (!pattern) { - uc_new_exception(state, op->off, "Syntax error: %s", err); - free(err); + rv->type = TK_REGEXP; - return 0; - } - - return op - state->pool; + return rv; } } break; } - return 0; + return NULL; } @@ -711,50 +787,50 @@ parse_regexp(struct uc_state *state) * -UT_ERROR_OVERLONG_STRING Label too long */ -static uint32_t -parse_label(struct uc_state *s) +static uc_token * +parse_label(uc_lexer *lex) { - const struct token *tok = s->lex.tok; + const struct token *tok = lex->tok; const struct keyword *word; - uint32_t rv; + uc_token *rv; char *ptr; size_t i; - if (!s->lex.lookbehind && tok->plen) - lookbehind_append(s, tok->pat, tok->plen); + if (!lex->lookbehind && tok->plen) + lookbehind_append(lex, tok->pat, tok->plen); - if (!buf_remaining(s) || (s->lex.bufstart[0] != '_' && !isalnum(s->lex.bufstart[0]))) { + if (!buf_remaining(lex) || (lex->bufstart[0] != '_' && !isalnum(lex->bufstart[0]))) { for (i = 0, word = &reserved_words[0]; i < ARRAY_SIZE(reserved_words); i++, word = &reserved_words[i]) { - if (s->lex.lookbehindlen == word->plen && !strncmp(s->lex.lookbehind, word->pat, word->plen)) { - lookbehind_reset(s); + if (lex->lookbehindlen == word->plen && !strncmp(lex->lookbehind, word->pat, word->plen)) { + lookbehind_reset(lex); switch (word->type) { - case T_DOUBLE: - rv = emit_op(s, s->source->off - word->plen, word->type, uc_new_double(word->d)); + case TK_DOUBLE: + rv = emit_op(lex, lex->source->off - word->plen, word->type, uc_double_new(word->d)); break; - case T_BOOL: - rv = emit_op(s, s->source->off - word->plen, word->type, xjs_new_boolean(word->b)); + case TK_BOOL: + rv = emit_op(lex, lex->source->off - word->plen, word->type, xjs_new_boolean(word->b)); break; default: - rv = emit_op(s, s->source->off - word->plen, word->type, NULL); + rv = emit_op(lex, lex->source->off - word->plen, word->type, NULL); } return rv; } } - return lookbehind_to_text(s, s->source->off - s->lex.lookbehindlen, T_LABEL, NULL); + return lookbehind_to_text(lex, lex->source->off - lex->lookbehindlen, TK_LABEL, NULL); } - for (ptr = s->lex.bufstart; ptr < s->lex.bufend && (*ptr == '_' || isalnum(*ptr)); ptr++) + for (ptr = lex->bufstart; ptr < lex->bufend && (*ptr == '_' || isalnum(*ptr)); ptr++) ; - lookbehind_append(s, s->lex.bufstart, ptr - s->lex.bufstart); - buf_consume(s, ptr - s->lex.bufstart); + lookbehind_append(lex, lex->bufstart, ptr - lex->bufstart); + buf_consume(lex, ptr - lex->bufstart); - return 0; + return NULL; } @@ -769,198 +845,206 @@ parse_label(struct uc_state *s) */ static inline bool -is_numeric_char(struct uc_state *s, char c) +is_numeric_char(uc_lexer *lex, char c) { - char prev = s->lex.lookbehindlen ? s->lex.lookbehind[s->lex.lookbehindlen-1] : 0; + char prev = lex->lookbehindlen ? lex->lookbehind[lex->lookbehindlen-1] : 0; if ((prev == 'e' || prev == 'E') && (c == '-' || c == '+')) return true; - return (isxdigit(c) || c == 'x' || c == 'X' || c == '.'); + return prev ? (isxdigit(c) || c == 'x' || c == 'X' || c == '.') : (isdigit(c) || c == '.'); } -static uint32_t -parse_number(struct uc_state *state) +static uc_token * +parse_number(uc_lexer *lex) { - uint32_t rv = 0; + const struct token *tok = lex->tok; + uc_token *rv = NULL; long long int n; char *ptr, *e; double d; - if (!buf_remaining(state) || !is_numeric_char(state, state->lex.bufstart[0])) { - lookbehind_append(state, "\0", 1); + if (!buf_remaining(lex) || !is_numeric_char(lex, lex->bufstart[0])) { + if (lex->lookbehindlen == 0 && !is_numeric_char(lex, lex->bufstart[0])) + return emit_op(lex, lex->source->off, TK_SUB, NULL); - n = strtoll(state->lex.lookbehind, &e, 0); + lookbehind_append(lex, "\0", 1); + + n = strtoll(lex->lookbehind, &e, 0); if (*e == '.' || *e == 'e' || *e == 'E') { - d = strtod(state->lex.lookbehind, &e); + d = strtod(lex->lookbehind, &e); + + if (tok->pat[0] == '-') + d = -d; - if (e > state->lex.lookbehind && *e == 0) - rv = emit_op(state, state->source->off - (e - state->lex.lookbehind), T_DOUBLE, uc_new_double(d)); + if (e > lex->lookbehind && *e == 0) + rv = emit_op(lex, lex->source->off - (e - lex->lookbehind), TK_DOUBLE, uc_double_new(d)); else - uc_new_exception(state, state->source->off - (state->lex.lookbehindlen - (e - state->lex.lookbehind) - 1), - "Syntax error: Invalid number literal"); + rv = emit_op(lex, lex->source->off - (lex->lookbehindlen - (e - lex->lookbehind) - 1), TK_ERROR, xjs_new_string("Invalid number literal")); } else if (*e == 0) { - rv = emit_op(state, state->source->off - (e - state->lex.lookbehind), T_NUMBER, xjs_new_int64(n)); - OP(rv)->is_overflow = (errno == ERANGE); + if (tok->pat[0] == '-') + n = (errno == ERANGE) ? INT64_MIN : -n; + + rv = emit_op(lex, lex->source->off - (e - lex->lookbehind), TK_NUMBER, xjs_new_int64(n)); + //OP(rv)->is_overflow = (errno == ERANGE); } else { - uc_new_exception(state, state->source->off - (state->lex.lookbehindlen - (e - state->lex.lookbehind) - 1), - "Syntax error: Invalid number literal"); + rv = emit_op(lex, lex->source->off - (lex->lookbehindlen - (e - lex->lookbehind) - 1), TK_ERROR, xjs_new_string("Invalid number literal")); } - lookbehind_reset(state); + lookbehind_reset(lex); return rv; } - for (ptr = state->lex.bufstart; ptr < state->lex.bufend && is_numeric_char(state, *ptr); ptr++) + for (ptr = lex->bufstart; ptr < lex->bufend && is_numeric_char(lex, *ptr); ptr++) ; - lookbehind_append(state, state->lex.bufstart, ptr - state->lex.bufstart); - buf_consume(state, ptr - state->lex.bufstart); + lookbehind_append(lex, lex->bufstart, ptr - lex->bufstart); + buf_consume(lex, ptr - lex->bufstart); - return 0; + return NULL; } -static uint32_t -lex_step(struct uc_state *s, FILE *fp) +static uc_token * +lex_step(uc_lexer *lex, FILE *fp) { uint32_t masks[] = { 0, le32toh(0x000000ff), le32toh(0x0000ffff), le32toh(0x00ffffff), le32toh(0xffffffff) }; union { uint32_t n; char str[4]; } search; const struct token *tok; size_t rlen, rem; char *ptr, c; - uint32_t rv; + uc_token *rv; size_t i; /* only less than UT_LEX_MAX_TOKEN_LEN unreach buffer chars remaining, * move the remaining bytes to the beginning and read more data */ - if (buf_remaining(s) < UT_LEX_MAX_TOKEN_LEN) { - if (!s->lex.buf) { - s->lex.buflen = 128; - s->lex.buf = xalloc(s->lex.buflen); + if (buf_remaining(lex) < UT_LEX_MAX_TOKEN_LEN) { + if (!lex->buf) { + lex->buflen = 128; + lex->buf = xalloc(lex->buflen); } - rem = s->lex.bufend - s->lex.bufstart; + rem = lex->bufend - lex->bufstart; - memcpy(s->lex.buf, s->lex.bufstart, rem); + memcpy(lex->buf, lex->bufstart, rem); - rlen = fread(s->lex.buf + rem, 1, s->lex.buflen - rem, fp); + rlen = fread(lex->buf + rem, 1, lex->buflen - rem, fp); - s->lex.bufstart = s->lex.buf; - s->lex.bufend = s->lex.buf + rlen + rem; + lex->bufstart = lex->buf; + lex->bufend = lex->buf + rlen + rem; if (rlen == 0 && (ferror(fp) || feof(fp))) - s->lex.eof = 1; + lex->eof = 1; } - switch (s->lex.state) { + switch (lex->state) { case UT_LEX_IDENTIFY_BLOCK: /* previous block had strip trailing whitespace flag, skip leading whitespace */ - if (s->lex.skip_leading_whitespace) { - while (buf_remaining(s) && isspace(s->lex.bufstart[0])) - buf_consume(s, 1); + if (lex->skip_leading_whitespace) { + while (buf_remaining(lex) && isspace(lex->bufstart[0])) + buf_consume(lex, 1); - s->lex.skip_leading_whitespace = false; + lex->skip_leading_whitespace = false; } /* previous block was a statement block and trim_blocks is enabld, skip leading newline */ - else if (s->lex.skip_leading_newline) { - if (buf_startswith(s, "\n")) - buf_consume(s, 1); + else if (lex->skip_leading_newline) { + if (buf_startswith(lex, "\n")) + buf_consume(lex, 1); - s->lex.skip_leading_newline = false; + lex->skip_leading_newline = false; } /* scan forward through buffer to identify start token */ - for (ptr = s->lex.bufstart; ptr < s->lex.bufend - strlen("{#"); ptr++) { + for (ptr = lex->bufstart; ptr < lex->bufend - strlen("{#"); ptr++) { /* found start of comment block */ if (!strncmp(ptr, "{#", 2)) { - lookbehind_append(s, s->lex.bufstart, ptr - s->lex.bufstart); - buf_consume(s, (ptr + 2) - s->lex.bufstart); - s->lex.lastoff = s->source->off - 2; - s->lex.state = UT_LEX_BLOCK_COMMENT_START; + lookbehind_append(lex, lex->bufstart, ptr - lex->bufstart); + buf_consume(lex, (ptr + 2) - lex->bufstart); + lex->lastoff = lex->source->off - 2; + lex->state = UT_LEX_BLOCK_COMMENT_START; - return 0; + return NULL; } /* found start of expression block */ else if (!strncmp(ptr, "{{", 2)) { - lookbehind_append(s, s->lex.bufstart, ptr - s->lex.bufstart); - buf_consume(s, (ptr + 2) - s->lex.bufstart); - s->lex.lastoff = s->source->off - 2; - s->lex.state = UT_LEX_BLOCK_EXPRESSION_START; + lookbehind_append(lex, lex->bufstart, ptr - lex->bufstart); + buf_consume(lex, (ptr + 2) - lex->bufstart); + lex->lastoff = lex->source->off - 2; + lex->state = UT_LEX_BLOCK_EXPRESSION_START; - return 0; + return NULL; } /* found start of statement block */ else if (!strncmp(ptr, "{%", 2)) { - lookbehind_append(s, s->lex.bufstart, ptr - s->lex.bufstart); - buf_consume(s, (ptr + 2) - s->lex.bufstart); - s->lex.lastoff = s->source->off - 2; - s->lex.state = UT_LEX_BLOCK_STATEMENT_START; + lookbehind_append(lex, lex->bufstart, ptr - lex->bufstart); + buf_consume(lex, (ptr + 2) - lex->bufstart); + lex->lastoff = lex->source->off - 2; + lex->state = UT_LEX_BLOCK_STATEMENT_START; - return 0; + return NULL; } } /* we're at eof */ - if (s->lex.eof) { - lookbehind_append(s, ptr, s->lex.bufend - ptr); - s->lex.state = UT_LEX_EOF; + if (lex->eof) { + lookbehind_append(lex, ptr, lex->bufend - ptr); + lex->state = UT_LEX_EOF; - return lookbehind_to_text(s, s->lex.lastoff, T_TEXT, NULL); + return lookbehind_to_text(lex, lex->lastoff, TK_TEXT, NULL); } - lookbehind_append(s, s->lex.bufstart, ptr - s->lex.bufstart); - buf_consume(s, ptr - s->lex.bufstart); + lookbehind_append(lex, lex->bufstart, ptr - lex->bufstart); + buf_consume(lex, ptr - lex->bufstart); break; case UT_LEX_BLOCK_COMMENT_START: case UT_LEX_BLOCK_EXPRESSION_START: case UT_LEX_BLOCK_STATEMENT_START: - rv = 0; - s->lex.skip_leading_whitespace = 0; + rv = NULL; + lex->skip_leading_whitespace = 0; /* strip whitespace before block */ - if (buf_startswith(s, "-")) { - rv = lookbehind_to_text(s, s->source->off, T_TEXT, " \n\t\v\f\r"); - buf_consume(s, 1); + if (buf_startswith(lex, "-")) { + rv = lookbehind_to_text(lex, lex->source->off, TK_TEXT, " \n\t\v\f\r"); + buf_consume(lex, 1); } /* disable lstrip flag (only valid for statement blocks) */ - else if (s->lex.state == UT_LEX_BLOCK_STATEMENT_START) { + else if (lex->state == UT_LEX_BLOCK_STATEMENT_START) { /* disable lstrip flag */ - if (buf_startswith(s, "+")) { - rv = lookbehind_to_text(s, s->source->off, T_TEXT, NULL); - buf_consume(s, 1); + if (buf_startswith(lex, "+")) { + rv = lookbehind_to_text(lex, lex->source->off, TK_TEXT, NULL); + buf_consume(lex, 1); } /* global block lstrip */ - else if (s->lstrip_blocks) { - rv = lookbehind_to_text(s, s->source->off, T_TEXT, " \t\v\f\r"); + else if (lex->config && lex->config->lstrip_blocks) { + rv = lookbehind_to_text(lex, lex->source->off, TK_TEXT, " \t\v\f\r"); } } else { - rv = lookbehind_to_text(s, s->source->off, T_TEXT, NULL); + rv = lookbehind_to_text(lex, lex->source->off, TK_TEXT, NULL); } - switch (s->lex.state) { + switch (lex->state) { case UT_LEX_BLOCK_COMMENT_START: - s->lex.state = UT_LEX_BLOCK_COMMENT; + lex->state = UT_LEX_BLOCK_COMMENT; break; case UT_LEX_BLOCK_STATEMENT_START: - s->lex.within_statement_block = 1; - s->lex.state = UT_LEX_IDENTIFY_TOKEN; + lex->within_statement_block = 1; + lex->state = UT_LEX_IDENTIFY_TOKEN; break; case UT_LEX_BLOCK_EXPRESSION_START: - s->lex.state = UT_LEX_BLOCK_EXPRESSION_EMIT_TAG; + lex->state = UT_LEX_BLOCK_EXPRESSION_EMIT_TAG; break; default: @@ -972,152 +1056,151 @@ lex_step(struct uc_state *s, FILE *fp) case UT_LEX_BLOCK_COMMENT: /* scan forward through buffer to identify end token */ - while (s->lex.bufstart < s->lex.bufend - 2) { - if (buf_startswith(s, "-#}")) { - s->lex.state = UT_LEX_IDENTIFY_BLOCK; - s->lex.skip_leading_whitespace = 1; - buf_consume(s, 3); - s->lex.lastoff = s->source->off; + while (lex->bufstart < lex->bufend - 2) { + if (buf_startswith(lex, "-#}")) { + lex->state = UT_LEX_IDENTIFY_BLOCK; + lex->skip_leading_whitespace = 1; + buf_consume(lex, 3); + lex->lastoff = lex->source->off; break; } - else if (buf_startswith(s, "#}")) { - s->lex.state = UT_LEX_IDENTIFY_BLOCK; - s->lex.skip_leading_whitespace = 0; - buf_consume(s, 2); - s->lex.lastoff = s->source->off; + else if (buf_startswith(lex, "#}")) { + lex->state = UT_LEX_IDENTIFY_BLOCK; + lex->skip_leading_whitespace = 0; + buf_consume(lex, 2); + lex->lastoff = lex->source->off; break; } - buf_consume(s, 1); + buf_consume(lex, 1); } /* we're at eof */ - if (s->lex.eof) - uc_new_exception(s, s->lex.lastoff, "Syntax error: Unterminated template block"); + if (lex->eof) { + lex->state = UT_LEX_EOF; + + buf_consume(lex, lex->bufend - lex->bufstart); + + return emit_op(lex, lex->lastoff, TK_ERROR, xjs_new_string("Unterminated template block")); + } break; case UT_LEX_BLOCK_EXPRESSION_EMIT_TAG: - s->lex.within_expression_block = 1; - s->lex.state = UT_LEX_IDENTIFY_TOKEN; + lex->within_expression_block = 1; + lex->state = UT_LEX_IDENTIFY_TOKEN; - return emit_op(s, s->source->off, T_LEXP, NULL); + return emit_op(lex, lex->source->off, TK_LEXP, NULL); case UT_LEX_IDENTIFY_TOKEN: /* skip leading whitespace */ - for (i = 0; i < buf_remaining(s) && isspace(s->lex.bufstart[i]); i++) + for (i = 0; i < buf_remaining(lex) && isspace(lex->bufstart[i]); i++) ; - buf_consume(s, i); + buf_consume(lex, i); - if (i > 0 && buf_remaining(s) < UT_LEX_MAX_TOKEN_LEN) - return 0; + if (i > 0 && buf_remaining(lex) < UT_LEX_MAX_TOKEN_LEN) + return NULL; for (i = 0; i < sizeof(search.str); i++) - search.str[i] = (i < buf_remaining(s)) ? s->lex.bufstart[i] : 0; + search.str[i] = (i < buf_remaining(lex)) ? lex->bufstart[i] : 0; for (i = 0, tok = tokens; i < ARRAY_SIZE(tokens); tok = &tokens[++i]) { /* remaining buffer data is shorter than token, skip */ - if (tok->plen > buf_remaining(s)) + if (tok->plen > buf_remaining(lex)) continue; - c = s->lex.bufstart[0]; + c = buf_remaining(lex) ? lex->bufstart[0] : 0; if (tok->plen ? ((search.n & masks[tok->plen]) == tok->patn) : (c >= tok->pat[0] && c <= tok->pat[1])) { - buf_consume(s, tok->plen); - - s->lex.lastoff = s->source->off - tok->plen; + lex->lastoff = lex->source->off; /* token has a parse method, switch state */ if (tok->parse) { - s->lex.tok = tok; - s->lex.state = UT_LEX_PARSE_TOKEN; + lex->tok = tok; + lex->state = UT_LEX_PARSE_TOKEN; - return 0; + buf_consume(lex, tok->plen); + + return NULL; } /* disallow nesting blocks */ - if ((s->lex.within_expression_block && - (tok->type == T_LSTM || tok->type == T_RSTM || tok->type == T_LEXP)) || - (s->lex.within_statement_block && - (tok->type == T_LEXP || tok->type == T_REXP || tok->type == T_LSTM))) { - uc_new_exception(s, s->source->off - tok->plen, "Syntax error: Template blocks may not be nested"); + if ((lex->within_expression_block && + (tok->type == TK_LSTM || tok->type == TK_RSTM || tok->type == TK_LEXP)) || + (lex->within_statement_block && + (tok->type == TK_LEXP || tok->type == TK_REXP || tok->type == TK_LSTM))) { + buf_consume(lex, tok->plen); - return 0; + return emit_op(lex, lex->source->off - tok->plen, TK_ERROR, xjs_new_string("Template blocks may not be nested")); } /* found end of block */ - else if ((s->lex.within_statement_block && tok->type == T_RSTM) || - (s->lex.within_expression_block && tok->type == T_REXP)) { + else if ((lex->within_statement_block && tok->type == TK_RSTM) || + (lex->within_expression_block && tok->type == TK_REXP)) { /* emit additional empty statement (semicolon) at end of template block */ - if (!s->lex.semicolon_emitted) { - s->lex.semicolon_emitted = true; - - /* rewind */ - buf_consume(s, -tok->plen); + if (!lex->semicolon_emitted) { + lex->semicolon_emitted = true; - return emit_op(s, s->source->off, T_SCOL, NULL); + return emit_op(lex, lex->source->off, TK_SCOL, NULL); } /* strip whitespace after block */ if (tok->pat[0] == '-') - s->lex.skip_leading_whitespace = true; + lex->skip_leading_whitespace = true; /* strip newline after statement block */ - else if (s->lex.within_statement_block && s->trim_blocks) - s->lex.skip_leading_newline = true; - - s->lex.semicolon_emitted = false; - s->lex.within_statement_block = false; - s->lex.within_expression_block = false; - s->lex.state = UT_LEX_IDENTIFY_BLOCK; - s->lex.lastoff = s->source->off; + else if (lex->within_statement_block && + lex->config && lex->config->trim_blocks) + lex->skip_leading_newline = true; + + lex->semicolon_emitted = false; + lex->within_statement_block = false; + lex->within_expression_block = false; + lex->state = UT_LEX_IDENTIFY_BLOCK; } /* do not report statement tags to the parser */ - if (tok->type != 0 && tok->type != T_LSTM && tok->type != T_RSTM) - rv = emit_op(s, s->source->off - tok->plen, tok->type, NULL); + if (tok->type != 0 && tok->type != TK_LSTM && tok->type != TK_RSTM) + rv = emit_op(lex, lex->source->off, tok->type, NULL); else - rv = 0; + rv = NULL; + + buf_consume(lex, tok->plen); return rv; } } /* no token matched and we do have remaining data, junk */ - if (buf_remaining(s)) { - uc_new_exception(s, s->source->off, "Syntax error: Unexpected character"); - - return 0; - } + if (buf_remaining(lex)) + return emit_op(lex, lex->source->off, TK_ERROR, xjs_new_string("Unexpected character")); /* we're at eof, allow unclosed statement blocks */ - if (s->lex.within_statement_block) { - s->lex.state = UT_LEX_EOF; + if (lex->within_statement_block) { + lex->state = UT_LEX_EOF; - return 0; + return NULL; } /* premature EOF */ - uc_new_exception(s, s->source->off, "Syntax error: Unterminated template block"); - - break; + return emit_op(lex, lex->source->off, TK_ERROR, xjs_new_string("Unterminated template block")); case UT_LEX_PARSE_TOKEN: - tok = s->lex.tok; - rv = tok->parse(s); + tok = lex->tok; + rv = tok->parse(lex); if (rv) { - memset(s->lex.esc, 0, sizeof(s->lex.esc)); - s->lex.state = UT_LEX_IDENTIFY_TOKEN; - s->lex.tok = NULL; + memset(lex->esc, 0, sizeof(lex->esc)); + lex->state = UT_LEX_IDENTIFY_TOKEN; + lex->tok = NULL; - if (rv == UINT32_MAX) - rv = 0; + if (rv == UC_LEX_CONTINUE_PARSING) + rv = NULL; return rv; } @@ -1129,25 +1212,66 @@ lex_step(struct uc_state *s, FILE *fp) break; } - return 0; + return NULL; } -uint32_t -uc_get_token(struct uc_state *s, FILE *fp) +void +uc_lexer_init(uc_lexer *lex, uc_parse_config *config, uc_source *source) { - uint32_t rv; + lex->state = UT_LEX_IDENTIFY_BLOCK; - while (s->lex.state != UT_LEX_EOF) { - rv = lex_step(s, fp); + lex->config = config; + lex->source = uc_source_get(source); - if (rv == 0 && s->exception) - break; + lex->eof = 0; + lex->skip_leading_whitespace = 0; + lex->skip_leading_newline = 0; + lex->within_statement_block = 0; + lex->within_statement_block = 0; + lex->semicolon_emitted = 0; + lex->expect_div = 0; + lex->is_escape = 0; + + lex->buflen = 0; + lex->buf = NULL; + lex->bufstart = NULL; + lex->bufend = NULL; + + lex->lookbehindlen = 0; + lex->lookbehind = NULL; + + lex->tok = NULL; + + lex->esclen = 0; + memset(lex->esc, 0, sizeof(lex->esc)); + + lex->lead_surrogate = 0; + + lex->lastoff = 0; +} + +void +uc_lexer_free(uc_lexer *lex) +{ + uc_source_put(lex->source); + + free(lex->lookbehind); + free(lex->buf); +} + +uc_token * +uc_lexer_next_token(uc_lexer *lex) +{ + uc_token *rv; + + while (lex->state != UT_LEX_EOF) { + rv = lex_step(lex, lex->source->fp); - if (rv > 0) + if (rv != NULL) return rv; } - return 0; + return emit_op(lex, lex->source->off, TK_EOF, NULL); } const char * @@ -1158,11 +1282,11 @@ uc_get_tokenname(int type) switch (type) { case 0: return "End of file"; - case T_STRING: return "String"; - case T_LABEL: return "Label"; - case T_NUMBER: return "Number"; - case T_DOUBLE: return "Double"; - case T_REGEXP: return "Regexp"; + case TK_STRING: return "String"; + case TK_LABEL: return "Label"; + case TK_NUMBER: return "Number"; + case TK_DOUBLE: return "Double"; + case TK_REGEXP: return "Regexp"; } for (i = 0; i < ARRAY_SIZE(tokens); i++) { diff --git a/lexer.h b/lexer.h index e45d3e3..fd462ff 100644 --- a/lexer.h +++ b/lexer.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Jo-Philipp Wich + * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -17,18 +17,156 @@ #ifndef __LEXER_H_ #define __LEXER_H_ -#include "ast.h" +#include "source.h" #define __T_MAX 82 #define T_EXCEPTION (__T_MAX + 0) #define T_CFUNC (__T_MAX + 1) #define T_RESSOURCE (__T_MAX + 2) -bool -utf8enc(char **out, int *rem, int code); -uint32_t -uc_get_token(struct uc_state *s, FILE *fp); +typedef enum { + TK_LEXP = 1, + TK_REXP, + TK_LSTM, + TK_RSTM, + TK_IF, + TK_ELSE, + TK_COMMA, + TK_ASBAND, + TK_ASBXOR, + TK_ASBOR, + TK_ASLEFT, + TK_ASRIGHT, + TK_ASMUL, + TK_ASDIV, + TK_ASMOD, + TK_ASADD, + TK_ASSUB, + TK_ASSIGN, + TK_QMARK, + TK_COLON, + TK_OR, + TK_AND, + TK_BOR, + TK_BXOR, + TK_BAND, + TK_EQ, + TK_NE, + TK_EQS, + TK_NES, + TK_LT, + TK_LE, + TK_GT, + TK_GE, + TK_IN, + TK_LSHIFT, + TK_RSHIFT, + TK_ADD, + TK_SUB, + TK_MUL, + TK_DIV, + TK_MOD, + TK_NOT, + TK_COMPL, + TK_INC, + TK_DEC, + TK_LPAREN, + TK_LBRACK, + TK_TEXT, + TK_LBRACE, + TK_RBRACE, + TK_SCOL, + TK_RPAREN, + TK_ENDIF, + TK_ELIF, + TK_WHILE, + TK_ENDWHILE, + TK_FOR, + TK_ENDFOR, + TK_FUNC, + TK_LABEL, + TK_ENDFUNC, + TK_TRY, + TK_CATCH, + TK_SWITCH, + TK_CASE, + TK_DEFAULT, + TK_ELLIP, + TK_RETURN, + TK_BREAK, + TK_CONTINUE, + TK_LOCAL, + TK_ARROW, + TK_DOT, + TK_RBRACK, + TK_BOOL, + TK_NUMBER, + TK_DOUBLE, + TK_STRING, + TK_REGEXP, + TK_NULL, + TK_THIS, + + TK_EOF, + TK_ERROR +} uc_tokentype_t; + +typedef enum { + UT_LEX_IDENTIFY_BLOCK, + UT_LEX_BLOCK_COMMENT_START, + UT_LEX_BLOCK_EXPRESSION_START, + UT_LEX_BLOCK_EXPRESSION_EMIT_TAG, + UT_LEX_BLOCK_STATEMENT_START, + UT_LEX_BLOCK_COMMENT, + UT_LEX_IDENTIFY_TOKEN, + UT_LEX_PARSE_TOKEN, + UT_LEX_EOF +} uc_lex_state_t; + +typedef struct { + uc_tokentype_t type; + json_object *val; + size_t pos; +} uc_token; + +typedef struct { + bool lstrip_blocks; + bool trim_blocks; + bool strict_declarations; +} uc_parse_config; + +typedef struct { + uc_lex_state_t state; + uc_parse_config *config; + uc_source *source; + uint8_t eof:1; + uint8_t skip_leading_whitespace:1; + uint8_t skip_leading_newline:1; + uint8_t within_expression_block:1; + uint8_t within_statement_block:1; + uint8_t semicolon_emitted:1; + uint8_t expect_div:1; + uint8_t is_escape:1; + size_t buflen; + char *buf, *bufstart, *bufend; + size_t lookbehindlen; + char *lookbehind; + const void *tok; + uc_token curr; + char esc[5]; + uint8_t esclen; + int lead_surrogate; + size_t lastoff; +} uc_lexer; + + +void uc_lexer_init(uc_lexer *lex, uc_parse_config *config, uc_source *source); +void uc_lexer_free(uc_lexer *lex); + +uc_token *uc_lexer_next_token(uc_lexer *lex); + +bool utf8enc(char **out, int *rem, int code); const char * uc_get_tokenname(int type); diff --git a/lib.c b/lib.c index d2c361b..c8b50b6 100644 --- a/lib.c +++ b/lib.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Jo-Philipp Wich + * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -14,13 +14,6 @@ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#include "ast.h" -#include "parser.h" -#include "lexer.h" -#include "eval.h" -#include "lib.h" -#include "module.h" - #include #include #include @@ -38,6 +31,40 @@ #include #include +#include "lexer.h" +#include "compiler.h" +#include "vm.h" +#include "lib.h" +#include "object.h" + + +const uc_ops uc = { + .value = { + .proto = uc_prototype_new, + .cfunc = uc_cfunction_new, + .dbl = uc_double_new, + .regexp = uc_regexp_new, + .tonumber = uc_cast_number, + .ressource = uc_ressource_new + }, + + .ressource = { + .define = uc_ressource_type_add, + .create = uc_ressource_new, + .data = uc_ressource_dataptr, + .proto = uc_ressource_prototype + }, + + .vm = { + .call = uc_vm_call, + .peek = uc_vm_stack_peek, + .pop = uc_vm_stack_pop, + .push = uc_vm_stack_push, + .raise = uc_vm_raise_exception + } +}; + +const uc_ops *ops = &uc; __attribute__((format(printf, 3, 5))) static void snprintf_append(char **dptr, size_t *dlen, const char *fmt, ssize_t sz, ...) @@ -67,12 +94,15 @@ snprintf_append(char **dptr, size_t *dlen, const char *fmt, ssize_t sz, ...) snprintf_append(dptr, dlen, fmt, -1, ##__VA_ARGS__) static void -format_context_line(char **msg, size_t *msglen, const char *line, size_t off) +format_context_line(char **msg, size_t *msglen, const char *line, size_t off, bool compact) { const char *p; int padlen, i; for (p = line, padlen = 0; *p != '\n' && *p != '\0'; p++) { + if (compact && (p - line) == off) + sprintf_append(msg, msglen, "\033[22m"); + switch (*p) { case '\t': sprintf_append(msg, msglen, " "); @@ -94,6 +124,12 @@ format_context_line(char **msg, size_t *msglen, const char *line, size_t off) } } + if (compact) { + sprintf_append(msg, msglen, "\033[m\n"); + + return; + } + sprintf_append(msg, msglen, "`\n "); if (padlen < strlen("Near here ^")) { @@ -112,17 +148,73 @@ format_context_line(char **msg, size_t *msglen, const char *line, size_t off) } } -static void -format_error_context(char **msg, size_t *msglen, struct uc_source *src, struct json_object *stacktrace, size_t off) +static char * +source_filename(uc_source *src, uint32_t line) { - struct json_object *e, *fn, *file, *line, *byte; - size_t len, rlen, idx; - const char *path; + const char *name = src->filename ? basename(src->filename) : "[?]"; + static char buf[sizeof("xxxxxxxxx.uc:0000000000")]; + size_t len = strlen(name); + + if (len > 12) + snprintf(buf, sizeof(buf), "...%s:%u", name + (len - 9), line); + else + snprintf(buf, sizeof(buf), "%12s:%u", name, line); + + return buf; +} + +void +format_source_context(char **msg, size_t *msglen, uc_source *src, size_t off, bool compact) +{ + size_t len, rlen; bool truncated; char buf[256]; + long srcpos; int eline; - for (idx = 0; idx < json_object_array_length(stacktrace); idx++) { + srcpos = ftell(src->fp); + + if (srcpos == -1) + return; + + fseek(src->fp, 0, SEEK_SET); + + truncated = false; + eline = 1; + rlen = 0; + + while (fgets(buf, sizeof(buf), src->fp)) { + len = strlen(buf); + rlen += len; + + if (rlen > off) { + if (compact) + sprintf_append(msg, msglen, "\033[2;40;97m%17s %s", + source_filename(src, eline), + truncated ? "..." : ""); + else + sprintf_append(msg, msglen, "\n `%s", + truncated ? "..." : ""); + + format_context_line(msg, msglen, buf, len - (rlen - off) + (truncated ? 3 : 0), compact); + break; + } + + truncated = (len > 0 && buf[len-1] != '\n'); + eline += !truncated; + } + + fseek(src->fp, srcpos, SEEK_SET); +} + +void +format_error_context(char **msg, size_t *msglen, uc_source *src, json_object *stacktrace, size_t off) +{ + json_object *e, *fn, *file, *line, *byte; + const char *path; + size_t idx; + + for (idx = 0; idx < (stacktrace ? json_object_array_length(stacktrace) : 0); idx++) { e = json_object_array_get_idx(stacktrace, idx); fn = json_object_object_get(e, "function"); file = json_object_object_get(e, "filename"); @@ -153,94 +245,22 @@ format_error_context(char **msg, size_t *msglen, struct uc_source *src, struct j sprintf_append(msg, msglen, " called from %s%s (%s", fn ? "function " : "anonymous function", fn ? json_object_get_string(fn) : "", - json_object_get_string(file)); + file ? json_object_get_string(file) : ""); if (line && byte) sprintf_append(msg, msglen, ":%" PRId64 ":%" PRId64 ")\n", json_object_get_int64(line), json_object_get_int64(byte)); else - sprintf_append(msg, msglen, " [C])\n"); - } - } - - fseek(src->fp, 0, SEEK_SET); - - truncated = false; - eline = 1; - rlen = 0; - - while (fgets(buf, sizeof(buf), src->fp)) { - len = strlen(buf); - rlen += len; - - if (rlen > off) { - sprintf_append(msg, msglen, "\n `%s", truncated ? "..." : ""); - format_context_line(msg, msglen, buf, len - (rlen - off) + (truncated ? 3 : 0)); - break; - } - - truncated = (len > 0 && buf[len-1] != '\n'); - eline += !truncated; - } -} - -struct json_object * -uc_parse_error(struct uc_state *state, uint32_t off, uint64_t *tokens, int max_token) -{ - struct json_object *rv; - size_t msglen = 0; - bool first = true; - char *msg = NULL; - int i; - - for (i = 0; i <= max_token; i++) { - if (tokens[i / 64] & ((uint64_t)1 << (i % 64))) { - if (first) { - sprintf_append(&msg, &msglen, "Expecting %s", uc_get_tokenname(i)); - first = false; - } - else if (i < max_token) { - sprintf_append(&msg, &msglen, ", %s", uc_get_tokenname(i)); - } - else { - sprintf_append(&msg, &msglen, " or %s", uc_get_tokenname(i)); - } + sprintf_append(msg, msglen, "[C])\n"); } } - rv = uc_new_exception(state, - off ? OP_POS(off) : state->lex.lastoff, - "Syntax error: Unexpected token\n%s", msg); - free(msg); - - return rv; -} - -char * -uc_format_error(struct uc_state *state, FILE *fp) -{ - struct uc_source *src; - struct uc_op *tag; - size_t msglen = 0; - char *msg = NULL; - - tag = json_object_get_userdata(state->exception); - src = tag->tag.data; - - sprintf_append(&msg, &msglen, "%s\n", - json_object_get_string(json_object_object_get(state->exception, "message"))); - - if (tag->off) - format_error_context(&msg, &msglen, src, - json_object_object_get(state->exception, "stacktrace"), - tag->off); - - return msg; + format_source_context(msg, msglen, src, off, false); } static double -uc_cast_double(struct json_object *v) +uc_cast_double(json_object *v) { enum json_type t; int64_t n; @@ -262,7 +282,7 @@ uc_cast_double(struct json_object *v) } static int64_t -uc_cast_int64(struct json_object *v) +uc_cast_int64(json_object *v) { enum json_type t; int64_t n; @@ -285,60 +305,17 @@ uc_cast_int64(struct json_object *v) return n; } -static int -uc_c_fn_to_string(struct json_object *v, struct printbuf *pb, int level, int flags) -{ - struct uc_op *op = json_object_get_userdata(v); - struct uc_function *fn = (void *)op + ALIGN(sizeof(*op)); - - return sprintbuf(pb, "%sfunction %s(...) { [native code] }%s", - level ? "\"" : "", fn->name, level ? "\"" : ""); -} - -static void -uc_c_fn_free(struct json_object *v, void *ud) -{ - struct uc_op *op = ud; - - json_object_put(op->tag.proto); - free(ud); -} - -static bool -uc_register_function(struct uc_state *state, struct json_object *scope, const char *name, uc_c_fn *cfn) +static json_object * +uc_print_common(uc_vm *vm, size_t nargs, FILE *fh) { - struct json_object *val = xjs_new_object(); - struct uc_function *fn; - struct uc_op *op; - - op = xalloc(ALIGN(sizeof(*op)) + ALIGN(sizeof(*fn)) + ALIGN(strlen(name) + 1)); - op->val = val; - op->type = T_CFUNC; - - fn = (void *)op + ALIGN(sizeof(*op)); - fn->source = state->function ? state->function->source : NULL; - fn->name = strcpy((char *)fn + ALIGN(sizeof(*fn)), name); - fn->cfn = cfn; - - op->tag.data = fn; - - json_object_set_serializer(val, uc_c_fn_to_string, op, uc_c_fn_free); - - return json_object_object_add(scope, name, op->val); -} - -static struct json_object * -uc_print_common(struct uc_state *s, uint32_t off, struct json_object *args, FILE *fh) -{ - struct json_object *item; - size_t arridx, arrlen; + json_object *item; size_t reslen = 0; size_t len = 0; + size_t arridx; const char *p; - for (arridx = 0, arrlen = json_object_array_length(args); - arridx < arrlen; arridx++) { - item = json_object_array_get_idx(args, arridx); + for (arridx = 0; arridx < nargs; arridx++) { + item = uc_get_arg(arridx); if (json_object_is_type(item, json_type_string)) { p = json_object_get_string(item); @@ -357,16 +334,16 @@ uc_print_common(struct uc_state *s, uint32_t off, struct json_object *args, FILE } -static struct json_object * -uc_print(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_print(uc_vm *vm, size_t nargs) { - return uc_print_common(s, off, args, stdout); + return uc_print_common(vm, nargs, stdout); } -static struct json_object * -uc_length(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_length(uc_vm *vm, size_t nargs) { - struct json_object *arg = json_object_array_get_idx(args, 0); + json_object *arg = uc_get_arg(0); switch (json_object_get_type(arg)) { case json_type_object: @@ -383,18 +360,18 @@ uc_length(struct uc_state *s, uint32_t off, struct json_object *args) } } -static struct json_object * -uc_index(struct uc_state *s, uint32_t off, struct json_object *args, bool right) +static json_object * +uc_index(uc_vm *vm, size_t nargs, bool right) { - struct json_object *stack = json_object_array_get_idx(args, 0); - struct json_object *needle = json_object_array_get_idx(args, 1); + json_object *stack = uc_get_arg(0); + json_object *needle = uc_get_arg(1); size_t arridx, len, ret = -1; const char *sstr, *nstr, *p; switch (json_object_get_type(stack)) { case json_type_array: for (arridx = 0, len = json_object_array_length(stack); arridx < len; arridx++) { - if (uc_cmp(T_EQ, json_object_array_get_idx(stack, arridx), needle)) { + if (uc_cmp(TK_EQ, json_object_array_get_idx(stack, arridx), needle)) { ret = arridx; if (!right) @@ -425,42 +402,41 @@ uc_index(struct uc_state *s, uint32_t off, struct json_object *args, bool right) } } -static struct json_object * -uc_lindex(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_lindex(uc_vm *vm, size_t nargs) { - return uc_index(s, off, args, false); + return uc_index(vm, nargs, false); } -static struct json_object * -uc_rindex(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_rindex(uc_vm *vm, size_t nargs) { - return uc_index(s, off, args, true); + return uc_index(vm, nargs, true); } -static struct json_object * -uc_push(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_push(uc_vm *vm, size_t nargs) { - struct json_object *arr = json_object_array_get_idx(args, 0); - struct json_object *item = NULL; - size_t arridx, arrlen; + json_object *arr = uc_get_arg(0); + json_object *item = NULL; + size_t arridx; if (!json_object_is_type(arr, json_type_array)) return NULL; - for (arridx = 1, arrlen = json_object_array_length(args); - arridx < arrlen; arridx++) { - item = json_object_array_get_idx(args, arridx); - json_object_array_add(arr, json_object_get(item)); + for (arridx = 1; arridx < nargs; arridx++) { + item = uc_get_arg(arridx); + json_object_array_add(arr, uc_value_get(item)); } - return json_object_get(item); + return uc_value_get(item); } -static struct json_object * -uc_pop(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_pop(uc_vm *vm, size_t nargs) { - struct json_object *arr = json_object_array_get_idx(args, 0); - struct json_object *item = NULL; + json_object *arr = uc_get_arg(0); + json_object *item = NULL; size_t arrlen; if (!json_object_is_type(arr, json_type_array)) @@ -476,20 +452,20 @@ uc_pop(struct uc_state *s, uint32_t off, struct json_object *args) #endif } - return json_object_get(item); + return uc_value_get(item); } -static struct json_object * -uc_shift(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_shift(uc_vm *vm, size_t nargs) { - struct json_object *arr = json_object_array_get_idx(args, 0); - struct json_object *item = NULL; + json_object *arr = uc_get_arg(0); + json_object *item = NULL; size_t arridx, arrlen; if (!json_object_is_type(arr, json_type_array)) return NULL; - item = json_object_get(json_object_array_get_idx(arr, 0)); + item = uc_value_get(json_object_array_get_idx(arr, 0)); arrlen = json_object_array_length(arr); for (arridx = 0; arridx < arrlen - 1; arridx++) @@ -504,46 +480,45 @@ uc_shift(struct uc_state *s, uint32_t off, struct json_object *args) return item; } -static struct json_object * -uc_unshift(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_unshift(uc_vm *vm, size_t nargs) { - struct json_object *arr = json_object_array_get_idx(args, 0); - struct json_object *item = NULL; + json_object *arr = uc_get_arg(0); + json_object *item = NULL; size_t arridx, arrlen, addlen; if (!json_object_is_type(arr, json_type_array)) return NULL; arrlen = json_object_array_length(arr); - addlen = json_object_array_length(args) - 1; + addlen = nargs - 1; for (arridx = arrlen; arridx > 0; arridx--) json_object_array_put_idx(arr, arridx + addlen - 1, - json_object_get(json_object_array_get_idx(arr, arridx - 1))); + uc_value_get(json_object_array_get_idx(arr, arridx - 1))); for (arridx = 0; arridx < addlen; arridx++) { - item = json_object_array_get_idx(args, arridx + 1); - json_object_array_put_idx(arr, arridx, json_object_get(item)); + item = uc_get_arg(arridx + 1); + json_object_array_put_idx(arr, arridx, uc_value_get(item)); } return item; } -static struct json_object * -uc_chr(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_chr(uc_vm *vm, size_t nargs) { - size_t len = json_object_array_length(args); size_t idx; int64_t n; char *str; - if (!len) + if (!nargs) return xjs_new_string_len("", 0); - str = xalloc(len); + str = xalloc(nargs); - for (idx = 0; idx < len; idx++) { - n = uc_cast_int64(json_object_array_get_idx(args, idx)); + for (idx = 0; idx < nargs; idx++) { + n = uc_cast_int64(uc_get_arg(idx)); if (n < 0) n = 0; @@ -553,25 +528,25 @@ uc_chr(struct uc_state *s, uint32_t off, struct json_object *args) str[idx] = (char)n; } - return xjs_new_string_len(str, len); + return xjs_new_string_len(str, nargs); } -static struct json_object * -uc_delete(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_delete(uc_vm *vm, size_t nargs) { - struct json_object *obj = json_object_array_get_idx(args, 0); - struct json_object *rv = NULL; - size_t arridx, arrlen; + json_object *obj = uc_get_arg(0); + json_object *rv = NULL; const char *key; + size_t arridx; if (!json_object_is_type(obj, json_type_object)) return NULL; - for (arrlen = json_object_array_length(args), arridx = 1; arridx < arrlen; arridx++) { - json_object_put(rv); + for (arridx = 1; arridx < nargs; arridx++) { + uc_value_put(rv); - key = json_object_get_string(json_object_array_get_idx(args, arridx)); - rv = json_object_get(json_object_object_get(obj, key ? key : "null")); + key = json_object_get_string(uc_get_arg(arridx)); + rv = uc_value_get(json_object_object_get(obj, key ? key : "null")); json_object_object_del(obj, key ? key : "null"); } @@ -579,28 +554,21 @@ uc_delete(struct uc_state *s, uint32_t off, struct json_object *args) return rv; } -static struct json_object * -uc_die(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_die(uc_vm *vm, size_t nargs) { - const char *msg = json_object_get_string(json_object_array_get_idx(args, 0)); - struct uc_function *prev_fn; - struct json_object *ex; - - prev_fn = s->function; - s->function = s->callstack->function; - - ex = uc_new_exception(s, s->callstack->off, "%s", msg ? msg : "Died"); + const char *msg = json_object_get_string(uc_get_arg(0)); - s->function = prev_fn; + uc_vm_raise_exception(vm, EXCEPTION_USER, msg ? msg : "Died"); - return ex; + return NULL; } -static struct json_object * -uc_exists(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_exists(uc_vm *vm, size_t nargs) { - struct json_object *obj = json_object_array_get_idx(args, 0); - const char *key = json_object_get_string(json_object_array_get_idx(args, 1)); + json_object *obj = uc_get_arg(0); + const char *key = json_object_get_string(uc_get_arg(1)); if (!json_object_is_type(obj, json_type_object)) return false; @@ -608,98 +576,95 @@ uc_exists(struct uc_state *s, uint32_t off, struct json_object *args) return xjs_new_boolean(json_object_object_get_ex(obj, key ? key : "null", NULL)); } -__attribute__((noreturn)) static struct json_object * -uc_exit(struct uc_state *s, uint32_t off, struct json_object *args) +__attribute__((noreturn)) static json_object * +uc_exit(uc_vm *vm, size_t nargs) { - int64_t n = uc_cast_int64(json_object_array_get_idx(args, 0)); + int64_t n = uc_cast_int64(uc_get_arg(0)); exit(n); } -static struct json_object * -uc_getenv(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_getenv(uc_vm *vm, size_t nargs) { - const char *key = json_object_get_string(json_object_array_get_idx(args, 0)); + const char *key = json_object_get_string(uc_get_arg(0)); char *val = key ? getenv(key) : NULL; return val ? xjs_new_string(val) : NULL; } -static struct json_object * -uc_filter(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_filter(uc_vm *vm, size_t nargs) { - struct json_object *obj = json_object_array_get_idx(args, 0); - struct json_object *func = json_object_array_get_idx(args, 1); - struct json_object *rv, *arr, *cmpargs; + json_object *obj = uc_get_arg(0); + json_object *func = uc_get_arg(1); + json_object *rv, *arr; size_t arridx, arrlen; if (!json_object_is_type(obj, json_type_array)) return NULL; arr = xjs_new_array(); - cmpargs = xjs_new_array(); - - json_object_array_put_idx(cmpargs, 2, json_object_get(obj)); for (arrlen = json_object_array_length(obj), arridx = 0; arridx < arrlen; arridx++) { - json_object_array_put_idx(cmpargs, 0, json_object_get(json_object_array_get_idx(obj, arridx))); - json_object_array_put_idx(cmpargs, 1, xjs_new_int64(arridx)); + /* XXX: revisit leaks */ + uc_vm_stack_push(vm, uc_value_get(func)); + uc_vm_stack_push(vm, uc_value_get(json_object_array_get_idx(obj, arridx))); + uc_vm_stack_push(vm, xjs_new_int64(arridx)); + uc_vm_stack_push(vm, uc_value_get(obj)); - rv = uc_invoke(s, off, NULL, func, cmpargs); + if (uc_vm_call(vm, false, 3)) { + uc_value_put(arr); - if (uc_is_type(rv, T_EXCEPTION)) { - json_object_put(cmpargs); - json_object_put(arr); - - return rv; + return NULL; } + rv = uc_vm_stack_pop(vm); + if (uc_val_is_truish(rv)) - json_object_array_add(arr, json_object_get(json_object_array_get_idx(obj, arridx))); + json_object_array_add(arr, uc_value_get(json_object_array_get_idx(obj, arridx))); - json_object_put(rv); + uc_value_put(rv); } - json_object_put(cmpargs); - return arr; } -static struct json_object * -uc_hex(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_hex(uc_vm *vm, size_t nargs) { - const char *val = json_object_get_string(json_object_array_get_idx(args, 0)); + const char *val = json_object_get_string(uc_get_arg(0)); int64_t n; char *e; if (!val || !isxdigit(*val)) - return uc_new_double(NAN); + return uc_double_new(NAN); n = strtoll(val, &e, 16); if (e == val || *e) - return uc_new_double(NAN); + return uc_double_new(NAN); return xjs_new_int64(n); } -static struct json_object * -uc_int(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_int(uc_vm *vm, size_t nargs) { - int64_t n = uc_cast_int64(json_object_array_get_idx(args, 0)); + int64_t n = uc_cast_int64(uc_get_arg(0)); if (errno == EINVAL || errno == EOVERFLOW) - return uc_new_double(NAN); + return uc_double_new(NAN); return xjs_new_int64(n); } -static struct json_object * -uc_join(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_join(uc_vm *vm, size_t nargs) { - const char *sep = json_object_get_string(json_object_array_get_idx(args, 0)); - struct json_object *arr = json_object_array_get_idx(args, 1); - struct json_object *rv = NULL; + const char *sep = json_object_get_string(uc_get_arg(0)); + json_object *arr = uc_get_arg(1); + json_object *rv = NULL; size_t arrlen, arridx, len = 1; const char *item; char *res, *p; @@ -750,11 +715,11 @@ out: return rv; } -static struct json_object * -uc_keys(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_keys(uc_vm *vm, size_t nargs) { - struct json_object *obj = json_object_array_get_idx(args, 0); - struct json_object *arr = NULL; + json_object *obj = uc_get_arg(0); + json_object *arr = NULL; if (!json_object_is_type(obj, json_type_object)) return NULL; @@ -767,12 +732,12 @@ uc_keys(struct uc_state *s, uint32_t off, struct json_object *args) return arr; } -static struct json_object * -uc_lc(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_lc(uc_vm *vm, size_t nargs) { - const char *str = json_object_get_string(json_object_array_get_idx(args, 0)); + const char *str = json_object_get_string(uc_get_arg(0)); size_t len = str ? strlen(str) : 0; - struct json_object *rv = NULL; + json_object *rv = NULL; char *res, *p; if (!str) @@ -792,50 +757,47 @@ uc_lc(struct uc_state *s, uint32_t off, struct json_object *args) return rv; } -static struct json_object * -uc_map(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_map(uc_vm *vm, size_t nargs) { - struct json_object *obj = json_object_array_get_idx(args, 0); - struct json_object *func = json_object_array_get_idx(args, 1); - struct json_object *arr, *cmpargs, *rv; + json_object *obj = uc_get_arg(0); + json_object *func = uc_get_arg(1); + json_object *arr, *rv; size_t arridx, arrlen; if (!json_object_is_type(obj, json_type_array)) return NULL; arr = xjs_new_array(); - cmpargs = xjs_new_array(); - - json_object_array_put_idx(cmpargs, 2, json_object_get(obj)); for (arrlen = json_object_array_length(obj), arridx = 0; arridx < arrlen; arridx++) { - json_object_array_put_idx(cmpargs, 0, json_object_get(json_object_array_get_idx(obj, arridx))); - json_object_array_put_idx(cmpargs, 1, xjs_new_int64(arridx)); + /* XXX: revisit leaks */ + uc_vm_stack_push(vm, uc_value_get(func)); + uc_vm_stack_push(vm, uc_value_get(json_object_array_get_idx(obj, arridx))); + uc_vm_stack_push(vm, xjs_new_int64(arridx)); + uc_vm_stack_push(vm, uc_value_get(obj)); - rv = uc_invoke(s, off, NULL, func, cmpargs); + if (uc_vm_call(vm, false, 3)) { + uc_value_put(arr); - if (uc_is_type(rv, T_EXCEPTION)) { - json_object_put(cmpargs); - json_object_put(arr); - - return rv; + return NULL; } + rv = uc_vm_stack_pop(vm); + json_object_array_add(arr, rv); } - json_object_put(cmpargs); - return arr; } -static struct json_object * -uc_ord(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_ord(uc_vm *vm, size_t nargs) { - struct json_object *obj = json_object_array_get_idx(args, 0); - struct json_object *rv, *pos; - size_t i, len, nargs; + json_object *obj = uc_get_arg(0); + json_object *rv, *pos; const char *str; + size_t i, len; int64_t n; if (!json_object_is_type(obj, json_type_string)) @@ -844,15 +806,13 @@ uc_ord(struct uc_state *s, uint32_t off, struct json_object *args) str = json_object_get_string(obj); len = json_object_get_string_len(obj); - nargs = json_object_array_length(args); - if (nargs == 1) return str[0] ? xjs_new_int64((int64_t)str[0]) : NULL; rv = xjs_new_array(); for (i = 1; i < nargs; i++) { - pos = json_object_array_get_idx(args, i); + pos = uc_get_arg(i); if (json_object_is_type(pos, json_type_int)) { n = json_object_get_int64(pos); @@ -872,17 +832,19 @@ uc_ord(struct uc_state *s, uint32_t off, struct json_object *args) return rv; } -static struct json_object * -uc_type(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_type(uc_vm *vm, size_t nargs) { - struct json_object *v = json_object_array_get_idx(args, 0); - struct uc_op *tag = json_object_get_userdata(v); + json_object *v = uc_get_arg(0); + uc_objtype_t o = uc_object_type(v); - switch (tag ? tag->type : 0) { - case T_FUNC: + switch (o) { + case UC_OBJ_CFUNCTION: + case UC_OBJ_FUNCTION: + case UC_OBJ_CLOSURE: return xjs_new_string("function"); - case T_RESSOURCE: + case UC_OBJ_RESSOURCE: return xjs_new_string("ressource"); default: @@ -911,11 +873,11 @@ uc_type(struct uc_state *s, uint32_t off, struct json_object *args) } } -static struct json_object * -uc_reverse(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_reverse(uc_vm *vm, size_t nargs) { - struct json_object *obj = json_object_array_get_idx(args, 0); - struct json_object *rv = NULL; + json_object *obj = uc_get_arg(0); + json_object *rv = NULL; size_t len, arridx; const char *str; char *dup, *p; @@ -924,7 +886,7 @@ uc_reverse(struct uc_state *s, uint32_t off, struct json_object *args) rv = xjs_new_array(); for (arridx = json_object_array_length(obj); arridx > 0; arridx--) - json_object_array_add(rv, json_object_get(json_object_array_get_idx(obj, arridx - 1))); + json_object_array_add(rv, uc_value_get(json_object_array_get_idx(obj, arridx - 1))); } else if (json_object_is_type(obj, json_type_string)) { len = json_object_get_string_len(obj); @@ -944,80 +906,74 @@ uc_reverse(struct uc_state *s, uint32_t off, struct json_object *args) static struct { - struct uc_state *s; - uint32_t off; - struct json_object *fn; - struct json_object *args; - struct json_object *ex; + uc_vm *vm; + bool ex; + json_object *fn; } sort_ctx; static int sort_fn(const void *k1, const void *k2) { - struct json_object * const *v1 = k1; - struct json_object * const *v2 = k2; - struct json_object *rv; + json_object * const *v1 = k1; + json_object * const *v2 = k2; + json_object *rv; int ret; if (!sort_ctx.fn) - return !uc_cmp(T_LT, *v1, *v2); + return !uc_cmp(TK_LT, *v1, *v2); if (sort_ctx.ex) return 0; - json_object_array_put_idx(sort_ctx.args, 0, json_object_get(*v1)); - json_object_array_put_idx(sort_ctx.args, 1, json_object_get(*v2)); - - rv = uc_invoke(sort_ctx.s, sort_ctx.off, NULL, sort_ctx.fn, sort_ctx.args); + uc_vm_stack_push(sort_ctx.vm, uc_value_get(sort_ctx.fn)); + uc_vm_stack_push(sort_ctx.vm, uc_value_get(*v1)); + uc_vm_stack_push(sort_ctx.vm, uc_value_get(*v2)); - if (uc_is_type(rv, T_EXCEPTION)) { - sort_ctx.ex = rv; + if (uc_vm_call(sort_ctx.vm, false, 2)) { + sort_ctx.ex = true; return 0; } + rv = uc_vm_stack_pop(sort_ctx.vm); + ret = !uc_val_is_truish(rv); - json_object_put(rv); + uc_value_put(rv); return ret; } -static struct json_object * -uc_sort(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_sort(uc_vm *vm, size_t nargs) { - struct json_object *arr = json_object_array_get_idx(args, 0); - struct json_object *fn = json_object_array_get_idx(args, 1); + json_object *arr = uc_get_arg(0); + json_object *fn = uc_get_arg(1); if (!json_object_is_type(arr, json_type_array)) return NULL; - if (fn) { - sort_ctx.s = s; - sort_ctx.off = off; - sort_ctx.fn = fn; - sort_ctx.args = xjs_new_array(); - } + sort_ctx.vm = vm; + sort_ctx.fn = fn; json_object_array_sort(arr, sort_fn); - json_object_put(sort_ctx.args); - return sort_ctx.ex ? sort_ctx.ex : json_object_get(arr); + return sort_ctx.ex ? NULL : uc_value_get(arr); } -static struct json_object * -uc_splice(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_splice(uc_vm *vm, size_t nargs) { - struct json_object *arr = json_object_array_get_idx(args, 0); - int64_t ofs = uc_cast_int64(json_object_array_get_idx(args, 1)); - int64_t remlen = uc_cast_int64(json_object_array_get_idx(args, 2)); + json_object *arr = uc_get_arg(0); + int64_t ofs = uc_cast_int64(uc_get_arg(1)); + int64_t remlen = uc_cast_int64(uc_get_arg(2)); size_t arrlen, addlen, idx; if (!json_object_is_type(arr, json_type_array)) return NULL; arrlen = json_object_array_length(arr); - addlen = json_object_array_length(args); + addlen = nargs; if (addlen == 1) { ofs = 0; @@ -1068,26 +1024,26 @@ uc_splice(struct uc_state *s, uint32_t off, struct json_object *args) else if (addlen > remlen) { for (idx = arrlen; idx > ofs; idx--) json_object_array_put_idx(arr, idx + addlen - remlen - 1, - json_object_get(json_object_array_get_idx(arr, idx - 1))); + uc_value_get(json_object_array_get_idx(arr, idx - 1))); } for (idx = 0; idx < addlen; idx++) json_object_array_put_idx(arr, ofs + idx, - json_object_get(json_object_array_get_idx(args, 3 + idx))); + uc_value_get(uc_get_arg(3 + idx))); - return json_object_get(arr); + return uc_value_get(arr); } -static struct json_object * -uc_split(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_split(uc_vm *vm, size_t nargs) { - struct json_object *str = json_object_array_get_idx(args, 0); - struct json_object *sep = json_object_array_get_idx(args, 1); - struct json_object *arr = NULL; + json_object *str = uc_get_arg(0); + json_object *sep = uc_get_arg(1); + json_object *arr = NULL; const char *p, *sepstr, *splitstr; int eflags = 0, res; regmatch_t pmatch; - struct uc_op *tag; + uc_regexp *re; size_t seplen; if (!sep || !json_object_is_type(str, json_type_string)) @@ -1096,11 +1052,11 @@ uc_split(struct uc_state *s, uint32_t off, struct json_object *args) arr = xjs_new_array(); splitstr = json_object_get_string(str); - if (uc_is_type(sep, T_REGEXP)) { - tag = json_object_get_userdata(sep); + if (uc_object_is_type(sep, UC_OBJ_REGEXP)) { + re = uc_object_as_regexp(sep); while (true) { - res = regexec((regex_t *)tag->tag.data, splitstr, 1, &pmatch, eflags); + res = regexec(&re->re, splitstr, 1, &pmatch, eflags); if (res == REG_NOMATCH) break; @@ -1130,7 +1086,7 @@ uc_split(struct uc_state *s, uint32_t off, struct json_object *args) json_object_array_add(arr, xjs_new_string_len(splitstr, p - splitstr)); } else { - json_object_put(arr); + uc_value_put(arr); return NULL; } @@ -1138,12 +1094,12 @@ uc_split(struct uc_state *s, uint32_t off, struct json_object *args) return arr; } -static struct json_object * -uc_substr(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_substr(uc_vm *vm, size_t nargs) { - struct json_object *str = json_object_array_get_idx(args, 0); - int64_t ofs = uc_cast_int64(json_object_array_get_idx(args, 1)); - int64_t sublen = uc_cast_int64(json_object_array_get_idx(args, 2)); + json_object *str = uc_get_arg(0); + int64_t ofs = uc_cast_int64(uc_get_arg(1)); + int64_t sublen = uc_cast_int64(uc_get_arg(2)); const char *p; size_t len; @@ -1153,7 +1109,7 @@ uc_substr(struct uc_state *s, uint32_t off, struct json_object *args) p = json_object_get_string(str); len = json_object_get_string_len(str); - switch (json_object_array_length(args)) { + switch (nargs) { case 1: ofs = 0; sublen = len; @@ -1202,20 +1158,20 @@ uc_substr(struct uc_state *s, uint32_t off, struct json_object *args) return xjs_new_string_len(p + ofs, sublen); } -static struct json_object * -uc_time(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_time(uc_vm *vm, size_t nargs) { time_t t = time(NULL); return xjs_new_int64((int64_t)t); } -static struct json_object * -uc_uc(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uc(uc_vm *vm, size_t nargs) { - const char *str = json_object_get_string(json_object_array_get_idx(args, 0)); + const char *str = json_object_get_string(uc_get_arg(0)); size_t len = str ? strlen(str) : 0; - struct json_object *rv = NULL; + json_object *rv = NULL; char *res, *p; if (!str) @@ -1235,17 +1191,16 @@ uc_uc(struct uc_state *s, uint32_t off, struct json_object *args) return rv; } -static struct json_object * -uc_uchr(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uchr(uc_vm *vm, size_t nargs) { - size_t len = json_object_array_length(args); size_t idx, ulen; char *p, *str; int64_t n; int rem; - for (idx = 0, ulen = 0; idx < len; idx++) { - n = uc_cast_int64(json_object_array_get_idx(args, idx)); + for (idx = 0, ulen = 0; idx < nargs; idx++) { + n = uc_cast_int64(uc_get_arg(idx)); if (errno == EINVAL || errno == EOVERFLOW || n < 0 || n > 0x10FFFF) ulen += 3; @@ -1261,8 +1216,8 @@ uc_uchr(struct uc_state *s, uint32_t off, struct json_object *args) str = xalloc(ulen); - for (idx = 0, p = str, rem = ulen; idx < len; idx++) { - n = uc_cast_int64(json_object_array_get_idx(args, idx)); + for (idx = 0, p = str, rem = ulen; idx < nargs; idx++) { + n = uc_cast_int64(uc_get_arg(idx)); if (errno == EINVAL || errno == EOVERFLOW || n < 0 || n > 0x10FFFF) n = 0xFFFD; @@ -1274,11 +1229,11 @@ uc_uchr(struct uc_state *s, uint32_t off, struct json_object *args) return xjs_new_string_len(str, ulen); } -static struct json_object * -uc_values(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_values(uc_vm *vm, size_t nargs) { - struct json_object *obj = json_object_array_get_idx(args, 0); - struct json_object *arr; + json_object *obj = uc_get_arg(0); + json_object *arr; if (!json_object_is_type(obj, json_type_object)) return NULL; @@ -1287,17 +1242,17 @@ uc_values(struct uc_state *s, uint32_t off, struct json_object *args) json_object_object_foreach(obj, key, val) { (void)key; - json_object_array_add(arr, json_object_get(val)); + json_object_array_add(arr, uc_value_get(val)); } return arr; } -static struct json_object * -uc_trim_common(struct uc_state *s, uint32_t off, struct json_object *args, bool start, bool end) +static json_object * +uc_trim_common(uc_vm *vm, size_t nargs, bool start, bool end) { - struct json_object *str = json_object_array_get_idx(args, 0); - struct json_object *chr = json_object_array_get_idx(args, 1); + json_object *str = uc_get_arg(0); + json_object *chr = uc_get_arg(1); const char *p, *c; size_t len; @@ -1333,32 +1288,32 @@ uc_trim_common(struct uc_state *s, uint32_t off, struct json_object *args, bool return xjs_new_string_len(p, len); } -static struct json_object * -uc_trim(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_trim(uc_vm *vm, size_t nargs) { - return uc_trim_common(s, off, args, true, true); + return uc_trim_common(vm, nargs, true, true); } -static struct json_object * -uc_ltrim(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_ltrim(uc_vm *vm, size_t nargs) { - return uc_trim_common(s, off, args, true, false); + return uc_trim_common(vm, nargs, true, false); } -static struct json_object * -uc_rtrim(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_rtrim(uc_vm *vm, size_t nargs) { - return uc_trim_common(s, off, args, false, true); + return uc_trim_common(vm, nargs, false, true); } static size_t -uc_printf_common(struct uc_state *s, uint32_t off, struct json_object *args, char **res) +uc_printf_common(uc_vm *vm, size_t nargs, char **res) { - struct json_object *fmt = json_object_array_get_idx(args, 0); + json_object *fmt = uc_get_arg(0); char *fp, sfmt[sizeof("%0- 123456789.123456789%")]; union { const char *s; int64_t n; double d; } arg; - size_t len = 0, arglen, argidx; const char *fstr, *last, *p; + size_t len = 0, argidx = 1; enum json_type t; *res = NULL; @@ -1368,9 +1323,6 @@ uc_printf_common(struct uc_state *s, uint32_t off, struct json_object *args, cha else fstr = ""; - arglen = json_object_array_length(args); - argidx = 1; - for (last = p = fstr; *p; p++) { if (*p == '%') { snprintf_append(res, &len, "%s", p - last, last); @@ -1447,8 +1399,8 @@ uc_printf_common(struct uc_state *s, uint32_t off, struct json_object *args, cha case 'X': t = json_type_int; - if (argidx < arglen) - arg.n = uc_cast_int64(json_object_array_get_idx(args, argidx++)); + if (argidx < nargs) + arg.n = uc_cast_int64(uc_get_arg(argidx++)); else arg.n = 0; @@ -1462,8 +1414,8 @@ uc_printf_common(struct uc_state *s, uint32_t off, struct json_object *args, cha case 'G': t = json_type_double; - if (argidx < arglen) - arg.d = uc_cast_double(json_object_array_get_idx(args, argidx++)); + if (argidx < nargs) + arg.d = uc_cast_double(uc_get_arg(argidx++)); else arg.d = 0; @@ -1472,8 +1424,8 @@ uc_printf_common(struct uc_state *s, uint32_t off, struct json_object *args, cha case 'c': t = json_type_int; - if (argidx < arglen) - arg.n = uc_cast_int64(json_object_array_get_idx(args, argidx++)) & 0xff; + if (argidx < nargs) + arg.n = uc_cast_int64(uc_get_arg(argidx++)) & 0xff; else arg.n = 0; @@ -1482,8 +1434,8 @@ uc_printf_common(struct uc_state *s, uint32_t off, struct json_object *args, cha case 's': t = json_type_string; - if (argidx < arglen) - arg.s = json_object_get_string(json_object_array_get_idx(args, argidx++)); + if (argidx < nargs) + arg.s = json_object_get_string(uc_get_arg(argidx++)); else arg.s = NULL; @@ -1494,9 +1446,9 @@ uc_printf_common(struct uc_state *s, uint32_t off, struct json_object *args, cha case 'J': t = json_type_string; - if (argidx < arglen) + if (argidx < nargs) arg.s = json_object_to_json_string_ext( - json_object_array_get_idx(args, argidx++), + uc_get_arg(argidx++), JSON_C_TO_STRING_SPACED|JSON_C_TO_STRING_NOSLASHESCAPE|JSON_C_TO_STRING_STRICT); else arg.s = NULL; @@ -1543,14 +1495,14 @@ next: return len; } -static struct json_object * -uc_sprintf(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_sprintf(uc_vm *vm, size_t nargs) { - struct json_object *rv; + json_object *rv; char *str = NULL; size_t len; - len = uc_printf_common(s, off, args, &str); + len = uc_printf_common(vm, nargs, &str); rv = xjs_new_string_len(str, len); free(str); @@ -1558,13 +1510,13 @@ uc_sprintf(struct uc_state *s, uint32_t off, struct json_object *args) return rv; } -static struct json_object * -uc_printf(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_printf(uc_vm *vm, size_t nargs) { char *str = NULL; size_t len; - len = uc_printf_common(s, off, args, &str); + len = uc_printf_common(vm, nargs, &str); len = fwrite(str, 1, len, stdout); free(str); @@ -1572,121 +1524,108 @@ uc_printf(struct uc_state *s, uint32_t off, struct json_object *args) return xjs_new_int64(len); } -static struct json_object * -uc_require_so(struct uc_state *state, uint32_t off, const char *path) +static bool +uc_require_so(uc_vm *vm, const char *path, json_object **res) { - void (*init)(const struct uc_ops *, struct uc_state *, struct json_object *); - struct uc_function fn = {}, *prev_fn; - struct uc_source *src, *prev_src; - struct json_object *scope; + void (*init)(const uc_ops *, uc_prototype *); + uc_prototype *scope; struct stat st; void *dlh; if (stat(path, &st)) - return NULL; + return false; dlerror(); dlh = dlopen(path, RTLD_LAZY|RTLD_LOCAL); - if (!dlh) - return uc_new_exception(state, OP_POS(off), - "Unable to dlopen file %s: %s", path, dlerror()); - - init = dlsym(dlh, "uc_module_init"); + if (!dlh) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "Unable to dlopen file '%s': %s", path, dlerror()); - if (!init) - return uc_new_exception(state, OP_POS(off), - "Module %s provides no 'uc_module_init' function", path); - - src = xalloc(sizeof(*src)); - src->filename = xstrdup(path); - src->next = state->sources; + return true; + } - fn.name = "require"; - fn.source = src; + init = dlsym(dlh, "uc_module_entry"); - prev_fn = state->function; - state->function = &fn; + if (!init) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "Module '%s' provides no 'uc_module_entry' function", path); - prev_src = state->source; - state->source = state->sources = src; + return true; + } - scope = xjs_new_object(); + scope = uc_prototype_new(NULL); - init(&ut, state, scope); + init(&uc, scope); - state->source = prev_src; - state->function = prev_fn; + *res = scope->header.jso; - return scope; + return true; } -struct json_object * -uc_execute_source(struct uc_state *s, struct uc_source *src, struct uc_scope *scope) +static bool +uc_require_ucode(uc_vm *vm, const char *path, uc_prototype *scope, json_object **res) { - struct json_object *entry, *rv; + uc_exception_type_t extype; + uc_prototype *prev_scope; + uc_function *function; + uc_closure *closure; + uc_source *source; + struct stat st; + char *err; - rv = uc_parse(s, src->fp); + if (stat(path, &st)) + return false; - if (!uc_is_type(rv, T_EXCEPTION)) { - entry = uc_new_func(s, s->main, scope ? scope : s->scope); + source = uc_source_new_file(path); - json_object_put(rv); - rv = uc_invoke(s, s->main, NULL, entry, NULL); + if (!source) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "Unable to open file '%s': %s", path, strerror(errno)); - json_object_put(entry); + return true; } - return rv; -} + function = uc_compile(vm->config, source, &err); -static struct json_object * -uc_require_utpl(struct uc_state *state, uint32_t off, const char *path, struct uc_scope *scope) -{ - struct uc_function fn = {}, *prev_fn; - struct uc_source *src, *prev_src; - struct json_object *rv; - struct stat st; - FILE *fp; + if (!function) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "Unable to compile module '%s':\n%s", path, err); - if (stat(path, &st)) - return NULL; + uc_source_put(source); + free(err); - fp = fopen(path, "rb"); + return true; + } - if (!fp) - return uc_new_exception(state, OP_POS(off), - "Unable to open file %s: %s", path, strerror(errno)); + closure = uc_closure_new(function, false); - src = xalloc(sizeof(*src)); - src->fp = fp; - src->filename = path ? xstrdup(path) : NULL; - src->next = state->sources; + uc_vm_stack_push(vm, closure->header.jso); - prev_src = state->source; - state->source = state->sources = src; + prev_scope = vm->globals; + vm->globals = scope ? scope : prev_scope; - fn.name = "require"; - fn.source = src; + extype = uc_vm_call(vm, false, 0); - prev_fn = state->function; - state->function = &fn; + vm->globals = prev_scope; - rv = uc_execute_source(state, src, scope); + if (extype == EXCEPTION_NONE) + *res = uc_vm_stack_pop(vm); - state->function = prev_fn; - state->source = prev_src; + uc_source_put(source); - return rv; + return true; } -static struct json_object * -uc_require_path(struct uc_state *s, uint32_t off, const char *path_template, const char *name) +static bool +uc_require_path(uc_vm *vm, const char *path_template, const char *name, json_object **res) { - struct json_object *rv = NULL; const char *p, *q, *last; char *path = NULL; size_t plen = 0; + bool rv = false; + + *res = NULL; p = strchr(path_template, '*'); @@ -1711,9 +1650,9 @@ uc_require_path(struct uc_state *s, uint32_t off, const char *path_template, con } if (!strcmp(p, ".so")) - rv = uc_require_so(s, off, path); + rv = uc_require_so(vm, path, res); else if (!strcmp(p, ".uc")) - rv = uc_require_utpl(s, off, path, NULL); + rv = uc_require_ucode(vm, path, NULL, res); invalid: free(path); @@ -1721,56 +1660,49 @@ invalid: return rv; } -static struct json_object * -uc_require(struct uc_state *state, uint32_t off, struct json_object *args) +static json_object * +uc_require(uc_vm *vm, size_t nargs) { - struct json_object *val = json_object_array_get_idx(args, 0); - struct json_object *search, *se, *res; - struct uc_scope *sc, *scparent; + const char *name = json_object_get_string(uc_get_arg(0)); + + json_object *val = uc_get_arg(0); + json_object *search, *se, *res; size_t arridx, arrlen; - const char *name; if (!json_object_is_type(val, json_type_string)) return NULL; - /* find root scope */ - for (sc = state->scope; sc; ) { - scparent = uc_parent_scope(sc); + name = json_object_get_string(val); + search = vm->globals ? json_object_object_get(vm->globals->header.jso, "REQUIRE_SEARCH_PATH") : NULL; - if (!scparent) - break; + if (!json_object_is_type(search, json_type_array)) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "Global require search path not set"); - sc = scparent; + return NULL; } - name = json_object_get_string(val); - search = sc ? json_object_object_get(sc->scope, "REQUIRE_SEARCH_PATH") : NULL; - - if (!json_object_is_type(search, json_type_array)) - return uc_new_exception(state, off ? OP_POS(off) : 0, - "Global require search path not set"); - for (arridx = 0, arrlen = json_object_array_length(search); arridx < arrlen; arridx++) { se = json_object_array_get_idx(search, arridx); if (!json_object_is_type(se, json_type_string)) continue; - res = uc_require_path(state, off, json_object_get_string(se), name); - - if (res) + if (uc_require_path(vm, json_object_get_string(se), name, &res)) return res; } - return uc_new_exception(state, off ? OP_POS(off) : 0, - "No module named '%s' could be found", name); + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "No module named '%s' could be found", name); + + return NULL; } -static struct json_object * -uc_iptoarr(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_iptoarr(uc_vm *vm, size_t nargs) { - struct json_object *ip = json_object_array_get_idx(args, 0); - struct json_object *res; + json_object *ip = uc_get_arg(0); + json_object *res; union { uint8_t u8[4]; struct in_addr in; @@ -1804,7 +1736,7 @@ uc_iptoarr(struct uc_state *s, uint32_t off, struct json_object *args) } static int -check_byte(struct json_object *v) +check_byte(json_object *v) { int n; @@ -1819,10 +1751,10 @@ check_byte(struct json_object *v) return n; } -static struct json_object * -uc_arrtoip(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_arrtoip(uc_vm *vm, size_t nargs) { - struct json_object *arr = json_object_array_get_idx(args, 0); + json_object *arr = uc_get_arg(0); union { uint8_t u8[4]; struct in6_addr in6; @@ -1867,24 +1799,25 @@ uc_arrtoip(struct uc_state *s, uint32_t off, struct json_object *args) } } -static struct json_object * -uc_match(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_match(uc_vm *vm, size_t nargs) { - struct json_object *subject = json_object_array_get_idx(args, 0); - struct json_object *pattern = json_object_array_get_idx(args, 1); - struct uc_op *tag = json_object_get_userdata(pattern); - struct json_object *rv = NULL, *m; + json_object *subject = uc_get_arg(0); + json_object *pattern = uc_get_arg(1); + json_object *rv = NULL, *m; int eflags = 0, res, i; regmatch_t pmatch[10]; + uc_regexp *re; const char *p; - if (!uc_is_type(pattern, T_REGEXP) || !subject) + if (!uc_object_is_type(pattern, UC_OBJ_REGEXP) || !subject) return NULL; p = json_object_get_string(subject); + re = uc_object_as_regexp(pattern); while (true) { - res = regexec((regex_t *)tag->tag.data, p, ARRAY_SIZE(pmatch), pmatch, eflags); + res = regexec(&re->re, p, ARRAY_SIZE(pmatch), pmatch, eflags); if (res == REG_NOMATCH) break; @@ -1897,7 +1830,7 @@ uc_match(struct uc_state *s, uint32_t off, struct json_object *args) pmatch[i].rm_eo - pmatch[i].rm_so)); } - if (tag->is_reg_global) { + if (re->global) { if (!rv) rv = xjs_new_array(); @@ -1915,39 +1848,37 @@ uc_match(struct uc_state *s, uint32_t off, struct json_object *args) return rv; } -static struct json_object * -uc_replace_cb(struct uc_state *s, uint32_t off, struct json_object *func, +static json_object * +uc_replace_cb(uc_vm *vm, json_object *func, const char *subject, regmatch_t *pmatch, size_t plen, char **sp, size_t *sl) { - struct json_object *cbargs = xjs_new_array(); - struct json_object *rv; + json_object *rv; size_t i; + /* XXX: revisit leaks */ + uc_vm_stack_push(vm, uc_value_get(func)); + for (i = 0; i < plen && pmatch[i].rm_so != -1; i++) { - json_object_array_add(cbargs, + uc_vm_stack_push(vm, xjs_new_string_len(subject + pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so)); } - rv = uc_invoke(s, off, NULL, func, cbargs); - - if (uc_is_type(rv, T_EXCEPTION)) { - json_object_put(cbargs); + if (uc_vm_call(vm, false, i)) + return NULL; - return rv; - } + rv = uc_vm_stack_pop(vm); sprintf_append(sp, sl, "%s", rv ? json_object_get_string(rv) : "null"); - json_object_put(cbargs); - json_object_put(rv); + uc_value_put(rv); return NULL; } static void -uc_replace_str(struct uc_state *s, uint32_t off, struct json_object *str, +uc_replace_str(uc_vm *vm, json_object *str, const char *subject, regmatch_t *pmatch, size_t plen, char **sp, size_t *sl) { @@ -2011,36 +1942,37 @@ uc_replace_str(struct uc_state *s, uint32_t off, struct json_object *str, } } -static struct json_object * -uc_replace(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_replace(uc_vm *vm, size_t nargs) { - struct json_object *subject = json_object_array_get_idx(args, 0); - struct json_object *pattern = json_object_array_get_idx(args, 1); - struct json_object *replace = json_object_array_get_idx(args, 2); - struct uc_op *tag = json_object_get_userdata(pattern); - struct json_object *rv = NULL; + json_object *subject = uc_get_arg(0); + json_object *pattern = uc_get_arg(1); + json_object *replace = uc_get_arg(2); + json_object *rv = NULL; const char *sb, *p, *l; regmatch_t pmatch[10]; int eflags = 0, res; size_t sl = 0, pl; char *sp = NULL; + uc_regexp *re; if (!pattern || !subject || !replace) return NULL; - if (uc_is_type(pattern, T_REGEXP)) { + if (uc_object_is_type(pattern, UC_OBJ_REGEXP)) { p = json_object_get_string(subject); + re = uc_object_as_regexp(pattern); while (true) { - res = regexec((regex_t *)tag->tag.data, p, ARRAY_SIZE(pmatch), pmatch, eflags); + res = regexec(&re->re, p, ARRAY_SIZE(pmatch), pmatch, eflags); if (res == REG_NOMATCH) break; snprintf_append(&sp, &sl, "%s", pmatch[0].rm_so, p); - if (uc_is_type(replace, T_FUNC) || uc_is_type(replace, T_CFUNC)) { - rv = uc_replace_cb(s, off, replace, p, pmatch, ARRAY_SIZE(pmatch), &sp, &sl); + if (uc_object_is_callable(replace)) { + rv = uc_replace_cb(vm, replace, p, pmatch, ARRAY_SIZE(pmatch), &sp, &sl); if (rv) { free(sp); @@ -2049,12 +1981,12 @@ uc_replace(struct uc_state *s, uint32_t off, struct json_object *args) } } else { - uc_replace_str(s, off, replace, p, pmatch, ARRAY_SIZE(pmatch), &sp, &sl); + uc_replace_str(vm, replace, p, pmatch, ARRAY_SIZE(pmatch), &sp, &sl); } p += pmatch[0].rm_eo; - if (tag->is_reg_global) + if (re->global) eflags |= REG_NOTBOL; else break; @@ -2074,8 +2006,8 @@ uc_replace(struct uc_state *s, uint32_t off, struct json_object *args) pmatch[0].rm_so = sb - l; pmatch[0].rm_eo = pmatch[0].rm_so + pl; - if (uc_is_type(replace, T_FUNC) || uc_is_type(replace, T_CFUNC)) { - rv = uc_replace_cb(s, off, replace, l, pmatch, 1, &sp, &sl); + if (uc_object_is_callable(replace)) { + rv = uc_replace_cb(vm, replace, l, pmatch, 1, &sp, &sl); if (rv) { free(sp); @@ -2084,7 +2016,7 @@ uc_replace(struct uc_state *s, uint32_t off, struct json_object *args) } } else { - uc_replace_str(s, off, replace, l, pmatch, 1, &sp, &sl); + uc_replace_str(vm, replace, l, pmatch, 1, &sp, &sl); } l = sb + pl; @@ -2101,18 +2033,21 @@ uc_replace(struct uc_state *s, uint32_t off, struct json_object *args) return rv; } -static struct json_object * -uc_json(struct uc_state *state, uint32_t off, struct json_object *args) +static json_object * +uc_json(uc_vm *vm, size_t nargs) { - struct json_object *rv, *src = json_object_array_get_idx(args, 0); + json_object *rv, *src = uc_get_arg(0); struct json_tokener *tok = NULL; enum json_tokener_error err; const char *str; size_t len; - if (!json_object_is_type(src, json_type_string)) - return uc_new_exception(state, OP_POS(off), - "Passed value is not a string"); + if (!json_object_is_type(src, json_type_string)) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "Passed value is not a string"); + + return NULL; + } tok = xjs_new_tokener(); str = json_object_get_string(src); @@ -2122,20 +2057,26 @@ uc_json(struct uc_state *state, uint32_t off, struct json_object *args) err = json_tokener_get_error(tok); if (err == json_tokener_continue) { - json_object_put(rv); - rv = uc_new_exception(state, OP_POS(off), + uc_value_put(rv); + uc_vm_raise_exception(vm, EXCEPTION_SYNTAX, "Unexpected end of string in JSON data"); + + return NULL; } else if (err != json_tokener_success) { - json_object_put(rv); - rv = uc_new_exception(state, OP_POS(off), + uc_value_put(rv); + uc_vm_raise_exception(vm, EXCEPTION_SYNTAX, "Failed to parse JSON string: %s", json_tokener_error_desc(err)); + + return NULL; } else if (json_tokener_get_parse_end(tok) < len) { - json_object_put(rv); - rv = uc_new_exception(state, OP_POS(off), + uc_value_put(rv); + uc_vm_raise_exception(vm, EXCEPTION_SYNTAX, "Trailing garbage after JSON data"); + + return NULL; } json_tokener_free(tok); @@ -2176,64 +2117,83 @@ include_path(const char *curpath, const char *incpath) return dup; } -static struct json_object * -uc_include(struct uc_state *state, uint32_t off, struct json_object *args) +static json_object * +uc_include(uc_vm *vm, size_t nargs) { - struct json_object *rv, *path = json_object_array_get_idx(args, 0); - struct json_object *scope = json_object_array_get_idx(args, 1); - struct uc_scope *sc; + json_object *path = uc_get_arg(0); + json_object *scope = uc_get_arg(1); + json_object *rv = NULL; + uc_closure *closure = NULL; + uc_prototype *sc; + size_t i; char *p; - if (!json_object_is_type(path, json_type_string)) - return uc_new_exception(state, OP_POS(off), - "Passed filename is not a string"); + if (!json_object_is_type(path, json_type_string)) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "Passed filename is not a string"); - if (scope && !json_object_is_type(scope, json_type_object)) - return uc_new_exception(state, OP_POS(off), - "Passed scope value is not an object"); + return NULL; + } - p = include_path(state->callstack->function->source->filename, json_object_get_string(path)); + if (scope && !json_object_is_type(scope, json_type_object)) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "Passed scope value is not an object"); - if (!p) - return uc_new_exception(state, OP_POS(off), - "Include file not found"); + return NULL; + } + + /* find calling closure */ + for (i = vm->callframes.count; i > 0; i--) { + closure = vm->callframes.entries[i - 1].closure; + + if (closure) + break; + } + + if (!closure) + return NULL; + + p = include_path(closure->function->source->filename, json_object_get_string(path)); + + if (!p) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "Include file not found"); + + return NULL; + } if (scope) { - sc = uc_new_scope(state, NULL); + sc = uc_prototype_new(NULL); json_object_object_foreach(scope, key, val) - json_object_object_add(sc->scope, key, json_object_get(val)); + json_object_object_add(sc->header.jso, key, uc_value_get(val)); } else { - sc = state->scope; + sc = vm->globals; } - rv = uc_require_utpl(state, off, p, sc); + if (uc_require_ucode(vm, p, sc, &rv)) + uc_value_put(rv); free(p); if (scope) - json_object_put(sc->scope); - - if (uc_is_type(rv, T_EXCEPTION)) - return rv; - - json_object_put(rv); + uc_value_put(sc->header.jso); return NULL; } -static struct json_object * -uc_warn(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_warn(uc_vm *vm, size_t nargs) { - return uc_print_common(s, off, args, stderr); + return uc_print_common(vm, nargs, stderr); } -static struct json_object * -uc_system(struct uc_state *state, uint32_t off, struct json_object *args) +static json_object * +uc_system(uc_vm *vm, size_t nargs) { - struct json_object *cmdline = json_object_array_get_idx(args, 0); - struct json_object *timeout = json_object_array_get_idx(args, 1); + json_object *cmdline = uc_get_arg(0); + json_object *timeout = uc_get_arg(1); sigset_t sigmask, sigomask; const char **arglist, *fn; struct timespec ts; @@ -2262,13 +2222,18 @@ uc_system(struct uc_state *state, uint32_t off, struct json_object *args) break; default: - return uc_new_exception(state, OP_POS(off), - "Passed command is neither string nor array"); + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "Passed command is neither string nor array"); + + return NULL; } - if (timeout && (!json_object_is_type(timeout, json_type_int) || json_object_get_int64(timeout) < 0)) - return uc_new_exception(state, OP_POS(off), - "Invalid timeout specified"); + if (timeout && (!json_object_is_type(timeout, json_type_int) || json_object_get_int64(timeout) < 0)) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "Invalid timeout specified"); + + return NULL; + } tms = timeout ? json_object_get_int64(timeout) : 0; @@ -2339,22 +2304,31 @@ fail: sigprocmask(SIG_SETMASK, &sigomask, NULL); free(arglist); - return uc_new_exception(state, OP_POS(off), - "%s(): %s", fn, strerror(errno)); + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "%s(): %s", fn, strerror(errno)); + + return NULL; } -const struct uc_ops ut = { - .register_function = uc_register_function, - .register_type = uc_register_extended_type, - .set_type = uc_set_extended_type, - .get_type = uc_get_extended_type, - .new_object = uc_new_object, - .new_double = uc_new_double, - .invoke = uc_invoke, - .cast_number = uc_cast_number, -}; +static json_object * +uc_trace(uc_vm *vm, size_t nargs) +{ + json_object *level = uc_get_arg(0); + uint8_t prev_level; -static const struct { const char *name; uc_c_fn *func; } functions[] = { + if (!json_object_is_type(level, json_type_int)) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Invalid level specified"); + + return NULL; + } + + prev_level = vm->trace; + vm->trace = json_object_get_int64(level); + + return xjs_new_int64(prev_level); +} + +static const uc_cfunction_list functions[] = { { "chr", uc_chr }, { "delete", uc_delete }, { "die", uc_die }, @@ -2401,14 +2375,12 @@ static const struct { const char *name; uc_c_fn *func; } functions[] = { { "include", uc_include }, { "warn", uc_warn }, { "system", uc_system }, + { "trace", uc_trace }, }; void -uc_lib_init(struct uc_state *state, struct json_object *scope) +uc_lib_init(uc_prototype *scope) { - int i; - - for (i = 0; i < sizeof(functions) / sizeof(functions[0]); i++) - uc_register_function(state, scope, functions[i].name, functions[i].func); + uc_add_proto_functions(scope, functions); } diff --git a/lib.h b/lib.h index 409cfc4..c14d11d 100644 --- a/lib.h +++ b/lib.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Jo-Philipp Wich + * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -17,17 +17,187 @@ #ifndef __LIB_H_ #define __LIB_H_ -#include "ast.h" +#include "vm.h" #include "lexer.h" +#include "object.h" -typedef struct json_object *(uc_c_fn)(struct uc_state *, uint32_t, struct json_object *); +typedef struct { + const char *name; + uc_cfn_ptr func; +} uc_cfunction_list; -void uc_lib_init(struct uc_state *state, struct json_object *scope); +typedef struct { + /* value operations */ + struct { + uc_prototype *(*proto)(uc_prototype *); + uc_cfunction *(*cfunc)(const char *, uc_cfn_ptr); + json_object *(*dbl)(double); + uc_regexp *(*regexp)(const char *, bool, bool, bool, char **); + uc_ressource *(*ressource)(json_object *, uc_ressource_type *, void *); + enum json_type (*tonumber)(json_object *, int64_t *, double *); + } value; -struct json_object *uc_execute_source(struct uc_state *s, struct uc_source *src, struct uc_scope *scope); + /* ressource operations */ + struct { + uc_ressource_type *(*define)(const char *, uc_prototype *, void (*)(void *)); + uc_ressource *(*create)(json_object *, uc_ressource_type *, void *); + void **(*data)(json_object *, const char *); + uc_prototype *(*proto)(json_object *); + } ressource; -struct json_object *uc_parse_error(struct uc_state *s, uint32_t off, uint64_t *tokens, int max_token); + /* VM operations */ + struct { + uc_exception_type_t (*call)(uc_vm *, bool, size_t); + json_object *(*peek)(uc_vm *, size_t); + json_object *(*pop)(uc_vm *); + void (*push)(uc_vm *, json_object *); + void (*raise)(uc_vm *, uc_exception_type_t, const char *, ...); + } vm; +} uc_ops; -char *uc_format_error(struct uc_state *state, FILE *fp); +extern const uc_ops uc; + +void uc_lib_init(uc_prototype *scope); + +void format_source_context(char **msg, size_t *msglen, uc_source *src, size_t off, bool compact); +void format_error_context(char **msg, size_t *msglen, uc_source *src, json_object *stacktrace, size_t off); + + +/* vm helper */ + +static inline void * +_uc_get_self(const uc_ops *ops, uc_vm *vm, const char *expected_type) +{ + return ops->ressource.data(vm->callframes.entries[vm->callframes.count - 1].ctx, expected_type); +} + +#define uc_get_self(...) _uc_get_self(ops, vm, __VA_ARGS__) + +static inline json_object * +_uc_get_arg(const uc_ops *ops, uc_vm *vm, size_t nargs, size_t n) +{ + if (n >= nargs) + return NULL; + + return ops->vm.peek(vm, nargs - n - 1); +} + +#define uc_get_arg(...) _uc_get_arg(ops, vm, nargs, __VA_ARGS__) + +#define uc_call(nargs) ops->vm.call(vm, false, nargs) +#define uc_push_val(val) ops->vm.push(vm, val) +#define uc_pop_val() ops->vm.pop(vm) + + +/* value helper */ + +static inline json_object * +_uc_alloc_proto(const uc_ops *ops, uc_prototype *parent) +{ + return ops->value.proto(parent)->header.jso; +} + +static inline json_object * +_uc_alloc_cfunc(const uc_ops *ops, const char *name, uc_cfn_ptr fptr) +{ + return ops->value.cfunc(name, fptr)->header.jso; +} + +static inline json_object * +_uc_alloc_double(const uc_ops *ops, double dbl) +{ + return ops->value.dbl(dbl); +} + +static inline json_object * +_uc_alloc_regexp(const uc_ops *ops, const char *pattern, bool global, bool icase, bool newline, char **errp) +{ + uc_regexp *re = ops->value.regexp(pattern, global, icase, newline, errp); + + return re ? re->header.jso : NULL; +} + +static inline json_object * +_uc_alloc_ressource(const uc_ops *ops, uc_ressource_type *type, void *data) +{ + uc_ressource *res = ops->value.ressource(xjs_new_object(), type, data); + + return res ? res->header.jso : NULL; +} + +#define uc_alloc_proto(...) _uc_alloc_proto(ops, __VA_ARGS__) +#define uc_alloc_cfunc(...) _uc_alloc_cfunc(ops, __VA_ARGS__) +#define uc_alloc_double(...) _uc_alloc_double(ops, __VA_ARGS__) +#define uc_alloc_regexp(...) _uc_alloc_regexp(ops, __VA_ARGS__) +#define uc_alloc_ressource(...) _uc_alloc_ressource(ops, __VA_ARGS__) + +static inline json_type +_uc_to_number(const uc_ops *ops, json_object *v, int64_t *n, double *d) +{ + return ops->value.tonumber(v, n, d); +} + +static inline double +_uc_to_double(const uc_ops *ops, json_object *v) +{ + int64_t n; + double d; + + return (ops->value.tonumber(v, &n, &d) == json_type_double) ? d : (double)n; +} + +static inline int64_t +_uc_to_int64(const uc_ops *ops, json_object *v) +{ + int64_t n; + double d; + + return (ops->value.tonumber(v, &n, &d) == json_type_double) ? (int64_t)d : n; +} + +#define uc_to_number(...) _uc_to_number(ops, __VA_ARGS__) +#define uc_to_double(...) _uc_to_double(ops, __VA_ARGS__) +#define uc_to_int64(...) _uc_to_int64(ops, __VA_ARGS__) + + +/* ressource type helper */ + +static inline uc_ressource_type * +_uc_declare_type(const uc_ops *ops, const char *name, const uc_cfunction_list *list, size_t len, void (*freefn)(void *)) +{ + uc_prototype *proto = ops->value.proto(NULL); + + while (len-- > 0) + json_object_object_add(proto->header.jso, list[len].name, + _uc_alloc_cfunc(ops, list[len].name, list[len].func)); + + return ops->ressource.define(name, proto, freefn); +} + +#define uc_declare_type(name, functions, freefn) \ + _uc_declare_type(ops, name, functions, ARRAY_SIZE(functions), freefn) + + +/* prototype helper */ + +static inline bool +uc_add_proto_val(uc_prototype *proto, const char *key, json_object *value) +{ + if (!proto) + return false; + + return json_object_object_add(proto->header.jso, key, value); +} + +static inline void +_uc_add_proto_functions(const uc_ops *ops, uc_prototype *proto, const uc_cfunction_list *list, size_t len) +{ + while (len-- > 0) + json_object_object_add(proto->header.jso, list[len].name, + _uc_alloc_cfunc(ops, list[len].name, list[len].func)); +} + +#define uc_add_proto_functions(proto, functions) \ + _uc_add_proto_functions(ops, proto, functions, ARRAY_SIZE(functions)) #endif /* __LIB_H_ */ diff --git a/lib/fs.c b/lib/fs.c index 1e148c3..c6066cc 100644 --- a/lib/fs.c +++ b/lib/fs.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Jo-Philipp Wich + * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -14,8 +14,6 @@ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#include "../module.h" - #include #include #include @@ -25,16 +23,19 @@ #include #include +#include "../module.h" + #define err_return(err) do { last_error = err; return NULL; } while(0) -static const struct uc_ops *ops; +//static const uc_ops *ops; +static uc_ressource_type *file_type, *proc_type, *dir_type; static int last_error = 0; -static struct json_object * -uc_fs_error(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_error(uc_vm *vm, size_t nargs) { - struct json_object *errmsg; + json_object *errmsg; if (last_error == 0) return NULL; @@ -45,17 +46,17 @@ uc_fs_error(struct uc_state *s, uint32_t off, struct json_object *args) return errmsg; } -static struct json_object * -uc_fs_read_common(struct uc_state *s, uint32_t off, struct json_object *args, const char *type) +static json_object * +uc_fs_read_common(uc_vm *vm, size_t nargs, const char *type) { - struct json_object *limit = json_object_array_get_idx(args, 0); - struct json_object *rv = NULL; + json_object *limit = uc_get_arg(0); + json_object *rv = NULL; char buf[128], *p = NULL, *tmp; size_t rlen, len = 0; const char *lstr; int64_t lsize; - FILE **fp = (FILE **)ops->get_type(s->ctx, type); + FILE **fp = uc_get_self(type); if (!fp || !*fp) err_return(EBADF); @@ -137,14 +138,14 @@ uc_fs_read_common(struct uc_state *s, uint32_t off, struct json_object *args, co return rv; } -static struct json_object * -uc_fs_write_common(struct uc_state *s, uint32_t off, struct json_object *args, const char *type) +static json_object * +uc_fs_write_common(uc_vm *vm, size_t nargs, const char *type) { - struct json_object *data = json_object_array_get_idx(args, 0); + json_object *data = uc_get_arg(0); size_t len, wsize; const char *str; - FILE **fp = (FILE **)ops->get_type(s->ctx, type); + FILE **fp = uc_get_self(type); if (!fp || !*fp) err_return(EBADF); @@ -167,10 +168,10 @@ uc_fs_write_common(struct uc_state *s, uint32_t off, struct json_object *args, c } -static struct json_object * -uc_fs_pclose(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_pclose(uc_vm *vm, size_t nargs) { - FILE **fp = (FILE **)ops->get_type(s->ctx, "fs.proc"); + FILE **fp = uc_get_self("fs.proc"); int rc; if (!fp || !*fp) @@ -191,24 +192,23 @@ uc_fs_pclose(struct uc_state *s, uint32_t off, struct json_object *args) return xjs_new_int64(0); } -static struct json_object * -uc_fs_pread(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_pread(uc_vm *vm, size_t nargs) { - return uc_fs_read_common(s, off, args, "fs.proc"); + return uc_fs_read_common(vm, nargs, "fs.proc"); } -static struct json_object * -uc_fs_pwrite(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_pwrite(uc_vm *vm, size_t nargs) { - return uc_fs_write_common(s, off, args, "fs.proc"); + return uc_fs_write_common(vm, nargs, "fs.proc"); } -static struct json_object * -uc_fs_popen(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_popen(uc_vm *vm, size_t nargs) { - struct json_object *comm = json_object_array_get_idx(args, 0); - struct json_object *mode = json_object_array_get_idx(args, 1); - struct json_object *fo; + json_object *comm = uc_get_arg(0); + json_object *mode = uc_get_arg(1); FILE *fp; if (!json_object_is_type(comm, json_type_string)) @@ -220,21 +220,14 @@ uc_fs_popen(struct uc_state *s, uint32_t off, struct json_object *args) if (!fp) err_return(errno); - fo = json_object_new_object(); - - if (!fo) { - pclose(fp); - err_return(ENOMEM); - } - - return ops->set_type(fo, "fs.proc", fp); + return uc_alloc_ressource(proc_type, fp); } -static struct json_object * -uc_fs_close(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_close(uc_vm *vm, size_t nargs) { - FILE **fp = (FILE **)ops->get_type(s->ctx, "fs.file"); + FILE **fp = uc_get_self("fs.file"); if (!fp || !*fp) err_return(EBADF); @@ -245,27 +238,27 @@ uc_fs_close(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_fs_read(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_read(uc_vm *vm, size_t nargs) { - return uc_fs_read_common(s, off, args, "fs.file"); + return uc_fs_read_common(vm, nargs, "fs.file"); } -static struct json_object * -uc_fs_write(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_write(uc_vm *vm, size_t nargs) { - return uc_fs_write_common(s, off, args, "fs.file"); + return uc_fs_write_common(vm, nargs, "fs.file"); } -static struct json_object * -uc_fs_seek(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_seek(uc_vm *vm, size_t nargs) { - struct json_object *ofs = json_object_array_get_idx(args, 0); - struct json_object *how = json_object_array_get_idx(args, 1); + json_object *ofs = uc_get_arg(0); + json_object *how = uc_get_arg(1); int whence, res; long offset; - FILE **fp = (FILE **)ops->get_type(s->ctx, "fs.file"); + FILE **fp = uc_get_self("fs.file"); if (!fp || !*fp) err_return(EBADF); @@ -292,12 +285,12 @@ uc_fs_seek(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_fs_tell(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_tell(uc_vm *vm, size_t nargs) { long offset; - FILE **fp = (FILE **)ops->get_type(s->ctx, "fs.file"); + FILE **fp = uc_get_self("fs.file"); if (!fp || !*fp) err_return(EBADF); @@ -310,12 +303,11 @@ uc_fs_tell(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_int64(offset); } -static struct json_object * -uc_fs_open(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_open(uc_vm *vm, size_t nargs) { - struct json_object *path = json_object_array_get_idx(args, 0); - struct json_object *mode = json_object_array_get_idx(args, 1); - struct json_object *fo; + json_object *path = uc_get_arg(0); + json_object *mode = uc_get_arg(1); FILE *fp; if (!json_object_is_type(path, json_type_string)) @@ -327,21 +319,14 @@ uc_fs_open(struct uc_state *s, uint32_t off, struct json_object *args) if (!fp) err_return(errno); - fo = json_object_new_object(); - - if (!fo) { - fclose(fp); - err_return(ENOMEM); - } - - return ops->set_type(fo, "fs.file", fp); + return uc_alloc_ressource(file_type, fp); } -static struct json_object * -uc_fs_readdir(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_readdir(uc_vm *vm, size_t nargs) { - DIR **dp = (DIR **)ops->get_type(s->ctx, "fs.dir"); + DIR **dp = uc_get_self("fs.dir"); struct dirent *e; if (!dp || !*dp) @@ -356,10 +341,10 @@ uc_fs_readdir(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_string(e->d_name); } -static struct json_object * -uc_fs_telldir(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_telldir(uc_vm *vm, size_t nargs) { - DIR **dp = (DIR **)ops->get_type(s->ctx, "fs.dir"); + DIR **dp = uc_get_self("fs.dir"); long position; if (!dp || !*dp) @@ -373,11 +358,11 @@ uc_fs_telldir(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_int64((int64_t)position); } -static struct json_object * -uc_fs_seekdir(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_seekdir(uc_vm *vm, size_t nargs) { - struct json_object *ofs = json_object_array_get_idx(args, 0); - DIR **dp = (DIR **)ops->get_type(s->ctx, "fs.dir"); + json_object *ofs = uc_get_arg(0); + DIR **dp = uc_get_self("fs.dir"); long position; if (!json_object_is_type(ofs, json_type_int)) @@ -393,10 +378,10 @@ uc_fs_seekdir(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_fs_closedir(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_closedir(uc_vm *vm, size_t nargs) { - DIR **dp = (DIR **)ops->get_type(s->ctx, "fs.dir"); + DIR **dp = uc_get_self("fs.dir"); if (!dp || !*dp) err_return(EBADF); @@ -407,11 +392,10 @@ uc_fs_closedir(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_fs_opendir(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_opendir(uc_vm *vm, size_t nargs) { - struct json_object *path = json_object_array_get_idx(args, 0); - struct json_object *diro; + json_object *path = uc_get_arg(0); DIR *dp; if (!json_object_is_type(path, json_type_string)) @@ -422,21 +406,14 @@ uc_fs_opendir(struct uc_state *s, uint32_t off, struct json_object *args) if (!dp) err_return(errno); - diro = json_object_new_object(); - - if (!diro) { - closedir(dp); - err_return(ENOMEM); - } - - return ops->set_type(diro, "fs.dir", dp); + return uc_alloc_ressource(dir_type, dp); } -static struct json_object * -uc_fs_readlink(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_readlink(uc_vm *vm, size_t nargs) { - struct json_object *path = json_object_array_get_idx(args, 0); - struct json_object *res; + json_object *path = uc_get_arg(0); + json_object *res; ssize_t buflen = 0, rv; char *buf = NULL, *tmp; @@ -472,11 +449,11 @@ uc_fs_readlink(struct uc_state *s, uint32_t off, struct json_object *args) return res; } -static struct json_object * -uc_fs_stat_common(struct uc_state *s, uint32_t off, struct json_object *args, bool use_lstat) +static json_object * +uc_fs_stat_common(uc_vm *vm, size_t nargs, bool use_lstat) { - struct json_object *path = json_object_array_get_idx(args, 0); - struct json_object *res, *o; + json_object *path = uc_get_arg(0); + json_object *res, *o; struct stat st; int rv; @@ -556,23 +533,23 @@ uc_fs_stat_common(struct uc_state *s, uint32_t off, struct json_object *args, bo return res; } -static struct json_object * -uc_fs_stat(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_stat(uc_vm *vm, size_t nargs) { - return uc_fs_stat_common(s, off, args, false); + return uc_fs_stat_common(vm, nargs, false); } -static struct json_object * -uc_fs_lstat(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_lstat(uc_vm *vm, size_t nargs) { - return uc_fs_stat_common(s, off, args, true); + return uc_fs_stat_common(vm, nargs, true); } -static struct json_object * -uc_fs_mkdir(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_mkdir(uc_vm *vm, size_t nargs) { - struct json_object *path = json_object_array_get_idx(args, 0); - struct json_object *mode = json_object_array_get_idx(args, 1); + json_object *path = uc_get_arg(0); + json_object *mode = uc_get_arg(1); if (!json_object_is_type(path, json_type_string) || (mode && !json_object_is_type(mode, json_type_int))) @@ -584,10 +561,10 @@ uc_fs_mkdir(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_fs_rmdir(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_rmdir(uc_vm *vm, size_t nargs) { - struct json_object *path = json_object_array_get_idx(args, 0); + json_object *path = uc_get_arg(0); if (!json_object_is_type(path, json_type_string)) err_return(EINVAL); @@ -598,11 +575,11 @@ uc_fs_rmdir(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_fs_symlink(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_symlink(uc_vm *vm, size_t nargs) { - struct json_object *dest = json_object_array_get_idx(args, 0); - struct json_object *path = json_object_array_get_idx(args, 1); + json_object *dest = uc_get_arg(0); + json_object *path = uc_get_arg(1); if (!json_object_is_type(dest, json_type_string) || !json_object_is_type(path, json_type_string)) @@ -614,10 +591,10 @@ uc_fs_symlink(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_fs_unlink(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_unlink(uc_vm *vm, size_t nargs) { - struct json_object *path = json_object_array_get_idx(args, 0); + json_object *path = uc_get_arg(0); if (!json_object_is_type(path, json_type_string)) err_return(EINVAL); @@ -628,10 +605,10 @@ uc_fs_unlink(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_fs_getcwd(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_getcwd(uc_vm *vm, size_t nargs) { - struct json_object *res; + json_object *res; char *buf = NULL, *tmp; size_t buflen = 0; @@ -663,10 +640,10 @@ uc_fs_getcwd(struct uc_state *s, uint32_t off, struct json_object *args) return res; } -static struct json_object * -uc_fs_chdir(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_fs_chdir(uc_vm *vm, size_t nargs) { - struct json_object *path = json_object_array_get_idx(args, 0); + json_object *path = uc_get_arg(0); if (!json_object_is_type(path, json_type_string)) err_return(EINVAL); @@ -677,13 +654,13 @@ uc_fs_chdir(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static const struct { const char *name; uc_c_fn *func; } proc_fns[] = { +static const uc_cfunction_list proc_fns[] = { { "read", uc_fs_pread }, { "write", uc_fs_pwrite }, { "close", uc_fs_pclose }, }; -static const struct { const char *name; uc_c_fn *func; } file_fns[] = { +static const uc_cfunction_list file_fns[] = { { "read", uc_fs_read }, { "write", uc_fs_write }, { "seek", uc_fs_seek }, @@ -691,14 +668,14 @@ static const struct { const char *name; uc_c_fn *func; } file_fns[] = { { "close", uc_fs_close }, }; -static const struct { const char *name; uc_c_fn *func; } dir_fns[] = { +static const uc_cfunction_list dir_fns[] = { { "read", uc_fs_readdir }, { "seek", uc_fs_seekdir }, { "tell", uc_fs_telldir }, { "close", uc_fs_closedir }, }; -static const struct { const char *name; uc_c_fn *func; } global_fns[] = { +static const uc_cfunction_list global_fns[] = { { "error", uc_fs_error }, { "open", uc_fs_open }, { "opendir", uc_fs_opendir }, @@ -715,40 +692,39 @@ static const struct { const char *name; uc_c_fn *func; } global_fns[] = { }; -static void close_proc(void *ud) { - pclose((FILE *)ud); +static void close_proc(void *ud) +{ + FILE *fp = ud; + + if (fp) + pclose(fp); } -static void close_file(void *ud) { +static void close_file(void *ud) +{ FILE *fp = ud; - if (fp != stdin && fp != stdout && fp != stderr) + if (fp && fp != stdin && fp != stdout && fp != stderr) fclose(fp); } -static void close_dir(void *ud) { - closedir((DIR *)ud); -} - -void uc_module_init(const struct uc_ops *ut, struct uc_state *s, struct json_object *scope) +static void close_dir(void *ud) { - struct json_object *proc_proto, *file_proto, *dir_proto; + DIR *dp = ud; - ops = ut; - proc_proto = ops->new_object(NULL); - file_proto = ops->new_object(NULL); - dir_proto = ops->new_object(NULL); + if (dp) + closedir(dp); +} - register_functions(s, ops, global_fns, scope); - register_functions(s, ops, proc_fns, proc_proto); - register_functions(s, ops, file_fns, file_proto); - register_functions(s, ops, dir_fns, dir_proto); +void uc_module_init(uc_prototype *scope) +{ + uc_add_proto_functions(scope, global_fns); - ops->register_type("fs.proc", proc_proto, close_proc); - ops->register_type("fs.file", file_proto, close_file); - ops->register_type("fs.dir", dir_proto, close_dir); + proc_type = uc_declare_type("fs.proc", proc_fns, close_proc); + file_type = uc_declare_type("fs.file", file_fns, close_file); + dir_type = uc_declare_type("fs.dir", dir_fns, close_dir); - json_object_object_add(scope, "stdin", ops->set_type(xjs_new_object(), "fs.file", stdin)); - json_object_object_add(scope, "stdout", ops->set_type(xjs_new_object(), "fs.file", stdout)); - json_object_object_add(scope, "stderr", ops->set_type(xjs_new_object(), "fs.file", stderr)); + uc_add_proto_val(scope, "stdin", uc_alloc_ressource(file_type, stdin)); + uc_add_proto_val(scope, "stdout", uc_alloc_ressource(file_type, stdout)); + uc_add_proto_val(scope, "stderr", uc_alloc_ressource(file_type, stderr)); } diff --git a/lib/math.c b/lib/math.c index 6dbca08..99f3fbc 100644 --- a/lib/math.c +++ b/lib/math.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Jo-Philipp Wich + * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -14,172 +14,151 @@ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#include "../module.h" - #include #include -static const struct uc_ops *ops; - -static double -to_double(struct json_object *v) -{ - int64_t n; - double d; - - return (ops->cast_number(v, &n, &d) == json_type_double) ? d : (double)n; -} - -static int64_t -to_int64(struct json_object *v) -{ - int64_t n; - double d; +#include "../module.h" - return (ops->cast_number(v, &n, &d) == json_type_double) ? (int64_t)d : n; -} +static bool srand_called = false; -static struct json_object * -uc_abs(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_abs(uc_vm *vm, size_t nargs) { - struct json_object *v = json_object_array_get_idx(args, 0); + json_object *v = uc_get_arg(0); enum json_type t; int64_t n; double d; if (json_object_is_type(v, json_type_null)) - return ops->new_double(NAN); + return uc_alloc_double(NAN); - t = ops->cast_number(v, &n, &d); + t = uc_to_number(v, &n, &d); if (t == json_type_double) - return (isnan(d) || d < 0) ? ops->new_double(-d) : json_object_get(v); + return (isnan(d) || d < 0) ? uc_alloc_double(-d) : json_object_get(v); return (n < 0) ? json_object_new_int64(-n) : json_object_get(v); } -static struct json_object * -uc_atan2(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_atan2(uc_vm *vm, size_t nargs) { - double d1 = to_double(json_object_array_get_idx(args, 0)); - double d2 = to_double(json_object_array_get_idx(args, 1)); + double d1 = uc_to_double(uc_get_arg(0)); + double d2 = uc_to_double(uc_get_arg(1)); if (isnan(d1) || isnan(d2)) - return ops->new_double(NAN); + return uc_alloc_double(NAN); - return ops->new_double(atan2(d1, d2)); + return uc_alloc_double(atan2(d1, d2)); } -static struct json_object * -uc_cos(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_cos(uc_vm *vm, size_t nargs) { - double d = to_double(json_object_array_get_idx(args, 0)); + double d = uc_to_double(uc_get_arg(0)); if (isnan(d)) - return ops->new_double(NAN); + return uc_alloc_double(NAN); - return ops->new_double(cos(d)); + return uc_alloc_double(cos(d)); } -static struct json_object * -uc_exp(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_exp(uc_vm *vm, size_t nargs) { - double d = to_double(json_object_array_get_idx(args, 0)); + double d = uc_to_double(uc_get_arg(0)); if (isnan(d)) - return ops->new_double(NAN); + return uc_alloc_double(NAN); - return ops->new_double(exp(d)); + return uc_alloc_double(exp(d)); } -static struct json_object * -uc_log(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_log(uc_vm *vm, size_t nargs) { - double d = to_double(json_object_array_get_idx(args, 0)); + double d = uc_to_double(uc_get_arg(0)); if (isnan(d)) - return ops->new_double(NAN); + return uc_alloc_double(NAN); - return ops->new_double(log(d)); + return uc_alloc_double(log(d)); } -static struct json_object * -uc_sin(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_sin(uc_vm *vm, size_t nargs) { - double d = to_double(json_object_array_get_idx(args, 0)); + double d = uc_to_double(uc_get_arg(0)); if (isnan(d)) - return ops->new_double(NAN); + return uc_alloc_double(NAN); - return ops->new_double(sin(d)); + return uc_alloc_double(sin(d)); } -static struct json_object * -uc_sqrt(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_sqrt(uc_vm *vm, size_t nargs) { - double d = to_double(json_object_array_get_idx(args, 0)); + double d = uc_to_double(uc_get_arg(0)); if (isnan(d)) - return ops->new_double(NAN); + return uc_alloc_double(NAN); - return ops->new_double(sqrt(d)); + return uc_alloc_double(sqrt(d)); } -static struct json_object * -uc_pow(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_pow(uc_vm *vm, size_t nargs) { - double x = to_double(json_object_array_get_idx(args, 0)); - double y = to_double(json_object_array_get_idx(args, 1)); + double x = uc_to_double(uc_get_arg(0)); + double y = uc_to_double(uc_get_arg(1)); if (isnan(x) || isnan(y)) - return ops->new_double(NAN); + return uc_alloc_double(NAN); - return ops->new_double(pow(x, y)); + return uc_alloc_double(pow(x, y)); } -static struct json_object * -uc_rand(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_rand(uc_vm *vm, size_t nargs) { struct timeval tv; - if (!s->srand_called) { + if (!srand_called) { gettimeofday(&tv, NULL); srand((tv.tv_sec * 1000) + (tv.tv_usec / 1000)); - s->srand_called = true; + srand_called = true; } return json_object_new_int64(rand()); } -static struct json_object * -uc_srand(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_srand(uc_vm *vm, size_t nargs) { - - int64_t n = to_int64(json_object_array_get_idx(args, 0)); + int64_t n = uc_to_int64(uc_get_arg(0)); srand((unsigned int)n); - s->srand_called = true; + srand_called = true; return NULL; } -static const struct { const char *name; uc_c_fn *func; } global_fns[] = { - { "abs", uc_abs }, - { "atan2", uc_atan2 }, - { "cos", uc_cos }, - { "exp", uc_exp }, - { "log", uc_log }, - { "sin", uc_sin }, - { "sqrt", uc_sqrt }, - { "pow", uc_pow }, - { "rand", uc_rand }, - { "srand", uc_srand }, +static const uc_cfunction_list math_fns[] = { + { "abs", uc_abs }, + { "atan2", uc_atan2 }, + { "cos", uc_cos }, + { "exp", uc_exp }, + { "log", uc_log }, + { "sin", uc_sin }, + { "sqrt", uc_sqrt }, + { "pow", uc_pow }, + { "rand", uc_rand }, + { "srand", uc_srand }, }; -void uc_module_init(const struct uc_ops *ut, struct uc_state *s, struct json_object *scope) +void uc_module_init(uc_prototype *scope) { - ops = ut; - - register_functions(s, ops, global_fns, scope); + uc_add_proto_functions(scope, math_fns); } diff --git a/lib/ubus.c b/lib/ubus.c index a11b014..b965bbe 100644 --- a/lib/ubus.c +++ b/lib/ubus.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Jo-Philipp Wich + * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -14,29 +14,28 @@ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#include "../module.h" - #include #include #include #include -#define err_return(err) do { last_error = err; return NULL; } while(0) +#include "../module.h" -static const struct uc_ops *ops; +#define err_return(err) do { last_error = err; return NULL; } while(0) static enum ubus_msg_status last_error = 0; +static uc_ressource_type *conn_type; -struct ubus_connection { +typedef struct { int timeout; struct blob_buf buf; struct ubus_context *ctx; -}; +} ubus_connection; -static struct json_object * -uc_ubus_error(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_ubus_error(uc_vm *vm, size_t nargs) { - struct json_object *errmsg; + json_object *errmsg; if (last_error == 0) return NULL; @@ -47,14 +46,14 @@ uc_ubus_error(struct uc_state *s, uint32_t off, struct json_object *args) return errmsg; } -static struct json_object * +static json_object * uc_blob_to_json(struct blob_attr *attr, bool table, const char **name); -static struct json_object * +static json_object * uc_blob_array_to_json(struct blob_attr *attr, size_t len, bool table) { - struct json_object *o = table ? json_object_new_object() : json_object_new_array(); - struct json_object *v; + json_object *o = table ? json_object_new_object() : json_object_new_array(); + json_object *v; struct blob_attr *pos; size_t rem = len; const char *name; @@ -77,7 +76,7 @@ uc_blob_array_to_json(struct blob_attr *attr, size_t len, bool table) return o; } -static struct json_object * +static json_object * uc_blob_to_json(struct blob_attr *attr, bool table, const char **name) { void *data; @@ -131,13 +130,13 @@ uc_blob_to_json(struct blob_attr *attr, bool table, const char **name) } -static struct json_object * -uc_ubus_connect(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_ubus_connect(uc_vm *vm, size_t nargs) { - struct json_object *socket = json_object_array_get_idx(args, 0); - struct json_object *timeout = json_object_array_get_idx(args, 1); - struct json_object *co; - struct ubus_connection *c; + json_object *socket = uc_get_arg(0); + json_object *timeout = uc_get_arg(1); + json_object *co; + ubus_connection *c; if ((socket && !json_object_is_type(socket, json_type_string)) || (timeout && !json_object_is_type(timeout, json_type_int))) @@ -169,14 +168,14 @@ uc_ubus_connect(struct uc_state *s, uint32_t off, struct json_object *args) ubus_add_uloop(c->ctx); - return ops->set_type(co, "ubus.connection", c); + return uc_alloc_ressource(conn_type, c); } static void uc_ubus_signatures_cb(struct ubus_context *c, struct ubus_object_data *o, void *p) { - struct json_object *arr = p; - struct json_object *sig; + json_object *arr = p; + json_object *sig; if (!o->signature) return; @@ -190,8 +189,8 @@ uc_ubus_signatures_cb(struct ubus_context *c, struct ubus_object_data *o, void * static void uc_ubus_objects_cb(struct ubus_context *c, struct ubus_object_data *o, void *p) { - struct json_object *arr = p; - struct json_object *obj; + json_object *arr = p; + json_object *obj; obj = json_object_new_string(o->path); @@ -199,12 +198,12 @@ uc_ubus_objects_cb(struct ubus_context *c, struct ubus_object_data *o, void *p) json_object_array_add(arr, obj); } -static struct json_object * -uc_ubus_list(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_ubus_list(uc_vm *vm, size_t nargs) { - struct ubus_connection **c = (struct ubus_connection **)ops->get_type(s->ctx, "ubus.connection"); - struct json_object *objname = json_object_array_get_idx(args, 0); - struct json_object *res = NULL; + ubus_connection **c = uc_get_self("ubus.connection"); + json_object *objname = uc_get_arg(0); + json_object *res = NULL; enum ubus_msg_status rv; if (!c || !*c || !(*c)->ctx) @@ -232,19 +231,19 @@ uc_ubus_list(struct uc_state *s, uint32_t off, struct json_object *args) static void uc_ubus_call_cb(struct ubus_request *req, int type, struct blob_attr *msg) { - struct json_object **res = (struct json_object **)req->priv; + json_object **res = (json_object **)req->priv; *res = msg ? uc_blob_array_to_json(blob_data(msg), blob_len(msg), true) : NULL; } -static struct json_object * -uc_ubus_call(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_ubus_call(uc_vm *vm, size_t nargs) { - struct ubus_connection **c = (struct ubus_connection **)ops->get_type(s->ctx, "ubus.connection"); - struct json_object *objname = json_object_array_get_idx(args, 0); - struct json_object *funname = json_object_array_get_idx(args, 1); - struct json_object *funargs = json_object_array_get_idx(args, 2); - struct json_object *res = NULL; + ubus_connection **c = uc_get_self("ubus.connection"); + json_object *objname = uc_get_arg(0); + json_object *funname = uc_get_arg(1); + json_object *funargs = uc_get_arg(2); + json_object *res = NULL; enum ubus_msg_status rv; uint32_t id; @@ -275,10 +274,10 @@ uc_ubus_call(struct uc_state *s, uint32_t off, struct json_object *args) return res; } -static struct json_object * -uc_ubus_disconnect(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_ubus_disconnect(uc_vm *vm, size_t nargs) { - struct ubus_connection **c = (struct ubus_connection **)ops->get_type(s->ctx, "ubus.connection"); + ubus_connection **c = uc_get_self("ubus.connection"); if (!c || !*c || !(*c)->ctx) err_return(UBUS_STATUS_CONNECTION_FAILED); @@ -290,12 +289,12 @@ uc_ubus_disconnect(struct uc_state *s, uint32_t off, struct json_object *args) } -static const struct { const char *name; uc_c_fn *func; } global_fns[] = { +static const uc_cfunction_list global_fns[] = { { "error", uc_ubus_error }, { "connect", uc_ubus_connect }, }; -static const struct { const char *name; uc_c_fn *func; } conn_fns[] = { +static const uc_cfunction_list conn_fns[] = { { "list", uc_ubus_list }, { "call", uc_ubus_call }, { "disconnect", uc_ubus_disconnect }, @@ -303,7 +302,7 @@ static const struct { const char *name; uc_c_fn *func; } conn_fns[] = { static void close_connection(void *ud) { - struct ubus_connection *conn = ud; + ubus_connection *conn = ud; blob_buf_free(&conn->buf); @@ -313,15 +312,9 @@ static void close_connection(void *ud) { free(conn); } -void uc_module_init(const struct uc_ops *ut, struct uc_state *s, struct json_object *scope) +void uc_module_init(uc_prototype *scope) { - struct json_object *conn_proto; - - ops = ut; - conn_proto = ops->new_object(NULL); - - register_functions(s, ops, global_fns, scope); - register_functions(s, ops, conn_fns, conn_proto); + uc_add_proto_functions(scope, global_fns); - ops->register_type("ubus.connection", conn_proto, close_connection); + conn_type = uc_declare_type("ubus.connection", conn_fns, close_connection); } diff --git a/lib/uci.c b/lib/uci.c index 1b4c5db..e00f77e 100644 --- a/lib/uci.c +++ b/lib/uci.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Jo-Philipp Wich + * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -14,16 +14,15 @@ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#include "../module.h" - #include #include -#define err_return(err) do { last_error = err; return NULL; } while(0) +#include "../module.h" -static const struct uc_ops *ops; +#define err_return(err) do { last_error = err; return NULL; } while(0) static int last_error = 0; +static uc_ressource_type *cursor_type; enum pkg_cmd { CMD_SAVE, @@ -31,11 +30,11 @@ enum pkg_cmd { CMD_REVERT }; -static struct json_object * -uc_uci_error(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_error(uc_vm *vm, size_t nargs) { char buf[sizeof("Unknown error: -9223372036854775808")]; - struct json_object *errmsg; + json_object *errmsg; const char *errstr[] = { [UCI_ERR_MEM] = "Out of memory", @@ -64,12 +63,11 @@ uc_uci_error(struct uc_state *s, uint32_t off, struct json_object *args) } -static struct json_object * -uc_uci_cursor(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_cursor(uc_vm *vm, size_t nargs) { - struct json_object *cdir = json_object_array_get_idx(args, 0); - struct json_object *sdir = json_object_array_get_idx(args, 1); - struct json_object *co; + json_object *cdir = uc_get_arg(0); + json_object *sdir = uc_get_arg(1); struct uci_context *c; int rv; @@ -96,22 +94,15 @@ uc_uci_cursor(struct uc_state *s, uint32_t off, struct json_object *args) err_return(rv); } - co = json_object_new_object(); - - if (!co) { - uci_free_context(c); - err_return(UCI_ERR_MEM); - } - - return ops->set_type(co, "uci.cursor", c); + return uc_alloc_ressource(cursor_type, c); } -static struct json_object * -uc_uci_load(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_load(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); struct uci_element *e; if (!c || !*c) @@ -133,11 +124,11 @@ uc_uci_load(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_uci_unload(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_unload(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); struct uci_element *e; if (!c || !*c) @@ -186,10 +177,10 @@ lookup_ptr(struct uci_context *ctx, struct uci_ptr *ptr, bool extended) return uci_lookup_ptr(ctx, ptr, NULL, extended); } -static struct json_object * +static json_object * option_to_json(struct uci_option *o) { - struct json_object *arr; + json_object *arr; struct uci_element *e; switch (o->type) { @@ -210,10 +201,10 @@ option_to_json(struct uci_option *o) } } -static struct json_object * +static json_object * section_to_json(struct uci_section *s, int index) { - struct json_object *so = json_object_new_object(); + json_object *so = json_object_new_object(); struct uci_element *e; struct uci_option *o; @@ -235,11 +226,11 @@ section_to_json(struct uci_section *s, int index) return so; } -static struct json_object * +static json_object * package_to_json(struct uci_package *p) { - struct json_object *po = json_object_new_object(); - struct json_object *so; + json_object *po = json_object_new_object(); + json_object *so; struct uci_element *e; int i = 0; @@ -254,13 +245,13 @@ package_to_json(struct uci_package *p) return po; } -static struct json_object * -uc_uci_get_any(struct uc_state *s, uint32_t off, struct json_object *args, bool all) +static json_object * +uc_uci_get_any(uc_vm *vm, size_t nargs, bool all) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); - struct json_object *sect = json_object_array_get_idx(args, 1); - struct json_object *opt = json_object_array_get_idx(args, 2); + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); + json_object *sect = uc_get_arg(1); + json_object *opt = uc_get_arg(2); struct uci_ptr ptr = {}; int rv; @@ -314,25 +305,25 @@ uc_uci_get_any(struct uc_state *s, uint32_t off, struct json_object *args, bool return json_object_new_string(ptr.s->type); } -static struct json_object * -uc_uci_get(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_get(uc_vm *vm, size_t nargs) { - return uc_uci_get_any(s, off, args, false); + return uc_uci_get_any(vm, nargs, false); } -static struct json_object * -uc_uci_get_all(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_get_all(uc_vm *vm, size_t nargs) { - return uc_uci_get_any(s, off, args, true); + return uc_uci_get_any(vm, nargs, true); } -static struct json_object * -uc_uci_get_first(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_get_first(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); - struct json_object *type = json_object_array_get_idx(args, 1); - struct json_object *opt = json_object_array_get_idx(args, 2); + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); + json_object *type = uc_get_arg(1); + json_object *opt = uc_get_arg(2); struct uci_package *p = NULL; struct uci_section *sc; struct uci_element *e; @@ -384,12 +375,12 @@ uc_uci_get_first(struct uc_state *s, uint32_t off, struct json_object *args) err_return(UCI_ERR_NOTFOUND); } -static struct json_object * -uc_uci_add(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_add(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); - struct json_object *type = json_object_array_get_idx(args, 1); + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); + json_object *type = uc_get_arg(1); struct uci_element *e = NULL; struct uci_package *p = NULL; struct uci_section *sc = NULL; @@ -420,9 +411,9 @@ uc_uci_add(struct uc_state *s, uint32_t off, struct json_object *args) } static bool -json_to_value(struct json_object *val, const char **p, bool *is_list) +json_to_value(json_object *val, const char **p, bool *is_list) { - struct json_object *item; + json_object *item; *p = NULL; @@ -463,13 +454,13 @@ json_to_value(struct json_object *val, const char **p, bool *is_list) } } -static struct json_object * -uc_uci_set(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_set(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); - struct json_object *sect = json_object_array_get_idx(args, 1); - struct json_object *opt = NULL, *val = NULL; + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); + json_object *sect = uc_get_arg(1); + json_object *opt = NULL, *val = NULL; struct uci_ptr ptr = {}; bool is_list = false; int rv, i; @@ -478,11 +469,11 @@ uc_uci_set(struct uc_state *s, uint32_t off, struct json_object *args) !json_object_is_type(sect, json_type_string)) err_return(UCI_ERR_INVAL); - switch (json_object_array_length(args)) { + switch (nargs) { /* conf, sect, opt, val */ case 4: - opt = json_object_array_get_idx(args, 2); - val = json_object_array_get_idx(args, 3); + opt = uc_get_arg(2); + val = uc_get_arg(3); if (!json_object_is_type(opt, json_type_string)) err_return(UCI_ERR_INVAL); @@ -491,7 +482,7 @@ uc_uci_set(struct uc_state *s, uint32_t off, struct json_object *args) /* conf, sect, type */ case 3: - val = json_object_array_get_idx(args, 2); + val = uc_get_arg(2); if (!json_object_is_type(val, json_type_string)) err_return(UCI_ERR_INVAL); @@ -563,13 +554,13 @@ uc_uci_set(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_uci_delete(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_delete(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); - struct json_object *sect = json_object_array_get_idx(args, 1); - struct json_object *opt = json_object_array_get_idx(args, 2); + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); + json_object *sect = uc_get_arg(1); + json_object *opt = uc_get_arg(2); struct uci_ptr ptr = {}; int rv; @@ -598,13 +589,13 @@ uc_uci_delete(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_uci_rename(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_rename(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); - struct json_object *sect = json_object_array_get_idx(args, 1); - struct json_object *opt = NULL, *val = NULL; + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); + json_object *sect = uc_get_arg(1); + json_object *opt = NULL, *val = NULL; struct uci_ptr ptr = {}; int rv; @@ -612,11 +603,11 @@ uc_uci_rename(struct uc_state *s, uint32_t off, struct json_object *args) !json_object_is_type(sect, json_type_string)) err_return(UCI_ERR_INVAL); - switch (json_object_array_length(args)) { + switch (nargs) { /* conf, sect, opt, val */ case 4: - opt = json_object_array_get_idx(args, 2); - val = json_object_array_get_idx(args, 3); + opt = uc_get_arg(2); + val = uc_get_arg(3); if (!json_object_is_type(opt, json_type_string) || !json_object_is_type(val, json_type_string)) @@ -626,7 +617,7 @@ uc_uci_rename(struct uc_state *s, uint32_t off, struct json_object *args) /* conf, sect, type */ case 3: - val = json_object_array_get_idx(args, 2); + val = uc_get_arg(2); if (!json_object_is_type(val, json_type_string)) err_return(UCI_ERR_INVAL); @@ -658,13 +649,13 @@ uc_uci_rename(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_uci_reorder(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_reorder(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); - struct json_object *sect = json_object_array_get_idx(args, 1); - struct json_object *val = json_object_array_get_idx(args, 2); + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); + json_object *sect = uc_get_arg(1); + json_object *val = uc_get_arg(2); struct uci_ptr ptr = {}; int64_t n; int rv; @@ -698,11 +689,11 @@ uc_uci_reorder(struct uc_state *s, uint32_t off, struct json_object *args) return json_object_new_boolean(true); } -static struct json_object * -uc_uci_pkg_command(struct uc_state *s, uint32_t off, struct json_object *args, enum pkg_cmd cmd) +static json_object * +uc_uci_pkg_command(uc_vm *vm, size_t nargs, enum pkg_cmd cmd) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); struct uci_element *e, *tmp; struct uci_package *p; struct uci_ptr ptr = {}; @@ -748,25 +739,25 @@ uc_uci_pkg_command(struct uc_state *s, uint32_t off, struct json_object *args, e return json_object_new_boolean(true); } -static struct json_object * -uc_uci_save(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_save(uc_vm *vm, size_t nargs) { - return uc_uci_pkg_command(s, off, args, CMD_SAVE); + return uc_uci_pkg_command(vm, nargs, CMD_SAVE); } -static struct json_object * -uc_uci_commit(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_commit(uc_vm *vm, size_t nargs) { - return uc_uci_pkg_command(s, off, args, CMD_COMMIT); + return uc_uci_pkg_command(vm, nargs, CMD_COMMIT); } -static struct json_object * -uc_uci_revert(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_revert(uc_vm *vm, size_t nargs) { - return uc_uci_pkg_command(s, off, args, CMD_REVERT); + return uc_uci_pkg_command(vm, nargs, CMD_REVERT); } -static struct json_object * +static json_object * change_to_json(struct uci_delta *d) { const char *types[] = { @@ -779,7 +770,7 @@ change_to_json(struct uci_delta *d) [UCI_CMD_CHANGE] = "set", }; - struct json_object *a; + json_object *a; if (!d->section) return NULL; @@ -805,10 +796,10 @@ change_to_json(struct uci_delta *d) return a; } -static struct json_object * +static json_object * changes_to_json(struct uci_context *ctx, const char *package) { - struct json_object *a = NULL, *c; + json_object *a = NULL, *c; struct uci_package *p = NULL; struct uci_element *e; bool unload = false; @@ -855,12 +846,12 @@ changes_to_json(struct uci_context *ctx, const char *package) return a; } -static struct json_object * -uc_uci_changes(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_changes(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); - struct json_object *res, *chg; + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); + json_object *res, *chg; char **configs; int rv, i; @@ -894,17 +885,18 @@ uc_uci_changes(struct uc_state *s, uint32_t off, struct json_object *args) return res; } -static struct json_object * -uc_uci_foreach(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_foreach(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *conf = json_object_array_get_idx(args, 0); - struct json_object *type = json_object_array_get_idx(args, 1); - struct json_object *func = json_object_array_get_idx(args, 2); - struct json_object *fnargs, *rv = NULL; + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *conf = uc_get_arg(0); + json_object *type = uc_get_arg(1); + json_object *func = uc_get_arg(2); + json_object *rv = NULL; struct uci_package *p = NULL; struct uci_element *e, *tmp; struct uci_section *sc; + uc_exception_type_t ex; bool stop = false; bool ret = false; int i = 0; @@ -924,11 +916,6 @@ uc_uci_foreach(struct uc_state *s, uint32_t off, struct json_object *args) if (!p) err_return(UCI_ERR_NOTFOUND); - fnargs = json_object_new_array(); - - if (!fnargs) - err_return(UCI_ERR_MEM); - uci_foreach_element_safe(&p->sections, tmp, e) { sc = uci_to_section(e); i++; @@ -936,18 +923,17 @@ uc_uci_foreach(struct uc_state *s, uint32_t off, struct json_object *args) if (type && strcmp(sc->type, json_object_get_string(type))) continue; - json_object_array_put_idx(fnargs, 0, section_to_json(sc, i - 1)); - - rv = ops->invoke(s, off, NULL, func, fnargs); + uc_push_val(uc_value_get(func)); + uc_push_val(section_to_json(sc, i - 1)); - /* forward exceptions from callback function */ - if (uc_is_type(rv, T_EXCEPTION)) { - json_object_put(fnargs); + ex = uc_call(1); - return rv; - } + /* stop on exception in callback */ + if (ex) + break; ret = true; + rv = uc_pop_val(); stop = (json_object_is_type(rv, json_type_boolean) && !json_object_get_boolean(rv)); json_object_put(rv); @@ -956,16 +942,16 @@ uc_uci_foreach(struct uc_state *s, uint32_t off, struct json_object *args) break; } - json_object_put(fnargs); + /* XXX: rethrow */ return json_object_new_boolean(ret); } -static struct json_object * -uc_uci_configs(struct uc_state *s, uint32_t off, struct json_object *args) +static json_object * +uc_uci_configs(uc_vm *vm, size_t nargs) { - struct uci_context **c = (struct uci_context **)ops->get_type(s->ctx, "uci.cursor"); - struct json_object *a; + struct uci_context **c = uc_get_self("uci.cursor"); + json_object *a; char **configs; int i, rv; @@ -990,7 +976,7 @@ uc_uci_configs(struct uc_state *s, uint32_t off, struct json_object *args) } -static const struct { const char *name; uc_c_fn *func; } cursor_fns[] = { +static const uc_cfunction_list cursor_fns[] = { { "load", uc_uci_load }, { "unload", uc_uci_unload }, { "get", uc_uci_get }, @@ -1009,7 +995,7 @@ static const struct { const char *name; uc_c_fn *func; } cursor_fns[] = { { "configs", uc_uci_configs }, }; -static const struct { const char *name; uc_c_fn *func; } global_fns[] = { +static const uc_cfunction_list global_fns[] = { { "error", uc_uci_error }, { "cursor", uc_uci_cursor }, }; @@ -1019,15 +1005,9 @@ static void close_uci(void *ud) { uci_free_context((struct uci_context *)ud); } -void uc_module_init(const struct uc_ops *ut, struct uc_state *s, struct json_object *scope) +void uc_module_init(uc_prototype *scope) { - struct json_object *uci_proto; - - ops = ut; - uci_proto = ops->new_object(NULL); - - register_functions(s, ops, global_fns, scope); - register_functions(s, ops, cursor_fns, uci_proto); + uc_add_proto_functions(scope, global_fns); - ops->register_type("uci.cursor", uci_proto, close_uci); + cursor_type = uc_declare_type("uci.cursor", cursor_fns, close_uci); } diff --git a/main.c b/main.c index 11c191b..18a7d3b 100644 --- a/main.c +++ b/main.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Jo-Philipp Wich + * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -19,6 +19,7 @@ #include #include #include +#include #include #ifdef JSONC @@ -27,10 +28,11 @@ #include #endif +#include "compiler.h" #include "lexer.h" -#include "parser.h" -#include "eval.h" #include "lib.h" +#include "vm.h" +#include "source.h" static void @@ -52,103 +54,56 @@ print_usage(char *app) app); } -#ifndef NDEBUG -static void dump(struct uc_state *state, uint32_t off, int level); - -static void dump_node(struct uc_state *state, uint32_t off) { - const char *p; - - switch (OP_TYPE(off)) { - case T_NUMBER: - printf("n%u [label=\"%"PRId64"\"];\n", off, json_object_get_int64(OP_VAL(off))); - break; - - case T_DOUBLE: - printf("n%u [label=\"%f\"];\n", off, json_object_get_double(OP_VAL(off))); - break; - - case T_BOOL: - printf("n%u [label=\"%s\"];\n", off, json_object_get_boolean(OP_VAL(off)) ? "true" : "false"); - break; - - case T_STRING: - case T_LABEL: - case T_TEXT: - printf("n%u [label=\"%s<", off, uc_get_tokenname(OP_TYPE(off))); - - for (p = json_object_get_string(OP_VAL(off)); *p; p++) - switch (*p) { - case '\n': - printf("\\\n"); - break; +static void +globals_init(uc_prototype *scope) +{ + json_object *arr = xjs_new_array(); + const char *p, *last; - case '\t': - printf("\\\t"); - break; + for (p = last = LIB_SEARCH_PATH;; p++) { + if (*p == ':' || *p == '\0') { + json_object_array_add(arr, xjs_new_string_len(last, p - last)); - case '"': - printf("\\\""); + if (!*p) break; - default: - printf("%c", *p); - } - - printf(">\"];\n"); - break; - - default: - printf("n%u [label=\"%s", off, uc_get_tokenname(OP_TYPE(off))); - - if (OP_IS_POSTFIX(off)) - printf(", postfix"); - - printf("\"];\n"); - } -} - -static void dump(struct uc_state *state, uint32_t off, int level) { - uint32_t prev_off, cur_off, child_off; - int i; - - if (level == 0) { - printf("digraph G {\nmain [shape=box];\n"); + last = p + 1; + } } - for (prev_off = 0, cur_off = off; cur_off != 0; prev_off = cur_off, cur_off = OP_NEXT(cur_off)) { - dump_node(state, cur_off); - - if (OP_TYPE(cur_off) < __T_MAX) { - for (i = 0; i < OPn_NUM; i++) { - child_off = OPn(cur_off, i); + json_object_object_add(scope->header.jso, "REQUIRE_SEARCH_PATH", arr); +} - if (child_off) { - dump(state, child_off, level + 1); - printf("n%u -> n%u [label=\"op%d\"];\n", cur_off, child_off, i + 1); - } - } - } +static void +register_variable(uc_prototype *scope, const char *key, json_object *val) +{ + char *name = strdup(key); + char *p; - if (prev_off) - printf("n%u -> n%u [style=dotted];\n", prev_off, cur_off); - } + if (!name) + return; - if (level == 0) { - printf("main -> n%u [style=dotted];\n", off); + for (p = name; *p; p++) + if (!isalnum(*p) && *p != '_') + *p = '_'; - printf("}\n"); - } + json_object_object_add(scope->header.jso, name, val); + free(name); } -#endif /* NDEBUG */ + static int -parse(struct uc_state *state, struct uc_source *src, bool dumponly, - bool skip_shebang, struct json_object *env, struct json_object *modules) +parse(uc_parse_config *config, uc_source *src, + bool skip_shebang, json_object *env, json_object *modules) { - struct json_object *rv; - char c, c2, *msg; + uc_prototype *globals = uc_prototype_new(NULL); + uc_function *entry; + uc_vm vm = {}; + char c, c2, *err; int rc = 0; + uc_vm_init(&vm, config); + if (skip_shebang) { c = fgetc(src->fp); c2 = fgetc(src->fp); @@ -167,33 +122,42 @@ parse(struct uc_state *state, struct uc_source *src, bool dumponly, } } - if (dumponly) { -#ifdef NDEBUG - rv = uc_new_exception(state, 0, "Debug support not compiled in"); -#else /* NDEBUG */ - rv = uc_parse(state, src->fp); + entry = uc_compile(config, src, &err); - if (!uc_is_type(rv, T_EXCEPTION)) - dump(state, state->main, 0); -#endif /* NDEBUG */ + if (!entry) { + fprintf(stderr, "%s", err); + free(err); + rc = 2; + goto out; } - else { - rv = uc_run(state, env, modules); + + /* load global variables */ + globals_init(globals); + + /* load env variables */ + if (env) { + json_object_object_foreach(env, key, val) + register_variable(globals, key, uc_value_get(val)); } - if (uc_is_type(rv, T_EXCEPTION)) { - msg = uc_format_error(state, src->fp); - fprintf(stderr, "%s\n\n", msg); - free(msg); + /* load std functions into global scope */ + uc_lib_init(globals); + + rc = uc_vm_execute(&vm, entry, globals, modules); + + if (rc) { rc = 1; + goto out; } - json_object_put(rv); +out: + uc_vm_free(&vm); + uc_value_put(globals->header.jso); return rc; } -static FILE * +static uc_source * read_stdin(char **ptr) { size_t rlen = 0, tlen = 0; @@ -217,13 +181,13 @@ read_stdin(char **ptr) tlen += rlen; } - return fmemopen(*ptr, tlen, "rb"); + return uc_source_new_buffer("[stdin]", *ptr, tlen); } -static struct json_object * +static json_object * parse_envfile(FILE *fp) { - struct json_object *rv = NULL; + json_object *rv = NULL; enum json_tokener_error err; struct json_tokener *tok; char buf[128]; @@ -257,29 +221,25 @@ parse_envfile(FILE *fp) int main(int argc, char **argv) { - struct json_object *env = NULL, *modules = NULL, *o, *p; - struct uc_state *state = NULL; - struct uc_source source = {}; + json_object *env = NULL, *modules = NULL, *o, *p; + uc_source *source = NULL, *envfile = NULL; char *stdin = NULL, *c; - bool dumponly = false; bool shebang = false; - FILE *envfile = NULL; int opt, rv = 0; + uc_parse_config config = { + .strict_declarations = false, + .lstrip_blocks = true, + .trim_blocks = true + }; + if (argc == 1) { print_usage(argv[0]); goto out; } - state = xalloc(sizeof(*state)); - state->lstrip_blocks = 1; - state->trim_blocks = 1; - - /* reserve opcode slot 0 */ - uc_new_op(state, 0, NULL, UINT32_MAX); - - while ((opt = getopt(argc, argv, "dhlrSe:E:i:s:m:")) != -1) + while ((opt = getopt(argc, argv, "hlrSe:E:i:s:m:")) != -1) { switch (opt) { case 'h': @@ -287,19 +247,15 @@ main(int argc, char **argv) goto out; case 'i': - if (source.fp) + if (source) fprintf(stderr, "Options -i and -s are exclusive\n"); - if (!strcmp(optarg, "-")) { - source.fp = read_stdin(&stdin); - source.filename = xstrdup("[stdin]"); - } - else { - source.fp = fopen(optarg, "rb"); - source.filename = xstrdup(optarg); - } + if (!strcmp(optarg, "-")) + source = read_stdin(&stdin); + else + source = uc_source_new_file(optarg); - if (!source.fp) { + if (!source) { fprintf(stderr, "Failed to open %s: %s\n", optarg, strerror(errno)); rv = 1; goto out; @@ -307,28 +263,23 @@ main(int argc, char **argv) break; - case 'd': - dumponly = true; - break; - case 'l': - state->lstrip_blocks = 0; + config.lstrip_blocks = false; break; case 'r': - state->trim_blocks = 0; + config.trim_blocks = false; break; case 's': - if (source.fp) + if (source) fprintf(stderr, "Options -i and -s are exclusive\n"); - source.fp = fmemopen(optarg, strlen(optarg), "rb"); - source.filename = xstrdup("[-s argument]"); + source = uc_source_new_buffer("[-s argument]", xstrdup(optarg), strlen(optarg)); break; case 'S': - state->strict_declarations = 1; + config.strict_declarations = true; break; case 'e': @@ -339,7 +290,7 @@ main(int argc, char **argv) else c = optarg; - envfile = fmemopen(c, strlen(c), "rb"); + envfile = uc_source_new_buffer("[-e argument]", xstrdup(c), strlen(c)); /* fallthrough */ case 'E': @@ -354,7 +305,7 @@ main(int argc, char **argv) if (!strcmp(c, "-")) envfile = read_stdin(&stdin); else - envfile = fopen(c, "rb"); + envfile = uc_source_new_file(c); if (!envfile) { fprintf(stderr, "Failed to open %s: %s\n", c, strerror(errno)); @@ -363,9 +314,9 @@ main(int argc, char **argv) } } - o = parse_envfile(envfile); + o = parse_envfile(envfile->fp); - fclose(envfile); + uc_source_put(envfile); envfile = NULL; @@ -401,11 +352,10 @@ main(int argc, char **argv) } } - if (!source.fp && argv[optind] != NULL) { - source.fp = fopen(argv[optind], "rb"); - source.filename = xstrdup(argv[optind]); + if (!source && argv[optind] != NULL) { + source = uc_source_new_file(argv[optind]); - if (!source.fp) { + if (!source) { fprintf(stderr, "Failed to open %s: %s\n", argv[optind], strerror(errno)); rv = 1; goto out; @@ -414,24 +364,19 @@ main(int argc, char **argv) shebang = true; } - if (!source.fp) { + if (!source) { fprintf(stderr, "One of -i or -s is required\n"); rv = 1; goto out; } - state->source = xalloc(sizeof(source)); - state->sources = state->source; - *state->source = source; - - rv = parse(state, state->source, dumponly, shebang, env, modules); + rv = parse(&config, source, shebang, env, modules); out: json_object_put(modules); json_object_put(env); - uc_free(state); - free(stdin); + uc_source_put(source); return rv; } diff --git a/module.h b/module.h index 6d11a16..9885270 100644 --- a/module.h +++ b/module.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Jo-Philipp Wich + * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -17,27 +17,42 @@ #ifndef __MODULE_H_ #define __MODULE_H_ -#include "ast.h" #include "lib.h" +#include "object.h" +#include "vm.h" -struct uc_ops { - bool (*register_function)(struct uc_state *, struct json_object *, const char *, uc_c_fn *); - bool (*register_type)(const char *, struct json_object *, void (*)(void *)); - struct json_object *(*set_type)(struct json_object *, const char *, void *); - void **(*get_type)(struct json_object *, const char *); - struct json_object *(*new_object)(struct json_object *); - struct json_object *(*new_double)(double); - struct json_object *(*invoke)(struct uc_state *, uint32_t, struct json_object *, struct json_object *, struct json_object *); - enum json_type (*cast_number)(struct json_object *, int64_t *, double *); -}; - -extern const struct uc_ops ut; - -#define register_functions(state, ops, functions, scope) \ +#define register_functions(scope, functions) \ if (scope) \ for (int i = 0; i < ARRAY_SIZE(functions); i++) \ - ops->register_function(state, scope, functions[i].name, functions[i].func) + json_object_object_add(scope->header.jso, functions[i].name, \ + ops->value.cfunc(functions[i].name, functions[i].func)) + +#define alloc_prototype(functions) ({ \ + uc_prototype *__proto = uc_object_as_prototype(ops->value.proto(NULL)); \ + register_functions(__proto, functions); \ + __proto; \ +}) + +#define declare_type(name, proto, freefn) \ + ops->ressource.define(name, proto, freefn) + +#define alloc_ressource(data, type) \ + ops->ressource.create(xjs_new_object(), type, data) + +#define register_ressource(scope, key, res) \ + json_object_object_add((scope)->header.jso, key, (res)->header.jso) + +static const uc_ops *ops; + +void uc_module_init(uc_prototype *scope) __attribute__((weak)); + +void uc_module_entry(const uc_ops *_ops, uc_prototype *scope); +void uc_module_entry(const uc_ops *_ops, uc_prototype *scope) +{ + ops = _ops; -void uc_module_init(const struct uc_ops *, struct uc_state *, struct json_object *); + if (uc_module_init) + uc_module_init(scope); +} #endif /* __MODULE_H_ */ diff --git a/object.c b/object.c new file mode 100644 index 0000000..5841f76 --- /dev/null +++ b/object.c @@ -0,0 +1,432 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include + +#include "object.h" + +static void * +uc_object_new(uc_objtype_t type, size_t size, json_object_to_json_string_fn *tostring, json_object_delete_fn *gc) +{ + uc_objhdr *hdr = xalloc(size); + + hdr->type = type; + hdr->jso = xjs_new_object(); + + json_object_set_serializer(hdr->jso, tostring, hdr, gc); + + return hdr; +} + +static int +uc_upvalref_tostring(json_object *jso, struct printbuf *pb, int level, int flags) +{ + return sprintbuf(pb, "", jso); +} + +static void +uc_upvalref_gc(json_object *jso, void *userdata) +{ + uc_upvalref *up = userdata; + + uc_value_put(up->value); + free(up); +} + +uc_upvalref * +uc_upvalref_new(size_t slot) +{ + uc_upvalref *up; + + up = uc_object_new(UC_OBJ_UPVAL, sizeof(*up), uc_upvalref_tostring, uc_upvalref_gc); + up->slot = slot; + + return up; +} + +static int +uc_function_tostring(json_object *jso, struct printbuf *pb, int level, int flags) +{ + return sprintbuf(pb, "", jso); +} + +static void +uc_function_gc(json_object *jso, void *userdata) +{ + uc_function *fn = userdata; + + uc_chunk_free(&fn->chunk); + uc_source_put(fn->source); + + free(fn); +} + +uc_function * +uc_function_new(const char *name, size_t srcpos, uc_source *source) +{ + size_t namelen = 0; + uc_function *fn; + + if (name) + namelen = strlen(name) + 1; + + fn = uc_object_new(UC_OBJ_FUNCTION, ALIGN(sizeof(*fn)) + namelen, uc_function_tostring, uc_function_gc); + fn->name = name ? strcpy((char *)fn + ALIGN(sizeof(*fn)), name) : NULL; + fn->nargs = 0; + fn->nupvals = 0; + fn->srcpos = srcpos; + fn->source = uc_source_get(source); + fn->vararg = false; + + uc_chunk_init(&fn->chunk); + + return fn; +} + +size_t +uc_function_get_srcpos(uc_function *fn, size_t off) +{ + size_t pos = uc_chunk_debug_get_srcpos(&fn->chunk, off); + + return pos ? fn->srcpos + pos : 0; +} + +static int +uc_closure_tostring(json_object *jso, struct printbuf *pb, int level, int flags) +{ + bool strict = (level > 0) || (flags & JSON_C_TO_STRING_STRICT); + uc_closure *closure = json_object_get_userdata(jso); + uc_function *function = closure->function; + json_object *argname; + size_t i; + + sprintbuf(pb, "%s%s", + strict ? "\"" : "", + closure->is_arrow ? "" : "function"); + + if (function->name) + sprintbuf(pb, " %s", function->name); + + sprintbuf(pb, "("); + + for (i = 1; i <= function->nargs; i++) { + argname = uc_chunk_debug_get_variable(&function->chunk, i - 1, i, false); + + if (i > 1) + sprintbuf(pb, ", "); + + if (i == function->nargs && function->vararg) + sprintbuf(pb, "..."); + + if (argname) + sprintbuf(pb, "%s", json_object_get_string(argname)); + else + sprintbuf(pb, "[arg%zu]", i); + + uc_value_put(argname); + } + + return sprintbuf(pb, ")%s { ... }%s", + closure->is_arrow ? " =>" : "", + strict ? "\"" : ""); +} + +static void +uc_closure_gc(json_object *jso, void *userdata) +{ + uc_closure *closure = userdata; + uc_function *function = closure->function; + size_t i; + + for (i = 0; i < function->nupvals; i++) + uc_value_put(closure->upvals[i]->header.jso); + + uc_value_put(function->header.jso); + + free(closure); +} + +uc_closure * +uc_closure_new(uc_function *function, bool arrow_fn) +{ + uc_closure *closure; + + closure = uc_object_new(UC_OBJ_CLOSURE, + ALIGN(sizeof(*closure)) + (sizeof(uc_upvalref *) * function->nupvals), + uc_closure_tostring, uc_closure_gc); + + closure->function = function; + closure->is_arrow = arrow_fn; + closure->upvals = function->nupvals ? ((void *)closure + ALIGN(sizeof(*closure))) : NULL; + + return closure; +} + +static int +uc_cfunction_tostring(json_object *jso, struct printbuf *pb, int level, int flags) +{ + bool strict = (level > 0) || (flags & JSON_C_TO_STRING_STRICT); + uc_cfunction *cfn = json_object_get_userdata(jso); + + return sprintbuf(pb, "%sfunction%s%s(...) { [native code] }%s", + strict ? "\"" : "", + cfn->name ? " " : "", + cfn->name ? cfn->name : "", + strict ? "\"" : ""); +} + +static void +uc_cfunction_gc(json_object *jso, void *userdata) +{ + free(userdata); +} + +uc_cfunction * +uc_cfunction_new(const char *name, uc_cfn_ptr fptr) +{ + size_t namelen = 0; + uc_cfunction *cfn; + + if (name) + namelen = strlen(name) + 1; + + cfn = uc_object_new(UC_OBJ_CFUNCTION, ALIGN(sizeof(*cfn)) + namelen, uc_cfunction_tostring, uc_cfunction_gc); + cfn->name = name ? strcpy((char *)cfn + ALIGN(sizeof(*cfn)), name) : NULL; + cfn->cfn = fptr; + + return cfn; +} + +static int +uc_regexp_tostring(json_object *jso, struct printbuf *pb, int level, int flags) +{ + bool strict = (level > 0) || (flags & JSON_C_TO_STRING_STRICT); + uc_regexp *re = json_object_get_userdata(jso); + json_object *s; + const char *p; + size_t len; + + sprintbuf(pb, "%s/", strict ? "\"" : ""); + + s = xjs_new_string(re->pattern); + + if (strict) + for (p = json_object_to_json_string(s) + 1, len = strlen(p) - 1; len > 0; len--, p++) + sprintbuf(pb, "%c", *p); + else + sprintbuf(pb, "%s", json_object_get_string(s)); + + uc_value_put(s); + + return sprintbuf(pb, "/%s%s%s%s", + re->global ? "g" : "", + re->icase ? "i" : "", + re->newline ? "s" : "", + strict ? "\"" : ""); +} + +static void +uc_regexp_gc(json_object *jso, void *userdata) +{ + uc_regexp *re = userdata; + + regfree(&re->re); + free(re); +} + +uc_regexp * +uc_regexp_new(const char *pattern, bool icase, bool newline, bool global, char **err) +{ + int cflags = REG_EXTENDED, res; + uc_regexp *re; + size_t len; + + re = uc_object_new(UC_OBJ_REGEXP, ALIGN(sizeof(*re)) + strlen(pattern) + 1, uc_regexp_tostring, uc_regexp_gc); + re->icase = icase; + re->global = global; + re->newline = newline; + re->pattern = strcpy((char *)re + ALIGN(sizeof(*re)), pattern); + + if (icase) + cflags |= REG_ICASE; + + if (newline) + cflags |= REG_NEWLINE; + + res = regcomp(&re->re, pattern, cflags); + + if (res != 0) { + if (err) { + len = regerror(res, &re->re, NULL, 0); + *err = xalloc(len); + + regerror(res, &re->re, *err, len); + } + + uc_value_put(re->header.jso); + + return NULL; + } + + json_object_object_add(re->header.jso, "source", xjs_new_string(pattern)); + json_object_object_add(re->header.jso, "i", xjs_new_boolean(icase)); + json_object_object_add(re->header.jso, "g", xjs_new_boolean(global)); + json_object_object_add(re->header.jso, "s", xjs_new_boolean(newline)); + + return re; +} + +static void +uc_prototype_gc(json_object *jso, void *userdata) +{ + uc_prototype *proto = userdata; + + if (proto->parent) + uc_value_put(proto->parent->header.jso); + + free(proto); +} + +uc_prototype * +uc_prototype_new(uc_prototype *parent) +{ + uc_prototype *proto; + + proto = uc_object_new(UC_OBJ_PROTOTYPE, sizeof(*proto), NULL, uc_prototype_gc); + + if (parent) { + proto->parent = parent; + uc_value_get(parent->header.jso); + } + + return proto; +} + + +static uc_ressource_types res_types; + +uc_ressource_type * +uc_ressource_type_add(const char *name, uc_prototype *proto, void (*freefn)(void *)) +{ + uc_vector_grow(&res_types); + + res_types.entries[res_types.count].name = name; + res_types.entries[res_types.count].proto = proto; + res_types.entries[res_types.count].free = freefn; + + return &res_types.entries[res_types.count++]; +} + +static uc_ressource_type * +uc_ressource_type_get(size_t type) +{ + return (type < res_types.count) ? &res_types.entries[type] : NULL; +} + +uc_ressource_type * +uc_ressource_type_lookup(const char *name) +{ + size_t i; + + for (i = 0; i < res_types.count; i++) + if (!strcmp(res_types.entries[i].name, name)) + return &res_types.entries[i]; + + return NULL; +} + +static int +uc_ressource_tostring(json_object *jso, struct printbuf *pb, int level, int flags) +{ + bool strict = (level > 0) || (flags & JSON_C_TO_STRING_STRICT); + uc_ressource *res = json_object_get_userdata(jso); + uc_ressource_type *type = uc_ressource_type_get(res->type); + + return sprintbuf(pb, "%s<%s %p>%s", + strict ? "\"" : "", + type ? type->name : "ressource", + res->data, + strict ? "\"" : ""); +} + +static void +uc_ressource_gc(json_object *jso, void *userdata) +{ + uc_ressource *res = userdata; + uc_ressource_type *type = uc_ressource_type_get(res->type); + + if (type && type->free) + type->free(res->data); + + free(res); +} + +uc_ressource * +uc_ressource_new(json_object *jso, uc_ressource_type *type, void *data) +{ + uc_ressource *res; + + if (!jso) + return NULL; + + res = xalloc(sizeof(*res)); + res->header.type = UC_OBJ_RESSOURCE; + res->header.jso = jso; + + res->type = type - res_types.entries; + res->data = data; + + json_object_set_serializer(res->header.jso, uc_ressource_tostring, res, uc_ressource_gc); + + return res; +} + +void ** +uc_ressource_dataptr(json_object *jso, const char *name) +{ + uc_ressource_type *type; + uc_ressource *res; + + if (!uc_object_is_type(jso, UC_OBJ_RESSOURCE)) + return NULL; + + res = uc_object_as_ressource(jso); + + if (name) { + type = uc_ressource_type_lookup(name); + + if (!type || type != uc_ressource_type_get(res->type)) + return NULL; + } + + return &res->data; +} + +uc_prototype * +uc_ressource_prototype(json_object *jso) +{ + uc_ressource_type *type; + uc_ressource *res; + + if (!uc_object_is_type(jso, UC_OBJ_RESSOURCE)) + return NULL; + + res = uc_object_as_ressource(jso); + type = uc_ressource_type_get(res->type); + + return type ? type->proto : NULL; +} diff --git a/object.h b/object.h new file mode 100644 index 0000000..ba08651 --- /dev/null +++ b/object.h @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef __OBJECT_H_ +#define __OBJECT_H_ + +#include +#include +#include +#include + +#ifdef JSONC + #include +#else + #include +#endif + +#include "source.h" +#include "chunk.h" +#include "util.h" + +typedef enum { + UC_OBJ_INVAL, + UC_OBJ_UPVAL, + UC_OBJ_FUNCTION, + UC_OBJ_CLOSURE, + UC_OBJ_CFUNCTION, + UC_OBJ_REGEXP, + UC_OBJ_PROTOTYPE, + UC_OBJ_RESSOURCE +} uc_objtype_t; + +typedef struct { + uc_objtype_t type; + json_object *jso; +} uc_objhdr; + +typedef struct uc_upvalref { + uc_objhdr header; + size_t slot; + bool closed; + json_object *value; + struct uc_upvalref *next; +} uc_upvalref; + +typedef struct { + uc_objhdr header; + char *name; + bool arrow, vararg; + size_t nargs; + size_t nupvals; + size_t srcpos; + uc_chunk chunk; + uc_source *source; +} uc_function; + +typedef struct { + uc_objhdr header; + uc_function *function; + uc_upvalref **upvals; + bool is_arrow; +} uc_closure; + +struct uc_vm; +typedef json_object *(*uc_cfn_ptr)(struct uc_vm *, size_t); + +typedef struct { + uc_objhdr header; + char *name; + uc_cfn_ptr cfn; +} uc_cfunction; + +typedef struct { + uc_objhdr header; + regex_t re; + char *pattern; + bool icase, newline, global; +} uc_regexp; + +struct uc_prototype { + uc_objhdr header; + struct uc_prototype *parent; +}; + +typedef struct uc_prototype uc_prototype; + +typedef struct { + uc_objhdr header; + uc_prototype *proto; + size_t type; + void *data; +} uc_ressource; + +typedef struct { + const char *name; + uc_prototype *proto; + void (*free)(void *); +} uc_ressource_type; + +uc_declare_vector(uc_ressource_types, uc_ressource_type); + +uc_upvalref *uc_upvalref_new(size_t slot); +uc_function *uc_function_new(const char *name, size_t line, uc_source *source); +uc_closure *uc_closure_new(uc_function *function, bool arrow_fn); +uc_cfunction *uc_cfunction_new(const char *name, uc_cfn_ptr cfn); +uc_regexp *uc_regexp_new(const char *pattern, bool icase, bool newline, bool global, char **err); +uc_prototype *uc_prototype_new(uc_prototype *parent); + +uc_ressource_type *uc_ressource_type_add(const char *name, uc_prototype *proto, void (*freefn)(void *)); +uc_ressource_type *uc_ressource_type_lookup(const char *name); + +uc_ressource *uc_ressource_new(json_object *jso, uc_ressource_type *type, void *data); +uc_prototype *uc_ressource_prototype(json_object *jso); +void **uc_ressource_dataptr(json_object *jso, const char *name); + +size_t uc_function_get_srcpos(uc_function *function, size_t off); + +static inline uc_objtype_t +uc_object_type(json_object *jso) +{ + uc_objhdr *hdr = json_object_get_userdata(jso); + + return hdr ? hdr->type : UC_OBJ_INVAL; +} + +static inline bool +uc_object_is_type(json_object *jso, uc_objtype_t type) +{ + return uc_object_type(jso) == type; +} + +static inline uc_upvalref * +uc_object_as_upvalref(json_object *jso) +{ + return json_object_get_userdata(jso); +} + +static inline uc_function * +uc_object_as_function(json_object *jso) +{ + return json_object_get_userdata(jso); +} + +static inline uc_closure * +uc_object_as_closure(json_object *jso) +{ + return json_object_get_userdata(jso); +} + +static inline uc_cfunction * +uc_object_as_cfunction(json_object *jso) +{ + return json_object_get_userdata(jso); +} + +static inline uc_regexp * +uc_object_as_regexp(json_object *jso) +{ + return json_object_get_userdata(jso); +} + +static inline uc_prototype * +uc_object_as_prototype(json_object *jso) +{ + return json_object_get_userdata(jso); +} + +static inline uc_ressource * +uc_object_as_ressource(json_object *jso) +{ + return json_object_get_userdata(jso); +} + +static inline bool +uc_object_is_callable(json_object *jso) +{ + switch (uc_object_type(jso)) { + case UC_OBJ_CLOSURE: + case UC_OBJ_CFUNCTION: + return true; + + default: + return false; + } +} + +#endif /* __OBJECT_H_ */ diff --git a/parser.y b/parser.y deleted file mode 100644 index ebd5f5c..0000000 --- a/parser.y +++ /dev/null @@ -1,476 +0,0 @@ -/* - * Copyright (C) 2020 Jo-Philipp Wich - * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. - * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -%token_type {uint32_t} -%extra_argument {struct uc_state *state} - -%nonassoc T_LEXP T_REXP T_LSTM T_RSTM. - -%nonassoc T_IF. -%nonassoc T_ELSE. - -%left T_COMMA. -%right T_ASBAND T_ASBXOR T_ASBOR. -%right T_ASLEFT T_ASRIGHT. -%right T_ASMUL T_ASDIV T_ASMOD. -%right T_ASADD T_ASSUB. -%right T_ASSIGN. -%right T_QMARK T_COLON. -%left T_OR. -%left T_AND. -%left T_BOR. -%left T_BXOR. -%left T_BAND. -%left T_EQ T_NE T_EQS T_NES. -%left T_LT T_LE T_GT T_GE T_IN. -%left T_LSHIFT T_RSHIFT. -%left T_ADD T_SUB. -%left T_MUL T_DIV T_MOD. -%right T_NOT T_COMPL. -%right T_INC T_DEC. -%left T_LPAREN T_LBRACK. - - -%include { -#include -#include -#include -#include - -#include "ast.h" -#include "lib.h" -#include "lexer.h" -#include "parser.h" - -#define YYSTACKDEPTH 0 -#define YYNOERRORRECOVERY - -#define new_op(type, val, ...) \ - uc_new_op(state, type, val, ##__VA_ARGS__, UINT32_MAX) - -#define wrap_op(op, ...) \ - uc_wrap_op(state, op, ##__VA_ARGS__, UINT32_MAX) - -#define append_op(op1, op2) \ - uc_append_op(state, op1, op2) - -#define no_empty_obj(op) \ - uc_no_empty_obj(state, op) - -static inline uint32_t -uc_no_empty_obj(struct uc_state *state, uint32_t off) -{ - return (OP_TYPE(off) != T_LBRACE || OPn(off, 0)) ? off : 0; -} - -static inline uint32_t -uc_add_else(struct uc_state *state, uint32_t off, uint32_t add) -{ - uint32_t tail_off = off; - - while (OPn(tail_off, 2)) - tail_off = OPn(tail_off, 2); - - OPn(tail_off, 2) = add; - - return off; -} - -static inline uint32_t -uc_expect_token(struct uc_state *state, uint32_t off, int token) -{ - uint64_t tokens[(__T_MAX + 63) & -64] = {}; - - tokens[token / 64] |= ((uint64_t)1 << (token % 64)); - uc_parse_error(state, off, tokens, token); - - return 0; -} - -static inline uint32_t -_uc_check_op_seq_types(struct uc_state *state, uint32_t off, ...) -{ - uint64_t tokens[(__T_MAX + 63) & -64] = {}; - int type, token, max_token = 0; - uint32_t arg_off; - va_list ap; - - va_start(ap, off); - - while ((token = va_arg(ap, int)) != 0) { - tokens[token / 64] |= ((uint64_t)1 << (token % 64)); - max_token = (token > max_token) ? token : max_token; - } - - va_end(ap); - - for (arg_off = off; arg_off != 0; arg_off = OP_NEXT(arg_off)) { - type = OP_TYPE(arg_off); - - if (!(tokens[type / 64] & ((uint64_t)1 << (type % 64)))) { - uc_parse_error(state, off, tokens, max_token); - - return 0; - } - } - - return off; -} - -#define uc_check_op_seq_types(state, off, ...) _uc_check_op_seq_types(state, off, __VA_ARGS__, 0) - -static inline uint32_t -uc_reject_local(struct uc_state *state, uint32_t off) -{ - if (OP_TYPE(off) == T_LOCAL) { - uc_new_exception(state, OP_POS(off), - "Syntax error: Unexpected token\nDeclaration not allowed in this context"); - - return 0; - } - - return off; -} - -static inline uint32_t -uc_check_for_in(struct uc_state *state, uint32_t off) -{ - uint32_t arg_off, idx = 0; - - arg_off = (OP_TYPE(off) == T_LOCAL) ? OPn(off, 0) : off; - - if (OP_TYPE(arg_off) == T_LABEL) { - idx = arg_off; - - if (!OP_NEXT(arg_off)) { - uc_new_exception(state, OP_POS(arg_off) + json_object_get_string_len(OP_VAL(arg_off)), - "Syntax error: Unexpected token\nExpecting ',' or 'in'"); - - return 0; - } - - arg_off = OP_NEXT(arg_off); - } - - if (OP_TYPE(arg_off) != T_IN || OP_NEXT(arg_off) || OPn_TYPE(arg_off, 0) != T_LABEL) { - if (OP_TYPE(arg_off) == T_IN && OP_NEXT(arg_off)) - arg_off = OP_NEXT(arg_off); - - uc_new_exception(state, OP_POS(arg_off), "Syntax error: Invalid for-in expression"); - - return 0; - } - - /* transform T_LABEL->T_IN(T_LABEL, ...) into T_IN(T_LABEL->T_LABEL, ...) */ - if (idx) { - OP_NEXT(idx) = 0; - OPn(arg_off, 0) = append_op(idx, OPn(arg_off, 0)); - - if (OP_TYPE(off) == T_LOCAL) - OPn(off, 0) = arg_off; - else - off = arg_off; - } - - return off; -} - -} - -%syntax_error { - uint64_t tokens[(__T_MAX + 63) & -64] = {}; - int i, max_token = 0; - - for (i = 0; i < __T_MAX; i++) { - if (yy_find_shift_action(yypParser, (YYCODETYPE)i) < YYNSTATE + YYNRULE) { - tokens[i / 64] |= ((uint64_t)1 << (i % 64)); - max_token = i; - } - } - - uc_parse_error(state, TOKEN, tokens, max_token); -} - - -input ::= chunks(A). { state->main = new_op(T_FUNC, NULL, 0, 0, A); } -input ::= . { state->main = new_op(T_TEXT, xjs_new_string("")); state->main = new_op(T_FUNC, NULL, 0, 0, state->main); } - -chunks(A) ::= chunks(B) T_TEXT(C). { A = B ? append_op(B, C) : C; } -chunks(A) ::= chunks(B) tplexp(C). { A = B ? append_op(B, C) : C; } -chunks(A) ::= chunks(B) stmt(C). { A = B ? append_op(B, C) : C; } -chunks(A) ::= T_TEXT(B). { A = B; } -chunks(A) ::= tplexp(B). { A = B; } -chunks(A) ::= stmt(B). { A = B; } - -tplexp(A) ::= T_LEXP(B) exp_stmt(C) T_REXP. { A = wrap_op(B, C); } - -stmts(A) ::= stmts(B) stmt(C). { A = B ? append_op(B, C) : C; } -stmts(A) ::= stmt(B). { A = B; } - -stmt(A) ::= cpd_stmt(B). { A = B; } -stmt(A) ::= exp_stmt(B). { A = B; } -stmt(A) ::= sel_stmt(B). { A = B; } -stmt(A) ::= iter_stmt(B). { A = B; } -stmt(A) ::= func_stmt(B). { A = B; } -stmt(A) ::= try_stmt(B). { A = B; } -stmt(A) ::= switch_stmt(B). { A = B; } -stmt(A) ::= ret_stmt(B). { A = B; } -stmt(A) ::= break_stmt(B). { A = B; } -stmt(A) ::= decl_stmt(B). { A = B; } - -//cpd_stmt(A) ::= T_LBRACE T_RBRACE. { A = NULL; } -cpd_stmt(A) ::= T_LBRACE stmts(B) exp(C) T_RBRACE. { A = B ? append_op(B, C) : C; } -cpd_stmt(A) ::= T_LBRACE stmts(B) T_RBRACE. { A = B; } -cpd_stmt(A) ::= T_LBRACE exp(B) T_RBRACE. { A = B; } - -exp_stmt(A) ::= exp(B) T_SCOL. { A = B; } -exp_stmt(A) ::= T_SCOL. { A = 0; } - -sel_stmt(A) ::= T_IF(B) T_LPAREN exp(C) T_RPAREN stmt(D) T_ELSE stmt(E). - { A = wrap_op(B, C, no_empty_obj(D), no_empty_obj(E)); } -sel_stmt(A) ::= T_IF(B) T_LPAREN exp(C) T_RPAREN stmt(D). [T_IF] - { A = wrap_op(B, C, no_empty_obj(D)); } -sel_stmt(A) ::= T_IF(B) T_LPAREN exp(C) T_RPAREN T_COLON chunks(D) sel_elifs(E) T_ELSE chunks(F) T_ENDIF. - { A = uc_add_else(state, wrap_op(B, C, D, E), F); } -sel_stmt(A) ::= T_IF(B) T_LPAREN exp(C) T_RPAREN T_COLON chunks(D) T_ELSE chunks(E) T_ENDIF. - { A = wrap_op(B, C, D, E); } -sel_stmt(A) ::= T_IF(B) T_LPAREN exp(C) T_RPAREN T_COLON chunks(D) T_ENDIF. [T_IF] - { A = wrap_op(B, C, D); } - -sel_elifs(A) ::= sel_elifs(B) sel_elif(C). { A = uc_add_else(state, B, C); } -sel_elifs(A) ::= sel_elif(B). { A = B; } - -sel_elif(A) ::= T_ELIF(B) T_LPAREN exp(C) T_RPAREN T_COLON chunks(D). - { A = wrap_op(B, C, D); } - -iter_stmt(A) ::= T_WHILE(B) T_LPAREN exp(C) T_RPAREN stmt(D). - { A = wrap_op(B, C, no_empty_obj(D)); } -iter_stmt(A) ::= T_WHILE(B) T_LPAREN exp(C) T_RPAREN T_COLON chunks(D) T_ENDWHILE. - { A = wrap_op(B, C, D); } -iter_stmt(A) ::= T_FOR(B) paren_exp(C) stmt(D). - { A = wrap_op(B, uc_check_for_in(state, C), NULL, NULL, no_empty_obj(D)); OP(A)->is_for_in = 1; } -iter_stmt(A) ::= T_FOR(B) paren_exp(C) T_COLON chunks(D) T_ENDFOR. - { A = wrap_op(B, uc_check_for_in(state, C), NULL, NULL, no_empty_obj(D)); OP(A)->is_for_in = 1; } -iter_stmt(A) ::= T_FOR(B) T_LPAREN decl_or_exp(C) exp_stmt(D) T_RPAREN stmt(E). - { A = wrap_op(B, C, D, NULL, no_empty_obj(E)); } -iter_stmt(A) ::= T_FOR(B) T_LPAREN decl_or_exp(C) exp_stmt(D) exp(E) T_RPAREN stmt(F). - { A = wrap_op(B, C, D, E, no_empty_obj(F)); } -iter_stmt(A) ::= T_FOR(B) T_LPAREN decl_or_exp(C) exp_stmt(D) T_RPAREN T_COLON chunks(E) T_ENDFOR. - { A = wrap_op(B, C, D, NULL, E); } -iter_stmt(A) ::= T_FOR(B) T_LPAREN decl_or_exp(C) exp_stmt(D) exp(E) T_RPAREN T_COLON chunks(F) T_ENDFOR. - { A = wrap_op(B, C, D, E, F); } - -func_stmt(A) ::= T_FUNC(B) T_LABEL(C) T_LPAREN T_RPAREN cpd_stmt(D). - { A = wrap_op(B, C, 0, D); } -func_stmt(A) ::= T_FUNC(B) T_LABEL(C) T_LPAREN T_RPAREN empty_object. - { A = wrap_op(B, C, 0, 0); } -func_stmt(A) ::= T_FUNC(B) T_LABEL(C) T_LPAREN T_RPAREN T_COLON chunks(D) T_ENDFUNC. - { A = wrap_op(B, C, 0, D); } -func_stmt(A) ::= T_FUNC(B) T_LABEL(C) T_LPAREN args(D) T_RPAREN cpd_stmt(E). - { A = wrap_op(B, C, D, E); } -func_stmt(A) ::= T_FUNC(B) T_LABEL(C) T_LPAREN args(D) T_RPAREN empty_object. - { A = wrap_op(B, C, D, 0); } -func_stmt(A) ::= T_FUNC(B) T_LABEL(C) T_LPAREN args(D) T_RPAREN T_COLON chunks(E) T_ENDFUNC. - { A = wrap_op(B, C, D, E); } - -try_stmt(A) ::= T_TRY(B) try_catch_block(C) T_CATCH T_LPAREN T_LABEL(D) T_RPAREN try_catch_block(E). - { A = wrap_op(B, C, D, E); } -try_stmt(A) ::= T_TRY(B) try_catch_block(C) T_CATCH try_catch_block(D). - { A = wrap_op(B, C, 0, D); } - -try_catch_block(A) ::= cpd_stmt(B). { A = B; } -try_catch_block(A) ::= empty_object. { A = 0; } - -switch_stmt(A) ::= T_SWITCH(B) T_LPAREN exp(C) T_RPAREN T_LBRACE switch_cases(D) T_RBRACE. - { A = wrap_op(B, C, D); } -switch_stmt(A) ::= T_SWITCH T_LPAREN exp(B) T_RPAREN empty_object. - { A = B; } - -switch_cases(A) ::= switch_cases(B) switch_case(C). { A = append_op(B, C); } -switch_cases(A) ::= switch_case(B). { A = B; } - -switch_case(A) ::= T_CASE(B) exp(C) T_COLON stmts(D). { A = wrap_op(B, C, D); } -switch_case(A) ::= T_CASE(B) exp(C) T_COLON. { A = wrap_op(B, C); } -switch_case(A) ::= T_DEFAULT(B) T_COLON stmts(C). { A = wrap_op(B, C); } - -args(A) ::= sargs(B) T_COMMA T_ELLIP T_LABEL(C). { A = append_op(B, C); OP(C)->is_ellip = 1; } -args(A) ::= T_ELLIP T_LABEL(B). { A = B; OP(B)->is_ellip = 1; } -args(A) ::= sargs(B). { A = B; } - -sargs(A) ::= sargs(B) T_COMMA T_LABEL(C). { A = append_op(B, C); } -sargs(A) ::= T_LABEL(B). { A = B; } - -decl_or_exp(A) ::= exp_stmt(B). { A = B; } -decl_or_exp(A) ::= decl_stmt(B). { A = B; } - -ret_stmt(A) ::= T_RETURN(B) exp(C) T_SCOL. { A = wrap_op(B, C); } -ret_stmt(A) ::= T_RETURN(B) T_SCOL. { A = B; } - -break_stmt(A) ::= T_BREAK(B) T_SCOL. { A = B; } -break_stmt(A) ::= T_CONTINUE(B) T_SCOL. { A = B; } - -decl_stmt(A) ::= T_LOCAL(B) decls(C) T_SCOL. { A = wrap_op(B, uc_check_op_seq_types(state, C, T_ASSIGN, T_LABEL)); } - -decls(A) ::= decls(B) T_COMMA decl(C). { A = append_op(B, C); } -decls(A) ::= decl(B). { A = B; } - -decl(A) ::= T_LABEL(B) T_ASSIGN(C) arrow_exp(D). { A = wrap_op(C, B, D); } -decl(A) ::= T_LABEL(B) T_IN(C) arrow_exp(D). { A = wrap_op(C, B, D); } -decl(A) ::= T_LABEL(B). { A = B; } - -arrowfn_body(A) ::= cpd_stmt(B). { A = B; } -arrowfn_body(A) ::= assign_exp(B). { A = no_empty_obj(B); } - -exp(A) ::= exp(B) T_COMMA assign_exp(C). { A = append_op(B, C); } -exp(A) ::= assign_exp(B). { A = B; } - -assign_exp(A) ::= unary_exp(B) T_ASSIGN(C) arrow_exp(D). - { A = wrap_op(C, B, D); } -assign_exp(A) ::= unary_exp(B) T_ASADD arrow_exp(C). { A = new_op(T_ADD, NULL, B, C); A = new_op(T_ASSIGN, NULL, B, A); } -assign_exp(A) ::= unary_exp(B) T_ASSUB arrow_exp(C). { A = new_op(T_SUB, NULL, B, C); A = new_op(T_ASSIGN, NULL, B, A); } -assign_exp(A) ::= unary_exp(B) T_ASMUL arrow_exp(C). { A = new_op(T_MUL, NULL, B, C); A = new_op(T_ASSIGN, NULL, B, A); } -assign_exp(A) ::= unary_exp(B) T_ASDIV arrow_exp(C). { A = new_op(T_DIV, NULL, B, C); A = new_op(T_ASSIGN, NULL, B, A); } -assign_exp(A) ::= unary_exp(B) T_ASMOD arrow_exp(C). { A = new_op(T_MOD, NULL, B, C); A = new_op(T_ASSIGN, NULL, B, A); } -assign_exp(A) ::= unary_exp(B) T_ASLEFT arrow_exp(C). { A = new_op(T_LSHIFT, NULL, B, C); A = new_op(T_ASSIGN, NULL, B, A); } -assign_exp(A) ::= unary_exp(B) T_ASRIGHT arrow_exp(C). - { A = new_op(T_RSHIFT, NULL, B, C); A = new_op(T_ASSIGN, NULL, B, A); } -assign_exp(A) ::= unary_exp(B) T_ASBAND arrow_exp(C). { A = new_op(T_BAND, NULL, B, C); A = new_op(T_ASSIGN, NULL, B, A); } -assign_exp(A) ::= unary_exp(B) T_ASBXOR arrow_exp(C). { A = new_op(T_BXOR, NULL, B, C); A = new_op(T_ASSIGN, NULL, B, A); } -assign_exp(A) ::= unary_exp(B) T_ASBOR arrow_exp(C). { A = new_op(T_BOR, NULL, B, C); A = new_op(T_ASSIGN, NULL, B, A); } -assign_exp(A) ::= arrow_exp(B). { A = B; } - -arrow_exp(A) ::= unary_exp(B) T_ARROW(C) arrowfn_body(D). - { A = wrap_op(C, 0, uc_check_op_seq_types(state, B, T_LABEL), D); } -arrow_exp(A) ::= T_LPAREN T_RPAREN T_ARROW(C) arrowfn_body(D). - { A = wrap_op(C, 0, 0, D); } -arrow_exp(A) ::= T_LPAREN T_ELLIP T_LABEL(B) T_RPAREN T_ARROW(C) arrowfn_body(D). - { A = wrap_op(C, 0, B, D); OP(B)->is_ellip = 1; } -arrow_exp(A) ::= T_LPAREN exp(B) T_COMMA T_ELLIP T_LABEL(C) T_RPAREN T_ARROW(D) arrowfn_body(E). - { A = append_op(B, C); A = wrap_op(D, 0, uc_check_op_seq_types(state, A, T_LABEL), E); OP(C)->is_ellip = 1; } -arrow_exp(A) ::= ternary_exp(B). { A = B; } - -ternary_exp(A) ::= or_exp(B) T_QMARK(C) assign_exp(D) T_COLON ternary_exp(E). - { A = wrap_op(C, B, D, E); } -ternary_exp(A) ::= or_exp(B). { A = B; } - -or_exp(A) ::= or_exp(B) T_OR(C) and_exp(D). { A = wrap_op(C, B, D); } -or_exp(A) ::= and_exp(B). { A = B; } - -and_exp(A) ::= and_exp(B) T_AND(C) bor_exp(D). { A = wrap_op(C, B, D); } -and_exp(A) ::= bor_exp(B). { A = B; } - -bor_exp(A) ::= bor_exp(B) T_BOR(C) bxor_exp(D). { A = wrap_op(C, B, D); } -bor_exp(A) ::= bxor_exp(B). { A = B; } - -bxor_exp(A) ::= bxor_exp(B) T_BXOR(C) band_exp(D). { A = wrap_op(C, B, D); } -bxor_exp(A) ::= band_exp(B). { A = B; } - -band_exp(A) ::= band_exp(B) T_BAND(C) equal_exp(D). { A = wrap_op(C, B, D); } -band_exp(A) ::= equal_exp(B). { A = B; } - -equal_exp(A) ::= equal_exp(B) T_EQ(C) rel_exp(D). { A = wrap_op(C, B, D); } -equal_exp(A) ::= equal_exp(B) T_NE(C) rel_exp(D). { A = wrap_op(C, B, D); } -equal_exp(A) ::= equal_exp(B) T_EQS(C) rel_exp(D). { A = wrap_op(C, B, D); } -equal_exp(A) ::= equal_exp(B) T_NES(C) rel_exp(D). { A = wrap_op(C, B, D); } -equal_exp(A) ::= rel_exp(B). { A = B; } - -rel_exp(A) ::= rel_exp(B) T_LT(C) shift_exp(D). { A = wrap_op(C, B, D); } -rel_exp(A) ::= rel_exp(B) T_LE(C) shift_exp(D). { A = wrap_op(C, B, D); } -rel_exp(A) ::= rel_exp(B) T_GT(C) shift_exp(D). { A = wrap_op(C, B, D); } -rel_exp(A) ::= rel_exp(B) T_GE(C) shift_exp(D). { A = wrap_op(C, B, D); } -rel_exp(A) ::= rel_exp(B) T_IN(C) shift_exp(D). { A = wrap_op(C, B, D); } -rel_exp(A) ::= shift_exp(B). { A = B; } - -shift_exp(A) ::= shift_exp(B) T_LSHIFT(C) add_exp(D). { A = wrap_op(C, B, D); } -shift_exp(A) ::= shift_exp(B) T_RSHIFT(C) add_exp(D). { A = wrap_op(C, B, D); } -shift_exp(A) ::= add_exp(B). { A = B; } - -add_exp(A) ::= add_exp(B) T_ADD(C) mul_exp(D). { A = wrap_op(C, B, D); } -add_exp(A) ::= add_exp(B) T_SUB(C) mul_exp(D). { A = wrap_op(C, B, D); } -add_exp(A) ::= mul_exp(B). { A = B; } - -mul_exp(A) ::= mul_exp(B) T_MUL(C) unary_exp(D). { A = wrap_op(C, B, D); } -mul_exp(A) ::= mul_exp(B) T_DIV(C) unary_exp(D). { A = wrap_op(C, B, D); } -mul_exp(A) ::= mul_exp(B) T_MOD(C) unary_exp(D). { A = wrap_op(C, B, D); } -mul_exp(A) ::= unary_exp(B). { A = B; } - -unary_exp(A) ::= T_INC(B) unary_exp(C). [T_LPAREN] { A = wrap_op(B, C); } -unary_exp(A) ::= T_DEC(B) unary_exp(C). [T_LPAREN] { A = wrap_op(B, C); } -unary_exp(A) ::= T_ADD(B) unary_exp(C). [T_NOT] { A = wrap_op(B, C); } -unary_exp(A) ::= T_SUB(B) unary_exp(C). [T_NOT] { A = wrap_op(B, C); } -unary_exp(A) ::= T_COMPL(B) unary_exp(C). { A = wrap_op(B, C); } -unary_exp(A) ::= T_NOT(B) unary_exp(C). { A = wrap_op(B, C); } -unary_exp(A) ::= postfix_exp(B). { A = B; } - -postfix_exp(A) ::= unary_exp(B) T_INC(C). { A = wrap_op(C, B); OP(A)->is_postfix = 1; } -postfix_exp(A) ::= unary_exp(B) T_DEC(C). { A = wrap_op(C, B); OP(A)->is_postfix = 1; } -postfix_exp(A) ::= unary_exp(B) T_LPAREN(C) T_RPAREN. { A = wrap_op(C, B); } -postfix_exp(A) ::= unary_exp(B) T_LPAREN(C) arg_exps(D) T_RPAREN. - { A = wrap_op(C, B, D); } -postfix_exp(A) ::= postfix_exp(B) T_DOT(C) T_LABEL(D). { A = wrap_op(C, B, D); } -postfix_exp(A) ::= postfix_exp(B) T_LBRACK(C) exp(D) T_RBRACK. - { A = wrap_op(C, B, D); OP(A)->is_postfix = 1; } -postfix_exp(A) ::= primary_exp(B). { A = B; } - -primary_exp(A) ::= T_BOOL(B). { A = B; } -primary_exp(A) ::= T_NUMBER(B). { A = B; } -primary_exp(A) ::= T_DOUBLE(B). { A = B; } -primary_exp(A) ::= T_STRING(B). { A = B; } -primary_exp(A) ::= T_LABEL(B). { A = B; } -primary_exp(A) ::= T_REGEXP(B). { A = B; } -primary_exp(A) ::= T_NULL(B). { A = B; } -primary_exp(A) ::= T_THIS(B). { A = B; } -primary_exp(A) ::= array(B). { A = B; } -primary_exp(A) ::= object(B). { A = B; } -primary_exp(A) ::= paren_exp(B). { A = uc_reject_local(state, B); } -primary_exp(A) ::= T_FUNC(B) T_LPAREN T_RPAREN empty_object. - { A = B; } -primary_exp(A) ::= T_FUNC(B) T_LPAREN args(C) T_RPAREN empty_object. - { A = wrap_op(B, 0, C, 0); } -primary_exp(A) ::= T_FUNC(B) T_LPAREN T_RPAREN cpd_stmt(C). - { A = wrap_op(B, 0, 0, C); } -primary_exp(A) ::= T_FUNC(B) T_LPAREN args(C) T_RPAREN cpd_stmt(D). - { A = wrap_op(B, 0, C, D); } - -paren_exp(A) ::= T_LPAREN exp(B) T_RPAREN. { A = B; } -paren_exp(A) ::= T_LPAREN T_LOCAL(B) decls(C) T_RPAREN. { A = wrap_op(B, C); } - -array(A) ::= T_LBRACK(B) T_RBRACK. { A = B; } -array(A) ::= T_LBRACK(B) items(C) T_RBRACK. { A = wrap_op(B, C); } - -items(A) ::= items(B) T_COMMA item(C). { A = append_op(B, C); } -items(A) ::= item(B). { A = B; } - -item(A) ::= T_ELLIP assign_exp(B). { A = OP_NEXT(B) ? new_op(T_COMMA, NULL, B) : B; OP(A)->is_ellip = 1; } -item(A) ::= assign_exp(B). { A = OP_NEXT(B) ? new_op(T_COMMA, NULL, B) : B; } - -object(A) ::= empty_object(B). { A = B; } -object(A) ::= T_LBRACE(B) tuples(C) T_RBRACE. { A = wrap_op(B, C); } - -empty_object(A) ::= T_LBRACE(B) T_RBRACE. { A = B; } - -tuples(A) ::= tuples(B) T_COMMA tuple(C). { A = append_op(B, C); } -tuples(A) ::= tuple(B). { A = B; } - -tuple(A) ::= T_LABEL(B) T_COLON exp(C). { A = wrap_op(B, C); } -tuple(A) ::= T_STRING(B) T_COLON exp(C). { A = wrap_op(B, C); } -tuple(A) ::= T_ELLIP(B) assign_exp(C). { A = wrap_op(B, C); } - -arg_exps(A) ::= arg_exps(B) T_COMMA arg_exp(C). { A = append_op(B, C); OP(A)->is_list = 1; } -arg_exps(A) ::= arg_exp(B). { A = B; OP(A)->is_list = 1; } - -arg_exp(A) ::= T_ELLIP assign_exp(B). { A = OP_NEXT(B) ? new_op(T_COMMA, NULL, B) : B; OP(A)->is_ellip = 1; } -arg_exp(A) ::= assign_exp(B). { A = OP_NEXT(B) ? new_op(T_COMMA, NULL, B) : B; } diff --git a/source.c b/source.c new file mode 100644 index 0000000..21b9124 --- /dev/null +++ b/source.c @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include + +#include "source.h" + + +uc_source * +uc_source_new_file(const char *path) +{ + FILE *fp = fopen(path, "rb"); + uc_source *src; + + if (!fp) + return NULL; + + src = xalloc(ALIGN(sizeof(*src)) + strlen(path) + 1); + src->fp = fp; + src->buffer = NULL; + src->filename = strcpy((char *)src + ALIGN(sizeof(*src)), path); + + src->usecount = 1; + + src->lineinfo.count = 0; + src->lineinfo.entries = NULL; + + return src; +} + +uc_source * +uc_source_new_buffer(const char *name, char *buf, size_t len) +{ + FILE *fp = fmemopen(buf, len, "rb"); + uc_source *src; + + if (!fp) + return NULL; + + src = xalloc(ALIGN(sizeof(*src)) + strlen(name) + 1); + src->fp = fp; + src->buffer = buf; + src->filename = strcpy((char *)src + ALIGN(sizeof(*src)), name); + + src->usecount = 1; + + src->lineinfo.count = 0; + src->lineinfo.entries = NULL; + + return src; +} + +size_t +uc_source_get_line(uc_source *source, size_t *offset) +{ + uc_lineinfo *lines = &source->lineinfo; + size_t i, pos = 0, line = 0, lastoff = 0; + + for (i = 0; i < lines->count; i++) { + if (lines->entries[i] & 0x80) { + lastoff = pos; + line++; + pos++; + } + + pos += (lines->entries[i] & 0x7f); + + if (pos >= *offset) { + *offset -= lastoff - 1; + + return line; + } + } + + return 0; +} + +uc_source * +uc_source_get(uc_source *source) +{ + if (!source) + return NULL; + + source->usecount++; + + return source; +} + +void +uc_source_put(uc_source *source) +{ + if (!source) + return; + + if (source->usecount > 1) { + source->usecount--; + + return; + } + + uc_vector_clear(&source->lineinfo); + fclose(source->fp); + free(source->buffer); + free(source); +} diff --git a/source.h b/source.h new file mode 100644 index 0000000..4ca01b3 --- /dev/null +++ b/source.h @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef __SOURCE_H_ +#define __SOURCE_H_ + +#include +#include +#include + +#include "util.h" + + +uc_declare_vector(uc_lineinfo, uint8_t); + +typedef struct { + char *filename, *buffer; + FILE *fp; + size_t usecount, off; + uc_lineinfo lineinfo; +} uc_source; + +uc_source *uc_source_new_file(const char *path); +uc_source *uc_source_new_buffer(const char *name, char *buf, size_t len); + +size_t uc_source_get_line(uc_source *source, size_t *offset); + +uc_source *uc_source_get(uc_source *source); +void uc_source_put(uc_source *source); + +#endif /* __SOURCE_H_ */ diff --git a/tests/00_syntax/05_block_nesting b/tests/00_syntax/05_block_nesting index 7b74adb..fcfd7da 100644 --- a/tests/00_syntax/05_block_nesting +++ b/tests/00_syntax/05_block_nesting @@ -8,6 +8,13 @@ In line 2, byte 61: Near here --------------------------------------------------^ +Syntax error: Template blocks may not be nested +In line 3, byte 61: + + `We may not nest expression blocks into statement blocks: {% {{ 1 + 2 }} %}.` + Near here --------------------------------------------------^ + + -- End -- -- Testcase -- diff --git a/tests/00_syntax/13_object_literals b/tests/00_syntax/13_object_literals index 60c9f32..67dbd6c 100644 --- a/tests/00_syntax/13_object_literals +++ b/tests/00_syntax/13_object_literals @@ -48,6 +48,7 @@ either JSON or JavaScript notation. print(another_obj, "\n"); print(third_obj, "\n"); print(nested_obj, "\n"); +%} -- End -- diff --git a/tests/00_syntax/16_for_loop b/tests/00_syntax/16_for_loop index 33d1d97..67edc21 100644 --- a/tests/00_syntax/16_for_loop +++ b/tests/00_syntax/16_for_loop @@ -218,11 +218,12 @@ Ensure that for-in loop expressions with more than two variables are rejected. -- Expect stderr -- -Syntax error: Invalid for-in expression -In line 2, byte 14: +Syntax error: Unexpected token +Expecting ';' +In line 2, byte 24: ` for (let x, y, z in {})` - Near here ------^ + Near here ----------------^ -- End -- @@ -238,11 +239,12 @@ In line 2, byte 14: Ensure that assignments in for-in loop expressions are rejected. -- Expect stderr -- -Syntax error: Invalid for-in expression -In line 2, byte 13: +Syntax error: Unexpected token +Expecting ';' +In line 2, byte 25: ` for (let x = 1, y in {})` - Near here -----^ + Near here -----------------^ -- End -- @@ -259,7 +261,7 @@ Ensure that too short for-in loop expressions are rejected (1/2). -- Expect stderr -- Syntax error: Unexpected token -Expecting ',' or 'in' +Expecting ';' In line 2, byte 12: ` for (let x)` @@ -279,11 +281,12 @@ In line 2, byte 12: Ensure that too short for-in loop expressions are rejected (2/2). -- Expect stderr -- -Syntax error: Invalid for-in expression -In line 2, byte 14: +Syntax error: Unexpected token +Expecting ';' +In line 2, byte 15: ` for (let x, y)` - Near here ------^ + Near here -------^ -- End -- diff --git a/tests/00_syntax/17_while_loop b/tests/00_syntax/17_while_loop index 4dfaccc..1e68d6b 100644 --- a/tests/00_syntax/17_while_loop +++ b/tests/00_syntax/17_while_loop @@ -32,7 +32,7 @@ Iteration 8 Iteration 9 A counting while-loop using the alternative syntax: -Iteration null +Iteration 0 Iteration 1 Iteration 2 Iteration 3 diff --git a/tests/00_syntax/19_arrow_functions b/tests/00_syntax/19_arrow_functions index 4847d8a..102c527 100644 --- a/tests/00_syntax/19_arrow_functions +++ b/tests/00_syntax/19_arrow_functions @@ -108,11 +108,11 @@ subsequent testcase asserts that case. -- Expect stderr -- Syntax error: Unexpected token -Expecting Label -In line 2, byte 5: +Expecting ';' +In line 2, byte 10: ` (a + 1) => { print("test\n") }` - ^-- Near here + Near here --^ -- End -- diff --git a/tests/00_syntax/21_regex_literals b/tests/00_syntax/21_regex_literals index 4aef33f..3af53bb 100644 --- a/tests/00_syntax/21_regex_literals +++ b/tests/00_syntax/21_regex_literals @@ -35,7 +35,7 @@ Testing invalid flag characters. -- Expect stderr -- Syntax error: Unexpected token -Expecting ',' or ';' +Expecting ';' In line 2, byte 8: ` /test/x` diff --git a/tests/01_arithmetic/04_inc_dec b/tests/01_arithmetic/04_inc_dec index 5a048fe..ae50ceb 100644 --- a/tests/01_arithmetic/04_inc_dec +++ b/tests/01_arithmetic/04_inc_dec @@ -17,9 +17,9 @@ or decrement operation is NaN. -- Expect stdout -- Incrementing a not existing variable assumes "0" as initial value: - - Postfix increment result: null, value after: 1 + - Postfix increment result: 0, value after: 1 - Prefix increment result: 1, value after: 1 - - Postfix decrement result: null, value after: -1 + - Postfix decrement result: 0, value after: -1 - Prefix decrement result: -1, value after: -1 Incrementing a non-numeric value will convert it to a number: diff --git a/tests/02_runtime/00_scoping b/tests/02_runtime/00_scoping index 2bca2ab..5fadf43 100644 --- a/tests/02_runtime/00_scoping +++ b/tests/02_runtime/00_scoping @@ -12,7 +12,7 @@ c_global=true c_local=false -When seting a nonlet variable, it is set in the nearest parent +When seting a nonlocal variable, it is set in the nearest parent scope containing the variable or in the root scope if the variable was not found. @@ -25,13 +25,13 @@ Variables implicitly declared by for-in or counting for loops follow the same scoping rules. inner2 f_a=3 -inner2 f_b=3 +inner2 f_b= inner2 f_c=3 -inner2 f_d=3 +inner2 f_d= inner2 f_e=3 inner f_a=3 -inner f_b=3 +inner f_b= inner f_c=3 inner f_d= inner f_e=3 @@ -73,7 +73,7 @@ c_global={{ !!c_global }} c_local={{ !!c_local }} -When seting a nonlet variable, it is set in the nearest parent +When seting a nonlocal variable, it is set in the nearest parent scope containing the variable or in the root scope if the variable was not found. @@ -110,7 +110,7 @@ scoping rules. {% function scope3() { - // f_a is not declared let and be set i nthe root scope + // f_a is not declared local and be set in the root scope for (f_a = 1; f_a < 3; f_a++) ; @@ -120,7 +120,7 @@ scoping rules. let f_c; function scope4() { - // f_c is not declared let but declared in the parent scope, it + // f_c is not declared local but declared in the parent scope, it // will be set there for (f_c in [1, 2, 3]) ; diff --git a/tests/02_runtime/02_this b/tests/02_runtime/02_this index e629853..d8e85d2 100644 --- a/tests/02_runtime/02_this +++ b/tests/02_runtime/02_this @@ -13,7 +13,8 @@ true } // When invoked, "this" will point to the object containing the function - let o = { + let o; + o = { test: function() { return (this === o); } @@ -34,7 +35,8 @@ true -- Testcase -- {% - let o = { + let o; + o = { test: function() { return (this === o); } @@ -45,3 +47,4 @@ true print(o.test(dummy.foo, dummy.bar), "\n"); print(o.test(dummy.foo, o.test(dummy.foo, dummy.bar)), "\n"); %} +-- End -- diff --git a/tests/02_runtime/03_try_catch b/tests/02_runtime/03_try_catch index 518c1f1..751ca1d 100644 --- a/tests/02_runtime/03_try_catch +++ b/tests/02_runtime/03_try_catch @@ -29,3 +29,110 @@ After exceptions. print("After exceptions.\n"); %} -- End -- + + +Ensure that exceptions are propagated through C function calls. + +-- Expect stderr -- +exception +In [anonymous function](), line 3, byte 18: + called from function replace ([C]) + called from anonymous function ([stdin]:4:3) + + ` die("exception");` + Near here -------------^ + + +-- End -- + +-- Testcase -- +{% + replace("test", "t", function(m) { + die("exception"); + }); +%} +-- End -- + + +Ensure that exception can be catched through C function calls. + +-- Expect stdout -- +Caught exception: exception +-- End -- + +-- Testcase -- +{% + try { + replace("test", "t", function(m) { + die("exception"); + }); + } + catch (e) { + print("Caught exception: ", e, "\n"); + } +%} +-- End -- + + +Ensure that exceptions are propagated through user function calls. + +-- Expect stderr -- +exception +In a(), line 3, byte 18: + called from function b ([stdin]:7:5) + called from function c ([stdin]:11:5) + called from anonymous function ([stdin]:14:4) + + ` die("exception");` + Near here -------------^ + + +-- End -- + +-- Testcase -- +{% + function a() { + die("exception"); + } + + function b() { + a(); + } + + function c() { + b(); + } + + c(); +%} +-- End -- + + +Ensure that exceptions can be caught in parent functions. + +-- Expect stdout -- +Caught exception: exception +-- End -- + +-- Testcase -- +{% + function a() { + die("exception"); + } + + function b() { + a(); + } + + function c() { + try { + b(); + } + catch (e) { + print("Caught exception: ", e, "\n"); + } + } + + c(); +%} +-- End -- diff --git a/tests/02_runtime/04_switch_case b/tests/02_runtime/04_switch_case index 0de87dc..4c1fc57 100644 --- a/tests/02_runtime/04_switch_case +++ b/tests/02_runtime/04_switch_case @@ -84,7 +84,26 @@ default -- End -- -4. Ensure that duplicate default cases emit a syntax +4. Ensure that a single default case matches. + +-- Expect stdout -- +default +default +-- End -- + +-- Testcase -- +{% + for (n in [1, 3]) { + switch (n) { + default: + print("default\n"); + } + } +%} +-- End -- + + +5. Ensure that duplicate default cases emit a syntax error during parsing. -- Expect stderr -- @@ -95,6 +114,13 @@ In line 6, byte 3: ^-- Near here +Syntax error: Expecting expression +In line 8, byte 2: + + ` }` + ^-- Near here + + -- End -- -- Testcase -- @@ -110,7 +136,7 @@ In line 6, byte 3: -- End -- -5. Ensure that case values use strict comparison. +6. Ensure that case values use strict comparison. -- Expect stdout -- b @@ -142,7 +168,7 @@ b -- End -- -6. Ensure that case values may be complex expressions. +7. Ensure that case values may be complex expressions. -- Expect stdout -- 2, 3, 1 @@ -159,7 +185,7 @@ b -- End -- -7. Ensure that empty switch statements are accepted by the +8. Ensure that empty switch statements are accepted by the parser and that the test expression is evaluated. -- Expect stdout -- @@ -179,7 +205,7 @@ true -- End -- -8. Ensure that `return` breaks out of switch statements. +9. Ensure that `return` breaks out of switch statements. -- Expect stdout -- one @@ -207,7 +233,7 @@ two -- End -- -9. Ensure that `continue` breaks out of switch statements. +10. Ensure that `continue` breaks out of switch statements. -- Expect stdout -- one @@ -234,7 +260,7 @@ two -- End -- -10. Ensure that exceptions break out of switch statements. +11. Ensure that exceptions break out of switch statements. -- Expect stdout -- one @@ -242,11 +268,11 @@ one -- Expect stderr -- Died -In test(), line 6, byte 7: - called from anonymous function ([stdin]:17:12) +In test(), line 6, byte 8: + called from anonymous function ([stdin]:17:14) ` die();` - Near here -----^ + Near here ------^ -- End -- @@ -273,7 +299,7 @@ In test(), line 6, byte 7: -- End -- -11. Ensure that consecutive cases values are properly handled. +12. Ensure that consecutive cases values are properly handled. -- Expect stdout -- three and four diff --git a/tests/02_runtime/06_recursion b/tests/02_runtime/06_recursion index b222640..470fc3a 100644 --- a/tests/02_runtime/06_recursion +++ b/tests/02_runtime/06_recursion @@ -39,11 +39,11 @@ Testing recursive invocations. -- Expect stderr -- Runtime error: Too much recursion -In test(), line 3, byte 7: - called from anonymous function ([stdin]:6:6) +In test(), line 3, byte 8: + called from anonymous function ([stdin]:6:7) ` test();` - Near here --^ + Near here ---^ -- End -- diff --git a/util.h b/util.h new file mode 100644 index 0000000..b7029cc --- /dev/null +++ b/util.h @@ -0,0 +1,248 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef __UTIL_H_ +#define __UTIL_H_ + +#include +#include +#include +#include +#include /* va_start(), va_end(), va_list */ +#include /* strdup() */ +#include + + +/* alignment & array size */ + +#ifndef ALIGN +#define ALIGN(x) (((x) + sizeof(size_t) - 1) & -sizeof(size_t)) +#endif + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) +#endif + +#define JSON_C_TO_STRING_STRICT (1<<31) + + +/* vector macros */ + +#define UC_VECTOR_CHUNK_SIZE 8 + +#define uc_declare_vector(name, type) \ + typedef struct { \ + size_t count; \ + type *entries; \ + } name + +#define uc_vector_grow(vec) \ + do { \ + if (((vec)->count % UC_VECTOR_CHUNK_SIZE) == 0) { \ + (vec)->entries = xrealloc((vec)->entries, sizeof((vec)->entries[0]) * ((vec)->count + UC_VECTOR_CHUNK_SIZE)); \ + memset(&(vec)->entries[(vec)->count], 0, sizeof((vec)->entries[0]) * UC_VECTOR_CHUNK_SIZE); \ + } \ + } while(0) + +#define uc_vector_clear(vec) \ + do { \ + free((vec)->entries); \ + (vec)->entries = NULL; \ + (vec)->count = 0; \ + } while(0) + +#define uc_vector_first(vec) \ + (&((vec)->entries[0])) + +#define uc_vector_last(vec) \ + (&((vec)->entries[(vec)->count - 1])) + + +/* debug helper */ + +static inline uint32_t getrefcnt(json_object *v) { + struct { + enum json_type o_type; + uint32_t _ref_count; + } *spy = (void *)v; + + return spy ? spy->_ref_count : 0; +} + +static inline void *xalloc(size_t size) { + void *ptr = calloc(1, size); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + + +/* "failsafe" utility functions */ + +static inline void *xrealloc(void *ptr, size_t size) { + ptr = realloc(ptr, size); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + +static inline char *xstrdup(const char *s) { + char *ptr = strdup(s); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + +static inline json_object *xjs_new_object(void) { + json_object *ptr = json_object_new_object(); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + +static inline json_object *xjs_new_array(void) { + json_object *ptr = json_object_new_array(); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + +static inline json_object *xjs_new_array_size(int size) { + json_object *ptr = json_object_new_array_ext(size); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + +static inline json_object *xjs_new_int64(int64_t n) { + json_object *ptr = json_object_new_int64(n); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + +static inline json_object *xjs_new_uint64(uint64_t n) { + json_object *ptr = json_object_new_uint64(n); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + +static inline json_object *xjs_new_string(const char *s) { + json_object *ptr = json_object_new_string(s); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + +static inline json_object *xjs_new_string_len(const char *s, size_t len) { + json_object *ptr = json_object_new_string_len(s, len); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + +static inline json_object *xjs_new_boolean(bool v) { + json_object *ptr = json_object_new_boolean(v); + + if (!ptr) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return ptr; +} + + +static inline struct json_tokener *xjs_new_tokener(void) { + struct json_tokener *tok = json_tokener_new(); + + if (!tok) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return tok; +} + +static inline int xasprintf(char **strp, const char *fmt, ...) { + va_list ap; + int len; + + va_start(ap, fmt); + len = vasprintf(strp, fmt, ap); + va_end(ap); + + if (len == -1) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return len; +} + +static inline int xvasprintf(char **strp, const char *fmt, va_list ap) { + int len = vasprintf(strp, fmt, ap); + + if (len == -1) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + return len; +} + +#endif /* __UTIL_H_ */ diff --git a/value.c b/value.c new file mode 100644 index 0000000..cea8220 --- /dev/null +++ b/value.c @@ -0,0 +1,716 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include /* memcpy(), memset() */ +#include /* htobe64(), be64toh() */ +#include /* isnan(), INFINITY */ +#include /* isspace(), isdigit(), isxdigit() */ +#include + +#include "util.h" +#include "chunk.h" +#include "value.h" +#include "object.h" +#include "lexer.h" /* TK_* */ + +#define TAG_TYPE uint64_t +#define TAG_BITS 3 +#define TAG_MASK ((1LL << ((sizeof(TAG_TYPE) << 3) - TAG_BITS)) - 1) +#define TAG_MAXN (TAG_MASK / 2) +#define TAG_ALIGN(s) (((s) + (1 << TAG_BITS) - 1) & -(1 << TAG_BITS)) +#define TAG_GET_TYPE(n) (int)((TAG_TYPE)n & ((1 << TAG_BITS) - 1)) +#define TAG_FIT_NV(n) ((int64_t)n >= -TAG_MAXN && (int64_t)n <= TAG_MAXN) +#define TAG_SET_NV(n) ((TAG_TYPE)((int64_t)n + TAG_MAXN) << TAG_BITS) +#define TAG_GET_NV(n) (int64_t)((int64_t)(((TAG_TYPE)n >> TAG_BITS) & TAG_MASK) - TAG_MAXN) +#define TAG_FIT_STR(l) ((l - 1) < (((sizeof(TAG_TYPE) << 3) - TAG_BITS) >> 3)) +#define TAG_SET_STR_L(l) (TAG_TYPE)((l & ((1 << (8 - TAG_BITS)) - 1)) << TAG_BITS) +#define TAG_GET_STR_L(n) (size_t)(((TAG_TYPE)n >> TAG_BITS) & ((1 << (8 - TAG_BITS)) - 1)) +#define TAG_GET_BOOL(n) (bool)(((TAG_TYPE)n >> TAG_BITS) & 1) +#define TAG_GET_OFFSET(n) (size_t)(((TAG_TYPE)n >> TAG_BITS) & TAG_MASK) + +#define UC_VALLIST_CHUNK_SIZE 8 + + +static int +uc_double_tostring(json_object *v, struct printbuf *pb, int level, int flags) +{ + bool strict = (level > 0) || (flags & JSON_C_TO_STRING_STRICT); + double d = json_object_get_double(v); + + if (isnan(d)) + return sprintbuf(pb, strict ? "\"NaN\"" : "NaN"); + + if (d == INFINITY) + return sprintbuf(pb, strict ? "1e309" : "Infinity"); + + if (d == -INFINITY) + return sprintbuf(pb, strict ? "-1e309" : "-Infinity"); + + return sprintbuf(pb, "%g", d); +} + +json_object * +uc_double_new(double v) +{ + json_object *d = json_object_new_double(v); + + if (!d) { + fprintf(stderr, "Out of memory\n"); + abort(); + } + + json_object_set_serializer(d, uc_double_tostring, NULL, NULL); + + return d; +} + +bool +uc_val_is_truish(json_object *val) +{ + double d; + + switch (json_object_get_type(val)) { + case json_type_int: + return (json_object_get_int64(val) != 0); + + case json_type_double: + d = json_object_get_double(val); + + return (d != 0 && !isnan(d)); + + case json_type_boolean: + return (json_object_get_boolean(val) != false); + + case json_type_string: + return (json_object_get_string_len(val) > 0); + + case json_type_array: + case json_type_object: + return true; + + default: + return false; + } +} + +enum json_type +uc_cast_number(json_object *v, int64_t *n, double *d) +{ + bool is_double = false; + const char *s; + char *e; + + *d = 0.0; + *n = 0; + + switch (json_object_get_type(v)) { + case json_type_int: + *n = json_object_get_int64(v); + + return json_type_int; + + case json_type_double: + *d = json_object_get_double(v); + + return json_type_double; + + case json_type_null: + return json_type_int; + + case json_type_boolean: + *n = json_object_get_boolean(v) ? 1 : 0; + + return json_type_int; + + case json_type_string: + s = json_object_get_string(v); + + while (isspace(*s)) + s++; + + if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X') && isxdigit(s[2])) { + *n = strtoll(s, &e, 16); + } + else if (s[0] == '0' && isdigit(s[2])) { + *n = strtoll(s, &e, 8); + } + else { + *n = strtoll(s, &e, 10); + + if (*e == '.') { + *d = strtod(s, &e); + is_double = (e > s); + } + } + + while (isspace(*e)) + e++; + + if (*e) { + *d = NAN; + + return json_type_double; + } + + if (is_double) + return json_type_double; + + return json_type_int; + + default: + *d = NAN; + + return json_type_double; + } +} + +static json_object * +uc_getproto(json_object *obj) +{ + uc_prototype *proto; + + switch (uc_object_type(obj)) { + case UC_OBJ_RESSOURCE: + proto = uc_ressource_prototype(obj); + break; + + case UC_OBJ_PROTOTYPE: + proto = uc_object_as_prototype(obj)->parent; + break; + + default: + proto = NULL; + } + + return proto ? proto->header.jso : NULL; +} + +json_object * +uc_getval(json_object *scope, json_object *key) +{ + json_object *o, *v; + int64_t idx; + double d; + + if (!key) + return NULL; + + if (json_object_is_type(scope, json_type_array)) { + /* only consider doubles with integer values as array keys */ + if (json_object_is_type(key, json_type_double)) { + d = json_object_get_double(key); + + if ((double)(int64_t)(d) != d) + return NULL; + + idx = (int64_t)d; + } + else { + errno = 0; + idx = json_object_get_int64(key); + + if (errno != 0) + return NULL; + } + + return json_object_get(json_object_array_get_idx(scope, idx)); + } + + for (o = scope; o; o = uc_getproto(o)) { + if (!json_object_is_type(o, json_type_object)) + continue; + + if (json_object_object_get_ex(o, key ? json_object_get_string(key) : "null", &v)) + return json_object_get(v); + } + + return NULL; +} + +json_object * +uc_setval(json_object *scope, json_object *key, json_object *val) +{ + int64_t idx; + + if (!key) + return NULL; + + if (json_object_is_type(scope, json_type_array)) { + errno = 0; + idx = json_object_get_int64(key); + + if (errno != 0) + return NULL; + + if (json_object_array_put_idx(scope, idx, val)) + return NULL; + + return json_object_get(val); + } + + if (json_object_object_add(scope, key ? json_object_get_string(key) : "null", val)) + return NULL; + + return json_object_get(val); +} + +bool +uc_cmp(int how, json_object *v1, json_object *v2) +{ + enum json_type t1 = json_object_get_type(v1); + enum json_type t2 = json_object_get_type(v2); + int64_t n1, n2, delta; + double d1, d2; + + if (t1 == json_type_string && t2 == json_type_string) { + delta = strcmp(json_object_get_string(v1), json_object_get_string(v2)); + } + else { + if ((t1 == json_type_array && t2 == json_type_array) || + (t1 == json_type_object && t2 == json_type_object)) { + delta = (void *)v1 - (void *)v2; + } + else { + t1 = uc_cast_number(v1, &n1, &d1); + t2 = uc_cast_number(v2, &n2, &d2); + + if (t1 == json_type_double || t2 == json_type_double) { + d1 = (t1 == json_type_double) ? d1 : (double)n1; + d2 = (t2 == json_type_double) ? d2 : (double)n2; + + if (d1 == d2) + delta = 0; + else if (d1 < d2) + delta = -1; + else + delta = 1; + } + else { + delta = n1 - n2; + } + } + } + + switch (how) { + case TK_LT: + return (delta < 0); + + case TK_LE: + return (delta <= 0); + + case TK_GT: + return (delta > 0); + + case TK_GE: + return (delta >= 0); + + case TK_EQ: + return (delta == 0); + + case TK_NE: + return (delta != 0); + + default: + return false; + } +} + +bool +uc_eq(json_object *v1, json_object *v2) +{ + uc_objtype_t o1 = uc_object_type(v1); + uc_objtype_t o2 = uc_object_type(v2); + enum json_type t1 = json_object_get_type(v1); + enum json_type t2 = json_object_get_type(v2); + + if (o1 != o2 || t1 != t2) + return false; + + switch (t1) { + case json_type_array: + case json_type_object: + return (v1 == v2); + + case json_type_boolean: + return (json_object_get_boolean(v1) == json_object_get_boolean(v2)); + + case json_type_double: + if (isnan(json_object_get_double(v1)) || isnan(json_object_get_double(v2))) + return false; + + return (json_object_get_double(v1) == json_object_get_double(v2)); + + case json_type_int: + return (json_object_get_int64(v1) == json_object_get_int64(v2)); + + case json_type_string: + return !strcmp(json_object_get_string(v1), json_object_get_string(v2)); + + case json_type_null: + return true; + } + + return false; +} + +void +uc_vallist_init(uc_value_list *list) +{ + list->isize = 0; + list->dsize = 0; + list->index = NULL; + list->data = NULL; +} + +void +uc_vallist_free(uc_value_list *list) +{ + json_object *o; + size_t i; + + for (i = 0; i < list->isize; i++) { + if (TAG_GET_TYPE(list->index[i]) == TAG_PTR) { + o = uc_vallist_get(list, i); + uc_value_put(o); + uc_value_put(o); + } + } + + free(list->index); + free(list->data); + uc_vallist_init(list); +} + +static void +add_num(uc_value_list *list, int64_t n) +{ + size_t sz = TAG_ALIGN(sizeof(n)); + + if (TAG_FIT_NV(n)) { + list->index[list->isize++] = (TAG_TYPE)(TAG_NUM | TAG_SET_NV(n)); + } + else { + if (list->dsize + sz > TAG_MASK) { + fprintf(stderr, "Constant data too large\n"); + abort(); + } + + list->data = xrealloc(list->data, list->dsize + sz); + + n = htobe64(n); + memset(list->data + list->dsize, 0, sz); + memcpy(list->data + list->dsize, &n, sizeof(n)); + + list->index[list->isize++] = (TAG_TYPE)(TAG_LNUM | (list->dsize << TAG_BITS)); + list->dsize += sz; + } +} + +static ssize_t +find_num(uc_value_list *list, int64_t n) +{ + TAG_TYPE search; + size_t i; + + if (TAG_FIT_NV(n)) { + search = (TAG_TYPE)(TAG_NUM | TAG_SET_NV(n)); + + for (i = 0; i < list->isize; i++) + if (list->index[i] == search) + return i; + } + else { + for (i = 0; i < list->isize; i++) { + if (TAG_GET_TYPE(list->index[i]) != TAG_LNUM) + continue; + + if (TAG_GET_OFFSET(list->index[i]) + sizeof(int64_t) > list->dsize) + continue; + + if ((int64_t)be64toh(*(int64_t *)(list->data + TAG_GET_OFFSET(list->index[i]))) != n) + continue; + + return i; + } + } + + return -1; +} + +static void +add_dbl(uc_value_list *list, double d) +{ + size_t sz = TAG_ALIGN(sizeof(d)); + + if (list->dsize + sz > TAG_MASK) { + fprintf(stderr, "Constant data too large\n"); + abort(); + } + + list->data = xrealloc(list->data, list->dsize + sz); + + memset(list->data + list->dsize, 0, sz); + memcpy(list->data + list->dsize, &d, sizeof(d)); + + list->index[list->isize++] = (uint64_t)(TAG_DBL | (list->dsize << TAG_BITS)); + list->dsize += sz; +} + +static ssize_t +find_dbl(uc_value_list *list, double d) +{ + size_t i; + + for (i = 0; i < list->isize; i++) { + if (TAG_GET_TYPE(list->index[i]) != TAG_DBL) + continue; + + if (TAG_GET_OFFSET(list->index[i]) + sizeof(double) > list->dsize) + continue; + + if (*(double *)(list->data + TAG_GET_OFFSET(list->index[i])) != d) + continue; + + return i; + } + + return -1; +} + +static void +add_str(uc_value_list *list, const char *s, size_t slen) +{ + uint32_t sl; + size_t sz; + char *dst; + int i; + + if (slen > UINT32_MAX) { + fprintf(stderr, "String constant too long\n"); + abort(); + } + + sz = TAG_ALIGN(sizeof(uint32_t) + slen); + + if (list->dsize + sz > TAG_MASK) { + fprintf(stderr, "Constant data too large\n"); + abort(); + } + + if (TAG_FIT_STR(slen)) { + list->index[list->isize] = (uint64_t)(TAG_STR | TAG_SET_STR_L(slen)); + + for (i = 0; i < slen; i++) + list->index[list->isize] |= (((TAG_TYPE)s[i] << ((i + 1) << 3))); + + list->isize++; + } + else { + list->data = xrealloc(list->data, list->dsize + sz); + + sl = htobe32(slen); + dst = list->data + list->dsize; + memcpy(dst, &sl, sizeof(sl)); + + dst += sizeof(sl); + memcpy(dst, s, slen); + + dst += slen; + memset(dst, 0, TAG_ALIGN(sizeof(uint32_t) + slen) - (sizeof(uint32_t) + slen)); + + list->index[list->isize++] = (uint64_t)(TAG_LSTR | (list->dsize << TAG_BITS)); + list->dsize += sz; + } +} + +static ssize_t +find_str(uc_value_list *list, const char *s, size_t slen) +{ + TAG_TYPE search; + size_t i, len; + + if (TAG_FIT_STR(slen)) { + search = (TAG_TYPE)(TAG_STR | TAG_SET_STR_L(slen)); + + for (i = 0; i < slen; i++) + search |= (((TAG_TYPE)s[i] << ((i + 1) << 3))); + + for (i = 0; i < list->isize; i++) + if (list->index[i] == search) + return i; + } + else { + for (i = 0; i < list->isize; i++) { + if (TAG_GET_TYPE(list->index[i]) != TAG_LSTR) + continue; + + if (TAG_GET_OFFSET(list->index[i]) + sizeof(uint32_t) > list->dsize) + continue; + + len = (size_t)be32toh(*(uint32_t *)(list->data + TAG_GET_OFFSET(list->index[i]))); + + if (len != slen) + continue; + + if (TAG_GET_OFFSET(list->index[i]) + sizeof(uint32_t) + len > list->dsize) + continue; + + if (memcmp(list->data + TAG_GET_OFFSET(list->index[i]) + sizeof(uint32_t), s, slen)) + continue; + + return i; + } + } + + return -1; +} + +static void +add_ptr(uc_value_list *list, void *ptr) +{ + size_t sz = TAG_ALIGN(sizeof(ptr)); + + if (list->dsize + sz > TAG_MASK) { + fprintf(stderr, "Constant data too large\n"); + abort(); + } + + list->data = xrealloc(list->data, list->dsize + sz); + + memset(list->data + list->dsize, 0, sz); + memcpy(list->data + list->dsize, &ptr, sizeof(ptr)); + + list->index[list->isize++] = (uint64_t)(TAG_PTR | (list->dsize << TAG_BITS)); + list->dsize += sz; +} + +ssize_t +uc_vallist_add(uc_value_list *list, json_object *value) +{ + ssize_t existing; + + if ((list->isize % UC_VALLIST_CHUNK_SIZE) == 0) { + list->index = xrealloc(list->index, sizeof(list->index[0]) * (list->isize + UC_VALLIST_CHUNK_SIZE)); + memset(&list->index[list->isize], 0, UC_VALLIST_CHUNK_SIZE); + } + + switch (json_object_get_type(value)) { + case json_type_int: + existing = find_num(list, json_object_get_int64(value)); + + if (existing > -1) + return existing; + + add_num(list, json_object_get_int64(value)); + + break; + + case json_type_double: + existing = find_dbl(list, json_object_get_double(value)); + + if (existing > -1) + return existing; + + add_dbl(list, json_object_get_double(value)); + + break; + + case json_type_string: + existing = find_str(list, + json_object_get_string(value), + json_object_get_string_len(value)); + + if (existing > -1) + return existing; + + add_str(list, + json_object_get_string(value), + json_object_get_string_len(value)); + + break; + + case json_type_object: + add_ptr(list, value); + break; + + default: + return -1; + } + + return (ssize_t)list->isize - 1; +} + +uc_value_type_t +uc_vallist_type(uc_value_list *list, size_t idx) +{ + if (idx >= list->isize) + return TAG_INVAL; + + return TAG_GET_TYPE(list->index[idx]); +} + +json_object * +uc_vallist_get(uc_value_list *list, size_t idx) +{ + char str[sizeof(TAG_TYPE)]; + size_t len; + int n; + + switch (uc_vallist_type(list, idx)) { + case TAG_NUM: + return xjs_new_int64(TAG_GET_NV(list->index[idx])); + + case TAG_LNUM: + if (TAG_GET_OFFSET(list->index[idx]) + sizeof(int64_t) > list->dsize) + return NULL; + + return xjs_new_int64(be64toh(*(int64_t *)(list->data + TAG_GET_OFFSET(list->index[idx])))); + + case TAG_DBL: + if (TAG_GET_OFFSET(list->index[idx]) + sizeof(double) > list->dsize) + return NULL; + + return uc_double_new(*(double *)(list->data + TAG_GET_OFFSET(list->index[idx]))); + + case TAG_STR: + len = TAG_GET_STR_L(list->index[idx]); + + for (n = 0; n < len; n++) + str[n] = (list->index[idx] >> ((n + 1) << 3)); + + return xjs_new_string_len(str, len); + + case TAG_LSTR: + if (TAG_GET_OFFSET(list->index[idx]) + sizeof(uint32_t) > list->dsize) + return NULL; + + len = (size_t)be32toh(*(uint32_t *)(list->data + TAG_GET_OFFSET(list->index[idx]))); + + if (TAG_GET_OFFSET(list->index[idx]) + sizeof(uint32_t) + len > list->dsize) + return NULL; + + return xjs_new_string_len(list->data + TAG_GET_OFFSET(list->index[idx]) + sizeof(uint32_t), len); + + case TAG_PTR: + if (TAG_GET_OFFSET(list->index[idx]) + sizeof(void *) > list->dsize) + return NULL; + + return uc_value_get(*(json_object **)(list->data + TAG_GET_OFFSET(list->index[idx]))); + + default: + return NULL; + } +} diff --git a/value.h b/value.h new file mode 100644 index 0000000..e9d5ce6 --- /dev/null +++ b/value.h @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef __VALUE_H_ +#define __VALUE_H_ + +#include +#include +#include + +#ifdef JSONC + #include +#else + #include +#endif + +#include + +typedef enum { + TAG_INVAL = 0, + TAG_NUM = 1, + TAG_LNUM = 2, + TAG_DBL = 3, + TAG_STR = 4, + TAG_LSTR = 5, + TAG_PTR = 6 +} uc_value_type_t; + +typedef struct { + size_t isize; + size_t dsize; + uint64_t *index; + char *data; +} uc_value_list; + +json_object *uc_double_new(double v); + +bool uc_eq(json_object *v1, json_object *v2); +bool uc_cmp(int how, json_object *v1, json_object *v2); +bool uc_val_is_truish(json_object *val); + +enum json_type uc_cast_number(json_object *v, int64_t *n, double *d); + +json_object *uc_getval(json_object *scope, json_object *key); +json_object *uc_setval(json_object *scope, json_object *key, json_object *val); + +void uc_vallist_init(uc_value_list *list); +void uc_vallist_free(uc_value_list *list); + +ssize_t uc_vallist_add(uc_value_list *list, json_object *value); +uc_value_type_t uc_vallist_type(uc_value_list *list, size_t idx); +struct json_object *uc_vallist_get(uc_value_list *list, size_t idx); + +#define uc_value_get(val) \ + ({ \ + struct json_object *__o = val; \ + /*fprintf(stderr, "get(%p // %s) [%d + 1] @ %s:%d\n", __o, json_object_to_json_string(__o), getrefcnt(__o), __FILE__, __LINE__);*/ \ + json_object_get(__o); \ + }) + +#define uc_value_put(val) \ + ({ \ + struct json_object *__o = val; \ + /*fprintf(stderr, "put(%p // %s) [%d - 1] @ %s:%d\n", __o, json_object_to_json_string(__o), getrefcnt(__o), __FILE__, __LINE__);*/ \ + json_object_put(__o); \ + }) + +#endif /* __VALUE_H_ */ diff --git a/vm.c b/vm.c new file mode 100644 index 0000000..e5cfdb5 --- /dev/null +++ b/vm.c @@ -0,0 +1,2233 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include +#include +#include + +#include "vm.h" +#include "compiler.h" +#include "lib.h" /* format_error_context() */ + +#undef __insn +#define __insn(_name) #_name, + +static const char *insn_names[__I_MAX] = { + __insns +}; + +static const uc_insn_definition insn_defs[__I_MAX] = { + [I_NOOP] = { 0, 0, 0 }, + + [I_LOAD] = { 0, 1, 4 }, + [I_LOAD8] = { 0, 1, -1 }, + [I_LOAD16] = { 0, 1, -2 }, + [I_LOAD32] = { 0, 1, -4 }, + + [I_LREXP] = { 0, 1, 4 }, + [I_LNULL] = { 0, 1, 0 }, + [I_LTRUE] = { 0, 1, 0 }, + [I_LFALSE] = { 0, 1, 0 }, + [I_LTHIS] = { 0, 1, 0 }, + + [I_LLOC] = { 0, 1, 4 }, + [I_LVAR] = { 0, 1, 4 }, + [I_LUPV] = { 0, 1, 4 }, + [I_LVAL] = { 2, 1, 0 }, + + [I_CLFN] = { 0, 1, 4, true }, + [I_ARFN] = { 0, 1, 4, true }, + + [I_SLOC] = { 0, 0, 4 }, + [I_SUPV] = { 0, 0, 4 }, + [I_SVAR] = { 0, 0, 4 }, + [I_SVAL] = { 3, 1, 0 }, + + [I_ULOC] = { 1, 0, 4 }, + [I_UUPV] = { 1, 0, 4 }, + [I_UVAR] = { 1, 0, 4 }, + [I_UVAL] = { 3, 1, 1 }, + + [I_NARR] = { 0, 1, 4 }, + [I_PARR] = { -1, 0, 4 }, + [I_MARR] = { 1, 0, 0 }, + + [I_NOBJ] = { 0, 1, 4 }, + [I_SOBJ] = { -1, 0, 4 }, + [I_MOBJ] = { 1, 0, 0 }, + + [I_ADD] = { 2, 1, 0 }, + [I_SUB] = { 2, 1, 0 }, + [I_MUL] = { 2, 1, 0 }, + [I_DIV] = { 2, 1, 0 }, + [I_MOD] = { 2, 1, 0 }, + [I_LSHIFT] = { 2, 1, 0 }, + [I_RSHIFT] = { 2, 1, 0 }, + [I_BAND] = { 2, 1, 0 }, + [I_BXOR] = { 2, 1, 0 }, + [I_BOR] = { 2, 1, 0 }, + [I_EQ] = { 2, 1, 0 }, + [I_NE] = { 2, 1, 0 }, + [I_EQS] = { 2, 1, 0 }, + [I_NES] = { 2, 1, 0 }, + [I_LT] = { 2, 1, 0 }, + [I_GT] = { 2, 1, 0 }, + [I_IN] = { 2, 1, 0 }, + + [I_JMP] = { 0, 0, -4, true }, + [I_JMPZ] = { 1, 0, -4, true }, + + [I_COPY] = { 0, 1, 1 }, + [I_POP] = { 1, 0, 0 }, + [I_CUPV] = { 1, 0, 0 }, + + [I_PLUS] = { 1, 1, 0 }, + [I_MINUS] = { 1, 1, 0 }, + + [I_RETURN] = { 1, 0, 0 }, + [I_CALL] = { -2, 1, 4 }, + [I_MCALL] = { -3, 1, 4 }, + + [I_NEXTK] = { 2, 2, 0 }, + [I_NEXTKV] = { 2, 3, 0 }, + + [I_PRINT] = { 1, 0, 0 } +}; + +static const char *exception_type_strings[] = { + [EXCEPTION_SYNTAX] = "Syntax error", + [EXCEPTION_RUNTIME] = "Runtime error", + [EXCEPTION_TYPE] = "Type error", + [EXCEPTION_REFERENCE] = "Reference error", + [EXCEPTION_USER] = "Error", +}; + + +static void +uc_vm_reset_stack(uc_vm *vm) +{ + while (vm->stack.count > 0) { + vm->stack.count--; + uc_value_put(vm->stack.entries[vm->stack.count]); + vm->stack.entries[vm->stack.count] = NULL; + } +} + +static json_object * +uc_vm_callframe_pop(uc_vm *vm); + +static void +uc_vm_reset_callframes(uc_vm *vm) +{ + while (vm->callframes.count > 0) + uc_value_put(uc_vm_callframe_pop(vm)); +} + +void uc_vm_init(uc_vm *vm, uc_parse_config *config) +{ + char *s = getenv("TRACE"); + + vm->exception.type = EXCEPTION_NONE; + vm->exception.message = NULL; + + vm->trace = s ? strtoul(s, NULL, 0) : 0; + + vm->config = config; + + vm->open_upvals = NULL; + + uc_vm_reset_stack(vm); +} + +void uc_vm_free(uc_vm *vm) +{ + uc_upvalref *ref; + + uc_value_put(vm->exception.stacktrace); + free(vm->exception.message); + + while (vm->open_upvals) { + ref = vm->open_upvals->next; + uc_value_put(vm->open_upvals->header.jso); + vm->open_upvals = ref; + } + + uc_vm_reset_callframes(vm); + uc_vm_reset_stack(vm); + uc_vector_clear(&vm->stack); + uc_vector_clear(&vm->callframes); +} + +static uc_chunk * +uc_vm_frame_chunk(uc_callframe *frame) +{ + return frame->closure ? &frame->closure->function->chunk : NULL; +} + +static uc_callframe * +uc_vm_current_frame(uc_vm *vm) +{ + return uc_vector_last(&vm->callframes); +} + +static uc_chunk * +uc_vm_current_chunk(uc_vm *vm) +{ + return uc_vm_frame_chunk(uc_vm_current_frame(vm)); +} + +static enum insn_type +uc_vm_decode_insn(uc_vm *vm, uc_callframe *frame, uc_chunk *chunk) +{ + enum insn_type insn; + +#ifndef NDEBUG + uint8_t *end = chunk->entries + chunk->count; +#endif + + assert(frame->ip < end); + + insn = frame->ip[0]; + frame->ip++; + + assert(frame->ip + abs(insn_defs[insn].operand_bytes) <= end); + + switch (insn_defs[insn].operand_bytes) { + case 0: + break; + + case -1: + vm->arg.s8 = frame->ip[0] - 0x7f; + frame->ip++; + break; + + case -2: + vm->arg.s16 = ( + frame->ip[0] * 0x100 + + frame->ip[1] + ) - 0x7fff; + frame->ip += 2; + break; + + case -4: + vm->arg.s32 = ( + frame->ip[0] * 0x1000000 + + frame->ip[1] * 0x10000 + + frame->ip[2] * 0x100 + + frame->ip[3] + ) - 0x7fffffff; + frame->ip += 4; + break; + + case 1: + vm->arg.u8 = frame->ip[0]; + frame->ip++; + break; + + case 4: + vm->arg.u32 = ( + frame->ip[0] * 0x1000000 + + frame->ip[1] * 0x10000 + + frame->ip[2] * 0x100 + + frame->ip[3] + ); + frame->ip += 4; + break; + + default: + fprintf(stderr, "Unhandled operand format: %d\n", insn_defs[insn].operand_bytes); + abort(); + } + + return insn; +} + + +static void +uc_vm_frame_dump(uc_vm *vm, uc_callframe *frame) +{ + uc_chunk *chunk = uc_vm_frame_chunk(frame); + uc_function *function; + uc_closure *closure; + uc_upvalref *ref; + size_t i; + + fprintf(stderr, " [*] CALLFRAME[%lx]\n", + frame - vm->callframes.entries); + + fprintf(stderr, " |- stackframe %zu/%zu\n", + frame->stackframe, vm->stack.count); + + fprintf(stderr, " |- ctx %s\n", + json_object_to_json_string(frame->ctx)); + + if (chunk) { + fprintf(stderr, " |- %zu constants\n", + chunk->constants.isize); + + for (i = 0; i < chunk->constants.isize; i++) + fprintf(stderr, " | [%zu] %s\n", + i, + json_object_to_json_string(uc_chunk_get_constant(chunk, i))); + + closure = frame->closure; + function = closure->function; + + fprintf(stderr, " `- %zu upvalues\n", + function->nupvals); + + for (i = 0; i < function->nupvals; i++) { + ref = closure->upvals[i]; + + if (ref->closed) + fprintf(stderr, " [%zu] <%p> %s {closed} %s\n", + i, + ref, + json_object_to_json_string( + uc_chunk_debug_get_variable(chunk, 0, i, true)), + json_object_to_json_string(ref->value)); + else + fprintf(stderr, " [%zu] <%p> %s {open[%zu]} %s\n", + i, + ref, + json_object_to_json_string( + uc_chunk_debug_get_variable(chunk, 0, i, true)), + ref->slot, + json_object_to_json_string(vm->stack.entries[ref->slot])); + } + } +} + +void +uc_vm_stack_push(uc_vm *vm, json_object *value) +{ + uc_vector_grow(&vm->stack); + + uc_value_put(vm->stack.entries[vm->stack.count]); + + vm->stack.entries[vm->stack.count] = value; + vm->stack.count++; + + if (vm->trace) + fprintf(stderr, " [+%zd] %s\n", + vm->stack.count, + json_object_to_json_string(value)); +} + +json_object * +uc_vm_stack_pop(uc_vm *vm) +{ + json_object *rv; + + vm->stack.count--; + rv = vm->stack.entries[vm->stack.count]; + vm->stack.entries[vm->stack.count] = NULL; + + if (vm->trace) + fprintf(stderr, " [-%zd] %s\n", + vm->stack.count + 1, + json_object_to_json_string(rv)); + + return rv; +} + +json_object * +uc_vm_stack_peek(uc_vm *vm, size_t offset) +{ + return vm->stack.entries[vm->stack.count + (-1 - offset)]; +} + +static void +uc_vm_stack_set(uc_vm *vm, size_t offset, json_object *value) +{ + if (vm->trace) + fprintf(stderr, " [!%zu] %s\n", + offset, json_object_to_json_string(value)); + + uc_value_put(vm->stack.entries[offset]); + vm->stack.entries[offset] = value; +} + +static void +uc_vm_call_native(uc_vm *vm, json_object *ctx, uc_cfunction *fptr, bool mcall, size_t nargs) +{ + json_object *res = NULL; + uc_callframe *frame; + + /* add new callframe */ + uc_vector_grow(&vm->callframes); + + frame = &vm->callframes.entries[vm->callframes.count++]; + frame->stackframe = vm->stack.count - nargs - 1; + frame->cfunction = fptr; + frame->closure = NULL; + frame->ctx = ctx; + frame->mcall = mcall; + + if (vm->trace) + uc_vm_frame_dump(vm, frame); + + res = fptr->cfn(vm, nargs); + + /* reset stack */ + uc_value_put(uc_vm_callframe_pop(vm)); + + /* push return value */ + if (!vm->exception.type) + uc_vm_stack_push(vm, res); + else + uc_value_put(res); +} + +static bool +uc_vm_call_function(uc_vm *vm, json_object *ctx, json_object *fno, bool mcall, size_t argspec) +{ + size_t i, j, stackoff, nargs = argspec & 0xffff, nspreads = argspec >> 16; + uc_callframe *frame = uc_vm_current_frame(vm); + json_object *ellip, *arg; + uc_function *function; + uc_closure *closure; + uint16_t slot, tmp; + + /* XXX: make dependent on stack size */ + if (vm->callframes.count >= 1000) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Too much recursion"); + + return false; + } + + stackoff = vm->stack.count - nargs - 1; + + /* argument list contains spread operations, we need to reshuffle the stack */ + if (nspreads > 0) { + /* create temporary array */ + ellip = xjs_new_array_size(nargs); + + /* pop original stack values and push to temp array in reverse order */ + for (i = 0; i < nargs; i++) + json_object_array_add(ellip, uc_vm_stack_pop(vm)); + + /* for each spread value index ... */ + for (i = 0, slot = nargs; i < nspreads; i++) { + /* decode stack depth value */ + tmp = frame->ip[0] * 0x100 + frame->ip[1]; + frame->ip += 2; + + /* push each preceeding non-spread value to the stack */ + for (j = slot; j > tmp + 1; j--) + uc_vm_stack_push(vm, uc_value_get(json_object_array_get_idx(ellip, j - 1))); + + /* read spread value at index... */ + slot = tmp; + arg = uc_value_get(json_object_array_get_idx(ellip, slot)); + + /* ... ensure that it is an array type ... */ + if (!json_object_is_type(arg, json_type_array)) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "(%s) is not iterable", + json_object_to_json_string(arg)); + + return false; + } + + /* ... and push each spread array value as argument to the stack */ + for (j = 0; j < json_object_array_length(arg); j++) + uc_vm_stack_push(vm, uc_value_get(json_object_array_get_idx(arg, j))); + + uc_value_put(arg); + } + + /* push remaining non-spread arguments to the stack */ + for (i = slot; i > 0; i--) + uc_vm_stack_push(vm, uc_value_get(json_object_array_get_idx(ellip, i - 1))); + + /* free temp array */ + uc_value_put(ellip); + + /* update arg count */ + nargs = vm->stack.count - stackoff - 1; + } + + /* is a native function */ + if (uc_object_is_type(fno, UC_OBJ_CFUNCTION)) { + uc_vm_call_native(vm, ctx, uc_object_as_cfunction(fno), mcall, nargs); + + return true; + } + + if (!uc_object_is_type(fno, UC_OBJ_CLOSURE)) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, "left-hand side is not a function"); + + return false; + } + + closure = uc_object_as_closure(fno); + function = closure->function; + + /* fewer arguments on stack than function expects => pad */ + if (nargs < function->nargs) { + for (i = nargs; i < function->nargs; i++) { + if (function->vararg && (i + 1) == function->nargs) + uc_vm_stack_push(vm, xjs_new_array_size(0)); + else + uc_vm_stack_push(vm, NULL); + } + } + + /* more arguments on stack than function expects... */ + else if (nargs > function->nargs - function->vararg) { + /* is a vararg function => pass excess args as array */ + if (function->vararg) { + ellip = xjs_new_array_size(nargs - (function->nargs - 1)); + + for (i = function->nargs; i <= nargs; i++) + json_object_array_add(ellip, uc_vm_stack_peek(vm, nargs - i)); + + for (i = function->nargs; i <= nargs; i++) + uc_vm_stack_pop(vm); + + uc_vm_stack_push(vm, ellip); + } + + /* static amount of args => drop excess values */ + else { + for (i = function->nargs; i < nargs; i++) + uc_value_put(uc_vm_stack_pop(vm)); + } + } + + uc_vector_grow(&vm->callframes); + + frame = &vm->callframes.entries[vm->callframes.count++]; + frame->stackframe = stackoff; + frame->cfunction = NULL; + frame->closure = closure; + frame->ctx = ctx; + frame->ip = function->chunk.entries; + frame->mcall = mcall; + + if (vm->trace) + uc_vm_frame_dump(vm, frame); + + return true; +} + +static uc_source *last_source = NULL; +static size_t last_srcpos = 0; + +static void +uc_dump_insn(uc_vm *vm, uint8_t *pos, enum insn_type insn) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + uc_chunk *chunk = uc_vm_frame_chunk(frame); + size_t msglen = 0, srcpos; + json_object *cnst = NULL; + char *msg = NULL; + + srcpos = uc_function_get_srcpos(frame->closure->function, pos - chunk->entries); + + if (last_srcpos == 0 || last_source != frame->closure->function->source || srcpos != last_srcpos) { + format_source_context(&msg, &msglen, + frame->closure->function->source, + srcpos, true); + + fprintf(stderr, "%s", msg); + + last_source = frame->closure->function->source; + last_srcpos = srcpos; + } + + fprintf(stderr, "%08lx %s", pos - chunk->entries, insn_names[insn]); + + switch (insn_defs[insn].operand_bytes) { + case 0: + break; + + case -1: + fprintf(stderr, " {%s%hhd}", vm->arg.s8 < 0 ? "" : "+", vm->arg.s8); + break; + + case -2: + fprintf(stderr, " {%s%hx}", vm->arg.s16 < 0 ? "" : "+", vm->arg.s16); + break; + + case -4: + fprintf(stderr, " {%s%x}", vm->arg.s32 < 0 ? "" : "+", vm->arg.s32); + break; + + case 1: + fprintf(stderr, " {%hhu}", vm->arg.u8); + break; + + case 2: + fprintf(stderr, " {%hx}", vm->arg.u16); + break; + + case 4: + fprintf(stderr, " {%x}", vm->arg.u32); + break; + + default: + fprintf(stderr, " (unknown operand format: %d)", insn_defs[insn].operand_bytes); + break; + } + + switch (insn) { + case I_LOAD: + case I_LVAR: + case I_SVAR: + cnst = uc_chunk_get_constant(uc_vm_frame_chunk(uc_vector_last(&vm->callframes)), vm->arg.u32); + + fprintf(stderr, "\t; %s", cnst ? json_object_to_json_string(cnst) : "null"); + uc_value_put(cnst); + break; + + case I_LLOC: + case I_LUPV: + case I_SLOC: + case I_SUPV: + cnst = uc_chunk_debug_get_variable(chunk, pos - chunk->entries, vm->arg.u32, (insn == I_LUPV || insn == I_SUPV)); + + fprintf(stderr, "\t; %s", cnst ? json_object_to_json_string(cnst) : "(?)"); + uc_value_put(cnst); + break; + + case I_ULOC: + case I_UUPV: + cnst = uc_chunk_debug_get_variable(chunk, pos - chunk->entries, vm->arg.u32 & 0x00ffffff, (insn == I_UUPV)); + /* fall through */ + + case I_UVAR: + if (!cnst) + cnst = uc_chunk_get_constant(uc_vm_frame_chunk(uc_vector_last(&vm->callframes)), vm->arg.u32 & 0x00ffffff); + + fprintf(stderr, "\t; %s (%s)", + cnst ? json_object_to_json_string(cnst) : "(?)", + insn_names[vm->arg.u32 >> 24]); + + uc_value_put(cnst); + break; + + case I_UVAL: + fprintf(stderr, "\t; (%s)", insn_names[vm->arg.u32]); + break; + + default: + break; + } + + fprintf(stderr, "\n"); +} + +static int +uc_vm_exception_tostring(json_object *jso, struct printbuf *pb, int level, int flags) +{ + bool strict = (level > 0) || (flags & JSON_C_TO_STRING_STRICT); + json_object *message = json_object_object_get(jso, "message"); + + return sprintbuf(pb, "%s", + strict ? json_object_to_json_string(message) : json_object_get_string(message)); +} + +static bool +uc_vm_handle_exception(uc_vm *vm) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + uc_chunk *chunk = NULL; + json_object *exo; + size_t i, pos; + + if (!frame->closure) + return false; + + chunk = uc_vm_frame_chunk(frame); + pos = frame->ip - chunk->entries; + + /* iterate the known exception ranges, see if the current ip falls into any of them */ + for (i = 0; i < chunk->ehranges.count; i++) { + /* skip nonmatching ranges */ + if (pos < chunk->ehranges.entries[i].from || + pos >= chunk->ehranges.entries[i].to) + continue; + + /* we found a matching range... first unwind stack */ + while (vm->stack.count > frame->stackframe + chunk->ehranges.entries[i].slot) + uc_value_put(uc_vm_stack_pop(vm)); + + /* prepare exception object and expose it to user handler code */ + exo = xjs_new_object(); + + json_object_object_add(exo, "type", xjs_new_string(exception_type_strings[vm->exception.type])); + json_object_object_add(exo, "message", xjs_new_string(vm->exception.message)); + json_object_object_add(exo, "stacktrace", uc_value_get(vm->exception.stacktrace)); + + json_object_set_serializer(exo, uc_vm_exception_tostring, NULL, NULL); + uc_vm_stack_push(vm, exo); + + /* reset exception information */ + free(vm->exception.message); + + vm->exception.type = EXCEPTION_NONE; + vm->exception.message = NULL; + + /* jump to exception handler */ + if (chunk->ehranges.entries[i].target >= chunk->count) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "jump target out of range"); + return false; + } + +#if 0 + if (vm->trace && chunk->entries + chunk->ehranges.entries[i].target > frame->ip) { + while (frame->ip < chunk->entries + chunk->ehranges.entries[i].target) { + fprintf(stderr, "(eh:skip) [%p:%zu] ", chunk, frame->ip - chunk->entries); + uc_dump_insn(vm, frame->ip, uc_vm_decode_insn(vm, frame, chunk)); + } + } +#endif + + frame->ip = chunk->entries + chunk->ehranges.entries[i].target; + + return true; + } + + return false; +} + +static json_object * +uc_vm_capture_stacktrace(uc_vm *vm, size_t i) +{ + json_object *stacktrace, *entry, *last = NULL; + uc_function *function; + uc_callframe *frame; + size_t off, srcpos; + char *name; + + stacktrace = xjs_new_array(); + + for (; i > 0; i--) { + frame = &vm->callframes.entries[i - 1]; + entry = xjs_new_object(); + + if (frame->closure) { + function = frame->closure->function; + + off = (frame->ip - uc_vm_frame_chunk(frame)->entries) - 1; + srcpos = uc_function_get_srcpos(function, off); + + json_object_object_add(entry, "filename", xjs_new_string(function->source->filename)); + json_object_object_add(entry, "line", xjs_new_int64(uc_source_get_line(function->source, &srcpos))); + json_object_object_add(entry, "byte", xjs_new_int64(srcpos)); + } + + if (i > 1) { + if (frame->closure) { + if (frame->closure->function->name) + name = frame->closure->function->name; + else if (frame->closure->is_arrow) + name = "[arrow function]"; + else + name = "[anonymous function]"; + } + else { + name = frame->cfunction->name; + } + + json_object_object_add(entry, "function", xjs_new_string(name)); + } + + if (!json_object_equal(last, entry)) { + json_object_array_add(stacktrace, entry); + last = entry; + } + else { + uc_value_put(entry); + } + } + + return stacktrace; +} + +static json_object * +uc_vm_get_error_context(uc_vm *vm) +{ + json_object *stacktrace; + uc_callframe *frame; + uc_chunk *chunk; + size_t offset, len = 0, i; + char *msg = NULL; + + /* skip to first non-native function call frame */ + for (i = vm->callframes.count; i > 0; i--) + if (vm->callframes.entries[i - 1].closure) + break; + + frame = &vm->callframes.entries[i - 1]; + + if (!frame->closure) + return NULL; + + chunk = uc_vm_frame_chunk(frame); + offset = uc_function_get_srcpos(frame->closure->function, (frame->ip - chunk->entries) - 1); + stacktrace = uc_vm_capture_stacktrace(vm, i); + + if (offset) + format_error_context(&msg, &len, frame->closure->function->source, stacktrace, offset); + else + xasprintf(&msg, "At offset %zu", (frame->ip - chunk->entries) - 1); + + json_object_object_add(json_object_array_get_idx(stacktrace, 0), "context", xjs_new_string(msg)); + + free(msg); + + return stacktrace; +} + +void __attribute__((format(printf, 3, 0))) +uc_vm_raise_exception(uc_vm *vm, uc_exception_type_t type, const char *fmt, ...) +{ + va_list ap; + + vm->exception.type = type; + + free(vm->exception.message); + + va_start(ap, fmt); + xvasprintf(&vm->exception.message, fmt, ap); + va_end(ap); + + uc_value_put(vm->exception.stacktrace); + vm->exception.stacktrace = uc_vm_get_error_context(vm); +} + + +static void +uc_vm_insn_load(uc_vm *vm, enum insn_type insn) +{ + switch (insn) { + case I_LOAD: + uc_vm_stack_push(vm, uc_chunk_get_constant(uc_vm_current_chunk(vm), vm->arg.u32)); + break; + + case I_LOAD8: + uc_vm_stack_push(vm, xjs_new_int64(vm->arg.s8)); + break; + + case I_LOAD16: + uc_vm_stack_push(vm, xjs_new_int64(vm->arg.s16)); + break; + + case I_LOAD32: + uc_vm_stack_push(vm, xjs_new_int64(vm->arg.s32)); + break; + + default: + break; + } +} + +static void +uc_vm_insn_load_regexp(uc_vm *vm, enum insn_type insn) +{ + bool icase = false, newline = false, global = false; + json_object *jstr = uc_chunk_get_constant(uc_vm_current_chunk(vm), vm->arg.u32); + const char *str; + uc_regexp *re; + char *err; + + if (!json_object_is_type(jstr, json_type_string) || json_object_get_string_len(jstr) < 2) { + uc_vm_stack_push(vm, NULL); + uc_value_put(jstr); + + return; + } + + str = json_object_get_string(jstr); + + global = (*str & (1 << 0)); + icase = (*str & (1 << 1)); + newline = (*str & (1 << 2)); + + re = uc_regexp_new(++str, icase, newline, global, &err); + + uc_value_put(jstr); + + if (re) + uc_vm_stack_push(vm, re->header.jso); + else + uc_vm_raise_exception(vm, EXCEPTION_SYNTAX, "%s", err); +} + +static void +uc_vm_insn_load_null(uc_vm *vm, enum insn_type insn) +{ + uc_vm_stack_push(vm, NULL); +} + +static void +uc_vm_insn_load_bool(uc_vm *vm, enum insn_type insn) +{ + uc_vm_stack_push(vm, xjs_new_boolean(insn == I_LTRUE)); +} + +static void +uc_vm_insn_load_var(uc_vm *vm, enum insn_type insn) +{ + json_object *name, *val = NULL; + uc_prototype *scope, *next; + + scope = vm->globals; + name = uc_chunk_get_constant(uc_vm_current_chunk(vm), vm->arg.u32); + + while (json_object_get_type(name) == json_type_string) { + if (json_object_object_get_ex(scope->header.jso, json_object_get_string(name), &val)) + break; + + next = scope->parent; + + if (!next) { + if (vm->config->strict_declarations) { + uc_vm_raise_exception(vm, EXCEPTION_REFERENCE, + "access to undeclared variable %s", + json_object_get_string(name)); + } + + break; + } + + scope = next; + } + + uc_value_put(name); + + uc_vm_stack_push(vm, uc_value_get(val)); +} + +static void +uc_vm_insn_load_val(uc_vm *vm, enum insn_type insn) +{ + json_object *k = uc_vm_stack_pop(vm); + json_object *v = uc_vm_stack_pop(vm); + + switch (json_object_get_type(v)) { + case json_type_object: + case json_type_array: + uc_vm_stack_push(vm, uc_getval(v, k)); + break; + + default: + uc_vm_raise_exception(vm, EXCEPTION_REFERENCE, + "left-hand side expression is %s", + v ? "not an array or object" : "null"); + + break; + } + + + uc_value_put(k); + uc_value_put(v); +} + +static void +uc_vm_insn_load_upval(uc_vm *vm, enum insn_type insn) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + uc_upvalref *ref = frame->closure->upvals[vm->arg.u32]; + + if (ref->closed) + uc_vm_stack_push(vm, uc_value_get(ref->value)); + else + uc_vm_stack_push(vm, uc_value_get(vm->stack.entries[ref->slot])); +} + +static void +uc_vm_insn_load_local(uc_vm *vm, enum insn_type insn) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + + uc_vm_stack_push(vm, uc_value_get(vm->stack.entries[frame->stackframe + vm->arg.u32])); +} + +static uc_upvalref * +uc_vm_capture_upval(uc_vm *vm, size_t slot) +{ + uc_upvalref *curr = vm->open_upvals; + uc_upvalref *prev = NULL; + uc_upvalref *created; + + while (curr && curr->slot > slot) { + prev = curr; + curr = curr->next; + } + + if (curr && curr->slot == slot) { + if (vm->trace) + fprintf(stderr, " {+%zu} <%p> %s\n", + slot, + curr, + json_object_to_json_string(vm->stack.entries[slot])); + + return curr; + } + + created = uc_upvalref_new(slot); + created->next = curr; + + if (vm->trace) + fprintf(stderr, " {*%zu} <%p> %s\n", + slot, + created, + json_object_to_json_string(vm->stack.entries[slot])); + + if (prev) + prev->next = created; + else + vm->open_upvals = created; + + return created; +} + +static void +uc_vm_close_upvals(uc_vm *vm, size_t slot) +{ + uc_upvalref *ref; + + while (vm->open_upvals && vm->open_upvals->slot >= slot) { + ref = vm->open_upvals; + ref->value = uc_value_get(vm->stack.entries[ref->slot]); + ref->closed = true; + + if (vm->trace) + fprintf(stderr, " {!%zu} <%p> %s\n", + ref->slot, + ref, + json_object_to_json_string(ref->value)); + + vm->open_upvals = ref->next; + json_object_put(ref->header.jso); + } +} + +static void +uc_vm_insn_load_closure(uc_vm *vm, enum insn_type insn) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + json_object *fno = uc_chunk_get_constant(uc_vm_current_chunk(vm), vm->arg.u32); + uc_function *function = uc_object_as_function(fno); + uc_closure *closure = uc_closure_new(function, insn == I_ARFN); + volatile int32_t uv; + size_t i; + + uc_vm_stack_push(vm, closure->header.jso); + + for (i = 0; i < function->nupvals; i++) { + uv = ( + frame->ip[0] * 0x1000000 + + frame->ip[1] * 0x10000 + + frame->ip[2] * 0x100 + + frame->ip[3] + ) - 0x7fffffff; + + if (uv < 0) + closure->upvals[i] = uc_vm_capture_upval(vm, frame->stackframe - (uv + 1)); + else + closure->upvals[i] = frame->closure->upvals[uv]; + + uc_value_get(closure->upvals[i]->header.jso); + + frame->ip += 4; + } +} + +static void +uc_vm_insn_store_var(uc_vm *vm, enum insn_type insn) +{ + json_object *name, *v = uc_vm_stack_pop(vm); + uc_prototype *scope, *next; + + scope = vm->globals; + name = uc_chunk_get_constant(uc_vm_current_chunk(vm), vm->arg.u32); + + while (json_object_get_type(name) == json_type_string) { + if (json_object_object_get_ex(scope->header.jso, json_object_get_string(name), NULL)) + break; + + next = scope->parent; + + if (!next) { + if (vm->config->strict_declarations) { + uc_vm_raise_exception(vm, EXCEPTION_REFERENCE, + "access to undeclared variable %s", + json_object_get_string(name)); + } + + break; + } + + scope = next; + } + + if (scope && json_object_get_type(name) == json_type_string) + json_object_object_add(scope->header.jso, json_object_get_string(name), uc_value_get(v)); + + uc_value_put(name); + uc_vm_stack_push(vm, v); +} + +static void +uc_vm_insn_store_val(uc_vm *vm, enum insn_type insn) +{ + json_object *v = uc_vm_stack_pop(vm); + json_object *k = uc_vm_stack_pop(vm); + json_object *o = uc_vm_stack_pop(vm); + + uc_vm_stack_push(vm, uc_setval(o, k, v)); + + uc_value_put(o); + uc_value_put(k); +} + +static void +uc_vm_insn_store_upval(uc_vm *vm, enum insn_type insn) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + uc_upvalref *ref = frame->closure->upvals[vm->arg.u32]; + json_object *val = uc_value_get(uc_vm_stack_peek(vm, 0)); + + if (ref->closed) { + uc_value_put(ref->value); + ref->value = val; + } + else { + uc_vm_stack_set(vm, ref->slot, val); + } +} + +static void +uc_vm_insn_store_local(uc_vm *vm, enum insn_type insn) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + json_object *val = uc_value_get(uc_vm_stack_peek(vm, 0)); + + uc_vm_stack_set(vm, frame->stackframe + vm->arg.u32, val); +} + +static json_object * +uc_vm_value_bitop(uc_vm *vm, enum insn_type operation, json_object *value, json_object *operand) +{ + json_object *rv = NULL; + int64_t n1, n2; + double d; + + if (uc_cast_number(value, &n1, &d) == json_type_double) + n1 = isnan(d) ? 0 : (int64_t)d; + + if (uc_cast_number(operand, &n2, &d) == json_type_double) + n2 = isnan(d) ? 0 : (int64_t)d; + + switch (operation) { + case I_LSHIFT: + rv = xjs_new_int64(n1 << n2); + break; + + case I_RSHIFT: + rv = xjs_new_int64(n1 >> n2); + break; + + case I_BAND: + rv = xjs_new_int64(n1 & n2); + break; + + case I_BXOR: + rv = xjs_new_int64(n1 ^ n2); + break; + + case I_BOR: + rv = xjs_new_int64(n1 | n2); + break; + + default: + break; + } + + return rv; +} + +static json_object * +uc_vm_value_arith(uc_vm *vm, enum insn_type operation, json_object *value, json_object *operand) +{ + json_object *rv = NULL; + enum json_type t1, t2; + const char *s1, *s2; + size_t len1, len2; + int64_t n1, n2; + double d1, d2; + char *s; + + if (operation > I_MOD) + return uc_vm_value_bitop(vm, operation, value, operand); + + if (operation == I_ADD && + (json_object_is_type(value, json_type_string) || + json_object_is_type(operand, json_type_string))) { + s1 = value ? json_object_get_string(value) : "null"; + s2 = operand ? json_object_get_string(operand) : "null"; + len1 = strlen(s1); + len2 = strlen(s2); + s = xalloc(len1 + len2 + 1); + + snprintf(s, len1 + len2 + 1, "%s%s", s1, s2); + + rv = xjs_new_string(s); + + free(s); + + return rv; + } + + t1 = uc_cast_number(value, &n1, &d1); + t2 = uc_cast_number(operand, &n2, &d2); + + if (t1 == json_type_double || t2 == json_type_double) { + d1 = (t1 == json_type_double) ? d1 : (double)n1; + d2 = (t2 == json_type_double) ? d2 : (double)n2; + + switch (operation) { + case I_ADD: + case I_PLUS: + rv = uc_double_new(d1 + d2); + break; + + case I_SUB: + rv = uc_double_new(d1 - d2); + break; + + case I_MUL: + rv = uc_double_new(d1 * d2); + break; + + case I_DIV: + if (d2 == 0.0) + rv = uc_double_new(INFINITY); + else if (isnan(d2)) + rv = uc_double_new(NAN); + else if (!isfinite(d2)) + rv = uc_double_new(isfinite(d1) ? 0.0 : NAN); + else + rv = uc_double_new(d1 / d2); + + break; + + case I_MOD: + rv = uc_double_new(NAN); + break; + + default: + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "undefined arithmetic operation %d", + operation); + break; + } + } + else { + switch (operation) { + case I_ADD: + case I_PLUS: + rv = xjs_new_int64(n1 + n2); + break; + + case I_SUB: + rv = xjs_new_int64(n1 - n2); + break; + + case I_MUL: + rv = xjs_new_int64(n1 * n2); + break; + + case I_DIV: + if (n2 == 0) + rv = uc_double_new(INFINITY); + else + rv = xjs_new_int64(n1 / n2); + + break; + + case I_MOD: + rv = xjs_new_int64(n1 % n2); + break; + + default: + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, + "undefined arithmetic operation %d", + operation); + break; + } + } + + return rv; +} + +static void +uc_vm_insn_update_var(uc_vm *vm, enum insn_type insn) +{ + json_object *name, *val, *inc = uc_vm_stack_pop(vm); + uc_prototype *scope, *next; + + scope = vm->globals; + name = uc_chunk_get_constant(uc_vm_current_chunk(vm), vm->arg.u32 & 0x00FFFFFF); + + assert(json_object_is_type(name, json_type_string)); + + while (true) { + if (json_object_object_get_ex(scope->header.jso, json_object_get_string(name), &val)) + break; + + next = scope->parent; + + if (!next) { + if (vm->config->strict_declarations) { + uc_vm_raise_exception(vm, EXCEPTION_REFERENCE, + "access to undeclared variable %s", + json_object_get_string(name)); + } + + break; + } + + scope = next; + } + + val = uc_vm_value_arith(vm, vm->arg.u32 >> 24, val, inc); + + json_object_object_add(scope->header.jso, json_object_get_string(name), uc_value_get(val)); + uc_vm_stack_push(vm, val); + + uc_value_put(name); + uc_value_put(inc); +} + +static void +uc_vm_insn_update_val(uc_vm *vm, enum insn_type insn) +{ + json_object *inc = uc_vm_stack_pop(vm); + json_object *k = uc_vm_stack_pop(vm); + json_object *v = uc_vm_stack_pop(vm); + json_object *val = NULL; + + switch (json_object_get_type(v)) { + case json_type_object: + case json_type_array: + val = uc_getval(v, k); + uc_vm_stack_push(vm, uc_setval(v, k, uc_vm_value_arith(vm, vm->arg.u8, val, inc))); + break; + + default: + uc_vm_raise_exception(vm, EXCEPTION_REFERENCE, + "left-hand side expression is %s", + v ? "not an array or object" : "null"); + + break; + } + + uc_value_put(val); + uc_value_put(inc); + uc_value_put(v); + uc_value_put(k); +} + +static void +uc_vm_insn_update_upval(uc_vm *vm, enum insn_type insn) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + size_t slot = vm->arg.u32 & 0x00FFFFFF; + uc_upvalref *ref = frame->closure->upvals[slot]; + json_object *inc = uc_vm_stack_pop(vm); + json_object *val; + + if (ref->closed) + val = ref->value; + else + val = vm->stack.entries[ref->slot]; + + val = uc_vm_value_arith(vm, vm->arg.u32 >> 24, val, inc); + + uc_vm_stack_push(vm, val); + + uc_value_put(inc); + + if (ref->closed) { + uc_value_put(ref->value); + ref->value = uc_value_get(uc_vm_stack_peek(vm, 0)); + } + else { + uc_vm_stack_set(vm, ref->slot, uc_value_get(uc_vm_stack_peek(vm, 0))); + } +} + +static void +uc_vm_insn_update_local(uc_vm *vm, enum insn_type insn) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + size_t slot = vm->arg.u32 & 0x00FFFFFF; + json_object *inc = uc_vm_stack_pop(vm); + json_object *val; + + val = uc_vm_value_arith(vm, vm->arg.u32 >> 24, + vm->stack.entries[frame->stackframe + slot], inc); + + uc_vm_stack_push(vm, val); + + uc_value_put(inc); + uc_vm_stack_set(vm, frame->stackframe + slot, uc_value_get(uc_vm_stack_peek(vm, 0))); +} + +static void +uc_vm_insn_narr(uc_vm *vm, enum insn_type insn) +{ + json_object *arr = xjs_new_array_size(vm->arg.u32); + + uc_vm_stack_push(vm, arr); +} + +static void +uc_vm_insn_parr(uc_vm *vm, enum insn_type insn) +{ + json_object *arr = uc_vm_stack_peek(vm, vm->arg.u32); + size_t idx; + + for (idx = 0; idx < vm->arg.u32; idx++) + json_object_array_add(arr, uc_vm_stack_peek(vm, vm->arg.u32 - idx - 1)); + + for (idx = 0; idx < vm->arg.u32; idx++) + uc_vm_stack_pop(vm); + + //uc_vm_shrink(state, vm->arg.u32); +} + +static void +uc_vm_insn_marr(uc_vm *vm, enum insn_type insn) +{ + json_object *src = uc_vm_stack_pop(vm); + json_object *dst = uc_vm_stack_peek(vm, 0); + size_t i; + + if (!json_object_is_type(src, json_type_array)) { + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "(%s) is not iterable", + json_object_to_json_string(src)); + + return; + } + + for (i = 0; i < json_object_array_length(src); i++) + json_object_array_add(dst, uc_value_get(json_object_array_get_idx(src, i))); + + uc_value_put(src); +} + +static void +uc_vm_insn_nobj(uc_vm *vm, enum insn_type insn) +{ + json_object *arr = xjs_new_object(); + + uc_vm_stack_push(vm, arr); +} + +static void +uc_vm_insn_sobj(uc_vm *vm, enum insn_type insn) +{ + json_object *obj = uc_vm_stack_peek(vm, vm->arg.u32); + size_t idx; + + for (idx = 0; idx < vm->arg.u32; idx += 2) { + json_object_object_add(obj, + json_object_get_string(uc_vm_stack_peek(vm, vm->arg.u32 - idx - 1)), + uc_value_get(uc_vm_stack_peek(vm, vm->arg.u32 - idx - 2))); + } + + for (idx = 0; idx < vm->arg.u32; idx++) + uc_value_put(uc_vm_stack_pop(vm)); +} + +static void +uc_vm_insn_mobj(uc_vm *vm, enum insn_type insn) +{ + json_object *src = uc_vm_stack_pop(vm); + json_object *dst = uc_vm_stack_peek(vm, 0); + char *istr; + size_t i; + + switch (json_object_get_type(src)) { + case json_type_object: + ; /* a label can only be part of a statement and a declaration is not a statement */ + json_object_object_foreach(src, k, v) + json_object_object_add(dst, k, uc_value_get(v)); + + uc_value_put(src); + break; + + case json_type_array: + for (i = 0; i < json_object_array_length(src); i++) { + xasprintf(&istr, "%zu", i); + json_object_object_add(dst, istr, uc_value_get(json_object_array_get_idx(src, i))); + free(istr); + } + + uc_value_put(src); + break; + + default: + uc_vm_raise_exception(vm, EXCEPTION_TYPE, + "Value (%s) is not iterable", + json_object_to_json_string(src)); + + break; + } +} + +static void +uc_vm_insn_arith(uc_vm *vm, enum insn_type insn) +{ + json_object *r2 = uc_vm_stack_pop(vm); + json_object *r1 = uc_vm_stack_pop(vm); + json_object *rv; + + rv = uc_vm_value_arith(vm, insn, r1, r2); + + uc_value_put(r1); + uc_value_put(r2); + + uc_vm_stack_push(vm, rv); +} + +static void +uc_vm_insn_plus_minus(uc_vm *vm, enum insn_type insn) +{ + struct json_object *v = uc_vm_stack_pop(vm); + bool is_sub = (insn == I_MINUS); + enum json_type t; + int64_t n; + double d; + + t = uc_cast_number(v, &n, &d); + + json_object_put(v); + + switch (t) { + case json_type_int: + uc_vm_stack_push(vm, xjs_new_int64(is_sub ? -n : n)); + break; + + default: + uc_vm_stack_push(vm, uc_double_new(is_sub ? -d : d)); + break; + } +} + +static void +uc_vm_insn_bitop(uc_vm *vm, enum insn_type insn) +{ + json_object *r2 = uc_vm_stack_pop(vm); + json_object *r1 = uc_vm_stack_pop(vm); + json_object *rv; + + rv = uc_vm_value_bitop(vm, insn, r1, r2); + + uc_value_put(r1); + uc_value_put(r2); + + uc_vm_stack_push(vm, rv); +} + +static void +uc_vm_insn_complement(uc_vm *vm, enum insn_type insn) +{ + struct json_object *v = uc_vm_stack_pop(vm); + int64_t n; + double d; + + if (uc_cast_number(v, &n, &d) == json_type_double) + n = isnan(d) ? 0 : (int64_t)d; + + json_object_put(v); + + uc_vm_stack_push(vm, xjs_new_int64(~n)); +} + +static void +uc_vm_insn_rel(uc_vm *vm, enum insn_type insn) +{ + json_object *r2 = uc_vm_stack_pop(vm); + json_object *r1 = uc_vm_stack_pop(vm); + bool res = false; + + switch (insn) { + case I_LT: + res = uc_cmp(TK_LT, r1, r2); + break; + + case I_GT: + res = uc_cmp(TK_GT, r1, r2); + break; + + case I_EQ: + res = uc_cmp(TK_EQ, r1, r2); + break; + + case I_NE: + res = uc_cmp(TK_NE, r1, r2); + break; + + default: + break; + } + + uc_value_put(r1); + uc_value_put(r2); + + uc_vm_stack_push(vm, xjs_new_boolean(res)); +} + +static void +uc_vm_insn_in(uc_vm *vm, enum insn_type insn) +{ + json_object *r2 = uc_vm_stack_pop(vm); + json_object *r1 = uc_vm_stack_pop(vm); + json_object *item; + size_t arrlen, arridx; + bool found = false; + const char *key; + + switch (json_object_get_type(r2)) { + case json_type_array: + for (arridx = 0, arrlen = json_object_array_length(r2); + arridx < arrlen; arridx++) { + item = json_object_array_get_idx(r2, arridx); + + if (uc_cmp(TK_EQ, r1, item)) { + found = true; + break; + } + } + + break; + + case json_type_object: + key = r1 ? json_object_get_string(r1) : "null"; + found = json_object_object_get_ex(r2, key, NULL); + break; + + default: + found = false; + } + + uc_value_put(r1); + uc_value_put(r2); + + uc_vm_stack_push(vm, xjs_new_boolean(found)); +} + +static void +uc_vm_insn_equality(uc_vm *vm, enum insn_type insn) +{ + json_object *r2 = uc_vm_stack_pop(vm); + json_object *r1 = uc_vm_stack_pop(vm); + bool equal = uc_eq(r1, r2); + + uc_value_put(r1); + uc_value_put(r2); + + uc_vm_stack_push(vm, xjs_new_boolean((insn == I_EQS) ? equal : !equal)); +} + +static void +uc_vm_insn_not(uc_vm *vm, enum insn_type insn) +{ + json_object *r1 = uc_vm_stack_pop(vm); + + uc_vm_stack_push(vm, xjs_new_boolean(!uc_val_is_truish(r1))); + uc_value_put(r1); +} + +static void +uc_vm_insn_jmp(uc_vm *vm, enum insn_type insn) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + uc_chunk *chunk = uc_vm_frame_chunk(frame); + int32_t addr = vm->arg.s32; + + /* ip already has been incremented */ + addr -= 5; + + if (frame->ip + addr < chunk->entries || + frame->ip + addr >= chunk->entries + chunk->count) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "jump target out of range"); + return; + } + + frame->ip += addr; +} + +static void +uc_vm_insn_jmpz(uc_vm *vm, enum insn_type insn) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + uc_chunk *chunk = uc_vm_frame_chunk(frame); + json_object *v = uc_vm_stack_pop(vm); + int32_t addr = vm->arg.s32; + + /* ip already has been incremented */ + addr -= 5; + + if (frame->ip + addr < chunk->entries || + frame->ip + addr >= chunk->entries + chunk->count) { + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "jump target out of range"); + return; + } + + if (!uc_val_is_truish(v)) + frame->ip += addr; + + uc_value_put(v); +} + +static void +uc_vm_insn_next(uc_vm *vm, enum insn_type insn) +{ + json_object *k = uc_vm_stack_pop(vm); + json_object *v = uc_vm_stack_pop(vm); + struct lh_entry *curr; + int64_t n; + + switch (json_object_get_type(v)) { + case json_type_object: + curr = k ? json_object_get_userdata(k) : json_object_get_object(v)->head; + + if (curr) { + if (!k) + k = xjs_new_string("[key]"); + + json_object_set_userdata(k, curr->next, NULL); + + uc_vm_stack_push(vm, xjs_new_string(curr->k)); + + if (insn == I_NEXTKV) + uc_vm_stack_push(vm, uc_value_get((json_object *)curr->v)); + + uc_vm_stack_push(vm, k); + + return; + } + + break; + + case json_type_array: + if (!k) + k = xjs_new_int64(0); + + n = json_object_get_int64(k); + + if (json_object_is_type(k, json_type_int) && n < json_object_array_length(v)) { + json_object_int_inc(k, 1); + + if (insn == I_NEXTKV) + uc_vm_stack_push(vm, xjs_new_int64(n)); + + uc_vm_stack_push(vm, uc_value_get(json_object_array_get_idx(v, n))); + + uc_vm_stack_push(vm, k); + + return; + } + + break; + + default: + break; + } + + uc_vm_stack_push(vm, NULL); + uc_vm_stack_push(vm, NULL); + + if (insn == I_NEXTKV) + uc_vm_stack_push(vm, NULL); +} + +static void +uc_vm_insn_close_upval(uc_vm *vm, enum insn_type insn) +{ + uc_vm_close_upvals(vm, vm->stack.count - 1); + uc_value_put(uc_vm_stack_pop(vm)); +} + +static void +uc_vm_insn_call(uc_vm *vm, enum insn_type insn) +{ + json_object *fno = uc_value_get(uc_vm_stack_peek(vm, vm->arg.u32 & 0xffff)); + json_object *ctx = NULL; + + if (!uc_object_is_type(fno, UC_OBJ_CLOSURE) || !uc_object_as_closure(fno)->is_arrow) + ctx = NULL; + else if (vm->callframes.count > 0) + ctx = uc_value_get(uc_vm_current_frame(vm)->ctx); + + uc_vm_call_function(vm, ctx, fno, false, vm->arg.u32); +} + +static void +uc_vm_insn_mcall(uc_vm *vm, enum insn_type insn) +{ + size_t key_slot = vm->stack.count - (vm->arg.u32 & 0xffff) - 1; + json_object *ctx = vm->stack.entries[key_slot - 1]; + json_object *key = vm->stack.entries[key_slot]; + json_object *fno = uc_getval(ctx, key); + + uc_vm_stack_set(vm, key_slot, fno); + + /* arrow functions as method calls inherit the parent ctx */ + if (uc_object_is_type(fno, UC_OBJ_CLOSURE) && uc_object_as_closure(fno)->is_arrow) + ctx = uc_vm_current_frame(vm)->ctx; + + uc_vm_call_function(vm, uc_value_get(ctx), uc_value_get(fno), true, vm->arg.u32); +} + +static void +uc_vm_insn_print(uc_vm *vm, enum insn_type insn) +{ + json_object *v = uc_vm_stack_pop(vm); + const char *p; + size_t len; + + switch (json_object_get_type(v)) { + case json_type_object: + case json_type_array: + p = json_object_to_json_string_ext(v, JSON_C_TO_STRING_NOSLASHESCAPE|JSON_C_TO_STRING_SPACED); + len = strlen(p); + break; + + case json_type_string: + p = json_object_get_string(v); + len = json_object_get_string_len(v); + break; + + case json_type_null: + p = ""; + len = 0; + break; + + default: + p = json_object_get_string(v); + len = strlen(p); + } + + fwrite(p, 1, len, stdout); + + uc_value_put(v); +} + +static json_object * +uc_vm_callframe_pop(uc_vm *vm) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + json_object *retval; + + /* close upvalues */ + uc_vm_close_upvals(vm, frame->stackframe); + + if (vm->stack.count > frame->stackframe) + retval = uc_vm_stack_pop(vm); + else + retval = NULL; + + /* reset function stack frame */ + while (vm->stack.count > frame->stackframe) + uc_value_put(uc_vm_stack_pop(vm)); + + /* for method calls, release context as well */ + if (frame->mcall) + uc_value_put(uc_vm_stack_pop(vm)); + + /* release function */ + uc_value_put(frame->closure ? frame->closure->header.jso : NULL); + uc_value_put(frame->cfunction ? frame->cfunction->header.jso : NULL); + + /* release context */ + uc_value_put(frame->ctx); + + vm->callframes.count--; + + return retval; +} + +static void +uc_vm_output_exception(uc_vm *vm) +{ + if (vm->exception.type == EXCEPTION_USER) + fprintf(stderr, "%s\n", vm->exception.message); + else + fprintf(stderr, "%s: %s\n", + exception_type_strings[vm->exception.type] ? exception_type_strings[vm->exception.type] : "Error", + vm->exception.message); + + fprintf(stderr, "%s\n\n", + json_object_get_string( + json_object_object_get( + json_object_array_get_idx(vm->exception.stacktrace, 0), "context"))); +} + +static uc_vm_status_t +uc_vm_execute_chunk(uc_vm *vm) +{ + uc_callframe *frame = uc_vm_current_frame(vm); + uc_chunk *chunk = uc_vm_frame_chunk(frame); + json_object *retval; + enum insn_type insn; + + while (chunk) { + if (vm->trace) + uc_dump_insn(vm, frame->ip, (insn = uc_vm_decode_insn(vm, frame, chunk))); + else + insn = uc_vm_decode_insn(vm, frame, chunk); + + switch (insn) { + case I_LOAD: + case I_LOAD8: + case I_LOAD16: + case I_LOAD32: + uc_vm_insn_load(vm, insn); + break; + + case I_LREXP: + uc_vm_insn_load_regexp(vm, insn); + break; + + case I_LNULL: + uc_vm_insn_load_null(vm, insn); + break; + + case I_LTRUE: + case I_LFALSE: + uc_vm_insn_load_bool(vm, insn); + break; + + case I_LTHIS: + uc_vm_stack_push(vm, uc_value_get(frame->ctx)); + break; + + case I_LVAR: + uc_vm_insn_load_var(vm, insn); + break; + + case I_LVAL: + uc_vm_insn_load_val(vm, insn); + break; + + case I_LUPV: + uc_vm_insn_load_upval(vm, insn); + break; + + case I_LLOC: + uc_vm_insn_load_local(vm, insn); + break; + + case I_CLFN: + case I_ARFN: + uc_vm_insn_load_closure(vm, insn); + break; + + case I_NARR: + uc_vm_insn_narr(vm, insn); + break; + + case I_PARR: + uc_vm_insn_parr(vm, insn); + break; + + case I_MARR: + uc_vm_insn_marr(vm, insn); + break; + + case I_NOBJ: + uc_vm_insn_nobj(vm, insn); + break; + + case I_SOBJ: + uc_vm_insn_sobj(vm, insn); + break; + + case I_MOBJ: + uc_vm_insn_mobj(vm, insn); + break; + + case I_SVAR: + uc_vm_insn_store_var(vm, insn); + break; + + case I_SVAL: + uc_vm_insn_store_val(vm, insn); + break; + + case I_SUPV: + uc_vm_insn_store_upval(vm, insn); + break; + + case I_SLOC: + uc_vm_insn_store_local(vm, insn); + break; + + case I_UVAR: + uc_vm_insn_update_var(vm, insn); + break; + + case I_UVAL: + uc_vm_insn_update_val(vm, insn); + break; + + case I_UUPV: + uc_vm_insn_update_upval(vm, insn); + break; + + case I_ULOC: + uc_vm_insn_update_local(vm, insn); + break; + + case I_ADD: + case I_SUB: + case I_MUL: + case I_DIV: + case I_MOD: + uc_vm_insn_arith(vm, insn); + break; + + case I_PLUS: + case I_MINUS: + uc_vm_insn_plus_minus(vm, insn); + break; + + case I_LSHIFT: + case I_RSHIFT: + case I_BAND: + case I_BXOR: + case I_BOR: + uc_vm_insn_bitop(vm, insn); + break; + + case I_COMPL: + uc_vm_insn_complement(vm, insn); + break; + + case I_EQS: + case I_NES: + uc_vm_insn_equality(vm, insn); + break; + + case I_EQ: + case I_NE: + case I_LT: + case I_GT: + uc_vm_insn_rel(vm, insn); + break; + + case I_IN: + uc_vm_insn_in(vm, insn); + break; + + case I_NOT: + uc_vm_insn_not(vm, insn); + break; + + case I_JMP: + uc_vm_insn_jmp(vm, insn); + break; + + case I_JMPZ: + uc_vm_insn_jmpz(vm, insn); + break; + + case I_NEXTK: + case I_NEXTKV: + uc_vm_insn_next(vm, insn); + break; + + case I_COPY: + uc_vm_stack_push(vm, uc_value_get(uc_vm_stack_peek(vm, vm->arg.u8))); + break; + + case I_POP: + uc_value_put(uc_vm_stack_pop(vm)); + break; + + case I_CUPV: + uc_vm_insn_close_upval(vm, insn); + break; + + case I_CALL: + uc_vm_insn_call(vm, insn); + frame = uc_vm_current_frame(vm); + chunk = frame->closure ? uc_vm_frame_chunk(frame) : NULL; + break; + + case I_MCALL: + uc_vm_insn_mcall(vm, insn); + frame = uc_vm_current_frame(vm); + chunk = frame->closure ? uc_vm_frame_chunk(frame) : NULL; + break; + + case I_RETURN: + retval = uc_vm_callframe_pop(vm); + + if (vm->callframes.count == 0) { + uc_value_put(retval); + + return STATUS_OK; + } + + uc_vm_stack_push(vm, retval); + + frame = uc_vector_last(&vm->callframes); + chunk = uc_vm_frame_chunk(frame); + break; + + case I_PRINT: + uc_vm_insn_print(vm, insn); + break; + + default: + uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "unknown opcode %d", insn); + break; + } + + /* previous instruction raised exception */ + if (vm->exception.type != EXCEPTION_NONE) { + /* walk up callframes until something handles the exception or the root is reached */ + while (!uc_vm_handle_exception(vm)) { + /* no further callframe to pop, report unhandled exception and terminate */ + if (vm->callframes.count == 1) { + uc_vm_output_exception(vm); + + return ERROR_RUNTIME; + } + + /* if VM returned into native function, don't bubble up */ + if (!chunk) + return ERROR_RUNTIME; + + /* no exception handler in current function, pop callframe */ + uc_value_put(uc_vm_callframe_pop(vm)); + + /* resume execution at topmost remaining callframe */ + frame = uc_vector_last(&vm->callframes); + chunk = uc_vm_frame_chunk(frame); + } + } + } + + return STATUS_OK; +} + +static uc_vm_status_t +uc_vm_preload(uc_vm *vm, json_object *modules) +{ + json_object *requirefn, *module, *name; + uc_exception_type_t ex; + size_t i; + + if (!json_object_is_type(modules, json_type_array)) + return STATUS_OK; + + requirefn = json_object_object_get(vm->globals->header.jso, "require"); + + if (!uc_object_is_type(requirefn, UC_OBJ_CFUNCTION)) + return STATUS_OK; + + for (i = 0; i < json_object_array_length(modules); i++) { + name = json_object_array_get_idx(modules, i); + + uc_vm_stack_push(vm, uc_value_get(requirefn)); + uc_vm_stack_push(vm, uc_value_get(name)); + + ex = uc_vm_call(vm, false, 1); + + if (ex) + return ERROR_RUNTIME; + + module = uc_vm_stack_pop(vm); + + uc_value_put(uc_setval(vm->globals->header.jso, name, module)); + } + + return STATUS_OK; +} + +uc_vm_status_t +uc_vm_execute(uc_vm *vm, uc_function *fn, uc_prototype *globals, json_object *modules) +{ + uc_closure *closure = uc_closure_new(fn, false); + uc_callframe *frame; + uc_vm_status_t rv; + + vm->globals = globals; + + uc_vector_grow(&vm->callframes); + + frame = &vm->callframes.entries[vm->callframes.count++]; + frame->closure = closure; + frame->stackframe = 0; + frame->ip = uc_vm_frame_chunk(frame)->entries; + + if (vm->trace) { + size_t msglen = 0; + char *msg = NULL; + + format_source_context(&msg, &msglen, + fn->source, 0, true); + + fprintf(stderr, "%s", msg); + + uc_vm_frame_dump(vm, frame); + } + + //uc_vm_stack_push(vm, closure->header.jso); + uc_vm_stack_push(vm, NULL); + + rv = uc_vm_preload(vm, modules); + + if (rv != STATUS_OK) + uc_vm_output_exception(vm); + else + rv = uc_vm_execute_chunk(vm); + + uc_value_put(vm->globals->header.jso); + vm->globals = NULL; + + return rv; +} + +uc_exception_type_t +uc_vm_call(uc_vm *vm, bool mcall, size_t nargs) +{ + json_object *ctx = mcall ? uc_value_get(uc_vm_stack_peek(vm, nargs - 1)) : NULL; + json_object *fno = uc_value_get(uc_vm_stack_peek(vm, nargs)); + + if (uc_vm_call_function(vm, ctx, fno, mcall, nargs & 0xffff)) { + if (!uc_object_is_type(fno, UC_OBJ_CFUNCTION)) + uc_vm_execute_chunk(vm); + } + + return vm->exception.type; +} diff --git a/vm.h b/vm.h new file mode 100644 index 0000000..5672cbb --- /dev/null +++ b/vm.h @@ -0,0 +1,177 @@ +/* + * Copyright (C) 2020-2021 Jo-Philipp Wich + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef __VM_H_ +#define __VM_H_ + +#include +#include + +#include "chunk.h" +#include "object.h" +#include "util.h" +#include "lexer.h" + +#define __insns \ +__insn(NOOP) \ +__insn(LOAD) \ +__insn(LOAD8) \ +__insn(LOAD16) \ +__insn(LOAD32) \ +__insn(LTHIS) \ +__insn(LREXP) \ +__insn(LNULL) \ +__insn(LTRUE) \ +__insn(LFALSE) \ +__insn(LLOC) \ +__insn(LUPV) \ +__insn(LVAR) \ +__insn(LVAL) \ +__insn(CLFN) \ +__insn(ARFN) \ +__insn(SLOC) \ +__insn(SUPV) \ +__insn(SVAR) \ +__insn(SVAL) \ +__insn(ULOC) \ +__insn(UUPV) \ +__insn(UVAR) \ +__insn(UVAL) \ +__insn(NARR) \ +__insn(PARR) \ +__insn(MARR) \ +__insn(NOBJ) \ +__insn(SOBJ) \ +__insn(MOBJ) \ +__insn(PLUS) \ +__insn(MINUS) \ +__insn(ADD) \ +__insn(SUB) \ +__insn(MUL) \ +__insn(DIV) \ +__insn(MOD) \ +__insn(LSHIFT) \ +__insn(RSHIFT) \ +__insn(BAND) \ +__insn(BXOR) \ +__insn(BOR) \ +__insn(COMPL) \ +__insn(EQ) \ +__insn(NE) \ +__insn(EQS) \ +__insn(NES) \ +__insn(LT) \ +__insn(GT) \ +__insn(IN) \ +__insn(NOT) \ +__insn(JMP) \ +__insn(JMPZ) \ +__insn(COPY) \ +__insn(POP) \ +__insn(CUPV) \ +__insn(RETURN) \ +__insn(CALL) \ +__insn(MCALL) \ +__insn(PRINT) \ +__insn(NEXTK) \ +__insn(NEXTKV) + + +#undef __insn +#define __insn(_name) I_##_name, + +enum insn_type { + __insns + __I_MAX +}; + +typedef struct { + int8_t stack_pop; + int8_t stack_push; + int8_t operand_bytes; + bool operand_is_skip; +} uc_insn_definition; + +typedef enum { + EXCEPTION_NONE, + EXCEPTION_SYNTAX, + EXCEPTION_RUNTIME, + EXCEPTION_TYPE, + EXCEPTION_REFERENCE, + EXCEPTION_USER +} uc_exception_type_t; + +typedef struct { + uc_exception_type_t type; + json_object *stacktrace; + char *message; +} uc_exception; + +typedef struct { + uint8_t *ip; + uc_closure *closure; + uc_cfunction *cfunction; + size_t stackframe; + json_object *ctx; + bool mcall; +} uc_callframe; + +uc_declare_vector(uc_callframes, uc_callframe); +uc_declare_vector(uc_stack, json_object *); + +typedef struct uc_vm { + uc_stack stack; + uc_exception exception; + uc_callframes callframes; + uc_upvalref *open_upvals; + uc_parse_config *config; + uc_prototype *globals; + uc_source *sources; + union { + uint32_t u32; + int32_t s32; + uint16_t u16; + int16_t s16; + uint8_t u8; + int8_t s8; + } arg; + size_t spread_values; + uint8_t trace; +} uc_vm; + +typedef enum { + STATUS_OK, + ERROR_COMPILE, + ERROR_RUNTIME +} uc_vm_status_t; + +extern uint32_t insns[__I_MAX]; + +void uc_vm_init(uc_vm *vm, uc_parse_config *config); +void uc_vm_free(uc_vm *vm); + +void uc_vm_stack_push(uc_vm *vm, json_object *value); +json_object *uc_vm_stack_pop(uc_vm *vm); +json_object *uc_vm_stack_peek(uc_vm *vm, size_t offset); + +uc_exception_type_t uc_vm_call(uc_vm *vm, bool mcall, size_t nargs); + +void __attribute__((format(printf, 3, 0))) +uc_vm_raise_exception(uc_vm *vm, uc_exception_type_t type, const char *fmt, ...); + +uc_vm_status_t uc_vm_execute(uc_vm *vm, uc_function *fn, uc_prototype *globals, json_object *modules); + +#endif /* __VM_H_ */ -- cgit v1.2.3