ati/PLati/algo.pks

CREATE OR REPLACE PACKAGE algo AS
	SUBTYPE ASTRING IS VARCHAR(128);
	-- ###
	EMPTY_VAL CONSTANT CHAR(1) := '0';
	TRUE_ CONSTANT CHAR(4) := 'true';
	FALSE_ CONSTANT CHAR(5) := 'false';
	-- ###
	PROCEDURE init;

	PROCEDURE assign_ (name_ ASTRING, val ASTRING);

	FUNCTION arref (s ASTRING) RETURN ASTRING;
	FUNCTION deref_ (s ASTRING) RETURN ASTRING;
	FUNCTION aint (s ASTRING) RETURN INT;

	PROCEDURE do_eval (opr1 ASTRING, oper CHAR, opr2 ASTRING);

	PROCEDURE pop (head INT);
	PROCEDURE push (head INT);

	FUNCTION jump (head INT, jmp INT, dest ASTRING, push CHAR) RETURN BOOLEAN;
	PROCEDURE call_ (head INT, jmp INT, dest ASTRING, is_push BOOLEAN);
END;
/

CREATE OR REPLACE PACKAGE BODY algo AS
	PROCEDURE init IS
	BEGIN
		REPLACE INTO TABLE vars VALUES
			('eval', ''),
			('ret', ''),
			('argv-0', ''),
			('argv-1', ''),
			('argv-2', ''),
			('argv-3', ''),
			('argv-4', ''),
			('argv-5', ''),
			('argv-6', ''),
			('argv-7', ''),
			('argv-8', ''),
			('argv-9', '')
		;
	END;



	PROCEDURE assign_ (
		name_ VARCHAR(128),
		val VARCHAR(128)
	) IS
	BEGIN
		INSERT INTO vars (name_, val);
	END;



	FUNCTION arref AS ASTRING (s ASTRING)
	DECLARE 
		p INT;
		subs ASTRING;
	BEGIN
		WHILE TRUE LOOP
			p = INSTR(s, '-', -1);
			IF p THEN
				subs := s.SUBSTR(p);
				s := REPLACE(s, subs, deref_(subs));
			ELSE
				EXIT;
			END IF;
		END LOOP;

		RETURN s;
	END;
	FUNCTION deref_ AS ASTRING (s ASTRING)
		varval ASTRING;
	BEGIN
		s := arref(s);
		SELECT value INTO varval FROM vars WHERE name = s;
		RETURN varval;
	EXCEPTION
		WHEN OTHERS THEN
			RETURN s;
	END;
	FUNCTION aint AS INT (s ASTRING)
		sign_ BOOLEAN := TRUE;
		i INT := 0;
		buf ASTRING := '';
	BEGIN
		WHILE TRUE LOOP
			CASE SUBSTR(s, i, 1)
				WHEN '-' THEN
					sign := NOT(XOR(sign, FALSE));
				WHEN '+' THEN
					sign := NOT(XOR(sign, TRUE));
				ELSE
					EXIT;
			END CASE;
			i := i + 1;
		END LOOP;

		s := REPLACE(s, SUBSTR(s, 0, i));

		FOR index IN 0 .. LENGTH(s) LOOP
			IF SUBSTR(index, 1) IN ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9') THEN
				buf := ret + SUBSTR(index, 1);
			END IF;
		END LOOP;

		RETURN TO_NUMBER(buf) * (IF sign_ THEN 1 ELSE -1 END IF);
	END;



	PROCEDURE do_eval (opr1 ASTRING, oper CHAR, opr2 ASTRING)
	DECLARE
		res ASTRING := '';
	BEGIN
		CASE oper
			WHEN EMPTY_VAL THEN
				res := opr1;
			WHEN '.' THEN
				res := CONCAT(opr1, opr2);
			WHEN '-' THEN
				res := aint(opr1) - aint(opr2);
			ELSE
				NULL;
		END CASE;
		UPDATE vars SET (value, res) WHERE name = 'eval';
	END;



	PROCEDURE pop (head INT)
	DECLARE
		EMPTY_STACK EXCEPTION;
	BEGIN
		IF SELECT COUNT(bp) FROM callstack = 1 THEN
			RAISE EMPTY_STACK;
		END IF
		DELETE FROM callstack WHERE rowid = (SELECT MAX(rowid) FROM callstack);
		SELECT bp INTO HEAD FROM callstack WHERE rowid = (SELECT MAX(rowid) FROM callstack);
		head := head + 1;
	END;
	PROCEDURE push (head INT)
	BEGIN
		UPDATE callstack SET (bp, head) WHERE rowid = (SELECT MAX(rowid) FROM callstack);
		INSERT INTO callstack VALUES (0);
	END;



	FUNCTION jump AS BOOLEAN (head INT, jmp INT, dest ASTRING, push CHAR)
	DECLARE
		ret BOOLEAN = FALSE;
	BEGIN
		CASE jmp
			WHEN 0 THEN
				EXIT;
			WHEN 1 THEN
				call_(head, dest, (push != EMPTY_VAL));
				ret := TRUE;
			WHEN 2 THEN
				IF SELECT value FROM vars WHERE name = 'eval' = TRUE_ THEN
					call_(head, dest, (push != EMPTY_VAL));
					ret := TRUE;
				END IF;
			WHEN 3 THEN
				IF SELECT value FROM vars WHERE name = 'eval' = FALSE_ THEN
					call_(head, dest, (push != EMPTY_VAL));
					ret := TRUE;
				END IF;
		END CASE;
		RETURN ret;
	END;
	PROCEDURE call_ (head INT, jmp INT, dest ASTRING, is_push BOOLEAN)
	BEGIN
		IF dest = 'return' THEN
			pop(head);
			RETURN;
		END IF;

		IF is_push THEN push(head) END IF;

		head := TO_NUMBER(deref_(head));
	END;
END algo;