| summaryrefslogtreecommitdiff |
diff options
8 files changed, 281 insertions, 306 deletions
diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/AddElement.java b/src/core/src/tonkadur/fate/v1/lang/instruction/AddElement.java index c60b87d..791e193 100644 --- a/src/core/src/tonkadur/fate/v1/lang/instruction/AddElement.java +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/AddElement.java @@ -1,19 +1,12 @@ package tonkadur.fate.v1.lang.instruction; -import tonkadur.error.ErrorManager; - import tonkadur.parser.Origin; - -import tonkadur.fate.v1.error.ConflictingTypeException; -import tonkadur.fate.v1.error.IncomparableTypeException; -import tonkadur.fate.v1.error.InvalidTypeException; - -import tonkadur.fate.v1.lang.type.CollectionType; -import tonkadur.fate.v1.lang.type.Type; +import tonkadur.parser.ParsingError; import tonkadur.fate.v1.lang.meta.InstructionVisitor; import tonkadur.fate.v1.lang.meta.Instruction; import tonkadur.fate.v1.lang.meta.Computation; +import tonkadur.fate.v1.lang.meta.RecurrentChecks; public class AddElement extends Instruction { @@ -50,72 +43,9 @@ public class AddElement extends Instruction final Computation element, final Computation collection ) - throws - InvalidTypeException, - ConflictingTypeException, - IncomparableTypeException + throws ParsingError { - final Type hint; - final Type collection_type; - final CollectionType collection_true_type; - final Type collection_element_type; - - collection_type = collection.get_type(); - - if (!(collection_type instanceof CollectionType)) - { - ErrorManager.handle - ( - new InvalidTypeException - ( - collection.get_origin(), - collection.get_type(), - Type.COLLECTION_TYPES - ) - ); - } - - collection_true_type = (CollectionType) collection_type; - collection_element_type = collection_true_type.get_content_type(); - - if - ( - element.get_type().can_be_used_as(collection_element_type) - || - (element.get_type().try_merging_with(collection_element_type) != null) - ) - { - return new AddElement(origin, element, collection); - } - - ErrorManager.handle - ( - new ConflictingTypeException - ( - element.get_origin(), - element.get_type(), - collection_element_type - ) - ); - - hint = - (Type) element.get_type().generate_comparable_to - ( - collection_element_type - ); - - if (hint.equals(Type.ANY)) - { - ErrorManager.handle - ( - new IncomparableTypeException - ( - element.get_origin(), - element.get_type(), - collection_element_type - ) - ); - } + RecurrentChecks.assert_is_a_collection_of(collection, element); return new AddElement(origin, element, collection); } diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/AddElementAt.java b/src/core/src/tonkadur/fate/v1/lang/instruction/AddElementAt.java index 4cd192f..156b54f 100644 --- a/src/core/src/tonkadur/fate/v1/lang/instruction/AddElementAt.java +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/AddElementAt.java @@ -1,21 +1,14 @@ package tonkadur.fate.v1.lang.instruction; -import java.util.Collections; - -import tonkadur.error.ErrorManager; - import tonkadur.parser.Origin; +import tonkadur.parser.ParsingError; -import tonkadur.fate.v1.error.ConflictingTypeException; -import tonkadur.fate.v1.error.IncomparableTypeException; -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; +import tonkadur.fate.v1.lang.meta.RecurrentChecks; public class AddElementAt extends Instruction { @@ -56,89 +49,10 @@ public class AddElementAt extends Instruction final Computation element, final Computation collection ) - throws - InvalidTypeException, - ConflictingTypeException, - IncomparableTypeException + throws ParsingError { - final Type hint; - final Type collection_type; - final CollectionType collection_true_type; - final Type collection_element_type; - - collection_type = collection.get_type(); - - if - ( - (!(collection_type instanceof CollectionType)) - || (((CollectionType) collection_type).is_set()) - ) - { - ErrorManager.handle - ( - new InvalidTypeException - ( - collection.get_origin(), - collection.get_type(), - Collections.singletonList(Type.LIST) - ) - ); - } - - if (!index.get_type().can_be_used_as(Type.INT)) - { - ErrorManager.handle - ( - new InvalidTypeException - ( - index.get_origin(), - index.get_type(), - Collections.singletonList(Type.INT) - ) - ); - } - - collection_true_type = (CollectionType) collection_type; - collection_element_type = collection_true_type.get_content_type(); - - if - ( - element.get_type().can_be_used_as(collection_element_type) - || - (element.get_type().try_merging_with(collection_element_type) != null) - ) - { - return new AddElementAt(origin, index, element, collection); - } - - ErrorManager.handle - ( - new ConflictingTypeException - ( - element.get_origin(), - element.get_type(), - collection_element_type - ) - ); - - hint = - (Type) element.get_type().generate_comparable_to - ( - collection_element_type - ); - - if (hint.equals(Type.ANY)) - { - ErrorManager.handle - ( - new IncomparableTypeException - ( - element.get_origin(), - element.get_type(), - collection_element_type - ) - ); - } + RecurrentChecks.assert_is_a_list_of(collection, element); + RecurrentChecks.assert_can_be_used_as(index, Type.INT); return new AddElementAt(origin, index, element, collection); } diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/AddElementsOf.java b/src/core/src/tonkadur/fate/v1/lang/instruction/AddElementsOf.java index 7409b2b..0b4f378 100644 --- a/src/core/src/tonkadur/fate/v1/lang/instruction/AddElementsOf.java +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/AddElementsOf.java @@ -1,19 +1,14 @@ package tonkadur.fate.v1.lang.instruction; -import tonkadur.error.ErrorManager; - import tonkadur.parser.Origin; - -import tonkadur.fate.v1.error.ConflictingTypeException; -import tonkadur.fate.v1.error.IncomparableTypeException; -import tonkadur.fate.v1.error.InvalidTypeException; +import tonkadur.parser.ParsingError; 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.Reference; +import tonkadur.fate.v1.lang.meta.RecurrentChecks; public class AddElementsOf extends Instruction { @@ -50,77 +45,17 @@ public class AddElementsOf extends Instruction final Reference other_collection, final Reference collection ) - throws - InvalidTypeException, - ConflictingTypeException, - IncomparableTypeException + throws ParsingError { - final Type hint; - final Type collection_type, other_collection_type; - - collection_type = collection.get_type(); - other_collection_type = other_collection.get_type(); - - if (!(collection_type instanceof CollectionType)) - { - ErrorManager.handle - ( - new InvalidTypeException - ( - collection.get_origin(), - collection_type, - Type.COLLECTION_TYPES - ) - ); - } - - if (!(other_collection_type instanceof CollectionType)) - { - ErrorManager.handle - ( - new InvalidTypeException - ( - other_collection.get_origin(), - other_collection_type, - Type.COLLECTION_TYPES - ) - ); - } - - if (other_collection_type.can_be_used_as(collection_type)) - { - return new AddElementsOf(origin, other_collection, collection); - } - - ErrorManager.handle + RecurrentChecks.assert_is_a_collection(collection); + RecurrentChecks.assert_is_a_collection(other_collection); + RecurrentChecks.assert_can_be_used_as ( - new ConflictingTypeException - ( - other_collection.get_origin(), - other_collection_type, - collection_type - ) + other_collection.get_origin(), + ((CollectionType) other_collection.get_type()).get_content_type(), + ((CollectionType) collection.get_type()).get_content_type() ); - hint = - (Type) other_collection.get_type().generate_comparable_to - ( - collection_type - ); - - if (hint.equals(Type.ANY)) - { - ErrorManager.handle - ( - new IncomparableTypeException - ( - other_collection.get_origin(), - other_collection_type, - collection_type - ) - ); - } - return new AddElementsOf(origin, other_collection, collection); } 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 c4bf9a9..d487d38 100644 --- a/src/core/src/tonkadur/fate/v1/lang/instruction/Assert.java +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/Assert.java @@ -1,19 +1,15 @@ 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.Type; +import tonkadur.parser.ParsingError; 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; +import tonkadur.fate.v1.lang.meta.RecurrentChecks; + +import tonkadur.fate.v1.lang.type.Type; public class Assert extends Instruction { @@ -50,20 +46,9 @@ public class Assert extends Instruction final Computation condition, final RichTextNode message ) - throws InvalidTypeException + throws ParsingError { - if (!condition.get_type().get_base_type().equals(Type.BOOL)) - { - ErrorManager.handle - ( - new InvalidTypeException - ( - condition.get_origin(), - condition.get_type(), - Collections.singleton(Type.BOOL) - ) - ); - } + RecurrentChecks.assert_can_be_used_as(condition, Type.BOOL); return new Assert(origin, condition, message); } diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/Clear.java b/src/core/src/tonkadur/fate/v1/lang/instruction/Clear.java index fd8090f..fe8943f 100644 --- a/src/core/src/tonkadur/fate/v1/lang/instruction/Clear.java +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/Clear.java @@ -1,17 +1,12 @@ package tonkadur.fate.v1.lang.instruction; -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.parser.ParsingError; import tonkadur.fate.v1.lang.meta.InstructionVisitor; import tonkadur.fate.v1.lang.meta.Instruction; import tonkadur.fate.v1.lang.meta.Computation; +import tonkadur.fate.v1.lang.meta.RecurrentChecks; public class Clear extends Instruction { @@ -44,26 +39,9 @@ public class Clear extends Instruction final Origin origin, final Computation collection ) - throws InvalidTypeException + throws ParsingError { - if - ( - !Type.COLLECTION_TYPES.contains - ( - collection.get_type().get_act_as_type() - ) - ) - { - ErrorManager.handle - ( - new InvalidTypeException - ( - collection.get_origin(), - collection.get_type(), - Type.COLLECTION_TYPES - ) - ); - } + RecurrentChecks.assert_is_a_collection(collection); return new Clear(origin, collection); } diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/CondInstruction.java b/src/core/src/tonkadur/fate/v1/lang/instruction/CondInstruction.java index 0236a7e..b7eb9bb 100644 --- a/src/core/src/tonkadur/fate/v1/lang/instruction/CondInstruction.java +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/CondInstruction.java @@ -1,21 +1,18 @@ package tonkadur.fate.v1.lang.instruction; -import java.util.Collections; import java.util.List; -import tonkadur.error.ErrorManager; - import tonkadur.functional.Cons; import tonkadur.parser.Origin; - -import tonkadur.fate.v1.error.InvalidTypeException; +import tonkadur.parser.ParsingError; 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; +import tonkadur.fate.v1.lang.meta.RecurrentChecks; public class CondInstruction extends Instruction { @@ -48,22 +45,11 @@ public class CondInstruction extends Instruction final Origin origin, final List<Cons<Computation, Instruction>> branches ) - throws InvalidTypeException + throws ParsingError { for (final Cons<Computation, Instruction> branch: branches) { - if (!branch.get_car().get_type().get_base_type().equals(Type.BOOL)) - { - ErrorManager.handle - ( - new InvalidTypeException - ( - branch.get_car().get_origin(), - branch.get_car().get_type(), - Collections.singleton(Type.BOOL) - ) - ); - } + RecurrentChecks.assert_can_be_used_as(branch.get_car(), Type.BOOL); } return new CondInstruction(origin, branches); diff --git a/src/core/src/tonkadur/fate/v1/lang/instruction/Map.java b/src/core/src/tonkadur/fate/v1/lang/instruction/Map.java index 228423c..2123ee4 100644 --- a/src/core/src/tonkadur/fate/v1/lang/instruction/Map.java +++ b/src/core/src/tonkadur/fate/v1/lang/instruction/Map.java @@ -9,8 +9,6 @@ import tonkadur.parser.ParsingError; import tonkadur.error.ErrorManager; -import tonkadur.fate.v1.error.IncompatibleTypeException; -import tonkadur.fate.v1.error.IncomparableTypeException; import tonkadur.fate.v1.error.InvalidArityException; import tonkadur.fate.v1.error.InvalidTypeException; diff --git a/src/core/src/tonkadur/fate/v1/lang/meta/RecurrentChecks.java b/src/core/src/tonkadur/fate/v1/lang/meta/RecurrentChecks.java new file mode 100644 index 0000000..da9c233 --- /dev/null +++ b/src/core/src/tonkadur/fate/v1/lang/meta/RecurrentChecks.java @@ -0,0 +1,249 @@ +package tonkadur.fate.v1.lang.meta; + +import java.util.Collections; + +import tonkadur.error.ErrorManager; + +import tonkadur.parser.Origin; +import tonkadur.parser.ParsingError; + +import tonkadur.fate.v1.error.ConflictingTypeException; +import tonkadur.fate.v1.error.IncomparableTypeException; +import tonkadur.fate.v1.error.InvalidTypeException; + +import tonkadur.fate.v1.lang.type.CollectionType; +import tonkadur.fate.v1.lang.type.Type; + +public class RecurrentChecks +{ + /* Utility Class */ + private RecurrentChecks () { } + + public static Type assert_can_be_used_as + ( + final Computation a, + final Computation b + ) + throws ParsingError + { + return assert_can_be_used_as(a.get_origin(), a.get_type(), b.get_type()); + } + + public static Type assert_can_be_used_as + ( + final Computation a, + final Type t + ) + throws ParsingError + { + return assert_can_be_used_as(a.get_origin(), a.get_type(), t); + } + + public static Type assert_can_be_used_as + ( + final Origin o, + final Type a, + final Type b + ) + throws ParsingError + { + Type result; + + if (a.can_be_used_as(b)) + { + return b; + } + + result = a.try_merging_with(b); + + if (result != null) + { + return result; + } + + ErrorManager.handle(new ConflictingTypeException(o, a, b)); + + result = (Type) a.generate_comparable_to(b); + + if (result.equals(Type.ANY)) + { + ErrorManager.handle(new IncomparableTypeException(o, a, b)); + } + + return result; + } + + public static void assert_is_a_list (final Computation a) + throws ParsingError + { + assert_is_a_list(a.get_origin(), a.get_type()); + } + + public static void assert_is_a_list (final Origin o, final Type t) + throws ParsingError + { + if + ( + (!(t instanceof CollectionType)) + || ((CollectionType) t).is_set() + ) + { + ErrorManager.handle + ( + new InvalidTypeException + ( + o, + t, + Collections.singletonList(Type.LIST) + ) + ); + } + } + + public static void assert_is_a_set (final Computation a) + throws ParsingError + { + assert_is_a_set(a.get_origin(), a.get_type()); + } + + public static void assert_is_a_set (final Origin o, final Type t) + throws ParsingError + { + if + ( + (!(t instanceof CollectionType)) + || !((CollectionType) t).is_set() + ) + { + ErrorManager.handle + ( + new InvalidTypeException + ( + o, + t, + Collections.singletonList(Type.SET) + ) + ); + } + } + + public static void assert_is_a_collection (final Computation a) + throws ParsingError + { + assert_is_a_set(a.get_origin(), a.get_type()); + } + + public static void assert_is_a_collection (final Origin o, final Type t) + throws ParsingError + { + if + ( + (!(t instanceof CollectionType)) + ) + { + ErrorManager.handle + ( + new InvalidTypeException + ( + o, + t, + Type.COLLECTION_TYPES + ) + ); + } + } + + public static void assert_is_a_list_of (final Computation c, final Computation e) + throws ParsingError + { + assert_is_a_list_of + ( + c.get_origin(), + c.get_type(), + e.get_origin(), + e.get_type() + ); + } + + public static void assert_is_a_list_of + ( + final Origin oc, + final Type c, + final Origin oe, + final Type e + ) + throws ParsingError + { + assert_is_a_list(oc, c); + assert_can_be_used_as + ( + oe, + e, + ((CollectionType) c).get_content_type() + ); + } + + public static void assert_is_a_set_of (final Computation c, final Computation e) + throws ParsingError + { + assert_is_a_set_of + ( + c.get_origin(), + c.get_type(), + e.get_origin(), + e.get_type() + ); + } + + public static void assert_is_a_set_of + ( + final Origin oc, + final Type c, + final Origin oe, + final Type e + ) + throws ParsingError + { + assert_is_a_set(oc, c); + assert_can_be_used_as + ( + oe, + e, + ((CollectionType) c).get_content_type() + ); + } + + public static void assert_is_a_collection_of + ( + final Computation c, + final Computation e + ) + throws ParsingError + { + assert_is_a_collection_of + ( + c.get_origin(), + c.get_type(), + e.get_origin(), + e.get_type() + ); + } + + public static void assert_is_a_collection_of + ( + final Origin oc, + final Type c, + final Origin oe, + final Type e + ) + throws ParsingError + { + assert_is_a_collection(oc, c); + assert_can_be_used_as + ( + oe, + e, + ((CollectionType) c).get_content_type() + ); + } +} |