[jackhill/mal.git] / plsql / step7_quote.sql

@io.sql
@types.sql
@reader.sql
@printer.sql
@env.sql
@core.sql

CREATE OR REPLACE PACKAGE mal IS

FUNCTION MAIN(args varchar DEFAULT '()') RETURN integer;

END mal;
/

CREATE OR REPLACE PACKAGE BODY mal IS

FUNCTION MAIN(args varchar DEFAULT '()') RETURN integer IS
    M         types.mal_table;                 -- general mal value memory pool
    H         types.map_entry_table;    -- hashmap memory pool
    E         env_pkg.env_entry_table;  -- mal env memory pool
    repl_env  integer;
    x         integer;
    line      CLOB;
    core_ns   core_ns_T;
    cidx      integer;
    argv      mal_vals;

    -- read
    FUNCTION READ(line varchar) RETURN integer IS
    BEGIN
        RETURN reader.read_str(M, H, line);
    END;

    -- eval

    -- forward declarations
    FUNCTION EVAL(orig_ast integer, orig_env integer) RETURN integer;
    FUNCTION do_builtin(fn integer, args mal_vals) RETURN integer;

    FUNCTION is_pair(ast integer) RETURN BOOLEAN IS
    BEGIN
        RETURN M(ast).type_id IN (8,9) AND types.count(M, ast) > 0;
    END;

    FUNCTION quasiquote(ast integer) RETURN integer IS
        a0   integer;
        a00  integer;
    BEGIN
        IF NOT is_pair(ast) THEN
            RETURN types.list(M, types.symbol(M, 'quote'), ast);
        ELSE
            a0 := types.nth(M, ast, 0);
            IF M(a0).type_id = 7 AND
               TREAT(m(a0) AS mal_str_T).val_str = 'unquote' THEN
                RETURN types.nth(M, ast, 1);
            ELSIF is_pair(a0) THEN
                a00 := types.nth(M, a0, 0);
                IF M(a00).type_id = 7 AND
                   TREAT(M(a00) AS mal_str_T).val_str = 'splice-unquote' THEN
                    RETURN types.list(M, types.symbol(M, 'concat'),
                                         types.nth(M, a0, 1),
                                         quasiquote(types.slice(M, ast, 1)));
                END IF;
            END IF;
            RETURN types.list(M, types.symbol(M, 'cons'),
                                 quasiquote(a0),
                                 quasiquote(types.slice(M, ast, 1)));
        END IF;
    END;

    FUNCTION eval_ast(ast integer, env integer) RETURN integer IS
        i         integer;
        old_seq   mal_vals;
        new_seq   mal_vals;
        new_hm    integer;
        old_midx  integer;
        new_midx  integer;
        k         varchar2(256);
    BEGIN
        IF M(ast).type_id = 7 THEN
            RETURN env_pkg.env_get(M, E, env, ast);
        ELSIF M(ast).type_id IN (8,9) THEN
            old_seq := TREAT(M(ast) AS mal_seq_T).val_seq;
            new_seq := mal_vals();
            new_seq.EXTEND(old_seq.COUNT);
            FOR i IN 1..old_seq.COUNT LOOP
                new_seq(i) := EVAL(old_seq(i), env);
            END LOOP;
            RETURN types.seq(M, M(ast).type_id, new_seq);
        ELSIF M(ast).type_id IN (10) THEN
            new_hm := types.hash_map(M, H, mal_vals());
            old_midx := TREAT(M(ast) AS mal_map_T).map_idx;
            new_midx := TREAT(M(new_hm) AS mal_map_T).map_idx;

            k := H(old_midx).FIRST();
            WHILE k IS NOT NULL LOOP
                H(new_midx)(k) := EVAL(H(old_midx)(k), env);
                k := H(old_midx).NEXT(k);
            END LOOP;
            RETURN new_hm;
        ELSE
            RETURN ast;
        END IF;
    END;

    FUNCTION EVAL(orig_ast integer, orig_env integer) RETURN integer IS
        ast      integer := orig_ast;
        env      integer := orig_env;
        el       integer;
        a0       integer;
        a0sym    varchar2(100);
        seq      mal_vals;
        let_env  integer;
        i        integer;
        f        integer;
        cond     integer;
        malfn    mal_func_T;
        args     mal_vals;
    BEGIN
      WHILE TRUE LOOP
        -- io.writeline('EVAL: ' || printer.pr_str(M, ast));
        IF M(ast).type_id <> 8 THEN
            RETURN eval_ast(ast, env);
        END IF;
        IF types.count(M, ast) = 0 THEN
            RETURN ast; -- empty list just returned
        END IF;

        -- apply
        a0 := types.first(M, ast);
        if M(a0).type_id = 7 THEN -- symbol
            a0sym := TREAT(M(a0) AS mal_str_T).val_str;
        ELSE
            a0sym := '__<*fn*>__';
        END IF;

        CASE
        WHEN a0sym = 'def!' THEN
            RETURN env_pkg.env_set(M, E, env,
                types.nth(M, ast, 1), EVAL(types.nth(M, ast, 2), env));
        WHEN a0sym = 'let*' THEN
            let_env := env_pkg.env_new(M, E, env);
            seq := TREAT(M(types.nth(M, ast, 1)) AS mal_seq_T).val_seq;
            i := 1;
            WHILE i <= seq.COUNT LOOP
                x := env_pkg.env_set(M, E, let_env,
                    seq(i), EVAL(seq(i+1), let_env));
                i := i + 2;
            END LOOP;
            env := let_env;
            ast := types.nth(M, ast, 2); -- TCO
        WHEN a0sym = 'quote' THEN
            RETURN types.nth(M, ast, 1);
        WHEN a0sym = 'quasiquote' THEN
            RETURN EVAL(quasiquote(types.nth(M, ast, 1)), env);
        WHEN a0sym = 'do' THEN
            x := types.slice(M, ast, 1, types.count(M, ast)-2);
            x := eval_ast(x, env);
            ast := types.nth(M, ast, types.count(M, ast)-1);  -- TCO
        WHEN a0sym = 'if' THEN
            cond := EVAL(types.nth(M, ast, 1), env);
            IF cond = 1 OR cond = 2 THEN  -- nil or false
                IF types.count(M, ast) > 3 THEN
                    ast := types.nth(M, ast, 3);  -- TCO
                ELSE
                    RETURN 1;  -- nil
                END IF;
            ELSE
                ast := types.nth(M, ast, 2);  -- TCO
            END IF;
        WHEN a0sym = 'fn*' THEN
            RETURN types.malfunc(M, types.nth(M, ast, 2),
                                    types.nth(M, ast, 1),
                                    env);
        ELSE
            el := eval_ast(ast, env);
            f := types.first(M, el);
            args := TREAT(M(types.slice(M, el, 1)) AS mal_seq_T).val_seq;
            IF M(f).type_id = 12 THEN
                malfn := TREAT(M(f) AS mal_func_T);
                env := env_pkg.env_new(M, E, malfn.env,
                                          malfn.params, args);
                ast := malfn.ast;  -- TCO
            ELSE
                RETURN do_builtin(f, args);
            END IF;
        END CASE;

      END LOOP;

    END;

    -- hack to get around lack of function references
    -- functions that require special access to repl_env or EVAL
    -- are implemented directly here, otherwise, core.do_core_fn
    -- is called.
    FUNCTION do_builtin(fn integer, args mal_vals) RETURN integer IS
        fname   varchar2(100);
        val     integer;
        f       integer;
        malfn   mal_func_T;
        fargs   mal_vals;
        fn_env  integer;
    BEGIN
        fname := TREAT(M(fn) AS mal_str_T).val_str;
        CASE
        WHEN fname = 'do_eval' THEN
            RETURN EVAL(args(1), repl_env);
        WHEN fname = 'swap!' THEN
            val := TREAT(M(args(1)) AS mal_atom_T).val;
            f := args(2);
            -- slice one extra at the beginning that will be changed
            -- to the value of the atom
            fargs := TREAT(M(types.slice(M, args, 1)) AS mal_seq_T).val_seq;
            fargs(1) := val;
            IF M(f).type_id = 12 THEN
                malfn := TREAT(M(f) AS mal_func_T);
                fn_env := env_pkg.env_new(M, E, malfn.env,
                                          malfn.params, fargs);
                val := EVAL(malfn.ast, fn_env);
            ELSE
                val := do_builtin(f, fargs);
            END IF;
            RETURN types.atom_reset(M, args(1), val);
        ELSE
            RETURN core.do_core_func(M, H, fn, args);
        END CASE;
    END;


    -- print
    FUNCTION PRINT(exp integer) RETURN varchar IS
    BEGIN
        RETURN printer.pr_str(M, H, exp);
    END;

    -- repl
    FUNCTION REP(line varchar) RETURN varchar IS
    BEGIN
        RETURN PRINT(EVAL(READ(line), repl_env));
    END;

