aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--repl.d77
-rw-r--r--src/definition.d15
-rw-r--r--src/primitives/conditional.d77
-rw-r--r--src/primitives/core.d (renamed from src/primitives/impl.d)70
-rw-r--r--src/primitives/eval.d98
-rw-r--r--src/stack.d11
6 files changed, 193 insertions, 155 deletions
diff --git a/repl.d b/repl.d
index b68b46a..df2905d 100644
--- a/repl.d
+++ b/repl.d
@@ -1,69 +1,60 @@
import std.stdio;
import std.string;
-import std.conv;
import std.variant;
import std.typecons;
-import std.container : SList;
-
import src.stack;
static import definition = src.definition;
static import primitives = src.primitives.eval;
-template process(T)
-if ( is(T == int) || is(T == bool) ) {
- void process(T value) {
- try {
- if ( !primitives.evaluate(value) ) {
- stack.push(value);
- }
- }
- catch (Exception ex) {
- writeln("Error: ", ex.msg);
- }
- }
-}
-
-void process(string word) {
+Stack!Token resolve(Token token) {
try {
- if ( !primitives.evaluate(word) ) {
- if ( word in definition.words ) {
- foreach ( token; definition.words[word] ) {
- process(token);
- }
- } else {
- stack.push(word);
- }
+ if ( primitives.evaluate(token) ) {
+ return primitives.result;
+ } else {
+ return token.visit!(
+ (int value) => Stack!Token(Token(value)),
+ (bool value) => Stack!Token(Token(value)),
+ (string word ) => definition.get(word)
+ );
}
}
catch (Exception ex) {
writeln("Error: ", ex.msg);
+ return Stack!Token();
}
}
-void process(Token token) {
- token.visit!(
- (int value) => process(value),
- (bool value) => process(value),
- (string word ) => process(word)
- );
+void process(string value) {
+ Stack!Token buffer;
+ Token token = toToken(value);
+
+ if ( !definition.handle(token) ) {
+ buffer = resolve(token);
+ }
+
+ while ( !buffer.empty ) {
+ Token current = buffer.pop;
+
+ if ( !definition.handle(current) ) {
+ Stack!Token resolved = resolve(current);
+
+ if ( !resolved.empty ) {
+ if ( resolved.front == current ) {
+ stack.push(current);
+ } else {
+ buffer.insertFront(resolved[]);
+ }
+ }
+ }
+ }
}
void main() {
while ( !stdin.eof ) {
foreach ( token; stdin.readln.split ) {
- if ( token.isNumeric ) {
- auto value = parse!int(token);
-
- if ( !definition.handle(value) ) {
- process(value);
- }
- } else {
- if ( !definition.handle(token) ) {
- process(token);
- }
- }
+ process(token);
}
}
}
diff --git a/src/definition.d b/src/definition.d
index e6a7789..7429f4b 100644
--- a/src/definition.d
+++ b/src/definition.d
@@ -3,11 +3,12 @@ module src.definition;
import std.string;
import std.variant;
import std.typecons;
+
import std.container : DList;
-import src.stack : Token;
+import src.stack;
-alias Words = DList!Token[string];
+alias Words = Stack!Token[string];
Nullable!(DList!Token) definition;
Words words;
@@ -30,7 +31,7 @@ void end() {
}
definition.removeFront;
- words[wordToBeDefined] = definition;
+ words[wordToBeDefined] = Stack!Token(definition[]);
definition.nullify;
}
@@ -67,3 +68,11 @@ bool handle(Token token) {
(string word ) => handle(word)
);
}
+
+Stack!Token get(string word) {
+ if ( word in words ) {
+ return words[word].dup;
+ } else {
+ return Stack!Token(Token(word));
+ }
+}
diff --git a/src/primitives/conditional.d b/src/primitives/conditional.d
new file mode 100644
index 0000000..ee89ea5
--- /dev/null
+++ b/src/primitives/conditional.d
@@ -0,0 +1,77 @@
+module src.primitives.conditional;
+
+import std.variant;
+import std.typecons;
+import std.container : DList;
+
+import src.stack;
+
+Nullable!(DList!Token) buffer;
+bool concluded = true;
+bool drop_mode = false;
+
+void capture(Token token) {
+ if ( !drop_mode ) {
+ buffer.insertBack(token);
+ }
+}
+
+bool drop(Token token) {
+ if ( concluded && buffer.isNull ) {
+ return false;
+ }
+
+ if ( token.type == typeid(string) ) {
+ switch ( *token.peek!string ) {
+ case "if" : eval_if; break;
+ case "then" : eval_then; break;
+ case "else" : eval_else; break;
+ default : capture(token); break;
+ }
+ } else {
+ capture(token);
+ }
+
+ return true;
+}
+
+void eval_if() {
+ if ( concluded ) {
+ buffer = DList!Token();
+ drop_mode = !stack.pop.get!bool;
+ concluded = false;
+ } else {
+ throw new Exception("conditionals may not be nested directly");
+ }
+}
+
+void eval_then() {
+ if ( concluded ) {
+ throw new Exception("`then` without preceding `if`");
+ } else {
+ drop_mode = !drop_mode;
+ }
+}
+
+void eval_else() {
+ if ( concluded ) {
+ throw new Exception("`else` without preceding `if`");
+ } else {
+ drop_mode = false;
+ concluded = true;
+ }
+}
+
+bool dischargeable() {
+ return concluded && !buffer.isNull;
+}
+
+Stack!Token discharge() {
+ if ( concluded ) {
+ Stack!Token result = buffer[];
+ buffer.nullify;
+ return result;
+ } else {
+ throw new Exception("unconcluded conditional may not be discharged");
+ }
+}
diff --git a/src/primitives/impl.d b/src/primitives/core.d
index 9fddee5..5b3d43d 100644
--- a/src/primitives/impl.d
+++ b/src/primitives/core.d
@@ -1,4 +1,4 @@
-module src.primitives.impl;
+module src.primitives.core;
import std.stdio;
@@ -6,65 +6,40 @@ import src.stack;
import src.definition;
Token[string] variables;
-bool drop_mode;
-bool definition_start() {
+void definition_start() {
src.definition.start;
- return true;
}
-bool binary_op_variable_bind() {
- string name = stack.pop.get!string;
- Token value = stack.pop;
-
+void binary_op_variable_bind() {
+ string name = stack.pop.get!string;
+ Token value = stack.pop;
variables[name] = value;
- return true;
}
-bool unary_op_variable_resolve() {
+void unary_op_variable_resolve() {
string name = stack.pop.get!string;
if ( name in variables ) {
stack.push(variables[name]);
}
-
- return true;
-}
-
-bool unary_conditional_if() {
- drop_mode = !stack.pop.get!bool;
- return true;
-}
-
-bool n_ary_conditional_then() {
- drop_mode = !drop_mode;
- return true;
}
-bool n_ary_conditional_else() {
- drop_mode = false;
- return true;
-}
-
-bool binary_op_add() {
+void binary_op_add() {
int b = stack.pop.get!int;
int a = stack.pop.get!int;
stack.push(a + b);
-
- return true;
}
-bool binary_op_multiply() {
+void binary_op_multiply() {
int b = stack.pop.get!int;
int a = stack.pop.get!int;
stack.push(a * b);
-
- return true;
}
-bool binary_op_divide() {
+void binary_op_divide() {
int b = stack.pop.get!int;
int a = stack.pop.get!int;
@@ -73,11 +48,9 @@ bool binary_op_divide() {
} else {
stack.push(a / b);
}
-
- return true;
}
-bool binary_op_modulo() {
+void binary_op_modulo() {
int b = stack.pop.get!int;
int a = stack.pop.get!int;
@@ -86,52 +59,43 @@ bool binary_op_modulo() {
} else {
stack.push(a % b);
}
-
- return true;
}
-bool unary_op_io_print() {
+void unary_op_io_print() {
writeln(stack.top);
- return true;
}
-bool unary_op_stack_pop() {
+void unary_op_stack_pop() {
stack.pop;
- return true;
}
-bool unary_op_stack_dup() {
+void unary_op_stack_dup() {
stack.push(stack.top);
- return true;
}
-bool binary_op_stack_swp() {
+void binary_op_stack_swp() {
auto b = stack.pop;
auto a = stack.pop;
stack.push(b);
stack.push(a);
- return true;
}
-bool binary_cond_lt() {
+void binary_cond_lt() {
int b = stack.pop.get!int;
int a = stack.pop.get!int;
stack.push(a < b);
- return true;
}
-bool binary_cond_eq() {
+void binary_cond_eq() {
auto b = stack.pop;
auto a = stack.pop;
stack.push(a == b);
- return true;
}
-bool integral_value_bool(bool value) {
+void integral_value_bool(bool value) {
stack.push(Token(value));
- return true;
}
diff --git a/src/primitives/eval.d b/src/primitives/eval.d
index 8b080e2..08d8fb9 100644
--- a/src/primitives/eval.d
+++ b/src/primitives/eval.d
@@ -1,65 +1,53 @@
module src.primitives.eval;
-import src.primitives.impl;
+import std.variant;
-bool evaluate(int value) {
- return drop_mode;
-}
+import src.stack;
+import src.primitives.core;
+import conditional = src.primitives.conditional;
+
+bool evaluate_primitive(string word) {
+ switch ( word ) {
+ case "§" : definition_start; break;
+ case "$" : binary_op_variable_bind; break;
+ case "@" : unary_op_variable_resolve; break;
+ case "if" : conditional.eval_if; break;
+ case "then" : conditional.eval_then; break;
+ case "else" : conditional.eval_else; break;
+ case "+" : binary_op_add; break;
+ case "*" : binary_op_multiply; break;
+ case "/" : binary_op_divide; break;
+ case "%" : binary_op_modulo; break;
+ case "." : unary_op_io_print; break;
+ case "pop" : unary_op_stack_pop; break;
+ case "dup" : unary_op_stack_dup; break;
+ case "swp" : binary_op_stack_swp; break;
+ case "true" : integral_value_bool(true); break;
+ case "false" : integral_value_bool(false); break;
+ case "<" : binary_cond_lt; break;
+ case "=" : binary_cond_eq; break;
+ default : return false;
+ }
-bool evaluate(bool value) {
- return drop_mode;
+ return true;
}
-bool evaluate(string word) {
- if ( drop_mode ) {
- switch ( word ) {
- case "then":
- return n_ary_conditional_then;
- case "else":
- return n_ary_conditional_else;
- default:
- return true;
- }
+bool evaluate(Token token) {
+ if ( conditional.drop(token) ) {
+ return true;
+ } else {
+ return token.visit!(
+ (int value) => false,
+ (bool value) => false,
+ (string word ) => evaluate_primitive(word)
+ );
}
+}
- switch ( word ) {
- case "§":
- return definition_start;
- case "$":
- return binary_op_variable_bind;
- case "@":
- return unary_op_variable_resolve;
- case "if":
- return unary_conditional_if;
- case "then":
- return n_ary_conditional_then;
- case "else":
- return n_ary_conditional_else;
- case "+":
- return binary_op_add;
- case "*":
- return binary_op_multiply;
- case "/":
- return binary_op_divide;
- case "%":
- return binary_op_modulo;
- case ".":
- return unary_op_io_print;
- case "pop":
- return unary_op_stack_pop;
- case "dup":
- return unary_op_stack_dup;
- case "swp":
- return binary_op_stack_swp;
- case "true":
- return integral_value_bool(true);
- case "false":
- return integral_value_bool(false);
- case "<":
- return binary_cond_lt;
- case "=":
- return binary_cond_eq;
- default:
- return false;
+Stack!Token result() {
+ if ( conditional.dischargeable ) {
+ return conditional.discharge;
+ } else {
+ return Stack!Token();
}
}
diff --git a/src/stack.d b/src/stack.d
index 2fb602b..678f3e8 100644
--- a/src/stack.d
+++ b/src/stack.d
@@ -1,7 +1,8 @@
module src.stack;
-import std.variant;
+import std.conv;
import std.string;
+import std.variant;
import std.container : SList;
static import src.definition;
@@ -11,6 +12,14 @@ alias Stack = SList;
Stack!Token stack;
+Token toToken(string value) {
+ if ( value.isNumeric ) {
+ return Token(parse!int(value));
+ } else {
+ return Token(value);
+ }
+}
+
Token top(ref Stack!Token stack) {
if ( stack.empty ) {
throw new Exception("stack is empty");