Start Linking

src/be/jeffcheasey88/peeratcode/parser/Bag.java

@@ -1,5 +1,6 @@
 package be.jeffcheasey88.peeratcode.parser;
 
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -45,6 +46,6 @@ public class Bag{
 		String map = "";
 		for(Entry<String, Object> entry : this.map.entrySet()) map+=","+(entry.getKey())+" -> "+entry.getValue();
 		if(map.length() > 0) map = map.substring(1);
-		return "([bag] | value="+value+" | map="+map+" )";
+		return "([bag] | value="+value+" | map["+Arrays.toString(this.map.keySet().toArray())+"]="+map+" )";
 	}
 }

src/be/jeffcheasey88/peeratcode/parser/state/generator/ParserComposantGenerator.java

@@ -5,6 +5,8 @@ import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -17,7 +19,10 @@ import be.jeffcheasey88.peeratcode.parser.Tokenizer;
 import be.jeffcheasey88.peeratcode.parser.state.RedirectStateTree;
 import be.jeffcheasey88.peeratcode.parser.state.StateTree;
 import be.jeffcheasey88.peeratcode.parser.state.generator.ParserComposantGenerator.Element.SynthaxeComposant;
+import be.jeffcheasey88.peeratcode.parser.state.generator.ParserComposantGenerator.Element.SynthaxeComposant.Composant;
 import be.jeffcheasey88.peeratcode.parser.state.generator.ParserComposantGenerator.Element.SynthaxeComposant.Composant.ComposantCall;
+import be.jeffcheasey88.peeratcode.parser.state.generator.ParserComposantGenerator.Element.SynthaxeComposant.Composant.LinkedComposant;
+import be.jeffcheasey88.peeratcode.parser.state.generator.ParserComposantGenerator.Element.SynthaxeComposant.Composant.MultipleWayComposant;
 import be.jeffcheasey88.peeratcode.parser.state.generator.ParserComposantGenerator.Element.SynthaxeComposant.Composant.NamedElement;
 import be.jeffcheasey88.peeratcode.parser.state.generator.ParserComposantGenerator.Element.SynthaxeComposant.Composant.Redirection;
 import be.jeffcheasey88.peeratcode.parser.state.generator.ParserComposantGenerator.Element.SynthaxeComposant.Composant.Validator;
@@ -106,7 +111,9 @@ public class ParserComposantGenerator {
 						(t) -> t.getType().equals(TokenType.NAME),
 						(bag, t) -> bag.set(t)))
 					.then((v) -> v.validate((t) -> t.getValue().equals(":")))
-					.end((composant, bag) -> composant);
+					.end((composant, bag) -> {
+						return composant;
+					});
 				
 				StateTree<Element> redirection = new StateTree<>();
 				redirection.then((v) -> v.validate((t) -> 
@@ -139,46 +146,103 @@ public class ParserComposantGenerator {
 					}))
 					.then((v) -> v.validate((t) -> t.getValue().equals(")")))
 					.end((composant, bag) -> {
+						System.out.println("\t"+composant);
 						System.out.println("\t"+bag);
 						return composant;
 					});
 				
-				operation.then(new RedirectStateTree<>(gotoValidator, (bag) -> "?"))
+				operation.then(new RedirectStateTree<>(gotoValidator, (bag) -> "goto"))
 				.then(operations);
 				
 				StateTree<Element> op_validator = operation.then(new RedirectStateTree<>(validator, (bag) -> "validator"));