BEGIN
    -- initialize memory pools
    M := types.mem_new();
    H := types.map_entry_table();
    E := env_pkg.env_entry_table();

    repl_env := env_pkg.env_new(M, E, NULL);

    argv := TREAT(M(reader.read_str(M, H, args)) AS mal_seq_T).val_seq;

    -- core.EXT: defined using PL/SQL
    core_ns := core.get_core_ns();
    FOR cidx IN 1..core_ns.COUNT LOOP
        x := env_pkg.env_set(M, E, repl_env,
            types.symbol(M, core_ns(cidx)),
            types.func(M, core_ns(cidx)));
    END LOOP;
    x := env_pkg.env_set(M, E, repl_env,
        types.symbol(M, 'eval'),
        types.func(M, 'do_eval'));
    x := env_pkg.env_set(M, E, repl_env,
        types.symbol(M, '*ARGV*'),
        types.slice(M, argv, 1));

    -- core.mal: defined using the language itself
    line := REP('(def! not (fn* (a) (if a false true)))');
    line := REP('(def! load-file (fn* (f) (eval (read-string (str "(do " (slurp f) ")")))))');

    IF argv.COUNT() > 0 THEN
        BEGIN
            line := REP('(load-file "' ||
                    TREAT(M(argv(1)) AS mal_str_T).val_str ||
                    '")');
            io.close(1);  -- close output stream
            RETURN 0;
        EXCEPTION WHEN OTHERS THEN
            io.writeline('Error: ' || SQLERRM);
            io.writeline(dbms_utility.format_error_backtrace);
            io.close(1);  -- close output stream
            RAISE;
        END;
    END IF;

    WHILE true LOOP
        BEGIN
            line := io.readline('user> ', 0);
            IF line = EMPTY_CLOB() THEN CONTINUE; END IF;
            IF line IS NOT NULL THEN
                io.writeline(REP(line));
            END IF;

            EXCEPTION WHEN OTHERS THEN
                IF SQLCODE = -20001 THEN  -- io read stream closed
                    io.close(1);  -- close output stream
                    RETURN 0;
                END IF;
                io.writeline('Error: ' || SQLERRM);
                io.writeline(dbms_utility.format_error_backtrace);
        END;
    END LOOP;
