remove explicit call syntax
This commit is contained in:
parent
a9d744d278
commit
20cbcf7963
518
compile.phi
518
compile.phi
@ -2,10 +2,10 @@
|
||||
(fn Emitter (ast filename) (do
|
||||
(let output (list))
|
||||
|
||||
(let (enter_scope leave_scope define_sym get_sym print_syms) (call Syms))
|
||||
(let (enter_scope leave_scope define_sym get_sym print_syms) (Syms))
|
||||
|
||||
(let (let_node_reg_count let_node_reg_increment) (call Counter))
|
||||
(let (sym_id_count sym_id_increment) (call Counter))
|
||||
(let (let_node_reg_count let_node_reg_increment) (Counter))
|
||||
(let (sym_id_count sym_id_increment) (Counter))
|
||||
|
||||
(let builtin_syms (list
|
||||
(list "format" "builtinFormat")
|
||||
@ -25,25 +25,25 @@
|
||||
))
|
||||
|
||||
(fn generate () (do
|
||||
(call emit "#!/usr/bin/env node\n")
|
||||
(call emit "import { Runtime } from \"./runtime.js\";\n")
|
||||
(call emit "const runtime = new Runtime({ filename: \"")
|
||||
(call emit filename)
|
||||
(call emit "\" });\n")
|
||||
(emit "#!/usr/bin/env node\n")
|
||||
(emit "import { Runtime } from \"./runtime.js\";\n")
|
||||
(emit "const runtime = new Runtime({ filename: \"")
|
||||
(emit filename)
|
||||
(emit "\" });\n")
|
||||
|
||||
(for (ident builtin_id) builtin_syms (do
|
||||
(call define_builtin ident builtin_id)
|
||||
(define_builtin ident builtin_id)
|
||||
))
|
||||
|
||||
(call discover_syms ast)
|
||||
(call emit_exprs ast)
|
||||
(return (call strings_join output))
|
||||
(discover_syms ast)
|
||||
(emit_exprs ast)
|
||||
(return (strings_join output))
|
||||
))
|
||||
|
||||
(fn emit_exprs (exprs) (do
|
||||
(for expr exprs (do
|
||||
(call emit_expr expr)
|
||||
(call emit ";\n")
|
||||
(emit_expr expr)
|
||||
(emit ";\n")
|
||||
))
|
||||
))
|
||||
|
||||
@ -52,11 +52,11 @@
|
||||
(let (ty line) expr)
|
||||
(if (!= ty "list") (return))
|
||||
(let (_ _ s) expr)
|
||||
(if (== (call len s) 0) (return))
|
||||
(if (== (len s) 0) (return))
|
||||
(let ((_ _ id)) s)
|
||||
(if (== id "fn") (do
|
||||
(let (_ (_ _ ident) (_ _ params) body) s)
|
||||
(call define_fn ident line)
|
||||
(define_fn ident line)
|
||||
))
|
||||
))
|
||||
))
|
||||
@ -64,247 +64,247 @@
|
||||
(fn emit_expr (expr) (do
|
||||
(let (ty line) expr)
|
||||
(if (== ty "list") (do
|
||||
(call emit_list expr)
|
||||
(emit_list expr)
|
||||
) (if (== ty "int") (do
|
||||
(let (_ _ value) expr)
|
||||
(call emit (call format "({ type: \"int\", value: % })" value))
|
||||
(emit (format "({ type: \"int\", value: % })" value))
|
||||
) (if (== ty "string") (do
|
||||
(let (_ _ value) expr)
|
||||
(call emit (call format "({ type: \"string\", value: \"%\" })" (call string_escape value)))
|
||||
(emit (format "({ type: \"string\", value: \"%\" })" (string_escape value)))
|
||||
) (if (== ty "ident") (do
|
||||
(let (_ _ value) expr)
|
||||
|
||||
(if (== value "null") (do
|
||||
(call emit "({ type: \"null\" })")
|
||||
(emit "({ type: \"null\" })")
|
||||
(return)
|
||||
) (if (== value "false") (do
|
||||
(call emit "({ type: \"bool\", value: false })")
|
||||
(emit "({ type: \"bool\", value: false })")
|
||||
(return)
|
||||
) (if (== value "true") (do
|
||||
(call emit "({ type: \"bool\", value: true })")
|
||||
(emit "({ type: \"bool\", value: true })")
|
||||
(return)
|
||||
))))
|
||||
|
||||
(let sym (call get_sym value))
|
||||
(let sym (get_sym value))
|
||||
(if (== sym null) (do
|
||||
(call panic "undefined symbol '%' on line %" value line)
|
||||
(panic "undefined symbol '%' on line %" value line)
|
||||
))
|
||||
|
||||
(let (sym_id sym_ty) sym)
|
||||
(if (== sym_ty "builtin") (do
|
||||
(let (_ _ id) sym)
|
||||
(call emit (call format "((...args) => runtime.%(...args))" id))
|
||||
(emit (format "((...args) => runtime.%(...args))" id))
|
||||
) (if (== sym_ty "fn") (do
|
||||
(call emit (call format "_%%" value sym_id))
|
||||
(emit (format "_%%" value sym_id))
|
||||
) (if (== sym_ty "param") (do
|
||||
(call emit (call format "_%%" value sym_id))
|
||||
(emit (format "_%%" value sym_id))
|
||||
) (if (== sym_ty "let") (do
|
||||
(call emit (call format "_%%" value sym_id))
|
||||
(emit (format "_%%" value sym_id))
|
||||
) (do
|
||||
(call panic "not implemented '%'" sym_ty)
|
||||
(panic "not implemented '%'" sym_ty)
|
||||
)))))
|
||||
) (do
|
||||
(call panic "unknown expr type '%' on line %" ty line)
|
||||
(panic "unknown expr type '%' on line %" ty line)
|
||||
)))))
|
||||
))
|
||||
|
||||
(fn emit_list (expr) (do
|
||||
(let (ty line s) expr)
|
||||
(if (== (call len s) 0) (do
|
||||
(call panic "illegal function call on line %" line)
|
||||
(if (== (len s) 0) (do
|
||||
(panic "illegal function on line %" line)
|
||||
))
|
||||
(let ((id_ty _ id)) s)
|
||||
(if (!= id_ty "ident") (do
|
||||
(call panic "illegal function call on line %" line)
|
||||
(panic "illegal function on line %" line)
|
||||
))
|
||||
(if (== id "fn") (do
|
||||
(let (_ (_ _ ident) (_ _ params) body) s)
|
||||
|
||||
(let sym (call get_sym ident))
|
||||
(let sym (get_sym ident))
|
||||
(let (sym_id) sym)
|
||||
|
||||
(call emit (call format "function _%%(" ident sym_id))
|
||||
(emit (format "function _%%(" ident sym_id))
|
||||
|
||||
(call enter_scope)
|
||||
(enter_scope)
|
||||
|
||||
(let first true)
|
||||
(for (_ _ ident) params (do
|
||||
(if (not first) (do
|
||||
(call emit ", ")
|
||||
(emit ", ")
|
||||
))
|
||||
(= first false)
|
||||
|
||||
(let sym_id (call define_param ident line))
|
||||
(call emit (call format "_%%" ident sym_id))
|
||||
(let sym_id (define_param ident line))
|
||||
(emit (format "_%%" ident sym_id))
|
||||
))
|
||||
|
||||
|
||||
(call emit ") {\n")
|
||||
(call emit (call format "runtime.pushCall(\"%\");\n" ident))
|
||||
(emit ") {\n")
|
||||
(emit (format "runtime.pushCall(\"%\");\n" ident))
|
||||
|
||||
(call emit_expr body)
|
||||
(call emit ";\nruntime.popCall();\nreturn { type: \"null\" };\n}")
|
||||
(emit_expr body)
|
||||
(emit ";\nruntime.popCall();\nreturn { type: \"null\" };\n}")
|
||||
|
||||
(call leave_scope)
|
||||
(leave_scope)
|
||||
) (if (== id "let") (do
|
||||
(let (_ pat expr) s)
|
||||
(let reg (call let_node_reg_count))
|
||||
(call let_node_reg_increment)
|
||||
(call emit (call format "const r_% = " reg))
|
||||
(call emit_expr expr)
|
||||
(call emit_let_node pat reg)
|
||||
(let reg (let_node_reg_count))
|
||||
(let_node_reg_increment)
|
||||
(emit (format "const r_% = " reg))
|
||||
(emit_expr expr)
|
||||
(emit_let_node pat reg)
|
||||
) (if (== id "do") (do
|
||||
(call enter_scope)
|
||||
(call discover_syms (call slice s 1))
|
||||
(call emit_exprs (call slice s 1))
|
||||
(call leave_scope)
|
||||
(enter_scope)
|
||||
(discover_syms (slice s 1))
|
||||
(emit_exprs (slice s 1))
|
||||
(leave_scope)
|
||||
) (if (== id "for") (do
|
||||
(let (_ pat expr body) s)
|
||||
|
||||
(let reg (call let_node_reg_count))
|
||||
(call let_node_reg_increment)
|
||||
(call emit (call format "for (const r_% of " reg))
|
||||
(call emit_expr expr)
|
||||
(call emit ".values) {")
|
||||
(let reg (let_node_reg_count))
|
||||
(let_node_reg_increment)
|
||||
(emit (format "for (const r_% of " reg))
|
||||
(emit_expr expr)
|
||||
(emit ".values) {")
|
||||
|
||||
(call enter_scope)
|
||||
(call emit_let_node pat reg)
|
||||
(call enter_scope)
|
||||
(enter_scope)
|
||||
(emit_let_node pat reg)
|
||||
(enter_scope)
|
||||
|
||||
(call emit ";\n")
|
||||
(call emit_expr body)
|
||||
(call emit "}")
|
||||
(emit ";\n")
|
||||
(emit_expr body)
|
||||
(emit "}")
|
||||
|
||||
(call leave_scope)
|
||||
(call leave_scope)
|
||||
(leave_scope)
|
||||
(leave_scope)
|
||||
) (if (== id "loop") (do
|
||||
(let (_ body) s)
|
||||
(call emit "while (true) {\n")
|
||||
(call emit_expr body)
|
||||
(call emit "}")
|
||||
(emit "while (true) {\n")
|
||||
(emit_expr body)
|
||||
(emit "}")
|
||||
) (if (== id "if") (do
|
||||
(let (_ cond truthy falsy) s)
|
||||
(call emit "if (runtime.truthy(")
|
||||
(call emit_expr cond)
|
||||
(call emit ")) {\n")
|
||||
(call emit_expr truthy)
|
||||
(call emit "}")
|
||||
(emit "if (runtime.truthy(")
|
||||
(emit_expr cond)
|
||||
(emit ")) {\n")
|
||||
(emit_expr truthy)
|
||||
(emit "}")
|
||||
(if (!= falsy null) (do
|
||||
(call emit " else {\n")
|
||||
(call emit_expr falsy)
|
||||
(call emit "}")
|
||||
(emit " else {\n")
|
||||
(emit_expr falsy)
|
||||
(emit "}")
|
||||
))
|
||||
) (if (== id "return") (do
|
||||
(let (_ value) s)
|
||||
(call emit "runtime.popCall();\n")
|
||||
(call emit "return ")
|
||||
(emit "runtime.popCall();\n")
|
||||
(emit "return ")
|
||||
(if (!= value null) (do
|
||||
(call emit_expr value)
|
||||
(emit_expr value)
|
||||
) (do
|
||||
(call emit "{ type: \"null\" }")
|
||||
(emit "{ type: \"null\" }")
|
||||
))
|
||||
) (if (== id "break") (do
|
||||
(let (_ value) s)
|
||||
(call emit "break")
|
||||
(emit "break")
|
||||
(if (!= value null) (do
|
||||
(call panic "not implemented")
|
||||
(panic "not implemented")
|
||||
))
|
||||
) (if (== id "call") (do
|
||||
(let (_ callee) s)
|
||||
(let args (call slice s 2))
|
||||
(call emit (call format "(runtime.setLine(%), " line))
|
||||
(call emit_expr callee)
|
||||
(call emit "(")
|
||||
(let args (slice s 2))
|
||||
(emit (format "(runtime.setLine(%), " line))
|
||||
(emit_expr callee)
|
||||
(emit "(")
|
||||
|
||||
(let first true)
|
||||
(for arg args (do
|
||||
(if (not first) (do
|
||||
(call emit ", ")
|
||||
(emit ", ")
|
||||
))
|
||||
(= first false)
|
||||
|
||||
(call emit_expr arg)
|
||||
(emit_expr arg)
|
||||
))
|
||||
|
||||
(call emit "))")
|
||||
(emit "))")
|
||||
) (if (== id "list") (do
|
||||
(call emit_list_literal (call slice s 1))
|
||||
(emit_list_literal (slice s 1))
|
||||
) (if (== id "=") (do
|
||||
(call emit_assign_expr s line "=")
|
||||
(emit_assign_expr s line "=")
|
||||
) (if (== id "+=") (do
|
||||
(call emit_assign_expr s line "+")
|
||||
(emit_assign_expr s line "+")
|
||||
) (if (== id "-=") (do
|
||||
(call emit_assign_expr s line "-")
|
||||
(emit_assign_expr s line "-")
|
||||
) (if (== id "or") (do
|
||||
(let (_ left right) s)
|
||||
(call emit (call format "(runtime.setLine(%)" line))
|
||||
(call emit ", { type: \"bool\", value: runtime.truthy(")
|
||||
(call emit_expr left)
|
||||
(call emit ") || runtime.truthy(")
|
||||
(call emit_expr right)
|
||||
(call emit ") })")
|
||||
(emit (format "(runtime.setLine(%)" line))
|
||||
(emit ", { type: \"bool\", value: runtime.truthy(")
|
||||
(emit_expr left)
|
||||
(emit ") || runtime.truthy(")
|
||||
(emit_expr right)
|
||||
(emit ") })")
|
||||
) (if (== id "and") (do
|
||||
(let (_ left right) s)
|
||||
(call emit (call format "(runtime.setLine(%)" line))
|
||||
(call emit ", { type: \"bool\", value: runtime.truthy(")
|
||||
(call emit_expr left)
|
||||
(call emit ") && runtime.truthy(")
|
||||
(call emit_expr right)
|
||||
(call emit ") })")
|
||||
(emit (format "(runtime.setLine(%)" line))
|
||||
(emit ", { type: \"bool\", value: runtime.truthy(")
|
||||
(emit_expr left)
|
||||
(emit ") && runtime.truthy(")
|
||||
(emit_expr right)
|
||||
(emit ") })")
|
||||
) (if (== id "==") (do
|
||||
(call emit_binary_op s "opEq")
|
||||
(emit_binary_op s "opEq")
|
||||
) (if (== id "!=") (do
|
||||
(call emit_binary_op s "opNe")
|
||||
(emit_binary_op s "opNe")
|
||||
) (if (== id "<") (do
|
||||
(call emit_binary_op s "opLt")
|
||||
(emit_binary_op s "opLt")
|
||||
) (if (== id ">") (do
|
||||
(call emit_binary_op s "opGt")
|
||||
(emit_binary_op s "opGt")
|
||||
) (if (== id "<=") (do
|
||||
(call emit_binary_op s "opLte")
|
||||
(emit_binary_op s "opLte")
|
||||
) (if (== id ">=") (do
|
||||
(call emit_binary_op s "opGte")
|
||||
(emit_binary_op s "opGte")
|
||||
) (if (== id "+") (do
|
||||
(call emit_binary_op s "opAdd")
|
||||
(emit_binary_op s "opAdd")
|
||||
) (if (== id "-") (do
|
||||
(call emit_binary_op s "opSub")
|
||||
(emit_binary_op s "opSub")
|
||||
) (if (== id "not") (do
|
||||
(let (_ expr) s)
|
||||
(call emit "runtime.opNot(")
|
||||
(call emit_expr expr)
|
||||
(call emit ")")
|
||||
(emit "runtime.opNot(")
|
||||
(emit_expr expr)
|
||||
(emit ")")
|
||||
) (do
|
||||
(let (callee) s)
|
||||
(let args (call slice s 1))
|
||||
(call emit (call format "(runtime.setLine(%), " line))
|
||||
(call emit_expr callee)
|
||||
(call emit "(")
|
||||
(let args (slice s 1))
|
||||
(emit (format "(runtime.setLine(%), " line))
|
||||
(emit_expr callee)
|
||||
(emit "(")
|
||||
|
||||
(let first true)
|
||||
(for arg args (do
|
||||
(if (not first) (do
|
||||
(call emit ", ")
|
||||
(emit ", ")
|
||||
))
|
||||
(= first false)
|
||||
|
||||
(call emit_expr arg)
|
||||
(emit_expr arg)
|
||||
))
|
||||
|
||||
(call emit "))")
|
||||
(emit "))")
|
||||
)))))))))))))))))))))))))
|
||||
))
|
||||
|
||||
(fn emit_list_literal (s) (do
|
||||
(call emit "({ type: \"list\", values: [")
|
||||
(emit "({ type: \"list\", values: [")
|
||||
(let first true)
|
||||
(for e s (do
|
||||
(if (not first) (do
|
||||
(call emit ", ")
|
||||
(emit ", ")
|
||||
))
|
||||
(= first false)
|
||||
|
||||
(call emit_expr e)
|
||||
(emit_expr e)
|
||||
))
|
||||
(call emit "] })")
|
||||
(emit "] })")
|
||||
))
|
||||
|
||||
(fn emit_let_node (pat base_reg) (do
|
||||
@ -314,117 +314,117 @@
|
||||
|
||||
(if (== ident "_") (return))
|
||||
|
||||
(let sym_id (call define_let ident line))
|
||||
(call emit (call format ";\nlet _%% = r_%" ident sym_id base_reg))
|
||||
(let sym_id (define_let ident line))
|
||||
(emit (format ";\nlet _%% = r_%" ident sym_id base_reg))
|
||||
) (if (== pat_ty "list") (do
|
||||
(let (_ _ pats) pat)
|
||||
|
||||
//(call emit (call format
|
||||
//(emit (format
|
||||
// (+ ";\nif (r_%.type !== \"list\") {\nruntime.setLine(%);"
|
||||
// "\nruntime.panic(\"expected list\");\n}\n")
|
||||
// base_reg
|
||||
// line
|
||||
//))
|
||||
//(call emit (call format
|
||||
//(emit (format
|
||||
// (+ ";\nif (% > r_%.values.length) {\nruntime.setLine(%);\nruntime.panic"
|
||||
// "(`expected % elements, got ${r_%.values.length}`);\n}\n")
|
||||
// (call len pats)
|
||||
// (len pats)
|
||||
// base_reg
|
||||
// line
|
||||
// (call len pats)
|
||||
// (len pats)
|
||||
// base_reg
|
||||
//))
|
||||
|
||||
(let i 0)
|
||||
(for pat pats (do
|
||||
(let reg (call let_node_reg_count))
|
||||
(call let_node_reg_increment)
|
||||
(call emit (call format
|
||||
(let reg (let_node_reg_count))
|
||||
(let_node_reg_increment)
|
||||
(emit (format
|
||||
";\nconst r_% = r_%.values[%] ?? { type: \"null\"}"
|
||||
reg base_reg i
|
||||
))
|
||||
(call emit_let_node pat reg)
|
||||
(emit_let_node pat reg)
|
||||
(+= i 1)
|
||||
))
|
||||
) (do
|
||||
(call panic "malformed pattern on line %" line)
|
||||
(panic "malformed pattern on line %" line)
|
||||
)))
|
||||
))
|
||||
|
||||
(fn emit_binary_op (s id) (do
|
||||
(let (_ left right) s)
|
||||
(call emit (call format "runtime.%(" id))
|
||||
(call emit_expr left)
|
||||
(call emit ", ")
|
||||
(call emit_expr right)
|
||||
(call emit ")")
|
||||
(emit (format "runtime.%(" id))
|
||||
(emit_expr left)
|
||||
(emit ", ")
|
||||
(emit_expr right)
|
||||
(emit ")")
|
||||
))
|
||||
|
||||
(fn emit_assign_expr (s line id) (do
|
||||
(let (_ (target_type) expr) s)
|
||||
(if (!= target_type "ident") (do
|
||||
(call panic "cannot assign to expression on line %" line)
|
||||
(panic "cannot assign to expression on line %" line)
|
||||
))
|
||||
(let (_ (_ _ ident)) s)
|
||||
(let sym (call get_sym ident))
|
||||
(let sym (get_sym ident))
|
||||
(if (== sym null) (do
|
||||
(call panic "could not find symbol '%' on line %" ident line)
|
||||
(panic "could not find symbol '%' on line %" ident line)
|
||||
))
|
||||
(let (sym_id sym_type sym_ident _) sym)
|
||||
(if (== sym_type "let") (do
|
||||
(call emit (call format "(_%% = " sym_ident sym_id))
|
||||
(emit (format "(_%% = " sym_ident sym_id))
|
||||
(if (== id "=") (do
|
||||
(call emit_expr expr)
|
||||
(emit_expr expr)
|
||||
) (if (== id "+") (do
|
||||
(call emit (call format "runtime.opAdd(_%%, " sym_ident sym_id))
|
||||
(call emit_expr expr)
|
||||
(call emit ")")
|
||||
(emit (format "runtime.opAdd(_%%, " sym_ident sym_id))
|
||||
(emit_expr expr)
|
||||
(emit ")")
|
||||
) (if (== id "-") (do
|
||||
(call emit (call format "runtime.opSub(_%%, " sym_ident sym_id))
|
||||
(call emit_expr expr)
|
||||
(call emit ")")
|
||||
(emit (format "runtime.opSub(_%%, " sym_ident sym_id))
|
||||
(emit_expr expr)
|
||||
(emit ")")
|
||||
) (do
|
||||
(call panic "not implemented")
|
||||
(panic "not implemented")
|
||||
))))
|
||||
(call emit ")")
|
||||
(emit ")")
|
||||
) (do
|
||||
(call panic "cannot assign to symbol '%' on line %" sym_ident line)
|
||||
(panic "cannot assign to symbol '%' on line %" sym_ident line)
|
||||
))
|
||||
))
|
||||
|
||||
(fn emit (str) (do
|
||||
(call push output str)
|
||||
(push output str)
|
||||
))
|
||||
|
||||
(fn define_builtin (ident builtin_id) (do
|
||||
(let sym_id (call sym_id_count))
|
||||
(call sym_id_increment)
|
||||
(let sym_id (sym_id_count))
|
||||
(sym_id_increment)
|
||||
|
||||
(call define_sym ident (list sym_id "builtin" builtin_id))
|
||||
(define_sym ident (list sym_id "builtin" builtin_id))
|
||||
(return sym_id)
|
||||
))
|
||||
|
||||
(fn define_fn (ident line) (do
|
||||
(let sym_id (call sym_id_count))
|
||||
(call sym_id_increment)
|
||||
(let sym_id (sym_id_count))
|
||||
(sym_id_increment)
|
||||
|
||||
(call define_sym ident (list sym_id "fn" ident line))
|
||||
(define_sym ident (list sym_id "fn" ident line))
|
||||
(return sym_id)
|
||||
))
|
||||
|
||||
(fn define_param (ident line) (do
|
||||
(let sym_id (call sym_id_count))
|
||||
(call sym_id_increment)
|
||||
(let sym_id (sym_id_count))
|
||||
(sym_id_increment)
|
||||
|
||||
(call define_sym ident (list sym_id "param" ident line))
|
||||
(define_sym ident (list sym_id "param" ident line))
|
||||
(return sym_id)
|
||||
))
|
||||
|
||||
(fn define_let (ident line) (do
|
||||
(let sym_id (call sym_id_count))
|
||||
(call sym_id_increment)
|
||||
(let sym_id (sym_id_count))
|
||||
(sym_id_increment)
|
||||
|
||||
(call define_sym ident (list sym_id "let" ident line))
|
||||
(define_sym ident (list sym_id "let" ident line))
|
||||
(return sym_id)
|
||||
))
|
||||
|
||||
@ -461,50 +461,50 @@
|
||||
(let (_ map) syms)
|
||||
(let i 0)
|
||||
(loop (do
|
||||
(if (>= i (call len map)) (break))
|
||||
(let (s_ident _) (call at map i))
|
||||
(if (>= i (len map)) (break))
|
||||
(let (s_ident _) (at map i))
|
||||
(if (== ident s_ident) (do
|
||||
(call set map i (list ident sym))
|
||||
(set map i (list ident sym))
|
||||
(return)
|
||||
))
|
||||
(+= i 1)
|
||||
))
|
||||
(call push map (list ident sym))
|
||||
(push map (list ident sym))
|
||||
))
|
||||
|
||||
(fn find_sym (syms ident) (do
|
||||
(let (parent map) syms)
|
||||
(let i 0)
|
||||
(loop (do
|
||||
(if (>= i (call len map)) (break))
|
||||
(let (s_ident s_sym) (call at map i))
|
||||
(if (>= i (len map)) (break))
|
||||
(let (s_ident s_sym) (at map i))
|
||||
(if (== ident s_ident) (do
|
||||
(return s_sym)
|
||||
))
|
||||
(+= i 1)
|
||||
))
|
||||
(if (!= parent null) (do
|
||||
(return (call find_sym parent ident))
|
||||
(return (find_sym parent ident))
|
||||
))
|
||||
(return null)
|
||||
))
|
||||
|
||||
(fn get (ident) (do
|
||||
(return (call find_sym syms ident))
|
||||
(return (find_sym syms ident))
|
||||
))
|
||||
|
||||
(fn print_syms_node (syms depth) (do
|
||||
(let (parent map) syms)
|
||||
(for (ident sym) map (do
|
||||
(call println "%- %: %" (call indent depth) ident sym)
|
||||
(println "%- %: %" (indent depth) ident sym)
|
||||
))
|
||||
(if (!= parent null) (do
|
||||
(call print_syms_node parent (+ depth 1))
|
||||
(print_syms_node parent (+ depth 1))
|
||||
))
|
||||
))
|
||||
|
||||
(fn print_syms () (do
|
||||
(call print_syms_node syms 0)
|
||||
(print_syms_node syms 0)
|
||||
))
|
||||
|
||||
(return (list
|
||||
@ -518,12 +518,12 @@
|
||||
|
||||
|
||||
(fn string_escape (str) (do
|
||||
(let str_len (call len str))
|
||||
(let str_len (len str))
|
||||
(let i 0)
|
||||
(let result "")
|
||||
(loop (do
|
||||
(if (>= i str_len) (break))
|
||||
(let ch (call at str i))
|
||||
(let ch (at str i))
|
||||
(if (== ch "\\") (do
|
||||
(+= result "\\\\")
|
||||
) (if (== ch "\"") (do
|
||||
@ -546,69 +546,69 @@
|
||||
|
||||
(fn Parser (tokens) (do
|
||||
(let i 0)
|
||||
(let tok (call at tokens i))
|
||||
(let tok (at tokens i))
|
||||
|
||||
(fn parse () (do
|
||||
(let exprs (list))
|
||||
(loop (do
|
||||
(if (call done) (break))
|
||||
(call push exprs (call parse_expr))
|
||||
(if (done) (break))
|
||||
(push exprs (parse_expr))
|
||||
))
|
||||
(return exprs)
|
||||
))
|
||||
|
||||
(fn parse_expr () (do
|
||||
(let (ty line value) tok)
|
||||
(if (call eat "(") (do
|
||||
(if (eat "(") (do
|
||||
(let values (list))
|
||||
(loop (do
|
||||
(if (call test ")") (break))
|
||||
(call push values (call parse_expr))
|
||||
(if (test ")") (break))
|
||||
(push values (parse_expr))
|
||||
))
|
||||
(if (not (call eat ")")) (do
|
||||
(call panic "expected ')' on line %" (call at tok 1))
|
||||
(if (not (eat ")")) (do
|
||||
(panic "expected ')' on line %" (at tok 1))
|
||||
))
|
||||
(return (list "list" line values))
|
||||
) (if (call eat "string") (do
|
||||
) (if (eat "string") (do
|
||||
(return (list "string" line value))
|
||||
) (if (call eat "int") (do
|
||||
(return (list "int" line (call string_to_int value)))
|
||||
) (if (call eat "ident") (do
|
||||
) (if (eat "int") (do
|
||||
(return (list "int" line (string_to_int value)))
|
||||
) (if (eat "ident") (do
|
||||
(return (list "ident" line value))
|
||||
) (do
|
||||
(call panic "expected expression, got '%' on line %" ty line)
|
||||
(panic "expected expression, got '%' on line %" ty line)
|
||||
)))))
|
||||
))
|
||||
|
||||
(fn eat (pat) (do
|
||||
(if (not (call test pat)) (return false))
|
||||
(call step)
|
||||
(if (not (test pat)) (return false))
|
||||
(step)
|
||||
(return true)
|
||||
))
|
||||
|
||||
(fn step () (do
|
||||
(+= i 1)
|
||||
(if (not (call done)) (do
|
||||
(let new_tok (call at tokens i))
|
||||
(if (not (done)) (do
|
||||
(let new_tok (at tokens i))
|
||||
(= tok new_tok)
|
||||
))
|
||||
))
|
||||
|
||||
(fn test (pat) (do
|
||||
(if (call done) (return false))
|
||||
(if (done) (return false))
|
||||
(let (ty) tok)
|
||||
(return (== pat ty))
|
||||
))
|
||||
|
||||
(fn done () (do
|
||||
(return (>= i (call len tokens)))
|
||||
(return (>= i (len tokens)))
|
||||
))
|
||||
|
||||
(return (list parse))
|
||||
))
|
||||
|
||||
(fn tokenize (text) (do
|
||||
(let text_len (call len text))
|
||||
(let text_len (len text))
|
||||
|
||||
(let tokens (list))
|
||||
(let i 0)
|
||||
@ -620,27 +620,27 @@
|
||||
(loop (do
|
||||
(if (>= i text_len) (break))
|
||||
|
||||
(let ch (call at text i))
|
||||
(let ch (at text i))
|
||||
|
||||
(if (call contains " \t\r\n" ch) (do
|
||||
(if (contains " \t\r\n" ch) (do
|
||||
(if (== ch "\n") (do
|
||||
(+= line 1)
|
||||
))
|
||||
(+= i 1)
|
||||
) (if (call slice_eq text i "//") (do
|
||||
) (if (slice_eq text i "//") (do
|
||||
(loop (do
|
||||
(if (or (>= i text_len) (== (call at text i) "\n")) (do
|
||||
(if (or (>= i text_len) (== (at text i) "\n")) (do
|
||||
(break)
|
||||
))
|
||||
(+= i 1)
|
||||
))
|
||||
) (if (call contains "()" ch) (do
|
||||
(call push tokens (list ch line))
|
||||
) (if (contains "()" ch) (do
|
||||
(push tokens (list ch line))
|
||||
(+= i 1)
|
||||
) (if (== ch "\"") (do
|
||||
(let value "")
|
||||
(+= i 1)
|
||||
(= ch (call at text i))
|
||||
(= ch (at text i))
|
||||
(loop (do
|
||||
(if (or (>= i text_len) (== ch "\"")) (do
|
||||
(break)
|
||||
@ -650,7 +650,7 @@
|
||||
(if (>= i text_len) (do
|
||||
(break)
|
||||
))
|
||||
(= ch (call at text i))
|
||||
(= ch (at text i))
|
||||
(if (== ch "t") (do
|
||||
(+= value "\t")
|
||||
) (if (== ch "r") (do
|
||||
@ -666,37 +666,37 @@
|
||||
(+= value ch)
|
||||
))
|
||||
(+= i 1)
|
||||
(= ch (call at text i))
|
||||
(= ch (at text i))
|
||||
))
|
||||
(if (or (>= i text_len) (!= ch "\"")) (do
|
||||
(call panic "expected '\"' on line %" line)
|
||||
(panic "expected '\"' on line %" line)
|
||||
))
|
||||
(+= i 1)
|
||||
(call push tokens (list "string" line value))
|
||||
) (if (call contains "0123456789" ch) (do
|
||||
(push tokens (list "string" line value))
|
||||
) (if (contains "0123456789" ch) (do
|
||||
(let value "")
|
||||
(loop (do
|
||||
(= ch (call at text i))
|
||||
(if (or (>= i text_len) (not (call contains "0123456789" ch))) (do
|
||||
(= ch (at text i))
|
||||
(if (or (>= i text_len) (not (contains "0123456789" ch))) (do
|
||||
(break)
|
||||
))
|
||||
(+= value ch)
|
||||
(+= i 1)
|
||||
))
|
||||
(call push tokens (list "int" line value))
|
||||
) (if (call contains ident_chars ch) (do
|
||||
(push tokens (list "int" line value))
|
||||
) (if (contains ident_chars ch) (do
|
||||
(let value "")
|
||||
(loop (do
|
||||
(= ch (call at text i))
|
||||
(if (or (>= i text_len) (not (call contains ident_chars ch))) (do
|
||||
(= ch (at text i))
|
||||
(if (or (>= i text_len) (not (contains ident_chars ch))) (do
|
||||
(break)
|
||||
))
|
||||
(+= value ch)
|
||||
(+= i 1)
|
||||
))
|
||||
(call push tokens (list "ident" line value))
|
||||
(push tokens (list "ident" line value))
|
||||
) (do
|
||||
(call println "illegal char '%'" ch)
|
||||
(println "illegal char '%'" ch)
|
||||
(+= i 1)
|
||||
)))))))
|
||||
))
|
||||
@ -704,11 +704,11 @@
|
||||
))
|
||||
|
||||
(fn contains (text ch) (do
|
||||
(let text_len (call len text))
|
||||
(let text_len (len text))
|
||||
(let i 0)
|
||||
(loop (do
|
||||
(if (>= i text_len) (break))
|
||||
(if (== (call at text i) ch) (do
|
||||
(if (== (at text i) ch) (do
|
||||
(return true)
|
||||
))
|
||||
(+= i 1)
|
||||
@ -717,15 +717,15 @@
|
||||
))
|
||||
|
||||
(fn slice_eq (str slice_idx substr) (do
|
||||
(let str_len (call len str))
|
||||
(let substr_len (call len substr))
|
||||
(let str_len (len str))
|
||||
(let substr_len (len substr))
|
||||
(let i 0)
|
||||
(loop (do
|
||||
(if (>= i substr_len)
|
||||
(return true))
|
||||
(if (>= (+ slice_idx i) str_len)
|
||||
(return false))
|
||||
(if (!= (call at str (+ slice_idx i)) (call at substr i))
|
||||
(if (!= (at str (+ slice_idx i)) (at substr i))
|
||||
(return false))
|
||||
(+= i 1)
|
||||
))
|
||||
@ -735,13 +735,13 @@
|
||||
(fn print_expr (expr depth) (do
|
||||
(let (ty line value) expr)
|
||||
(if (== ty "list") (do
|
||||
(call println "%(% %" (call indent depth) ty line)
|
||||
(println "%(% %" (indent depth) ty line)
|
||||
(for e value (do
|
||||
(call print_expr e (+ depth 1))
|
||||
(print_expr e (+ depth 1))
|
||||
))
|
||||
(call println "%)" (call indent depth))
|
||||
(println "%)" (indent depth))
|
||||
) (do
|
||||
(call println "%%" (call indent depth) expr)
|
||||
(println "%%" (indent depth) expr)
|
||||
))
|
||||
))
|
||||
|
||||
@ -757,12 +757,12 @@
|
||||
))
|
||||
|
||||
(fn slice (list idx) (do
|
||||
(let list_len (call len list))
|
||||
(let list_len (len list))
|
||||
(let elems (list))
|
||||
(let i idx)
|
||||
(loop (do
|
||||
(if (>= i list_len) (break))
|
||||
(call push elems (call at list i))
|
||||
(push elems (at list i))
|
||||
(+= i 1)
|
||||
))
|
||||
(return elems)
|
||||
@ -770,49 +770,49 @@
|
||||
|
||||
(let silent false)
|
||||
|
||||
(let (input_filename output_filename) (call get_args))
|
||||
(let (input_filename output_filename) (get_args))
|
||||
|
||||
(if (not silent) (call println "reading file '%'..." input_filename))
|
||||
(let text (call read_text_file input_filename))
|
||||
(if (not silent) (println "reading file '%'..." input_filename))
|
||||
(let text (read_text_file input_filename))
|
||||
|
||||
//(call println "=== text ===")
|
||||
// (call println text)
|
||||
//(call println (call len text))
|
||||
//(println "=== text ===")
|
||||
// (println text)
|
||||
//(println (len text))
|
||||
|
||||
(if (not silent) (call println "tokenizing..."))
|
||||
(let tokens (call tokenize text))
|
||||
(if (not silent) (println "tokenizing..."))
|
||||
(let tokens (tokenize text))
|
||||
|
||||
//(call println "=== tokens ===")
|
||||
//(println "=== tokens ===")
|
||||
//(for elem tokens (do
|
||||
// (let (tok line value) elem)
|
||||
// (if (!= value null) (do
|
||||
// (call println "%\t%\t%" line tok value)
|
||||
// (println "%\t%\t%" line tok value)
|
||||
// ) (do
|
||||
// (call println "%\t%" line tok)
|
||||
// (println "%\t%" line tok)
|
||||
// ))
|
||||
//))
|
||||
//(call println (call len tokens))
|
||||
//(println (len tokens))
|
||||
|
||||
(if (not silent) (call println "parsing..."))
|
||||
(let parser (call Parser tokens))
|
||||
(if (not silent) (println "parsing..."))
|
||||
(let parser (Parser tokens))
|
||||
(let (parse) parser)
|
||||
(let ast (call parse))
|
||||
(let ast (parse))
|
||||
|
||||
// (call println "=== ast ===")
|
||||
// (println "=== ast ===")
|
||||
// (for expr ast (do
|
||||
// (call print_expr expr 0)
|
||||
// (print_expr expr 0)
|
||||
// ))
|
||||
|
||||
(if (not silent) (call println "emitting..."))
|
||||
(let emitter (call Emitter ast input_filename))
|
||||
(if (not silent) (println "emitting..."))
|
||||
(let emitter (Emitter ast input_filename))
|
||||
(let (emit) emitter)
|
||||
(let js_code (call emit))
|
||||
(let js_code (emit))
|
||||
|
||||
// (call println "=== js ===")
|
||||
// (call println js_code)
|
||||
// (println "=== js ===")
|
||||
// (println js_code)
|
||||
|
||||
(if (not silent) (call println "writing file '%'..." output_filename))
|
||||
(call write_text_file output_filename js_code)
|
||||
(if (not silent) (println "writing file '%'..." output_filename))
|
||||
(write_text_file output_filename js_code)
|
||||
|
||||
|
||||
|
||||
|
||||
@ -202,7 +202,7 @@ let _line77 = r_67;
|
||||
const r_68 = r_65.values[2] ?? { type: "null"};
|
||||
let _s78 = r_68;
|
||||
if (runtime.truthy(runtime.opEq((runtime.setLine(113), ((...args) => runtime.builtinLen(...args))(_s78)), ({ type: "int", value: 0 })))) {
|
||||
(runtime.setLine(114), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "illegal function call on line %" }), _line77));
|
||||
(runtime.setLine(114), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "illegal function on line %" }), _line77));
|
||||
};
|
||||
const r_69 = _s78;
|
||||
const r_70 = r_69.values[0] ?? { type: "null"};
|
||||
@ -212,7 +212,7 @@ const r_72 = r_70.values[1] ?? { type: "null"};
|
||||
const r_73 = r_70.values[2] ?? { type: "null"};
|
||||
let _id80 = r_73;
|
||||
if (runtime.truthy(runtime.opNe(_id_ty79, ({ type: "string", value: "ident" })))) {
|
||||
(runtime.setLine(118), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "illegal function call on line %" }), _line77));
|
||||
(runtime.setLine(118), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "illegal function on line %" }), _line77));
|
||||
};
|
||||
if (runtime.truthy(runtime.opEq(_id80, ({ type: "string", value: "fn" })))) {
|
||||
const r_74 = _s78;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user