-				op_validator.end((composant, bag) -> {
+				op_validator.<Element>end((composant, bag) -> {
-					return bag.<Bag>get("validator").<Element>get();
+					Element result = bag.<Bag>get("validator").<Element>get();
+					bag.set(result);
+					return new Composant();
 				}).then(op_childs);
-				op_validator.then(new RedirectStateTree<>(namedValidator, (bag) -> "namedValidator")).end((composant, bag) -> {
+				op_validator.then(new RedirectStateTree<>(namedValidator, (bag) -> "namedValidator")).<Element>end((composant, bag) -> {
-					bag.<Bag>get("namedValidator").<NamedElement>get().child = bag.<Bag>get("validator").<Validator>get();
+					NamedElement result = null;
-					return composant;
+					(result = bag.<Bag>get("namedValidator").<NamedElement>get()).child = bag.<Bag>get("validator").<Validator>get();
+					bag.set(result);
+					return new Composant();
 				}).then(op_childs);
 				
 				StateTree<Element> op_call = operation.then(new RedirectStateTree<>(methodCall, (bag) -> "methodCall"));
-				op_call.end((composant, bag) -> {
+				op_call.<Element>end((composant, bag) -> {
-					return bag.<Bag>get("methodCall").<Element>get();
+					Element result = bag.<Bag>get("methodCall").<Element>get();
+					bag.set(result);
+					return new Composant();
 				}).then(op_childs);
-				op_call.then(new RedirectStateTree<>(namedValidator, (bag) -> "namedValidator")).end((composant, bag) -> {
+				op_call.then(new RedirectStateTree<>(namedValidator, (bag) -> "namedValidator")).<Element>end((composant, bag) -> {
-					bag.<Bag>get("namedValidator").<NamedElement>get().child = bag.<Bag>get("methodCall").<Validator>get();
+					NamedElement result = null;
-					return composant;
+					(result = bag.<Bag>get("namedValidator").<NamedElement>get()).child = bag.<Bag>get("methodCall").<Validator>get();
+					bag.set(result);
+					return new Composant();
 				}).then(op_childs);
 				
 				StateTree<Element> op_redirect = operation.then(new RedirectStateTree<>(redirection, (bag) -> "redirection"));
-				op_redirect.end((composant, bag) -> {
+				op_redirect.<Element>end((composant, bag) -> {
-					return bag.<Bag>get("redirection").<Element>get();
+					Element result = bag.<Bag>get("redirection").<Element>get();
+					bag.set(result);
+					return new Composant();
 				}).then(op_childs);
-				op_redirect.then(new RedirectStateTree<>(namedValidator, (bag) -> "namedValidator")).end((composant, bag) -> {
+				op_redirect.then(new RedirectStateTree<>(namedValidator, (bag) -> "namedValidator")).<Element>end((composant, bag) -> {
-					bag.<Bag>get("namedValidator").<NamedElement>get().child = bag.<Bag>get("redirection").<Validator>get();
+					NamedElement result = null;
-					return composant;
+					(result = bag.<Bag>get("namedValidator").<NamedElement>get()).child = bag.<Bag>get("redirection").<Validator>get();
+					bag.set(result);
+					return new Composant();
 				}).then(op_childs);
 				
-				StateTree<Element> suit = operations.then(new RedirectStateTree<>(operation, (bag) -> "operation")).loop();
+				StateTree<Element> suit = operations.then(new RedirectStateTree<>(operation, (bag) ->  {
+					Integer count = bag.get("count");
+					if(count == null) count = 0;
+					bag.set("count", count+1);
+					return "operation"+count;
+				})).loop();
 				suit.then((v) -> v.validate((t) -> t.getValue().equals(",")))
-					.then(suit).end((composant, bag) -> composant);
+					.end((composant, bag) -> {
+						MultipleWayComposant way = ((Composant)composant).current;
+						
+						int count = bag.get("count");
+						LinkedComposant linked = new LinkedComposant();
+						for(int i = 0; i < count; i++){
+							Bag op = bag.get("operation"+i);
+							if(op.get() == null) continue;
+							linked.elements.add(op.get());
+						}
+						way.elements.add(linked);
+						System.out.println(",\t"+way);
+						return composant;
+					}).then(suit);
 				suit.then((v) -> v.validate((t) -> t.getValue().equals(";")))
-					.then(suit).end((composant, bag) -> composant);
+					.end((composant, bag) -> {
-				suit.end((composant, bag) -> composant);
+						MultipleWayComposant way = ((Composant)composant).current;
+						
+						int count = bag.get("count");
+						LinkedComposant linked = new LinkedComposant();
+						for(int i = 0; i < count; i++){
+							Bag op = bag.get("operation"+i);
+							if(op.get() == null) continue;
+							linked.elements.add(op.get());
+						}
+						way.elements.add(linked);
+						System.out.println(",\t"+way);
+						return composant;
+					}).then(suit);
+				suit.end((composant, bag) -> {
+					MultipleWayComposant way = ((Composant)composant).current;
+					
+					int count = bag.get("count");
+					LinkedComposant linked = new LinkedComposant();
+					for(int i = 0; i < count; i++){
+						Bag op = bag.get("operation"+i);
+						if(op.get() == null) continue;
+						linked.elements.add(op.get());
+					}
+					way.elements.add(linked);
+					System.out.println("none\t"+way);
+					return composant;
+				});
 				
 				StateTree<Element> main = new StateTree<>();
 				
@@ -186,11 +250,9 @@ public class ParserComposantGenerator {
 						(token) -> token.getType().equals(TokenType.NAME),
 						(bag, token) -> bag.set(token)
 				));
-				composant.then(new RedirectStateTree<>(op_childs, (bag) -> "content"))
+				composant.<Element>end((element, bag) -> {
-				.end((element, bag) -> {
+					return new Composant(bag);
-					System.out.println(bag);
+				}).then(new RedirectStateTree<>(op_childs, (bag) -> "content"))
-					return element;
-				})
 				.then(composant);
 				
 				
@@ -223,6 +285,11 @@ public class ParserComposantGenerator {
 			this.composants.put(name, composant);
 		}
 		
+		@Override
+		public String toString(){
+			return "SynthaxeComposant";
+		}
+		
 		public static class Composant extends Element{
 			
 			private String title;
@@ -231,8 +298,48 @@ public class ParserComposantGenerator {
 			private List<Element> declared;
 			private List<Element> next;
 			
+			private MultipleWayComposant current;
+			
 			public Composant(){
+				current = new MultipleWayComposant();
+			}
+			
+			public Composant(Bag bag){
+				this();
+				this.title = bag.<Token>get().getValue();
+			}
+			
+			@Override
+			public String toString(){
+				return title+"(";
+			}
+			
+			public static class LinkedComposant extends Element{
 				
+				private List<Element> elements;
+				
+				public LinkedComposant(){
+					this.elements = new ArrayList<>();
+				}
+				
+				@Override
+				public String toString(){
+					return "["+Arrays.toString(elements.toArray())+"]";
+				}
+			}
+			
+			public static class MultipleWayComposant extends Element{
+				
+				private List<Element> elements;
+				
+				public MultipleWayComposant(){
+					this.elements = new ArrayList<>();
+				}
+				
+				@Override
+				public String toString(){
+					return "<"+Arrays.toString(elements.toArray())+">";
+				}
 			}
 			
 				public static class Validator extends Element{