END;

END mal;
/
show errors;

quit;
Commit	Line	Data
0fc03918 JM	1	@io.sql
	2	@types.sql
	3	@reader.sql
	4	@printer.sql
	5	@env.sql
	6	@core.sql
	7
	8	CREATE OR REPLACE PACKAGE mal IS
	9
10cc781f	10	FUNCTION MAIN(args varchar DEFAULT '()') RETURN integer;
0fc03918 JM	11
	12	END mal;
	13	/
	14
	15	CREATE OR REPLACE PACKAGE BODY mal IS
	16
10cc781f	17	FUNCTION MAIN(args varchar DEFAULT '()') RETURN integer IS
2866f9a8	18	M types.mal_table; -- general mal value memory pool
6a085103 JM	19	H types.map_entry_table; -- hashmap memory pool
6a085103 JM	20	E env_pkg.env_entry_table; -- mal env memory pool
0fc03918 JM	21	repl_env integer;
0fc03918 JM	22	x integer;
02936b42	23	line CLOB;
2866f9a8	24	core_ns core_ns_T;
0fc03918	25	cidx integer;
2866f9a8	26	argv mal_vals;
0fc03918 JM	27
	28	-- read
	29	FUNCTION READ(line varchar) RETURN integer IS
	30	BEGIN
6a085103	31	RETURN reader.read_str(M, H, line);
0fc03918 JM	32	END;
	33
	34	-- eval
	35
	36	-- forward declarations
	37	FUNCTION EVAL(orig_ast integer, orig_env integer) RETURN integer;
2866f9a8	38	FUNCTION do_builtin(fn integer, args mal_vals) RETURN integer;
0fc03918 JM	39
	40	FUNCTION is_pair(ast integer) RETURN BOOLEAN IS
	41	BEGIN
	42	RETURN M(ast).type_id IN (8,9) AND types.count(M, ast) > 0;
	43	END;
	44
	45	FUNCTION quasiquote(ast integer) RETURN integer IS
	46	a0 integer;
	47	a00 integer;
	48	BEGIN
	49	IF NOT is_pair(ast) THEN
	50	RETURN types.list(M, types.symbol(M, 'quote'), ast);
	51	ELSE
	52	a0 := types.nth(M, ast, 0);
	53	IF M(a0).type_id = 7 AND
