MORPH
SIGN IN SIGN UP
kanaka / mal UNCLAIMED

mal - Make a Lisp

0 0 1 Assembly
Normal View History Raw
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
-- ---------------------------------------------------------
-- step9_try.sql
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
\i init.sql
plpgsql: IO using stream table. Add keywords.
2016-03-25 00:05:54 -05:00
\i io.sql
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
\i types.sql
\i reader.sql
\i printer.sql
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
\i envs.sql
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
\i core.sql
-- ---------------------------------------------------------
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
CREATE SCHEMA mal;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
-- read
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
CREATE FUNCTION mal.READ(line varchar) RETURNS integer AS $$
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
RETURN reader.read_str(line);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END; $$ LANGUAGE plpgsql;
-- eval
Change quasiquote algorithm - Add a `vec` built-in function in step7 so that `quasiquote` does not require `apply` from step9. - Introduce quasiquoteexpand special in order to help debugging step7. This may also prepare newcomers to understand step8. - Add soft tests. - Do not quote numbers, strings and so on. Should ideally have been in separate commits: - elisp: simplify and fix (keyword :k) - factor: fix copy/paste error in let*/step7, simplify eval-ast. - guile: improve list/vector types - haskell: revert evaluation during quasiquote - logo, make: cosmetic issues
2020-07-21 18:01:48 +02:00
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
CREATE FUNCTION mal.eval_debug(ast integer, env integer) RETURNS void AS $$
DECLARE
val constant integer := envs.get(env, 'DEBUG-EVAL');
BEGIN
IF val IS NOT NULL THEN
IF (SELECT type_id FROM types.value WHERE value_id = val) NOT IN (0, 1)
THEN
PERFORM io.writeline(format('EVAL: %s [%s]', mal.PRINT(ast), ast));
END IF;
END IF;
END; $$ LANGUAGE plpgsql;
Change quasiquote algorithm - Add a `vec` built-in function in step7 so that `quasiquote` does not require `apply` from step9. - Introduce quasiquoteexpand special in order to help debugging step7. This may also prepare newcomers to understand step8. - Add soft tests. - Do not quote numbers, strings and so on. Should ideally have been in separate commits: - elisp: simplify and fix (keyword :k) - factor: fix copy/paste error in let*/step7, simplify eval-ast. - guile: improve list/vector types - haskell: revert evaluation during quasiquote - logo, make: cosmetic issues
2020-07-21 18:01:48 +02:00
CREATE FUNCTION mal.qq_loop(elt integer, acc integer) RETURNS integer AS $$
DECLARE
a0 integer;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
Change quasiquote algorithm - Add a `vec` built-in function in step7 so that `quasiquote` does not require `apply` from step9. - Introduce quasiquoteexpand special in order to help debugging step7. This may also prepare newcomers to understand step8. - Add soft tests. - Do not quote numbers, strings and so on. Should ideally have been in separate commits: - elisp: simplify and fix (keyword :k) - factor: fix copy/paste error in let*/step7, simplify eval-ast. - guile: improve list/vector types - haskell: revert evaluation during quasiquote - logo, make: cosmetic issues
2020-07-21 18:01:48 +02:00
IF types._list_Q(elt) AND types._count(elt) = 2 THEN
a0 := types._first(elt);
IF types._symbol_Q(a0) AND a0 = types._symbolv('splice-unquote') THEN
RETURN types._list(ARRAY[types._symbolv('concat'), types._nth(elt, 1), acc]);
END IF;
END IF;
RETURN types._list(ARRAY[types._symbolv('cons'), mal.quasiquote(elt), acc]);
END; $$ LANGUAGE plpgsql;
CREATE FUNCTION mal.qq_foldr(xs integer) RETURNS integer AS $$
DECLARE
elt integer;
acc integer := types._list(ARRAY[]::integer[]);
BEGIN
FOREACH elt IN ARRAY types.array_reverse(types._valueToArray(xs)) LOOP
acc := mal.qq_loop(elt, acc);
END LOOP;
RETURN acc;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END; $$ LANGUAGE plpgsql;
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
CREATE FUNCTION mal.quasiquote(ast integer) RETURNS integer AS $$
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
CASE type_id FROM types.value WHERE value_id = ast
WHEN 8 THEN -- list
DECLARE
a0 integer;
Change quasiquote algorithm - Add a `vec` built-in function in step7 so that `quasiquote` does not require `apply` from step9. - Introduce quasiquoteexpand special in order to help debugging step7. This may also prepare newcomers to understand step8. - Add soft tests. - Do not quote numbers, strings and so on. Should ideally have been in separate commits: - elisp: simplify and fix (keyword :k) - factor: fix copy/paste error in let*/step7, simplify eval-ast. - guile: improve list/vector types - haskell: revert evaluation during quasiquote - logo, make: cosmetic issues
2020-07-21 18:01:48 +02:00
BEGIN
IF types._count(ast) = 2 THEN
a0 := types._first(ast);
IF types._symbol_Q(a0) AND a0 = types._symbolv('unquote') THEN
RETURN types._nth(ast, 1);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END IF;
END IF;
Change quasiquote algorithm - Add a `vec` built-in function in step7 so that `quasiquote` does not require `apply` from step9. - Introduce quasiquoteexpand special in order to help debugging step7. This may also prepare newcomers to understand step8. - Add soft tests. - Do not quote numbers, strings and so on. Should ideally have been in separate commits: - elisp: simplify and fix (keyword :k) - factor: fix copy/paste error in let*/step7, simplify eval-ast. - guile: improve list/vector types - haskell: revert evaluation during quasiquote - logo, make: cosmetic issues
2020-07-21 18:01:48 +02:00
RETURN mal.qq_foldr(ast);
END;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
WHEN 9 THEN -- vector
Change quasiquote algorithm - Add a `vec` built-in function in step7 so that `quasiquote` does not require `apply` from step9. - Introduce quasiquoteexpand special in order to help debugging step7. This may also prepare newcomers to understand step8. - Add soft tests. - Do not quote numbers, strings and so on. Should ideally have been in separate commits: - elisp: simplify and fix (keyword :k) - factor: fix copy/paste error in let*/step7, simplify eval-ast. - guile: improve list/vector types - haskell: revert evaluation during quasiquote - logo, make: cosmetic issues
2020-07-21 18:01:48 +02:00
RETURN types._list(ARRAY[types._symbolv('vec'), mal.qq_foldr(ast)]);
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
WHEN 7, 10 THEN -- symbol or map
Change quasiquote algorithm - Add a `vec` built-in function in step7 so that `quasiquote` does not require `apply` from step9. - Introduce quasiquoteexpand special in order to help debugging step7. This may also prepare newcomers to understand step8. - Add soft tests. - Do not quote numbers, strings and so on. Should ideally have been in separate commits: - elisp: simplify and fix (keyword :k) - factor: fix copy/paste error in let*/step7, simplify eval-ast. - guile: improve list/vector types - haskell: revert evaluation during quasiquote - logo, make: cosmetic issues
2020-07-21 18:01:48 +02:00
RETURN types._list(ARRAY[types._symbolv('quote'), ast]);
ELSE
RETURN ast;
END CASE;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END; $$ LANGUAGE plpgsql;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
CREATE FUNCTION mal.eval_symbol(ast integer, env integer) RETURNS integer
AS $$
DECLARE
symkey constant varchar := types._valueToString(ast);
result constant integer := envs.get(env, symkey);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
IF result IS NULL THEN
RAISE EXCEPTION '''%'' not found', symkey;
END IF;
RETURN result;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
$$ LANGUAGE plpgsql;
CREATE FUNCTION mal.eval_vector(ast integer, env integer) RETURNS integer
AS $$
DECLARE
seq constant integer[] := types._valueToArray(ast);
eseq integer[];
result integer;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: refactor/remove collection table. Add seq/conj.
2016-03-30 23:58:03 -05:00
-- Evaluate each entry creating a new sequence
FOR i IN 1 .. COALESCE(array_length(seq, 1), 0) LOOP
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
eseq[i] := mal.EVAL(seq[i], env);
plpgsql: refactor/remove collection table. Add seq/conj.
2016-03-30 23:58:03 -05:00
END LOOP;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
INSERT INTO types.value (type_id, val_seq) VALUES (9, eseq)
plpgsql: stepA, hash-maps, metadata.
2016-03-25 23:11:40 -05:00
RETURNING value_id INTO result;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
RETURN result;
plpgsql: refactor/remove collection table. Add seq/conj.
2016-03-30 23:58:03 -05:00
END;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
$$ LANGUAGE plpgsql;
CREATE FUNCTION mal.eval_map(ast integer, env integer) RETURNS integer
AS $$
DECLARE
hash hstore;
ehash hstore;
kv RECORD;
e integer;
result integer;
plpgsql: refactor/remove collection table. Add seq/conj.
2016-03-30 23:58:03 -05:00
BEGIN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
SELECT val_hash INTO hash FROM types.value WHERE value_id = ast;
plpgsql: refactor/remove collection table. Add seq/conj.
2016-03-30 23:58:03 -05:00
-- Evaluate each value for every key/value
FOR kv IN SELECT * FROM each(hash) LOOP
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
e := mal.EVAL(CAST(kv.value AS integer), env);
plpgsql: refactor/remove collection table. Add seq/conj.
2016-03-30 23:58:03 -05:00
IF ehash IS NULL THEN
ehash := hstore(kv.key, CAST(e AS varchar));
ELSE
ehash := ehash || hstore(kv.key, CAST(e AS varchar));
END IF;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END LOOP;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
INSERT INTO types.value (type_id, val_hash) VALUES (10, ehash)
plpgsql: refactor/remove collection table. Add seq/conj.
2016-03-30 23:58:03 -05:00
RETURNING value_id INTO result;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
RETURN result;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
$$ LANGUAGE plpgsql;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
CREATE FUNCTION mal.EVAL(ast integer, env integer) RETURNS integer AS $$
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
DECLARE
a0 integer;
BEGIN
LOOP
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
PERFORM mal.eval_debug(ast, env);
CASE type_id FROM types.value WHERE value_id = ast
WHEN 7 THEN RETURN mal.eval_symbol(ast, env);
WHEN 8 THEN NULL; -- List, proceed after this case statement.
WHEN 9 THEN RETURN mal.eval_vector(ast, env);
WHEN 10 THEN RETURN mal.eval_map(ast, env);
ELSE RETURN ast;
END CASE;
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
IF types._count(ast) = 0 THEN
RETURN ast;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END IF;
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
a0 := types._first(ast);
IF types._symbol_Q(a0) THEN
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
CASE val_string FROM types.value WHERE value_id = a0
WHEN 'def!' THEN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
RETURN envs.set(env, types._nth(ast, 1),
mal.EVAL(types._nth(ast, 2), env));
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
WHEN 'let*' THEN
DECLARE
let_env constant integer := envs.new(env);
binds constant integer[] := types._valueToArray(types._nth(ast, 1));
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
FOR idx IN 1 .. array_length(binds, 1) BY 2 LOOP
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
PERFORM envs.set(let_env, binds[idx],
mal.EVAL(binds[idx+1], let_env));
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END LOOP;
env := let_env;
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
ast := types._nth(ast, 2);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
CONTINUE; -- TCO
END;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
WHEN 'quote' THEN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
RETURN types._nth(ast, 1);
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
WHEN 'quasiquote' THEN
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
ast := mal.quasiquote(types._nth(ast, 1));
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
CONTINUE; -- TCO
END;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
WHEN 'defmacro!' THEN
RETURN envs.set(env, types._nth(ast, 1),
types._macro(mal.EVAL(types._nth(ast, 2), env)));
WHEN 'try*' THEN
DECLARE
a1 constant integer := types._nth(ast, 1);
a2 integer;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
IF types._count(ast) >= 3 THEN
a2 = types._nth(ast, 2);
IF types._valueToString(types._nth(a2, 0)) = 'catch*' THEN
BEGIN
RETURN mal.EVAL(a1, env);
EXCEPTION WHEN OTHERS THEN
env := envs.new(env);
PERFORM envs.set(env, types._nth(a2, 1),
types._stringv(SQLERRM));
ast := types._nth(a2, 2);
CONTINUE; -- TCO
END;
END IF;
END IF;
ast := a1;
CONTINUE; -- TCO
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
WHEN 'do' THEN
DECLARE
ignored integer;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
FOR i IN 1 .. types._count(ast) - 2 LOOP
ignored := mal.EVAL(types._nth(ast, i), env);
END LOOP;
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
ast := types._nth(ast, types._count(ast)-1);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
CONTINUE; -- TCO
END;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
WHEN 'if' THEN
IF (SELECT type_id FROM types.value
WHERE value_id = mal.EVAL(types._nth(ast, 1), env))
IN (0, 1)
THEN -- nil or false
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
IF types._count(ast) > 3 THEN
ast := types._nth(ast, 3);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
CONTINUE; -- TCO
ELSE
RETURN 0; -- nil
END IF;
ELSE
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
ast := types._nth(ast, 2);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
CONTINUE; -- TCO
END IF;
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
WHEN 'fn*' THEN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
RETURN types._malfunc(types._nth(ast, 2), types._nth(ast, 1), env);
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
ELSE
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
NULL;
END CASE;
END IF;
-- Apply phase.
DECLARE
type integer;
fname varchar;
fast integer;
fparams integer;
fenv integer;
fmacro boolean;
args integer[] := ARRAY[]::integer[];
result integer;
evda0 constant integer := mal.EVAL(a0, env);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: merge evalASt {quasiquote,macro}expand, add DEBUG-EVAL env.get: loop instead of a recursion, string parameter (merged with vget), do not raise an exception when the key is missing. Split eval_ast into eval_{symbol,vector,map} in order to reduce the diff and improve readability of EVAL. Use existing blocks to declare variables/constants near the place they are actually used. Several were unused. Simplify try*, perform TCO.
2024-10-25 16:55:53 +02:00
SELECT type_id, val_string, ast_id, params_id, env_id, macro
INTO type, fname, fast, fparams, fenv, fmacro
FROM types.value WHERE value_id = evda0;
IF fmacro THEN
ast := types._apply(evda0, types._restArray(ast));
CONTINUE; -- TCO
END IF;
FOR i in 1 .. types._count(ast) - 1 LOOP
args[i] := mal.EVAL(types._nth(ast, i), env);
END LOOP;
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
IF type = 11 THEN
EXECUTE format('SELECT %s($1);', fname)
INTO result USING args;
RETURN result;
ELSIF type = 12 THEN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
env := envs.new(fenv, fparams, args);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
ast := fast;
CONTINUE; -- TCO
ELSE
RAISE EXCEPTION 'Invalid function call';
END IF;
END;
END LOOP;
END; $$ LANGUAGE plpgsql;
-- print
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
CREATE FUNCTION mal.PRINT(exp integer) RETURNS varchar AS $$
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
RETURN printer.pr_str(exp);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END; $$ LANGUAGE plpgsql;
-- repl
-- repl_env is environment 0
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
CREATE FUNCTION mal.REP(line varchar) RETURNS varchar AS $$
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
RETURN mal.PRINT(mal.EVAL(mal.READ(line), 0));
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END; $$ LANGUAGE plpgsql;
-- core.sql: defined using SQL (in core.sql)
-- repl_env is created and populated with core functions in by core.sql
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
CREATE FUNCTION mal.mal_eval(args integer[]) RETURNS integer AS $$
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
BEGIN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
RETURN mal.EVAL(args[1], 0);
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
END; $$ LANGUAGE plpgsql;
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
INSERT INTO types.value (type_id, val_string) VALUES (11, 'mal.mal_eval');
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
SELECT envs.vset(0, 'eval',
(SELECT value_id FROM types.value
WHERE val_string = 'mal.mal_eval')) \g '/dev/null'
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
-- *ARGV* values are set by RUN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
SELECT envs.vset(0, '*ARGV*', mal.READ('()')) \g '/dev/null'
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
-- core.mal: defined using the language itself
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
SELECT mal.REP('(def! not (fn* (a) (if a false true)))') \g '/dev/null'
load-file: accept empty file or final comment, return nil Let `load-file` append a new line in case last line contains a comment. Also append `nil` so that the return value is predictible. Remove the existing explicit `nil` from existing sources. Adapt documentation and tests.
2019-07-15 23:57:02 +02:00
SELECT mal.REP('(def! load-file (fn* (f) (eval (read-string (str "(do " (slurp f) "\nnil)")))))') \g '/dev/null'
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
SELECT mal.REP('(defmacro! cond (fn* (& xs) (if (> (count xs) 0) (list ''if (first xs) (if (> (count xs) 1) (nth xs 1) (throw "odd number of forms to cond")) (cons ''cond (rest (rest xs)))))))') \g '/dev/null'
plpgsql: add steps7-9
2016-03-24 21:10:10 -05:00
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
CREATE FUNCTION mal.MAIN(pwd varchar, argstring varchar DEFAULT NULL)
RETURNS integer AS $$
plpgsql: IO using stream table. Add keywords.
2016-03-25 00:05:54 -05:00
DECLARE
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
line varchar;
output varchar;
allargs integer;
plpgsql: IO using stream table. Add keywords.
2016-03-25 00:05:54 -05:00
BEGIN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
PERFORM envs.vset(0, '*PWD*', types._stringv(pwd));
IF argstring IS NOT NULL THEN
allargs := mal.READ(argstring);
PERFORM envs.vset(0, '*ARGV*', types._rest(allargs));
PERFORM mal.REP('(load-file ' ||
printer.pr_str(types._first(allargs)) || ')');
PERFORM io.close(1);
PERFORM io.wait_flushed(1);
RETURN 0;
END IF;
plpgsql: IO using stream table. Add keywords.
2016-03-25 00:05:54 -05:00
WHILE true
LOOP
BEGIN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
line := io.readline('user> ', 0);
IF line IS NULL THEN
PERFORM io.close(1);
RETURN 0;
END IF;
IF line NOT IN ('', E'\n') THEN
output := mal.REP(line);
PERFORM io.writeline(output);
plpgsql: IO using stream table. Add keywords.
2016-03-25 00:05:54 -05:00
END IF;
EXCEPTION WHEN OTHERS THEN
plpgsql: schema namespaces. refactor IO. - move each file to a schema namespace. Don't recreate DB, just the schemas. This is much faster and avoids the error about user still using the DB when recreating the DB. - combine RUN and MAIN_LOOP into MAIN routine. - add open column to streams table - close stream 1 in MAIN
2016-05-02 23:02:29 -05:00
PERFORM io.writeline('Error: ' || SQLERRM);
plpgsql: IO using stream table. Add keywords.
2016-03-25 00:05:54 -05:00
END;
END LOOP;
END; $$ LANGUAGE plpgsql;
Reference in New Issue Copy Permalink