nomsu/lib/metaprogramming.nom

#..
    This File contains actions for making actions and macros and some helper functions to make
    that easier.

# Helper function
immediately:
    lua> ".."
        nomsu.parse_spec = function(nomsu, spec)
            local signature = {};
            for i, alias in ipairs(spec.value) do
                signature[i] = alias.src;
            end
            local _, arg_names, _ = nomsu:get_stub(spec.value[1]);
            local args = {"nomsu"};
            for i, a in ipairs(arg_names) do args[i+1] = "_"..nomsu:var_to_lua_identifier(a); end
            signature, args = nomsu:repr(signature), table.concat(args, ", ");
            return signature, args;
        end

# Macro to make macros:
immediately:
    lua> ".."
        nomsu:define_macro("compile %macro_def to %body", \(__line_no__), function(nomsu, \%macro_def, \%body)
            nomsu:assert(\%macro_def.type == "List",
                "Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type));
            nomsu:assert(\%body.type == "Block",
                "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type));
            local signature, args = nomsu:parse_spec(\%macro_def);
            local body_lua = nomsu:tree_to_lua(\%body);
            body_lua = body_lua.statements or ("return "..body_lua.expr..";");
            local lua = ([[
        do
            local function macro(%s)
                %s
            end
            local function macro_wrapper(...) return {expr=macro(...)}; end
            nomsu:define_macro(%s, %s, macro_wrapper, %s);
        end]]):format(args, body_lua, signature, nomsu:repr(\%macro_def:get_line_no()),
            nomsu:repr(("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src)));
            return {statements=lua};
        end, \(__src__ 1));

    lua> ".."
        nomsu:define_macro("compile %macro_def to code %body", \(__line_no__), function(nomsu, \%macro_def, \%body)
            nomsu:assert(\%macro_def.type == "List",
                "Invalid type for compile definition signature. Expected List, but got: "..tostring(\%macro_def.type));
            nomsu:assert(\%body.type == "Block",
                "Invalid type for compile definition body. Expected Block, but got: "..tostring(\%body.type));
            local signature, args = nomsu:parse_spec(\%macro_def);
            local body_lua = nomsu:tree_to_lua(\%body);
            body_lua = body_lua.statements or ("return "..body_lua.expr..";");
            local lua = ([[
        do
            local function macro(%s)
                %s
            end
            local function macro_wrapper(...) return {statements=macro(...)}; end
            nomsu:define_macro(%s, %s, macro_wrapper, %s);
        end]]):format(args, body_lua, signature, nomsu:repr(\%macro_def:get_line_no()),
            nomsu:repr(("compile %s\\n..to code %s"):format(\%macro_def.src, \%body.src)));
            return {statements=lua};
        end, \(__src__ 1));

# Macro to make actions:
immediately:
    compile [action %signature %body] to code:
        lua> ".."
            nomsu:assert(\%signature.type == "List",
                "Invalid type for action definition signature. Expected List, but got: "..tostring(\%signature.type));
            nomsu:assert(\%body.type == "Block",
                "Invalid type for action definition body. Expected Block, but got: "..tostring(\%body.type));
            local signature, args = nomsu:parse_spec(\%signature);
            local body_lua = nomsu:tree_to_lua(\%body);
            body_lua = body_lua.statements or ("return "..body_lua.expr..";");
            local src = nomsu:dedent(nomsu:source_code(0));
            local def_lua = ([[
            nomsu:define_action(%s, \(__line_no__), function(%s)
                %s
            end, %s);]]):format(signature, args, body_lua, nomsu:repr(src));
            return def_lua;

# Macro to make nomsu macros:
immediately:
    lua> ".."
        nomsu:define_macro("parse %shorthand as %longhand", \(__line_no__), (function(nomsu, \%shorthand, \%longhand)
            nomsu:assert(\%shorthand.type == "List",
                "Invalid type for parse definition signature. Expected List, but got: "..tostring(\%shorthand.type));
            nomsu:assert(\%longhand.type == "Block",
                "Invalid type for parse definition body. Expected Block, but got: "..tostring(\%longhand.type));
            local signature, args = nomsu:parse_spec(\%shorthand);
            local template = {};
            for i, line in ipairs(\%longhand.value) do
                template[i] = nomsu:dedent(line.src);
            end
            template = nomsu:repr(table.concat(template, "\\n"));
            local _, arg_names, _ = nomsu:get_stub(\%shorthand.value[1]);
            local replacements = {};
            for i, a in ipairs(arg_names) do replacements[i] = "["..nomsu:repr(a).."]=_"..nomsu:var_to_lua_identifier(a); end
            replacements = "{"..table.concat(replacements, ", ").."}";
            local lua_code = ([[
        nomsu:define_macro(%s, %s, (function(%s)
            local template = nomsu:parse(%s, %s);
            local replacement = nomsu:replaced_vars(template, %s);
            return nomsu:tree_to_lua(replacement);
        end), %s)]]):format(signature, nomsu:repr(\%shorthand:get_line_no()), args, template,
            nomsu:repr(\%shorthand:get_line_no()), replacements, nomsu:repr(nomsu:source_code(0)));
            return {statements=lua_code};
        end), \(__src__ 1));

action [remove action %stub]:
    lua> ".."
        local def = nomsu.defs[\%stub];
        for _, alias in ipairs(def.aliases) do
            nomsu.defs[alias] = false;
        end

immediately:
    action [%tree as lua]:
        =lua "nomsu:tree_to_lua(\%tree).expr"
    action [%tree as lua statements]:
        lua> ".."
            local lua = nomsu:tree_to_lua(\%tree);
            return lua.statements or (lua.expr..";");
    action [%tree as value]:
        =lua "nomsu:tree_to_value(\%tree)"
    compile [repr %obj] to:
        "nomsu:repr(\(%obj as lua))"
    compile [indented %obj] to:
        "nomsu:indent(\(%obj as lua))"
    compile [dedented %obj] to:
        "nomsu:dedent(\(%obj as lua))"
    compile [type %obj, type of %obj] to:
        "type(\(%obj as lua))"

immediately:
    parse [lua do> %block] as:
        lua> "do"
        lua> %block
        lua> "end"

compile [nomsu] to: "nomsu"

compile [nomsu's %key] to: "nomsu[\(%key as lua)]"
compile [nomsu %method %args] to: "nomsu[\(%method as lua)](nomsu, unpack(\(%args as lua)))"
compile [tree %tree with %replacements] to: ".."
    nomsu:replaced_vars(\(%tree as lua), \(%replacements as lua))

parse [action %signature] as:
    (nomsu's "defs")->(nomsu "get_stub" [\%signature])

# Get the source code for a function
action [help %action]:
    lua> ".."
        local fn_def = nomsu.defs[nomsu:get_stub(\%action)]
        if not fn_def then
            nomsu:writeln("Action not found: "..nomsu:repr(\%action));
        else
            nomsu:writeln(fn_def.src or "<unknown source code>");
        end

# Compiler tools
parse [eval %code, run %code] as: nomsu "run" [%code]
action [source code from tree %tree]:
    lua> ".."
        local _,_,leading_space = \%tree.src:find("\\n(%s*)%S");
        if leading_space then
            local chunk1, chunk2 = \%tree.src:match(":%s*([^\\n]*)(\\n.*)");
            chunk2 = chunk2:gsub("\\n"..leading_space, "\\n");
            return chunk1..chunk2.."\\n";
        else
            return \%tree.src:match(":%s*(%S.*)").."\\n";
        end
parse [source code %body] as: source code from tree \%body

parse [parse tree %code] as: nomsu "tree_to_str" [\%code]

parse [enable debugging] as: lua> "nomsu.debug = true"
parse [disable debugging] as: lua> "nomsu.debug = false"