2866f9a8	54	TREAT(m(a0) AS mal_str_T).val_str = 'unquote' THEN
0fc03918 JM	55	RETURN types.nth(M, ast, 1);
	56	ELSIF is_pair(a0) THEN
	57	a00 := types.nth(M, a0, 0);
	58	IF M(a00).type_id = 7 AND
2866f9a8	59	TREAT(M(a00) AS mal_str_T).val_str = 'splice-unquote' THEN
0fc03918 JM	60	RETURN types.list(M, types.symbol(M, 'concat'),
	61	types.nth(M, a0, 1),
	62	quasiquote(types.slice(M, ast, 1)));
	63	END IF;
	64	END IF;
	65	RETURN types.list(M, types.symbol(M, 'cons'),
	66	quasiquote(a0),
	67	quasiquote(types.slice(M, ast, 1)));
	68	END IF;
	69	END;
	70
	71	FUNCTION eval_ast(ast integer, env integer) RETURN integer IS
6a085103	72	i integer;
2866f9a8 JM	73	old_seq mal_vals;
2866f9a8 JM	74	new_seq mal_vals;
6a085103 JM	75	new_hm integer;
	76	old_midx integer;
	77	new_midx integer;
	78	k varchar2(256);
0fc03918 JM	79	BEGIN
0fc03918 JM	80	IF M(ast).type_id = 7 THEN
10cc781f	81	RETURN env_pkg.env_get(M, E, env, ast);
0fc03918	82	ELSIF M(ast).type_id IN (8,9) THEN
2866f9a8 JM	83	old_seq := TREAT(M(ast) AS mal_seq_T).val_seq;
2866f9a8 JM	84	new_seq := mal_vals();
0fc03918 JM	85	new_seq.EXTEND(old_seq.COUNT);
	86	FOR i IN 1..old_seq.COUNT LOOP
	87	new_seq(i) := EVAL(old_seq(i), env);
	88	END LOOP;
	89	RETURN types.seq(M, M(ast).type_id, new_seq);
6a085103	90	ELSIF M(ast).type_id IN (10) THEN
2866f9a8 JM	91	new_hm := types.hash_map(M, H, mal_vals());
	92	old_midx := TREAT(M(ast) AS mal_map_T).map_idx;
	93	new_midx := TREAT(M(new_hm) AS mal_map_T).map_idx;
6a085103 JM	94
	95	k := H(old_midx).FIRST();
	96	WHILE k IS NOT NULL LOOP
	97	H(new_midx)(k) := EVAL(H(old_midx)(k), env);
	98	k := H(old_midx).NEXT(k);
	99	END LOOP;
	100	RETURN new_hm;
0fc03918 JM	101	ELSE
	102	RETURN ast;
	103	END IF;
	104	END;
	105
	106	FUNCTION EVAL(orig_ast integer, orig_env integer) RETURN integer IS
	107	ast integer := orig_ast;
	108	env integer := orig_env;
	109	el integer;
	110	a0 integer;
150011e4	111	a0sym varchar2(100);
2866f9a8	112	seq mal_vals;
0fc03918 JM	113	let_env integer;
	114	i integer;
	115	f integer;
	116	cond integer;
2866f9a8 JM	117	malfn mal_func_T;
2866f9a8 JM	118	args mal_vals;
0fc03918 JM	119	BEGIN
0fc03918 JM	120	WHILE TRUE LOOP
2866f9a8	121	-- io.writeline('EVAL: ' \|\| printer.pr_str(M, ast));
0fc03918 JM	122	IF M(ast).type_id <> 8 THEN
	123	RETURN eval_ast(ast, env);
	124	END IF;
6a085103 JM	125	IF types.count(M, ast) = 0 THEN
	126	RETURN ast; -- empty list just returned
	127	END IF;
0fc03918 JM	128
	129	-- apply
	130	a0 := types.first(M, ast);
	131	if M(a0).type_id = 7 THEN -- symbol
