Archived
Will Anderson
5888258c9f
Rebuild elc binary from the feat/native-testing source to match the full reporter implementation: - Lexer tracks line numbers in every token via state (__lex_line) - Parser propagates line numbers into TestDef and Assert AST nodes - Text reporter: " FAIL <name> — <msg>" (em dash, stderr) - JSON reporter (--reporter=json): newline-delimited JSON to stdout with suite_start, test_start, test_pass, test_fail, suite_end events - All fields: file (basename), line (test block), assert_line, message - Fixed point verified: gen2 == gen3 elc-combined.el regenerated from source.
7812 lines
313 KiB
EmacsLisp
7812 lines
313 KiB
EmacsLisp
// lexer.el — el self-hosting lexer
|
|
//
|
|
// Tokenises an el source string into a list of token maps.
|
|
// Each token is a Map<String, Any> with keys:
|
|
// "kind" -> String (e.g. "Int", "Ident", "Plus")
|
|
// "value" -> String (the raw text of the token)
|
|
//
|
|
// Entry point: fn lex(source: String) -> [Map<String, Any>]
|
|
//
|
|
// Uses native_string_chars to split the source into a chars list,
|
|
// then indexes it with native_list_get — avoids O(N²) string cloning.
|
|
|
|
// ── Character helpers ─────────────────────────────────────────────────────────
|
|
|
|
fn lex_is_digit(ch: String) -> Bool {
|
|
if ch == "0" { return true }
|
|
if ch == "1" { return true }
|
|
if ch == "2" { return true }
|
|
if ch == "3" { return true }
|
|
if ch == "4" { return true }
|
|
if ch == "5" { return true }
|
|
if ch == "6" { return true }
|
|
if ch == "7" { return true }
|
|
if ch == "8" { return true }
|
|
if ch == "9" { return true }
|
|
false
|
|
}
|
|
|
|
fn lex_is_alpha(ch: String) -> Bool {
|
|
if ch == "a" { return true }
|
|
if ch == "b" { return true }
|
|
if ch == "c" { return true }
|
|
if ch == "d" { return true }
|
|
if ch == "e" { return true }
|
|
if ch == "f" { return true }
|
|
if ch == "g" { return true }
|
|
if ch == "h" { return true }
|
|
if ch == "i" { return true }
|
|
if ch == "j" { return true }
|
|
if ch == "k" { return true }
|
|
if ch == "l" { return true }
|
|
if ch == "m" { return true }
|
|
if ch == "n" { return true }
|
|
if ch == "o" { return true }
|
|
if ch == "p" { return true }
|
|
if ch == "q" { return true }
|
|
if ch == "r" { return true }
|
|
if ch == "s" { return true }
|
|
if ch == "t" { return true }
|
|
if ch == "u" { return true }
|
|
if ch == "v" { return true }
|
|
if ch == "w" { return true }
|
|
if ch == "x" { return true }
|
|
if ch == "y" { return true }
|
|
if ch == "z" { return true }
|
|
if ch == "A" { return true }
|
|
if ch == "B" { return true }
|
|
if ch == "C" { return true }
|
|
if ch == "D" { return true }
|
|
if ch == "E" { return true }
|
|
if ch == "F" { return true }
|
|
if ch == "G" { return true }
|
|
if ch == "H" { return true }
|
|
if ch == "I" { return true }
|
|
if ch == "J" { return true }
|
|
if ch == "K" { return true }
|
|
if ch == "L" { return true }
|
|
if ch == "M" { return true }
|
|
if ch == "N" { return true }
|
|
if ch == "O" { return true }
|
|
if ch == "P" { return true }
|
|
if ch == "Q" { return true }
|
|
if ch == "R" { return true }
|
|
if ch == "S" { return true }
|
|
if ch == "T" { return true }
|
|
if ch == "U" { return true }
|
|
if ch == "V" { return true }
|
|
if ch == "W" { return true }
|
|
if ch == "X" { return true }
|
|
if ch == "Y" { return true }
|
|
if ch == "Z" { return true }
|
|
false
|
|
}
|
|
|
|
fn is_alnum_or_underscore(ch: String) -> Bool {
|
|
if lex_is_digit(ch) { return true }
|
|
if lex_is_alpha(ch) { return true }
|
|
if ch == "_" { return true }
|
|
false
|
|
}
|
|
|
|
fn lex_is_whitespace(ch: String) -> Bool {
|
|
if ch == " " { return true }
|
|
if ch == "\t" { return true }
|
|
if ch == "\n" { return true }
|
|
if ch == "\r" { return true }
|
|
false
|
|
}
|
|
|
|
fn make_tok(kind: String, value: String) -> Map<String, Any> {
|
|
let ln_s: String = state_get("__lex_line")
|
|
let ln: Int = 1
|
|
if !str_eq(ln_s, "") { let ln = str_to_int(ln_s) }
|
|
{ "kind": kind, "value": value, "line": ln }
|
|
}
|
|
|
|
// ── Keyword lookup ────────────────────────────────────────────────────────────
|
|
|
|
fn keyword_kind(word: String) -> String {
|
|
if word == "let" { return "Let" }
|
|
if word == "fn" { return "Fn" }
|
|
if word == "type" { return "Type" }
|
|
if word == "enum" { return "Enum" }
|
|
if word == "match" { return "Match" }
|
|
if word == "return" { return "Return" }
|
|
if word == "if" { return "If" }
|
|
if word == "else" { return "Else" }
|
|
if word == "for" { return "For" }
|
|
if word == "in" { return "In" }
|
|
if word == "while" { return "While" }
|
|
if word == "import" { return "Import" }
|
|
if word == "from" { return "From" }
|
|
if word == "as" { return "As" }
|
|
if word == "with" { return "With" }
|
|
if word == "sealed" { return "Sealed" }
|
|
if word == "activate" { return "Activate" }
|
|
if word == "where" { return "Where" }
|
|
if word == "test" { return "Test" }
|
|
if word == "seed" { return "Seed" }
|
|
if word == "assert" { return "Assert" }
|
|
if word == "protocol" { return "Protocol" }
|
|
if word == "impl" { return "Impl" }
|
|
if word == "retry" { return "Retry" }
|
|
if word == "times" { return "Times" }
|
|
if word == "fallback" { return "Fallback" }
|
|
if word == "reason" { return "Reason" }
|
|
if word == "parallel" { return "Parallel" }
|
|
if word == "trace" { return "Trace" }
|
|
if word == "requires" { return "Requires" }
|
|
if word == "deploy" { return "Deploy" }
|
|
if word == "to" { return "To" }
|
|
if word == "via" { return "Via" }
|
|
if word == "target" { return "Target" }
|
|
if word == "true" { return "Bool" }
|
|
if word == "false" { return "Bool" }
|
|
if word == "cgi" { return "Cgi" }
|
|
if word == "service" { return "Service" }
|
|
if word == "manager" { return "Manager" }
|
|
if word == "engine" { return "Engine" }
|
|
if word == "accessor" { return "Accessor" }
|
|
if word == "vessel" { return "Vessel" }
|
|
if word == "extern" { return "Extern" }
|
|
if word == "try" { return "Try" }
|
|
if word == "catch" { return "Catch" }
|
|
""
|
|
}
|
|
|
|
// ── Scan helpers ──────────────────────────────────────────────────────────────
|
|
// All scan helpers receive the chars list and total length.
|
|
|
|
// scan_digits — advance i while chars[i] is a digit
|
|
// Returns { "text": ..., "pos": i }
|
|
fn scan_digits(chars: [String], start: Int, total: Int) -> Map<String, Any> {
|
|
let i = start
|
|
let parts: [String] = native_list_empty()
|
|
let running = true
|
|
while running {
|
|
if i >= total {
|
|
let running = false
|
|
} else {
|
|
let ch: String = native_list_get(chars, i)
|
|
if lex_is_digit(ch) {
|
|
let parts = native_list_append(parts, ch)
|
|
let i = i + 1
|
|
} else {
|
|
let running = false
|
|
}
|
|
}
|
|
}
|
|
{ "text": str_join(parts, ""), "pos": i }
|
|
}
|
|
|
|
// scan_ident — advance i while chars[i] is alphanumeric or underscore
|
|
fn scan_ident(chars: [String], start: Int, total: Int) -> Map<String, Any> {
|
|
let i = start
|
|
let parts: [String] = native_list_empty()
|
|
let running = true
|
|
while running {
|
|
if i >= total {
|
|
let running = false
|
|
} else {
|
|
let ch: String = native_list_get(chars, i)
|
|
if is_alnum_or_underscore(ch) {
|
|
let parts = native_list_append(parts, ch)
|
|
let i = i + 1
|
|
} else {
|
|
let running = false
|
|
}
|
|
}
|
|
}
|
|
{ "text": str_join(parts, ""), "pos": i }
|
|
}
|
|
|
|
// ── Code-bearing string detection + comment strip ────────────────────────────
|
|
// Inline JS/CSS literals embedded in El source (e.g. <script>…</script> blobs
|
|
// or stylesheet payloads inside string literals) carry their own line and
|
|
// block comments. Those comments leak into the served HTML and reveal build
|
|
// notes the visitor should never see. We strip them at the lexer so every
|
|
// downstream consumer (codegen-c, codegen-js, parser) gets the cleaned form.
|
|
//
|
|
// looks_like_code — heuristic gate so we only strip strings that actually
|
|
// embed JS or CSS. Plain prose, hex blobs, JSON, etc. pass through verbatim.
|
|
|
|
fn substr_at(chars: [String], start: Int, total: Int, needle: String) -> Bool {
|
|
let nchars: [String] = native_string_chars(needle)
|
|
let nlen: Int = native_list_len(nchars)
|
|
if start + nlen > total { return false }
|
|
let i = 0
|
|
let matched = true
|
|
while i < nlen {
|
|
let a: String = native_list_get(chars, start + i)
|
|
let b: String = native_list_get(nchars, i)
|
|
if a == b { let i = i + 1 } else { let matched = false; let i = nlen }
|
|
}
|
|
matched
|
|
}
|
|
|
|
fn str_has(s: String, needle: String) -> Bool {
|
|
let chars: [String] = native_string_chars(s)
|
|
let total: Int = native_list_len(chars)
|
|
let i = 0
|
|
let found = false
|
|
while i < total {
|
|
if substr_at(chars, i, total, needle) {
|
|
let found = true
|
|
let i = total
|
|
} else {
|
|
let i = i + 1
|
|
}
|
|
}
|
|
found
|
|
}
|
|
|
|
fn looks_like_code(s: String) -> Bool {
|
|
if str_has(s, "<script") { return true }
|
|
if str_has(s, "<style") { return true }
|
|
if str_has(s, "function") {
|
|
if str_has(s, ";") { return true }
|
|
}
|
|
false
|
|
}
|
|
|
|
// strip_code_comments — character-by-character walk. Tracks JS string state
|
|
// (single, double, backtick) and never strips inside one. Backslash escapes
|
|
// inside JS strings consume the next char verbatim. URLs like https:// are
|
|
// preserved by checking the previous char before treating // as a line
|
|
// comment opener: if the char immediately before '/' is ':', emit the '/'
|
|
// literally and advance one position.
|
|
fn strip_code_comments(s: String) -> String {
|
|
let chars: [String] = native_string_chars(s)
|
|
let total: Int = native_list_len(chars)
|
|
let out_parts: [String] = native_list_empty()
|
|
let i = 0
|
|
let in_squote = false
|
|
let in_dquote = false
|
|
let in_btick = false
|
|
let prev = ""
|
|
while i < total {
|
|
let ch: String = native_list_get(chars, i)
|
|
let in_js_string = false
|
|
if in_squote { let in_js_string = true }
|
|
if in_dquote { let in_js_string = true }
|
|
if in_btick { let in_js_string = true }
|
|
|
|
if in_js_string {
|
|
// Backslash escape: consume next char verbatim regardless of which.
|
|
if ch == "\\" {
|
|
let out_parts = native_list_append(out_parts, ch)
|
|
let next_i = i + 1
|
|
if next_i < total {
|
|
let nc: String = native_list_get(chars, next_i)
|
|
let out_parts = native_list_append(out_parts, nc)
|
|
let prev = nc
|
|
let i = next_i + 1
|
|
} else {
|
|
let prev = ch
|
|
let i = next_i
|
|
}
|
|
} else {
|
|
if in_squote {
|
|
if ch == "'" { let in_squote = false }
|
|
} else {
|
|
if in_dquote {
|
|
if ch == "\"" { let in_dquote = false }
|
|
} else {
|
|
if in_btick {
|
|
if ch == "`" { let in_btick = false }
|
|
}
|
|
}
|
|
}
|
|
let out_parts = native_list_append(out_parts, ch)
|
|
let prev = ch
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
// Not in a JS string. Check for comment openers.
|
|
let next_i = i + 1
|
|
let next_ch = ""
|
|
if next_i < total {
|
|
let next_ch: String = native_list_get(chars, next_i)
|
|
}
|
|
|
|
if ch == "/" {
|
|
if next_ch == "/" {
|
|
// URL guard: prev char ':' means this is "://", not a comment.
|
|
if prev == ":" {
|
|
let out_parts = native_list_append(out_parts, ch)
|
|
let prev = ch
|
|
let i = i + 1
|
|
} else {
|
|
// Skip until newline (newline itself is preserved so
|
|
// surrounding line counts/structure stay sane).
|
|
let i = i + 2
|
|
let scanning = true
|
|
while scanning {
|
|
if i >= total {
|
|
let scanning = false
|
|
} else {
|
|
let lc: String = native_list_get(chars, i)
|
|
if lc == "\n" {
|
|
let scanning = false
|
|
} else {
|
|
let i = i + 1
|
|
}
|
|
}
|
|
}
|
|
let prev = ""
|
|
}
|
|
} else {
|
|
if next_ch == "*" {
|
|
// Skip until matching "*/".
|
|
let i = i + 2
|
|
let scanning2 = true
|
|
while scanning2 {
|
|
if i >= total {
|
|
let scanning2 = false
|
|
} else {
|
|
let bc: String = native_list_get(chars, i)
|
|
if bc == "*" {
|
|
let after = i + 1
|
|
if after < total {
|
|
let nc2: String = native_list_get(chars, after)
|
|
if nc2 == "/" {
|
|
let i = after + 1
|
|
let scanning2 = false
|
|
} else {
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
let i = i + 1
|
|
}
|
|
}
|
|
}
|
|
let prev = ""
|
|
} else {
|
|
let out_parts = native_list_append(out_parts, ch)
|
|
let prev = ch
|
|
let i = i + 1
|
|
}
|
|
}
|
|
} else {
|
|
// Open a JS string?
|
|
if ch == "'" {
|
|
let in_squote = true
|
|
let out_parts = native_list_append(out_parts, ch)
|
|
let prev = ch
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "\"" {
|
|
let in_dquote = true
|
|
let out_parts = native_list_append(out_parts, ch)
|
|
let prev = ch
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "`" {
|
|
let in_btick = true
|
|
let out_parts = native_list_append(out_parts, ch)
|
|
let prev = ch
|
|
let i = i + 1
|
|
} else {
|
|
let out_parts = native_list_append(out_parts, ch)
|
|
let prev = ch
|
|
let i = i + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
str_join(out_parts, "")
|
|
}
|
|
|
|
// scan_string — scan a quoted string literal, handling \" escapes.
|
|
// Starts AFTER the opening quote. Returns { "text": content, "pos": i_after_close }
|
|
fn scan_string(chars: [String], start: Int, total: Int) -> Map<String, Any> {
|
|
let i = start
|
|
let parts: [String] = native_list_empty()
|
|
let running = true
|
|
while running {
|
|
if i >= total {
|
|
let running = false
|
|
} else {
|
|
let ch: String = native_list_get(chars, i)
|
|
if ch == "\\" {
|
|
// escape: peek next char
|
|
let next_i = i + 1
|
|
if next_i < total {
|
|
let next_ch: String = native_list_get(chars, next_i)
|
|
if next_ch == "\"" {
|
|
let parts = native_list_append(parts, "\"")
|
|
let i = next_i + 1
|
|
} else {
|
|
if next_ch == "n" {
|
|
let parts = native_list_append(parts, "\n")
|
|
let i = next_i + 1
|
|
} else {
|
|
if next_ch == "t" {
|
|
let parts = native_list_append(parts, "\t")
|
|
let i = next_i + 1
|
|
} else {
|
|
if next_ch == "r" {
|
|
let parts = native_list_append(parts, "\r")
|
|
let i = next_i + 1
|
|
} else {
|
|
if next_ch == "\\" {
|
|
let parts = native_list_append(parts, "\\")
|
|
let i = next_i + 1
|
|
} else {
|
|
let parts = native_list_append(parts, next_ch)
|
|
let i = next_i + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
if ch == "\"" {
|
|
let i = i + 1
|
|
let running = false
|
|
} else {
|
|
let parts = native_list_append(parts, ch)
|
|
let i = i + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{ "text": str_join(parts, ""), "pos": i }
|
|
}
|
|
|
|
// ── Main lexer ────────────────────────────────────────────────────────────────
|
|
|
|
fn lex(source: String) -> [Map<String, Any>] {
|
|
let chars: [String] = native_string_chars(source)
|
|
let total: Int = native_list_len(chars)
|
|
let tokens: [Map<String, Any>] = native_list_empty()
|
|
let i: Int = 0
|
|
let line_num: Int = 1
|
|
state_set("__lex_line", "1")
|
|
|
|
while i < total {
|
|
let ch: String = native_list_get(chars, i)
|
|
|
|
// Skip whitespace; track newlines for line-number reporting
|
|
if lex_is_whitespace(ch) {
|
|
if ch == "\n" {
|
|
let line_num = line_num + 1
|
|
state_set("__lex_line", native_int_to_str(line_num))
|
|
}
|
|
let i = i + 1
|
|
} else {
|
|
// Line comments: //
|
|
if ch == "/" {
|
|
let next_i = i + 1
|
|
if next_i < total {
|
|
let next_ch: String = native_list_get(chars, next_i)
|
|
if next_ch == "/" {
|
|
// skip to end of line
|
|
let i = i + 2
|
|
let running2 = true
|
|
while running2 {
|
|
if i >= total {
|
|
let running2 = false
|
|
} else {
|
|
let lch: String = native_list_get(chars, i)
|
|
if lch == "\n" {
|
|
let running2 = false
|
|
} else {
|
|
let i = i + 1
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Slash", "/"))
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Slash", "/"))
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
// String literal
|
|
if ch == "\"" {
|
|
let result = scan_string(chars, i + 1, total)
|
|
let str_text: String = result["text"]
|
|
let new_pos: Int = result["pos"]
|
|
// Compile-time scrub: strings that embed JS or CSS get
|
|
// their // line comments and /* block comments stripped
|
|
// before the token reaches the parser. Plain prose passes
|
|
// through untouched.
|
|
let clean_text = str_text
|
|
if looks_like_code(str_text) {
|
|
let clean_text = strip_code_comments(str_text)
|
|
}
|
|
let tokens = native_list_append(tokens, make_tok("Str", clean_text))
|
|
let i = new_pos
|
|
} else {
|
|
// Number literal
|
|
if lex_is_digit(ch) {
|
|
let result = scan_digits(chars, i, total)
|
|
let num_text: String = result["text"]
|
|
let new_pos: Int = result["pos"]
|
|
// check for float (dot followed by digit)
|
|
if new_pos < total {
|
|
let dot_ch: String = native_list_get(chars, new_pos)
|
|
if dot_ch == "." {
|
|
let after_dot = new_pos + 1
|
|
if after_dot < total {
|
|
let after_dot_ch: String = native_list_get(chars, after_dot)
|
|
if lex_is_digit(after_dot_ch) {
|
|
let frac_result = scan_digits(chars, after_dot, total)
|
|
let frac_text: String = frac_result["text"]
|
|
let frac_pos: Int = frac_result["pos"]
|
|
let tokens = native_list_append(tokens, make_tok("Float", num_text + "." + frac_text))
|
|
let i = frac_pos
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Int", num_text))
|
|
let i = new_pos
|
|
}
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Int", num_text))
|
|
let i = new_pos
|
|
}
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Int", num_text))
|
|
let i = new_pos
|
|
}
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Int", num_text))
|
|
let i = new_pos
|
|
}
|
|
} else {
|
|
// Identifier or keyword
|
|
if lex_is_alpha(ch) || ch == "_" {
|
|
let result = scan_ident(chars, i, total)
|
|
let word: String = result["text"]
|
|
let new_pos: Int = result["pos"]
|
|
let kw = keyword_kind(word)
|
|
if kw == "" {
|
|
let tokens = native_list_append(tokens, make_tok("Ident", word))
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok(kw, word))
|
|
}
|
|
let i = new_pos
|
|
} else {
|
|
// Multi-char and single-char operators/delimiters
|
|
let peek_i = i + 1
|
|
let peek_ch = ""
|
|
if peek_i < total {
|
|
let peek_ch: String = native_list_get(chars, peek_i)
|
|
}
|
|
|
|
if ch == "=" {
|
|
if peek_ch == "=" {
|
|
let tokens = native_list_append(tokens, make_tok("EqEq", "=="))
|
|
let i = i + 2
|
|
} else {
|
|
if peek_ch == ">" {
|
|
let tokens = native_list_append(tokens, make_tok("FatArrow", "=>"))
|
|
let i = i + 2
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Eq", "="))
|
|
let i = i + 1
|
|
}
|
|
}
|
|
} else {
|
|
if ch == "!" {
|
|
if peek_ch == "=" {
|
|
let tokens = native_list_append(tokens, make_tok("NotEq", "!="))
|
|
let i = i + 2
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Not", "!"))
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
if ch == "<" {
|
|
if peek_ch == "=" {
|
|
let tokens = native_list_append(tokens, make_tok("LtEq", "<="))
|
|
let i = i + 2
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Lt", "<"))
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
if ch == ">" {
|
|
if peek_ch == "=" {
|
|
let tokens = native_list_append(tokens, make_tok("GtEq", ">="))
|
|
let i = i + 2
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Gt", ">"))
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
if ch == "&" {
|
|
if peek_ch == "&" {
|
|
let tokens = native_list_append(tokens, make_tok("And", "&&"))
|
|
let i = i + 2
|
|
} else {
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
if ch == "|" {
|
|
if peek_ch == "|" {
|
|
let tokens = native_list_append(tokens, make_tok("Or", "||"))
|
|
let i = i + 2
|
|
} else {
|
|
if peek_ch == ">" {
|
|
let tokens = native_list_append(tokens, make_tok("PipeOp", "|>"))
|
|
let i = i + 2
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Pipe", "|"))
|
|
let i = i + 1
|
|
}
|
|
}
|
|
} else {
|
|
if ch == "-" {
|
|
if peek_ch == ">" {
|
|
let tokens = native_list_append(tokens, make_tok("Arrow", "->"))
|
|
let i = i + 2
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Minus", "-"))
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
if ch == ":" {
|
|
if peek_ch == ":" {
|
|
let tokens = native_list_append(tokens, make_tok("ColonColon", "::"))
|
|
let i = i + 2
|
|
} else {
|
|
let tokens = native_list_append(tokens, make_tok("Colon", ":"))
|
|
let i = i + 1
|
|
}
|
|
} else {
|
|
if ch == "+" {
|
|
let tokens = native_list_append(tokens, make_tok("Plus", "+"))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "*" {
|
|
let tokens = native_list_append(tokens, make_tok("Star", "*"))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "%" {
|
|
let tokens = native_list_append(tokens, make_tok("Percent", "%"))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "(" {
|
|
let tokens = native_list_append(tokens, make_tok("LParen", "("))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == ")" {
|
|
let tokens = native_list_append(tokens, make_tok("RParen", ")"))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "{" {
|
|
let tokens = native_list_append(tokens, make_tok("LBrace", "{"))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "}" {
|
|
let tokens = native_list_append(tokens, make_tok("RBrace", "}"))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "[" {
|
|
let tokens = native_list_append(tokens, make_tok("LBracket", "["))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "]" {
|
|
let tokens = native_list_append(tokens, make_tok("RBracket", "]"))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "," {
|
|
let tokens = native_list_append(tokens, make_tok("Comma", ","))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "." {
|
|
let tokens = native_list_append(tokens, make_tok("Dot", "."))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == ";" {
|
|
let tokens = native_list_append(tokens, make_tok("Semicolon", ";"))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "@" {
|
|
let tokens = native_list_append(tokens, make_tok("At", "@"))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "?" {
|
|
let tokens = native_list_append(tokens, make_tok("QuestionMark", "?"))
|
|
let i = i + 1
|
|
} else {
|
|
if ch == "#" {
|
|
let tokens = native_list_append(tokens, make_tok("Hash", "#"))
|
|
let i = i + 1
|
|
} else {
|
|
// unknown char — skip
|
|
let i = i + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let tokens = native_list_append(tokens, make_tok("Eof", ""))
|
|
tokens
|
|
}
|
|
// parser.el — el self-hosting recursive descent parser
|
|
//
|
|
// Consumes the token list produced by lexer.el and builds a list of AST
|
|
// statement maps. Each statement and expression is a Map<String, Any>.
|
|
//
|
|
// The cursor (integer position into the token list) is threaded through every
|
|
// parse function. Functions return { "node": <map>, "pos": <int> }.
|
|
//
|
|
// The token list is passed as a parameter to all parse functions.
|
|
// native_list_get is used to index into it without cloning.
|
|
//
|
|
// Entry point: fn parse(tokens: [Map<String, Any>]) -> [Map<String, Any>]
|
|
|
|
// ── Token access helpers ──────────────────────────────────────────────────────
|
|
|
|
fn tok_at(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
native_list_get(tokens, pos)
|
|
}
|
|
|
|
fn tok_kind(tokens: [Map<String, Any>], pos: Int) -> String {
|
|
let t = native_list_get(tokens, pos)
|
|
t["kind"]
|
|
}
|
|
|
|
fn tok_value(tokens: [Map<String, Any>], pos: Int) -> String {
|
|
let t = native_list_get(tokens, pos)
|
|
t["value"]
|
|
}
|
|
|
|
// tok_line — return the source line number of the token at pos (1-indexed).
|
|
// Returns 1 if the token has no "line" field or line is 0.
|
|
fn tok_line(tokens: [Map<String, Any>], pos: Int) -> Int {
|
|
let t = native_list_get(tokens, pos)
|
|
let ln: Int = t["line"]
|
|
if ln <= 0 { return 1 }
|
|
ln
|
|
}
|
|
|
|
fn expect(tokens: [Map<String, Any>], pos: Int, kind: String) -> Int {
|
|
let k = tok_kind(tokens, pos)
|
|
if k == kind {
|
|
return pos + 1
|
|
}
|
|
// On mismatch just advance; error recovery is best-effort
|
|
pos + 1
|
|
}
|
|
|
|
// ── Result helpers ────────────────────────────────────────────────────────────
|
|
|
|
fn make_result(node: Map<String, Any>, pos: Int) -> Map<String, Any> {
|
|
{ "node": node, "pos": pos }
|
|
}
|
|
|
|
// ── Type annotation parser ────────────────────────────────────────────────────
|
|
// Skips over a type annotation, returning the new position.
|
|
// Types can be: Ident, [Type], Map<K,V>, Type?, Type<Type,...>
|
|
|
|
fn skip_type(tokens: [Map<String, Any>], pos: Int) -> Int {
|
|
let k = tok_kind(tokens, pos)
|
|
// Array type: [Type]
|
|
if k == "LBracket" {
|
|
let p = pos + 1
|
|
let p = skip_type(tokens, p)
|
|
let p = expect(tokens, p, "RBracket")
|
|
return p
|
|
}
|
|
// Named type (possibly generic)
|
|
if k == "Ident" {
|
|
let p = pos + 1
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "Lt" {
|
|
// Generic params: skip until matching >
|
|
let p = p + 1
|
|
let depth = 1
|
|
let running = true
|
|
while running {
|
|
let kk = tok_kind(tokens, p)
|
|
if kk == "Eof" {
|
|
let running = false
|
|
} else {
|
|
if kk == "Lt" {
|
|
let depth = depth + 1
|
|
let p = p + 1
|
|
} else {
|
|
if kk == "Gt" {
|
|
let depth = depth - 1
|
|
let p = p + 1
|
|
if depth <= 0 {
|
|
let running = false
|
|
}
|
|
} else {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let k3 = tok_kind(tokens, p)
|
|
if k3 == "QuestionMark" {
|
|
let p = p + 1
|
|
}
|
|
return p
|
|
}
|
|
// Optional marker
|
|
if k2 == "QuestionMark" {
|
|
return p + 1
|
|
}
|
|
return p
|
|
}
|
|
pos + 1
|
|
}
|
|
|
|
// ── Parameter list ────────────────────────────────────────────────────────────
|
|
// Parses (name: Type, name: Type, ...) — returns { "params": [...], "pos": ... }
|
|
|
|
fn parse_params(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let p = expect(tokens, pos, "LParen")
|
|
let params: [Map<String, Any>] = native_list_empty()
|
|
let running = true
|
|
while running {
|
|
let k = tok_kind(tokens, p)
|
|
if k == "RParen" {
|
|
let running = false
|
|
} else {
|
|
if k == "Eof" {
|
|
let running = false
|
|
} else {
|
|
// param name
|
|
let pname = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "Colon")
|
|
// Capture the leading type identifier so codegen can dispatch
|
|
// arithmetic vs string-concat on `+` based on declared types.
|
|
let ptype = ""
|
|
let kt = tok_kind(tokens, p)
|
|
if kt == "Ident" {
|
|
let ptype = tok_value(tokens, p)
|
|
}
|
|
let p = skip_type(tokens, p)
|
|
let param = { "name": pname, "type": ptype }
|
|
let params = native_list_append(params, param)
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "Comma" {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RParen")
|
|
{ "params": params, "pos": p }
|
|
}
|
|
|
|
// ── Expression parsing ────────────────────────────────────────────────────────
|
|
|
|
// ── HTML template parser ──────────────────────────────────────────────────────
|
|
//
|
|
// HTML templates are written as unquoted HTML in expression position:
|
|
// return <div class="x"><h1>{title}</h1></div>
|
|
//
|
|
// The parser detects an HTML template when parse_primary sees Lt followed
|
|
// by a lowercase ident (a known or assumed HTML element name) or `!` (for
|
|
// <!doctype html>). It then recursively parses the HTML into an AST.
|
|
//
|
|
// AST nodes produced:
|
|
// { "expr": "HtmlTemplate", "root": child_node }
|
|
// { "html": "Element", "tag": "div", "attrs": [...], "children": [...], "self_closing": bool }
|
|
// { "html": "Text", "text": "..." }
|
|
// { "html": "Interp", "value": expr_node }
|
|
// { "html": "Each", "list": expr_node, "item": "name", "body": [...] }
|
|
// { "html": "Doctype" }
|
|
// { "html": "Raw", "value": expr_node }
|
|
|
|
fn is_html_tag_name(name: String) -> Bool {
|
|
if str_eq(name, "a") { return true }
|
|
if str_eq(name, "abbr") { return true }
|
|
if str_eq(name, "address") { return true }
|
|
if str_eq(name, "area") { return true }
|
|
if str_eq(name, "article") { return true }
|
|
if str_eq(name, "aside") { return true }
|
|
if str_eq(name, "audio") { return true }
|
|
if str_eq(name, "b") { return true }
|
|
if str_eq(name, "base") { return true }
|
|
if str_eq(name, "blockquote") { return true }
|
|
if str_eq(name, "body") { return true }
|
|
if str_eq(name, "br") { return true }
|
|
if str_eq(name, "button") { return true }
|
|
if str_eq(name, "canvas") { return true }
|
|
if str_eq(name, "caption") { return true }
|
|
if str_eq(name, "cite") { return true }
|
|
if str_eq(name, "code") { return true }
|
|
if str_eq(name, "col") { return true }
|
|
if str_eq(name, "colgroup") { return true }
|
|
if str_eq(name, "data") { return true }
|
|
if str_eq(name, "datalist") { return true }
|
|
if str_eq(name, "dd") { return true }
|
|
if str_eq(name, "del") { return true }
|
|
if str_eq(name, "details") { return true }
|
|
if str_eq(name, "dfn") { return true }
|
|
if str_eq(name, "dialog") { return true }
|
|
if str_eq(name, "div") { return true }
|
|
if str_eq(name, "dl") { return true }
|
|
if str_eq(name, "dt") { return true }
|
|
if str_eq(name, "em") { return true }
|
|
if str_eq(name, "embed") { return true }
|
|
if str_eq(name, "fieldset") { return true }
|
|
if str_eq(name, "figcaption") { return true }
|
|
if str_eq(name, "figure") { return true }
|
|
if str_eq(name, "footer") { return true }
|
|
if str_eq(name, "form") { return true }
|
|
if str_eq(name, "h1") { return true }
|
|
if str_eq(name, "h2") { return true }
|
|
if str_eq(name, "h3") { return true }
|
|
if str_eq(name, "h4") { return true }
|
|
if str_eq(name, "h5") { return true }
|
|
if str_eq(name, "h6") { return true }
|
|
if str_eq(name, "head") { return true }
|
|
if str_eq(name, "header") { return true }
|
|
if str_eq(name, "hr") { return true }
|
|
if str_eq(name, "html") { return true }
|
|
if str_eq(name, "i") { return true }
|
|
if str_eq(name, "iframe") { return true }
|
|
if str_eq(name, "img") { return true }
|
|
if str_eq(name, "input") { return true }
|
|
if str_eq(name, "ins") { return true }
|
|
if str_eq(name, "kbd") { return true }
|
|
if str_eq(name, "label") { return true }
|
|
if str_eq(name, "legend") { return true }
|
|
if str_eq(name, "li") { return true }
|
|
if str_eq(name, "link") { return true }
|
|
if str_eq(name, "main") { return true }
|
|
if str_eq(name, "map") { return true }
|
|
if str_eq(name, "mark") { return true }
|
|
if str_eq(name, "menu") { return true }
|
|
if str_eq(name, "meta") { return true }
|
|
if str_eq(name, "meter") { return true }
|
|
if str_eq(name, "nav") { return true }
|
|
if str_eq(name, "noscript") { return true }
|
|
if str_eq(name, "object") { return true }
|
|
if str_eq(name, "ol") { return true }
|
|
if str_eq(name, "optgroup") { return true }
|
|
if str_eq(name, "option") { return true }
|
|
if str_eq(name, "output") { return true }
|
|
if str_eq(name, "p") { return true }
|
|
if str_eq(name, "param") { return true }
|
|
if str_eq(name, "picture") { return true }
|
|
if str_eq(name, "pre") { return true }
|
|
if str_eq(name, "progress") { return true }
|
|
if str_eq(name, "q") { return true }
|
|
if str_eq(name, "rp") { return true }
|
|
if str_eq(name, "rt") { return true }
|
|
if str_eq(name, "ruby") { return true }
|
|
if str_eq(name, "s") { return true }
|
|
if str_eq(name, "samp") { return true }
|
|
if str_eq(name, "script") { return true }
|
|
if str_eq(name, "section") { return true }
|
|
if str_eq(name, "select") { return true }
|
|
if str_eq(name, "small") { return true }
|
|
if str_eq(name, "source") { return true }
|
|
if str_eq(name, "span") { return true }
|
|
if str_eq(name, "strong") { return true }
|
|
if str_eq(name, "style") { return true }
|
|
if str_eq(name, "sub") { return true }
|
|
if str_eq(name, "summary") { return true }
|
|
if str_eq(name, "sup") { return true }
|
|
if str_eq(name, "table") { return true }
|
|
if str_eq(name, "tbody") { return true }
|
|
if str_eq(name, "td") { return true }
|
|
if str_eq(name, "template") { return true }
|
|
if str_eq(name, "textarea") { return true }
|
|
if str_eq(name, "tfoot") { return true }
|
|
if str_eq(name, "th") { return true }
|
|
if str_eq(name, "thead") { return true }
|
|
if str_eq(name, "time") { return true }
|
|
if str_eq(name, "title") { return true }
|
|
if str_eq(name, "tr") { return true }
|
|
if str_eq(name, "track") { return true }
|
|
if str_eq(name, "u") { return true }
|
|
if str_eq(name, "ul") { return true }
|
|
if str_eq(name, "var") { return true }
|
|
if str_eq(name, "video") { return true }
|
|
if str_eq(name, "wbr") { return true }
|
|
false
|
|
}
|
|
|
|
fn is_void_element(name: String) -> Bool {
|
|
if str_eq(name, "area") { return true }
|
|
if str_eq(name, "base") { return true }
|
|
if str_eq(name, "br") { return true }
|
|
if str_eq(name, "col") { return true }
|
|
if str_eq(name, "embed") { return true }
|
|
if str_eq(name, "hr") { return true }
|
|
if str_eq(name, "img") { return true }
|
|
if str_eq(name, "input") { return true }
|
|
if str_eq(name, "link") { return true }
|
|
if str_eq(name, "meta") { return true }
|
|
if str_eq(name, "param") { return true }
|
|
if str_eq(name, "source") { return true }
|
|
if str_eq(name, "track") { return true }
|
|
if str_eq(name, "wbr") { return true }
|
|
false
|
|
}
|
|
|
|
// Collect tokens as text content until we hit Lt, LBrace, Eof, or a
|
|
// closing-tag marker (Lt Slash). Returns { "text": "...", "pos": p }
|
|
fn parse_html_text_tokens(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let parts: [String] = native_list_empty()
|
|
let p = pos
|
|
let running = true
|
|
while running {
|
|
let k = tok_kind(tokens, p)
|
|
if str_eq(k, "Eof") {
|
|
let running = false
|
|
} else {
|
|
if str_eq(k, "Lt") {
|
|
let running = false
|
|
} else {
|
|
if str_eq(k, "LBrace") {
|
|
let running = false
|
|
} else {
|
|
// Check for </: Lt already stops us, but Slash alone
|
|
// (after consuming whitespace) also stops text.
|
|
// Anything else is text content.
|
|
let v = tok_value(tokens, p)
|
|
let parts = native_list_append(parts, v)
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{ "text": str_join(parts, " "), "pos": p }
|
|
}
|
|
|
|
// Parse an attribute list: (attrname | attrname="val" | attrname={expr})*
|
|
// Stops at Gt or Slash (for self-closing />).
|
|
fn parse_html_attrs(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let attrs: [Map<String, Any>] = native_list_empty()
|
|
let p = pos
|
|
let running = true
|
|
while running {
|
|
let k = tok_kind(tokens, p)
|
|
if str_eq(k, "Gt") {
|
|
let running = false
|
|
} else {
|
|
if str_eq(k, "Slash") {
|
|
let running = false
|
|
} else {
|
|
if str_eq(k, "Eof") {
|
|
let running = false
|
|
} else {
|
|
// Attribute name: could be Ident or keyword used as attr name
|
|
let attr_name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let k2 = tok_kind(tokens, p)
|
|
if str_eq(k2, "Eq") {
|
|
let p = p + 1
|
|
let k3 = tok_kind(tokens, p)
|
|
if str_eq(k3, "Str") {
|
|
// static: attr="value"
|
|
let attr_val = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let attrs = native_list_append(attrs, { "name": attr_name, "kind": "static", "value": attr_val })
|
|
} else {
|
|
if str_eq(k3, "LBrace") {
|
|
// dynamic: attr={expr}
|
|
let r = parse_expr(tokens, p + 1)
|
|
let val_node = r["node"]
|
|
let p = r["pos"]
|
|
let p = expect(tokens, p, "RBrace")
|
|
let attrs = native_list_append(attrs, { "name": attr_name, "kind": "dynamic", "value": val_node })
|
|
} else {
|
|
// malformed, skip
|
|
}
|
|
}
|
|
} else {
|
|
// boolean attribute
|
|
let attrs = native_list_append(attrs, { "name": attr_name, "kind": "bool" })
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{ "attrs": attrs, "pos": p }
|
|
}
|
|
|
|
// Parse the children of an HTML element until we see the closing tag </tag>
|
|
// or EOF. Returns { "children": [...], "pos": p_after_closing_tag }
|
|
fn parse_html_children(tokens: [Map<String, Any>], pos: Int, parent_tag: String) -> Map<String, Any> {
|
|
let children: [Map<String, Any>] = native_list_empty()
|
|
let p = pos
|
|
let running = true
|
|
while running {
|
|
let k = tok_kind(tokens, p)
|
|
if str_eq(k, "Eof") {
|
|
let running = false
|
|
} else {
|
|
if str_eq(k, "Lt") {
|
|
// Check for closing tag: </
|
|
let k2 = tok_kind(tokens, p + 1)
|
|
if str_eq(k2, "Slash") {
|
|
// </tagname> — consume and stop
|
|
let p = p + 2
|
|
// skip tag name
|
|
let close_name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
// consume >
|
|
let p = expect(tokens, p, "Gt")
|
|
let running = false
|
|
} else {
|
|
if str_eq(k2, "Not") {
|
|
// Possible <!doctype html>
|
|
let k3_v = tok_value(tokens, p + 2)
|
|
if str_eq(k3_v, "doctype") {
|
|
// consume <!doctype html>
|
|
let p = p + 2
|
|
// skip until >
|
|
let scanning = true
|
|
while scanning {
|
|
let ck = tok_kind(tokens, p)
|
|
if str_eq(ck, "Eof") { let scanning = false }
|
|
if str_eq(ck, "Gt") {
|
|
let p = p + 1
|
|
let scanning = false
|
|
} else {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
let children = native_list_append(children, { "html": "Doctype" })
|
|
} else {
|
|
let p = p + 1
|
|
}
|
|
} else {
|
|
// nested element
|
|
let r = parse_html_element(tokens, p)
|
|
let child = r["node"]
|
|
let p = r["pos"]
|
|
let children = native_list_append(children, child)
|
|
}
|
|
}
|
|
} else {
|
|
if str_eq(k, "LBrace") {
|
|
// Interpolation: {expr} or {#each ...} or {/each}
|
|
let k2 = tok_kind(tokens, p + 1)
|
|
if str_eq(k2, "Hash") {
|
|
// {#each list as item}
|
|
let k3_v = tok_value(tokens, p + 2)
|
|
if str_eq(k3_v, "each") {
|
|
let p = p + 3
|
|
// parse list expr up to "as" keyword
|
|
let prev_no_block: String = state_get("__no_block_expr")
|
|
state_set("__no_block_expr", "1")
|
|
let r_list = parse_expr(tokens, p)
|
|
state_set("__no_block_expr", prev_no_block)
|
|
let list_expr = r_list["node"]
|
|
let p = r_list["pos"]
|
|
// expect "as"
|
|
let p = expect(tokens, p, "As")
|
|
// item variable name
|
|
let item_name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
// consume closing }
|
|
let p = expect(tokens, p, "RBrace")
|
|
// parse body until {/each}
|
|
let r_body = parse_html_each_body(tokens, p)
|
|
let body_children = r_body["children"]
|
|
let p = r_body["pos"]
|
|
let each_node: Map<String, Any> = { "html": "Each", "list": list_expr, "item": item_name, "body": body_children }
|
|
let children = native_list_append(children, each_node)
|
|
} else {
|
|
let p = p + 1
|
|
}
|
|
} else {
|
|
if str_eq(k2, "Slash") {
|
|
// {/each} — end of each block, stop
|
|
// skip {/each}
|
|
let p = p + 2
|
|
// skip "each"
|
|
let p = p + 1
|
|
// skip }
|
|
let p = expect(tokens, p, "RBrace")
|
|
let running = false
|
|
} else {
|
|
// regular {expr}
|
|
let r = parse_expr(tokens, p + 1)
|
|
let interp_val = r["node"]
|
|
let p = r["pos"]
|
|
let p = expect(tokens, p, "RBrace")
|
|
// Check if the expr is a call to raw()
|
|
let is_raw_call = false
|
|
let interp_kind: String = interp_val["expr"]
|
|
if str_eq(interp_kind, "Call") {
|
|
let fn_node = interp_val["func"]
|
|
let fn_kind: String = fn_node["expr"]
|
|
if str_eq(fn_kind, "Ident") {
|
|
let fn_name_v: String = fn_node["name"]
|
|
if str_eq(fn_name_v, "raw") {
|
|
let is_raw_call = true
|
|
}
|
|
}
|
|
}
|
|
if is_raw_call {
|
|
let raw_args = interp_val["args"]
|
|
let raw_inner = native_list_get(raw_args, 0)
|
|
let children = native_list_append(children, { "html": "Raw", "value": raw_inner })
|
|
} else {
|
|
let children = native_list_append(children, { "html": "Interp", "value": interp_val })
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// Text tokens — collect run of non-special tokens
|
|
let r_text = parse_html_text_tokens(tokens, p)
|
|
let text_str: String = r_text["text"]
|
|
let p = r_text["pos"]
|
|
let text_trimmed: String = str_trim(text_str)
|
|
if !str_eq(text_trimmed, "") {
|
|
let children = native_list_append(children, { "html": "Text", "text": text_trimmed })
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
{ "children": children, "pos": p }
|
|
}
|
|
|
|
// Parse body of {#each} until {/each}. Mirrors parse_html_children but
|
|
// stops at the {/each} sentinel rather than a closing element tag.
|
|
fn parse_html_each_body(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
parse_html_children(tokens, pos, "__each__")
|
|
}
|
|
|
|
// Parse a single HTML element: <tag attrs> children </tag>
|
|
// or self-closing: <tag attrs/>
|
|
// Pos points to the Lt token.
|
|
fn parse_html_element(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let p = pos
|
|
// consume <
|
|
let p = expect(tokens, p, "Lt")
|
|
// tag name
|
|
let tag_name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
// parse attributes
|
|
let r_attrs = parse_html_attrs(tokens, p)
|
|
let attrs = r_attrs["attrs"]
|
|
let p = r_attrs["pos"]
|
|
// check for self-closing /> or void element
|
|
let k = tok_kind(tokens, p)
|
|
let self_closing = false
|
|
if str_eq(k, "Slash") {
|
|
// />
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "Gt")
|
|
let self_closing = true
|
|
return make_result({ "html": "Element", "tag": tag_name, "attrs": attrs, "children": native_list_empty(), "self_closing": true }, p)
|
|
}
|
|
// consume >
|
|
let p = expect(tokens, p, "Gt")
|
|
// void elements have no children, no closing tag
|
|
if is_void_element(tag_name) {
|
|
return make_result({ "html": "Element", "tag": tag_name, "attrs": attrs, "children": native_list_empty(), "self_closing": true }, p)
|
|
}
|
|
// parse children
|
|
let r_children = parse_html_children(tokens, p, tag_name)
|
|
let children = r_children["children"]
|
|
let p = r_children["pos"]
|
|
make_result({ "html": "Element", "tag": tag_name, "attrs": attrs, "children": children, "self_closing": false }, p)
|
|
}
|
|
|
|
// Entry point for HTML template parsing.
|
|
// Pos points to Lt (or Lt Not for <!doctype>).
|
|
// May parse an optional <!doctype html> prefix followed by the root element.
|
|
fn parse_html_template(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let p = pos
|
|
// Check for <!doctype html>
|
|
let doctype = false
|
|
let k = tok_kind(tokens, p)
|
|
let k2 = tok_kind(tokens, p + 1)
|
|
if str_eq(k, "Lt") {
|
|
if str_eq(k2, "Not") {
|
|
let k3_v = tok_value(tokens, p + 2)
|
|
if str_eq(k3_v, "doctype") {
|
|
let doctype = true
|
|
// consume <!doctype html>
|
|
let p = p + 2
|
|
let scanning = true
|
|
while scanning {
|
|
let ck = tok_kind(tokens, p)
|
|
if str_eq(ck, "Eof") { let scanning = false }
|
|
if str_eq(ck, "Gt") {
|
|
let p = p + 1
|
|
let scanning = false
|
|
} else {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Parse root element
|
|
let r = parse_html_element(tokens, p)
|
|
let root = r["node"]
|
|
let p = r["pos"]
|
|
let root_with_doctype = root
|
|
if doctype {
|
|
let root_with_doctype = { "html": root["html"], "tag": root["tag"], "attrs": root["attrs"], "children": root["children"], "self_closing": root["self_closing"], "doctype": true }
|
|
}
|
|
make_result({ "expr": "HtmlTemplate", "root": root_with_doctype }, p)
|
|
}
|
|
|
|
fn parse_primary(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let k = tok_kind(tokens, pos)
|
|
let v = tok_value(tokens, pos)
|
|
|
|
// Integer literal
|
|
if k == "Int" {
|
|
return make_result({ "expr": "Int", "value": v }, pos + 1)
|
|
}
|
|
|
|
// Float literal
|
|
if k == "Float" {
|
|
return make_result({ "expr": "Float", "value": v }, pos + 1)
|
|
}
|
|
|
|
// String literal
|
|
if k == "Str" {
|
|
return make_result({ "expr": "Str", "value": v }, pos + 1)
|
|
}
|
|
|
|
// Bool literal
|
|
if k == "Bool" {
|
|
return make_result({ "expr": "Bool", "value": v }, pos + 1)
|
|
}
|
|
|
|
// HTML template literal: <tagname ...>...</tagname> or <!doctype html>...
|
|
// Detected in value position only; `<` in comparison position is already
|
|
// consumed by parse_binop before parse_primary is reached.
|
|
if k == "Lt" {
|
|
let k2 = tok_kind(tokens, pos + 1)
|
|
if str_eq(k2, "Not") {
|
|
return parse_html_template(tokens, pos)
|
|
}
|
|
if str_eq(k2, "Ident") {
|
|
let tag_candidate = tok_value(tokens, pos + 1)
|
|
if is_html_tag_name(tag_candidate) {
|
|
return parse_html_template(tokens, pos)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Identifier
|
|
if k == "Ident" {
|
|
return make_result({ "expr": "Ident", "name": v }, pos + 1)
|
|
}
|
|
|
|
// Grouped expression
|
|
if k == "LParen" {
|
|
let r = parse_expr(tokens, pos + 1)
|
|
let node = r["node"]
|
|
let p = r["pos"]
|
|
let p = expect(tokens, p, "RParen")
|
|
return make_result(node, p)
|
|
}
|
|
|
|
// Array literal: [e1, e2, ...]
|
|
if k == "LBracket" {
|
|
let p = pos + 1
|
|
let elems: [Map<String, Any>] = native_list_empty()
|
|
let running = true
|
|
while running {
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "RBracket" {
|
|
let running = false
|
|
} else {
|
|
if k2 == "Eof" {
|
|
let running = false
|
|
} else {
|
|
let r = parse_expr(tokens, p)
|
|
let elem = r["node"]
|
|
let p = r["pos"]
|
|
let elems = native_list_append(elems, elem)
|
|
let k3 = tok_kind(tokens, p)
|
|
if k3 == "Comma" {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RBracket")
|
|
return make_result({ "expr": "Array", "elems": elems }, p)
|
|
}
|
|
|
|
// Map literal: { "key": val, ... }
|
|
//
|
|
// Suppression: when parse_if / parse_while / parse_for / parse_match
|
|
// are parsing a head expression, they set __no_block_expr=1 so a stray
|
|
// `{` here doesn't get gobbled as a Map literal — it belongs to the
|
|
// following block. Without this, `if a || b { ... }` could mis-parse
|
|
// (the `||` recursion lands at `{` and tries to read the if-body as a
|
|
// Map, then loops forever when keys don't match `Str: expr`).
|
|
if k == "LBrace" {
|
|
let no_block: String = state_get("__no_block_expr")
|
|
if str_eq(no_block, "1") {
|
|
// Fall through to fallback — caller will see `{` and treat it
|
|
// as the start of the block they're expecting.
|
|
return make_result({ "expr": "Nil" }, pos)
|
|
}
|
|
let p = pos + 1
|
|
let pairs: [Map<String, Any>] = native_list_empty()
|
|
let running = true
|
|
while running {
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "RBrace" {
|
|
let running = false
|
|
} else {
|
|
if k2 == "Eof" {
|
|
let running = false
|
|
} else {
|
|
// key: Str token
|
|
let key = tok_value(tokens, p)
|
|
let new_p: Int = p + 1
|
|
let new_p = expect(tokens, new_p, "Colon")
|
|
let r = parse_expr(tokens, new_p)
|
|
let val_node = r["node"]
|
|
let new_p = r["pos"]
|
|
let pair = { "key": key, "value": val_node }
|
|
let pairs = native_list_append(pairs, pair)
|
|
let k3 = tok_kind(tokens, new_p)
|
|
if k3 == "Comma" {
|
|
let new_p = new_p + 1
|
|
}
|
|
// Non-progress guard: malformed map content can leave
|
|
// parse_expr returning the same pos. Force advance.
|
|
if new_p <= p {
|
|
let p = p + 1
|
|
} else {
|
|
let p = new_p
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RBrace")
|
|
return make_result({ "expr": "Map", "pairs": pairs }, p)
|
|
}
|
|
|
|
// if expression
|
|
if k == "If" {
|
|
let r = parse_if(tokens, pos)
|
|
return r
|
|
}
|
|
|
|
// match expression
|
|
if k == "Match" {
|
|
let r = parse_match(tokens, pos)
|
|
return r
|
|
}
|
|
|
|
// for expression (used as statement)
|
|
if k == "For" {
|
|
let r = parse_for_expr(tokens, pos)
|
|
return r
|
|
}
|
|
|
|
// Anonymous function literal (lambda): fn(params) -> RetType { body }
|
|
// Used for inline callbacks: dom_listen(el, "click", fn(e: Any) -> Void { ... })
|
|
// Produces a Lambda expression node (distinct from a named FnDef statement).
|
|
if k == "Fn" {
|
|
let p = pos + 1
|
|
let r = parse_params(tokens, p)
|
|
let params = r["params"]
|
|
let p = r["pos"]
|
|
let ret_type = ""
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "Arrow" {
|
|
let p = p + 1
|
|
let kt = tok_kind(tokens, p)
|
|
if kt == "Ident" {
|
|
let ret_type = tok_value(tokens, p)
|
|
}
|
|
let p = skip_type(tokens, p)
|
|
}
|
|
let r2 = parse_block(tokens, p)
|
|
let body = r2["stmts"]
|
|
let p = r2["pos"]
|
|
return make_result({ "expr": "Lambda", "params": params, "body": body, "ret_type": ret_type }, p)
|
|
}
|
|
|
|
// Unary not
|
|
if k == "Not" {
|
|
let r = parse_primary(tokens, pos + 1)
|
|
let inner = r["node"]
|
|
let p = r["pos"]
|
|
return make_result({ "expr": "Not", "inner": inner }, p)
|
|
}
|
|
|
|
// Unary minus
|
|
if k == "Minus" {
|
|
let r = parse_primary(tokens, pos + 1)
|
|
let inner = r["node"]
|
|
let p = r["pos"]
|
|
return make_result({ "expr": "Neg", "inner": inner }, p)
|
|
}
|
|
|
|
// Soft keywords usable as identifiers in expression position. The lexer
|
|
// turns words like `target`, `to`, `via`, `deploy`, etc. into dedicated
|
|
// token kinds for the deploy/retry DSLs, but they're also valid as
|
|
// parameter names and local variables. When one of these appears in
|
|
// expression position (where only an Ident makes sense), treat it as
|
|
// an Ident carrying the original text — otherwise references to a
|
|
// parameter named `target` compile to EL_NULL.
|
|
if k == "Target" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "To" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Via" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Deploy" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Reason" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Times" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Fallback" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Retry" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Parallel" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Trace" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Requires" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Where" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "As" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "With" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Manager" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Engine" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Accessor" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
if k == "Vessel" { return make_result({ "expr": "Ident", "name": v }, pos + 1) }
|
|
|
|
// Fallback: skip unknown token
|
|
make_result({ "expr": "Nil" }, pos + 1)
|
|
}
|
|
|
|
fn parse_if(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let p = expect(tokens, pos, "If")
|
|
// Suppress Map-literal parsing in the cond so a stray `{` (the start
|
|
// of the then-block) isn't gobbled as a Map.
|
|
let prev_no_block: String = state_get("__no_block_expr")
|
|
state_set("__no_block_expr", "1")
|
|
let r = parse_expr(tokens, p)
|
|
state_set("__no_block_expr", prev_no_block)
|
|
let cond = r["node"]
|
|
let p = r["pos"]
|
|
let r2 = parse_block(tokens, p)
|
|
let then_stmts = r2["stmts"]
|
|
let p = r2["pos"]
|
|
let has_else = false
|
|
let else_stmts: [Map<String, Any>] = native_list_empty()
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "Else" {
|
|
let p = p + 1
|
|
let k3 = tok_kind(tokens, p)
|
|
if k3 == "If" {
|
|
// else-if chain: parse as nested if
|
|
let r3 = parse_if(tokens, p)
|
|
let nested = r3["node"]
|
|
let p = r3["pos"]
|
|
let else_stmts = native_list_append(else_stmts, { "stmt": "Expr", "value": nested })
|
|
let has_else = true
|
|
} else {
|
|
let r3 = parse_block(tokens, p)
|
|
let else_stmts = r3["stmts"]
|
|
let p = r3["pos"]
|
|
let has_else = true
|
|
}
|
|
}
|
|
make_result({ "expr": "If", "cond": cond, "then": then_stmts, "else": else_stmts, "has_else": has_else }, p)
|
|
}
|
|
|
|
fn parse_match(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let p = expect(tokens, pos, "Match")
|
|
let prev_no_block: String = state_get("__no_block_expr")
|
|
state_set("__no_block_expr", "1")
|
|
let r = parse_expr(tokens, p)
|
|
state_set("__no_block_expr", prev_no_block)
|
|
let subject = r["node"]
|
|
let p = r["pos"]
|
|
let p = expect(tokens, p, "LBrace")
|
|
let arms: [Map<String, Any>] = native_list_empty()
|
|
let running = true
|
|
while running {
|
|
let k = tok_kind(tokens, p)
|
|
if k == "RBrace" {
|
|
let running = false
|
|
} else {
|
|
if k == "Eof" {
|
|
let running = false
|
|
} else {
|
|
// parse pattern => body
|
|
let r2 = parse_pattern(tokens, p)
|
|
let pattern = r2["node"]
|
|
let p = r2["pos"]
|
|
let p = expect(tokens, p, "FatArrow")
|
|
let r3 = parse_expr(tokens, p)
|
|
let body = r3["node"]
|
|
let p = r3["pos"]
|
|
let arm = { "pattern": pattern, "body": body }
|
|
let arms = native_list_append(arms, arm)
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "Comma" {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RBrace")
|
|
make_result({ "expr": "Match", "subject": subject, "arms": arms }, p)
|
|
}
|
|
|
|
fn parse_pattern(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let k = tok_kind(tokens, pos)
|
|
if k == "Ident" {
|
|
let v = tok_value(tokens, pos)
|
|
if v == "_" {
|
|
return make_result({ "pattern": "Wildcard" }, pos + 1)
|
|
}
|
|
// Check for Enum::Variant pattern (Color::Red, Status::Ok, etc.)
|
|
// Lexed as: Ident ColonColon Ident
|
|
let next_k = tok_kind(tokens, pos + 1)
|
|
if next_k == "ColonColon" {
|
|
let variant_name = tok_value(tokens, pos + 2)
|
|
return make_result({ "pattern": "Variant", "enum_name": v, "variant": variant_name }, pos + 3)
|
|
}
|
|
return make_result({ "pattern": "Binding", "name": v }, pos + 1)
|
|
}
|
|
if k == "Int" {
|
|
return make_result({ "pattern": "LitInt", "value": tok_value(tokens, pos) }, pos + 1)
|
|
}
|
|
if k == "Str" {
|
|
return make_result({ "pattern": "LitStr", "value": tok_value(tokens, pos) }, pos + 1)
|
|
}
|
|
if k == "Bool" {
|
|
return make_result({ "pattern": "LitBool", "value": tok_value(tokens, pos) }, pos + 1)
|
|
}
|
|
// Wildcard _
|
|
make_result({ "pattern": "Wildcard" }, pos + 1)
|
|
}
|
|
|
|
fn parse_for_expr(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let p = expect(tokens, pos, "For")
|
|
let item_name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "In")
|
|
let prev_no_block: String = state_get("__no_block_expr")
|
|
state_set("__no_block_expr", "1")
|
|
let r = parse_expr(tokens, p)
|
|
state_set("__no_block_expr", prev_no_block)
|
|
let list_expr = r["node"]
|
|
let p = r["pos"]
|
|
let r2 = parse_block(tokens, p)
|
|
let body = r2["stmts"]
|
|
let p = r2["pos"]
|
|
make_result({ "expr": "For", "item": item_name, "list": list_expr, "body": body }, p)
|
|
}
|
|
|
|
fn parse_block(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let p = expect(tokens, pos, "LBrace")
|
|
let stmts: [Map<String, Any>] = native_list_empty()
|
|
let running = true
|
|
while running {
|
|
let k = tok_kind(tokens, p)
|
|
if k == "RBrace" {
|
|
let running = false
|
|
} else {
|
|
if k == "Eof" {
|
|
let running = false
|
|
} else {
|
|
let r = parse_stmt(tokens, p)
|
|
let stmt = r["node"]
|
|
let new_p: Int = r["pos"]
|
|
let stmts = native_list_append(stmts, stmt)
|
|
// Non-progress guard: a malformed input (e.g. `||` that
|
|
// dragged the parser into Map-literal mode partway through
|
|
// the if-body) can leave parse_stmt returning the same pos.
|
|
// Force advance so the outer compile doesn't hang.
|
|
if new_p <= p {
|
|
let p = p + 1
|
|
} else {
|
|
let p = new_p
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RBrace")
|
|
{ "stmts": stmts, "pos": p }
|
|
}
|
|
|
|
// ── Postfix expressions (calls, field access, index) ─────────────────────────
|
|
|
|
// is_duration_unit — recognise the postfix unit suffix on a numeric literal.
|
|
// Used by parse_postfix to detect `30.seconds`-shape time literals before
|
|
// falling back to the generic `obj.field` field-access lowering. Singular
|
|
// and plural forms map to the same nanosecond multiplier; codegen does the
|
|
// arithmetic at compile time.
|
|
fn is_duration_unit(name: String) -> Bool {
|
|
if name == "nanos" { return true }
|
|
if name == "nano" { return true }
|
|
if name == "millis" { return true }
|
|
if name == "milli" { return true }
|
|
if name == "millisecond" { return true }
|
|
if name == "milliseconds" { return true }
|
|
if name == "second" { return true }
|
|
if name == "seconds" { return true }
|
|
if name == "minute" { return true }
|
|
if name == "minutes" { return true }
|
|
if name == "hour" { return true }
|
|
if name == "hours" { return true }
|
|
if name == "day" { return true }
|
|
if name == "days" { return true }
|
|
false
|
|
}
|
|
|
|
fn parse_postfix(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let r = parse_primary(tokens, pos)
|
|
let node = r["node"]
|
|
let p = r["pos"]
|
|
|
|
// Postfix duration literal: `<Int>.<unit>` where <unit> is one of
|
|
// nanos | millis | seconds | minutes | hours | days (each with an
|
|
// optional plural). We recognise this before the generic Dot-as-field
|
|
// path so `30.seconds` lowers to a DurationLit AST node carrying the
|
|
// count and the unit, not a field access on an Int.
|
|
let primary_kind: String = node["expr"]
|
|
if primary_kind == "Int" {
|
|
let dot_kind = tok_kind(tokens, p)
|
|
if dot_kind == "Dot" {
|
|
let unit_kind = tok_kind(tokens, p + 1)
|
|
if unit_kind == "Ident" {
|
|
let unit_name = tok_value(tokens, p + 1)
|
|
if is_duration_unit(unit_name) {
|
|
let count_str: String = node["value"]
|
|
let node = { "expr": "DurationLit", "count": count_str, "unit": unit_name }
|
|
let p = p + 2
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let running = true
|
|
while running {
|
|
let k = tok_kind(tokens, p)
|
|
if k == "LParen" {
|
|
// function call
|
|
let p = p + 1
|
|
let args: [Map<String, Any>] = native_list_empty()
|
|
let run2 = true
|
|
while run2 {
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "RParen" {
|
|
let run2 = false
|
|
} else {
|
|
if k2 == "Eof" {
|
|
let run2 = false
|
|
} else {
|
|
let r2 = parse_expr(tokens, p)
|
|
let arg = r2["node"]
|
|
let p = r2["pos"]
|
|
let args = native_list_append(args, arg)
|
|
let k3 = tok_kind(tokens, p)
|
|
if k3 == "Comma" {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RParen")
|
|
let node = { "expr": "Call", "func": node, "args": args }
|
|
} else {
|
|
if k == "Dot" {
|
|
let field = tok_value(tokens, p + 1)
|
|
let p = p + 2
|
|
let node = { "expr": "Field", "object": node, "field": field }
|
|
} else {
|
|
if k == "LBracket" {
|
|
let r2 = parse_expr(tokens, p + 1)
|
|
let idx = r2["node"]
|
|
let p = r2["pos"]
|
|
let p = expect(tokens, p, "RBracket")
|
|
let node = { "expr": "Index", "object": node, "index": idx }
|
|
} else {
|
|
if k == "QuestionMark" {
|
|
let p = p + 1
|
|
let node = { "expr": "Try", "inner": node }
|
|
} else {
|
|
let running = false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
make_result(node, p)
|
|
}
|
|
|
|
// ── Binary expression precedence climbing ────────────────────────────────────
|
|
|
|
fn op_precedence(kind: String) -> Int {
|
|
if kind == "Or" { return 1 }
|
|
if kind == "And" { return 2 }
|
|
if kind == "EqEq" { return 3 }
|
|
if kind == "NotEq" { return 3 }
|
|
if kind == "Lt" { return 4 }
|
|
if kind == "Gt" { return 4 }
|
|
if kind == "LtEq" { return 4 }
|
|
if kind == "GtEq" { return 4 }
|
|
if kind == "Plus" { return 5 }
|
|
if kind == "Minus" { return 5 }
|
|
if kind == "Star" { return 6 }
|
|
if kind == "Slash" { return 6 }
|
|
0
|
|
}
|
|
|
|
fn is_binop(kind: String) -> Bool {
|
|
if kind == "Or" { return true }
|
|
if kind == "And" { return true }
|
|
if kind == "EqEq" { return true }
|
|
if kind == "NotEq" { return true }
|
|
if kind == "Lt" { return true }
|
|
if kind == "Gt" { return true }
|
|
if kind == "LtEq" { return true }
|
|
if kind == "GtEq" { return true }
|
|
if kind == "Plus" { return true }
|
|
if kind == "Minus" { return true }
|
|
if kind == "Star" { return true }
|
|
if kind == "Slash" { return true }
|
|
false
|
|
}
|
|
|
|
fn parse_binop(tokens: [Map<String, Any>], pos: Int, min_prec: Int) -> Map<String, Any> {
|
|
let r = parse_postfix(tokens, pos)
|
|
let left = r["node"]
|
|
let p = r["pos"]
|
|
let running = true
|
|
while running {
|
|
let k = tok_kind(tokens, p)
|
|
let prec = op_precedence(k)
|
|
if is_binop(k) {
|
|
if prec >= min_prec {
|
|
let op = k
|
|
let r2 = parse_binop(tokens, p + 1, prec + 1)
|
|
let right = r2["node"]
|
|
let p = r2["pos"]
|
|
let left = { "expr": "BinOp", "op": op, "left": left, "right": right }
|
|
} else {
|
|
let running = false
|
|
}
|
|
} else {
|
|
let running = false
|
|
}
|
|
}
|
|
make_result(left, p)
|
|
}
|
|
|
|
fn parse_expr(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
parse_binop(tokens, pos, 1)
|
|
}
|
|
|
|
// ── Statement parsing ─────────────────────────────────────────────────────────
|
|
|
|
fn parse_stmt(tokens: [Map<String, Any>], pos: Int) -> Map<String, Any> {
|
|
let k = tok_kind(tokens, pos)
|
|
|
|
// let binding
|
|
if k == "Let" {
|
|
let p = pos + 1
|
|
let name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let ltype = ""
|
|
let k2 = tok_kind(tokens, p)
|
|
// optional type annotation: name: Type — capture the leading
|
|
// identifier so codegen can dispatch arithmetic vs concat on
|
|
// `+` between two typed Idents.
|
|
if k2 == "Colon" {
|
|
let p = p + 1
|
|
let kt = tok_kind(tokens, p)
|
|
if kt == "Ident" {
|
|
let ltype = tok_value(tokens, p)
|
|
}
|
|
let p = skip_type(tokens, p)
|
|
}
|
|
let p = expect(tokens, p, "Eq")
|
|
let r = parse_expr(tokens, p)
|
|
let val = r["node"]
|
|
let p = r["pos"]
|
|
return make_result({ "stmt": "Let", "name": name, "value": val, "type": ltype }, p)
|
|
}
|
|
|
|
// return statement
|
|
if k == "Return" {
|
|
let p = pos + 1
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "RBrace" {
|
|
return make_result({ "stmt": "Return", "value": { "expr": "Nil" } }, p)
|
|
}
|
|
if k2 == "Eof" {
|
|
return make_result({ "stmt": "Return", "value": { "expr": "Nil" } }, p)
|
|
}
|
|
let r = parse_expr(tokens, p)
|
|
let val = r["node"]
|
|
let p = r["pos"]
|
|
return make_result({ "stmt": "Return", "value": val }, p)
|
|
}
|
|
|
|
// extern fn declaration (no body — forward declaration for separate compilation)
|
|
if k == "Extern" {
|
|
let p = pos + 1
|
|
let k2: String = tok_kind(tokens, p)
|
|
if str_eq(k2, "Fn") {
|
|
let p = p + 1
|
|
let name: String = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let r = parse_params(tokens, p)
|
|
let params = r["params"]
|
|
let p = r["pos"]
|
|
let ret_type = ""
|
|
let k3: String = tok_kind(tokens, p)
|
|
if str_eq(k3, "Arrow") {
|
|
let p = p + 1
|
|
let kt: String = tok_kind(tokens, p)
|
|
if str_eq(kt, "Ident") { let ret_type = tok_value(tokens, p) }
|
|
let p = skip_type(tokens, p)
|
|
}
|
|
return make_result({ "stmt": "ExternFn", "name": name, "params": params, "ret_type": ret_type }, p)
|
|
}
|
|
}
|
|
|
|
// fn definition
|
|
if k == "Fn" {
|
|
let p = pos + 1
|
|
let name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let r = parse_params(tokens, p)
|
|
let params = r["params"]
|
|
let p = r["pos"]
|
|
// return type annotation: -> Type. Capture the leading identifier
|
|
// so codegen can distinguish Void-returning functions from value-
|
|
// returning ones. Anything not "Void" is treated as a value type.
|
|
let ret_type = ""
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "Arrow" {
|
|
let p = p + 1
|
|
let kt = tok_kind(tokens, p)
|
|
if kt == "Ident" {
|
|
let ret_type = tok_value(tokens, p)
|
|
}
|
|
let p = skip_type(tokens, p)
|
|
}
|
|
let r2 = parse_block(tokens, p)
|
|
let body = r2["stmts"]
|
|
let p = r2["pos"]
|
|
return make_result({ "stmt": "FnDef", "name": name, "params": params, "body": body, "ret_type": ret_type }, p)
|
|
}
|
|
|
|
// type definition: `type Name = { field: Type, ... }`
|
|
// The `=` between the name and the brace is optional in the spec but
|
|
// present in practice. Skip it if present before consuming the LBrace.
|
|
if k == "Type" {
|
|
let p = pos + 1
|
|
let name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
// Consume optional `=` before the opening brace
|
|
let pk = tok_kind(tokens, p)
|
|
if pk == "Eq" { let p = p + 1 }
|
|
let p = expect(tokens, p, "LBrace")
|
|
let fields: [Map<String, Any>] = native_list_empty()
|
|
let running = true
|
|
while running {
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "RBrace" {
|
|
let running = false
|
|
} else {
|
|
if k2 == "Eof" {
|
|
let running = false
|
|
} else {
|
|
let fname = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "Colon")
|
|
let p = skip_type(tokens, p)
|
|
let fields = native_list_append(fields, { "name": fname })
|
|
let k3 = tok_kind(tokens, p)
|
|
if k3 == "Comma" {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RBrace")
|
|
return make_result({ "stmt": "TypeDef", "name": name, "fields": fields }, p)
|
|
}
|
|
|
|
// enum definition
|
|
if k == "Enum" {
|
|
let p = pos + 1
|
|
let name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "LBrace")
|
|
let variants: [Map<String, Any>] = native_list_empty()
|
|
let running = true
|
|
while running {
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "RBrace" {
|
|
let running = false
|
|
} else {
|
|
if k2 == "Eof" {
|
|
let running = false
|
|
} else {
|
|
let vname = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let variants = native_list_append(variants, { "name": vname })
|
|
let k3 = tok_kind(tokens, p)
|
|
if k3 == "Comma" {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RBrace")
|
|
return make_result({ "stmt": "EnumDef", "name": name, "variants": variants }, p)
|
|
}
|
|
|
|
// import statement
|
|
if k == "Import" {
|
|
let p = pos + 1
|
|
let path = tok_value(tokens, p)
|
|
let p = p + 1
|
|
return make_result({ "stmt": "Import", "path": path }, p)
|
|
}
|
|
|
|
// from ... import { ... }
|
|
if k == "From" {
|
|
let p = pos + 1
|
|
let module_name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
// skip "import" keyword
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "Import" {
|
|
let p = p + 1
|
|
}
|
|
// skip { Name, ... }
|
|
let k3 = tok_kind(tokens, p)
|
|
if k3 == "LBrace" {
|
|
let p = p + 1
|
|
let running = true
|
|
while running {
|
|
let k4 = tok_kind(tokens, p)
|
|
if k4 == "RBrace" {
|
|
let running = false
|
|
} else {
|
|
if k4 == "Eof" {
|
|
let running = false
|
|
} else {
|
|
let p = p + 1
|
|
let k5 = tok_kind(tokens, p)
|
|
if k5 == "Comma" {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RBrace")
|
|
}
|
|
return make_result({ "stmt": "Import", "path": module_name }, p)
|
|
}
|
|
|
|
// while loop
|
|
if k == "While" {
|
|
let p = pos + 1
|
|
let prev_no_block: String = state_get("__no_block_expr")
|
|
state_set("__no_block_expr", "1")
|
|
let r = parse_expr(tokens, p)
|
|
state_set("__no_block_expr", prev_no_block)
|
|
let cond = r["node"]
|
|
let p = r["pos"]
|
|
let r2 = parse_block(tokens, p)
|
|
let body = r2["stmts"]
|
|
let p = r2["pos"]
|
|
return make_result({ "stmt": "While", "cond": cond, "body": body }, p)
|
|
}
|
|
|
|
// for loop
|
|
if k == "For" {
|
|
let p = pos + 1
|
|
let item_name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "In")
|
|
let prev_no_block: String = state_get("__no_block_expr")
|
|
state_set("__no_block_expr", "1")
|
|
let r = parse_expr(tokens, p)
|
|
state_set("__no_block_expr", prev_no_block)
|
|
let list_expr = r["node"]
|
|
let p = r["pos"]
|
|
let r2 = parse_block(tokens, p)
|
|
let body = r2["stmts"]
|
|
let p = r2["pos"]
|
|
return make_result({ "stmt": "For", "item": item_name, "list": list_expr, "body": body }, p)
|
|
}
|
|
|
|
// try/catch statement
|
|
// try { body } catch (name: Type) { handler }
|
|
// The catch variable name and type are both captured; type is skipped.
|
|
if k == "Try" {
|
|
let p = pos + 1
|
|
let r_try = parse_block(tokens, p)
|
|
let try_body = r_try["stmts"]
|
|
let p = r_try["pos"]
|
|
let catch_name = "err"
|
|
let k2 = tok_kind(tokens, p)
|
|
if str_eq(k2, "Catch") {
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "LParen")
|
|
// catch variable name
|
|
let kn = tok_kind(tokens, p)
|
|
if str_eq(kn, "Ident") {
|
|
let catch_name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
}
|
|
// optional type annotation: : Type
|
|
let k3 = tok_kind(tokens, p)
|
|
if str_eq(k3, "Colon") {
|
|
let p = p + 1
|
|
let p = skip_type(tokens, p)
|
|
}
|
|
let p = expect(tokens, p, "RParen")
|
|
let r_catch = parse_block(tokens, p)
|
|
let catch_body = r_catch["stmts"]
|
|
let p = r_catch["pos"]
|
|
return make_result({ "stmt": "TryCatch", "try_body": try_body, "catch_name": catch_name, "catch_body": catch_body }, p)
|
|
}
|
|
return make_result({ "stmt": "TryCatch", "try_body": try_body, "catch_name": catch_name, "catch_body": native_list_empty() }, p)
|
|
}
|
|
|
|
// @decorator — capture decorator name and attach to following stmt
|
|
if k == "At" {
|
|
let p = pos + 1
|
|
let dec_name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let r = parse_stmt(tokens, p)
|
|
let inner = r["node"]
|
|
let p2 = r["pos"]
|
|
let inner_kind: String = inner["stmt"]
|
|
if str_eq(inner_kind, "FnDef") {
|
|
let with_dec = {
|
|
"stmt": "FnDef",
|
|
"name": inner["name"],
|
|
"params": inner["params"],
|
|
"body": inner["body"],
|
|
"ret_type": inner["ret_type"],
|
|
"decorator": dec_name
|
|
}
|
|
return make_result(with_dec, p2)
|
|
}
|
|
return r
|
|
}
|
|
|
|
// cgi block: cgi "name" { field: "val", ... }
|
|
if k == "Cgi" {
|
|
let p = pos + 1
|
|
let name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "LBrace")
|
|
let dharma_id = ""
|
|
let principal = ""
|
|
let network = ""
|
|
let engram = ""
|
|
let has_dharma_id = false
|
|
let has_principal = false
|
|
let has_network = false
|
|
let has_engram = false
|
|
let running = true
|
|
while running {
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "RBrace" {
|
|
let running = false
|
|
} else {
|
|
if k2 == "Eof" {
|
|
let running = false
|
|
} else {
|
|
let fname = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "Colon")
|
|
let fval = tok_value(tokens, p)
|
|
let p = p + 1
|
|
if str_eq(fname, "dharma_id") {
|
|
let dharma_id = fval
|
|
let has_dharma_id = true
|
|
}
|
|
if str_eq(fname, "principal") {
|
|
let principal = fval
|
|
let has_principal = true
|
|
}
|
|
if str_eq(fname, "network") {
|
|
let network = fval
|
|
let has_network = true
|
|
}
|
|
if str_eq(fname, "engram") {
|
|
let engram = fval
|
|
let has_engram = true
|
|
}
|
|
let k3 = tok_kind(tokens, p)
|
|
if k3 == "Comma" {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RBrace")
|
|
return make_result({
|
|
"stmt": "CgiBlock",
|
|
"name": name,
|
|
"dharma_id": dharma_id,
|
|
"principal": principal,
|
|
"network": network,
|
|
"engram": engram,
|
|
"has_dharma_id": has_dharma_id,
|
|
"has_principal": has_principal,
|
|
"has_network": has_network,
|
|
"has_engram": has_engram
|
|
}, p)
|
|
}
|
|
|
|
// service block: service "name" { sponsor: "...", domain: "...", ... }
|
|
//
|
|
// A `service` declaration restricts the program's capabilities at
|
|
// compile time: services CANNOT call self-formation primitives
|
|
// (llm_call_agentic, llm_register_tool, dharma_emit, dharma_field,
|
|
// mindlink-creation). Codegen enforces this with #error directives.
|
|
if k == "Service" {
|
|
let p = pos + 1
|
|
let name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "LBrace")
|
|
let sponsor = ""
|
|
let domain = ""
|
|
let running = true
|
|
while running {
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "RBrace" {
|
|
let running = false
|
|
} else {
|
|
if k2 == "Eof" {
|
|
let running = false
|
|
} else {
|
|
let fname = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let p = expect(tokens, p, "Colon")
|
|
let fval = tok_value(tokens, p)
|
|
let p = p + 1
|
|
if str_eq(fname, "sponsor") {
|
|
let sponsor = fval
|
|
}
|
|
if str_eq(fname, "domain") {
|
|
let domain = fval
|
|
}
|
|
let k3 = tok_kind(tokens, p)
|
|
if k3 == "Comma" {
|
|
let p = p + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let p = expect(tokens, p, "RBrace")
|
|
return make_result({
|
|
"stmt": "ServiceBlock",
|
|
"name": name,
|
|
"sponsor": sponsor,
|
|
"domain": domain
|
|
}, p)
|
|
}
|
|
|
|
// assert statement: assert <expr> or assert <expr>, "msg"
|
|
if k == "Assert" {
|
|
let assert_line: Int = tok_line(tokens, pos)
|
|
let p = pos + 1
|
|
let r = parse_expr(tokens, p)
|
|
let expr_node = r["node"]
|
|
let p = r["pos"]
|
|
let msg = ""
|
|
let k2 = tok_kind(tokens, p)
|
|
if k2 == "Comma" {
|
|
let p = p + 1
|
|
let msg = tok_value(tokens, p)
|
|
let p = p + 1
|
|
}
|
|
return make_result({ "stmt": "Assert", "expr": expr_node, "msg": msg, "line": assert_line }, p)
|
|
}
|
|
|
|
// test block: test "name" { stmts }
|
|
if k == "Test" {
|
|
let test_line: Int = tok_line(tokens, pos)
|
|
let p = pos + 1
|
|
let name = tok_value(tokens, p)
|
|
let p = p + 1
|
|
let r2 = parse_block(tokens, p)
|
|
let body = r2["stmts"]
|
|
let p = r2["pos"]
|
|
return make_result({ "stmt": "TestDef", "name": name, "body": body, "line": test_line }, p)
|
|
}
|
|
|
|
// Bare reassignment: `name = expr`. Handled BEFORE the expression
|
|
// fallback so we don't drop the assign on the floor and emit three
|
|
// orphan expressions (the original silent-miscompile bug). El's `let`
|
|
// already permits redeclaration, so this only applies when the parser
|
|
// sees an Ident followed directly by `=`. `==` is a separate kind
|
|
// (EqEq) so there's no ambiguity.
|
|
if k == "Ident" {
|
|
let k2 = tok_kind(tokens, pos + 1)
|
|
if k2 == "Eq" {
|
|
let name = tok_value(tokens, pos)
|
|
let p = pos + 2
|
|
let r = parse_expr(tokens, p)
|
|
let val = r["node"]
|
|
let p = r["pos"]
|
|
return make_result({ "stmt": "Assign", "name": name, "value": val }, p)
|
|
}
|
|
}
|
|
|
|
// bare expression or if/match statement
|
|
let r = parse_expr(tokens, pos)
|
|
let val = r["node"]
|
|
let p = r["pos"]
|
|
make_result({ "stmt": "Expr", "value": val }, p)
|
|
}
|
|
|
|
// ── Top-level parse ────────────────────────────────────────────────────────────
|
|
|
|
fn parse(tokens: [Map<String, Any>]) -> [Map<String, Any>] {
|
|
let total: Int = native_list_len(tokens)
|
|
let stmts: [Map<String, Any>] = native_list_empty()
|
|
let pos: Int = 0
|
|
let running = true
|
|
while running {
|
|
if pos >= total {
|
|
let running = false
|
|
} else {
|
|
let k = tok_kind(tokens, pos)
|
|
if k == "Eof" {
|
|
let running = false
|
|
} else {
|
|
let r = parse_stmt(tokens, pos)
|
|
let stmt = r["node"]
|
|
let new_pos: Int = r["pos"]
|
|
let stmts = native_list_append(stmts, stmt)
|
|
// Guard against infinite loops — if pos didn't advance, force it
|
|
if new_pos <= pos {
|
|
let pos = pos + 1
|
|
} else {
|
|
let pos = new_pos
|
|
}
|
|
}
|
|
}
|
|
}
|
|
stmts
|
|
}
|
|
// codegen.el - El compiler C source code generator
|
|
//
|
|
// Input: list of AST statement maps (from parser.el)
|
|
// Output: C source printed to stdout (streamed, one line at a time)
|
|
//
|
|
// Each El program compiles to a single .c file that #includes el_runtime.h.
|
|
// Functions map directly to C functions; top-level statements become main().
|
|
//
|
|
// Entry point: fn codegen(stmts: [Map<String, Any>], source: String) -> String
|
|
// Returns "" - output goes to stdout via println().
|
|
//
|
|
// Streaming output avoids O(n-) string concatenation: each emitted line is
|
|
// printed immediately rather than appended to a growing string.
|
|
|
|
// -- String helpers ------------------------------------------------------------
|
|
|
|
// Escape a C string literal (double-quotes and backslashes).
|
|
// Hex-encode a single nibble (0-15) as a lowercase hex character.
|
|
fn nibble_to_hex(n: Int) -> String {
|
|
str_char_at("0123456789abcdef", n)
|
|
}
|
|
|
|
// Encode a byte value (0-255) as a two-character hex string.
|
|
fn byte_to_hex2(b: Int) -> String {
|
|
let hi: Int = (b / 16)
|
|
let lo: Int = (b - hi * 16)
|
|
nibble_to_hex(hi) + nibble_to_hex(lo)
|
|
}
|
|
|
|
// Return true if the byte value is a C hex digit (0-9, a-f, A-F).
|
|
// Used to determine whether a \xNN escape needs a string-literal split
|
|
// to prevent the C preprocessor from greedily consuming following hex chars.
|
|
fn is_hex_digit_byte(b: Int) -> Bool {
|
|
if b >= 48 { if b <= 57 { return true } } // 0-9
|
|
if b >= 65 { if b <= 70 { return true } } // A-F
|
|
if b >= 97 { if b <= 102 { return true } } // a-f
|
|
false
|
|
}
|
|
|
|
fn c_escape(s: String) -> String {
|
|
// Use index-based byte scanning via str_char_code(s, i) and str_char_at(s, i).
|
|
// This avoids native_string_chars + str_join, which corrupts high-byte (>= 0x80)
|
|
// characters because list_join's looks_like_string heuristic rejects strings
|
|
// whose first byte is >= 0x7F and emits them as decimal pointer values instead.
|
|
//
|
|
// IMPORTANT: after a \xNN hex escape, if the next byte is a hex digit
|
|
// (0-9, a-f, A-F), we emit `""` to split the C string literal so the C
|
|
// compiler does not greedily read extra hex digits as part of the escape.
|
|
// E.g. "\xad" followed by "bamos" must become "\xad" "bamos" because 'b'
|
|
// is a hex digit and C would otherwise read "\xadb" (= 0xADB, out of range).
|
|
let total: Int = str_len(s)
|
|
let parts: [String] = native_list_empty()
|
|
let i: Int = 0
|
|
let prev_was_hex_escape: Bool = false
|
|
while i < total {
|
|
let bval: Int = str_char_code(s, i)
|
|
// If the previous token was a \xNN escape and the current byte is a
|
|
// hex digit, insert an empty string literal ("") to break the escape.
|
|
if prev_was_hex_escape {
|
|
if is_hex_digit_byte(bval) {
|
|
let parts = native_list_append(parts, "\"\"")
|
|
}
|
|
}
|
|
let prev_was_hex_escape = false
|
|
if bval == 34 {
|
|
// 34 = '"'
|
|
let parts = native_list_append(parts, "\\\"")
|
|
} else {
|
|
if bval == 92 {
|
|
// 92 = '\\'
|
|
let parts = native_list_append(parts, "\\\\")
|
|
} else {
|
|
if bval == 10 {
|
|
// 10 = '\n'
|
|
let parts = native_list_append(parts, "\\n")
|
|
} else {
|
|
if bval == 13 {
|
|
// 13 = '\r'
|
|
let parts = native_list_append(parts, "\\r")
|
|
} else {
|
|
if bval == 9 {
|
|
// 9 = '\t'
|
|
let parts = native_list_append(parts, "\\t")
|
|
} else {
|
|
if bval >= 128 {
|
|
// Escape non-ASCII bytes (>= 0x80) as \xNN so
|
|
// Clang does not misinterpret multi-byte UTF-8
|
|
// sequences in C string literals.
|
|
let parts = native_list_append(parts, "\\x" + byte_to_hex2(bval))
|
|
let prev_was_hex_escape = true
|
|
} else {
|
|
let parts = native_list_append(parts, str_char_at(s, i))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
str_join(parts, "")
|
|
}
|
|
|
|
fn c_str_lit(s: String) -> String {
|
|
"\"" + c_escape(s) + "\""
|
|
}
|
|
|
|
// -- Type mapping --------------------------------------------------------------
|
|
|
|
fn el_type_to_c(type_str: String) -> String {
|
|
if type_str == "String" { return "const char*" }
|
|
if type_str == "Int" { return "int64_t" }
|
|
if type_str == "Bool" { return "int" }
|
|
if type_str == "Float" { return "double" }
|
|
if type_str == "Void" { return "void" }
|
|
if type_str == "void" { return "void" }
|
|
"void*"
|
|
}
|
|
|
|
// -- Code emission -------------------------------------------------------------
|
|
//
|
|
// emit_line/emit_blank stream output directly via println.
|
|
// This avoids building a large string in memory.
|
|
|
|
fn emit_line(line: String) -> Void {
|
|
println(line)
|
|
}
|
|
|
|
fn emit_blank() -> Void {
|
|
println("")
|
|
}
|
|
|
|
// -- Operator helpers ----------------------------------------------------------
|
|
|
|
fn binop_to_c(op: String) -> String {
|
|
if op == "Plus" { return "+" }
|
|
if op == "Minus" { return "-" }
|
|
if op == "Star" { return "*" }
|
|
if op == "Slash" { return "/" }
|
|
if op == "EqEq" { return "==" }
|
|
if op == "NotEq" { return "!=" }
|
|
if op == "Lt" { return "<" }
|
|
if op == "Gt" { return ">" }
|
|
if op == "LtEq" { return "<=" }
|
|
if op == "GtEq" { return ">=" }
|
|
if op == "And" { return "&&" }
|
|
if op == "Or" { return "||" }
|
|
op
|
|
}
|
|
|
|
// -- Expression codegen --------------------------------------------------------
|
|
//
|
|
// cg_expr returns a C expression string (not a statement).
|
|
|
|
// duration_unit_nanos - multiplier from a postfix-literal unit name to
|
|
// nanoseconds. Singular and plural forms collapse to the same multiplier;
|
|
// the parser already restricted `unit` to the set is_duration_unit accepts.
|
|
// Returns the multiplier as a decimal string suitable for splicing into
|
|
// the generated C as a literal int64 expression.
|
|
fn duration_unit_nanos(unit: String) -> String {
|
|
if str_eq(unit, "nano") { return "1LL" }
|
|
if str_eq(unit, "nanos") { return "1LL" }
|
|
if str_eq(unit, "milli") { return "1000000LL" }
|
|
if str_eq(unit, "millis") { return "1000000LL" }
|
|
if str_eq(unit, "millisecond") { return "1000000LL" }
|
|
if str_eq(unit, "milliseconds") { return "1000000LL" }
|
|
if str_eq(unit, "second") { return "1000000000LL" }
|
|
if str_eq(unit, "seconds") { return "1000000000LL" }
|
|
if str_eq(unit, "minute") { return "60000000000LL" }
|
|
if str_eq(unit, "minutes") { return "60000000000LL" }
|
|
if str_eq(unit, "hour") { return "3600000000000LL" }
|
|
if str_eq(unit, "hours") { return "3600000000000LL" }
|
|
if str_eq(unit, "day") { return "86400000000000LL" }
|
|
if str_eq(unit, "days") { return "86400000000000LL" }
|
|
"1LL"
|
|
}
|
|
|
|
// ── HTML template codegen ─────────────────────────────────────────────────
|
|
//
|
|
// cg_html_template(expr) emits a C statement-expression `({ ... })` that
|
|
// builds the HTML string by chaining el_str_concat calls.
|
|
//
|
|
// Interpolated values are passed through html_escape(); the raw() form
|
|
// bypasses escaping. {#each} blocks compile to C for-loops that index into
|
|
// the list with el_list_get / el_list_len.
|
|
//
|
|
// A per-template accumulator variable `_html_N` holds the growing string.
|
|
// A global counter stored in state keeps names unique.
|
|
|
|
fn next_html_id() -> String {
|
|
let csv: String = state_get("__html_counter")
|
|
let n = 0
|
|
if !str_eq(csv, "") {
|
|
let n = str_to_int(csv)
|
|
}
|
|
let n = n + 1
|
|
state_set("__html_counter", native_int_to_str(n))
|
|
native_int_to_str(n)
|
|
}
|
|
|
|
// Emit children nodes into a flat list of C fragment strings (parts).
|
|
// Each part is either a static string fragment (already C-literal form) or
|
|
// a dynamic expression that produces an el_val_t string.
|
|
// We build them all into parts, then the caller wraps with concat chain.
|
|
|
|
fn cg_html_parts(children: [Map<String, Any>], acc_var: String) -> String {
|
|
let n: Int = native_list_len(children)
|
|
let i = 0
|
|
let out = ""
|
|
while i < n {
|
|
let child: Map<String, Any> = native_list_get(children, i)
|
|
let html_kind: String = child["html"]
|
|
if str_eq(html_kind, "Text") {
|
|
let text: String = child["text"]
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", EL_STR(" + c_str_lit(text) + ")); "
|
|
}
|
|
if str_eq(html_kind, "Doctype") {
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", EL_STR(\"<!doctype html>\")); "
|
|
}
|
|
if str_eq(html_kind, "Interp") {
|
|
let val_node = child["value"]
|
|
let val_c: String = cg_expr(val_node)
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", html_escape(" + val_c + ")); "
|
|
}
|
|
if str_eq(html_kind, "Raw") {
|
|
let val_node = child["value"]
|
|
let val_c: String = cg_expr(val_node)
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", html_raw(" + val_c + ")); "
|
|
}
|
|
if str_eq(html_kind, "Element") {
|
|
let elem_c: String = cg_html_element_str(child, acc_var)
|
|
let out = out + elem_c
|
|
}
|
|
if str_eq(html_kind, "Each") {
|
|
let each_c: String = cg_html_each(child, acc_var)
|
|
let out = out + each_c
|
|
}
|
|
let i = i + 1
|
|
}
|
|
out
|
|
}
|
|
|
|
// Generate open-tag attribute fragments inline.
|
|
// Parser stores attrs with "kind": "static" | "dynamic" | "bool".
|
|
// Static: "value" is the raw string value (not an expr node).
|
|
// Dynamic: "value" is an expr node.
|
|
// Bool: no "value" field.
|
|
fn cg_html_attrs_str(attrs: [Map<String, Any>], acc_var: String) -> String {
|
|
let n: Int = native_list_len(attrs)
|
|
let i = 0
|
|
let out = ""
|
|
// Closing-quote snippet: EL_STR("\"") in C text.
|
|
let close_q: String = "EL_STR(" + c_str_lit("\"") + ")"
|
|
while i < n {
|
|
let attr: Map<String, Any> = native_list_get(attrs, i)
|
|
let attr_name: String = attr["name"]
|
|
let kind: String = attr["kind"]
|
|
// Build: EL_STR(" name=\"")
|
|
let open_val: String = " " + attr_name + "=\""
|
|
let open_attr: String = "EL_STR(" + c_str_lit(open_val) + ")"
|
|
if str_eq(kind, "static") {
|
|
// Static attribute: value is a raw string.
|
|
let sv: String = attr["value"]
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", " + open_attr + "); "
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", EL_STR(" + c_str_lit(sv) + ")); "
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", " + close_q + "); "
|
|
} else {
|
|
if str_eq(kind, "dynamic") {
|
|
// Dynamic attribute: value is an expr node — html_escape it.
|
|
let val_node = attr["value"]
|
|
let val_c: String = cg_expr(val_node)
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", " + open_attr + "); "
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", html_escape(" + val_c + ")); "
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", " + close_q + "); "
|
|
} else {
|
|
// Boolean attribute (no value): emit " name"
|
|
let bool_attr: String = "EL_STR(" + c_str_lit(" " + attr_name) + ")"
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", " + bool_attr + "); "
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
out
|
|
}
|
|
|
|
// Generate code for a single element, appending into acc_var.
|
|
fn cg_html_element_str(elem: Map<String, Any>, acc_var: String) -> String {
|
|
let tag: String = elem["tag"]
|
|
let attrs: [Map<String, Any>] = elem["attrs"]
|
|
let children: [Map<String, Any>] = elem["children"]
|
|
let self_closing: Bool = elem["self_closing"]
|
|
// Open tag: <tagname
|
|
let out = acc_var + " = el_str_concat(" + acc_var + ", EL_STR(\"<" + tag + "\")); "
|
|
let out = out + cg_html_attrs_str(attrs, acc_var)
|
|
if self_closing {
|
|
// Self-closing void element: />
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", EL_STR(\"/>\")); "
|
|
} else {
|
|
// Close open tag: >
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", EL_STR(\">\")); "
|
|
let out = out + cg_html_parts(children, acc_var)
|
|
let out = out + acc_var + " = el_str_concat(" + acc_var + ", EL_STR(\"</" + tag + ">\")); "
|
|
}
|
|
out
|
|
}
|
|
|
|
// Generate code for {#each list as item} ... {/each}.
|
|
fn cg_html_each(node: Map<String, Any>, acc_var: String) -> String {
|
|
let list_expr = node["list"]
|
|
let item_name: String = node["item"]
|
|
let body_children: [Map<String, Any>] = node["body"]
|
|
let id: String = next_html_id()
|
|
let list_var: String = "_html_list_" + id
|
|
let len_var: String = "_html_len_" + id
|
|
let idx_var: String = "_html_i_" + id
|
|
let list_c: String = cg_expr(list_expr)
|
|
let inner_c: String = cg_html_parts(body_children, acc_var)
|
|
// Emit: { el_val_t _list = expr; int _len = el_list_len(_list);
|
|
// for (int _i = 0; _i < _len; _i++) {
|
|
// el_val_t item = el_list_get(_list, _i); inner_c } }
|
|
"{ el_val_t " + list_var + " = (" + list_c + "); el_val_t " + len_var + " = el_list_len(" + list_var + "); for (el_val_t " + idx_var + " = 0; " + idx_var + " < " + len_var + "; " + idx_var + "++) { el_val_t " + item_name + " = el_list_get(" + list_var + ", " + idx_var + "); " + inner_c + "} } "
|
|
}
|
|
|
|
// Top-level HTML template codegen — returns a C statement-expression string.
|
|
fn cg_html_template(expr: Map<String, Any>) -> String {
|
|
let root = expr["root"]
|
|
let id: String = next_html_id()
|
|
let acc: String = "_html_" + id
|
|
// If the root element has doctype:true the parser tagged it from <!doctype html>
|
|
let doctype_flag: Bool = root["doctype"]
|
|
let doctype_prefix: String = ""
|
|
if doctype_flag {
|
|
let doctype_prefix = acc + " = el_str_concat(" + acc + ", EL_STR(\"<!doctype html>\")); "
|
|
}
|
|
let body: String = cg_html_element_str(root, acc)
|
|
"({ el_val_t " + acc + " = EL_STR(\"\"); " + doctype_prefix + body + acc + "; })"
|
|
}
|
|
|
|
fn cg_expr(expr: Map<String, Any>) -> String {
|
|
let kind: String = expr["expr"]
|
|
|
|
if kind == "Int" {
|
|
let v: String = expr["value"]
|
|
return v
|
|
}
|
|
|
|
// DurationLit - postfix-literal time value (e.g. 30.seconds, 1.hour).
|
|
// Lowered to a literal int64 nanosecond count, wrapped in the runtime
|
|
// entry point so the intent is explicit at the C level. The arithmetic
|
|
// is fully constant-folded by any optimising C compiler.
|
|
if kind == "DurationLit" {
|
|
let count: String = expr["count"]
|
|
let unit: String = expr["unit"]
|
|
let mult: String = duration_unit_nanos(unit)
|
|
return "el_duration_from_nanos((el_val_t)(" + count + "LL * " + mult + "))"
|
|
}
|
|
|
|
if kind == "Float" {
|
|
// Wrap Float literals in el_from_float() so the bit pattern is
|
|
// preserved through the el_val_t (int64) slot. Without this,
|
|
// implicit double->int64 conversion in C truncates `0.8` to `0`
|
|
// when passed to a builtin that expects el_val_t.
|
|
let v: String = expr["value"]
|
|
return "el_from_float(" + v + ")"
|
|
}
|
|
|
|
if kind == "Str" {
|
|
let v: String = expr["value"]
|
|
return "EL_STR(" + c_str_lit(v) + ")"
|
|
}
|
|
|
|
if kind == "Bool" {
|
|
let v: String = expr["value"]
|
|
if v == "true" { return "1" }
|
|
return "0"
|
|
}
|
|
|
|
if kind == "Nil" {
|
|
return "EL_NULL"
|
|
}
|
|
|
|
if kind == "Ident" {
|
|
let name: String = expr["name"]
|
|
return name
|
|
}
|
|
|
|
if kind == "Not" {
|
|
let inner = expr["inner"]
|
|
let inner_c: String = cg_expr(inner)
|
|
return "!" + inner_c
|
|
}
|
|
|
|
if kind == "Neg" {
|
|
let inner = expr["inner"]
|
|
let inner_c: String = cg_expr(inner)
|
|
return "(-" + inner_c + ")"
|
|
}
|
|
|
|
if kind == "BinOp" {
|
|
let op: String = expr["op"]
|
|
let left = expr["left"]
|
|
let right = expr["right"]
|
|
let left_c: String = cg_expr(left)
|
|
let right_c: String = cg_expr(right)
|
|
let left_kind: String = left["expr"]
|
|
let right_kind: String = right["expr"]
|
|
|
|
// -- String/equality fast-path: skip O(N-) temporal traversals --------
|
|
// The 10 temporal predicates below each recurse into the left subtree:
|
|
// O(depth) state_get calls per predicate, O(N-) total for a chain of N
|
|
// string-concat BinOps (e.g. the 70-100-part HTML chains in soul.el).
|
|
// When either operand is a bare Str literal the result is always concat
|
|
// or str_eq - no temporal dispatch is possible. Exit immediately.
|
|
if str_eq(op, "Plus") {
|
|
if str_eq(left_kind, "Str") { return "el_str_concat(" + left_c + ", " + right_c + ")" }
|
|
if str_eq(right_kind, "Str") { return "el_str_concat(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
if str_eq(op, "EqEq") {
|
|
if str_eq(left_kind, "Str") { return "str_eq(" + left_c + ", " + right_c + ")" }
|
|
if str_eq(right_kind, "Str") { return "str_eq(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
if str_eq(op, "NotEq") {
|
|
if str_eq(left_kind, "Str") { return "!str_eq(" + left_c + ", " + right_c + ")" }
|
|
if str_eq(right_kind, "Str") { return "!str_eq(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
|
|
// -- Temporal-type dispatch (Instant + Duration first-class) --------
|
|
// Run BEFORE the int / string / generic paths so typed temporal
|
|
// operands route through the runtime wrappers and invalid combos
|
|
// become #error directives rather than silently falling through to
|
|
// raw int arithmetic. The wrappers are no-op casts at the C level
|
|
// but make the intent explicit and centralise future changes (e.g.
|
|
// saturating arithmetic, overflow guards).
|
|
let left_is_inst: Bool = is_instant_expr(left)
|
|
let right_is_inst: Bool = is_instant_expr(right)
|
|
let left_is_dur: Bool = is_duration_expr(left)
|
|
let right_is_dur: Bool = is_duration_expr(right)
|
|
|
|
// Phase 1.5 LocalDate / LocalTime / CalendarTime dispatch. These
|
|
// route through their typed runtime wrappers (el_local_date_add_dur,
|
|
// el_local_time_add_dur, el_local_date_lt, el_local_date_eq) and
|
|
// forbid mismatched ops at codegen time. Cross-calendar arithmetic
|
|
// (CalendarTime + CalendarTime, CalendarTime - CalendarTime under
|
|
// mismatched calendars) is structurally meaningless: a CalendarTime
|
|
// already projects an Instant under a Calendar, so subtraction
|
|
// between two of them only makes sense in instant-space (use
|
|
// cal_to_instant first).
|
|
let left_is_ld: Bool = is_localdate_expr(left)
|
|
let right_is_ld: Bool = is_localdate_expr(right)
|
|
let left_is_lt: Bool = is_localtime_expr(left)
|
|
let right_is_lt: Bool = is_localtime_expr(right)
|
|
let left_is_ct: Bool = is_caltime_expr(left)
|
|
let right_is_ct: Bool = is_caltime_expr(right)
|
|
if left_is_ld {
|
|
if op == "Plus" {
|
|
if right_is_dur {
|
|
return "el_local_date_add_dur(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
if op == "Lt" {
|
|
if right_is_ld { return "el_local_date_lt(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
if op == "EqEq" {
|
|
if right_is_ld { return "el_local_date_eq(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
}
|
|
if left_is_lt {
|
|
if op == "Plus" {
|
|
if right_is_dur {
|
|
return "el_local_time_add_dur(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
}
|
|
if left_is_ct {
|
|
if op == "Plus" {
|
|
if right_is_ct {
|
|
time_record_violation("caltime_plus_caltime", "CalendarTime + CalendarTime is not allowed (use cal_to_instant + Duration)")
|
|
return "0 /* TIME_TYPE_ERROR: CalendarTime + CalendarTime */"
|
|
}
|
|
}
|
|
}
|
|
|
|
let any_temporal: Bool = false
|
|
if left_is_inst { let any_temporal = true }
|
|
if right_is_inst { let any_temporal = true }
|
|
if left_is_dur { let any_temporal = true }
|
|
if right_is_dur { let any_temporal = true }
|
|
if any_temporal {
|
|
if op == "Plus" {
|
|
if left_is_inst {
|
|
if right_is_dur {
|
|
return "el_instant_add_dur(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_is_inst {
|
|
time_record_violation("instant_plus_instant", "Instant + Instant is not allowed")
|
|
return "0 /* TIME_TYPE_ERROR: Instant + Instant */"
|
|
}
|
|
}
|
|
if left_is_dur {
|
|
if right_is_inst {
|
|
return "el_instant_add_dur(" + right_c + ", " + left_c + ")"
|
|
}
|
|
if right_is_dur {
|
|
return "el_duration_add(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if is_int_expr(right) {
|
|
time_record_violation("duration_plus_int", "Duration + Int is not allowed (use duration_seconds(n) or N.seconds)")
|
|
return "0 /* TIME_TYPE_ERROR: Duration + Int */"
|
|
}
|
|
}
|
|
if right_is_dur {
|
|
if is_int_expr(left) {
|
|
time_record_violation("duration_plus_int", "Int + Duration is not allowed")
|
|
return "0 /* TIME_TYPE_ERROR: Int + Duration */"
|
|
}
|
|
}
|
|
}
|
|
if op == "Minus" {
|
|
if left_is_inst {
|
|
if right_is_dur {
|
|
return "el_instant_sub_dur(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_is_inst {
|
|
return "el_instant_diff(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
if left_is_dur {
|
|
if right_is_dur {
|
|
return "el_duration_sub(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if is_int_expr(right) {
|
|
time_record_violation("duration_minus_int", "Duration - Int is not allowed")
|
|
return "0 /* TIME_TYPE_ERROR: Duration - Int */"
|
|
}
|
|
}
|
|
}
|
|
if op == "Star" {
|
|
if left_is_dur {
|
|
if is_int_expr(right) {
|
|
return "el_duration_scale(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
if right_is_dur {
|
|
if is_int_expr(left) {
|
|
return "el_duration_scale(" + right_c + ", " + left_c + ")"
|
|
}
|
|
}
|
|
}
|
|
if op == "Slash" {
|
|
if left_is_dur {
|
|
if is_int_expr(right) {
|
|
return "el_duration_div(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
}
|
|
// Comparisons. Cross-type comparisons are forbidden.
|
|
if op == "Lt" {
|
|
if left_is_inst {
|
|
if right_is_inst { return "el_instant_lt(" + left_c + ", " + right_c + ")" }
|
|
if right_is_dur {
|
|
time_record_violation("instant_cmp_duration", "Instant < Duration is not allowed")
|
|
return "0 /* TIME_TYPE_ERROR: Instant < Duration */"
|
|
}
|
|
}
|
|
if left_is_dur {
|
|
if right_is_dur { return "el_duration_lt(" + left_c + ", " + right_c + ")" }
|
|
if right_is_inst {
|
|
time_record_violation("duration_cmp_instant", "Duration < Instant is not allowed")
|
|
return "0 /* TIME_TYPE_ERROR: Duration < Instant */"
|
|
}
|
|
}
|
|
}
|
|
if op == "LtEq" {
|
|
if left_is_inst {
|
|
if right_is_inst { return "el_instant_le(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
if left_is_dur {
|
|
if right_is_dur { return "el_duration_le(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
}
|
|
if op == "Gt" {
|
|
if left_is_inst {
|
|
if right_is_inst { return "el_instant_gt(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
if left_is_dur {
|
|
if right_is_dur { return "el_duration_gt(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
}
|
|
if op == "GtEq" {
|
|
if left_is_inst {
|
|
if right_is_inst { return "el_instant_ge(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
if left_is_dur {
|
|
if right_is_dur { return "el_duration_ge(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
}
|
|
if op == "EqEq" {
|
|
if left_is_inst {
|
|
if right_is_inst { return "el_instant_eq(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
if left_is_dur {
|
|
if right_is_dur { return "el_duration_eq(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
}
|
|
if op == "NotEq" {
|
|
if left_is_inst {
|
|
if right_is_inst { return "el_instant_ne(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
if left_is_dur {
|
|
if right_is_dur { return "el_duration_ne(" + left_c + ", " + right_c + ")" }
|
|
}
|
|
}
|
|
// Fall through - let the existing path handle anything we
|
|
// didn't explicitly cover (typically string-concat with a
|
|
// typed temporal value, e.g. for debug prints, which works
|
|
// because both share the int64 slot).
|
|
}
|
|
|
|
if op == "Plus" {
|
|
// If either side is a string literal, always concat
|
|
if left_kind == "Str" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Str" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
// Type-driven dispatch via recursive is_int_expr: any expression
|
|
// whose value is provably Int (literal, typed Ident, known-Int
|
|
// builtin, or BinOp arithmetic over Ints) participates in
|
|
// arithmetic, not string concat. Recursion into BinOp lets
|
|
// `a + b + c` (chained Int adds) and `acc * 16 + d` route to
|
|
// arithmetic instead of falling to el_str_concat - both sides
|
|
// are Int so the outer `+` is too.
|
|
if is_int_expr(left) {
|
|
if is_int_expr(right) {
|
|
let op_c: String = binop_to_c(op)
|
|
return "(" + left_c + " " + op_c + " " + right_c + ")"
|
|
}
|
|
}
|
|
// Mixed cases: at least one side is provably Int but the other
|
|
// is not provably anything. Historical heuristic biases to
|
|
// arithmetic when a literal Int is present (preserves prior
|
|
// behaviour for `pos + 1` where `pos` is an untyped param).
|
|
if left_kind == "Int" {
|
|
let op_c: String = binop_to_c(op)
|
|
return "(" + left_c + " " + op_c + " " + right_c + ")"
|
|
}
|
|
if right_kind == "Int" {
|
|
let op_c: String = binop_to_c(op)
|
|
return "(" + left_c + " " + op_c + " " + right_c + ")"
|
|
}
|
|
// Otherwise: BinOp(+) with a Call/Ident side without int-typed
|
|
// evidence - fall back to string concat (the historical default).
|
|
if left_kind == "Call" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Call" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if left_kind == "BinOp" {
|
|
let left_op: String = left["op"]
|
|
if left_op == "Plus" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
if right_kind == "BinOp" {
|
|
let right_op: String = right["op"]
|
|
if right_op == "Plus" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
if left_kind == "Ident" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Ident" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
|
|
// String equality: use str_eq() when either side is a string literal or ident.
|
|
// Use plain == when comparing integer literals OR when both sides are
|
|
// identifiers tracked in __int_names (typed Int via `let x: Int = ...`).
|
|
// Without the int-name check, `seen == idx` between two Int locals
|
|
// miscompiles to str_eq(seen, idx), strcmp'ing what are integer values
|
|
// dressed as char* - segfault on the first non-printable byte.
|
|
if op == "EqEq" {
|
|
if left_kind == "Int" {
|
|
return "(" + left_c + " == " + right_c + ")"
|
|
}
|
|
if right_kind == "Int" {
|
|
return "(" + left_c + " == " + right_c + ")"
|
|
}
|
|
if left_kind == "Bool" {
|
|
return "(" + left_c + " == " + right_c + ")"
|
|
}
|
|
if right_kind == "Bool" {
|
|
return "(" + left_c + " == " + right_c + ")"
|
|
}
|
|
if left_kind == "Ident" {
|
|
if right_kind == "Ident" {
|
|
let lname: String = left["name"]
|
|
let rname: String = right["name"]
|
|
if is_int_name(lname) {
|
|
if is_int_name(rname) {
|
|
return "(" + left_c + " == " + right_c + ")"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Extend int-equality to mixed Ident/BinOp cases: `i == n - 1`
|
|
// where the left is an int-name Ident and the right is an
|
|
// arithmetic BinOp (or vice-versa). Without this check the
|
|
// fallthrough to str_eq produces str_eq(int_value, int_value)
|
|
// which reads the integer as a char* and segfaults.
|
|
if is_int_expr(left) {
|
|
if is_int_expr(right) {
|
|
return "(" + left_c + " == " + right_c + ")"
|
|
}
|
|
}
|
|
if left_kind == "Str" {
|
|
return "str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Str" {
|
|
return "str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if left_kind == "Ident" {
|
|
return "str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Ident" {
|
|
return "str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if left_kind == "Call" {
|
|
return "str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Call" {
|
|
return "str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
|
|
if op == "NotEq" {
|
|
if left_kind == "Int" {
|
|
return "(" + left_c + " != " + right_c + ")"
|
|
}
|
|
if right_kind == "Int" {
|
|
return "(" + left_c + " != " + right_c + ")"
|
|
}
|
|
if left_kind == "Bool" {
|
|
return "(" + left_c + " != " + right_c + ")"
|
|
}
|
|
if right_kind == "Bool" {
|
|
return "(" + left_c + " != " + right_c + ")"
|
|
}
|
|
if left_kind == "Ident" {
|
|
if right_kind == "Ident" {
|
|
let lname: String = left["name"]
|
|
let rname: String = right["name"]
|
|
if is_int_name(lname) {
|
|
if is_int_name(rname) {
|
|
return "(" + left_c + " != " + right_c + ")"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Same mixed Ident/BinOp fix as EqEq: use is_int_expr to detect
|
|
// integer-typed operands before falling through to !str_eq.
|
|
if is_int_expr(left) {
|
|
if is_int_expr(right) {
|
|
return "(" + left_c + " != " + right_c + ")"
|
|
}
|
|
}
|
|
if left_kind == "Str" {
|
|
return "!str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Str" {
|
|
return "!str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if left_kind == "Ident" {
|
|
return "!str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Ident" {
|
|
return "!str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if left_kind == "Call" {
|
|
return "!str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Call" {
|
|
return "!str_eq(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
|
|
let op_c: String = binop_to_c(op)
|
|
return "(" + left_c + " " + op_c + " " + right_c + ")"
|
|
}
|
|
|
|
if kind == "Call" {
|
|
let func = expr["func"]
|
|
let args = expr["args"]
|
|
let arity: Int = native_list_len(args)
|
|
let func_kind: String = func["expr"]
|
|
|
|
let args_parts: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < arity {
|
|
let arg = native_list_get(args, i)
|
|
let arg_c: String = cg_expr(arg)
|
|
let args_parts = native_list_append(args_parts, arg_c)
|
|
let i = i + 1
|
|
}
|
|
let args_c: String = str_join(args_parts, ", ")
|
|
|
|
if func_kind == "Ident" {
|
|
let fn_name: String = func["name"]
|
|
// Capability-kind enforcement: services can't call
|
|
// self-formation primitives; utilities can't call any
|
|
// DHARMA or LLM primitives. cap_check_call records
|
|
// violations to be emitted as #error directives at the
|
|
// top of the generated C, so cc fails with a clear msg.
|
|
cap_check_call(fn_name)
|
|
// Arity check against the builtin table - refuse, with a clear
|
|
// El-source message, when a known builtin gets the wrong arg
|
|
// count (e.g. `http_serve(port)` instead of `http_serve(port,
|
|
// handler)`). User-defined fns and variadic builtins pass
|
|
// through (builtin_arity returns -1).
|
|
arity_check_call(fn_name, arity)
|
|
// sleep(Duration) - Phase 1 of the typed-time work. When the
|
|
// single arg is provably a Duration we lower to el_sleep_duration
|
|
// so the runtime sees nanos directly. Existing sleep() callers
|
|
// that pass an Int still emit `sleep(<int>)`, which falls through
|
|
// to the no-such-symbol path - those call sites must migrate to
|
|
// a typed Duration. Acceptable: the spec marks them out for an
|
|
// audit pass during Phase 1.
|
|
if str_eq(fn_name, "sleep") {
|
|
if arity == 1 {
|
|
let only_arg = native_list_get(args, 0)
|
|
if is_duration_expr(only_arg) {
|
|
return "el_sleep_duration(" + args_c + ")"
|
|
}
|
|
}
|
|
}
|
|
// el_from_float takes a raw C double - do not wrap the float
|
|
// argument in el_from_float() again. Without this, the float
|
|
// literal codegen (which wraps every Float in el_from_float())
|
|
// produces el_from_float(el_from_float(0.7)) - double-encoded.
|
|
if str_eq(fn_name, "el_from_float") {
|
|
if arity == 1 {
|
|
let only_arg = native_list_get(args, 0)
|
|
let arg_kind: String = only_arg["expr"]
|
|
if str_eq(arg_kind, "Float") {
|
|
let v: String = only_arg["value"]
|
|
return "el_from_float(" + v + ")"
|
|
}
|
|
}
|
|
}
|
|
return fn_name + "(" + args_c + ")"
|
|
}
|
|
|
|
if func_kind == "Field" {
|
|
let obj = func["object"]
|
|
let field: String = func["field"]
|
|
let obj_c: String = cg_expr(obj)
|
|
if arity > 0 {
|
|
return field + "(" + obj_c + ", " + args_c + ")"
|
|
}
|
|
return field + "(" + obj_c + ")"
|
|
}
|
|
|
|
let fn_c: String = cg_expr(func)
|
|
return fn_c + "(" + args_c + ")"
|
|
}
|
|
|
|
if kind == "Field" {
|
|
let obj = expr["object"]
|
|
let field: String = expr["field"]
|
|
let obj_c: String = cg_expr(obj)
|
|
// el_get_field takes el_val_t for both args, so the field name
|
|
// string literal must be wrapped in EL_STR(). Without the wrap
|
|
// the C compiler treats the bare const char* as an int64 (warns
|
|
// -Wint-conversion) and the runtime reads gibberish at the address
|
|
// when looking up the key.
|
|
return "el_get_field(" + obj_c + ", EL_STR(" + c_str_lit(field) + "))"
|
|
}
|
|
|
|
if kind == "Index" {
|
|
// El programs use `t["field"]` for map access and `arr[i]` for
|
|
// list access. The parser emits the same Index node for both.
|
|
// Dispatch at codegen time on the index expression kind: string-
|
|
// literal index -> map field access (`el_get_field`); anything
|
|
// else -> list element access (`el_list_get`).
|
|
let obj = expr["object"]
|
|
let idx = expr["index"]
|
|
let obj_c: String = cg_expr(obj)
|
|
let idx_c: String = cg_expr(idx)
|
|
let idx_kind: String = idx["expr"]
|
|
if str_eq(idx_kind, "Str") {
|
|
return "el_get_field(" + obj_c + ", " + idx_c + ")"
|
|
}
|
|
return "el_list_get(" + obj_c + ", " + idx_c + ")"
|
|
}
|
|
|
|
if kind == "Array" {
|
|
let elems = expr["elems"]
|
|
let n: Int = native_list_len(elems)
|
|
// Empty literal: el_list_new(0, ) generates malformed C (trailing
|
|
// comma in a varargs call). Emit el_list_empty() directly.
|
|
if n == 0 { return "el_list_empty()" }
|
|
let items_parts: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let elem = native_list_get(elems, i)
|
|
let elem_c: String = cg_expr(elem)
|
|
let items_parts = native_list_append(items_parts, elem_c)
|
|
let i = i + 1
|
|
}
|
|
return "el_list_new(" + native_int_to_str(n) + ", " + str_join(items_parts, ", ") + ")"
|
|
}
|
|
|
|
if kind == "Map" {
|
|
let pairs = expr["pairs"]
|
|
let n: Int = native_list_len(pairs)
|
|
// Empty literal: `el_map_new(0, )` is malformed C (trailing comma in
|
|
// a varargs call). Emit `el_map_new(0)` directly so empty-map
|
|
// shadowing inside for/while/if bodies - `let acc: Map = {}` -
|
|
// doesn't fail downstream cc with parse errors.
|
|
if n == 0 { return "el_map_new(0)" }
|
|
let items_parts: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let pair = native_list_get(pairs, i)
|
|
let key: String = pair["key"]
|
|
let val = pair["value"]
|
|
let val_c: String = cg_expr(val)
|
|
let items_parts = native_list_append(items_parts, c_str_lit(key) + ", " + val_c)
|
|
let i = i + 1
|
|
}
|
|
return "el_map_new(" + native_int_to_str(n) + ", " + str_join(items_parts, ", ") + ")"
|
|
}
|
|
|
|
if kind == "Try" {
|
|
let inner = expr["inner"]
|
|
return cg_expr(inner)
|
|
}
|
|
|
|
if kind == "If" {
|
|
return cg_if_expr(expr)
|
|
}
|
|
|
|
if kind == "Match" {
|
|
return cg_match(expr)
|
|
}
|
|
|
|
if kind == "HtmlTemplate" {
|
|
return cg_html_template(expr)
|
|
}
|
|
|
|
"EL_NULL"
|
|
}
|
|
|
|
// -- Match codegen -------------------------------------------------------------
|
|
//
|
|
// Lower a match expression to a GCC/Clang statement-expression.
|
|
// A unique label suffix is allocated per match via state_set("__match_counter").
|
|
|
|
fn next_match_id() -> String {
|
|
let csv: String = state_get("__match_counter")
|
|
let n = 0
|
|
if !str_eq(csv, "") {
|
|
let n = str_to_int(csv)
|
|
}
|
|
let n = n + 1
|
|
state_set("__match_counter", native_int_to_str(n))
|
|
native_int_to_str(n)
|
|
}
|
|
|
|
fn cg_match(expr: Map<String, Any>) -> String {
|
|
let subject = expr["subject"]
|
|
let arms = expr["arms"]
|
|
let subj_c: String = cg_expr(subject)
|
|
let id: String = next_match_id()
|
|
let subj_var: String = "_match_subj_" + id
|
|
let result_var: String = "_match_result_" + id
|
|
let done_label: String = "_match_done_" + id
|
|
// Accumulate arm fragments into a list to avoid O(n-) string growth.
|
|
let parts: [String] = native_list_empty()
|
|
let parts = native_list_append(parts, "({ el_val_t " + subj_var + " = " + subj_c + "; el_val_t " + result_var + " = 0; ")
|
|
let n: Int = native_list_len(arms)
|
|
let i = 0
|
|
while i < n {
|
|
let arm = native_list_get(arms, i)
|
|
let pat = arm["pattern"]
|
|
let body = arm["body"]
|
|
let pkind: String = pat["pattern"]
|
|
let body_c: String = cg_expr(body)
|
|
if str_eq(pkind, "Wildcard") {
|
|
let parts = native_list_append(parts, "{ " + result_var + " = (" + body_c + "); goto " + done_label + "; } ")
|
|
} else {
|
|
if str_eq(pkind, "Binding") {
|
|
let bname: String = pat["name"]
|
|
let parts = native_list_append(parts, "{ el_val_t " + bname + " = " + subj_var + "; " + result_var + " = (" + body_c + "); goto " + done_label + "; } ")
|
|
} else {
|
|
if str_eq(pkind, "LitInt") {
|
|
let v: String = pat["value"]
|
|
let parts = native_list_append(parts, "if (" + subj_var + " == " + v + ") { " + result_var + " = (" + body_c + "); goto " + done_label + "; } ")
|
|
} else {
|
|
if str_eq(pkind, "LitStr") {
|
|
let v: String = pat["value"]
|
|
let parts = native_list_append(parts, "if (str_eq(" + subj_var + ", EL_STR(" + c_str_lit(v) + "))) { " + result_var + " = (" + body_c + "); goto " + done_label + "; } ")
|
|
} else {
|
|
if str_eq(pkind, "LitBool") {
|
|
let v: String = pat["value"]
|
|
let bv = "0"
|
|
if str_eq(v, "true") {
|
|
let bv = "1"
|
|
}
|
|
let parts = native_list_append(parts, "if (" + subj_var + " == " + bv + ") { " + result_var + " = (" + body_c + "); goto " + done_label + "; } ")
|
|
} else {
|
|
if str_eq(pkind, "Variant") {
|
|
// Enum::Variant pattern — match against the variant name
|
|
// string (El enums compile to plain strings).
|
|
let variant: String = pat["variant"]
|
|
let parts = native_list_append(parts, "if (str_eq(" + subj_var + ", EL_STR(" + c_str_lit(variant) + "))) { " + result_var + " = (" + body_c + "); goto " + done_label + "; } ")
|
|
} else {
|
|
// unknown pattern -> wildcard
|
|
let parts = native_list_append(parts, "{ " + result_var + " = (" + body_c + "); goto " + done_label + "; } ")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
let parts = native_list_append(parts, done_label + ":; " + result_var + "; })")
|
|
str_join(parts, "")
|
|
}
|
|
|
|
// -- If-as-expression codegen -------------------------------------------------
|
|
//
|
|
// Lower `if cond { thenBody } else { elseBody }` used in expression position
|
|
// (e.g. `let x = if a { b } else { c }`) to a GCC/Clang statement-expression
|
|
// so the actual arm bodies are evaluated, not just `(cond ? 1 : 0)`.
|
|
//
|
|
// Each arm body is a list of statements; the result of the arm is the value
|
|
// of its final Expr statement (mirroring transform_implicit_return at function
|
|
// scope). Statements before the final Expr are emitted as expression-statements
|
|
// for their side effects.
|
|
|
|
fn next_if_id() -> String {
|
|
let csv: String = state_get("__if_expr_counter")
|
|
let n = 0
|
|
if !str_eq(csv, "") {
|
|
let n = str_to_int(csv)
|
|
}
|
|
let n = n + 1
|
|
state_set("__if_expr_counter", native_int_to_str(n))
|
|
native_int_to_str(n)
|
|
}
|
|
|
|
// Render a single arm of the if-as-expression: emit each statement-before-last
|
|
// as a side-effecting expression, then assign the final Expr's value to the
|
|
// result var. If the arm body is empty or its last stmt isn't an Expr, the
|
|
// result var stays at its initial 0.
|
|
fn cg_if_expr_arm(stmts: [Map<String, Any>], result_var: String) -> String {
|
|
let n: Int = native_list_len(stmts)
|
|
// Collect statement fragments into a list to avoid O(n-) string growth.
|
|
let parts: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let s = native_list_get(stmts, i)
|
|
let sk: String = s["stmt"]
|
|
let is_last: Bool = false
|
|
if i == n - 1 { let is_last = true }
|
|
if str_eq(sk, "Let") {
|
|
let name: String = s["name"]
|
|
let val = s["value"]
|
|
let val_c: String = cg_expr(val)
|
|
let parts = native_list_append(parts, "el_val_t " + name + " = " + val_c + "; ")
|
|
} else {
|
|
if str_eq(sk, "Return") {
|
|
let val = s["value"]
|
|
let val_c: String = cg_expr(val)
|
|
let parts = native_list_append(parts, result_var + " = (" + val_c + "); ")
|
|
} else {
|
|
if str_eq(sk, "Expr") {
|
|
let val = s["value"]
|
|
let val_c: String = cg_expr(val)
|
|
if is_last {
|
|
let parts = native_list_append(parts, result_var + " = (" + val_c + "); ")
|
|
} else {
|
|
let parts = native_list_append(parts, "(void)(" + val_c + "); ")
|
|
}
|
|
} else {
|
|
if str_eq(sk, "Assign") {
|
|
// Real reassignment in an expression-position arm -
|
|
// emit the store; the arm's "value" stays whatever
|
|
// result_var was last set to, which is the El
|
|
// semantics (assignment is a statement, not a value).
|
|
let aname: String = s["name"]
|
|
let aval = s["value"]
|
|
let aval_c: String = cg_expr(aval)
|
|
let parts = native_list_append(parts, aname + " = " + aval_c + "; ")
|
|
} else {
|
|
// Non-trivial stmt kinds (While/For) shouldn't appear in
|
|
// expression-position arm bodies; emit nothing rather
|
|
// than malformed C.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
str_join(parts, "")
|
|
}
|
|
|
|
fn cg_if_expr(expr: Map<String, Any>) -> String {
|
|
let cond = expr["cond"]
|
|
let then_stmts = expr["then"]
|
|
let else_stmts = expr["else"]
|
|
let has_else: Bool = expr["has_else"]
|
|
let cond_c: String = cg_expr(cond)
|
|
let id: String = next_if_id()
|
|
let result_var: String = "_if_result_" + id
|
|
let then_c: String = cg_if_expr_arm(then_stmts, result_var)
|
|
let else_c: String = ""
|
|
if has_else {
|
|
let else_c = cg_if_expr_arm(else_stmts, result_var)
|
|
}
|
|
let out: String = "({ el_val_t " + result_var + " = 0; if (" + cond_c + ") { " + then_c + "} else { " + else_c + "} " + result_var + "; })"
|
|
out
|
|
}
|
|
|
|
// -- Variable scope tracking ---------------------------------------------------
|
|
//
|
|
// El allows `let x = expr` to both declare and reassign x in the same scope.
|
|
// C doesn't allow redeclaring the same name in the same block.
|
|
// We track declared names in a list and emit `x = expr` (no type prefix)
|
|
// when x is already declared. The declared list is passed through all
|
|
// statement emitters.
|
|
|
|
fn list_contains(lst: [String], s: String) -> Bool {
|
|
let n: Int = native_list_len(lst)
|
|
let i = 0
|
|
while i < n {
|
|
let item: String = native_list_get(lst, i)
|
|
if item == s { return true }
|
|
let i = i + 1
|
|
}
|
|
false
|
|
}
|
|
|
|
// -- Statement codegen ---------------------------------------------------------
|
|
//
|
|
// cg_stmt emits C lines via println. declared is a list of already-declared
|
|
// variable names in the current C scope; returns updated declared list.
|
|
|
|
fn cg_stmt(stmt: Map<String, Any>, indent: String, declared: [String]) -> [String] {
|
|
let kind: String = stmt["stmt"]
|
|
|
|
if kind == "Let" {
|
|
let name: String = stmt["name"]
|
|
let val = stmt["value"]
|
|
let val_c: String = cg_expr(val)
|
|
// If the binding is annotated `: Int` and val is an Int literal,
|
|
// register `name` in the per-function int-name set so that later
|
|
// `name + ...` dispatches to arithmetic, not concat.
|
|
let ltype: String = stmt["type"]
|
|
if str_eq(ltype, "Int") {
|
|
add_int_name(name)
|
|
}
|
|
// Temporal type annotations register the name with the matching
|
|
// typed-set so BinOp / comparison codegen routes through the
|
|
// typed wrappers and forbids cross-type ops.
|
|
if str_eq(ltype, "Instant") {
|
|
add_instant_name(name)
|
|
}
|
|
if str_eq(ltype, "Duration") {
|
|
add_duration_name(name)
|
|
}
|
|
if str_eq(ltype, "Calendar") {
|
|
add_calendar_name(name)
|
|
}
|
|
if str_eq(ltype, "CalendarTime") {
|
|
add_caltime_name(name)
|
|
}
|
|
if str_eq(ltype, "Rhythm") {
|
|
add_rhythm_name(name)
|
|
}
|
|
if str_eq(ltype, "LocalDate") {
|
|
add_localdate_name(name)
|
|
}
|
|
if str_eq(ltype, "LocalTime") {
|
|
add_localtime_name(name)
|
|
}
|
|
if str_eq(ltype, "LocalDateTime") {
|
|
add_localdt_name(name)
|
|
}
|
|
if str_eq(ltype, "Zone") {
|
|
add_zone_name(name)
|
|
}
|
|
// Inference from RHS - duration literals and known-typed calls
|
|
// propagate even when the let is unannotated.
|
|
if is_instant_expr(val) {
|
|
add_instant_name(name)
|
|
}
|
|
if is_duration_expr(val) {
|
|
add_duration_name(name)
|
|
}
|
|
if is_calendar_expr(val) {
|
|
add_calendar_name(name)
|
|
}
|
|
if is_caltime_expr(val) {
|
|
add_caltime_name(name)
|
|
}
|
|
if is_rhythm_expr(val) {
|
|
add_rhythm_name(name)
|
|
}
|
|
if is_localdate_expr(val) {
|
|
add_localdate_name(name)
|
|
}
|
|
if is_localtime_expr(val) {
|
|
add_localtime_name(name)
|
|
}
|
|
if is_localdt_expr(val) {
|
|
add_localdt_name(name)
|
|
}
|
|
if is_zone_expr(val) {
|
|
add_zone_name(name)
|
|
}
|
|
let vk: String = val["expr"]
|
|
if str_eq(vk, "Int") {
|
|
add_int_name(name)
|
|
}
|
|
if list_contains(declared, name) {
|
|
emit_line(indent + name + " = " + val_c + ";")
|
|
return declared
|
|
} else {
|
|
emit_line(indent + "el_val_t " + name + " = " + val_c + ";")
|
|
return native_list_append(declared, name)
|
|
}
|
|
}
|
|
|
|
if kind == "Return" {
|
|
let val = stmt["value"]
|
|
let val_kind: String = val["expr"]
|
|
if val_kind == "Nil" {
|
|
emit_line(indent + "return 0;")
|
|
} else {
|
|
let val_c: String = cg_expr(val)
|
|
emit_line(indent + "return " + val_c + ";")
|
|
}
|
|
return declared
|
|
}
|
|
|
|
// Bare reassignment: `name = expr`. Always emits a plain C assignment
|
|
// (no `el_val_t` prefix) - by construction the parser only produces
|
|
// Assign for an existing identifier. If the name happens NOT to be in
|
|
// `declared` for the current C scope (it was let-bound by an enclosing
|
|
// block) the emit still resolves at C level because the variable lives
|
|
// in the surrounding scope.
|
|
if kind == "Assign" {
|
|
let name: String = stmt["name"]
|
|
let val = stmt["value"]
|
|
let val_c: String = cg_expr(val)
|
|
emit_line(indent + name + " = " + val_c + ";")
|
|
return declared
|
|
}
|
|
|
|
if kind == "Expr" {
|
|
let val = stmt["value"]
|
|
let val_kind: String = val["expr"]
|
|
if val_kind == "If" {
|
|
cg_if_stmt(val, indent, declared)
|
|
return declared
|
|
}
|
|
if val_kind == "For" {
|
|
cg_for_stmt(val, indent, declared)
|
|
return declared
|
|
}
|
|
let val_c: String = cg_expr(val)
|
|
emit_line(indent + val_c + ";")
|
|
return declared
|
|
}
|
|
|
|
if kind == "While" {
|
|
let cond = stmt["cond"]
|
|
let body = stmt["body"]
|
|
let cond_c: String = cg_expr(cond)
|
|
let cond_c = strip_outer_parens(cond_c)
|
|
emit_line(indent + "while (" + cond_c + ") {")
|
|
// Body lives in its own C block - clone so let-bindings inside the
|
|
// loop don't leak into the parent's `declared` list (which would make
|
|
// a sibling scope's `let x` emit assignment on an undeclared name).
|
|
cg_stmts(body, indent + " ", native_list_clone(declared))
|
|
emit_line(indent + "}")
|
|
return declared
|
|
}
|
|
|
|
if kind == "For" {
|
|
let item: String = stmt["item"]
|
|
let list_expr = stmt["list"]
|
|
let body = stmt["body"]
|
|
cg_for_body(item, list_expr, body, indent, declared)
|
|
return declared
|
|
}
|
|
|
|
if kind == "FnDef" { return declared }
|
|
if kind == "TypeDef" { return declared }
|
|
if kind == "EnumDef" { return declared }
|
|
if kind == "Import" { return declared }
|
|
if kind == "ExternFn" { return declared }
|
|
if kind == "CgiBlock" { return declared }
|
|
if kind == "ServiceBlock" { return declared }
|
|
// TestDef: skip in normal (non-test) mode.
|
|
// In test mode the body is emitted by cg_test_fn, not here.
|
|
if kind == "TestDef" { return declared }
|
|
// Assert: no-op in normal mode. In test mode, cg_stmt_assert is used
|
|
// directly when emitting the per-test function body.
|
|
if kind == "Assert" { return declared }
|
|
// TryCatch: browser-only control flow. In the C target, emit a comment
|
|
// noting that the try body runs unconditionally; error handling is a no-op.
|
|
// Programs that rely on catching JS exceptions should compile with --target=js.
|
|
if kind == "TryCatch" {
|
|
let try_body = stmt["try_body"]
|
|
emit_line(indent + "/* try (C target: exception handling not supported) */")
|
|
cg_stmts(try_body, indent, native_list_clone(declared))
|
|
return declared
|
|
}
|
|
declared
|
|
}
|
|
|
|
// Strip a single layer of surrounding parentheses from a C expression string.
|
|
fn strip_outer_parens(s: String) -> String {
|
|
let chars: [String] = native_string_chars(s)
|
|
let n: Int = native_list_len(chars)
|
|
if n < 2 { return s }
|
|
let first: String = native_list_get(chars, 0)
|
|
let last: String = native_list_get(chars, n - 1)
|
|
if first == "(" {
|
|
if last == ")" {
|
|
let depth = 1
|
|
let i = 1
|
|
let balanced = true
|
|
while i < n - 1 {
|
|
let ch: String = native_list_get(chars, i)
|
|
if ch == "(" {
|
|
let depth = depth + 1
|
|
}
|
|
if ch == ")" {
|
|
let depth = depth - 1
|
|
if depth == 0 {
|
|
let balanced = false
|
|
let i = n
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
if balanced {
|
|
return str_slice(s, 1, n - 1)
|
|
}
|
|
}
|
|
}
|
|
s
|
|
}
|
|
|
|
fn cg_if_stmt(expr: Map<String, Any>, indent: String, declared: [String]) -> Void {
|
|
let cond = expr["cond"]
|
|
let then_stmts = expr["then"]
|
|
let else_stmts = expr["else"]
|
|
let has_else: Bool = expr["has_else"]
|
|
let cond_c: String = cg_expr(cond)
|
|
let cond_c = strip_outer_parens(cond_c)
|
|
emit_line(indent + "if (" + cond_c + ") {")
|
|
// Each branch gets its own clone of `declared` - variables let-bound
|
|
// inside the then/else block live only in that C scope, and must not
|
|
// leak back to the parent (or to the sibling branch) through shared
|
|
// list mutation. Cheap shallow copy; the entries (variable name strings)
|
|
// are shared.
|
|
cg_stmts(then_stmts, indent + " ", native_list_clone(declared))
|
|
if has_else {
|
|
emit_line(indent + "} else {")
|
|
cg_stmts(else_stmts, indent + " ", native_list_clone(declared))
|
|
}
|
|
emit_line(indent + "}")
|
|
}
|
|
|
|
fn cg_for_body(item: String, list_expr: Map<String, Any>, body: [Map<String, Any>], indent: String, declared: [String]) -> Void {
|
|
let list_c: String = cg_expr(list_expr)
|
|
let idx = "_el_i"
|
|
let list_tmp = "_el_lst"
|
|
let len_tmp = "_el_len"
|
|
emit_line(indent + "{")
|
|
emit_line(indent + " el_val_t " + list_tmp + " = " + list_c + ";")
|
|
emit_line(indent + " el_val_t " + len_tmp + " = el_list_len(" + list_tmp + ");")
|
|
emit_line(indent + " for (el_val_t " + idx + " = 0; " + idx + " < " + len_tmp + "; " + idx + "++) {")
|
|
emit_line(indent + " el_val_t " + item + " = el_list_get(" + list_tmp + ", " + idx + ");")
|
|
// Body lives inside its own C block; the loop variable and any locally
|
|
// let-bound names go out of scope at the closing brace, so we mustn't
|
|
// pollute the parent's `declared` with them.
|
|
let body_decl = native_list_clone(declared)
|
|
let body_decl = native_list_append(body_decl, item)
|
|
cg_stmts(body, indent + " ", body_decl)
|
|
emit_line(indent + " }")
|
|
emit_line(indent + "}")
|
|
}
|
|
|
|
fn cg_for_stmt(expr: Map<String, Any>, indent: String, declared: [String]) -> Void {
|
|
let item: String = expr["item"]
|
|
let list_expr = expr["list"]
|
|
let body = expr["body"]
|
|
cg_for_body(item, list_expr, body, indent, declared)
|
|
}
|
|
|
|
fn cg_stmts(stmts: [Map<String, Any>], indent: String, declared: [String]) -> [String] {
|
|
let n: Int = native_list_len(stmts)
|
|
let i = 0
|
|
let decl = declared
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let decl = cg_stmt(stmt, indent, decl)
|
|
let i = i + 1
|
|
}
|
|
decl
|
|
}
|
|
|
|
// -- Function declaration codegen -----------------------------------------------
|
|
|
|
fn param_decl(param: Map<String, Any>, idx: Int) -> String {
|
|
let name: String = param["name"]
|
|
"el_val_t " + name
|
|
}
|
|
|
|
fn params_to_c(params: [Map<String, Any>]) -> String {
|
|
let n: Int = native_list_len(params)
|
|
if n == 0 { return "void" }
|
|
let parts: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let param = native_list_get(params, i)
|
|
let decl: String = param_decl(param, i)
|
|
let parts = native_list_append(parts, decl)
|
|
let i = i + 1
|
|
}
|
|
str_join(parts, ", ")
|
|
}
|
|
|
|
// Transform a function body so that an implicit-return final expression
|
|
// becomes an explicit Return. El allows the last expression in a function
|
|
// body to be the return value (e.g. `fn lex(s) { ... tokens }` returns
|
|
// `tokens`). Without this transform, the codegen emits the bare expression
|
|
// and falls through to the trailing `return 0;`, losing the value.
|
|
//
|
|
// Rules: a body ending in a bare Expr whose inner expr is NOT a control-
|
|
// flow construct (If/For) is rewritten so that final Expr becomes a
|
|
// Return statement carrying the same value. Bodies whose final statement
|
|
// is already a Return, While, For, or a non-value-producing form pass
|
|
// through unchanged.
|
|
fn transform_implicit_return(body: [Map<String, Any>]) -> [Map<String, Any>] {
|
|
let n: Int = native_list_len(body)
|
|
if n == 0 { return body }
|
|
let last: Map<String, Any> = native_list_get(body, n - 1)
|
|
let last_kind: String = last["stmt"]
|
|
if last_kind == "Expr" {
|
|
let val = last["value"]
|
|
let val_kind: String = val["expr"]
|
|
// Skip control-flow expressions used as statements
|
|
if val_kind == "If" { return body }
|
|
if val_kind == "For" { return body }
|
|
// Replace the last bare Expr with a Return carrying the same value
|
|
let new_body: [Map<String, Any>] = native_list_empty()
|
|
let i = 0
|
|
while i < n - 1 {
|
|
let new_body = native_list_append(new_body, native_list_get(body, i))
|
|
let i = i + 1
|
|
}
|
|
let return_stmt: Map<String, Any> = { "stmt": "Return", "value": val }
|
|
let new_body = native_list_append(new_body, return_stmt)
|
|
return new_body
|
|
}
|
|
body
|
|
}
|
|
|
|
// Test whether `name` is currently registered as an Int-typed identifier
|
|
// for the function being codegened. The set is maintained as a comma-
|
|
// bounded CSV in process state; cg_fn seeds it from typed parameters,
|
|
// cg_stmt extends it from typed `let` bindings.
|
|
fn is_int_name(name: String) -> Bool {
|
|
let csv: String = state_get("__int_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
// Same shape as is_int_name, for Instant- and Duration-typed bindings.
|
|
// Used by the BinOp/comparison codegen to dispatch arithmetic through the
|
|
// typed runtime wrappers (el_instant_add_dur, el_duration_lt, -) and to
|
|
// surface mismatches (Instant + Instant, Duration + Int) as #error
|
|
// directives at the top of the generated C.
|
|
fn is_instant_name(name: String) -> Bool {
|
|
let csv: String = state_get("__instant_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
fn is_duration_name(name: String) -> Bool {
|
|
let csv: String = state_get("__duration_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
// Known runtime builtins that return Int. Used to dispatch arithmetic vs
|
|
// string-concat on `+` when one side is a Call. New builtins must be added
|
|
// here when they return Int and may participate in arithmetic.
|
|
fn is_int_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "str_len") { return true }
|
|
if str_eq(name, "str_index_of") { return true }
|
|
if str_eq(name, "str_to_int") { return true }
|
|
if str_eq(name, "str_char_code") { return true }
|
|
if str_eq(name, "str_count") { return true }
|
|
if str_eq(name, "str_count_chars") { return true }
|
|
if str_eq(name, "str_count_bytes") { return true }
|
|
if str_eq(name, "str_count_lines") { return true }
|
|
if str_eq(name, "str_count_words") { return true }
|
|
if str_eq(name, "str_count_letters") { return true }
|
|
if str_eq(name, "str_count_digits") { return true }
|
|
if str_eq(name, "str_last_index_of") { return true }
|
|
if str_eq(name, "str_find_chars") { return true }
|
|
if str_eq(name, "native_list_len") { return true }
|
|
if str_eq(name, "el_list_len") { return true }
|
|
if str_eq(name, "len") { return true }
|
|
if str_eq(name, "json_get_int") { return true }
|
|
if str_eq(name, "json_array_len") { return true }
|
|
if str_eq(name, "engram_node_count") { return true }
|
|
if str_eq(name, "engram_edge_count") { return true }
|
|
if str_eq(name, "time_now") { return true }
|
|
if str_eq(name, "time_now_utc") { return true }
|
|
if str_eq(name, "time_diff") { return true }
|
|
if str_eq(name, "time_add") { return true }
|
|
if str_eq(name, "time_from_parts") { return true }
|
|
if str_eq(name, "el_abs") { return true }
|
|
if str_eq(name, "el_max") { return true }
|
|
if str_eq(name, "el_min") { return true }
|
|
if str_eq(name, "float_to_int") { return true }
|
|
if str_eq(name, "unix_timestamp") { return true }
|
|
if str_eq(name, "instant_to_unix_seconds") { return true }
|
|
if str_eq(name, "instant_to_unix_millis") { return true }
|
|
if str_eq(name, "duration_to_seconds") { return true }
|
|
if str_eq(name, "duration_to_millis") { return true }
|
|
if str_eq(name, "duration_to_nanos") { return true }
|
|
return false
|
|
}
|
|
|
|
// Builtins that return an Instant. Used by is_instant_expr and the BinOp
|
|
// dispatch - `now() + 5.seconds` types as Instant only because we can see
|
|
// that now() is an Instant-returning Call.
|
|
fn is_instant_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "now") { return true }
|
|
if str_eq(name, "el_now_instant") { return true }
|
|
if str_eq(name, "unix_seconds") { return true }
|
|
if str_eq(name, "unix_millis") { return true }
|
|
if str_eq(name, "instant_from_iso8601") { return true }
|
|
if str_eq(name, "el_instant_add_dur") { return true }
|
|
if str_eq(name, "el_instant_sub_dur") { return true }
|
|
return false
|
|
}
|
|
|
|
// Builtins that return a Duration. Same role as is_instant_call.
|
|
fn is_duration_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "el_duration_from_nanos") { return true }
|
|
if str_eq(name, "duration_seconds") { return true }
|
|
if str_eq(name, "duration_millis") { return true }
|
|
if str_eq(name, "duration_nanos") { return true }
|
|
if str_eq(name, "el_instant_diff") { return true }
|
|
if str_eq(name, "el_duration_add") { return true }
|
|
if str_eq(name, "el_duration_sub") { return true }
|
|
if str_eq(name, "el_duration_scale") { return true }
|
|
if str_eq(name, "el_duration_div") { return true }
|
|
if str_eq(name, "ttl_cache_age") { return true }
|
|
return false
|
|
}
|
|
|
|
// Phase 1.5 - Calendar / CalendarTime / Rhythm / LocalDate / LocalTime /
|
|
// LocalDateTime / Zone are first-class boxed types. Each has its own name
|
|
// set in process state, populated from typed `let` bindings and parameter
|
|
// annotations. The BinOp dispatcher consults these to forbid mismatched
|
|
// arithmetic (e.g. CalendarTime + CalendarTime, LocalDate < CalendarTime).
|
|
fn is_calendar_name(name: String) -> Bool {
|
|
let csv: String = state_get("__calendar_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
fn is_caltime_name(name: String) -> Bool {
|
|
let csv: String = state_get("__caltime_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
fn is_rhythm_name(name: String) -> Bool {
|
|
let csv: String = state_get("__rhythm_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
fn is_localdate_name(name: String) -> Bool {
|
|
let csv: String = state_get("__localdate_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
fn is_localtime_name(name: String) -> Bool {
|
|
let csv: String = state_get("__localtime_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
fn is_localdt_name(name: String) -> Bool {
|
|
let csv: String = state_get("__localdt_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
fn is_zone_name(name: String) -> Bool {
|
|
let csv: String = state_get("__zone_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
// Calendar-returning builtins. earth_calendar / mars_calendar / cycle_calendar
|
|
// / no_cycle_calendar / relative_calendar all box a calendar struct.
|
|
fn is_calendar_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "earth_calendar") { return true }
|
|
if str_eq(name, "earth_calendar_default") { return true }
|
|
if str_eq(name, "mars_calendar") { return true }
|
|
if str_eq(name, "cycle_calendar") { return true }
|
|
if str_eq(name, "no_cycle_calendar") { return true }
|
|
if str_eq(name, "relative_calendar") { return true }
|
|
return false
|
|
}
|
|
|
|
// CalendarTime-returning builtins.
|
|
fn is_caltime_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "now_in") { return true }
|
|
if str_eq(name, "in_calendar") { return true }
|
|
if str_eq(name, "cal_in") { return true }
|
|
if str_eq(name, "zoned") { return true }
|
|
return false
|
|
}
|
|
|
|
// Rhythm-returning builtins.
|
|
fn is_rhythm_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "rhythm_cycle_start") { return true }
|
|
if str_eq(name, "rhythm_cycle_phase") { return true }
|
|
if str_eq(name, "rhythm_duration") { return true }
|
|
if str_eq(name, "rhythm_session_start") { return true }
|
|
if str_eq(name, "rhythm_event") { return true }
|
|
if str_eq(name, "rhythm_and") { return true }
|
|
if str_eq(name, "rhythm_or") { return true }
|
|
if str_eq(name, "rhythm_weekday") { return true }
|
|
if str_eq(name, "rhythm_weekly_at") { return true }
|
|
return false
|
|
}
|
|
|
|
// LocalDate-returning builtins.
|
|
fn is_localdate_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "local_date") { return true }
|
|
if str_eq(name, "el_local_date_add_dur") { return true }
|
|
return false
|
|
}
|
|
|
|
fn is_localtime_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "local_time") { return true }
|
|
if str_eq(name, "el_local_time_add_dur") { return true }
|
|
return false
|
|
}
|
|
|
|
fn is_localdt_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "local_datetime") { return true }
|
|
return false
|
|
}
|
|
|
|
fn is_zone_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "zone") { return true }
|
|
if str_eq(name, "zone_utc") { return true }
|
|
if str_eq(name, "zone_local") { return true }
|
|
if str_eq(name, "zone_offset") { return true }
|
|
return false
|
|
}
|
|
|
|
fn is_calendar_expr(expr: Map<String, Any>) -> Bool {
|
|
let k: String = expr["expr"]
|
|
if str_eq(k, "Ident") { return is_calendar_name(expr["name"]) }
|
|
if str_eq(k, "Call") { return is_calendar_call(expr) }
|
|
return false
|
|
}
|
|
|
|
fn is_caltime_expr(expr: Map<String, Any>) -> Bool {
|
|
let k: String = expr["expr"]
|
|
if str_eq(k, "Ident") { return is_caltime_name(expr["name"]) }
|
|
if str_eq(k, "Call") { return is_caltime_call(expr) }
|
|
return false
|
|
}
|
|
|
|
fn is_rhythm_expr(expr: Map<String, Any>) -> Bool {
|
|
let k: String = expr["expr"]
|
|
if str_eq(k, "Ident") { return is_rhythm_name(expr["name"]) }
|
|
if str_eq(k, "Call") { return is_rhythm_call(expr) }
|
|
return false
|
|
}
|
|
|
|
fn is_localdate_expr(expr: Map<String, Any>) -> Bool {
|
|
let k: String = expr["expr"]
|
|
if str_eq(k, "Ident") { return is_localdate_name(expr["name"]) }
|
|
if str_eq(k, "Call") { return is_localdate_call(expr) }
|
|
return false
|
|
}
|
|
|
|
fn is_localtime_expr(expr: Map<String, Any>) -> Bool {
|
|
let k: String = expr["expr"]
|
|
if str_eq(k, "Ident") { return is_localtime_name(expr["name"]) }
|
|
if str_eq(k, "Call") { return is_localtime_call(expr) }
|
|
return false
|
|
}
|
|
|
|
fn is_localdt_expr(expr: Map<String, Any>) -> Bool {
|
|
let k: String = expr["expr"]
|
|
if str_eq(k, "Ident") { return is_localdt_name(expr["name"]) }
|
|
if str_eq(k, "Call") { return is_localdt_call(expr) }
|
|
return false
|
|
}
|
|
|
|
fn is_zone_expr(expr: Map<String, Any>) -> Bool {
|
|
let k: String = expr["expr"]
|
|
if str_eq(k, "Ident") { return is_zone_name(expr["name"]) }
|
|
if str_eq(k, "Call") { return is_zone_call(expr) }
|
|
return false
|
|
}
|
|
|
|
// Recursive type predicates for Instant / Duration. Mirror is_int_expr.
|
|
// is_instant_expr / is_duration_expr return true only when the expression
|
|
// is provably of that type at codegen time. Anything ambiguous returns
|
|
// false - the BinOp dispatcher then leaves the expression on the
|
|
// untyped-int path, which is the safest fallback because at the runtime
|
|
// level all three types share the int64 slot.
|
|
fn is_instant_expr(expr: Map<String, Any>) -> Bool {
|
|
let k: String = expr["expr"]
|
|
if str_eq(k, "Ident") {
|
|
let name: String = expr["name"]
|
|
return is_instant_name(name)
|
|
}
|
|
if str_eq(k, "Call") {
|
|
return is_instant_call(expr)
|
|
}
|
|
if str_eq(k, "BinOp") {
|
|
let op: String = expr["op"]
|
|
if str_eq(op, "Plus") {
|
|
// Instant + Duration -> Instant
|
|
// Duration + Instant -> Instant
|
|
if is_instant_expr(expr["left"]) {
|
|
if is_duration_expr(expr["right"]) { return true }
|
|
}
|
|
if is_duration_expr(expr["left"]) {
|
|
if is_instant_expr(expr["right"]) { return true }
|
|
}
|
|
return false
|
|
}
|
|
if str_eq(op, "Minus") {
|
|
// Instant - Duration -> Instant
|
|
if is_instant_expr(expr["left"]) {
|
|
if is_duration_expr(expr["right"]) { return true }
|
|
}
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
|
|
fn is_duration_expr(expr: Map<String, Any>) -> Bool {
|
|
let k: String = expr["expr"]
|
|
if str_eq(k, "DurationLit") { return true }
|
|
if str_eq(k, "Ident") {
|
|
let name: String = expr["name"]
|
|
return is_duration_name(name)
|
|
}
|
|
if str_eq(k, "Call") {
|
|
return is_duration_call(expr)
|
|
}
|
|
if str_eq(k, "Neg") {
|
|
return is_duration_expr(expr["inner"])
|
|
}
|
|
if str_eq(k, "BinOp") {
|
|
let op: String = expr["op"]
|
|
if str_eq(op, "Plus") {
|
|
// Duration + Duration -> Duration
|
|
if is_duration_expr(expr["left"]) {
|
|
if is_duration_expr(expr["right"]) { return true }
|
|
}
|
|
return false
|
|
}
|
|
if str_eq(op, "Minus") {
|
|
// Duration - Duration -> Duration
|
|
// Instant - Instant -> Duration (caught here, not in is_instant_expr)
|
|
if is_duration_expr(expr["left"]) {
|
|
if is_duration_expr(expr["right"]) { return true }
|
|
}
|
|
if is_instant_expr(expr["left"]) {
|
|
if is_instant_expr(expr["right"]) { return true }
|
|
}
|
|
return false
|
|
}
|
|
if str_eq(op, "Star") {
|
|
// Duration * Int -> Duration
|
|
// Int * Duration -> Duration
|
|
if is_duration_expr(expr["left"]) {
|
|
if is_int_expr(expr["right"]) { return true }
|
|
}
|
|
if is_int_expr(expr["left"]) {
|
|
if is_duration_expr(expr["right"]) { return true }
|
|
}
|
|
return false
|
|
}
|
|
if str_eq(op, "Slash") {
|
|
// Duration / Int -> Duration
|
|
if is_duration_expr(expr["left"]) {
|
|
if is_int_expr(expr["right"]) { return true }
|
|
}
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Record a temporal-type violation. Surfaced as `#error` directives at the
|
|
// top of the generated C, identical machinery to cap_record_violation.
|
|
// kinds: "instant_plus_instant", "duration_plus_int", etc.
|
|
fn time_record_violation(kind: String, detail: String) -> Bool {
|
|
let csv: String = state_get("__time_violations")
|
|
if str_eq(csv, "") { let csv = "," }
|
|
let entry: String = kind + ":" + detail
|
|
let key: String = "," + entry + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__time_violations", csv + entry + ",")
|
|
return true
|
|
}
|
|
|
|
// Recursive type-propagation: is `expr` known-Int at codegen time?
|
|
// This unifies the BinOp(+) dispatch so chained arithmetic over Int
|
|
// operands stays arithmetic. Without recursion, a wrapping `+` between
|
|
// `BinOp(+) of two Ints` and another Int falls to el_str_concat because
|
|
// the outer dispatch only checks the immediate kind, not the inner.
|
|
//
|
|
// Rules:
|
|
// Int literal -> Int
|
|
// Ident in __int_names -> Int
|
|
// Call to known-Int builtin -> Int
|
|
// Neg of Int -> Int
|
|
// BinOp arithmetic of two Ints -> Int (Plus, Minus, Star, Slash, Percent)
|
|
// BinOp comparison/logical -> Int (yields 0/1; safe to treat as Int)
|
|
// anything else -> not provably Int
|
|
fn is_int_expr(expr: Map<String, Any>) -> Bool {
|
|
let k: String = expr["expr"]
|
|
if str_eq(k, "Int") { return true }
|
|
if str_eq(k, "Ident") {
|
|
let name: String = expr["name"]
|
|
return is_int_name(name)
|
|
}
|
|
if str_eq(k, "Call") {
|
|
return is_int_call(expr)
|
|
}
|
|
if str_eq(k, "Neg") {
|
|
return is_int_expr(expr["inner"])
|
|
}
|
|
if str_eq(k, "Not") {
|
|
return true
|
|
}
|
|
if str_eq(k, "BinOp") {
|
|
let op: String = expr["op"]
|
|
// Comparisons and logicals always yield 0/1 - safe Int.
|
|
if str_eq(op, "EqEq") { return true }
|
|
if str_eq(op, "NotEq") { return true }
|
|
if str_eq(op, "Lt") { return true }
|
|
if str_eq(op, "Gt") { return true }
|
|
if str_eq(op, "LtEq") { return true }
|
|
if str_eq(op, "GtEq") { return true }
|
|
if str_eq(op, "And") { return true }
|
|
if str_eq(op, "Or") { return true }
|
|
// Arithmetic propagates: Int op Int -> Int.
|
|
if str_eq(op, "Plus") {
|
|
if is_int_expr(expr["left"]) {
|
|
if is_int_expr(expr["right"]) { return true }
|
|
}
|
|
return false
|
|
}
|
|
if str_eq(op, "Minus") {
|
|
if is_int_expr(expr["left"]) {
|
|
if is_int_expr(expr["right"]) { return true }
|
|
}
|
|
return false
|
|
}
|
|
if str_eq(op, "Star") {
|
|
if is_int_expr(expr["left"]) {
|
|
if is_int_expr(expr["right"]) { return true }
|
|
}
|
|
return false
|
|
}
|
|
if str_eq(op, "Slash") {
|
|
if is_int_expr(expr["left"]) {
|
|
if is_int_expr(expr["right"]) { return true }
|
|
}
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
|
|
// -- Capability-kind enforcement ----------------------------------------------
|
|
//
|
|
// A program's top-level block (cgi / service / none) determines which
|
|
// runtime primitives it may call. The compiler records violations in
|
|
// process state during cg_expr's Call emission; codegen's entry point
|
|
// then emits #error directives at the top of the generated C so the
|
|
// downstream cc step fails with a clear message.
|
|
//
|
|
// Capability tiers:
|
|
// "cgi" - full self-formation. All primitives.
|
|
// "service" - bounded. Cannot call self-formation primitives:
|
|
// llm_call_agentic, llm_register_tool, dharma_emit,
|
|
// dharma_field. Single-turn LLM calls are allowed.
|
|
// "utility" - default. No DHARMA, no LLM. Pure compute + I/O.
|
|
//
|
|
// The compiler-level rule is structural: the binary either CAN or CANNOT
|
|
// emit the call. There is no runtime check, no opt-in, no override.
|
|
|
|
fn cap_record_violation(kind: String, fn_name: String) -> Bool {
|
|
let csv: String = state_get("__cap_violations")
|
|
if str_eq(csv, "") { let csv = "," }
|
|
let entry: String = kind + ":" + fn_name
|
|
let key: String = "," + entry + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__cap_violations", csv + entry + ",")
|
|
return true
|
|
}
|
|
|
|
// Self-formation primitives - the cut between CGI and service. A program
|
|
// that emits these calls IS structurally a CGI; we forbid them everywhere
|
|
// else.
|
|
fn is_self_formation_call(fn_name: String) -> Bool {
|
|
if str_eq(fn_name, "llm_call_agentic") { return true }
|
|
if str_eq(fn_name, "llm_register_tool") { return true }
|
|
if str_eq(fn_name, "dharma_emit") { return true }
|
|
if str_eq(fn_name, "dharma_field") { return true }
|
|
return false
|
|
}
|
|
|
|
// Any DHARMA primitive - utilities have zero network presence.
|
|
fn is_dharma_call(fn_name: String) -> Bool {
|
|
if str_eq(fn_name, "dharma_connect") { return true }
|
|
if str_eq(fn_name, "dharma_send") { return true }
|
|
if str_eq(fn_name, "dharma_activate") { return true }
|
|
if str_eq(fn_name, "dharma_emit") { return true }
|
|
if str_eq(fn_name, "dharma_field") { return true }
|
|
if str_eq(fn_name, "dharma_strengthen") { return true }
|
|
if str_eq(fn_name, "dharma_relationship") { return true }
|
|
if str_eq(fn_name, "dharma_peers") { return true }
|
|
return false
|
|
}
|
|
|
|
// Any LLM primitive - utilities have no LLM access at all.
|
|
fn is_llm_call(fn_name: String) -> Bool {
|
|
if str_eq(fn_name, "llm_call") { return true }
|
|
if str_eq(fn_name, "llm_call_system") { return true }
|
|
if str_eq(fn_name, "llm_call_agentic") { return true }
|
|
if str_eq(fn_name, "llm_vision") { return true }
|
|
if str_eq(fn_name, "llm_register_tool") { return true }
|
|
if str_eq(fn_name, "llm_models") { return true }
|
|
return false
|
|
}
|
|
|
|
fn cap_check_call(fn_name: String) -> Bool {
|
|
let kind: String = state_get("__program_kind")
|
|
if str_eq(kind, "cgi") { return true }
|
|
if str_eq(kind, "service") {
|
|
if is_self_formation_call(fn_name) {
|
|
cap_record_violation("service", fn_name)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
// utility (default)
|
|
if is_dharma_call(fn_name) {
|
|
cap_record_violation("utility", fn_name)
|
|
return false
|
|
}
|
|
if is_llm_call(fn_name) {
|
|
cap_record_violation("utility", fn_name)
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Emit collected capability violations as #error directives. Called
|
|
// from codegen()'s entry point right after the cgi/service-block scan,
|
|
// so they appear at the very top of the generated C.
|
|
fn emit_cap_violations() -> Void {
|
|
let csv: String = state_get("__cap_violations")
|
|
if str_eq(csv, "") { return }
|
|
if str_eq(csv, ",") { return }
|
|
let n: Int = str_len(csv)
|
|
let i: Int = 1
|
|
while i < n {
|
|
let next_comma: Int = str_index_of(str_slice(csv, i, n), ",")
|
|
if next_comma < 0 { return }
|
|
let entry: String = str_slice(csv, i, i + next_comma)
|
|
let colon: Int = str_index_of(entry, ":")
|
|
if colon > 0 {
|
|
let kind: String = str_slice(entry, 0, colon)
|
|
let fn_name: String = str_slice(entry, colon + 1, str_len(entry))
|
|
emit_line("#error \"capability violation: '" + kind + "' programs may not call '" + fn_name + "' (self-formation primitive - only 'cgi' programs may use it)\"")
|
|
}
|
|
let i = i + next_comma + 1
|
|
}
|
|
}
|
|
|
|
// Surface temporal-type violations as #error directives. The cg_expr BinOp
|
|
// dispatcher records each violation (Instant + Instant, Duration + Int, -)
|
|
// as a CSV entry "kind:detail" via time_record_violation. Each entry maps
|
|
// to a single #error so downstream cc fails the build with a clear El-
|
|
// source-level message before the bogus C even links.
|
|
fn emit_time_violations() -> Void {
|
|
let csv: String = state_get("__time_violations")
|
|
if str_eq(csv, "") { return }
|
|
if str_eq(csv, ",") { return }
|
|
let n: Int = str_len(csv)
|
|
let i: Int = 1
|
|
while i < n {
|
|
let next_comma: Int = str_index_of(str_slice(csv, i, n), ",")
|
|
if next_comma < 0 { return }
|
|
let entry: String = str_slice(csv, i, i + next_comma)
|
|
let colon: Int = str_index_of(entry, ":")
|
|
if colon > 0 {
|
|
let detail: String = str_slice(entry, colon + 1, str_len(entry))
|
|
emit_line("#error \"temporal type error: " + detail + "\"")
|
|
}
|
|
let i = i + next_comma + 1
|
|
}
|
|
}
|
|
|
|
// -- Builtin arity table -------------------------------------------------------
|
|
//
|
|
// El programs sometimes call runtime builtins with the wrong number of
|
|
// arguments (e.g. `http_serve(port)` instead of `http_serve(port, handler)`).
|
|
// Without this check the generated C compiles to a call with too few /
|
|
// too many args and fails downstream cc with a generic "too few arguments"
|
|
// message that doesn't point to the El source line.
|
|
//
|
|
// Strategy: a small static table mirrors el_runtime.h. Variadic builtins
|
|
// (el_list_new, el_map_new, args) and unknown identifiers (user fns,
|
|
// dynamic dispatch) return -1 -> no check. A mismatch records a violation
|
|
// in process state, which emit_arity_violations() turns into #error
|
|
// directives at the top of the generated C.
|
|
fn builtin_arity(name: String) -> Int {
|
|
// I/O
|
|
if str_eq(name, "println") { return 1 }
|
|
if str_eq(name, "print") { return 1 }
|
|
if str_eq(name, "readline") { return 0 }
|
|
// String
|
|
if str_eq(name, "el_str_concat") { return 2 }
|
|
if str_eq(name, "str_eq") { return 2 }
|
|
if str_eq(name, "str_starts_with") { return 2 }
|
|
if str_eq(name, "str_ends_with") { return 2 }
|
|
if str_eq(name, "str_len") { return 1 }
|
|
if str_eq(name, "str_concat") { return 2 }
|
|
if str_eq(name, "int_to_str") { return 1 }
|
|
if str_eq(name, "str_to_int") { return 1 }
|
|
if str_eq(name, "str_slice") { return 3 }
|
|
if str_eq(name, "str_contains") { return 2 }
|
|
if str_eq(name, "str_replace") { return 3 }
|
|
if str_eq(name, "str_to_upper") { return 1 }
|
|
if str_eq(name, "str_to_lower") { return 1 }
|
|
if str_eq(name, "str_trim") { return 1 }
|
|
if str_eq(name, "str_index_of") { return 2 }
|
|
if str_eq(name, "str_split") { return 2 }
|
|
if str_eq(name, "str_char_at") { return 2 }
|
|
if str_eq(name, "str_char_code") { return 2 }
|
|
if str_eq(name, "str_pad_left") { return 3 }
|
|
if str_eq(name, "str_pad_right") { return 3 }
|
|
if str_eq(name, "str_format") { return 2 }
|
|
if str_eq(name, "str_lower") { return 1 }
|
|
if str_eq(name, "str_upper") { return 1 }
|
|
// Text-processing primitives (Phase 1)
|
|
if str_eq(name, "str_count") { return 2 }
|
|
if str_eq(name, "str_count_chars") { return 1 }
|
|
if str_eq(name, "str_count_bytes") { return 1 }
|
|
if str_eq(name, "str_count_lines") { return 1 }
|
|
if str_eq(name, "str_count_words") { return 1 }
|
|
if str_eq(name, "str_count_letters") { return 1 }
|
|
if str_eq(name, "str_count_digits") { return 1 }
|
|
if str_eq(name, "str_index_of_all") { return 2 }
|
|
if str_eq(name, "str_last_index_of") { return 2 }
|
|
if str_eq(name, "str_find_chars") { return 2 }
|
|
if str_eq(name, "str_repeat") { return 2 }
|
|
if str_eq(name, "str_reverse") { return 1 }
|
|
if str_eq(name, "str_strip_prefix") { return 2 }
|
|
if str_eq(name, "str_strip_suffix") { return 2 }
|
|
if str_eq(name, "str_strip_chars") { return 2 }
|
|
if str_eq(name, "str_lstrip") { return 1 }
|
|
if str_eq(name, "str_rstrip") { return 1 }
|
|
if str_eq(name, "is_letter") { return 1 }
|
|
if str_eq(name, "is_digit") { return 1 }
|
|
if str_eq(name, "is_alphanumeric") { return 1 }
|
|
if str_eq(name, "is_whitespace") { return 1 }
|
|
if str_eq(name, "is_punctuation") { return 1 }
|
|
if str_eq(name, "is_uppercase") { return 1 }
|
|
if str_eq(name, "is_lowercase") { return 1 }
|
|
if str_eq(name, "str_split_lines") { return 1 }
|
|
if str_eq(name, "str_split_chars") { return 1 }
|
|
if str_eq(name, "str_split_n") { return 3 }
|
|
if str_eq(name, "str_join") { return 2 }
|
|
// HTML sanitizer
|
|
if str_eq(name, "el_html_sanitize") { return 2 }
|
|
// Math
|
|
if str_eq(name, "el_abs") { return 1 }
|
|
if str_eq(name, "el_max") { return 2 }
|
|
if str_eq(name, "el_min") { return 2 }
|
|
// List
|
|
if str_eq(name, "el_list_len") { return 1 }
|
|
if str_eq(name, "el_list_get") { return 2 }
|
|
if str_eq(name, "el_list_append") { return 2 }
|
|
if str_eq(name, "el_list_empty") { return 0 }
|
|
if str_eq(name, "el_list_clone") { return 1 }
|
|
if str_eq(name, "list_push") { return 2 }
|
|
if str_eq(name, "list_push_front") { return 2 }
|
|
if str_eq(name, "list_join") { return 2 }
|
|
if str_eq(name, "list_range") { return 2 }
|
|
// Map
|
|
if str_eq(name, "el_get_field") { return 2 }
|
|
if str_eq(name, "el_map_get") { return 2 }
|
|
if str_eq(name, "el_map_set") { return 3 }
|
|
// HTTP
|
|
if str_eq(name, "http_get") { return 1 }
|
|
if str_eq(name, "http_post") { return 2 }
|
|
if str_eq(name, "http_post_json") { return 2 }
|
|
if str_eq(name, "http_get_with_headers") { return 2 }
|
|
if str_eq(name, "http_post_with_headers") { return 3 }
|
|
if str_eq(name, "http_post_form_auth") { return 3 }
|
|
if str_eq(name, "http_serve") { return 2 }
|
|
if str_eq(name, "http_set_handler") { return 1 }
|
|
// Filesystem
|
|
if str_eq(name, "fs_read") { return 1 }
|
|
if str_eq(name, "fs_write") { return 2 }
|
|
if str_eq(name, "fs_list") { return 1 }
|
|
// JSON
|
|
if str_eq(name, "json_get") { return 2 }
|
|
if str_eq(name, "json_parse") { return 1 }
|
|
if str_eq(name, "json_stringify") { return 1 }
|
|
if str_eq(name, "json_get_string") { return 2 }
|
|
if str_eq(name, "json_get_int") { return 2 }
|
|
if str_eq(name, "json_get_float") { return 2 }
|
|
if str_eq(name, "json_get_bool") { return 2 }
|
|
if str_eq(name, "json_get_raw") { return 2 }
|
|
if str_eq(name, "json_set") { return 3 }
|
|
if str_eq(name, "json_array_len") { return 1 }
|
|
// Time
|
|
if str_eq(name, "time_now") { return 0 }
|
|
if str_eq(name, "time_now_utc") { return 0 }
|
|
if str_eq(name, "sleep_secs") { return 1 }
|
|
if str_eq(name, "sleep_ms") { return 1 }
|
|
if str_eq(name, "time_format") { return 2 }
|
|
if str_eq(name, "time_to_parts") { return 1 }
|
|
if str_eq(name, "time_from_parts") { return 3 }
|
|
if str_eq(name, "time_add") { return 3 }
|
|
if str_eq(name, "time_diff") { return 3 }
|
|
// UUID
|
|
if str_eq(name, "uuid_new") { return 0 }
|
|
if str_eq(name, "uuid_v4") { return 0 }
|
|
// Env / state
|
|
if str_eq(name, "env") { return 1 }
|
|
if str_eq(name, "state_set") { return 2 }
|
|
if str_eq(name, "state_get") { return 1 }
|
|
if str_eq(name, "state_del") { return 1 }
|
|
if str_eq(name, "state_keys") { return 0 }
|
|
// Float
|
|
if str_eq(name, "float_to_str") { return 1 }
|
|
if str_eq(name, "int_to_float") { return 1 }
|
|
if str_eq(name, "float_to_int") { return 1 }
|
|
if str_eq(name, "format_float") { return 2 }
|
|
if str_eq(name, "decimal_round") { return 2 }
|
|
if str_eq(name, "str_to_float") { return 1 }
|
|
// Math (Float)
|
|
if str_eq(name, "math_sqrt") { return 1 }
|
|
if str_eq(name, "math_log") { return 1 }
|
|
if str_eq(name, "math_ln") { return 1 }
|
|
if str_eq(name, "math_sin") { return 1 }
|
|
if str_eq(name, "math_cos") { return 1 }
|
|
if str_eq(name, "math_pi") { return 0 }
|
|
// Bool
|
|
if str_eq(name, "bool_to_str") { return 1 }
|
|
// Process
|
|
if str_eq(name, "exit_program") { return 1 }
|
|
// Process info
|
|
if str_eq(name, "getpid_now") { return 0 }
|
|
// stdout redirect (used by elc post-processing)
|
|
if str_eq(name, "stdout_to_file") { return 1 }
|
|
if str_eq(name, "stdout_restore") { return 0 }
|
|
// Subprocess execution
|
|
if str_eq(name, "exec_command") { return 1 }
|
|
if str_eq(name, "exec_capture") { return 1 }
|
|
if str_eq(name, "exec") { return 1 }
|
|
if str_eq(name, "exec_bg") { return 1 }
|
|
// CGI / DHARMA
|
|
if str_eq(name, "dharma_connect") { return 1 }
|
|
if str_eq(name, "dharma_send") { return 2 }
|
|
if str_eq(name, "dharma_activate") { return 1 }
|
|
if str_eq(name, "dharma_emit") { return 2 }
|
|
if str_eq(name, "dharma_field") { return 1 }
|
|
if str_eq(name, "dharma_strengthen") { return 2 }
|
|
if str_eq(name, "dharma_relationship") { return 1 }
|
|
if str_eq(name, "dharma_peers") { return 0 }
|
|
// Engram
|
|
if str_eq(name, "engram_node") { return 3 }
|
|
if str_eq(name, "engram_node_full") { return 8 }
|
|
if str_eq(name, "engram_get_node") { return 1 }
|
|
if str_eq(name, "engram_strengthen") { return 1 }
|
|
if str_eq(name, "engram_forget") { return 1 }
|
|
if str_eq(name, "engram_node_count") { return 0 }
|
|
if str_eq(name, "engram_search") { return 2 }
|
|
if str_eq(name, "engram_scan_nodes") { return 2 }
|
|
if str_eq(name, "engram_connect") { return 4 }
|
|
if str_eq(name, "engram_edge_between") { return 2 }
|
|
if str_eq(name, "engram_neighbors") { return 1 }
|
|
if str_eq(name, "engram_neighbors_filtered") { return 3 }
|
|
if str_eq(name, "engram_edge_count") { return 0 }
|
|
if str_eq(name, "engram_activate") { return 2 }
|
|
if str_eq(name, "engram_save") { return 1 }
|
|
if str_eq(name, "engram_load") { return 1 }
|
|
if str_eq(name, "engram_get_node_json") { return 1 }
|
|
if str_eq(name, "engram_search_json") { return 2 }
|
|
if str_eq(name, "engram_scan_nodes_json") { return 2 }
|
|
if str_eq(name, "engram_neighbors_json") { return 3 }
|
|
if str_eq(name, "engram_activate_json") { return 2 }
|
|
if str_eq(name, "engram_stats_json") { return 0 }
|
|
// LLM
|
|
if str_eq(name, "llm_call") { return 2 }
|
|
if str_eq(name, "llm_call_system") { return 3 }
|
|
if str_eq(name, "llm_call_agentic") { return 4 }
|
|
if str_eq(name, "llm_vision") { return 4 }
|
|
if str_eq(name, "llm_models") { return 0 }
|
|
if str_eq(name, "llm_register_tool") { return 2 }
|
|
// Crypto
|
|
if str_eq(name, "sha256_hex") { return 1 }
|
|
if str_eq(name, "sha256_bytes") { return 1 }
|
|
if str_eq(name, "hmac_sha256_hex") { return 2 }
|
|
if str_eq(name, "hmac_sha256_bytes") { return 2 }
|
|
if str_eq(name, "base64_encode") { return 1 }
|
|
if str_eq(name, "base64_decode") { return 1 }
|
|
if str_eq(name, "base64url_encode") { return 1 }
|
|
if str_eq(name, "base64url_decode") { return 1 }
|
|
// Native VM aliases
|
|
if str_eq(name, "native_list_get") { return 2 }
|
|
if str_eq(name, "native_list_len") { return 1 }
|
|
if str_eq(name, "native_list_append") { return 2 }
|
|
if str_eq(name, "native_list_empty") { return 0 }
|
|
if str_eq(name, "native_list_clone") { return 1 }
|
|
if str_eq(name, "native_string_chars") { return 1 }
|
|
if str_eq(name, "native_int_to_str") { return 1 }
|
|
// Method-call aliases
|
|
if str_eq(name, "append") { return 2 }
|
|
if str_eq(name, "len") { return 1 }
|
|
if str_eq(name, "get") { return 2 }
|
|
if str_eq(name, "map_get") { return 2 }
|
|
if str_eq(name, "map_set") { return 3 }
|
|
// -1 sentinel: variadic / unknown / user-defined -> no check.
|
|
return -1
|
|
}
|
|
|
|
fn arity_record_violation(fn_name: String, expected: Int, actual: Int) -> Bool {
|
|
let csv: String = state_get("__arity_violations")
|
|
if str_eq(csv, "") { let csv = "," }
|
|
// Encode as fn_name|expected|actual to recover all three at emit time.
|
|
let entry: String = fn_name + "|" + native_int_to_str(expected) + "|" + native_int_to_str(actual)
|
|
let key: String = "," + entry + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__arity_violations", csv + entry + ",")
|
|
return true
|
|
}
|
|
|
|
// Validate the call's arity against the builtin table. Returns true (always)
|
|
// because cg_expr ignores the result; -1 from builtin_arity signals
|
|
// "no check possible" (variadic or user-defined). A mismatch is recorded
|
|
// and surfaced as an #error at the bottom of the generated C, so cc fails
|
|
// before it ever attempts to type-check the wrong call.
|
|
fn arity_check_call(fn_name: String, actual: Int) -> Bool {
|
|
let expected: Int = builtin_arity(fn_name)
|
|
if expected < 0 { return true }
|
|
if expected == actual { return true }
|
|
arity_record_violation(fn_name, expected, actual)
|
|
return true
|
|
}
|
|
|
|
// Emit recorded arity violations as #error directives.
|
|
fn emit_arity_violations() -> Void {
|
|
let csv: String = state_get("__arity_violations")
|
|
if str_eq(csv, "") { return }
|
|
if str_eq(csv, ",") { return }
|
|
let n: Int = str_len(csv)
|
|
let i: Int = 1
|
|
while i < n {
|
|
let next_comma: Int = str_index_of(str_slice(csv, i, n), ",")
|
|
if next_comma < 0 { return }
|
|
let entry: String = str_slice(csv, i, i + next_comma)
|
|
let p1: Int = str_index_of(entry, "|")
|
|
if p1 > 0 {
|
|
let fn_name: String = str_slice(entry, 0, p1)
|
|
let rest: String = str_slice(entry, p1 + 1, str_len(entry))
|
|
let p2: Int = str_index_of(rest, "|")
|
|
if p2 > 0 {
|
|
let exp_s: String = str_slice(rest, 0, p2)
|
|
let act_s: String = str_slice(rest, p2 + 1, str_len(rest))
|
|
emit_line("#error \"arity error: '" + fn_name + "' takes " + exp_s + " arguments, but called with " + act_s + "\"")
|
|
}
|
|
}
|
|
let i = i + next_comma + 1
|
|
}
|
|
}
|
|
|
|
fn add_int_name(name: String) -> Bool {
|
|
let csv: String = state_get("__int_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__int_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn add_instant_name(name: String) -> Bool {
|
|
let csv: String = state_get("__instant_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__instant_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn add_duration_name(name: String) -> Bool {
|
|
let csv: String = state_get("__duration_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__duration_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn add_calendar_name(name: String) -> Bool {
|
|
let csv: String = state_get("__calendar_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__calendar_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn add_caltime_name(name: String) -> Bool {
|
|
let csv: String = state_get("__caltime_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__caltime_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn add_rhythm_name(name: String) -> Bool {
|
|
let csv: String = state_get("__rhythm_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__rhythm_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn add_localdate_name(name: String) -> Bool {
|
|
let csv: String = state_get("__localdate_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__localdate_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn add_localtime_name(name: String) -> Bool {
|
|
let csv: String = state_get("__localtime_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__localtime_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn add_localdt_name(name: String) -> Bool {
|
|
let csv: String = state_get("__localdt_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__localdt_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn add_zone_name(name: String) -> Bool {
|
|
let csv: String = state_get("__zone_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__zone_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn build_int_names_for_params(params: [Map<String, Any>]) -> Bool {
|
|
state_set("__int_names", ",")
|
|
state_set("__instant_names", ",")
|
|
state_set("__duration_names", ",")
|
|
state_set("__calendar_names", ",")
|
|
state_set("__caltime_names", ",")
|
|
state_set("__rhythm_names", ",")
|
|
state_set("__localdate_names", ",")
|
|
state_set("__localtime_names", ",")
|
|
state_set("__localdt_names", ",")
|
|
state_set("__zone_names", ",")
|
|
let np: Int = native_list_len(params)
|
|
let pi = 0
|
|
while pi < np {
|
|
let param = native_list_get(params, pi)
|
|
let pname: String = param["name"]
|
|
let ptype: String = param["type"]
|
|
if str_eq(ptype, "Int") {
|
|
add_int_name(pname)
|
|
}
|
|
if str_eq(ptype, "Instant") {
|
|
add_instant_name(pname)
|
|
}
|
|
if str_eq(ptype, "Duration") {
|
|
add_duration_name(pname)
|
|
}
|
|
if str_eq(ptype, "Calendar") {
|
|
add_calendar_name(pname)
|
|
}
|
|
if str_eq(ptype, "CalendarTime") {
|
|
add_caltime_name(pname)
|
|
}
|
|
if str_eq(ptype, "Rhythm") {
|
|
add_rhythm_name(pname)
|
|
}
|
|
if str_eq(ptype, "LocalDate") {
|
|
add_localdate_name(pname)
|
|
}
|
|
if str_eq(ptype, "LocalTime") {
|
|
add_localtime_name(pname)
|
|
}
|
|
if str_eq(ptype, "LocalDateTime") {
|
|
add_localdt_name(pname)
|
|
}
|
|
if str_eq(ptype, "Zone") {
|
|
add_zone_name(pname)
|
|
}
|
|
let pi = pi + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn cg_fn(stmt: Map<String, Any>) -> Void {
|
|
let fn_name: String = stmt["name"]
|
|
// Skip El's `fn main()` - C provides its own main() for top-level stmts
|
|
// and a duplicate `el_val_t main(void)` would collide with it.
|
|
if fn_name == "main" { return }
|
|
let params = stmt["params"]
|
|
let body = stmt["body"]
|
|
let ret_type: String = stmt["ret_type"]
|
|
let params_c: String = params_to_c(params)
|
|
// VBD role enforcement: dharma_emit / dharma_field may only be called
|
|
// from @manager-decorated functions. Surface violations to the C compiler
|
|
// via #error directives emitted before the function definition.
|
|
let decorator: String = stmt["decorator"]
|
|
if vbd_has_restricted_call(body) {
|
|
if !str_eq(decorator, "manager") {
|
|
emit_line("#error \"VBD violation: dharma_emit/dharma_field called from non-@manager fn '" + fn_name + "'\"")
|
|
}
|
|
}
|
|
// Seed the per-function int-name set so the `+` codegen can dispatch
|
|
// arithmetic vs concat on type-annotated identifiers.
|
|
build_int_names_for_params(params)
|
|
emit_line("el_val_t " + fn_name + "(" + params_c + ") {")
|
|
// Seed declared with parameter names so reassignment works
|
|
let decl = native_list_empty()
|
|
let np: Int = native_list_len(params)
|
|
let pi = 0
|
|
while pi < np {
|
|
let param = native_list_get(params, pi)
|
|
let pname: String = param["name"]
|
|
let decl = native_list_append(decl, pname)
|
|
let pi = pi + 1
|
|
}
|
|
// Lift the final bare expression into an explicit return so implicit
|
|
// returns ("fn lex(s) { ... tokens }") actually return their value.
|
|
// Void-returning functions skip this - wrapping `println(x)` in
|
|
// `return -` is a C type error.
|
|
let body_xformed = body
|
|
if !str_eq(ret_type, "Void") {
|
|
let body_xformed = transform_implicit_return(body)
|
|
}
|
|
cg_stmts(body_xformed, " ", decl)
|
|
emit_line(" return 0;")
|
|
emit_line("}")
|
|
emit_blank()
|
|
}
|
|
|
|
// -- Top-level codegen ---------------------------------------------------------
|
|
|
|
fn is_fndef(stmt: Map<String, Any>) -> Bool {
|
|
let kind: String = stmt["stmt"]
|
|
if kind == "FnDef" { return true }
|
|
false
|
|
}
|
|
|
|
fn is_top_level_decl(stmt: Map<String, Any>) -> Bool {
|
|
let kind: String = stmt["stmt"]
|
|
if kind == "TypeDef" { return true }
|
|
if kind == "EnumDef" { return true }
|
|
if kind == "Import" { return true }
|
|
if kind == "CgiBlock" { return true }
|
|
if kind == "ExternFn" { return true }
|
|
if kind == "TestDef" { return true }
|
|
false
|
|
}
|
|
|
|
// Format a string-or-EL_NULL argument for el_cgi_init.
|
|
fn cgi_arg(value: String, has_value: Bool) -> String {
|
|
if has_value {
|
|
return "EL_STR(" + c_str_lit(value) + ")"
|
|
}
|
|
return "EL_NULL"
|
|
}
|
|
|
|
// -- VBD role enforcement ------------------------------------------------------
|
|
//
|
|
// Scan a function body for direct calls to DHARMA-restricted builtins
|
|
// (dharma_emit, dharma_field). These may only appear inside @manager fns.
|
|
|
|
fn vbd_is_restricted_name(name: String) -> Bool {
|
|
if str_eq(name, "dharma_emit") { return true }
|
|
if str_eq(name, "dharma_field") { return true }
|
|
false
|
|
}
|
|
|
|
fn vbd_expr_has_restricted_call(expr: Map<String, Any>) -> Bool {
|
|
let kind: String = expr["expr"]
|
|
if str_eq(kind, "Call") {
|
|
let func = expr["func"]
|
|
let fk: String = func["expr"]
|
|
if str_eq(fk, "Ident") {
|
|
let fname: String = func["name"]
|
|
if vbd_is_restricted_name(fname) { return true }
|
|
}
|
|
if vbd_expr_has_restricted_call(func) { return true }
|
|
let args = expr["args"]
|
|
let an: Int = native_list_len(args)
|
|
let ai = 0
|
|
while ai < an {
|
|
let a = native_list_get(args, ai)
|
|
if vbd_expr_has_restricted_call(a) { return true }
|
|
let ai = ai + 1
|
|
}
|
|
return false
|
|
}
|
|
if str_eq(kind, "BinOp") {
|
|
let l = expr["left"]
|
|
let r = expr["right"]
|
|
if vbd_expr_has_restricted_call(l) { return true }
|
|
if vbd_expr_has_restricted_call(r) { return true }
|
|
return false
|
|
}
|
|
if str_eq(kind, "Not") {
|
|
return vbd_expr_has_restricted_call(expr["inner"])
|
|
}
|
|
if str_eq(kind, "Neg") {
|
|
return vbd_expr_has_restricted_call(expr["inner"])
|
|
}
|
|
if str_eq(kind, "Field") {
|
|
return vbd_expr_has_restricted_call(expr["object"])
|
|
}
|
|
if str_eq(kind, "Index") {
|
|
if vbd_expr_has_restricted_call(expr["object"]) { return true }
|
|
if vbd_expr_has_restricted_call(expr["index"]) { return true }
|
|
return false
|
|
}
|
|
if str_eq(kind, "Try") {
|
|
return vbd_expr_has_restricted_call(expr["inner"])
|
|
}
|
|
if str_eq(kind, "Array") {
|
|
let elems = expr["elems"]
|
|
let n: Int = native_list_len(elems)
|
|
let i = 0
|
|
while i < n {
|
|
let e = native_list_get(elems, i)
|
|
if vbd_expr_has_restricted_call(e) { return true }
|
|
let i = i + 1
|
|
}
|
|
return false
|
|
}
|
|
if str_eq(kind, "Map") {
|
|
let pairs = expr["pairs"]
|
|
let n: Int = native_list_len(pairs)
|
|
let i = 0
|
|
while i < n {
|
|
let pair = native_list_get(pairs, i)
|
|
let v = pair["value"]
|
|
if vbd_expr_has_restricted_call(v) { return true }
|
|
let i = i + 1
|
|
}
|
|
return false
|
|
}
|
|
if str_eq(kind, "If") {
|
|
if vbd_expr_has_restricted_call(expr["cond"]) { return true }
|
|
if vbd_has_restricted_call(expr["then"]) { return true }
|
|
if vbd_has_restricted_call(expr["else"]) { return true }
|
|
return false
|
|
}
|
|
if str_eq(kind, "For") {
|
|
if vbd_expr_has_restricted_call(expr["list"]) { return true }
|
|
if vbd_has_restricted_call(expr["body"]) { return true }
|
|
return false
|
|
}
|
|
if str_eq(kind, "Match") {
|
|
if vbd_expr_has_restricted_call(expr["subject"]) { return true }
|
|
let arms = expr["arms"]
|
|
let n: Int = native_list_len(arms)
|
|
let i = 0
|
|
while i < n {
|
|
let arm = native_list_get(arms, i)
|
|
let body = arm["body"]
|
|
if vbd_expr_has_restricted_call(body) { return true }
|
|
let i = i + 1
|
|
}
|
|
return false
|
|
}
|
|
false
|
|
}
|
|
|
|
fn vbd_has_restricted_call(stmts: [Map<String, Any>]) -> Bool {
|
|
let n: Int = native_list_len(stmts)
|
|
let i = 0
|
|
while i < n {
|
|
let s = native_list_get(stmts, i)
|
|
let sk: String = s["stmt"]
|
|
if str_eq(sk, "Let") {
|
|
if vbd_expr_has_restricted_call(s["value"]) { return true }
|
|
}
|
|
if str_eq(sk, "Return") {
|
|
if vbd_expr_has_restricted_call(s["value"]) { return true }
|
|
}
|
|
if str_eq(sk, "Expr") {
|
|
if vbd_expr_has_restricted_call(s["value"]) { return true }
|
|
}
|
|
if str_eq(sk, "While") {
|
|
if vbd_expr_has_restricted_call(s["cond"]) { return true }
|
|
if vbd_has_restricted_call(s["body"]) { return true }
|
|
}
|
|
if str_eq(sk, "For") {
|
|
if vbd_expr_has_restricted_call(s["list"]) { return true }
|
|
if vbd_has_restricted_call(s["body"]) { return true }
|
|
}
|
|
let i = i + 1
|
|
}
|
|
false
|
|
}
|
|
|
|
// -- Test mode codegen ----------------------------------------------------------
|
|
//
|
|
// reporter = "text" → human-readable output to stderr
|
|
// reporter = "json" → newline-delimited JSON to stdout
|
|
//
|
|
// Each test function signature: static int el_test_N(void)
|
|
// Returns 0 = pass, non-zero = fail.
|
|
//
|
|
// Text assert: if (!expr) { fprintf(stderr, " FAIL <name> — <msg>\n"); return 1; }
|
|
// JSON assert: stores the assert_line for the runner's suite_end emission.
|
|
// Emits {"type":"test_fail",...} to stdout then returns 1.
|
|
|
|
fn cg_stmt_assert_text(stmt: Map<String, Any>, test_name: String) -> Void {
|
|
let expr_node = stmt["expr"]
|
|
let msg: String = stmt["msg"]
|
|
let expr_c: String = cg_expr(expr_node)
|
|
let expr_c = strip_outer_parens(expr_c)
|
|
let disp_msg = "assert failed"
|
|
if !str_eq(msg, "") { let disp_msg = msg }
|
|
emit_line(" if (!(" + expr_c + ")) {")
|
|
emit_line(" fprintf(stderr, \" FAIL " + c_escape(test_name) + " \\xe2\\x80\\x94 " + c_escape(disp_msg) + "\\n\");")
|
|
emit_line(" return 1;")
|
|
emit_line(" }")
|
|
}
|
|
|
|
fn cg_stmt_assert_json(stmt: Map<String, Any>, test_name: String, file_name: String, test_line: Int) -> Void {
|
|
let expr_node = stmt["expr"]
|
|
let msg: String = stmt["msg"]
|
|
let assert_line: Int = stmt["line"]
|
|
let expr_c: String = cg_expr(expr_node)
|
|
let expr_c = strip_outer_parens(expr_c)
|
|
let disp_msg = "assert failed"
|
|
if !str_eq(msg, "") { let disp_msg = msg }
|
|
// Embed all compile-time-known strings as C string literals (no %s runtime formatting).
|
|
let json_line: String = "{\"type\":\"test_fail\",\"name\":\"" + c_escape(test_name) + "\",\"file\":\"" + c_escape(file_name) + "\",\"line\":" + native_int_to_str(test_line) + ",\"assert_line\":" + native_int_to_str(assert_line) + ",\"message\":\"" + c_escape(disp_msg) + "\"}"
|
|
emit_line(" if (!(" + expr_c + ")) {")
|
|
emit_line(" puts(" + c_str_lit(json_line) + ");")
|
|
emit_line(" return 1;")
|
|
emit_line(" }")
|
|
}
|
|
|
|
// cg_stmts_in_test: emit test body statements, routing Assert to the
|
|
// appropriate handler based on reporter mode.
|
|
fn cg_stmts_in_test(stmts: [Map<String, Any>], indent: String, declared: [String], test_name: String, reporter: String, file_name: String, test_line: Int) -> [String] {
|
|
let n: Int = native_list_len(stmts)
|
|
let i = 0
|
|
let decl = declared
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let sk: String = stmt["stmt"]
|
|
if str_eq(sk, "Assert") {
|
|
if str_eq(reporter, "json") {
|
|
cg_stmt_assert_json(stmt, test_name, file_name, test_line)
|
|
} else {
|
|
cg_stmt_assert_text(stmt, test_name)
|
|
}
|
|
} else {
|
|
let decl = cg_stmt(stmt, indent, decl)
|
|
}
|
|
let i = i + 1
|
|
}
|
|
decl
|
|
}
|
|
|
|
// cg_test_fn: emit a single test function.
|
|
fn cg_test_fn(test_def: Map<String, Any>, idx: Int, reporter: String, file_name: String) -> String {
|
|
let fn_name: String = "el_test_" + native_int_to_str(idx)
|
|
let test_name: String = test_def["name"]
|
|
let test_line: Int = test_def["line"]
|
|
let body = test_def["body"]
|
|
emit_line("static int " + fn_name + "(void) {")
|
|
cg_stmts_in_test(body, " ", native_list_empty(), test_name, reporter, file_name, test_line)
|
|
emit_line(" return 0;")
|
|
emit_line("}")
|
|
emit_blank()
|
|
fn_name
|
|
}
|
|
|
|
// codegen_test: emit a complete test binary.
|
|
// reporter: "text" (stderr human-readable) or "json" (stdout ndjson)
|
|
// file_name: basename of the source file (used in JSON output)
|
|
fn codegen_test(stmts: [Map<String, Any>], reporter: String, file_name: String) -> Void {
|
|
// Collect all TestDef nodes in order.
|
|
let n: Int = native_list_len(stmts)
|
|
let test_defs: [Map<String, Any>] = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let sk: String = stmt["stmt"]
|
|
if str_eq(sk, "TestDef") {
|
|
let test_defs = native_list_append(test_defs, stmt)
|
|
}
|
|
let i = i + 1
|
|
}
|
|
let n_tests: Int = native_list_len(test_defs)
|
|
|
|
// Emit forward declarations for test functions.
|
|
let ti = 0
|
|
while ti < n_tests {
|
|
let fn_name: String = "el_test_" + native_int_to_str(ti)
|
|
emit_line("static int " + fn_name + "(void);")
|
|
let ti = ti + 1
|
|
}
|
|
emit_blank()
|
|
|
|
// Emit all non-test, non-main function definitions.
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
if is_fndef(stmt) {
|
|
let fn_name: String = stmt["name"]
|
|
if !str_eq(fn_name, "main") {
|
|
cg_fn(stmt)
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
|
|
// Emit each test function.
|
|
let ti = 0
|
|
while ti < n_tests {
|
|
let test_def = native_list_get(test_defs, ti)
|
|
cg_test_fn(test_def, ti, reporter, file_name)
|
|
let ti = ti + 1
|
|
}
|
|
|
|
// Emit the test runner main().
|
|
let test_word = "tests"
|
|
if n_tests == 1 { let test_word = "test" }
|
|
emit_line("int main(void) {")
|
|
emit_line(" int pass = 0; int fail = 0;")
|
|
|
|
if str_eq(reporter, "json") {
|
|
// JSON reporter: all strings are compile-time constants; use puts.
|
|
// Only suite_end needs runtime pass/fail counts (printf).
|
|
let suite_start_json: String = "{\"type\":\"suite_start\",\"file\":\"" + c_escape(file_name) + "\",\"total\":" + native_int_to_str(n_tests) + "}"
|
|
emit_line(" puts(" + c_str_lit(suite_start_json) + ");")
|
|
let ti = 0
|
|
while ti < n_tests {
|
|
let test_def = native_list_get(test_defs, ti)
|
|
let test_name: String = test_def["name"]
|
|
let test_line: Int = test_def["line"]
|
|
let fn_name: String = "el_test_" + native_int_to_str(ti)
|
|
let start_json: String = "{\"type\":\"test_start\",\"name\":\"" + c_escape(test_name) + "\",\"file\":\"" + c_escape(file_name) + "\",\"line\":" + native_int_to_str(test_line) + "}"
|
|
let pass_json: String = "{\"type\":\"test_pass\",\"name\":\"" + c_escape(test_name) + "\",\"file\":\"" + c_escape(file_name) + "\",\"line\":" + native_int_to_str(test_line) + ",\"duration_ms\":0}"
|
|
emit_line(" puts(" + c_str_lit(start_json) + ");")
|
|
emit_line(" if (" + fn_name + "() == 0) {")
|
|
emit_line(" pass++;")
|
|
emit_line(" puts(" + c_str_lit(pass_json) + ");")
|
|
emit_line(" } else { fail++; }")
|
|
let ti = ti + 1
|
|
}
|
|
// suite_end needs runtime pass/fail counts
|
|
emit_line(" printf(\"{\\\"type\\\":\\\"suite_end\\\",\\\"passed\\\":%d,\\\"failed\\\":%d}\\n\", pass, fail);")
|
|
} else {
|
|
// Text reporter: human-readable to stderr
|
|
emit_line(" fprintf(stderr, \"==> running " + native_int_to_str(n_tests) + " " + test_word + "\\n\\n\");")
|
|
let ti = 0
|
|
while ti < n_tests {
|
|
let test_def = native_list_get(test_defs, ti)
|
|
let test_name: String = test_def["name"]
|
|
let fn_name: String = "el_test_" + native_int_to_str(ti)
|
|
emit_line(" fprintf(stderr, \" RUN " + c_escape(test_name) + "\\n\");")
|
|
emit_line(" if (" + fn_name + "() == 0) { pass++; fprintf(stderr, \" PASS " + c_escape(test_name) + "\\n\"); }")
|
|
emit_line(" else { fail++; }")
|
|
let ti = ti + 1
|
|
}
|
|
emit_line(" fprintf(stderr, \"\\n%d passed, %d failed\\n\", pass, fail);")
|
|
}
|
|
|
|
emit_line(" return fail > 0 ? 1 : 0;")
|
|
emit_line("}")
|
|
emit_blank()
|
|
}
|
|
|
|
// -- Entry point ----------------------------------------------------------------
|
|
|
|
fn codegen(stmts: [Map<String, Any>], source: String) -> String {
|
|
codegen_inner(stmts, source, false, "text", "")
|
|
}
|
|
|
|
// codegen_with_tests: emit a test binary.
|
|
// reporter: "text" or "json"
|
|
// file_name: basename of the source file (used in JSON output)
|
|
fn codegen_with_tests(stmts: [Map<String, Any>], source: String, reporter: String, file_name: String) -> String {
|
|
codegen_inner(stmts, source, true, reporter, file_name)
|
|
}
|
|
|
|
fn codegen_inner(stmts: [Map<String, Any>], source: String, test_mode: Bool, reporter: String, file_name: String) -> String {
|
|
// Detect cgi/service blocks: at most one declarative top-level block.
|
|
// The block determines the program's CAPABILITY KIND:
|
|
// "cgi" - full self-formation. Calls all primitives.
|
|
// "service" - bounded. Cannot call self-formation primitives
|
|
// (llm_call_agentic, llm_register_tool, dharma_emit,
|
|
// dharma_field, mindlink-creation).
|
|
// "utility" - default; no DHARMA membership, no LLM, no agentic.
|
|
// Codegen enforces this with #error directives at every restricted
|
|
// call site. The capability boundary is structural: a binary either
|
|
// CAN or CANNOT do a thing, and the compiler decides at emission time.
|
|
let n_top: Int = native_list_len(stmts)
|
|
let cgi_count = 0
|
|
let cgi_block: Map<String, Any> = { "stmt": "None" }
|
|
let svc_count = 0
|
|
let svc_block: Map<String, Any> = { "stmt": "None" }
|
|
let ti = 0
|
|
while ti < n_top {
|
|
let s = native_list_get(stmts, ti)
|
|
let sk: String = s["stmt"]
|
|
if str_eq(sk, "CgiBlock") {
|
|
let cgi_count = cgi_count + 1
|
|
if cgi_count == 1 {
|
|
let cgi_block = s
|
|
}
|
|
}
|
|
if str_eq(sk, "ServiceBlock") {
|
|
let svc_count = svc_count + 1
|
|
if svc_count == 1 {
|
|
let svc_block = s
|
|
}
|
|
}
|
|
let ti = ti + 1
|
|
}
|
|
if cgi_count > 1 {
|
|
emit_line("#error \"El: multiple cgi blocks in program (only one allowed)\"")
|
|
}
|
|
if svc_count > 1 {
|
|
emit_line("#error \"El: multiple service blocks in program (only one allowed)\"")
|
|
}
|
|
if cgi_count >= 1 {
|
|
if svc_count >= 1 {
|
|
emit_line("#error \"El: program declares both cgi and service blocks (mutually exclusive - pick one)\"")
|
|
}
|
|
}
|
|
// Stash the program kind so cg_expr's Call branch can enforce
|
|
// per-kind capability restrictions on every emitted call.
|
|
let kind: String = "utility"
|
|
if cgi_count >= 1 { let kind = "cgi" }
|
|
if svc_count >= 1 { let kind = "service" }
|
|
state_set("__program_kind", kind)
|
|
// Clear capability-violation accumulator from any prior compile.
|
|
state_set("__cap_violations", "")
|
|
// Clear arity-violation accumulator from any prior compile.
|
|
state_set("__arity_violations", "")
|
|
// Clear temporal-type-violation accumulator from any prior compile.
|
|
state_set("__time_violations", "")
|
|
|
|
// In test mode, delegate to the test-specific path which emits test
|
|
// functions and a test runner main() instead of the normal program.
|
|
// Test mode still needs the standard preamble (#includes, forward
|
|
// decls) so we emit that before branching.
|
|
//
|
|
// Preamble
|
|
emit_line("#include <stdint.h>")
|
|
emit_line("#include <stdlib.h>")
|
|
emit_line("#include <stdio.h>")
|
|
emit_line("#include \"el_runtime.h\"")
|
|
|
|
// Cross-module forward declarations: for each imported module, emit
|
|
// #include "module.elh" so Clang sees the function signatures from
|
|
// that module without needing the full source inlined. The .elh files
|
|
// are generated by `elc --emit-header` and live in the same dist/
|
|
// directory as the generated .c files. We use basename only (strip
|
|
// the directory prefix and .el extension) so the include resolves
|
|
// correctly regardless of the source tree layout.
|
|
let imp_n: Int = native_list_len(stmts)
|
|
let imp_i = 0
|
|
while imp_i < imp_n {
|
|
let imp_stmt = native_list_get(stmts, imp_i)
|
|
let imp_kind: String = imp_stmt["stmt"]
|
|
if str_eq(imp_kind, "Import") {
|
|
let imp_path: String = imp_stmt["path"]
|
|
// Extract basename: find last '/' and strip from there.
|
|
let imp_path_len: Int = str_len(imp_path)
|
|
let imp_last_slash: Int = -1
|
|
let imp_j: Int = 0
|
|
while imp_j < imp_path_len {
|
|
let imp_c: String = str_slice(imp_path, imp_j, imp_j + 1)
|
|
if str_eq(imp_c, "/") { let imp_last_slash = imp_j }
|
|
let imp_j = imp_j + 1
|
|
}
|
|
let imp_base: String = str_slice(imp_path, imp_last_slash + 1, imp_path_len)
|
|
// Strip .el extension if present.
|
|
let imp_base_len: Int = str_len(imp_base)
|
|
let imp_bname: String = imp_base
|
|
if str_ends_with(imp_base, ".el") {
|
|
let imp_bname = str_slice(imp_base, 0, imp_base_len - 3)
|
|
}
|
|
emit_line("#include \"" + imp_bname + ".elh\"")
|
|
}
|
|
let imp_i = imp_i + 1
|
|
}
|
|
emit_blank()
|
|
|
|
// Forward declarations (skip `main` - C provides its own)
|
|
let n: Int = native_list_len(stmts)
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let kind: String = stmt["stmt"]
|
|
if kind == "FnDef" {
|
|
let fn_name: String = stmt["name"]
|
|
if !str_eq(fn_name, "main") {
|
|
let params = stmt["params"]
|
|
let params_c: String = params_to_c(params)
|
|
emit_line("el_val_t " + fn_name + "(" + params_c + ");")
|
|
}
|
|
}
|
|
if kind == "ExternFn" {
|
|
let fn_name: String = stmt["name"]
|
|
let params = stmt["params"]
|
|
let params_c: String = params_to_c(params)
|
|
emit_line("el_val_t " + fn_name + "(" + params_c + ");")
|
|
}
|
|
let i = i + 1
|
|
}
|
|
emit_blank()
|
|
|
|
// Top-level `let` bindings -> file-scope storage. El programs use
|
|
// top-level `let GREETING = "..."` as module constants that any
|
|
// function below should be able to read. Without this pass, a top-
|
|
// level Let only declares the name inside main()'s scope and any
|
|
// function referencing it compiles to an undefined-symbol use of
|
|
// the bare name (or, with non-static linkage, fails to link).
|
|
//
|
|
// We emit each top-level Let as `el_val_t NAME = VALUE;` at file
|
|
// scope and seed the int-name set when the binding is `: Int` so
|
|
// arithmetic/concat dispatch on the name works inside functions.
|
|
// Runtime-call initializers (e.g. `let m = el_map_new(...)`) cannot
|
|
// appear in C static initializers, so we emit a non-const slot and
|
|
// initialize it at the top of main() before any user statements run.
|
|
let has_toplevel_lets = false
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let kind: String = stmt["stmt"]
|
|
if str_eq(kind, "Let") {
|
|
let name: String = stmt["name"]
|
|
let ltype: String = stmt["type"]
|
|
if str_eq(ltype, "Int") { add_int_name(name) }
|
|
let val = stmt["value"]
|
|
let vk: String = val["expr"]
|
|
if str_eq(vk, "Int") { add_int_name(name) }
|
|
emit_line("el_val_t " + name + ";")
|
|
let has_toplevel_lets = true
|
|
}
|
|
let i = i + 1
|
|
}
|
|
if has_toplevel_lets {
|
|
emit_blank()
|
|
}
|
|
|
|
// Test mode: emit test functions and test runner instead of normal program.
|
|
if test_mode {
|
|
codegen_test(stmts, reporter, file_name)
|
|
emit_cap_violations()
|
|
emit_arity_violations()
|
|
emit_time_violations()
|
|
return ""
|
|
}
|
|
|
|
// Detect whether this compilation unit has an entry point.
|
|
// A unit is a library (no C main emitted) when there is no fn main()
|
|
// and no top-level executable statements. This supports separate
|
|
// compilation: library .c files contain only function definitions.
|
|
let has_el_main = false
|
|
let has_toplevel_stmts = false
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let sk: String = stmt["stmt"]
|
|
if str_eq(sk, "FnDef") {
|
|
let fn_name_chk: String = stmt["name"]
|
|
if str_eq(fn_name_chk, "main") { let has_el_main = true }
|
|
}
|
|
if !is_fndef(stmt) {
|
|
if !is_top_level_decl(stmt) {
|
|
if !str_eq(sk, "Let") {
|
|
let has_toplevel_stmts = true
|
|
}
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
let is_library = false
|
|
if !has_el_main {
|
|
if !has_toplevel_stmts {
|
|
let is_library = true
|
|
}
|
|
}
|
|
|
|
// Function definitions
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
if is_fndef(stmt) {
|
|
cg_fn(stmt)
|
|
}
|
|
let i = i + 1
|
|
}
|
|
|
|
// Skip C main() for library units (no fn main, no top-level stmts)
|
|
if is_library { return "" }
|
|
|
|
// main(). Use _argc/_argv so El programs are free to declare their own
|
|
// local `argv` / `argc` (compiler.el itself does this) without colliding
|
|
// with the C-side parameters when fn main()'s body is folded in below.
|
|
emit_line("int main(int _argc, char** _argv) {")
|
|
emit_line(" el_runtime_init_args(_argc, _argv);")
|
|
if cgi_count >= 1 {
|
|
let cname: String = cgi_block["name"]
|
|
let cdid: String = cgi_block["dharma_id"]
|
|
let cprin: String = cgi_block["principal"]
|
|
let cnet: String = cgi_block["network"]
|
|
let ceng: String = cgi_block["engram"]
|
|
let has_did: Bool = cgi_block["has_dharma_id"]
|
|
let has_prin: Bool = cgi_block["has_principal"]
|
|
let has_net: Bool = cgi_block["has_network"]
|
|
let has_eng: Bool = cgi_block["has_engram"]
|
|
let arg_name: String = "EL_STR(" + c_str_lit(cname) + ")"
|
|
let arg_did: String = cgi_arg(cdid, has_did)
|
|
let arg_prin: String = cgi_arg(cprin, has_prin)
|
|
let arg_net: String = cgi_arg(cnet, has_net)
|
|
let arg_eng: String = cgi_arg(ceng, has_eng)
|
|
emit_line(" el_cgi_init(" + arg_name + ", " + arg_did + ", " + arg_prin + ", " + arg_net + ", " + arg_eng + ");")
|
|
}
|
|
// Seed `declared` with the names of every top-level Let so that
|
|
// cg_stmt emits plain assignment (`X = ...;`) instead of a redundant
|
|
// `el_val_t X = ...;` shadowing the file-scope slot.
|
|
let main_decl = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let kind: String = stmt["stmt"]
|
|
if str_eq(kind, "Let") {
|
|
let name: String = stmt["name"]
|
|
let main_decl = native_list_append(main_decl, name)
|
|
}
|
|
let i = i + 1
|
|
}
|
|
// First pass: capture the body of `fn main()` if the source declared
|
|
// one. We've already skipped emitting it as a regular el_val_t
|
|
// function (see cg_fn early return); fold its body into C's main
|
|
// alongside top-level statements so the program actually runs.
|
|
let el_main_body = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
if is_fndef(stmt) {
|
|
let fn_name: String = stmt["name"]
|
|
if str_eq(fn_name, "main") {
|
|
let body = stmt["body"]
|
|
let bn: Int = native_list_len(body)
|
|
let bi: Int = 0
|
|
while bi < bn {
|
|
let el_main_body = native_list_append(el_main_body, native_list_get(body, bi))
|
|
let bi = bi + 1
|
|
}
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
if is_fndef(stmt) {
|
|
// skip - fn defs already emitted above; fn main body folded later
|
|
} else {
|
|
if is_top_level_decl(stmt) {
|
|
// skip
|
|
} else {
|
|
let main_decl = cg_stmt(stmt, " ", main_decl)
|
|
}
|
|
}
|
|
// Release AST node after final use - each stmt is fully processed
|
|
// by this point (forward decls, fn defs, top-level lets, and now
|
|
// the main-body pass are all done). Releasing here prevents the
|
|
// accumulated AST from exhausting memory on large source files.
|
|
el_release(stmt)
|
|
let i = i + 1
|
|
}
|
|
|
|
// Fold fn main()'s body in here, after top-level statements.
|
|
let mn: Int = native_list_len(el_main_body)
|
|
let mi: Int = 0
|
|
while mi < mn {
|
|
let mstmt = native_list_get(el_main_body, mi)
|
|
let main_decl = cg_stmt(mstmt, " ", main_decl)
|
|
let mi = mi + 1
|
|
}
|
|
|
|
emit_line(" return 0;")
|
|
emit_line("}")
|
|
emit_blank()
|
|
|
|
// Emit any accumulated capability-violation #error directives. cc
|
|
// will fail on the first one and surface the message; placement at
|
|
// the bottom is fine - preprocessor errors halt the build wherever
|
|
// they appear.
|
|
emit_cap_violations()
|
|
// Same for builtin-arity violations: cc halts on the first #error,
|
|
// so a misuse of a known builtin (wrong arg count) fails the build
|
|
// with a clear message naming the builtin and its expected arity.
|
|
emit_arity_violations()
|
|
// Temporal-type violations (Instant + Instant, Duration + Int, -).
|
|
emit_time_violations()
|
|
|
|
// Return empty string - output was streamed via println
|
|
""
|
|
}
|
|
// codegen-js.el — El compiler JavaScript source code generator
|
|
//
|
|
// Input: list of AST statement maps (from parser.el)
|
|
// Output: JavaScript source printed to stdout (streamed, one line at a time)
|
|
//
|
|
// Each El program compiles to a single .js file that imports el_runtime.js
|
|
// (which side-effects globals so call sites stay flat — println(x), not
|
|
// el.println(x)). Functions map to JS function declarations; top-level
|
|
// statements run at module load.
|
|
//
|
|
// Entry point: fn codegen_js(stmts: [Map<String, Any>], source: String) -> String
|
|
// Returns "" — output goes to stdout via println().
|
|
//
|
|
// This file mirrors codegen.el (the C backend). Where the C backend has to
|
|
// fight the int64_t-everywhere convention to dispatch arithmetic vs concat
|
|
// or `==` vs `str_eq`, the JS backend can usually let JS's own operator
|
|
// semantics do the right thing. We retain the dispatch logic for clarity
|
|
// and so that explicit calls to `el_str_concat` or `str_eq` still work.
|
|
|
|
// ── String helpers ────────────────────────────────────────────────────────────
|
|
|
|
// Escape a JS string literal (double-quotes, backslashes, newlines, etc.).
|
|
fn js_escape(s: String) -> String {
|
|
let chars: [String] = native_string_chars(s)
|
|
let total: Int = native_list_len(chars)
|
|
let parts: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < total {
|
|
let ch: String = native_list_get(chars, i)
|
|
if ch == "\"" {
|
|
let parts = native_list_append(parts, "\\\"")
|
|
} else {
|
|
if ch == "\\" {
|
|
let parts = native_list_append(parts, "\\\\")
|
|
} else {
|
|
if ch == "\n" {
|
|
let parts = native_list_append(parts, "\\n")
|
|
} else {
|
|
if ch == "\r" {
|
|
let parts = native_list_append(parts, "\\r")
|
|
} else {
|
|
if ch == "\t" {
|
|
let parts = native_list_append(parts, "\\t")
|
|
} else {
|
|
let parts = native_list_append(parts, ch)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
str_join(parts, "")
|
|
}
|
|
|
|
fn js_str_lit(s: String) -> String {
|
|
"\"" + js_escape(s) + "\""
|
|
}
|
|
|
|
// ── Code emission ─────────────────────────────────────────────────────────────
|
|
|
|
fn js_emit_line(line: String) -> Void {
|
|
println(line)
|
|
}
|
|
|
|
fn js_emit_blank() -> Void {
|
|
println("")
|
|
}
|
|
|
|
// ── Operator helpers ──────────────────────────────────────────────────────────
|
|
|
|
fn js_binop(op: String) -> String {
|
|
if op == "Plus" { return "+" }
|
|
if op == "Minus" { return "-" }
|
|
if op == "Star" { return "*" }
|
|
if op == "Slash" { return "/" }
|
|
if op == "Percent" { return "%" }
|
|
if op == "EqEq" { return "===" }
|
|
if op == "NotEq" { return "!==" }
|
|
if op == "Lt" { return "<" }
|
|
if op == "Gt" { return ">" }
|
|
if op == "LtEq" { return "<=" }
|
|
if op == "GtEq" { return ">=" }
|
|
if op == "And" { return "&&" }
|
|
if op == "Or" { return "||" }
|
|
op
|
|
}
|
|
|
|
// ── Known El runtime method names ─────────────────────────────────────────────
|
|
//
|
|
// These are the method shortforms exported by el_runtime.js and used by the
|
|
// El C-backend convention of `obj.method(args)` -> `method(obj, args)`.
|
|
// Any method name NOT in this set is treated as a native JS method call on the
|
|
// receiver object, emitting `obj.method(args)` directly.
|
|
//
|
|
// This is the mechanism that makes `client.auth.signInWithOtp(payload)` work
|
|
// without `native_js_call`: the receiver is Any-typed, the method is unknown
|
|
// to El, so codegen emits the JS call directly.
|
|
|
|
fn js_is_el_method(name: String) -> Bool {
|
|
if str_eq(name, "append") { return true }
|
|
if str_eq(name, "len") { return true }
|
|
if str_eq(name, "get") { return true }
|
|
if str_eq(name, "map_get") { return true }
|
|
if str_eq(name, "map_set") { return true }
|
|
false
|
|
}
|
|
|
|
// ── Async function tracking ───────────────────────────────────────────────────
|
|
//
|
|
// Functions decorated with @async are recorded here. Any call to a known-async
|
|
// builtin (http_get, http_post, http_post_json) or to a user-declared @async
|
|
// function gets an `await` prefix in generated JS.
|
|
//
|
|
// Known-async builtins — these return Promise<T> in el_runtime.js.
|
|
fn js_is_async_builtin(name: String) -> Bool {
|
|
if str_eq(name, "http_get") { return true }
|
|
if str_eq(name, "http_post") { return true }
|
|
if str_eq(name, "http_post_json") { return true }
|
|
if str_eq(name, "http_get_with_headers") { return true }
|
|
if str_eq(name, "http_post_with_headers") { return true }
|
|
false
|
|
}
|
|
|
|
fn js_register_async_fn(name: String) -> Bool {
|
|
let csv: String = state_get("__js_async_fns")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__js_async_fns", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn js_is_async_fn(name: String) -> Bool {
|
|
let csv: String = state_get("__js_async_fns")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
// ── Int-name tracking (mirrors codegen.el) ────────────────────────────────────
|
|
|
|
fn js_is_int_name(name: String) -> Bool {
|
|
let csv: String = state_get("__js_int_names")
|
|
if str_eq(csv, "") { return false }
|
|
return str_contains(csv, "," + name + ",")
|
|
}
|
|
|
|
fn js_add_int_name(name: String) -> Bool {
|
|
let csv: String = state_get("__js_int_names")
|
|
if str_eq(csv, "") { csv = "," }
|
|
let key: String = "," + name + ","
|
|
if str_contains(csv, key) { return true }
|
|
state_set("__js_int_names", csv + name + ",")
|
|
return true
|
|
}
|
|
|
|
fn js_build_int_names_for_params(params: [Map<String, Any>]) -> Bool {
|
|
state_set("__js_int_names", ",")
|
|
let np: Int = native_list_len(params)
|
|
let pi = 0
|
|
while pi < np {
|
|
let param = native_list_get(params, pi)
|
|
let pname: String = param["name"]
|
|
let ptype: String = param["type"]
|
|
if str_eq(ptype, "Int") {
|
|
js_add_int_name(pname)
|
|
}
|
|
let pi = pi + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn js_is_int_call(call_expr: Map<String, Any>) -> Bool {
|
|
let func = call_expr["func"]
|
|
let fk: String = func["expr"]
|
|
if !str_eq(fk, "Ident") { return false }
|
|
let name: String = func["name"]
|
|
if str_eq(name, "str_len") { return true }
|
|
if str_eq(name, "str_index_of") { return true }
|
|
if str_eq(name, "str_to_int") { return true }
|
|
if str_eq(name, "str_char_code") { return true }
|
|
if str_eq(name, "native_list_len") { return true }
|
|
if str_eq(name, "el_list_len") { return true }
|
|
if str_eq(name, "len") { return true }
|
|
if str_eq(name, "json_get_int") { return true }
|
|
if str_eq(name, "time_now") { return true }
|
|
if str_eq(name, "time_now_utc") { return true }
|
|
if str_eq(name, "el_abs") { return true }
|
|
if str_eq(name, "el_max") { return true }
|
|
if str_eq(name, "el_min") { return true }
|
|
return false
|
|
}
|
|
|
|
// ── HTML template codegen (JS) ────────────────────────────────────────────────
|
|
//
|
|
// HTML template expressions compile to a JS IIFE that builds the HTML string
|
|
// using string concatenation. Interpolated values go through html_escape();
|
|
// raw() bypasses escaping. {#each} blocks compile to Array.forEach or a
|
|
// for-loop that pushes fragments into a parts array.
|
|
//
|
|
// Entry point: js_cg_html_template(expr) → JS expression string.
|
|
|
|
fn js_next_html_id() -> String {
|
|
let csv: String = state_get("__js_html_counter")
|
|
let n = 0
|
|
if !str_eq(csv, "") {
|
|
let n = str_to_int(csv)
|
|
}
|
|
let n = n + 1
|
|
state_set("__js_html_counter", native_int_to_str(n))
|
|
native_int_to_str(n)
|
|
}
|
|
|
|
fn js_cg_html_parts(children: [Map<String, Any>], acc_var: String) -> String {
|
|
let n: Int = native_list_len(children)
|
|
let i = 0
|
|
let out = ""
|
|
while i < n {
|
|
let child: Map<String, Any> = native_list_get(children, i)
|
|
let html_kind: String = child["html"]
|
|
if str_eq(html_kind, "Text") {
|
|
let text: String = child["text"]
|
|
let out = out + acc_var + " += " + js_str_lit(text) + "; "
|
|
}
|
|
if str_eq(html_kind, "Doctype") {
|
|
let out = out + acc_var + " += \"<!doctype html>\"; "
|
|
}
|
|
if str_eq(html_kind, "Interp") {
|
|
let val_node = child["value"]
|
|
let val_c: String = js_cg_expr(val_node)
|
|
let out = out + acc_var + " += html_escape(" + val_c + "); "
|
|
}
|
|
if str_eq(html_kind, "Raw") {
|
|
let val_node = child["value"]
|
|
let val_c: String = js_cg_expr(val_node)
|
|
let out = out + acc_var + " += html_raw(" + val_c + "); "
|
|
}
|
|
if str_eq(html_kind, "Element") {
|
|
let elem_c: String = js_cg_html_element_str(child, acc_var)
|
|
let out = out + elem_c
|
|
}
|
|
if str_eq(html_kind, "Each") {
|
|
let each_c: String = js_cg_html_each(child, acc_var)
|
|
let out = out + each_c
|
|
}
|
|
let i = i + 1
|
|
}
|
|
out
|
|
}
|
|
|
|
fn js_cg_html_attrs_str(attrs: [Map<String, Any>], acc_var: String) -> String {
|
|
let n: Int = native_list_len(attrs)
|
|
let i = 0
|
|
let out = ""
|
|
while i < n {
|
|
let attr: Map<String, Any> = native_list_get(attrs, i)
|
|
let attr_name: String = attr["name"]
|
|
let kind: String = attr["kind"]
|
|
// open-attr snippet: " name=\""
|
|
let open_val: String = " " + attr_name + "=\""
|
|
if str_eq(kind, "static") {
|
|
let sv: String = attr["value"]
|
|
let out = out + acc_var + " += " + js_str_lit(open_val) + "; "
|
|
let out = out + acc_var + " += " + js_str_lit(sv) + "; "
|
|
let out = out + acc_var + " += " + js_str_lit("\"") + "; "
|
|
} else {
|
|
if str_eq(kind, "dynamic") {
|
|
let val_node = attr["value"]
|
|
let val_c: String = js_cg_expr(val_node)
|
|
let out = out + acc_var + " += " + js_str_lit(open_val) + "; "
|
|
let out = out + acc_var + " += html_escape(" + val_c + "); "
|
|
let out = out + acc_var + " += " + js_str_lit("\"") + "; "
|
|
} else {
|
|
// Boolean attribute
|
|
let out = out + acc_var + " += " + js_str_lit(" " + attr_name) + "; "
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
out
|
|
}
|
|
|
|
fn js_cg_html_element_str(elem: Map<String, Any>, acc_var: String) -> String {
|
|
let tag: String = elem["tag"]
|
|
let attrs: [Map<String, Any>] = elem["attrs"]
|
|
let children: [Map<String, Any>] = elem["children"]
|
|
let self_closing: Bool = elem["self_closing"]
|
|
let out = acc_var + " += " + js_str_lit("<" + tag) + "; "
|
|
let out = out + js_cg_html_attrs_str(attrs, acc_var)
|
|
if self_closing {
|
|
let out = out + acc_var + " += \"/>\"" + "; "
|
|
} else {
|
|
let out = out + acc_var + " += \">\"; "
|
|
let out = out + js_cg_html_parts(children, acc_var)
|
|
let out = out + acc_var + " += " + js_str_lit("</" + tag + ">") + "; "
|
|
}
|
|
out
|
|
}
|
|
|
|
fn js_cg_html_each(node: Map<String, Any>, acc_var: String) -> String {
|
|
let list_expr = node["list"]
|
|
let item_name: String = node["item"]
|
|
let body_children: [Map<String, Any>] = node["body"]
|
|
let id: String = js_next_html_id()
|
|
let list_var: String = "_html_list_" + id
|
|
let len_var: String = "_html_len_" + id
|
|
let idx_var: String = "_html_i_" + id
|
|
let list_c: String = js_cg_expr(list_expr)
|
|
let inner_c: String = js_cg_html_parts(body_children, acc_var)
|
|
"{ const " + list_var + " = " + list_c + "; const " + len_var + " = el_list_len(" + list_var + "); for (let " + idx_var + " = 0; " + idx_var + " < " + len_var + "; " + idx_var + "++) { const " + item_name + " = el_list_get(" + list_var + ", " + idx_var + "); " + inner_c + "} } "
|
|
}
|
|
|
|
fn js_cg_html_template(expr: Map<String, Any>) -> String {
|
|
let root = expr["root"]
|
|
let id: String = js_next_html_id()
|
|
let acc: String = "_html_" + id
|
|
let doctype_flag: Bool = root["doctype"]
|
|
let doctype_prefix: String = ""
|
|
if doctype_flag {
|
|
let doctype_prefix = acc + " += \"<!doctype html>\"; "
|
|
}
|
|
let body: String = js_cg_html_element_str(root, acc)
|
|
"(() => { let " + acc + " = \"\"; " + doctype_prefix + body + "return " + acc + "; })()"
|
|
}
|
|
|
|
// ── Expression codegen ────────────────────────────────────────────────────────
|
|
//
|
|
// js_cg_expr returns a JS expression string (not a statement).
|
|
//
|
|
// Note: the C backend's `+` dispatch is preserved here for two reasons:
|
|
// 1) Generated output stays grep-equivalent across targets
|
|
// 2) Explicit `el_str_concat()` lives in the runtime; codegen routes
|
|
// through it for ambiguous (Ident+Ident, Call+Call) cases. JS's
|
|
// own `+` would also work, but el_str_concat coerces both sides
|
|
// to strings — closer to the C semantics.
|
|
|
|
fn js_cg_expr(expr: Map<String, Any>) -> String {
|
|
let kind: String = expr["expr"]
|
|
|
|
if kind == "Int" {
|
|
let v: String = expr["value"]
|
|
return v
|
|
}
|
|
|
|
// DurationLit — postfix-literal time value (e.g. 30.seconds, 1.hour).
|
|
// The JS backend lowers to a literal integer nanosecond count. The C
|
|
// backend uses the typed wrapper el_duration_from_nanos to make intent
|
|
// explicit at the runtime boundary; JS has no equivalent shim yet, so
|
|
// we lower directly. A future Phase 2 JS time runtime can route through
|
|
// a wrapper once added.
|
|
if kind == "DurationLit" {
|
|
let count: String = expr["count"]
|
|
let unit: String = expr["unit"]
|
|
let mult_ns = "1"
|
|
if str_eq(unit, "nano") { let mult_ns = "1" }
|
|
if str_eq(unit, "nanos") { let mult_ns = "1" }
|
|
if str_eq(unit, "milli") { let mult_ns = "1000000" }
|
|
if str_eq(unit, "millis") { let mult_ns = "1000000" }
|
|
if str_eq(unit, "millisecond") { let mult_ns = "1000000" }
|
|
if str_eq(unit, "milliseconds") { let mult_ns = "1000000" }
|
|
if str_eq(unit, "second") { let mult_ns = "1000000000" }
|
|
if str_eq(unit, "seconds") { let mult_ns = "1000000000" }
|
|
if str_eq(unit, "minute") { let mult_ns = "60000000000" }
|
|
if str_eq(unit, "minutes") { let mult_ns = "60000000000" }
|
|
if str_eq(unit, "hour") { let mult_ns = "3600000000000" }
|
|
if str_eq(unit, "hours") { let mult_ns = "3600000000000" }
|
|
if str_eq(unit, "day") { let mult_ns = "86400000000000" }
|
|
if str_eq(unit, "days") { let mult_ns = "86400000000000" }
|
|
return "(" + count + " * " + mult_ns + ")"
|
|
}
|
|
|
|
if kind == "Float" {
|
|
// JS numbers are already doubles — no bit-cast trick needed.
|
|
let v: String = expr["value"]
|
|
return v
|
|
}
|
|
|
|
if kind == "Str" {
|
|
let v: String = expr["value"]
|
|
return js_str_lit(v)
|
|
}
|
|
|
|
if kind == "Bool" {
|
|
let v: String = expr["value"]
|
|
if v == "true" { return "true" }
|
|
return "false"
|
|
}
|
|
|
|
if kind == "Nil" {
|
|
return "null"
|
|
}
|
|
|
|
if kind == "Ident" {
|
|
let name: String = expr["name"]
|
|
return name
|
|
}
|
|
|
|
if kind == "Not" {
|
|
let inner = expr["inner"]
|
|
let inner_c: String = js_cg_expr(inner)
|
|
return "!" + inner_c
|
|
}
|
|
|
|
if kind == "Neg" {
|
|
let inner = expr["inner"]
|
|
let inner_c: String = js_cg_expr(inner)
|
|
return "(-" + inner_c + ")"
|
|
}
|
|
|
|
if kind == "BinOp" {
|
|
let op: String = expr["op"]
|
|
let left = expr["left"]
|
|
let right = expr["right"]
|
|
let left_c: String = js_cg_expr(left)
|
|
let right_c: String = js_cg_expr(right)
|
|
let left_kind: String = left["expr"]
|
|
let right_kind: String = right["expr"]
|
|
|
|
// Plus dispatch — same shape as C backend, but we route through
|
|
// el_str_concat for the string-concat path (its JS impl coerces
|
|
// and matches C's behavior). Arithmetic uses bare JS `+`.
|
|
if op == "Plus" {
|
|
if left_kind == "Str" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Str" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if left_kind == "Int" {
|
|
return "(" + left_c + " + " + right_c + ")"
|
|
}
|
|
if right_kind == "Int" {
|
|
return "(" + left_c + " + " + right_c + ")"
|
|
}
|
|
if left_kind == "Ident" {
|
|
if right_kind == "Ident" {
|
|
let lname: String = left["name"]
|
|
let rname: String = right["name"]
|
|
if js_is_int_name(lname) {
|
|
if js_is_int_name(rname) {
|
|
return "(" + left_c + " + " + right_c + ")"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if left_kind == "Ident" {
|
|
if right_kind == "Call" {
|
|
let lname: String = left["name"]
|
|
if js_is_int_name(lname) {
|
|
if js_is_int_call(right) {
|
|
return "(" + left_c + " + " + right_c + ")"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if right_kind == "Ident" {
|
|
if left_kind == "Call" {
|
|
let rname: String = right["name"]
|
|
if js_is_int_name(rname) {
|
|
if js_is_int_call(left) {
|
|
return "(" + left_c + " + " + right_c + ")"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if left_kind == "Call" {
|
|
if right_kind == "Call" {
|
|
if js_is_int_call(left) {
|
|
if js_is_int_call(right) {
|
|
return "(" + left_c + " + " + right_c + ")"
|
|
}
|
|
}
|
|
}
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Call" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
// Fallback: when in doubt, route through el_str_concat. JS's
|
|
// own + handles strings and numbers natively, but el_str_concat
|
|
// gives us a single point of control if behavior needs to diverge.
|
|
if left_kind == "Ident" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
if right_kind == "Ident" {
|
|
return "el_str_concat(" + left_c + ", " + right_c + ")"
|
|
}
|
|
}
|
|
|
|
// Equality dispatch — C backend disambiguates via str_eq for
|
|
// strings and == for ints. JS does both with === if we know
|
|
// the types are uniform; for ambiguous identifier pairs we
|
|
// route through str_eq for safety (it falls back to === in JS).
|
|
if op == "EqEq" {
|
|
if left_kind == "Int" { return "(" + left_c + " === " + right_c + ")" }
|
|
if right_kind == "Int" { return "(" + left_c + " === " + right_c + ")" }
|
|
if left_kind == "Bool" { return "(" + left_c + " === " + right_c + ")" }
|
|
if right_kind == "Bool" { return "(" + left_c + " === " + right_c + ")" }
|
|
if left_kind == "Nil" { return "(" + left_c + " === " + right_c + ")" }
|
|
if right_kind == "Nil" { return "(" + left_c + " === " + right_c + ")" }
|
|
if left_kind == "Ident" {
|
|
if right_kind == "Ident" {
|
|
let lname: String = left["name"]
|
|
let rname: String = right["name"]
|
|
if js_is_int_name(lname) {
|
|
if js_is_int_name(rname) {
|
|
return "(" + left_c + " === " + right_c + ")"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if left_kind == "Str" { return "str_eq(" + left_c + ", " + right_c + ")" }
|
|
if right_kind == "Str" { return "str_eq(" + left_c + ", " + right_c + ")" }
|
|
// Default: === (works for strings, numbers, bools in JS)
|
|
return "(" + left_c + " === " + right_c + ")"
|
|
}
|
|
|
|
if op == "NotEq" {
|
|
if left_kind == "Int" { return "(" + left_c + " !== " + right_c + ")" }
|
|
if right_kind == "Int" { return "(" + left_c + " !== " + right_c + ")" }
|
|
if left_kind == "Bool" { return "(" + left_c + " !== " + right_c + ")" }
|
|
if right_kind == "Bool" { return "(" + left_c + " !== " + right_c + ")" }
|
|
if left_kind == "Nil" { return "(" + left_c + " !== " + right_c + ")" }
|
|
if right_kind == "Nil" { return "(" + left_c + " !== " + right_c + ")" }
|
|
if left_kind == "Ident" {
|
|
if right_kind == "Ident" {
|
|
let lname: String = left["name"]
|
|
let rname: String = right["name"]
|
|
if js_is_int_name(lname) {
|
|
if js_is_int_name(rname) {
|
|
return "(" + left_c + " !== " + right_c + ")"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if left_kind == "Str" { return "!str_eq(" + left_c + ", " + right_c + ")" }
|
|
if right_kind == "Str" { return "!str_eq(" + left_c + ", " + right_c + ")" }
|
|
return "(" + left_c + " !== " + right_c + ")"
|
|
}
|
|
|
|
let op_c: String = js_binop(op)
|
|
return "(" + left_c + " " + op_c + " " + right_c + ")"
|
|
}
|
|
|
|
if kind == "Call" {
|
|
let func = expr["func"]
|
|
let args = expr["args"]
|
|
let arity: Int = native_list_len(args)
|
|
let func_kind: String = func["expr"]
|
|
|
|
let args_parts: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < arity {
|
|
let arg = native_list_get(args, i)
|
|
let arg_c: String = js_cg_expr(arg)
|
|
let args_parts = native_list_append(args_parts, arg_c)
|
|
let i = i + 1
|
|
}
|
|
let args_c: String = str_join(args_parts, ", ")
|
|
|
|
if func_kind == "Ident" {
|
|
let fn_name: String = func["name"]
|
|
let call_expr: String = fn_name + "(" + args_c + ")"
|
|
if js_is_async_builtin(fn_name) {
|
|
return "await " + call_expr
|
|
}
|
|
if js_is_async_fn(fn_name) {
|
|
return "await " + call_expr
|
|
}
|
|
return call_expr
|
|
}
|
|
|
|
if func_kind == "Field" {
|
|
let obj = func["object"]
|
|
let field: String = func["field"]
|
|
let obj_c: String = js_cg_expr(obj)
|
|
// If the method is a known El runtime shortform, keep the El
|
|
// convention: `method(obj, args)`. This preserves backward
|
|
// compatibility with list.append(x), map.map_get(k), etc.
|
|
if js_is_el_method(field) {
|
|
if arity > 0 {
|
|
return field + "(" + obj_c + ", " + args_c + ")"
|
|
}
|
|
return field + "(" + obj_c + ")"
|
|
}
|
|
// Unknown method — emit as a native JS method call on the
|
|
// receiver. This handles Any-typed values (third-party library
|
|
// objects, DOM elements, Promises, etc.) without requiring
|
|
// native_js_call. Example: `client.auth.signInWithOtp(payload)`
|
|
// emits `client["auth"].signInWithOtp(args_c)`.
|
|
if arity > 0 {
|
|
return obj_c + "." + field + "(" + args_c + ")"
|
|
}
|
|
return obj_c + "." + field + "()"
|
|
}
|
|
|
|
let fn_c: String = js_cg_expr(func)
|
|
return fn_c + "(" + args_c + ")"
|
|
}
|
|
|
|
if kind == "Field" {
|
|
// El's `obj.foo` becomes JS `obj["foo"]` — direct bracket access.
|
|
// This works for plain El map objects AND for real JS objects with
|
|
// prototype-inherited properties (DOM elements, third-party library
|
|
// objects, Promises, etc.). el_get_field used hasOwnProperty which
|
|
// silently returned null for inherited props, breaking e.g. client.auth.
|
|
//
|
|
// Nil-propagation: `obj?.foo` emits `(obj)?.["foo"] ?? null`.
|
|
let obj = expr["object"]
|
|
let field: String = expr["field"]
|
|
let obj_kind: String = obj["expr"]
|
|
if str_eq(obj_kind, "Try") {
|
|
let inner = obj["inner"]
|
|
let inner_c: String = js_cg_expr(inner)
|
|
return "(" + inner_c + ")?.[" + js_str_lit(field) + "] ?? null"
|
|
}
|
|
let obj_c: String = js_cg_expr(obj)
|
|
return obj_c + "[" + js_str_lit(field) + "]"
|
|
}
|
|
|
|
if kind == "Index" {
|
|
// Map vs list dispatch on the index expression kind, same as C.
|
|
// If the object is a Try (nil-propagation), use JS optional indexing.
|
|
let obj = expr["object"]
|
|
let idx = expr["index"]
|
|
let obj_c: String = js_cg_expr(obj)
|
|
let idx_c: String = js_cg_expr(idx)
|
|
let idx_kind: String = idx["expr"]
|
|
let obj_kind: String = obj["expr"]
|
|
if str_eq(obj_kind, "Try") {
|
|
let inner = obj["inner"]
|
|
let inner_c: String = js_cg_expr(inner)
|
|
return "(" + inner_c + ")?.[" + idx_c + "] ?? null"
|
|
}
|
|
if str_eq(idx_kind, "Str") {
|
|
return "el_get_field(" + obj_c + ", " + idx_c + ")"
|
|
}
|
|
return "el_list_get(" + obj_c + ", " + idx_c + ")"
|
|
}
|
|
|
|
if kind == "Array" {
|
|
let elems = expr["elems"]
|
|
let n: Int = native_list_len(elems)
|
|
if n == 0 { return "[]" }
|
|
let items_parts: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let elem = native_list_get(elems, i)
|
|
let elem_c: String = js_cg_expr(elem)
|
|
let items_parts = native_list_append(items_parts, elem_c)
|
|
let i = i + 1
|
|
}
|
|
return "[" + str_join(items_parts, ", ") + "]"
|
|
}
|
|
|
|
if kind == "Map" {
|
|
let pairs = expr["pairs"]
|
|
let n: Int = native_list_len(pairs)
|
|
if n == 0 { return "{}" }
|
|
let items_parts: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let pair = native_list_get(pairs, i)
|
|
let key: String = pair["key"]
|
|
let val = pair["value"]
|
|
let val_c: String = js_cg_expr(val)
|
|
let items_parts = native_list_append(items_parts, js_str_lit(key) + ": " + val_c)
|
|
let i = i + 1
|
|
}
|
|
return "{" + str_join(items_parts, ", ") + "}"
|
|
}
|
|
|
|
if kind == "Try" {
|
|
// Postfix `?` — nil-propagation guard.
|
|
// When used as `expr?.field` the Field handler above intercepts and
|
|
// emits `(expr)?.["field"]`. Here, a bare `expr?` (not followed by
|
|
// field/index access) passes through to the inner expression unchanged
|
|
// (it acts as an identity but marks the value as "nil-propagating" for
|
|
// its caller). This matches the C backend's current behavior.
|
|
let inner = expr["inner"]
|
|
return js_cg_expr(inner)
|
|
}
|
|
|
|
if kind == "If" {
|
|
let cond = expr["cond"]
|
|
let cond_c: String = js_cg_expr(cond)
|
|
// If as expression: ternary. Body of the if-expression is not
|
|
// currently emitted as expression-form for compound bodies; this
|
|
// matches the C backend's if-expr stub.
|
|
return "(" + cond_c + " ? 1 : 0)"
|
|
}
|
|
|
|
if kind == "Match" {
|
|
return js_cg_match(expr)
|
|
}
|
|
|
|
// Lambda (anonymous function literal): fn(params) -> RetType { body }
|
|
// Emitted as a JS arrow function expression: (params) => { body }.
|
|
// Used for inline callbacks: dom_listen(el, "click", fn(e: Any) -> Void { ... })
|
|
if kind == "Lambda" {
|
|
return js_cg_lambda(expr)
|
|
}
|
|
|
|
if kind == "HtmlTemplate" {
|
|
return js_cg_html_template(expr)
|
|
}
|
|
|
|
"null"
|
|
}
|
|
|
|
// ── Match codegen (basic) ─────────────────────────────────────────────────────
|
|
//
|
|
// Lower a match expression to an IIFE with if/else chain. Works for
|
|
// LitInt / LitStr / LitBool / Wildcard / Binding patterns. Tagged-union
|
|
// destructuring is not implemented — it's stubbed and falls through to
|
|
// the wildcard path.
|
|
|
|
fn js_next_match_id() -> String {
|
|
let csv: String = state_get("__js_match_counter")
|
|
let n = 0
|
|
if !str_eq(csv, "") {
|
|
let n = str_to_int(csv)
|
|
}
|
|
let n = n + 1
|
|
state_set("__js_match_counter", native_int_to_str(n))
|
|
native_int_to_str(n)
|
|
}
|
|
|
|
fn js_cg_match(expr: Map<String, Any>) -> String {
|
|
let subject = expr["subject"]
|
|
let arms = expr["arms"]
|
|
let subj_c: String = js_cg_expr(subject)
|
|
let id: String = js_next_match_id()
|
|
let subj_var: String = "_match_subj_" + id
|
|
let parts: [String] = native_list_empty()
|
|
let parts = native_list_append(parts, "((" + subj_var + ") => { ")
|
|
let n: Int = native_list_len(arms)
|
|
let i = 0
|
|
while i < n {
|
|
let arm = native_list_get(arms, i)
|
|
let pat = arm["pattern"]
|
|
let body = arm["body"]
|
|
let pkind: String = pat["pattern"]
|
|
let body_c: String = js_cg_expr(body)
|
|
if str_eq(pkind, "Wildcard") {
|
|
let parts = native_list_append(parts, "return (" + body_c + "); ")
|
|
} else {
|
|
if str_eq(pkind, "Binding") {
|
|
let bname: String = pat["name"]
|
|
let parts = native_list_append(parts, "{ const " + bname + " = " + subj_var + "; return (" + body_c + "); } ")
|
|
} else {
|
|
if str_eq(pkind, "LitInt") {
|
|
let v: String = pat["value"]
|
|
let parts = native_list_append(parts, "if (" + subj_var + " === " + v + ") return (" + body_c + "); ")
|
|
} else {
|
|
if str_eq(pkind, "LitStr") {
|
|
let v: String = pat["value"]
|
|
let parts = native_list_append(parts, "if (str_eq(" + subj_var + ", " + js_str_lit(v) + ")) return (" + body_c + "); ")
|
|
} else {
|
|
if str_eq(pkind, "LitBool") {
|
|
let v: String = pat["value"]
|
|
let bv = "false"
|
|
if str_eq(v, "true") { let bv = "true" }
|
|
let parts = native_list_append(parts, "if (" + subj_var + " === " + bv + ") return (" + body_c + "); ")
|
|
} else {
|
|
if str_eq(pkind, "Variant") {
|
|
// Enum::Variant patterns — El enums compile to plain
|
|
// strings (the variant name) or ints. Match the subject
|
|
// against the variant name string.
|
|
let variant: String = pat["variant"]
|
|
let parts = native_list_append(parts, "if (str_eq(" + subj_var + ", " + js_str_lit(variant) + ")) return (" + body_c + "); ")
|
|
} else {
|
|
// unknown pattern → wildcard
|
|
let parts = native_list_append(parts, "return (" + body_c + "); ")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
let parts = native_list_append(parts, "return null; })(" + subj_c + ")")
|
|
str_join(parts, "")
|
|
}
|
|
|
|
// ── Lambda codegen ────────────────────────────────────────────────────────────
|
|
//
|
|
// Anonymous function literals: fn(params) -> RetType { body }
|
|
//
|
|
// Strategy: emit the lambda as a hoisted JS function declaration with a
|
|
// generated name (__lambda_N), then return the name as the expression value.
|
|
// This works because JS function declarations are hoisted within their scope,
|
|
// so the generated name is valid at any use site within the same function or
|
|
// module. The emitted code looks like:
|
|
//
|
|
// function __lambda_1(event) { dom_hide(spinner); }
|
|
// ...
|
|
// dom_listen(btn, "click", __lambda_1);
|
|
//
|
|
// This approach is clean, debuggable, and avoids any need for a string-buffer
|
|
// mode in the codegen.
|
|
|
|
fn js_next_lambda_id() -> String {
|
|
let csv: String = state_get("__js_lambda_counter")
|
|
let n = 0
|
|
if !str_eq(csv, "") {
|
|
let n = str_to_int(csv)
|
|
}
|
|
let n = n + 1
|
|
state_set("__js_lambda_counter", native_int_to_str(n))
|
|
native_int_to_str(n)
|
|
}
|
|
|
|
fn js_cg_lambda(expr: Map<String, Any>) -> String {
|
|
let params = expr["params"]
|
|
let body = expr["body"]
|
|
let ret_type: String = expr["ret_type"]
|
|
let id: String = js_next_lambda_id()
|
|
let lambda_name: String = "__lambda_" + id
|
|
let params_str: String = js_params_str(params)
|
|
// Emit the function definition immediately into the output stream.
|
|
// It will appear before the statement containing this expression.
|
|
js_emit_line("function " + lambda_name + "(" + params_str + ") {")
|
|
let decl = native_list_empty()
|
|
let np: Int = native_list_len(params)
|
|
let pi = 0
|
|
while pi < np {
|
|
let param = native_list_get(params, pi)
|
|
let pname: String = param["name"]
|
|
let decl = native_list_append(decl, pname)
|
|
let pi = pi + 1
|
|
}
|
|
let body_xformed = body
|
|
if !str_eq(ret_type, "Void") {
|
|
let body_xformed = js_transform_implicit_return(body)
|
|
}
|
|
js_build_int_names_for_params(params)
|
|
js_cg_stmts(body_xformed, " ", decl)
|
|
js_emit_line("}")
|
|
js_emit_blank()
|
|
// Return the function name as the expression value.
|
|
lambda_name
|
|
}
|
|
|
|
// ── Variable scope tracking ───────────────────────────────────────────────────
|
|
//
|
|
// El allows `let x = ...` to redeclare in the same scope. JS would throw
|
|
// with `let` (Identifier already declared). We track declared names and
|
|
// emit bare `x = ...` on redeclaration, `let x = ...` first time.
|
|
|
|
fn js_list_contains(lst: [String], s: String) -> Bool {
|
|
let n: Int = native_list_len(lst)
|
|
let i = 0
|
|
while i < n {
|
|
let item: String = native_list_get(lst, i)
|
|
if item == s { return true }
|
|
let i = i + 1
|
|
}
|
|
false
|
|
}
|
|
|
|
// ── Statement codegen ─────────────────────────────────────────────────────────
|
|
|
|
fn js_cg_stmt(stmt: Map<String, Any>, indent: String, declared: [String]) -> [String] {
|
|
let kind: String = stmt["stmt"]
|
|
|
|
if kind == "Let" {
|
|
let name: String = stmt["name"]
|
|
let val = stmt["value"]
|
|
let val_c: String = js_cg_expr(val)
|
|
let ltype: String = stmt["type"]
|
|
if str_eq(ltype, "Int") {
|
|
js_add_int_name(name)
|
|
}
|
|
let vk: String = val["expr"]
|
|
if str_eq(vk, "Int") {
|
|
js_add_int_name(name)
|
|
}
|
|
if js_list_contains(declared, name) {
|
|
js_emit_line(indent + name + " = " + val_c + ";")
|
|
return declared
|
|
} else {
|
|
// Use `let` (not `const`) — El semantics allow rebinding.
|
|
js_emit_line(indent + "let " + name + " = " + val_c + ";")
|
|
return native_list_append(declared, name)
|
|
}
|
|
}
|
|
|
|
if kind == "Return" {
|
|
let val = stmt["value"]
|
|
let val_kind: String = val["expr"]
|
|
if val_kind == "Nil" {
|
|
js_emit_line(indent + "return null;")
|
|
} else {
|
|
let val_c: String = js_cg_expr(val)
|
|
js_emit_line(indent + "return " + val_c + ";")
|
|
}
|
|
return declared
|
|
}
|
|
|
|
// Bare reassignment: `name = expr`. Mirrors the C backend — emits a
|
|
// plain JS assignment without `let` so we don't shadow an outer binding.
|
|
if kind == "Assign" {
|
|
let name: String = stmt["name"]
|
|
let val = stmt["value"]
|
|
let val_c: String = js_cg_expr(val)
|
|
js_emit_line(indent + name + " = " + val_c + ";")
|
|
return declared
|
|
}
|
|
|
|
if kind == "Expr" {
|
|
let val = stmt["value"]
|
|
let val_kind: String = val["expr"]
|
|
if val_kind == "If" {
|
|
js_cg_if_stmt(val, indent, declared)
|
|
return declared
|
|
}
|
|
if val_kind == "For" {
|
|
js_cg_for_stmt(val, indent, declared)
|
|
return declared
|
|
}
|
|
let val_c: String = js_cg_expr(val)
|
|
js_emit_line(indent + val_c + ";")
|
|
return declared
|
|
}
|
|
|
|
if kind == "While" {
|
|
let cond = stmt["cond"]
|
|
let body = stmt["body"]
|
|
let cond_c: String = js_cg_expr(cond)
|
|
let cond_c = js_strip_outer_parens(cond_c)
|
|
js_emit_line(indent + "while (" + cond_c + ") {")
|
|
js_cg_stmts(body, indent + " ", native_list_clone(declared))
|
|
js_emit_line(indent + "}")
|
|
return declared
|
|
}
|
|
|
|
if kind == "For" {
|
|
let item: String = stmt["item"]
|
|
let list_expr = stmt["list"]
|
|
let body = stmt["body"]
|
|
js_cg_for_body(item, list_expr, body, indent, declared)
|
|
return declared
|
|
}
|
|
|
|
if kind == "FnDef" { return declared }
|
|
if kind == "TypeDef" { return declared }
|
|
if kind == "EnumDef" { return declared }
|
|
if kind == "Import" { return declared }
|
|
// TestDef: skip in normal mode; handled by js_codegen_test in test mode.
|
|
if kind == "TestDef" { return declared }
|
|
// Assert: no-op in normal mode; handled by js_cg_stmt_assert in test mode.
|
|
if kind == "Assert" { return declared }
|
|
|
|
if kind == "TryCatch" {
|
|
let try_body = stmt["try_body"]
|
|
let catch_name: String = stmt["catch_name"]
|
|
let catch_body = stmt["catch_body"]
|
|
js_emit_line(indent + "try {")
|
|
js_cg_stmts(try_body, indent + " ", native_list_clone(declared))
|
|
js_emit_line(indent + "} catch (" + catch_name + ") {")
|
|
js_cg_stmts(catch_body, indent + " ", native_list_clone(declared))
|
|
js_emit_line(indent + "}")
|
|
return declared
|
|
}
|
|
|
|
// ExternFn: the function exists in the JS environment (loaded via <script>
|
|
// tag or the module context). Emit a comment so the generated file is
|
|
// self-documenting, but no JS function body — the implementation is external.
|
|
if kind == "ExternFn" {
|
|
let ename: String = stmt["name"]
|
|
js_emit_line(indent + "// extern fn " + ename + " — provided by the JS environment")
|
|
return declared
|
|
}
|
|
if kind == "CgiBlock" {
|
|
// CGI blocks compile to a no-op + warning comment in JS target.
|
|
// The runtime cgi identity is server-side; UI code is not a CGI
|
|
// principal. See spec/codegen-js.md §7.
|
|
let cname: String = stmt["name"]
|
|
js_emit_line(indent + "// cgi block '" + cname + "' — no-op in JS target (server-side concept)")
|
|
return declared
|
|
}
|
|
if kind == "ServiceBlock" {
|
|
let sname: String = stmt["name"]
|
|
js_emit_line(indent + "// service block '" + sname + "' — no-op in JS target")
|
|
return declared
|
|
}
|
|
declared
|
|
}
|
|
|
|
// Strip a single layer of surrounding parentheses from a JS expression string.
|
|
fn js_strip_outer_parens(s: String) -> String {
|
|
let chars: [String] = native_string_chars(s)
|
|
let n: Int = native_list_len(chars)
|
|
if n < 2 { return s }
|
|
let first: String = native_list_get(chars, 0)
|
|
let last: String = native_list_get(chars, n - 1)
|
|
if first == "(" {
|
|
if last == ")" {
|
|
let depth = 1
|
|
let i = 1
|
|
let balanced = true
|
|
while i < n - 1 {
|
|
let ch: String = native_list_get(chars, i)
|
|
if ch == "(" {
|
|
let depth = depth + 1
|
|
}
|
|
if ch == ")" {
|
|
let depth = depth - 1
|
|
if depth == 0 {
|
|
let balanced = false
|
|
let i = n
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
if balanced {
|
|
return str_slice(s, 1, n - 1)
|
|
}
|
|
}
|
|
}
|
|
s
|
|
}
|
|
|
|
fn js_cg_if_stmt(expr: Map<String, Any>, indent: String, declared: [String]) -> Void {
|
|
let cond = expr["cond"]
|
|
let then_stmts = expr["then"]
|
|
let else_stmts = expr["else"]
|
|
let has_else: Bool = expr["has_else"]
|
|
let cond_c: String = js_cg_expr(cond)
|
|
let cond_c = js_strip_outer_parens(cond_c)
|
|
js_emit_line(indent + "if (" + cond_c + ") {")
|
|
js_cg_stmts(then_stmts, indent + " ", native_list_clone(declared))
|
|
if has_else {
|
|
js_emit_line(indent + "} else {")
|
|
js_cg_stmts(else_stmts, indent + " ", native_list_clone(declared))
|
|
}
|
|
js_emit_line(indent + "}")
|
|
}
|
|
|
|
fn js_cg_for_body(item: String, list_expr: Map<String, Any>, body: [Map<String, Any>], indent: String, declared: [String]) -> Void {
|
|
let list_c: String = js_cg_expr(list_expr)
|
|
js_emit_line(indent + "for (const " + item + " of " + list_c + ") {")
|
|
let body_decl = native_list_clone(declared)
|
|
let body_decl = native_list_append(body_decl, item)
|
|
js_cg_stmts(body, indent + " ", body_decl)
|
|
js_emit_line(indent + "}")
|
|
}
|
|
|
|
fn js_cg_for_stmt(expr: Map<String, Any>, indent: String, declared: [String]) -> Void {
|
|
let item: String = expr["item"]
|
|
let list_expr = expr["list"]
|
|
let body = expr["body"]
|
|
js_cg_for_body(item, list_expr, body, indent, declared)
|
|
}
|
|
|
|
fn js_cg_stmts(stmts: [Map<String, Any>], indent: String, declared: [String]) -> [String] {
|
|
let n: Int = native_list_len(stmts)
|
|
let i = 0
|
|
let decl = declared
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let decl = js_cg_stmt(stmt, indent, decl)
|
|
let i = i + 1
|
|
}
|
|
decl
|
|
}
|
|
|
|
// ── Function declaration codegen ──────────────────────────────────────────────
|
|
|
|
fn js_params_str(params: [Map<String, Any>]) -> String {
|
|
let n: Int = native_list_len(params)
|
|
if n == 0 { return "" }
|
|
let parts: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let param = native_list_get(params, i)
|
|
let name: String = param["name"]
|
|
let parts = native_list_append(parts, name)
|
|
let i = i + 1
|
|
}
|
|
str_join(parts, ", ")
|
|
}
|
|
|
|
// Same implicit-return transform as the C backend.
|
|
fn js_transform_implicit_return(body: [Map<String, Any>]) -> [Map<String, Any>] {
|
|
let n: Int = native_list_len(body)
|
|
if n == 0 { return body }
|
|
let last: Map<String, Any> = native_list_get(body, n - 1)
|
|
let last_kind: String = last["stmt"]
|
|
if last_kind == "Expr" {
|
|
let val = last["value"]
|
|
let val_kind: String = val["expr"]
|
|
if val_kind == "If" { return body }
|
|
if val_kind == "For" { return body }
|
|
let new_body: [Map<String, Any>] = native_list_empty()
|
|
let i = 0
|
|
while i < n - 1 {
|
|
let new_body = native_list_append(new_body, native_list_get(body, i))
|
|
let i = i + 1
|
|
}
|
|
let return_stmt: Map<String, Any> = { "stmt": "Return", "value": val }
|
|
let new_body = native_list_append(new_body, return_stmt)
|
|
return new_body
|
|
}
|
|
body
|
|
}
|
|
|
|
fn js_cg_fn(stmt: Map<String, Any>) -> Void {
|
|
let fn_name: String = stmt["name"]
|
|
let params = stmt["params"]
|
|
let body = stmt["body"]
|
|
let ret_type: String = stmt["ret_type"]
|
|
let decorator: String = stmt["decorator"]
|
|
let params_str: String = js_params_str(params)
|
|
js_build_int_names_for_params(params)
|
|
|
|
// Detect @async decorator — emit `async function` and register the name
|
|
// so call sites for this function get `await` prefixed automatically.
|
|
// When the decorator field is absent, el_get_field returns null; str_eq
|
|
// handles null safely (returns false), so no special nil-check is needed.
|
|
if str_eq(decorator, "async") {
|
|
js_register_async_fn(fn_name)
|
|
if fn_name == "main" {
|
|
js_emit_line("async function main(" + params_str + ") {")
|
|
} else {
|
|
js_emit_line("async function " + fn_name + "(" + params_str + ") {")
|
|
}
|
|
} else {
|
|
// Special-case `fn main` — emit as a regular function and call it
|
|
// at module bottom (after all top-level statements). This matches
|
|
// the C backend's behavior where `fn main` is the entry point.
|
|
if fn_name == "main" {
|
|
js_emit_line("function main(" + params_str + ") {")
|
|
} else {
|
|
js_emit_line("function " + fn_name + "(" + params_str + ") {")
|
|
}
|
|
}
|
|
|
|
let decl = native_list_empty()
|
|
let np: Int = native_list_len(params)
|
|
let pi = 0
|
|
while pi < np {
|
|
let param = native_list_get(params, pi)
|
|
let pname: String = param["name"]
|
|
let decl = native_list_append(decl, pname)
|
|
let pi = pi + 1
|
|
}
|
|
let body_xformed = body
|
|
if !str_eq(ret_type, "Void") {
|
|
let body_xformed = js_transform_implicit_return(body)
|
|
}
|
|
js_cg_stmts(body_xformed, " ", decl)
|
|
js_emit_line("}")
|
|
js_emit_blank()
|
|
}
|
|
|
|
// ── Top-level codegen ─────────────────────────────────────────────────────────
|
|
|
|
fn js_is_fndef(stmt: Map<String, Any>) -> Bool {
|
|
let kind: String = stmt["stmt"]
|
|
if kind == "FnDef" { return true }
|
|
false
|
|
}
|
|
|
|
fn js_is_top_level_decl(stmt: Map<String, Any>) -> Bool {
|
|
let kind: String = stmt["stmt"]
|
|
if kind == "TypeDef" { return true }
|
|
if kind == "EnumDef" { return true }
|
|
if kind == "Import" { return true }
|
|
if kind == "CgiBlock" { return true }
|
|
if kind == "ServiceBlock" { return true }
|
|
if kind == "ExternFn" { return true }
|
|
if kind == "TestDef" { return true }
|
|
false
|
|
}
|
|
|
|
// ── Test mode codegen (JS) ────────────────────────────────────────────────────
|
|
//
|
|
// reporter = "text" → human-readable output to stderr (console.error)
|
|
// reporter = "json" → newline-delimited JSON to stdout (process.stdout.write)
|
|
//
|
|
// The test function returns bool: true = pass, false = fail.
|
|
|
|
fn js_cg_stmt_assert_text(stmt: Map<String, Any>, test_name: String) -> Void {
|
|
let expr_node = stmt["expr"]
|
|
let msg: String = stmt["msg"]
|
|
let expr_c: String = js_cg_expr(expr_node)
|
|
let disp_msg = "assert failed"
|
|
if !str_eq(msg, "") { let disp_msg = msg }
|
|
js_emit_line(" if (!(" + expr_c + ")) {")
|
|
js_emit_line(" process.stderr.write(\" FAIL " + js_escape(test_name) + " — " + js_escape(disp_msg) + "\\n\");")
|
|
js_emit_line(" return false;")
|
|
js_emit_line(" }")
|
|
}
|
|
|
|
fn js_cg_stmt_assert_json(stmt: Map<String, Any>, test_name: String, file_name: String, test_line: Int) -> Void {
|
|
let expr_node = stmt["expr"]
|
|
let msg: String = stmt["msg"]
|
|
let assert_line: Int = stmt["line"]
|
|
let expr_c: String = js_cg_expr(expr_node)
|
|
let disp_msg = "assert failed"
|
|
if !str_eq(msg, "") { let disp_msg = msg }
|
|
js_emit_line(" if (!(" + expr_c + ")) {")
|
|
js_emit_line(" process.stdout.write(JSON.stringify({type:\"test_fail\",name:" + js_str_lit(test_name) + ",file:" + js_str_lit(file_name) + ",line:" + native_int_to_str(test_line) + ",assert_line:" + native_int_to_str(assert_line) + ",message:" + js_str_lit(disp_msg) + "}) + \"\\n\");")
|
|
js_emit_line(" return false;")
|
|
js_emit_line(" }")
|
|
}
|
|
|
|
// js_cg_stmts_in_test: emit test body, routing Assert to the right handler.
|
|
fn js_cg_stmts_in_test(stmts: [Map<String, Any>], indent: String, declared: [String], test_name: String, reporter: String, file_name: String, test_line: Int) -> [String] {
|
|
let n: Int = native_list_len(stmts)
|
|
let i = 0
|
|
let decl = declared
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let sk: String = stmt["stmt"]
|
|
if str_eq(sk, "Assert") {
|
|
if str_eq(reporter, "json") {
|
|
js_cg_stmt_assert_json(stmt, test_name, file_name, test_line)
|
|
} else {
|
|
js_cg_stmt_assert_text(stmt, test_name)
|
|
}
|
|
} else {
|
|
let decl = js_cg_stmt(stmt, indent, decl)
|
|
}
|
|
let i = i + 1
|
|
}
|
|
decl
|
|
}
|
|
|
|
// js_cg_test_fn: emit a single async test function.
|
|
fn js_cg_test_fn(test_def: Map<String, Any>, idx: Int, reporter: String, file_name: String) -> String {
|
|
let fn_name: String = "el_test_" + native_int_to_str(idx)
|
|
let test_name: String = test_def["name"]
|
|
let test_line: Int = test_def["line"]
|
|
let body = test_def["body"]
|
|
js_emit_line("async function " + fn_name + "() {")
|
|
js_cg_stmts_in_test(body, " ", native_list_empty(), test_name, reporter, file_name, test_line)
|
|
js_emit_line(" return true;")
|
|
js_emit_line("}")
|
|
js_emit_blank()
|
|
fn_name
|
|
}
|
|
|
|
// js_codegen_test: emit the test runner (replaces main() when --test active).
|
|
// reporter: "text" or "json"
|
|
// file_name: basename of the source file (used in JSON output)
|
|
fn js_codegen_test(stmts: [Map<String, Any>], reporter: String, file_name: String) -> Void {
|
|
// Collect TestDef nodes in order.
|
|
let n: Int = native_list_len(stmts)
|
|
let test_defs: [Map<String, Any>] = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let sk: String = stmt["stmt"]
|
|
if str_eq(sk, "TestDef") {
|
|
let test_defs = native_list_append(test_defs, stmt)
|
|
}
|
|
let i = i + 1
|
|
}
|
|
let n_tests: Int = native_list_len(test_defs)
|
|
|
|
// Emit non-test function definitions (skip fn main and TestDef nodes).
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
if js_is_fndef(stmt) {
|
|
let fn_name: String = stmt["name"]
|
|
if !str_eq(fn_name, "main") {
|
|
js_cg_fn(stmt)
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
|
|
// Emit each test function.
|
|
let ti = 0
|
|
while ti < n_tests {
|
|
let test_def = native_list_get(test_defs, ti)
|
|
js_cg_test_fn(test_def, ti, reporter, file_name)
|
|
let ti = ti + 1
|
|
}
|
|
|
|
// Emit the test runner IIFE.
|
|
let test_word = "tests"
|
|
if n_tests == 1 { let test_word = "test" }
|
|
js_emit_line("(async () => {")
|
|
js_emit_line(" let pass = 0; let fail = 0;")
|
|
|
|
if str_eq(reporter, "json") {
|
|
// JSON reporter: suite_start to stdout
|
|
js_emit_line(" process.stdout.write(JSON.stringify({type:\"suite_start\",file:" + js_str_lit(file_name) + ",total:" + native_int_to_str(n_tests) + "}) + \"\\n\");")
|
|
let ti = 0
|
|
while ti < n_tests {
|
|
let test_def = native_list_get(test_defs, ti)
|
|
let test_name: String = test_def["name"]
|
|
let test_line: Int = test_def["line"]
|
|
let fn_name: String = "el_test_" + native_int_to_str(ti)
|
|
js_emit_line(" process.stdout.write(JSON.stringify({type:\"test_start\",name:" + js_str_lit(test_name) + ",file:" + js_str_lit(file_name) + ",line:" + native_int_to_str(test_line) + "}) + \"\\n\");")
|
|
js_emit_line(" if (await " + fn_name + "()) {")
|
|
js_emit_line(" pass++;")
|
|
js_emit_line(" process.stdout.write(JSON.stringify({type:\"test_pass\",name:" + js_str_lit(test_name) + ",file:" + js_str_lit(file_name) + ",line:" + native_int_to_str(test_line) + ",duration_ms:0}) + \"\\n\");")
|
|
js_emit_line(" } else { fail++; }")
|
|
let ti = ti + 1
|
|
}
|
|
js_emit_line(" process.stdout.write(JSON.stringify({type:\"suite_end\",passed:pass,failed:fail}) + \"\\n\");")
|
|
} else {
|
|
// Text reporter: human-readable to stderr
|
|
js_emit_line(" process.stderr.write(\"==> running " + native_int_to_str(n_tests) + " " + test_word + "\\n\\n\");")
|
|
let ti = 0
|
|
while ti < n_tests {
|
|
let test_def = native_list_get(test_defs, ti)
|
|
let test_name: String = test_def["name"]
|
|
let fn_name: String = "el_test_" + native_int_to_str(ti)
|
|
js_emit_line(" process.stderr.write(\" RUN " + js_escape(test_name) + "\\n\");")
|
|
js_emit_line(" if (await " + fn_name + "()) { pass++; process.stderr.write(\" PASS " + js_escape(test_name) + "\\n\"); }")
|
|
js_emit_line(" else { fail++; }")
|
|
let ti = ti + 1
|
|
}
|
|
js_emit_line(" process.stderr.write(\"\\n\" + pass + \" passed, \" + fail + \" failed\\n\");")
|
|
}
|
|
|
|
js_emit_line(" process.exit(fail > 0 ? 1 : 0);")
|
|
js_emit_line("})();")
|
|
}
|
|
|
|
// ── Entry point ───────────────────────────────────────────────────────────────
|
|
|
|
fn codegen_js(stmts: [Map<String, Any>], source: String) -> String {
|
|
codegen_js_inner(stmts, source, false, "", false, "text", "")
|
|
}
|
|
|
|
// codegen_js_test: emit a JS test binary.
|
|
// reporter: "text" or "json"
|
|
// file_name: basename of the source file (used in JSON output)
|
|
fn codegen_js_test(stmts: [Map<String, Any>], source: String, reporter: String, file_name: String) -> String {
|
|
codegen_js_inner(stmts, source, false, "", true, reporter, file_name)
|
|
}
|
|
|
|
fn codegen_js_bundle(stmts: [Map<String, Any>], source: String, runtime_content: String) -> String {
|
|
codegen_js_inner(stmts, source, true, runtime_content, false, "text", "")
|
|
}
|
|
|
|
fn codegen_js_inner(stmts: [Map<String, Any>], source: String, bundle_mode: Bool, runtime_content: String, test_mode: Bool, reporter: String, file_name: String) -> String {
|
|
// Reset per-compile state.
|
|
state_set("__js_int_names", "")
|
|
state_set("__js_match_counter", "")
|
|
state_set("__js_async_fns", "")
|
|
state_set("__js_lambda_counter", "")
|
|
|
|
// Preamble: in bundle mode, inline the runtime and wrap in IIFE.
|
|
// In module mode, emit a single import that side-effects globalThis.
|
|
js_emit_line("// Generated by elc --target=js")
|
|
if bundle_mode {
|
|
js_emit_line("// Bundle mode: runtime inlined, no import statement needed.")
|
|
js_emit_line("// Drop directly into a <script> tag.")
|
|
js_emit_line(";(function() {")
|
|
js_emit_line("\"use strict\";")
|
|
// Inline the runtime content verbatim (already read from el_runtime.js).
|
|
// Strip the final ES export lines -- they use `export` syntax which is
|
|
// not valid inside an IIFE. The globalThis.__el assignment is what matters.
|
|
js_emit_line(js_strip_es_exports(runtime_content))
|
|
js_emit_line("")
|
|
} else {
|
|
js_emit_line("// Runtime: foundation/el/el-compiler/runtime/el_runtime.js")
|
|
js_emit_line("import \"./el_runtime.js\";")
|
|
}
|
|
// In module mode: destructure all builtins off globalThis.__el so call
|
|
// sites stay flat (println(x) not el.println(x)).
|
|
// In bundle mode: function declarations from the inlined runtime are
|
|
// already in scope within the IIFE -- no destructure needed.
|
|
if !bundle_mode {
|
|
js_emit_line("const {")
|
|
js_emit_line(" println, print, el_str_concat, str_concat, str_eq, str_starts_with, str_ends_with,")
|
|
js_emit_line(" str_len, int_to_str, str_to_int, str_slice, str_contains, str_replace,")
|
|
js_emit_line(" str_to_upper, str_to_lower, str_trim, str_index_of, str_split, str_char_at,")
|
|
js_emit_line(" str_char_code, str_lower, str_upper, el_abs, el_max, el_min,")
|
|
js_emit_line(" el_list_new, el_list_len, el_list_get, el_list_append, el_list_empty, el_list_clone,")
|
|
js_emit_line(" list_push, list_join, list_range,")
|
|
js_emit_line(" el_map_new, el_get_field, el_map_get, el_map_set,")
|
|
js_emit_line(" http_get, http_post, http_post_json,")
|
|
js_emit_line(" fs_read, fs_write, fs_list,")
|
|
js_emit_line(" json_parse, json_stringify, json_get, json_get_string, json_get_int,")
|
|
js_emit_line(" time_now, time_now_utc, sleep_ms, bool_to_str, exit_program,")
|
|
js_emit_line(" el_retain, el_release,")
|
|
js_emit_line(" append, len, get, map_get, map_set,")
|
|
js_emit_line(" native_list_get, native_list_len, native_list_append, native_list_empty,")
|
|
js_emit_line(" native_list_clone, native_string_chars, native_int_to_str,")
|
|
js_emit_line(" args, state_set, state_get, state_del, state_keys, env,")
|
|
js_emit_line(" dharma_connect, dharma_send, dharma_emit, dharma_field, dharma_activate,")
|
|
js_emit_line(" engram_node, engram_search, engram_activate,")
|
|
js_emit_line(" llm_call, llm_call_system,")
|
|
js_emit_line(" dom_get_element, dom_get_value, dom_set_value, dom_get_text, dom_set_text,")
|
|
js_emit_line(" dom_set_prop, dom_get_prop, dom_set_style, dom_add_class, dom_remove_class,")
|
|
js_emit_line(" dom_show, dom_hide, dom_listen, dom_query, dom_query_all, dom_create,")
|
|
js_emit_line(" dom_append, dom_remove, dom_is_null,")
|
|
js_emit_line(" dom_set_attr, dom_get_attr, dom_remove_attr, dom_set_html, dom_get_html,")
|
|
js_emit_line(" dom_get_parent, dom_contains_class, dom_get_checked, dom_set_checked,")
|
|
js_emit_line(" set_timeout, set_interval, clear_interval,")
|
|
js_emit_line(" local_storage_get, local_storage_set, local_storage_remove,")
|
|
js_emit_line(" window_location, window_redirect, window_on_load,")
|
|
js_emit_line(" console_log,")
|
|
js_emit_line(" window_set, window_get, native_js, native_js_call,")
|
|
js_emit_line(" promise_then, promise_catch, promise_resolve, promise_reject,")
|
|
js_emit_line(" object_assign, object_keys, object_values, json_deep_clone,")
|
|
js_emit_line(" array_from, type_of, instanceof_check,")
|
|
js_emit_line("} = globalThis.__el;")
|
|
js_emit_blank()
|
|
}
|
|
|
|
// URL import pass: emit `import "url"` (module mode) or a comment
|
|
// (bundle mode) for any import whose path starts with http(s):// or
|
|
// doesn't end in .el (i.e., it's a JS/CSS/CDN import, not an El source
|
|
// import which was already inlined by resolve_imports).
|
|
let n: Int = native_list_len(stmts)
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let sk: String = stmt["stmt"]
|
|
if str_eq(sk, "Import") {
|
|
let ipath: String = stmt["path"]
|
|
let is_url = str_starts_with(ipath, "http://")
|
|
let is_url = is_url || str_starts_with(ipath, "https://")
|
|
let is_js = !str_ends_with(ipath, ".el")
|
|
if is_url || is_js {
|
|
if bundle_mode {
|
|
js_emit_line("// external: " + ipath)
|
|
} else {
|
|
js_emit_line("import " + js_str_lit(ipath) + ";")
|
|
}
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
js_emit_blank()
|
|
|
|
// Pre-registration pass: scan all FnDefs for @async decorators so that
|
|
// forward calls to @async functions get `await` even if the callee is
|
|
// defined after the caller.
|
|
let n: Int = native_list_len(stmts)
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let sk: String = stmt["stmt"]
|
|
if str_eq(sk, "FnDef") {
|
|
let dec: String = stmt["decorator"]
|
|
if str_eq(dec, "async") {
|
|
let aname: String = stmt["name"]
|
|
js_register_async_fn(aname)
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
|
|
// Test mode: emit test functions and runner, skip normal program logic.
|
|
if test_mode {
|
|
js_codegen_test(stmts, reporter, file_name)
|
|
return ""
|
|
}
|
|
|
|
// Function definitions
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
if js_is_fndef(stmt) {
|
|
js_cg_fn(stmt)
|
|
}
|
|
let i = i + 1
|
|
}
|
|
|
|
// Top-level statements (those that are not FnDef and not declarative)
|
|
// run at module load. If the program defines `fn main`, we additionally
|
|
// call main() at the end so the C-backend mental model of "fn main is
|
|
// the entry point" carries over.
|
|
let has_main = false
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let sk: String = stmt["stmt"]
|
|
if str_eq(sk, "FnDef") {
|
|
let fn_name: String = stmt["name"]
|
|
if str_eq(fn_name, "main") {
|
|
let has_main = true
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
|
|
let main_decl = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
if js_is_fndef(stmt) {
|
|
// skip
|
|
} else {
|
|
if js_is_top_level_decl(stmt) {
|
|
// skip
|
|
} else {
|
|
let main_decl = js_cg_stmt(stmt, "", main_decl)
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
|
|
if has_main {
|
|
js_emit_blank()
|
|
js_emit_line("main();")
|
|
}
|
|
|
|
// Close IIFE in bundle mode.
|
|
if bundle_mode {
|
|
js_emit_line("")
|
|
js_emit_line("})();")
|
|
}
|
|
|
|
// Return empty string — output was streamed via println
|
|
""
|
|
}
|
|
|
|
// Strip ES module export statements from runtime content for IIFE embedding.
|
|
// The runtime ends with `export { ... }` and `export { __el as default }` lines
|
|
// that are invalid inside an IIFE. We strip everything from the first top-level
|
|
// `export {` line onward.
|
|
//
|
|
// Also strips `import` statements at the top if any (though el_runtime.js has none).
|
|
fn js_strip_es_exports(content: String) -> String {
|
|
let lines: [String] = str_split(content, "\n")
|
|
let n: Int = native_list_len(lines)
|
|
let out: [String] = native_list_empty()
|
|
let i = 0
|
|
while i < n {
|
|
let line: String = native_list_get(lines, i)
|
|
let trimmed: String = str_trim(line)
|
|
// Stop at top-level `export {` or `export default`
|
|
if str_starts_with(trimmed, "export {") {
|
|
let i = n
|
|
} else {
|
|
if str_starts_with(trimmed, "export default") {
|
|
let i = n
|
|
} else {
|
|
let out = native_list_append(out, line)
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
str_join(out, "\n")
|
|
}
|
|
// compiler.el — el self-hosting compiler pipeline
|
|
//
|
|
// Wires lexer -> parser -> codegen into a single compile() function.
|
|
// This is the bootstrap entry point: compiled once by the Rust el-compiler,
|
|
// then self-hosted from that point forward.
|
|
//
|
|
// Two backends:
|
|
// - C (default) compile() -> emits C source linked against el_runtime.c
|
|
// - JS (--target=js) compile_js() -> emits JS source linked against el_runtime.js
|
|
//
|
|
// Compile the C output with:
|
|
// cc -o <prog> <prog>.c el_runtime.c
|
|
//
|
|
// Run the JS output with:
|
|
// node <prog>.js (after copying el_runtime.js next to it)
|
|
|
|
import "lexer.el"
|
|
import "parser.el"
|
|
import "codegen.el"
|
|
import "codegen-js.el"
|
|
|
|
// compile — full pipeline (C target): source string -> C source string
|
|
fn compile(source: String) -> String {
|
|
let tokens: [Map<String, Any>] = lex(source)
|
|
let stmts: [Map<String, Any>] = parse(tokens)
|
|
// Token list is no longer needed after parsing — release it to free memory
|
|
// before codegen allocates its own working data on large source files.
|
|
el_release(tokens)
|
|
codegen(stmts, source)
|
|
}
|
|
|
|
// compile_js — full pipeline (JS target, module mode): source string -> JS source string
|
|
fn compile_js(source: String) -> String {
|
|
let tokens: [Map<String, Any>] = lex(source)
|
|
let stmts: [Map<String, Any>] = parse(tokens)
|
|
// Token list is no longer needed after parsing — release it to free memory.
|
|
el_release(tokens)
|
|
codegen_js(stmts, source)
|
|
}
|
|
|
|
// compile_js_with_bundle — JS target in bundle mode.
|
|
// Reads el_runtime.js from runtime_path and inlines it inside an IIFE.
|
|
fn compile_js_with_bundle(source: String, runtime_path: String) -> String {
|
|
let tokens: [Map<String, Any>] = lex(source)
|
|
let stmts: [Map<String, Any>] = parse(tokens)
|
|
el_release(tokens)
|
|
let runtime_content: String = fs_read(runtime_path)
|
|
if str_eq(runtime_content, "") {
|
|
println("el-compiler: warning: --bundle: could not read runtime at " + runtime_path)
|
|
println("el-compiler: warning: bundle output will be incomplete")
|
|
}
|
|
codegen_js_bundle(stmts, source, runtime_content)
|
|
}
|
|
|
|
// compile_test — full pipeline (C target, test mode): source -> C test runner.
|
|
// reporter: "text" or "json"; file_name: basename of the source file.
|
|
fn compile_test(source: String, reporter: String, file_name: String) -> String {
|
|
let tokens: [Map<String, Any>] = lex(source)
|
|
let stmts: [Map<String, Any>] = parse(tokens)
|
|
el_release(tokens)
|
|
codegen_with_tests(stmts, source, reporter, file_name)
|
|
}
|
|
|
|
// compile_js_test — full pipeline (JS target, test mode): source -> JS test runner.
|
|
// reporter: "text" or "json"; file_name: basename of the source file.
|
|
fn compile_js_test(source: String, reporter: String, file_name: String) -> String {
|
|
let tokens: [Map<String, Any>] = lex(source)
|
|
let stmts: [Map<String, Any>] = parse(tokens)
|
|
el_release(tokens)
|
|
codegen_js_test(stmts, source, reporter, file_name)
|
|
}
|
|
|
|
// compile_dispatch — pick a backend based on the requested target.
|
|
// tgt = "c" | "js"
|
|
// (The parameter is named `tgt` because `target` is a reserved keyword
|
|
// in El's lexer — it would be tokenised as `Target`, breaking the
|
|
// parser's identifier resolution.)
|
|
fn compile_dispatch(tgt: String, source: String) -> String {
|
|
if str_eq(tgt, "js") { return compile_js(source) }
|
|
compile(source)
|
|
}
|
|
|
|
// compile_dispatch_test — pick test-mode backend.
|
|
// reporter: "text" or "json"; file_name: basename of the source file.
|
|
fn compile_dispatch_test(tgt: String, source: String, reporter: String, file_name: String) -> String {
|
|
if str_eq(tgt, "js") { return compile_js_test(source, reporter, file_name) }
|
|
compile_test(source, reporter, file_name)
|
|
}
|
|
|
|
// compile_dispatch_bundle — like compile_dispatch but bundle mode for JS.
|
|
fn compile_dispatch_bundle(tgt: String, source: String, runtime_path: String) -> String {
|
|
if str_eq(tgt, "js") { return compile_js_with_bundle(source, runtime_path) }
|
|
compile(source)
|
|
}
|
|
|
|
// Detect a `--target=<lang>` flag in argv and return the target.
|
|
// Returns "c" if none specified or unrecognized.
|
|
fn detect_target(argv: [String]) -> String {
|
|
let n: Int = native_list_len(argv)
|
|
let i = 0
|
|
while i < n {
|
|
let a: String = native_list_get(argv, i)
|
|
if str_starts_with(a, "--target=") {
|
|
let v: String = str_slice(a, 9, str_len(a))
|
|
return v
|
|
}
|
|
let i = i + 1
|
|
}
|
|
return "c"
|
|
}
|
|
|
|
// Strip flags from argv, leaving only positional arguments.
|
|
fn strip_flags(argv: [String]) -> [String] {
|
|
let out: [String] = native_list_empty()
|
|
let n: Int = native_list_len(argv)
|
|
let i = 0
|
|
while i < n {
|
|
let a: String = native_list_get(argv, i)
|
|
if !str_starts_with(a, "--") {
|
|
let out = native_list_append(out, a)
|
|
}
|
|
let i = i + 1
|
|
}
|
|
return out
|
|
}
|
|
|
|
// Detect --emit-header flag in argv.
|
|
fn detect_emit_header(argv: [String]) -> Bool {
|
|
let n: Int = native_list_len(argv)
|
|
let i = 0
|
|
while i < n {
|
|
let a: String = native_list_get(argv, i)
|
|
if str_eq(a, "--emit-header") { return true }
|
|
let i = i + 1
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Detect --bundle flag in argv.
|
|
fn detect_bundle(argv: [String]) -> Bool {
|
|
let n: Int = native_list_len(argv)
|
|
let i = 0
|
|
while i < n {
|
|
let a: String = native_list_get(argv, i)
|
|
if str_eq(a, "--bundle") { return true }
|
|
let i = i + 1
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Detect --minify flag in argv.
|
|
fn detect_minify(argv: [String]) -> Bool {
|
|
let n: Int = native_list_len(argv)
|
|
let i = 0
|
|
while i < n {
|
|
let a: String = native_list_get(argv, i)
|
|
if str_eq(a, "--minify") { return true }
|
|
let i = i + 1
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Detect --obfuscate flag in argv.
|
|
fn detect_obfuscate(argv: [String]) -> Bool {
|
|
let n: Int = native_list_len(argv)
|
|
let i = 0
|
|
while i < n {
|
|
let a: String = native_list_get(argv, i)
|
|
if str_eq(a, "--obfuscate") { return true }
|
|
let i = i + 1
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Detect --test flag in argv.
|
|
fn detect_test(argv: [String]) -> Bool {
|
|
let n: Int = native_list_len(argv)
|
|
let i = 0
|
|
while i < n {
|
|
let a: String = native_list_get(argv, i)
|
|
if str_eq(a, "--test") { return true }
|
|
let i = i + 1
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Detect --reporter=<value> flag in argv.
|
|
// Returns "json" if --reporter=json, otherwise "text" (default).
|
|
fn detect_reporter(argv: [String]) -> String {
|
|
let n: Int = native_list_len(argv)
|
|
let i = 0
|
|
while i < n {
|
|
let a: String = native_list_get(argv, i)
|
|
if str_starts_with(a, "--reporter=") {
|
|
let v: String = str_slice(a, 11, str_len(a))
|
|
return v
|
|
}
|
|
let i = i + 1
|
|
}
|
|
return "text"
|
|
}
|
|
|
|
// basename_of — extract the filename portion of a path (after last '/').
|
|
fn basename_of(path: String) -> String {
|
|
let n: Int = str_len(path)
|
|
let i: Int = n - 1
|
|
while i >= 0 {
|
|
let c: String = str_slice(path, i, i + 1)
|
|
if str_eq(c, "/") {
|
|
return str_slice(path, i + 1, n)
|
|
}
|
|
let i = i - 1
|
|
}
|
|
return path
|
|
}
|
|
|
|
// Build a unique temp file path: /tmp/elc-<pid>-<timestamp>.<suffix>
|
|
fn make_temp_path(suffix: String) -> String {
|
|
let pid: Int = getpid_now()
|
|
let ts: Int = time_now()
|
|
"/tmp/elc-" + native_int_to_str(pid) + "-" + native_int_to_str(ts) + "." + suffix
|
|
}
|
|
|
|
// Reserved globals that terser and javascript-obfuscator must not mangle.
|
|
// These are referenced from HTML onclick= attributes and other direct window usage.
|
|
fn js_reserved_names() -> String {
|
|
"neuronDemoToggle,neuronDemoSend,neuronDemoReset,signInWith,signInWithEmail,signUpWithEmail,sendMagicLink,signOut,resetPassword,sendResetEmail,updatePassword,showSignIn,showSignUp,hideReset,setSort,addFamilyMember,removeFamilyMember,copyForPlatform,entHeadcountChange,NEURON_CFG"
|
|
}
|
|
|
|
// Find a CLI tool by checking node_modules paths first, then falling back to npx.
|
|
// src_dir is the directory of the source file being compiled.
|
|
// Returns the command string to invoke the tool, or "" if not found.
|
|
fn find_node_tool(tool_name: String, src_dir: String) -> String {
|
|
// 1. Check ./node_modules/.bin/<tool> relative to source file
|
|
let cand1: String = src_dir + "/node_modules/.bin/" + tool_name
|
|
let check1: String = str_trim(exec_capture("test -x " + cand1 + " && echo yes 2>/dev/null"))
|
|
if str_eq(check1, "yes") { return cand1 }
|
|
// 2. Check ../node_modules/.bin/<tool> (monorepo layout)
|
|
let parent_dir: String = dirname_of(src_dir)
|
|
let cand2: String = parent_dir + "/node_modules/.bin/" + tool_name
|
|
let check2: String = str_trim(exec_capture("test -x " + cand2 + " && echo yes 2>/dev/null"))
|
|
if str_eq(check2, "yes") { return cand2 }
|
|
// 3. Fall back to npx if it is on PATH. npx will use the globally cached
|
|
// package or download on first use. Use --no to avoid auto-install if
|
|
// the package is not already cached; if that fails, try with --yes.
|
|
let npx_path: String = str_trim(exec_capture("which npx 2>/dev/null"))
|
|
if !str_eq(npx_path, "") { return "npx --yes " + tool_name }
|
|
return ""
|
|
}
|
|
|
|
// apply_minify — run terser on js_path, write result to out_path.
|
|
// Returns true on success, false on failure.
|
|
fn apply_minify(js_path: String, out_path: String, src_dir: String) -> Bool {
|
|
let terser: String = find_node_tool("terser", src_dir)
|
|
if str_eq(terser, "") {
|
|
println("el-compiler: error: terser not found. Run 'npm install terser' in your project directory.")
|
|
return false
|
|
}
|
|
let names: String = js_reserved_names()
|
|
// Single-quote the mangle reserved list so the shell does not glob-expand
|
|
// the bracket expression. The compress options are safe without quoting.
|
|
let compress_opts: String = "passes=2,drop_console=false,drop_debugger=true"
|
|
let mangle_reserved: String = "'reserved=[" + names + "]'"
|
|
let cmd: String = terser + " " + js_path + " --compress " + compress_opts + " --mangle " + mangle_reserved + " --output " + out_path
|
|
let ret: Int = exec_command(cmd)
|
|
if ret == 0 { return true }
|
|
println("el-compiler: error: terser failed (exit " + native_int_to_str(ret) + ")")
|
|
return false
|
|
}
|
|
|
|
// apply_obfuscate — run javascript-obfuscator on js_path, write result to out_path.
|
|
// Returns true on success, false on failure.
|
|
fn apply_obfuscate(js_path: String, out_path: String, src_dir: String) -> Bool {
|
|
let obfuscator: String = find_node_tool("javascript-obfuscator", src_dir)
|
|
if str_eq(obfuscator, "") {
|
|
println("el-compiler: error: javascript-obfuscator not found. Run 'npm install javascript-obfuscator' in your project directory.")
|
|
return false
|
|
}
|
|
let names: String = js_reserved_names()
|
|
let cmd: String = obfuscator + " " + js_path + " --output " + out_path + " --compact true --simplify true --string-array true --string-array-encoding base64 --string-array-threshold 0.75 --identifier-names-generator hexadecimal --rename-globals false --self-defending false --reserved-names " + names
|
|
let ret: Int = exec_command(cmd)
|
|
if ret == 0 { return true }
|
|
println("el-compiler: error: javascript-obfuscator failed (exit " + native_int_to_str(ret) + ")")
|
|
return false
|
|
}
|
|
|
|
// Resolve the runtime path for --bundle mode.
|
|
// Looks for el_runtime.js next to the source file first;
|
|
// if not found there, looks next to the elc binary itself.
|
|
// Returns "" if not found anywhere (caller emits a warning).
|
|
fn resolve_runtime_path(src_path: String) -> String {
|
|
let src_dir: String = dirname_of(src_path)
|
|
let candidate: String = src_dir + "/el_runtime.js"
|
|
let existing: String = fs_read(candidate)
|
|
if !str_eq(existing, "") {
|
|
return candidate
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Reconstruct an El type annotation string from a parsed type node.
|
|
fn type_node_to_el(t: Map<String, Any>) -> String {
|
|
let k: String = t["kind"]
|
|
if str_eq(k, "Simple") { return t["name"] }
|
|
if str_eq(k, "List") {
|
|
let inner: String = type_node_to_el(t["inner"])
|
|
return "[" + inner + "]"
|
|
}
|
|
if str_eq(k, "Map") {
|
|
let kt: String = type_node_to_el(t["key"])
|
|
let vt: String = type_node_to_el(t["val"])
|
|
return "Map<" + kt + ", " + vt + ">"
|
|
}
|
|
"Any"
|
|
}
|
|
|
|
// emit_header — write a .elh file from parsed statements.
|
|
// Scans for FnDef nodes and emits 'extern fn' declarations.
|
|
fn emit_header(stmts: [Map<String, Any>], hdr_path: String) -> Void {
|
|
let n: Int = native_list_len(stmts)
|
|
let i = 0
|
|
let parts: [String] = native_list_empty()
|
|
let parts = native_list_append(parts, "// auto-generated by elc --emit-header — do not edit\n")
|
|
while i < n {
|
|
let stmt = native_list_get(stmts, i)
|
|
let kind: String = stmt["stmt"]
|
|
if str_eq(kind, "FnDef") {
|
|
let name: String = stmt["name"]
|
|
if !str_eq(name, "main") {
|
|
let params = stmt["params"]
|
|
let ret_type: String = stmt["ret_type"]
|
|
// build param list
|
|
let np: Int = native_list_len(params)
|
|
let pi = 0
|
|
let param_parts: [String] = native_list_empty()
|
|
while pi < np {
|
|
let param = native_list_get(params, pi)
|
|
let pname: String = param["name"]
|
|
let ptype: String = param["type"]
|
|
if str_eq(ptype, "") { let ptype = "Any" }
|
|
let param_parts = native_list_append(param_parts, pname + ": " + ptype)
|
|
let pi = pi + 1
|
|
}
|
|
let params_str: String = str_join(param_parts, ", ")
|
|
let ret_str: String = ret_type
|
|
if str_eq(ret_str, "") { let ret_str = "Any" }
|
|
let sig: String = "extern fn " + name + "(" + params_str + ") -> " + ret_str
|
|
let parts = native_list_append(parts, sig + "\n")
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
let content: String = str_join(parts, "")
|
|
let ok: Bool = fs_write(hdr_path, content)
|
|
}
|
|
|
|
// ── Import resolution ────────────────────────────────────────────────────────
|
|
//
|
|
// elc supports two forms of import:
|
|
// import "path/to/file.el" — quoted relative path
|
|
// from module import { Name } — bare module name resolves to module.el
|
|
// in the entry source's directory
|
|
//
|
|
// Codegen treats Import statements as no-ops (declarations only), so to
|
|
// actually link bodies across files we textually concatenate every imported
|
|
// source ahead of the entry source before lex/parse. resolve_imports does a
|
|
// depth-first traversal with deduplication so any module that gets pulled in
|
|
// transitively is included exactly once.
|
|
|
|
fn dirname_of(path: String) -> String {
|
|
let n: Int = str_len(path)
|
|
let i: Int = n - 1
|
|
while i >= 0 {
|
|
let c: String = str_slice(path, i, i + 1)
|
|
if str_eq(c, "/") {
|
|
return str_slice(path, 0, i)
|
|
}
|
|
let i = i - 1
|
|
}
|
|
return "."
|
|
}
|
|
|
|
// Extract the resolved file path from a single trimmed source line. Returns
|
|
// "" if the line is not an import.
|
|
fn parse_import_line(trimmed: String, dir: String) -> String {
|
|
if str_starts_with(trimmed, "import \"") {
|
|
let after: String = str_slice(trimmed, 8, str_len(trimmed))
|
|
let q: Int = str_index_of(after, "\"")
|
|
if q > 0 {
|
|
let mod: String = str_slice(after, 0, q)
|
|
return dir + "/" + mod
|
|
}
|
|
}
|
|
if str_starts_with(trimmed, "from ") {
|
|
let after: String = str_slice(trimmed, 5, str_len(trimmed))
|
|
// module name is the first whitespace-delimited token
|
|
let sp: Int = str_index_of(after, " ")
|
|
if sp > 0 {
|
|
let mod_raw: String = str_slice(after, 0, sp)
|
|
let mod: String = str_trim(mod_raw)
|
|
if !str_eq(mod, "") {
|
|
return dir + "/" + mod + ".el"
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Recursively resolve imports starting from src_path. Returns the combined
|
|
// source text with every imported module's body inlined ahead of the entry
|
|
// source, deduplicated by absolute path. Uses state_set to track which paths
|
|
// have already been pulled in for this run.
|
|
//
|
|
// Accumulates chunks into lists and joins once at the end to avoid the O(n²)
|
|
// memory growth caused by repeated `prefix = prefix + chunk` concatenation.
|
|
fn resolve_imports(src_path: String) -> String {
|
|
let seen_key: String = "__elc_imp__:" + src_path
|
|
let already: String = state_get(seen_key)
|
|
if !str_eq(already, "") { return "" }
|
|
state_set(seen_key, "1")
|
|
|
|
let source: String = fs_read(src_path)
|
|
let dir: String = dirname_of(src_path)
|
|
let lines: [String] = str_split(source, "\n")
|
|
let n: Int = native_list_len(lines)
|
|
|
|
// Collect chunks into lists — O(1) amortized per append.
|
|
// Join once at the end — O(n) single pass.
|
|
let prefix_chunks: [String] = native_list_empty()
|
|
let body_chunks: [String] = native_list_empty()
|
|
let i: Int = 0
|
|
while i < n {
|
|
let line: String = native_list_get(lines, i)
|
|
let trimmed: String = str_trim(line)
|
|
let imp_path: String = parse_import_line(trimmed, dir)
|
|
if !str_eq(imp_path, "") {
|
|
// Use pre-compiled header if available (separate compilation).
|
|
// Only check .elh for imported files — never for the entry file itself.
|
|
let imp_elh_path: String = str_slice(imp_path, 0, str_len(imp_path) - 3) + ".elh"
|
|
let imp_elh: String = fs_read(imp_elh_path)
|
|
if !str_eq(imp_elh, "") {
|
|
// Header exists: mark the .el as seen (so it won't be re-inlined
|
|
// if something else also imports it) and use the header text.
|
|
let seen_imp_key: String = "__elc_imp__:" + imp_path
|
|
state_set(seen_imp_key, "1")
|
|
let prefix_chunks = native_list_append(prefix_chunks, imp_elh)
|
|
} else {
|
|
let imp_body: String = resolve_imports(imp_path)
|
|
let prefix_chunks = native_list_append(prefix_chunks, imp_body)
|
|
}
|
|
} else {
|
|
let body_chunks = native_list_append(body_chunks, line + "\n")
|
|
}
|
|
let i = i + 1
|
|
}
|
|
return str_join(prefix_chunks, "") + str_join(body_chunks, "")
|
|
}
|
|
|
|
// run_with_postprocess — codegen + minify + optional obfuscate pipeline.
|
|
//
|
|
// Called from main() when --minify or --obfuscate is active. Redirects stdout
|
|
// to a temp file during codegen so the output can be passed through the
|
|
// external tools (terser, javascript-obfuscator) before final emission.
|
|
//
|
|
// Pipeline: codegen -> terser -> (javascript-obfuscator) -> stdout or file
|
|
fn run_with_postprocess(tgt: String, source: String, src_path: String, do_bundle: Bool, do_obfuscate: Bool, argc: Int, positional: [String]) -> Void {
|
|
let src_dir: String = dirname_of(src_path)
|
|
let tmp_gen: String = make_temp_path("js")
|
|
let tmp_min: String = make_temp_path("min.js")
|
|
|
|
// Redirect stdout to tmp_gen so codegen println output is captured.
|
|
stdout_to_file(tmp_gen)
|
|
if do_bundle {
|
|
let runtime_path: String = resolve_runtime_path(src_path)
|
|
compile_dispatch_bundle(tgt, source, runtime_path)
|
|
} else {
|
|
compile_dispatch(tgt, source)
|
|
}
|
|
stdout_restore()
|
|
|
|
// Run terser: tmp_gen -> tmp_min
|
|
let ok_min: Bool = apply_minify(tmp_gen, tmp_min, src_dir)
|
|
if !ok_min {
|
|
exec_command("rm -f " + tmp_gen + " " + tmp_min)
|
|
exit(1)
|
|
}
|
|
|
|
// Determine final result path (either tmp_min or post-obfuscation file).
|
|
// Use state to pass the final path out of the optional obfuscation branch.
|
|
state_set("__elc_final_js", tmp_min)
|
|
|
|
if do_obfuscate {
|
|
let tmp_obf: String = make_temp_path("obf.js")
|
|
let ok_obf: Bool = apply_obfuscate(tmp_min, tmp_obf, src_dir)
|
|
if !ok_obf {
|
|
exec_command("rm -f " + tmp_gen + " " + tmp_min + " " + tmp_obf)
|
|
exit(1)
|
|
}
|
|
state_set("__elc_final_js", tmp_obf)
|
|
}
|
|
|
|
let final_path: String = state_get("__elc_final_js")
|
|
let final_js: String = fs_read(final_path)
|
|
|
|
// Clean up all temp files.
|
|
exec_command("rm -f " + tmp_gen + " " + tmp_min)
|
|
if do_obfuscate {
|
|
exec_command("rm -f " + final_path)
|
|
}
|
|
|
|
if argc >= 2 {
|
|
let out_path: String = native_list_get(positional, 1)
|
|
let ok: Bool = fs_write(out_path, final_js)
|
|
if ok {
|
|
return
|
|
} else {
|
|
println("el-compiler: failed to write output")
|
|
exit(1)
|
|
}
|
|
}
|
|
// No output file: print final JS to stdout.
|
|
print(final_js)
|
|
}
|
|
|
|
// main — CLI entry point.
|
|
//
|
|
// elc <source.el> # emit C to stdout
|
|
// elc --test <source.el> # emit C test runner to stdout
|
|
// elc --target=js <source.el> # emit JS (module) to stdout
|
|
// elc --target=js --test <source.el> # emit JS test runner to stdout
|
|
// elc --target=js --bundle <source.el> # emit self-contained JS (IIFE) to stdout
|
|
// elc --target=js --bundle --minify <source.el> # emit minified IIFE to stdout
|
|
// elc --target=js --bundle --obfuscate <source.el> # emit minified+obfuscated IIFE to stdout
|
|
// elc --target=c <source.el> <out.c> # write C to file
|
|
// elc --target=js <source.el> <out.js> # write JS to file
|
|
// elc --target=js --bundle <source.el> <out.js> # write bundled JS to file
|
|
// elc --target=js --bundle --minify <source.el> <out.min.js> # write minified JS to file
|
|
fn main() -> Void {
|
|
let argv: [String] = args()
|
|
// Use `tgt` not `target`: `target` is a reserved keyword in the lexer
|
|
// (Section 1.5 of the language spec). detect_target itself is fine
|
|
// because the function-name position has no token-class restriction.
|
|
let tgt: String = detect_target(argv)
|
|
let do_emit_header: Bool = detect_emit_header(argv)
|
|
let do_bundle: Bool = detect_bundle(argv)
|
|
let do_minify: Bool = detect_minify(argv)
|
|
let do_obfuscate: Bool = detect_obfuscate(argv)
|
|
let do_test: Bool = detect_test(argv)
|
|
let reporter: String = detect_reporter(argv)
|
|
// --obfuscate implies --minify: obfuscating unminified code is pointless.
|
|
if do_obfuscate {
|
|
let do_minify = true
|
|
}
|
|
let positional: [String] = strip_flags(argv)
|
|
let argc: Int = native_list_len(positional)
|
|
if argc < 1 {
|
|
println("el-compiler: usage: elc [--target=c|js] [--test] [--reporter=text|json] [--bundle] [--minify] [--obfuscate] [--emit-header] <source.el> [<output>]")
|
|
exit(1)
|
|
}
|
|
|
|
// --minify and --obfuscate require --target=js
|
|
if do_minify {
|
|
if !str_eq(tgt, "js") {
|
|
println("el-compiler: error: --minify and --obfuscate require --target=js")
|
|
exit(1)
|
|
}
|
|
}
|
|
|
|
let src_path: String = native_list_get(positional, 0)
|
|
|
|
// When --emit-header is requested, parse the source file directly
|
|
// (without inlining imports) and write out a .elh file alongside the .c.
|
|
if do_emit_header {
|
|
let raw_source: String = fs_read(src_path)
|
|
let hdr_tokens: [Map<String, Any>] = lex(raw_source)
|
|
let hdr_stmts: [Map<String, Any>] = parse(hdr_tokens)
|
|
el_release(hdr_tokens)
|
|
let hdr_path: String = str_slice(src_path, 0, str_len(src_path) - 3) + ".elh"
|
|
emit_header(hdr_stmts, hdr_path)
|
|
el_release(hdr_stmts)
|
|
}
|
|
|
|
let source: String = resolve_imports(src_path)
|
|
let file_name: String = basename_of(src_path)
|
|
|
|
// --test mode: emit a test runner binary instead of the normal program.
|
|
if do_test {
|
|
let out: String = compile_dispatch_test(tgt, source, reporter, file_name)
|
|
if argc >= 2 {
|
|
let out_path: String = native_list_get(positional, 1)
|
|
let ok: Bool = fs_write(out_path, out)
|
|
if ok { exit(0) }
|
|
println("el-compiler: failed to write output")
|
|
exit(1)
|
|
}
|
|
exit(0)
|
|
}
|
|
|
|
// When post-processing (--minify or --obfuscate) is requested, redirect
|
|
// stdout to a temp file so codegen output can be captured and piped through
|
|
// the external tools. After codegen, restore stdout before emitting the
|
|
// final result.
|
|
if do_minify {
|
|
run_with_postprocess(tgt, source, src_path, do_bundle, do_obfuscate, argc, positional)
|
|
exit(0)
|
|
}
|
|
|
|
// Standard path (no post-processing).
|
|
let out: String = ""
|
|
if do_bundle {
|
|
let runtime_path: String = resolve_runtime_path(src_path)
|
|
let out = compile_dispatch_bundle(tgt, source, runtime_path)
|
|
} else {
|
|
let out = compile_dispatch(tgt, source)
|
|
}
|
|
if argc >= 2 {
|
|
let out_path: String = native_list_get(positional, 1)
|
|
let ok: Bool = fs_write(out_path, out)
|
|
if ok {
|
|
exit(0)
|
|
} else {
|
|
println("el-compiler: failed to write output")
|
|
exit(1)
|
|
}
|
|
}
|
|
// No output path: codegen streamed to stdout already; out is "".
|
|
}
|