| summaryrefslogtreecommitdiff |
diff options
Diffstat (limited to 'src')
14 files changed, 925 insertions, 0 deletions
diff --git a/src/core/src/tonkadur/fate/v1/error/UnknownSequenceException.java b/src/core/src/tonkadur/fate/v1/error/UnknownSequenceException.java index bb12260..62c6744 100644 --- a/src/core/src/tonkadur/fate/v1/error/UnknownSequenceException.java +++ b/src/core/src/tonkadur/fate/v1/error/UnknownSequenceException.java @@ -1,6 +1,8 @@ package tonkadur.fate.v1.error; +import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; import java.util.List; import tonkadur.functional.Cons; @@ -12,6 +14,8 @@ import tonkadur.parser.ParsingError; import tonkadur.fate.v1.lang.meta.Computation; +import tonkadur.fate.v1.lang.computation.SequenceReference; + public class UnknownSequenceException extends ParsingError { /***************************************************************************/ @@ -41,6 +45,32 @@ public class UnknownSequenceException extends ParsingError this.all_occurrences = all_occurrences; } + public UnknownSequenceException + ( + final String sequence_name, + final Collection<SequenceReference> all_occurrences + ) + { + super + ( + ErrorLevel.ERROR, + ErrorCategory.UNKNOWN, + all_occurrences.iterator().next().get_origin() + ); + + this.sequence_name = sequence_name; + + this.all_occurrences = new ArrayList<Cons<Origin, List<Computation>>>(); + + for (final SequenceReference occ: all_occurrences) + { + this.all_occurrences.add + ( + new Cons(occ.get_origin(), Collections.singleton(occ)) + ); + } + } + @Override public String toString () { diff --git a/src/core/src/tonkadur/fate/v1/lang/World.java b/src/core/src/tonkadur/fate/v1/lang/World.java index c813312..d07d9b7 100644 --- a/src/core/src/tonkadur/fate/v1/lang/World.java +++ b/src/core/src/tonkadur/fate/v1/lang/World.java @@ -22,9 +22,13 @@ import tonkadur.fate.v1.lang.meta.Computation; import tonkadur.fate.v1.lang.meta.DeclarationCollection; import tonkadur.fate.v1.lang.meta.ExtensionInstruction; import tonkadur.fate.v1.lang.meta.ExtensionComputation; +import tonkadur.fate.v1.lang.meta.RecurrentChecks; import tonkadur.fate.v1.lang.meta.Instruction; import tonkadur.fate.v1.lang.type.Type; +import tonkadur.fate.v1.lang.type.SequenceType; + +import tonkadur.fate.v1.lang.computation.SequenceReference; public class World { @@ -36,6 +40,7 @@ public class World protected final Map<String, List<Cons<Origin, List<Computation>>>> sequence_uses; + protected final Map<String, List<SequenceReference>> sequence_variables; protected final Map<String, ExtensionComputation> extension_value_nodes; protected final Map<String, ExtensionInstruction> extension_instructions; protected final Map<String, ExtensionInstruction> @@ -63,6 +68,8 @@ public class World sequence_uses = new HashMap<String, List<Cons<Origin, List<Computation>>>>(); + sequence_variables = new HashMap<String, List<SequenceReference>>(); + extension_value_nodes = new HashMap<String, ExtensionComputation>(); extension_instructions = new HashMap<String, ExtensionInstruction>(); extension_first_level_instructions = @@ -141,6 +148,22 @@ public class World list_of_uses.add(new Cons(origin, parameters)); } + public void add_sequence_variable (final SequenceReference sr) + { + List<SequenceReference> list_of_variables; + + list_of_variables = sequence_variables.get(sr.get_sequence_name()); + + if (list_of_variables == null) + { + list_of_variables = new ArrayList<SequenceReference>(); + + sequence_variables.put(sr.get_sequence_name(), list_of_variables); + } + + list_of_variables.add(sr); + } + /**** Extension Stuff ****/ public Map<String, ExtensionInstruction> extension_instructions () { @@ -209,6 +232,7 @@ public class World is_sane = true; is_sane = assert_sane_sequence_uses() & is_sane; + is_sane = assert_sane_sequence_variables() & is_sane; return is_sane; } @@ -365,4 +389,74 @@ public class World return is_sane; } + + protected boolean assert_sane_sequence_variables () + throws Throwable + { + Sequence seq; + + boolean is_sane; + + is_sane = true; + + for + ( + final Map.Entry<String, List<SequenceReference>> entry: + sequence_variables.entrySet() + ) + { + seq = sequences().get_or_null(entry.getKey()); + + if (seq == null) + { + final List<SequenceReference> variables; + + variables = entry.getValue(); + + if (variables.isEmpty()) + { + continue; + } + + is_sane = false; + + ErrorManager.handle + ( + new UnknownSequenceException + ( + entry.getKey(), + ((variables.size() == 1) ? null : variables) + ) + ); + } + else + { + final List<Type> signature_types; + + signature_types = new ArrayList<Type>(); + + for (final Variable v: seq.get_signature()) + { + signature_types.add(v.get_type()); + } + + for (final SequenceReference sr: entry.getValue()) + { + ((SequenceType) sr.get_type()).propose_signature + ( + signature_types + ); + + RecurrentChecks.assert_types_matches_signature + ( + sr.get_origin(), + ((SequenceType) sr.get_type()).get_signature(), + signature_types + ); + } + } + } + + return is_sane; + } } diff --git a/src/core/src/tonkadur/fate/v1/lang/computation/SequenceReference.java b/src/core/src/tonkadur/fate/v1/lang/computation/SequenceReference.java new file mode 100644 index 0000000..f7984df --- /dev/null +++ b/src/core/src/tonkadur/fate/v1/lang/computation/SequenceReference.java @@ -0,0 +1,63 @@ +package tonkadur.fate.v1.lang.computation; + +import tonkadur.parser.Origin; + +import tonkadur.fate.v1.lang.type.SequenceType; + +import tonkadur.fate.v1.lang.meta.ComputationVisitor; +import tonkadur.fate.v1.lang.meta.Computation; + +public class SequenceReference extends Computation +{ + /***************************************************************************/ + /**** MEMBERS **************************************************************/ + /***************************************************************************/ + protected final String sequence_name; + + /***************************************************************************/ + /**** PROTECTED ************************************************************/ + /***************************************************************************/ + + /***************************************************************************/ + /**** PUBLIC ***************************************************************/ + /***************************************************************************/ + /**** Constructors *********************************************************/ + public SequenceReference + ( + final Origin origin, + final String sequence_name + ) + { + super(origin, new SequenceType(origin, "(seq " + sequence_name + ")")); + + this.sequence_name = sequence_name; + } + + + /**** Accessors ************************************************************/ + @Override + public void get_visited_by (final ComputationVisitor cv) + throws Throwable + { + cv.visit_sequence_reference(this); + } + + public String get_sequence_name () + { + return sequence_name; + } + + /**** Misc. ****************************************************************/ + @Override + public String toString () + { + final StringBuilder sb = new StringBuilder(); + + sb.append("(SequenceReference "); + sb.append(sequence_name); + + sb.append(")"); + + return sb.toString(); + } +} diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/SequenceVariableCall.java b/src/core/src/tonkadur/fate/v1/lang/instruction/SequenceVariableCall.java new file mode 100644 index 0000000..407f430 --- /dev/null +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/SequenceVariableCall.java @@ -0,0 +1,125 @@ +package tonkadur.fate.v1.lang.instruction; + +import java.util.Collections; +import java.util.List; + +import tonkadur.parser.Origin; +import tonkadur.parser.ParsingError; + +import tonkadur.error.ErrorManager; + +import tonkadur.fate.v1.error.InvalidTypeException; + +import tonkadur.fate.v1.lang.type.SequenceType; +import tonkadur.fate.v1.lang.type.Type; + +import tonkadur.fate.v1.lang.meta.Computation; +import tonkadur.fate.v1.lang.meta.InstructionVisitor; +import tonkadur.fate.v1.lang.meta.Instruction; +import tonkadur.fate.v1.lang.meta.RecurrentChecks; + +public class SequenceVariableCall extends Instruction +{ + /***************************************************************************/ + /**** MEMBERS **************************************************************/ + /***************************************************************************/ + protected final List<Computation> parameters; + protected final Computation sequence; + + /***************************************************************************/ + /**** PROTECTED ************************************************************/ + /***************************************************************************/ + /**** Constructors *********************************************************/ + protected SequenceVariableCall + ( + final Origin origin, + final Computation sequence, + final List<Computation> parameters + ) + { + super(origin); + + this.sequence = sequence; + this.parameters = parameters; + } + + /***************************************************************************/ + /**** PUBLIC ***************************************************************/ + /***************************************************************************/ + /**** Constructors *********************************************************/ + public static SequenceVariableCall build + ( + final Origin origin, + final Computation sequence, + final List<Computation> parameters + ) + throws ParsingError + { + final List<Type> signature; + + ((SequenceType) sequence.get_type()).propose_signature_from_parameters + ( + parameters + ); + + if (!sequence.get_type().get_act_as_type().equals(Type.SEQUENCE)) + { + ErrorManager.handle + ( + new InvalidTypeException + ( + origin, + sequence.get_type(), + Collections.singleton(Type.SEQUENCE) + ) + ); + } + + RecurrentChecks.assert_computations_matches_signature + ( + origin, + parameters, + ((SequenceType) sequence.get_type()).get_signature() + ); + + return new SequenceVariableCall(origin, sequence, parameters); + } + + /**** Accessors ************************************************************/ + @Override + public void get_visited_by (final InstructionVisitor iv) + throws Throwable + { + iv.visit_sequence_variable_call(this); + } + + public Computation get_sequence () + { + return sequence; + } + + public List<Computation> get_parameters () + { + return parameters; + } + + /**** Misc. ****************************************************************/ + @Override + public String toString () + { + final StringBuilder sb = new StringBuilder(); + + sb.append("(SequenceVariableCall "); + sb.append(sequence); + + for (final Computation c: parameters) + { + sb.append(" "); + sb.append(c.toString()); + } + + sb.append(")"); + + return sb.toString(); + } +} diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/SequenceVariableJump.java b/src/core/src/tonkadur/fate/v1/lang/instruction/SequenceVariableJump.java new file mode 100644 index 0000000..52aa947 --- /dev/null +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/SequenceVariableJump.java @@ -0,0 +1,125 @@ +package tonkadur.fate.v1.lang.instruction; + +import java.util.Collections; +import java.util.List; + +import tonkadur.parser.Origin; +import tonkadur.parser.ParsingError; + +import tonkadur.error.ErrorManager; + +import tonkadur.fate.v1.error.InvalidTypeException; + +import tonkadur.fate.v1.lang.type.SequenceType; +import tonkadur.fate.v1.lang.type.Type; + +import tonkadur.fate.v1.lang.meta.Computation; +import tonkadur.fate.v1.lang.meta.InstructionVisitor; +import tonkadur.fate.v1.lang.meta.Instruction; +import tonkadur.fate.v1.lang.meta.RecurrentChecks; + +public class SequenceVariableJump extends Instruction +{ + /***************************************************************************/ + /**** MEMBERS **************************************************************/ + /***************************************************************************/ + protected final List<Computation> parameters; + protected final Computation sequence; + + /***************************************************************************/ + /**** PROTECTED ************************************************************/ + /***************************************************************************/ + /**** Constructors *********************************************************/ + protected SequenceVariableJump + ( + final Origin origin, + final Computation sequence, + final List<Computation> parameters + ) + { + super(origin); + + this.sequence = sequence; + this.parameters = parameters; + } + + /***************************************************************************/ + /**** PUBLIC ***************************************************************/ + /***************************************************************************/ + /**** Constructors *********************************************************/ + public static SequenceVariableJump build + ( + final Origin origin, + final Computation sequence, + final List<Computation> parameters + ) + throws ParsingError + { + final List<Type> signature; + + ((SequenceType) sequence.get_type()).propose_signature_from_parameters + ( + parameters + ); + + if (!sequence.get_type().get_act_as_type().equals(Type.SEQUENCE)) + { + ErrorManager.handle + ( + new InvalidTypeException + ( + origin, + sequence.get_type(), + Collections.singleton(Type.SEQUENCE) + ) + ); + } + + RecurrentChecks.assert_computations_matches_signature + ( + origin, + parameters, + ((SequenceType) sequence.get_type()).get_signature() + ); + + return new SequenceVariableJump(origin, sequence, parameters); + } + + /**** Accessors ************************************************************/ + @Override + public void get_visited_by (final InstructionVisitor iv) + throws Throwable + { + iv.visit_sequence_variable_jump(this); + } + + public Computation get_sequence () + { + return sequence; + } + + public List<Computation> get_parameters () + { + return parameters; + } + + /**** Misc. ****************************************************************/ + @Override + public String toString () + { + final StringBuilder sb = new StringBuilder(); + + sb.append("(SequenceVariableJump "); + sb.append(sequence); + + for (final Computation c: parameters) + { + sb.append(" "); + sb.append(c.toString()); + } + + sb.append(")"); + + return sb.toString(); + } +} diff --git a/src/core/src/tonkadur/fate/v1/lang/meta/ComputationVisitor.java b/src/core/src/tonkadur/fate/v1/lang/meta/ComputationVisitor.java index 4631a2f..adb3a05 100644 --- a/src/core/src/tonkadur/fate/v1/lang/meta/ComputationVisitor.java +++ b/src/core/src/tonkadur/fate/v1/lang/meta/ComputationVisitor.java @@ -79,6 +79,9 @@ public interface ComputationVisitor public void visit_operation (final Operation n) throws Throwable; + public void visit_sequence_reference (final SequenceReference n) + throws Throwable; + public void visit_paragraph (final Paragraph n) throws Throwable; 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 a672f3c..406cd7f 100644 --- a/src/core/src/tonkadur/fate/v1/lang/meta/InstructionVisitor.java +++ b/src/core/src/tonkadur/fate/v1/lang/meta/InstructionVisitor.java @@ -140,6 +140,12 @@ public interface InstructionVisitor public void visit_sequence_jump (final SequenceJump n) throws Throwable; + public void visit_sequence_variable_call (final SequenceVariableCall n) + throws Throwable; + + public void visit_sequence_variable_jump (final SequenceVariableJump n) + throws Throwable; + public void visit_local_variable (final LocalVariable n) throws Throwable; diff --git a/src/core/src/tonkadur/fate/v1/lang/type/SequenceType.java b/src/core/src/tonkadur/fate/v1/lang/type/SequenceType.java new file mode 100644 index 0000000..c6e7ef3 --- /dev/null +++ b/src/core/src/tonkadur/fate/v1/lang/type/SequenceType.java @@ -0,0 +1,193 @@ +package tonkadur.fate.v1.lang.type; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import tonkadur.parser.Origin; + +import tonkadur.fate.v1.lang.meta.DeclaredEntity; +import tonkadur.fate.v1.lang.meta.Computation; + +public class SequenceType extends Type +{ + /***************************************************************************/ + /**** MEMBERS **************************************************************/ + /***************************************************************************/ + protected final List<Type> signature; + protected boolean signature_is_defined; + + /***************************************************************************/ + /**** PUBLIC ***************************************************************/ + /***************************************************************************/ + + /**** Constructors *********************************************************/ + public SequenceType + ( + final Origin origin, + final String name, + final List<Type> signature + ) + { + super(origin, null, name); + + this.signature = signature; + this.signature_is_defined = true; + } + + public SequenceType + ( + final Origin origin, + final String name + ) + { + super(origin, null, name); + + this.signature = new ArrayList<Type>(); + this.signature_is_defined = false; + } + + /**** Accessors ************************************************************/ + public List<Type> get_signature () + { + return signature; + } + + public void propose_signature (final List<Type> signature) + { + if (signature_is_defined) + { + return; + } + + this.signature.addAll(signature); + + signature_is_defined = true; + } + + public void propose_signature_from_parameters + ( + final List<Computation> params + ) + { + if (signature_is_defined) + { + return; + } + + for (final Computation c: params) + { + signature.add(c.get_type()); + } + + signature_is_defined = true; + } + + /**** Compatibility ********************************************************/ + @Override + public boolean can_be_used_as (final Type t) + { + if (t instanceof SequenceType) + { + final Iterator<Type> i0, i1; + final SequenceType lt; + + lt = (SequenceType) t; + + propose_signature(lt.get_signature()); + + if (signature.size() != lt.signature.size()) + { + return false; + } + + i0 = signature.iterator(); + i1 = lt.signature.iterator(); + + while(i0.hasNext()) + { + if (!i0.next().can_be_used_as(i1.next())) + { + return false; + } + } + + return true; + } + + return false; + } + + /* + * This is for the very special case where a type is used despite not being + * even a sub-type of the expected one. Using this rather expensive function, + * the most restrictive shared type will be returned. If no such type exists, + * the ANY time is returned. + */ + @Override + public DeclaredEntity generate_comparable_to (final DeclaredEntity de) + { + final Iterator<Type> i0, i1; + final List<Type> resulting_signature; + final SequenceType lt; + + if (!(de instanceof SequenceType)) + { + return Type.ANY; + } + + lt = (SequenceType) de; + + if (lt.signature.size() != signature.size()) + { + return Type.ANY; + } + + resulting_signature = new ArrayList<Type>(); + + i0 = signature.iterator(); + i1 = lt.signature.iterator(); + + while(i0.hasNext()) + { + resulting_signature.add + ( + (Type) i0.next().generate_comparable_to(i1.next()) + ); + } + + return new SequenceType(get_origin(), name, resulting_signature); + } + + @Override + public Type get_act_as_type () + { + return Type.SEQUENCE; + } + + /**** Misc. ****************************************************************/ + @Override + public Type generate_alias (final Origin origin, final String name) + { + return new SequenceType(origin, name, signature); + } + + @Override + public String toString () + { + final StringBuilder sb = new StringBuilder(); + + sb.append("(Sequence ("); + + for (final Type t: signature) + { + sb.append(t.get_name()); + sb.append(" "); + } + + sb.append("))::"); + sb.append(name); + + return sb.toString(); + } +} diff --git a/src/core/src/tonkadur/fate/v1/lang/type/Type.java b/src/core/src/tonkadur/fate/v1/lang/type/Type.java index ac4bcb3..ce93e9e 100644 --- a/src/core/src/tonkadur/fate/v1/lang/type/Type.java +++ b/src/core/src/tonkadur/fate/v1/lang/type/Type.java @@ -29,6 +29,7 @@ public class Type extends DeclaredEntity public static final Type LIST; public static final Type REF; public static final Type RICH_TEXT; + public static final Type SEQUENCE; public static final Type SET; public static final Type STRING; @@ -57,6 +58,7 @@ public class Type extends DeclaredEntity LIST = new Type(base, null, "list"); REF = new Type(base, null, "ref"); RICH_TEXT = new Type(base, null, "text"); + SEQUENCE = new Type(base, null, "sequence"); SET = new Type(base, null, "set"); STRING = new Type(base, null, "string"); @@ -71,6 +73,7 @@ public class Type extends DeclaredEntity ALL_TYPES.add(LIST); ALL_TYPES.add(REF); ALL_TYPES.add(RICH_TEXT); + ALL_TYPES.add(SEQUENCE); ALL_TYPES.add(SET); ALL_TYPES.add(STRING); @@ -83,6 +86,7 @@ public class Type extends DeclaredEntity COMPARABLE_TYPES.add(FLOAT); COMPARABLE_TYPES.add(INT); + COMPARABLE_TYPES.add(SEQUENCE); COMPARABLE_TYPES.add(LAMBDA); COMPARABLE_TYPES.add(STRING); COMPARABLE_TYPES.add(BOOL); diff --git a/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4 b/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4 index b7b64dd..4b6edfc 100644 --- a/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4 +++ b/src/core/src/tonkadur/fate/v1/parser/FateLexer.g4 @@ -154,6 +154,7 @@ SUB_LIST_KW: L_PAREN 'sub'US'list' SEP+; IMP_SUB_LIST_KW: L_PAREN 'sub'US'list!' SEP+; LIST_KW: L_PAREN 'list' SEP+; SIZE_KW: L_PAREN 'size' SEP+; +SEQUENCE_KW: L_PAREN ('seq'|'sequence') SEP+; SWITCH_KW: L_PAREN 'switch' SEP+; TIMES_KW: L_PAREN ('times'|'*') SEP+; TRUE_KW: L_PAREN 'true)'; diff --git a/src/core/src/tonkadur/fate/v1/parser/FateParser.g4 b/src/core/src/tonkadur/fate/v1/parser/FateParser.g4 index 16a9472..8465af6 100644 --- a/src/core/src/tonkadur/fate/v1/parser/FateParser.g4 +++ b/src/core/src/tonkadur/fate/v1/parser/FateParser.g4 @@ -1801,6 +1801,86 @@ returns [Instruction result] $result = new SequenceJump(origin, sequence_name, params); } + | VISIT_KW value WS+ value_list WS* R_PAREN + { + final Origin origin; + + origin = + CONTEXT.get_origin_at + ( + ($VISIT_KW.getLine()), + ($VISIT_KW.getCharPositionInLine()) + ); + + $result = + SequenceVariableCall.build + ( + origin, + ($value.result), + ($value_list.result) + ); + } + + | VISIT_KW value WS* R_PAREN + { + final Origin origin; + + origin = + CONTEXT.get_origin_at + ( + ($VISIT_KW.getLine()), + ($VISIT_KW.getCharPositionInLine()) + ); + + $result = + SequenceVariableCall.build + ( + origin, + ($value.result), + new ArrayList<Computation>() + ); + } + + | CONTINUE_AS_KW value WS+ value_list WS* R_PAREN + { + final Origin origin; + + origin = + CONTEXT.get_origin_at + ( + ($CONTINUE_AS_KW.getLine()), + ($CONTINUE_AS_KW.getCharPositionInLine()) + ); + + $result = + SequenceVariableJump.build + ( + origin, + ($value.result), + ($value_list.result) + ); + } + + | CONTINUE_AS_KW value WS* R_PAREN + { + final Origin origin; + + origin = + CONTEXT.get_origin_at + ( + ($CONTINUE_AS_KW.getLine()), + ($CONTINUE_AS_KW.getCharPositionInLine()) + ); + + $result = + SequenceVariableJump.build + ( + origin, + ($value.result), + new ArrayList<Computation>() + ); + } + | ASSERT_KW non_text_value WS+ paragraph WS* R_PAREN { $result = @@ -2798,6 +2878,26 @@ returns [Type result] ($type_list.result) ); } + + | SEQUENCE_KW type_list WS* R_PAREN + { + final Origin start_origin; + + start_origin = + CONTEXT.get_origin_at + ( + ($SEQUENCE_KW.getLine()), + ($SEQUENCE_KW.getCharPositionInLine()) + ); + + $result = + new SequenceType + ( + start_origin, + "auto_generated", + ($type_list.result) + ); + } ; catch [final Throwable e] { @@ -4092,6 +4192,24 @@ returns [Computation result] } } + | SEQUENCE_KW WORD WS* R_PAREN + { + final SequenceReference sr; + final Origin origin; + + origin = + CONTEXT.get_origin_at + ( + ($SEQUENCE_KW.getLine()), + ($SEQUENCE_KW.getCharPositionInLine()) + ); + + sr = new SequenceReference(origin, ($WORD.text)); + $result = sr; + + WORLD.add_sequence_variable(sr); + } + | EVAL_KW value_reference WS* R_PAREN { final Origin origin; 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 2df0868..110c670 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 @@ -3955,4 +3955,18 @@ implements tonkadur.fate.v1.lang.meta.ComputationVisitor cc.release_registers(init_instructions); } } + + @Override + public void visit_sequence_reference + ( + final tonkadur.fate.v1.lang.computation.SequenceReference n + ) + throws Throwable + { + result_as_computation = + compiler.assembler().get_label_constant + ( + n.get_sequence_name() + ); + } } 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 5986682..dda6d2e 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 @@ -3514,6 +3514,79 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor } @Override + public void visit_sequence_variable_call + ( + final tonkadur.fate.v1.lang.instruction.SequenceVariableCall n + ) + throws Throwable + { + final ComputationCompiler sequence_cc; + final List<ComputationCompiler> parameter_ccs; + final List<Computation> parameters; + + final String return_to_label; + + return_to_label = + compiler.assembler().generate_label("<seq_call#return_to>"); + + sequence_cc = new ComputationCompiler(compiler); + parameter_ccs = new ArrayList<ComputationCompiler>(); + parameters = new ArrayList<Computation>(); + + n.get_sequence().get_visited_by(sequence_cc); + + if (sequence_cc.has_init()) + { + result.add(sequence_cc.get_init()); + } + + for + ( + final tonkadur.fate.v1.lang.meta.Computation param: n.get_parameters() + ) + { + final ComputationCompiler cc; + + cc = new ComputationCompiler(compiler); + + param.get_visited_by(cc); + + if (cc.has_init()) + { + result.add(cc.get_init()); + } + + parameters.add(cc.get_computation()); + parameter_ccs.add(cc); + } + + result.addAll(compiler.registers().store_parameters(parameters)); + + result.add + ( + compiler.assembler().mark_after + ( + compiler.assembler().merge + ( + compiler.registers().get_visit_context_instructions + ( + sequence_cc.get_computation(), + compiler.assembler().get_label_constant(return_to_label) + ) + ), + return_to_label + ) + ); + + sequence_cc.release_registers(result); + + for (final ComputationCompiler cc: parameter_ccs) + { + cc.release_registers(result); + } + } + + @Override public void visit_sequence_jump ( final tonkadur.fate.v1.lang.instruction.SequenceJump n @@ -3574,6 +3647,72 @@ implements tonkadur.fate.v1.lang.meta.InstructionVisitor } @Override + public void visit_sequence_variable_jump + ( + final tonkadur.fate.v1.lang.instruction.SequenceVariableJump n + ) + throws Throwable + { + final ComputationCompiler sequence_cc; + final List<ComputationCompiler> parameter_ccs; + final List<Computation> parameters; + + sequence_cc = new ComputationCompiler(compiler); + parameter_ccs = new ArrayList<ComputationCompiler>(); + parameters = new ArrayList<Computation>(); + + n.get_sequence().get_visited_by(sequence_cc); + + if (sequence_cc.has_init()) + { + result.add(sequence_cc.get_init()); + } + + for + ( + final tonkadur.fate.v1.lang.meta.Computation param: n.get_parameters() + ) + { + final ComputationCompiler cc; + + cc = new ComputationCompiler(compiler); + + param.get_visited_by(cc); + + if (cc.has_init()) + { + result.add(cc.get_init()); + } + + parameters.add(cc.get_computation()); + parameter_ccs.add(cc); + } + + result.addAll(compiler.registers().store_parameters(parameters)); + + for (final ComputationCompiler cc: parameter_ccs) + { + cc.release_registers(result); + } + + /* Terminate current context */ + result.addAll + ( + compiler.registers().get_finalize_context_instructions() + ); + + result.addAll + ( + compiler.registers().get_jump_to_context_instructions + ( + sequence_cc.get_computation() + ) + ); + + sequence_cc.release_registers(result); + } + + @Override public void visit_set_value ( final tonkadur.fate.v1.lang.instruction.SetValue n diff --git a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/TypeCompiler.java b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/TypeCompiler.java index f820d7b..af4f703 100644 --- a/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/TypeCompiler.java +++ b/src/core/src/tonkadur/wyrd/v1/compiler/fate/v1/TypeCompiler.java @@ -68,6 +68,11 @@ public class TypeCompiler return Type.INT; } + if (fate_type instanceof tonkadur.fate.v1.lang.type.SequenceType) + { + return Type.INT; + } + fate_type = fate_type.get_base_type(); if (fate_type.equals(tonkadur.fate.v1.lang.type.Type.BOOL)) @@ -181,6 +186,11 @@ public class TypeCompiler return MapType.MAP_TO_INT; } + if (fate_content_type instanceof tonkadur.fate.v1.lang.type.SequenceType) + { + return MapType.MAP_TO_INT; + } + return new MapType(compile(compiler, fate_content_type)); } } |