2866f9a8	132	a0sym := TREAT(M(a0) AS mal_str_T).val_str;
0fc03918 JM	133	ELSE
	134	a0sym := '__<fn>__';
	135	END IF;
	136
	137	CASE
	138	WHEN a0sym = 'def!' THEN
10cc781f	139	RETURN env_pkg.env_set(M, E, env,
0fc03918 JM	140	types.nth(M, ast, 1), EVAL(types.nth(M, ast, 2), env));
0fc03918 JM	141	WHEN a0sym = 'let*' THEN
10cc781f	142	let_env := env_pkg.env_new(M, E, env);
2866f9a8	143	seq := TREAT(M(types.nth(M, ast, 1)) AS mal_seq_T).val_seq;
0fc03918 JM	144	i := 1;
0fc03918 JM	145	WHILE i <= seq.COUNT LOOP
10cc781f	146	x := env_pkg.env_set(M, E, let_env,
0fc03918 JM	147	seq(i), EVAL(seq(i+1), let_env));
	148	i := i + 2;
	149	END LOOP;
	150	env := let_env;
	151	ast := types.nth(M, ast, 2); -- TCO
	152	WHEN a0sym = 'quote' THEN
	153	RETURN types.nth(M, ast, 1);
	154	WHEN a0sym = 'quasiquote' THEN
	155	RETURN EVAL(quasiquote(types.nth(M, ast, 1)), env);
	156	WHEN a0sym = 'do' THEN
	157	x := types.slice(M, ast, 1, types.count(M, ast)-2);
	158	x := eval_ast(x, env);
	159	ast := types.nth(M, ast, types.count(M, ast)-1); -- TCO
	160	WHEN a0sym = 'if' THEN
	161	cond := EVAL(types.nth(M, ast, 1), env);
	162	IF cond = 1 OR cond = 2 THEN -- nil or false
	163	IF types.count(M, ast) > 3 THEN
6a085103	164	ast := types.nth(M, ast, 3); -- TCO
0fc03918 JM	165	ELSE
	166	RETURN 1; -- nil
	167	END IF;
	168	ELSE
6a085103	169	ast := types.nth(M, ast, 2); -- TCO
0fc03918 JM	170	END IF;
	171	WHEN a0sym = 'fn*' THEN
	172	RETURN types.malfunc(M, types.nth(M, ast, 2),
	173	types.nth(M, ast, 1),
	174	env);
	175	ELSE
	176	el := eval_ast(ast, env);
	177	f := types.first(M, el);
2866f9a8	178	args := TREAT(M(types.slice(M, el, 1)) AS mal_seq_T).val_seq;
0fc03918	179	IF M(f).type_id = 12 THEN
2866f9a8	180	malfn := TREAT(M(f) AS mal_func_T);
10cc781f	181	env := env_pkg.env_new(M, E, malfn.env,
0fc03918 JM	182	malfn.params, args);
	183	ast := malfn.ast; -- TCO
	184	ELSE
	185	RETURN do_builtin(f, args);
	186	END IF;
	187	END CASE;
	188
	189	END LOOP;
	190
	191	END;
	192
	193	-- hack to get around lack of function references
	194	-- functions that require special access to repl_env or EVAL
	195	-- are implemented directly here, otherwise, core.do_core_fn
	196	-- is called.
2866f9a8	197	FUNCTION do_builtin(fn integer, args mal_vals) RETURN integer IS
0fc03918	198	fname varchar2(100);
150011e4	199	val integer;
0fc03918	200	f integer;
2866f9a8 JM	201	malfn mal_func_T;
2866f9a8 JM	202	fargs mal_vals;
0fc03918 JM	203	fn_env integer;
0fc03918 JM	204	BEGIN
2866f9a8	205	fname := TREAT(M(fn) AS mal_str_T).val_str;
0fc03918 JM	206	CASE
0fc03918 JM	207	WHEN fname = 'do_eval' THEN
150011e4	208	RETURN EVAL(args(1), repl_env);
0fc03918	209	WHEN fname = 'swap!' THEN
2866f9a8	210	val := TREAT(M(args(1)) AS mal_atom_T).val;
150011e4	211	f := args(2);
0fc03918 JM	212	-- slice one extra at the beginning that will be changed
0fc03918 JM	213	-- to the value of the atom
2866f9a8	214	fargs := TREAT(M(types.slice(M, args, 1)) AS mal_seq_T).val_seq;
150011e4	215	fargs(1) := val;
0fc03918	216	IF M(f).type_id = 12 THEN
2866f9a8	217	malfn := TREAT(M(f) AS mal_func_T);
10cc781f	218	fn_env := env_pkg.env_new(M, E, malfn.env,
150011e4 JM	219	malfn.params, fargs);
150011e4 JM	220	val := EVAL(malfn.ast, fn_env);
0fc03918	221	ELSE
150011e4	222	val := do_builtin(f, fargs);
0fc03918	223	END IF;
2866f9a8	224	RETURN types.atom_reset(M, args(1), val);
0fc03918	225	ELSE
6a085103	226	RETURN core.do_core_func(M, H, fn, args);
0fc03918 JM	227	END CASE;
	228	END;
	229
	230
	231	-- print
	232	FUNCTION PRINT(exp integer) RETURN varchar IS
	233	BEGIN
