| summaryrefslogtreecommitdiff |
diff options
20 files changed, 1033 insertions, 54 deletions
diff --git a/data/examples/monster_battle/battle.fate b/data/examples/monster_battle/battle.fate index cfdce39..9674b95 100644 --- a/data/examples/monster_battle/battle.fate +++ b/data/examples/monster_battle/battle.fate @@ -1,5 +1,5 @@ (fate_version 1) (define_sequence start_battle - nothing yet + (end) ) diff --git a/data/tests/conditionals.fate b/data/tests/conditionals.fate new file mode 100644 index 0000000..02730c6 --- /dev/null +++ b/data/tests/conditionals.fate @@ -0,0 +1,222 @@ +(fate_version 1) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; COMPUTATIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; COMPUTATION IF-ELSE +(assert (ifelse (true) (true) (false)) FAILED: computation if-else A) +(assert (ifelse (false) (false) (true)) FAILED: computation if-else B) +(assert (ifelse (false) (false) (ifelse (true) (true) (false))) FAILED: computation if-else C) + +;; COMPUTATION COND +(assert + (cond + ((true) (true)) + ) + FAILED: computation cond A +) +(assert + (cond + ((false) (false)) + ((true) (true)) + ) + FAILED: computation cond D +) +(assert + (cond + ((false) (false)) + ((true) (true)) + ((true) (false)) + ) + FAILED: computation cond E +) +(assert + (cond + ((false) (false)) + ((true) + (cond + ((false) (false)) + ((true) (true)) + ((true) (false)) + ) + ) + ((true) (false)) + ) + FAILED: computation cond D +) + +;; COMPUTATION SWITCH +;; TODO: re-enable. Currently not implemented in Wyrd compiler +;;(assert +;; (switch 3 +;; (0 (false)) +;; (1 (false)) +;; (3 (true)) +;; (2 (false)) +;; (false) +;; ) +;; FAILED: computation switch A +;;) +;;(assert +;; (switch 3 +;; (0 (false)) +;; (1 (false)) +;; (2 (false)) +;; (true) +;; ) +;; FAILED: computation switch B +;;) +;;(assert +;; (switch 3 +;; (0 (false)) +;; (1 (false)) +;; (2 (false)) +;; (switch 2 +;; (0 (false)) +;; (1 (false)) +;; (2 (true)) +;; (false) +;; ) +;; ) +;; FAILED: computation switch C +;;) +;;(assert +;; (switch 3 +;; (0 (false)) +;; (1 (false)) +;; (2 +;; (switch 1 +;; (0 (false)) +;; (2 (false)) +;; (1 (true)) +;; (false) +;; ) +;; ) +;; (false) +;; ) +;; FAILED: computation switch D +;;) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; INSTRUCTIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(declare_variable boolean test_var) +(set test_var (true)) + +(assert (var test_var) FAILED: setting test_var) + +;; INSTRUCTION IF +(if (false) + (assert (false) FAILED: instruction if A) +) + +(set test_var (false)) +(if (true) + (set test_var (true)) +) +(assert (var test_var) FAILED: instruction if B) + +(if (false) + (if (false) + (assert (false) FAILED: instruction if C) + ) +) +(if (true) + (if (false) + (assert (false) FAILED: instruction if D) + ) +) +(if (false) + (if (true) + (assert (false) FAILED: instruction if E) + ) +) + +(set test_var (false)) +(if (true) + (if (true) + (set test_var (true)) + ) +) +(assert (var test_var) FAILED: instruction if F) + +;; INSTRUCTION IF-ELSE +(set test_var (false)) +(ifelse (false) + (assert (false) FAILED: instruction ifelse A) + (set test_var (true)) +) +(assert (var test_var) FAILED: instruction ifelse B) + +(set test_var (false)) +(ifelse (true) + (set test_var (true)) + (assert (false) FAILED: instruction ifelse C) +) +(assert (var test_var) FAILED: instruction ifelse D) + +(set test_var (false)) +(ifelse (true) + (ifelse (false) + (assert (false) FAILED: instruction ifelse E) + (set test_var (true)) + ) + (assert (false) FAILED: instruction ifelse F) +) +(assert (var test_var) FAILED: instruction ifelse G) + +;; INSTRUCTION COND +(set test_var (false)) +(cond + ((false) (assert (false) FAILED: instruction cond A)) + ((true) (set test_var (true))) +) +(assert (var test_var) FAILED: instruction cond B) + +(set test_var (false)) +(cond + ((true) (set test_var (true))) + ((false) (assert (false) FAILED: instruction cond B)) +) +(assert (var test_var) FAILED: instruction cond C) + +(set test_var (false)) +(cond + ((true) (set test_var (true))) + ((true) (assert (false) FAILED: instruction cond D)) + ((false) (assert (false) FAILED: instruction cond E)) +) +(assert (var test_var) FAILED: instruction cond F) + +;; INSTRUCTION SWITCH +(set test_var (false)) +(switch 3 + (0 (assert (false) FAILED: instruction switch B)) + (1 (assert (false) FAILED: instruction switch C)) + (set test_var (true)) +) +(assert (var test_var) FAILED: instruction switch D) + +(set test_var (false)) +(switch 3 + (0 (assert (false) FAILED: instruction switch E)) + (1 (assert (false) FAILED: instruction switch F)) + (3 (set test_var (true))) + (2 (assert (false) FAILED: instruction switch G)) + (assert (false) FAILED: instruction switch H) +) +(assert (var test_var) FAILED: instruction switch I) + +(set test_var (false)) +(switch 3 + (0 (assert (false) FAILED: instruction switch J)) + (1 (assert (false) FAILED: instruction switch K)) + (3 (set test_var (true))) + (3 (assert (false) FAILED: instruction switch L)) + (2 (assert (false) FAILED: instruction switch M)) + (assert (false) FAILED: instruction switch N) +) +(assert (var test_var) FAILED: instruction switch O) + +(end) diff --git a/data/tests/include/data_types.fate b/data/tests/include/data_types.fate new file mode 100644 index 0000000..3205b69 --- /dev/null +++ b/data/tests/include/data_types.fate @@ -0,0 +1,70 @@ +(fate_version 1) + +(typedef boolean sub_boolean) +(typedef boolean alt_boolean) +(typedef sub_boolean sub_sub_boolean) +(typedef sub_boolean alt_sub_boolean) + +(typedef int sub_int) +(typedef int alt_int) +(typedef sub_int sub_sub_int) +(typedef sub_int alt_sub_int) + +(typedef float sub_float) +(typedef float alt_float) +(typedef sub_float sub_sub_float) +(typedef sub_float alt_sub_float) + +(typedef string sub_string) +(typedef string alt_string) +(typedef sub_string sub_sub_string) +(typedef sub_string alt_sub_string) + +(define_list_type boolean list_boolean) +(define_list_type sub_boolean list_sub_boolean) +(define_set_type boolean set_boolean) +(define_set_type sub_boolean set_sub_boolean) +(define_ref_type boolean ref_boolean) +(define_ref_type sub_boolean ref_sub_boolean) + +(define_list_type int list_int) +(define_list_type sub_int list_sub_int) +(define_set_type int set_int) +(define_set_type sub_int set_sub_int) +(define_ref_type int ref_int) +(define_ref_type sub_int ref_sub_int) + +(define_list_type float list_float) +(define_list_type sub_float list_sub_float) +(define_set_type float set_float) +(define_set_type sub_float set_sub_float) +(define_ref_type float ref_float) +(define_ref_type sub_float ref_sub_float) + +(define_list_type string list_int) +(define_list_type sub_string list_sub_int) +(define_set_type string set_int) +(define_set_type sub_string set_sub_int) +(define_ref_type string ref_int) +(define_ref_type sub_string ref_sub_int) + +(define_dict_type simple_dict + (boolean boolean) + (int int) + (float float) + (string string) +) + +(define_ref_type simple_dict simple_dict_ptr) +(define_list_type simple_dict_ptr simple_dict_ptr_list) +(define_set_type simple_dict_ptr simple_dict_ptr_set) + +(define_dict_type two_dict + (simple_dict dict_a) + (simple_dict dict_b) + (simple_dict_ptr dict_ptr) +) + +(define_ref_type two_dict two_dict_ptr) +(define_list_type two_dict_ptr two_dict_ptr_list) +(define_set_type two_dict_ptr two_dict_ptr_set) diff --git a/data/tests/operators.fate b/data/tests/operators.fate new file mode 100644 index 0000000..6598297 --- /dev/null +++ b/data/tests/operators.fate @@ -0,0 +1,154 @@ +(fate_version 1) + +;; EQUALITY +(assert (= 1 1) FAILED: int equality) +(assert (= 1.0 1.0) FAILED: float equality) +(assert (= test test) FAILED: string equality) +(assert (= (true) (true)) FAILED: boolean equality) + +(assert (= (= 1 2) (false)) FAILED: int inequality) +(assert (= (= 1.0 2.0) (false)) FAILED: float inequality) +(assert (= (= one two) (false)) FAILED: string inequality) +(assert (= (= (true) (false)) (false)) FAILED: boolean inequality) + +(assert (= 1 1 1 1 1) FAILED: int n>2 equality) +(assert (= 1.0 1.0 1.0 1.0 1.0) FAILED: float n>2 equality) +(assert (= test test test test test) FAILED: string n>2 equality) +(assert (= (true) (true) (true) (true)) FAILED: boolean n>2 equality) + + +;; ADDITION +(assert (= (+ 1 1) 2) FAILED: int addition) +(assert (= (+ 1 1 1 1) 4) FAILED: int n>2 addition) +(assert (= (+ 1.5 1.5) 3.0) FAILED: float addition) +(assert (= (+ 1.5 1.0 1.5 1.0) 5.0) FAILED: float n>2 addition) + +;; SUBTRACTION +(assert (= (- 1 1) 0) FAILED: int subtraction) +(assert (= (- 1 1 1 1) -2) FAILED: int n>2 subtraction) +(assert (= (- 1.5 1.5) 0.0) FAILED: float subtraction) +(assert (= (- 1.5 1.0 1.5 1.0) -2.0) FAILED: float n>2 subtraction) + +;; MULTIPLICATION +(assert (= (* 1 3) 3) FAILED: int multiplication) +(assert (= (* 1 1 3 2) 6) FAILED: int n>2 multiplication) +(assert (= (* 1.5 2.0) 3.0) FAILED: float multiplication) +(assert (= (* 1.5 1.0 3.0 1.0) 4.5) FAILED: float n>2 multiplication) + +;; DIVISION +(assert (= (/ 3 3) 1) FAILED: int division) +(assert (= (/ 4 3) 1) FAILED: int integer division) +(assert (= (/ 3.0 3.0) 1.0) FAILED: float division A) +(assert (= (/ 3.0 2.0) 1.5) FAILED: float division B) + +;; MODULO +(assert (= (% 3 3) 0) FAILED: modulo A) +(assert (= (% 2 3) 2) FAILED: modulo B) +(assert (= (% 4 3) 1) FAILED: modulo C) +(assert (= (% 9 3) 0) FAILED: modulo D) +(assert (= (% 10 3) 1) FAILED: modulo E) + +;; MIN +(assert (= (min 1 3) 1) FAILED: int min) +(assert (= (min 1 0 -3 9) -3) FAILED: int n>2 min) +(assert (= (min 1.5 2.0) 1.5) FAILED: float min) +(assert (= (min 1.5 1.0 3.0 -1.0) -1.0) FAILED: float n>2 min) + +;; MAX +(assert (= (max 3 1) 3) FAILED: int max) +(assert (= (max 1 0 -3 9) 9) FAILED: int n>2 max) +(assert (= (max 1.5 2.0) 2.0) FAILED: float max) +(assert (= (max 1.5 1.0 3.0 -1.0) 3.0) FAILED: float n>2 max) + +;; CLAMP +(assert (= (clamp 1 3 2) 2) FAILED: int clamp A) +(assert (= (clamp 1 3 4) 3) FAILED: int clamp B) +(assert (= (clamp 1 3 -1) 1) FAILED: int clamp C) +(assert (= (clamp 1 3 1) 1) FAILED: int clamp D) +(assert (= (clamp 1 3 3) 3) FAILED: int clamp E) +(assert (= (clamp 1.5 3.0 1.7) 1.7) FAILED: float clamp A) +(assert (= (clamp 1.5 3.0 4.7) 3.0) FAILED: float clamp B) +(assert (= (clamp 1.5 3.0 -1.7) 1.5) FAILED: float clamp C) +(assert (= (clamp 1.5 3.0 1.5) 1.5) FAILED: float clamp D) +(assert (= (clamp 1.5 3.0 3.0) 3.0) FAILED: float clamp E) + +;; ABS +(assert (= (abs 1) 1) FAILED: int abs A) +(assert (= (abs -1) 1) FAILED: int abs B) +(assert (= (abs -99) 99) FAILED: int abs C) +(assert (= (abs 0) 0) FAILED: int abs D) +(assert (= (abs 1.5) 1.5) FAILED: float abs A) +(assert (= (abs -1.5) 1.5) FAILED: float abs B) +(assert (= (abs -99.5) 99.5) FAILED: float abs C) +(assert (= (abs 0.5) 0.5) FAILED: float abs D) + +;; AND +(assert (= (and (true) (true)) (true)) FAILED: and A) +(assert (= (and (true) (false)) (false)) FAILED: and B) +(assert (= (and (false) (true)) (false)) FAILED: and C) +(assert (= (and (false) (false)) (false)) FAILED: and D) +(assert (= (and (true) (true) (true) (true) (true)) (true)) FAILED: and E) +(assert (= (and (false) (false) (false) (false) (false)) (false)) FAILED: and F) +(assert (= (and (true) (true) (false) (true) (true)) (false)) FAILED: and G) + +;; OR +(assert (= (or (true) (true)) (true)) FAILED: or A) +(assert (= (or (true) (false)) (true)) FAILED: or B) +(assert (= (or (false) (true)) (true)) FAILED: or C) +(assert (= (or (false) (false)) (false)) FAILED: or D) +(assert (= (or (true) (true) (true) (true) (true)) (true)) FAILED: or E) +(assert (= (and (false) (false) (false) (false) (false)) (false)) FAILED: or F) +(assert (= (or (true) (true) (false) (true) (true)) (true)) FAILED: or G) + +;; NOT +(assert (= (not (true)) (false)) FAILED: not A) +(assert (= (not (false)) (true)) FAILED: not B) + +;; IMPLIES +(assert (= (implies (true) (true)) (true)) FAILED: implies A) +(assert (= (implies (true) (false)) (false)) FAILED: implies B) +(assert (= (implies (false) (true)) (true)) FAILED: implies C) +(assert (= (implies (false) (false)) (true)) FAILED: implies D) + +;; ONE IN +(assert (= (one_in (true) (true)) (false)) FAILED: one_in A) +(assert (= (one_in (true) (false)) (true)) FAILED: one_in B) +(assert (= (one_in (false) (true)) (true)) FAILED: one_in C) +(assert (= (one_in (false) (false)) (false)) FAILED: one_in D) +(assert (= (one_in (false) (false) (false) (false)) (false)) FAILED: one_in E) +(assert (= (one_in (false) (true) (false) (false)) (true)) FAILED: one_in F) +(assert (= (one_in (false) (true) (false) (true)) (false)) FAILED: one_in F) + +;; LESS/LOWER THAN +(assert (= (< 1 3) (true)) FAILED: int LOWER/LESS THAN) +(assert (= (< 1 0) (false)) FAILED: int LOWER/LESS THAN) +(assert (= (< 1 1) (false)) FAILED: int LOWER/LESS THAN) +(assert (= (< 1.5 2.0) (true)) FAILED: float LOWER/LESS THAN) +(assert (= (< 1.5 1.0) (false)) FAILED: float LOWER/LESS THAN) +(assert (= (< 1.5 1.5) (false)) FAILED: float LOWER/LESS THAN) + +;; LESS/LOWER EQUAL THAN +(assert (= (=< 1 3) (true)) FAILED: int LOWER/LESS EQUAL THAN) +(assert (= (=< 1 0) (false)) FAILED: int LOWER/LESS EQUAL THAN) +(assert (= (=< 1 1) (true)) FAILED: int LOWER/LESS EQUAL THAN) +(assert (= (=< 1.5 2.0) (true)) FAILED: float LOWER/LESS EQUAL THAN) +(assert (= (=< 1.5 1.0) (false)) FAILED: float LOWER/LESS EQUAL THAN) +(assert (= (=< 1.5 1.5) (true)) FAILED: float LOWER/LESS EQUAL THAN) + +;; GREATER THAN +(assert (= (> 1 3) (false)) FAILED: int GREATER THAN) +(assert (= (> 1 0) (true)) FAILED: int GREATER THAN) +(assert (= (> 1 1) (false)) FAILED: int GREATER THAN) +(assert (= (> 1.5 2.0) (false)) FAILED: float GREATER THAN) +(assert (= (> 1.5 1.0) (true)) FAILED: float GREATER THAN) +(assert (= (> 1.5 1.5) (false)) FAILED: float GREATER THAN) + +;; GREATER EQUAL THAN +(assert (= (>= 1 3) (false)) FAILED: int GREATER EQUAL THAN) +(assert (= (>= 1 0) (true)) FAILED: int GREATER EQUAL THAN) +(assert (= (>= 1 1) (true)) FAILED: int GREATER EQUAL THAN) +(assert (= (>= 1.5 2.0) (false)) FAILED: float GREATER EQUAL THAN) +(assert (= (>= 1.5 1.0) (true)) FAILED: float GREATER EQUAL THAN) +(assert (= (>= 1.5 1.5) (true)) FAILED: float GREATER EQUAL THAN) + +(end) diff --git a/src/core/src/tonkadur/Main.java b/src/core/src/tonkadur/Main.java index cf8a8ae..ea02801 100644 --- a/src/core/src/tonkadur/Main.java +++ b/src/core/src/tonkadur/Main.java @@ -46,7 +46,6 @@ public class Main ); System.out.println("Parsing completed."); - System.out.println(fate_world.toString()); } catch (final Exception e) { @@ -88,15 +87,6 @@ public class Main tp.post_wyrd_compile(wyrd_world); } - for - ( - final tonkadur.wyrd.v1.lang.meta.Instruction line: - wyrd_world.get_code() - ) - { - System.out.println(line.toString()); - } - for (final TonkadurPlugin tp: plugins) { tp.finalize(); diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/Assert.java b/src/core/src/tonkadur/fate/v1/lang/instruction/Assert.java index 2770fa1..7869ab4 100644 --- a/src/core/src/tonkadur/fate/v1/lang/instruction/Assert.java +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/Assert.java @@ -12,6 +12,7 @@ import tonkadur.fate.v1.lang.type.Type; import tonkadur.fate.v1.lang.meta.InstructionVisitor; import tonkadur.fate.v1.lang.meta.Instruction; +import tonkadur.fate.v1.lang.meta.RichTextNode; import tonkadur.fate.v1.lang.meta.Computation; public class Assert extends Instruction @@ -20,6 +21,7 @@ public class Assert extends Instruction /**** MEMBERS **************************************************************/ /***************************************************************************/ protected final Computation condition; + protected final RichTextNode message; /***************************************************************************/ /**** PROTECTED ************************************************************/ @@ -28,12 +30,14 @@ public class Assert extends Instruction protected Assert ( final Origin origin, - final Computation condition + final Computation condition, + final RichTextNode message ) { super(origin); this.condition = condition; + this.message = message; } /***************************************************************************/ @@ -43,7 +47,8 @@ public class Assert extends Instruction public static Assert build ( final Origin origin, - final Computation condition + final Computation condition, + final RichTextNode message ) throws InvalidTypeException { @@ -60,7 +65,7 @@ public class Assert extends Instruction ); } - return new Assert(origin, condition); + return new Assert(origin, condition, message); } /**** Accessors ************************************************************/ @@ -76,6 +81,11 @@ public class Assert extends Instruction return condition; } + public RichTextNode get_message () + { + return message; + } + /**** Misc. ****************************************************************/ @Override public String toString () diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/ReverseList.java b/src/core/src/tonkadur/fate/v1/lang/instruction/ReverseList.java index e69de29..59a68e6 100644 --- a/src/core/src/tonkadur/fate/v1/lang/instruction/ReverseList.java +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/ReverseList.java @@ -0,0 +1,101 @@ +package tonkadur.fate.v1.lang.instruction; + +import java.util.Collections; + +import tonkadur.error.ErrorManager; + +import tonkadur.parser.Origin; + +import tonkadur.fate.v1.error.InvalidTypeException; + +import tonkadur.fate.v1.lang.type.CollectionType; +import tonkadur.fate.v1.lang.type.Type; + +import tonkadur.fate.v1.lang.meta.InstructionVisitor; +import tonkadur.fate.v1.lang.meta.Instruction; +import tonkadur.fate.v1.lang.meta.Computation; + +public class ReverseList extends Instruction +{ + /***************************************************************************/ + /**** MEMBERS **************************************************************/ + /***************************************************************************/ + protected final Computation collection; + + /***************************************************************************/ + /**** PROTECTED ************************************************************/ + /***************************************************************************/ + /**** Constructors *********************************************************/ + protected ReverseList + ( + final Origin origin, + final Computation collection + ) + { + super(origin); + + this.collection = collection; + } + + /***************************************************************************/ + /**** PUBLIC ***************************************************************/ + /***************************************************************************/ + /**** Constructors *********************************************************/ + public static ReverseList build + ( + final Origin origin, + final Computation collection + ) + throws InvalidTypeException + { + final Type t; + + t = collection.get_type(); + + if + ( + !(t instanceof CollectionType) + || ((CollectionType) t).is_set() + ) + { + ErrorManager.handle + ( + new InvalidTypeException + ( + collection.get_origin(), + collection.get_type(), + Collections.singleton(Type.LIST) + ) + ); + } + + return new ReverseList(origin, collection); + } + + /**** Accessors ************************************************************/ + @Override + public void get_visited_by (final InstructionVisitor iv) + throws Throwable + { + iv.visit_reverse_list(this); + } + + public Computation get_collection () + { + return collection; + } + + /**** Misc. ****************************************************************/ + @Override + public String toString () + { + final StringBuilder sb = new StringBuilder(); + + sb.append("(ReverseList "); + sb.append(collection.toString()); + + sb.append(")"); + + return sb.toString(); + } +} diff --git a/src/core/src/tonkadur/fate/v1/lang/meta/InstructionVisitor.java b/src/core/src/tonkadur/fate/v1/lang/meta/InstructionVisitor.java index 41167bb..3f4f973 100644 --- a/src/core/src/tonkadur/fate/v1/lang/meta/InstructionVisitor.java +++ b/src/core/src/tonkadur/fate/v1/lang/meta/InstructionVisitor.java @@ -38,6 +38,9 @@ public interface InstructionVisitor public void visit_clear (final Clear c) throws Throwable; + public void visit_reverse_list (final ReverseList n) + throws Throwable; + public void visit_cond_instruction (final CondInstruction ci) throws Throwable; diff --git a/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4 b/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4 index ca10603..2759c92 100644 --- a/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4 +++ b/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4 @@ -14,6 +14,7 @@ L_PAREN: '('; R_PAREN: ')'; +ABS_KW: L_PAREN 'abs'('olute'?) SEP+; ACCESS_KW: L_PAREN 'access' SEP+; ADD_KW: L_PAREN 'add' SEP+; AND_KW: L_PAREN ('and'|'/\\') SEP+; @@ -63,6 +64,9 @@ IS_MEMBER_KW: L_PAREN ('is'US'member'|'contains'|'has') SEP+; LOWER_EQUAL_THAN_KW: L_PAREN ('lower'US'equal'US'than'|'=<'|'<='|'le') SEP+; LOWER_THAN_KW: L_PAREN ('lower'US'than'|'<'|'lt') SEP+; MINUS_KW: L_PAREN ('minus'|'-') SEP+; +MIN_KW: L_PAREN ('min'('imum'?)) SEP+; +MAX_KW: L_PAREN ('max'('imum'?)) SEP+; +CLAMP_KW: L_PAREN ('clamp') SEP+; MODULO_KW: L_PAREN ('modulo'|'%'|'mod') SEP+; NEWLINE_KW: L_PAREN 'newline)'; NEW_KW: L_PAREN ('new'|'reserve'|'create') SEP+; diff --git a/src/core/src/tonkadur/fate/v1/parser/FateParser.g4 b/src/core/src/tonkadur/fate/v1/parser/FateParser.g4 index c8e42a6..ecf0c0d 100644 --- a/src/core/src/tonkadur/fate/v1/parser/FateParser.g4 +++ b/src/core/src/tonkadur/fate/v1/parser/FateParser.g4 @@ -847,6 +847,7 @@ returns [Instruction result] elem_type = Type.ANY; } + /* TODO: error if there is already a parameter with that name */ PARAMETERS.add ( CONTEXT.get_origin_at @@ -967,7 +968,7 @@ returns [Instruction result] $result = new SequenceCall(origin, sequence_name); } - | ASSERT_KW value WS* R_PAREN + | ASSERT_KW value WS+ paragraph WS* R_PAREN { $result = Assert.build @@ -977,7 +978,8 @@ returns [Instruction result] ($ASSERT_KW.getLine()), ($ASSERT_KW.getCharPositionInLine()) ), - ($value.result) + ($value.result), + ($paragraph.result) ); } @@ -1910,6 +1912,66 @@ returns [Computation result]: ); } + | MIN_KW value_list WS* R_PAREN + { + $result = + Operation.build + ( + CONTEXT.get_origin_at + ( + ($MIN_KW.getLine()), + ($MIN_KW.getCharPositionInLine()) + ), + Operator.MIN, + ($value_list.result) + ); + } + + | MAX_KW value_list WS* R_PAREN + { + $result = + Operation.build + ( + CONTEXT.get_origin_at + ( + ($MAX_KW.getLine()), + ($MAX_KW.getCharPositionInLine()) + ), + Operator.MAX, + ($value_list.result) + ); + } + + | CLAMP_KW value_list WS* R_PAREN + { + $result = + Operation.build + ( + CONTEXT.get_origin_at + ( + ($CLAMP_KW.getLine()), + ($CLAMP_KW.getCharPositionInLine()) + ), + Operator.CLAMP, + ($value_list.result) + ); + } + + | ABS_KW value_list WS* R_PAREN + { + $result = + Operation.build + ( + CONTEXT.get_origin_at + ( + ($ABS_KW.getLine()), + ($ABS_KW.getCharPositionInLine()) + ), + Operator.ABS, + ($value_list.result) + ); + } + | MODULO_KW value_list WS* R_PAREN { $result = diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/Compiler.java b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/Compiler.java index 4a315e1..037a705 100644 --- a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/Compiler.java +++ b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/Compiler.java @@ -3,6 +3,7 @@ package tonkadur.wyrd.v1.compiler.fate.v1; import tonkadur.wyrd.v1.compiler.util.AnonymousVariableManager; import tonkadur.wyrd.v1.compiler.util.InstructionManager; +import tonkadur.wyrd.v1.lang.Variable; import tonkadur.wyrd.v1.lang.World; public class Compiler @@ -32,6 +33,8 @@ public class Compiler compiler.compile_sequences(fate_world); + compiler.add_anonymous_variables(); + return compiler.wyrd_world; } @@ -116,6 +119,15 @@ public class Compiler ); } + protected void add_anonymous_variables () + throws Throwable + { + for (final Variable variable: anonymous_variables.get_all_variables()) + { + wyrd_world.add_variable(variable); + } + } + public World world () { return wyrd_world; diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/ComputationCompiler.java b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/ComputationCompiler.java index f3e5ae1..c9740f8 100644 --- a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/ComputationCompiler.java +++ b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/ComputationCompiler.java @@ -858,7 +858,7 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor { final Computation zero, minus_one; - if (operands.get(2).get_type().equals(Type.INT)) + if (operands.get(0).get_type().equals(Type.INT)) { zero = Constant.ZERO; minus_one = new Constant(Type.INT, "-1"); diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/InstructionCompiler.java b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/InstructionCompiler.java index b4c0e38..d05a280 100644 --- a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/InstructionCompiler.java +++ b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/InstructionCompiler.java @@ -14,6 +14,7 @@ import tonkadur.wyrd.v1.lang.meta.Computation; import tonkadur.wyrd.v1.lang.meta.Instruction; import tonkadur.wyrd.v1.lang.type.Type; +import tonkadur.wyrd.v1.lang.type.MapType; import tonkadur.wyrd.v1.lang.computation.Cast; import tonkadur.wyrd.v1.lang.computation.Constant; @@ -44,6 +45,7 @@ import tonkadur.wyrd.v1.compiler.util.While; import tonkadur.wyrd.v1.compiler.util.Clear; import tonkadur.wyrd.v1.compiler.util.IterativeSearch; import tonkadur.wyrd.v1.compiler.util.RemoveAllOf; +import tonkadur.wyrd.v1.compiler.util.ReverseList; import tonkadur.wyrd.v1.compiler.util.RemoveAt; public class InstructionCompiler @@ -275,20 +277,31 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor * * Wyrd: (assert Computation) */ - final ComputationCompiler cc; + final ComputationCompiler cond_cc, msg_cc; - cc = new ComputationCompiler(compiler); + cond_cc = new ComputationCompiler(compiler); + msg_cc = new ComputationCompiler(compiler); - a.get_condition().get_visited_by(cc); + a.get_condition().get_visited_by(cond_cc); + a.get_message().get_visited_by(msg_cc); - if (cc.has_init()) + if (cond_cc.has_init()) { - result.add(cc.get_init()); + result.add(cond_cc.get_init()); } - result.add(new Assert(cc.get_computation())); + if (msg_cc.has_init()) + { + result.add(msg_cc.get_init()); + } - cc.release_variables(); + result.add + ( + new Assert(cond_cc.get_computation(), msg_cc.get_computation()) + ); + + cond_cc.release_variables(); + msg_cc.release_variables(); } @Override @@ -328,6 +341,45 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor reference_compiler.release_variables(); } + public void visit_reverse_list + ( + final tonkadur.fate.v1.lang.instruction.ReverseList n + ) + throws Throwable + { + /* + * Fate: (reverse_list collection) + * + * Wyrd: <reverse_list collection> + */ + final ComputationCompiler reference_compiler; + final Ref collection_ref; + + reference_compiler = new ComputationCompiler(compiler); + + n.get_collection().get_visited_by(reference_compiler); + + collection_ref = reference_compiler.get_ref(); + + if (reference_compiler.has_init()) + { + result.add(reference_compiler.get_init()); + } + + result.add + ( + ReverseList.generate + ( + compiler.anonymous_variables(), + compiler.assembler(), + new Size(collection_ref), + collection_ref + ) + ); + + reference_compiler.release_variables(); + } + @Override public void visit_switch_instruction ( @@ -374,7 +426,9 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor Computation value_of_anon; List<Instruction> current_branch, previous_else_branch; - branches = new ArrayList(n.get_branches()); // shallow copy. + branches = new ArrayList<>(n.get_branches()); // shallow copy. + + Collections.reverse(branches); previous_else_branch = new ArrayList<Instruction>(); @@ -415,6 +469,7 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor cc = new ComputationCompiler(compiler); branch.get_car().get_visited_by(cc); + branch.get_cdr().get_visited_by(ic); if (cc.has_init()) { @@ -664,13 +719,17 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor { result.add ( - While.generate + compiler.assembler().mark_after ( - compiler.anonymous_variables(), - compiler.assembler(), - cc.get_init(), - cc.get_computation(), - compiler.assembler().merge(body) + While.generate + ( + compiler.anonymous_variables(), + compiler.assembler(), + cc.get_init(), + cc.get_computation(), + compiler.assembler().merge(body) + ), + end_of_loop_label ) ); } @@ -678,12 +737,16 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor { result.add ( - While.generate + compiler.assembler().mark_after ( - compiler.anonymous_variables(), - compiler.assembler(), - cc.get_computation(), - compiler.assembler().merge(body) + While.generate + ( + compiler.anonymous_variables(), + compiler.assembler(), + cc.get_computation(), + compiler.assembler().merge(body) + ), + end_of_loop_label ) ); } @@ -697,15 +760,107 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor throws Throwable { final String end_of_loop_label; + final ComputationCompiler cc; + final List<Instruction> new_body; + final Ref index, current_value, collection_size; + final Ref collection; + final Computation value_of_index; + final Type member_type; - end_of_loop_label = - compiler.assembler().generate_label("<AfterFor>"); + cc = new ComputationCompiler(compiler); + new_body = new ArrayList<Instruction>(); + + index = compiler.anonymous_variables().reserve(Type.INT); + collection_size = compiler.anonymous_variables().reserve(Type.INT); + + result.add(new SetValue(index, Constant.ZERO)); + + n.get_collection().get_visited_by(cc); + + if (cc.has_init()) + { + result.add(cc.get_init()); + } + + collection = cc.get_ref(); + + result.add(new SetValue(collection_size, new Size(collection))); + + value_of_index = new ValueOf(index); + + member_type = ((MapType) collection.get_target_type()).get_member_type(); + + current_value = compiler.anonymous_variables().reserve(member_type); + + end_of_loop_label = compiler.assembler().generate_label("<AfterForEach>"); compiler.assembler().push_context_label("breakable", end_of_loop_label); + compiler.macros().add_wild_parameter + ( + n.get_parameter_name(), + current_value + ); + + for + ( + final tonkadur.fate.v1.lang.meta.Instruction fate_instr: n.get_body() + ) + { + final InstructionCompiler ic; + + ic = new InstructionCompiler(compiler); - /* TODO */ + fate_instr.get_visited_by(ic); + new_body.add(ic.get_result()); + } + + new_body.add + ( + new SetValue + ( + current_value, + new ValueOf + ( + new RelativeRef + ( + collection, + new Cast(value_of_index, Type.STRING), + member_type + ) + ) + ) + ); + + new_body.add + ( + new SetValue(index, Operation.plus(Constant.ONE, value_of_index)) + ); + + result.add + ( + compiler.assembler().mark_after + ( + While.generate + ( + compiler.anonymous_variables(), + compiler.assembler(), + Operation.less_than + ( + value_of_index, + new ValueOf(collection_size) + ), + compiler.assembler.merge(new_body) + ), + end_of_loop_label + ) + ); + compiler.macros().remove_wild_parameter(n.get_parameter_name()); compiler.assembler().pop_context_label("breakable"); + + compiler.anonymous_variables().release(index); + compiler.anonymous_variables().release(current_value); + compiler.anonymous_variables().release(collection_size); } @Override @@ -1113,11 +1268,9 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor * Wyrd (add_choice label i0) */ final ComputationCompiler cc; - final InstructionCompiler ic; final String start_of_effect, end_of_effect; cc = new ComputationCompiler(compiler); - ic = new InstructionCompiler(compiler); start_of_effect = compiler.assembler().generate_label("<choice#start>"); end_of_effect = compiler.assembler().generate_label("<choice#end>"); @@ -1155,7 +1308,7 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor n.get_effects() ) { - fate_instruction.get_visited_by(ic); + fate_instruction.get_visited_by(this); } result.add diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/MacroManager.java b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/MacroManager.java index 085524a..fe2ab67 100644 --- a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/MacroManager.java +++ b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/MacroManager.java @@ -10,13 +10,30 @@ import tonkadur.wyrd.v1.lang.computation.Ref; public class MacroManager { + protected final Map<String, Ref> wild_parameters; protected final Stack<Map<String, Ref>> context_stack; public MacroManager () { + wild_parameters = new HashMap<String, Ref>(); context_stack = new Stack<Map<String, Ref>>(); } + public void add_wild_parameter (final String name, final Ref ref) + { + if (wild_parameters.containsKey(name)) + { + System.err.println("[P] duplicate wild parameter '" + name + "'."); + + return; + } + } + + public void remove_wild_parameter (final String name) + { + wild_parameters.remove(name); + } + public void pop () { context_stack.pop(); @@ -51,13 +68,18 @@ public class MacroManager public Ref get_parameter_ref (final String parameter) { - final Ref result; + Ref result; - result = context_stack.peek().get(parameter); + result = wild_parameters.get(parameter); if (result == null) { - System.err.println("[P] No such parameter '" + parameter + "'."); + result = context_stack.peek().get(parameter); + + if (result == null) + { + System.err.println("[P] No such parameter '" + parameter + "'."); + } } return result; diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/AnonymousVariableManager.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/AnonymousVariableManager.java index df0da53..8bec40a 100644 --- a/src/core/src/tonkadur/wyrd/v1/compiler/util/AnonymousVariableManager.java +++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/AnonymousVariableManager.java @@ -2,6 +2,7 @@ package tonkadur.wyrd.v1.compiler.util; import java.util.Map; import java.util.HashMap; +import java.util.Collection; import java.util.List; import java.util.ArrayList; @@ -32,6 +33,20 @@ public class AnonymousVariableManager generated_variables = 0; } + public Collection<Variable> get_all_variables () + { + final Collection<Variable> result; + + result = new ArrayList<Variable>(); + + for (final Cons<Boolean, Variable> variable: by_name.values()) + { + result.add(variable.get_cdr()); + } + + return result; + } + public Ref reserve (final Type t) { final String name; diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/RemoveAt.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/RemoveAt.java index 55f5f02..5fc7489 100644 --- a/src/core/src/tonkadur/wyrd/v1/compiler/util/RemoveAt.java +++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/RemoveAt.java @@ -90,7 +90,7 @@ public class RemoveAt /* (set .next (+ (val index) 1)) */ while_body.add ( - new SetValue(next, Operation.plus(value_of_end, Constant.ONE)) + new SetValue(next, Operation.plus(value_of_index, Constant.ONE)) ); /* (set collection[index] (val collection[.next])) */ diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/util/ReverseList.java b/src/core/src/tonkadur/wyrd/v1/compiler/util/ReverseList.java new file mode 100644 index 0000000..226e86a --- /dev/null +++ b/src/core/src/tonkadur/wyrd/v1/compiler/util/ReverseList.java @@ -0,0 +1,152 @@ +package tonkadur.wyrd.v1.compiler.util; + +import java.util.List; +import java.util.ArrayList; +import java.util.Collections; + +import tonkadur.wyrd.v1.lang.type.Type; +import tonkadur.wyrd.v1.lang.type.MapType; + +import tonkadur.wyrd.v1.lang.meta.Instruction; +import tonkadur.wyrd.v1.lang.meta.Computation; + +import tonkadur.wyrd.v1.lang.computation.Cast; +import tonkadur.wyrd.v1.lang.computation.Constant; +import tonkadur.wyrd.v1.lang.computation.Operation; +import tonkadur.wyrd.v1.lang.computation.Ref; +import tonkadur.wyrd.v1.lang.computation.RelativeRef; +import tonkadur.wyrd.v1.lang.computation.ValueOf; + +import tonkadur.wyrd.v1.lang.instruction.SetValue; + +public class ReverseList +{ + /* Utility Class */ + private ReverseList () {} + + /* + * (Computation int collection_size) + * (declare_variable global <List E> collection) + * + * (declare_variable E .buffer + * (declare_variable int .top) + * (declare_variable int .bot) + * + * (set .top (- (collection_size) 1)) + * (set .bot 0) + * + * (while (< (var .bot) (var .top)) + * (set .buffer collection[.top]) + * (set collection[.top] collection[.bot]) + * (set collection[.bot] .buffer) + * (set .bot (+ 1 (var .bot))) + * (set .top (- 1 (var .top))) + * ) + */ + public static Instruction generate + ( + final AnonymousVariableManager anonymous_variables, + final InstructionManager assembler, + final Computation collection_size, + final Ref collection + ) + { + final List<Instruction> result, while_body; + final Type element_type; + final Ref buffer, top, bot; + final Computation value_of_top, value_of_bot; + final Ref collection_at_top, collection_at_bot; + + result = new ArrayList<Instruction>(); + while_body = new ArrayList<Instruction>(); + + element_type = + ((MapType) collection.get_target_type()).get_member_type(); + + buffer = anonymous_variables.reserve(element_type); + top = anonymous_variables.reserve(Type.INT); + bot = anonymous_variables.reserve(Type.INT); + + value_of_top = new ValueOf(top); + value_of_bot = new ValueOf(bot); + + collection_at_top = + new RelativeRef + ( + collection, + new Cast(value_of_top, Type.STRING), + element_type + ); + + collection_at_bot = + new RelativeRef + ( + collection, + new Cast(value_of_bot, Type.STRING), + element_type + ); + + /* (set .top (- (collection_size) 1)) */ + result.add + ( + new SetValue(top, Operation.minus(collection_size, Constant.ONE)) + ); + + /* (set .bot 0) */ + result.add(new SetValue(bot, Constant.ZERO)); + + + /* (set .buffer collection[.top]) */ + while_body.add(new SetValue(buffer, new ValueOf(collection_at_top))); + + /* (set collection[.top] collection[.bot]) */ + while_body.add + ( + new SetValue(collection_at_top, new ValueOf(collection_at_bot)) + ); + + /* (set collection[.bot] .buffer) */ + while_body.add + ( + new SetValue(collection_at_bot, new ValueOf(buffer)) + ); + + /* (set .bot (+ 1 (var .bot))) */ + while_body.add + ( + new SetValue(bot, Operation.plus(Constant.ONE, value_of_bot)) + ); + + /* (set .top (- 1 (var .top))) */ + while_body.add + ( + new SetValue(top, Operation.minus(Constant.ONE, value_of_top)) + ); + + /* + * (while (< (var .bot) (var .top)) + * (set .buffer collection[.top]) + * (set collection[.top] collection[.bot]) + * (set collection[.bot] .buffer) + * (set .bot (+ 1 (var .bot))) + * (set .top (- 1 (var .top))) + * ) + */ + result.add + ( + While.generate + ( + anonymous_variables, + assembler, + Operation.less_than(value_of_bot, value_of_top), + assembler.merge(while_body) + ) + ); + + anonymous_variables.release(buffer); + anonymous_variables.release(top); + anonymous_variables.release(bot); + + return assembler.merge(result); + } +} diff --git a/src/core/src/tonkadur/wyrd/v1/lang/instruction/Assert.java b/src/core/src/tonkadur/wyrd/v1/lang/instruction/Assert.java index 7bfa25b..57dd7c1 100644 --- a/src/core/src/tonkadur/wyrd/v1/lang/instruction/Assert.java +++ b/src/core/src/tonkadur/wyrd/v1/lang/instruction/Assert.java @@ -10,14 +10,16 @@ public class Assert extends Instruction /**** MEMBERS **************************************************************/ /***************************************************************************/ protected final Computation condition; + protected final Computation message; /***************************************************************************/ /**** PUBLIC ***************************************************************/ /***************************************************************************/ /**** Constructors *********************************************************/ - public Assert (final Computation condition) + public Assert (final Computation condition, final Computation message) { this.condition = condition; + this.message = message; } /**** Accessors ************************************************************/ @@ -26,6 +28,11 @@ public class Assert extends Instruction return condition; } + public Computation get_message () + { + return message; + } + @Override public void get_visited_by (final InstructionVisitor iv) throws Throwable @@ -43,6 +50,8 @@ public class Assert extends Instruction sb.append("(Assert "); sb.append(condition.toString()); + sb.append(" "); + sb.append(message.toString()); sb.append(")"); return sb.toString(); diff --git a/src/json-export/src/tonkadur/jsonexport/InstructionCompiler.java b/src/json-export/src/tonkadur/jsonexport/InstructionCompiler.java index 00445c7..8f7913b 100644 --- a/src/json-export/src/tonkadur/jsonexport/InstructionCompiler.java +++ b/src/json-export/src/tonkadur/jsonexport/InstructionCompiler.java @@ -33,16 +33,19 @@ public class InstructionCompiler implements InstructionVisitor public void visit_assert (final Assert n) throws Throwable { - final ComputationCompiler cc; + final ComputationCompiler cond_cc, msg_cc; - cc = new ComputationCompiler(); + cond_cc = new ComputationCompiler(); + msg_cc = new ComputationCompiler(); - n.get_condition().get_visited_by(cc); + n.get_condition().get_visited_by(cond_cc); + n.get_message().get_visited_by(msg_cc); result = new JSONObject(); result.put("category", "assert"); - result.put("condition", cc.get_result()); + result.put("condition", cond_cc.get_result()); + result.put("message", msg_cc.get_result()); } public void visit_display (final Display n) diff --git a/src/json-export/src/tonkadur/jsonexport/Translator.java b/src/json-export/src/tonkadur/jsonexport/Translator.java index edd0a7f..cc22e7c 100644 --- a/src/json-export/src/tonkadur/jsonexport/Translator.java +++ b/src/json-export/src/tonkadur/jsonexport/Translator.java @@ -36,9 +36,6 @@ public class Translator out = new PrintWriter(output_file); out.println(result.toJSONString()); out.close(); - - System.out.println("JSON Result:"); - System.out.println(result.toJSONString()); } public static JSONArray get_compiled_variables (final World wyrd_world) |