6a085103	234	RETURN printer.pr_str(M, H, exp);
0fc03918 JM	235	END;
	236
	237	-- repl
	238	FUNCTION REP(line varchar) RETURN varchar IS
	239	BEGIN
	240	RETURN PRINT(EVAL(READ(line), repl_env));
	241	END;
	242
	243	BEGIN
6a085103	244	-- initialize memory pools
0fc03918	245	M := types.mem_new();
6a085103	246	H := types.map_entry_table();
10cc781f	247	E := env_pkg.env_entry_table();
0fc03918	248
10cc781f JM	249	repl_env := env_pkg.env_new(M, E, NULL);
10cc781f JM	250
2866f9a8	251	argv := TREAT(M(reader.read_str(M, H, args)) AS mal_seq_T).val_seq;
0fc03918 JM	252
	253	-- core.EXT: defined using PL/SQL
	254	core_ns := core.get_core_ns();
	255	FOR cidx IN 1..core_ns.COUNT LOOP
10cc781f	256	x := env_pkg.env_set(M, E, repl_env,
0fc03918 JM	257	types.symbol(M, core_ns(cidx)),
	258	types.func(M, core_ns(cidx)));
	259	END LOOP;
10cc781f	260	x := env_pkg.env_set(M, E, repl_env,
0fc03918 JM	261	types.symbol(M, 'eval'),
0fc03918 JM	262	types.func(M, 'do_eval'));
10cc781f	263	x := env_pkg.env_set(M, E, repl_env,
0fc03918	264	types.symbol(M, 'ARGV'),
10cc781f	265	types.slice(M, argv, 1));
0fc03918 JM	266
	267	-- core.mal: defined using the language itself
	268	line := REP('(def! not (fn* (a) (if a false true)))');
	269	line := REP('(def! load-file (fn* (f) (eval (read-string (str "(do " (slurp f) ")")))))');
	270
10cc781f	271	IF argv.COUNT() > 0 THEN
8119e744 JM	272	BEGIN
8119e744 JM	273	line := REP('(load-file "' \|\|
2866f9a8	274	TREAT(M(argv(1)) AS mal_str_T).val_str \|\|
8119e744 JM	275	'")');
	276	io.close(1); -- close output stream
	277	RETURN 0;
	278	EXCEPTION WHEN OTHERS THEN
	279	io.writeline('Error: ' \|\| SQLERRM);
	280	io.writeline(dbms_utility.format_error_backtrace);
	281	io.close(1); -- close output stream
	282	RAISE;
	283	END;
10cc781f JM	284	END IF;
10cc781f JM	285
0fc03918 JM	286	WHILE true LOOP
0fc03918 JM	287	BEGIN
02936b42 JM	288	line := io.readline('user> ', 0);
02936b42 JM	289	IF line = EMPTY_CLOB() THEN CONTINUE; END IF;
0fc03918	290	IF line IS NOT NULL THEN
02936b42	291	io.writeline(REP(line));
0fc03918 JM	292	END IF;
	293
	294	EXCEPTION WHEN OTHERS THEN
8119e744 JM	295	IF SQLCODE = -20001 THEN -- io read stream closed
8119e744 JM	296	io.close(1); -- close output stream
0fc03918 JM	297	RETURN 0;
0fc03918 JM	298	END IF;
02936b42 JM	299	io.writeline('Error: ' \|\| SQLERRM);
02936b42 JM	300	io.writeline(dbms_utility.format_error_backtrace);
0fc03918 JM	301	END;
	302	END LOOP;
	303	END;
	304
	305	END mal;
	306	/
	307	show errors;
	308
	309	quit;