diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml
new file mode 100644
index 0000000000000000000000000000000000000000..a55e7a179bde3e4e772c29c0c85e53354aa54618
--- /dev/null
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+ <state>
+ <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
+ </state>
+</component>
\ No newline at end of file
diff --git a/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/GraphBuilder.java b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/GraphBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..3673142aaa8a956b55608e6ce54c9f9541707a59
--- /dev/null
+++ b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/GraphBuilder.java
@@ -0,0 +1,43 @@
+package fr.tetras_libre.unltools.unl.builders;
+
+import fr.tetras_libre.unltools.unl.Graph;
+
+import java.util.function.Function;
+
+public class GraphBuilder {
+ Graph graph;
+
+ private GraphBuilder() {
+ this.graph = new Graph();
+ }
+
+ public static IBuild graph() {
+ return new GraphBuilder.Builder();
+ }
+
+ public interface IBuild {
+ IBuild addGraphRelation(Function<GraphRelationBuilder.RequiredLabel, GraphRelationBuilder.IBuild> c);
+
+ Graph buildGraph();
+ }
+
+ private static class Builder implements IBuild {
+ private final GraphBuilder instance;
+
+ public Builder() {
+ instance = new GraphBuilder();
+ }
+
+ @Override
+ public IBuild addGraphRelation(Function<GraphRelationBuilder.RequiredLabel, GraphRelationBuilder.IBuild> c) {
+ instance.graph.add(c.apply(GraphRelationBuilder.createBuilder()).buildGraphRelation());
+ return this;
+ }
+
+ @Override
+ public Graph buildGraph() {
+ return instance.graph;
+ }
+ }
+
+}
diff --git a/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/GraphRelationBuilder.java b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/GraphRelationBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..85ce4803b3750c363791fa5ae779c9c3346fa151
--- /dev/null
+++ b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/GraphRelationBuilder.java
@@ -0,0 +1,94 @@
+package fr.tetras_libre.unltools.unl.builders;
+
+import fr.tetras_libre.unltools.unl.GraphNode;
+import fr.tetras_libre.unltools.unl.GraphRelation;
+
+import java.util.function.Function;
+
+
+public class GraphRelationBuilder {
+ private String label;
+ private String graphReference;
+ private GraphNode node1;
+ private GraphNode node2;
+
+ public static RequiredLabel createBuilder() {
+ return new GraphRelationBuilder.Builder();
+ }
+
+
+ public interface RequiredLabel {
+ OptionalGraphReference label(String label);
+ }
+
+ public interface OptionalGraphReference {
+ RequiredLeftNode reference(String nodeName);
+
+ RequiredLeftNode noReference();
+ }
+
+ public interface RequiredLeftNode {
+ RequiredRightNode leftNode(Function<UniversalWordNodeBuilder.IRequiredUniversalWord, UniversalWordNodeBuilder.IBuild> f);
+
+ IBuild rightSubGraphNode(Function<SubGraphReferenceNodeBuilder.IRequiredReferenceNumber, SubGraphReferenceNodeBuilder.IBuild> f);
+ }
+
+ public interface RequiredRightNode {
+ IBuild rightNode(Function<UniversalWordNodeBuilder.IRequiredUniversalWord, UniversalWordNodeBuilder.IBuild> f);
+
+ IBuild rightSubGraphNode(Function<SubGraphReferenceNodeBuilder.IRequiredReferenceNumber, SubGraphReferenceNodeBuilder.IBuild> f);
+ }
+
+ public interface IBuild {
+ GraphRelation buildGraphRelation();
+ }
+
+ private static class Builder implements RequiredLabel, OptionalGraphReference, RequiredLeftNode, RequiredRightNode, IBuild {
+ private final GraphRelationBuilder instance;
+
+ public Builder() {
+ instance = new GraphRelationBuilder();
+ }
+
+ @Override
+ public RequiredLeftNode reference(String nodeName) {
+ instance.graphReference = nodeName;
+ return this;
+ }
+
+ @Override
+ public RequiredLeftNode noReference() {
+ instance.graphReference = "";
+ return this;
+ }
+
+ @Override
+ public RequiredRightNode leftNode(Function<UniversalWordNodeBuilder.IRequiredUniversalWord, UniversalWordNodeBuilder.IBuild> f) {
+ this.instance.node1 = f.apply(UniversalWordNodeBuilder.createBuilder()).buildUniversalWordNode();
+ return this;
+ }
+
+ @Override
+ public IBuild rightSubGraphNode(Function<SubGraphReferenceNodeBuilder.IRequiredReferenceNumber, SubGraphReferenceNodeBuilder.IBuild> f) {
+ instance.node2 = f.apply(SubGraphReferenceNodeBuilder.createBuilder()).buildSubGraphReferenceNode();
+ return this;
+ }
+
+ @Override
+ public GraphRelation buildGraphRelation() {
+ return new GraphRelation(instance.node1, instance.node2, instance.label, instance.graphReference);
+ }
+
+ @Override
+ public OptionalGraphReference label(String label) {
+ instance.label = label;
+ return this;
+ }
+
+ @Override
+ public IBuild rightNode(Function<UniversalWordNodeBuilder.IRequiredUniversalWord, UniversalWordNodeBuilder.IBuild> f) {
+ instance.node2 = f.apply(UniversalWordNodeBuilder.createBuilder()).buildUniversalWordNode();
+ return this;
+ }
+ }
+}
diff --git a/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/RestrictionBuilder.java b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/RestrictionBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..934e5186671ef5c114ecadf6624cd036c013cf28
--- /dev/null
+++ b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/RestrictionBuilder.java
@@ -0,0 +1,105 @@
+package fr.tetras_libre.unltools.unl.builders;
+
+import fr.tetras_libre.unltools.unl.Restriction;
+import fr.tetras_libre.unltools.unl.UniversalWord;
+
+public class RestrictionBuilder {
+ private String label;
+ private char orientation;
+ private UniversalWord universalWord;
+
+ private RestrictionBuilder() {
+ label = "";
+ orientation = ' ';
+ universalWord = null;
+ }
+
+ public interface IRequiredLabel {
+ IOrientation label(String label);
+ }
+
+ public static Restriction simpleRestriction(String label, RestrictionOrientation orientation, String headwordLabel) {
+ return RestrictionBuilder
+ .createBuilder()
+ .label(label)
+ .withOrientation(orientation)
+ .universalWord(UniversalWordBuilder.simpleUniversalWord(headwordLabel))
+ .buildRestriction();
+ }
+
+ public static IRequiredLabel createBuilder() {
+ return new RestrictionBuilder.Builder();
+ }
+
+ public static Restriction ternaryTransitiveRestriction(String label1, String label2, String label3, RestrictionOrientation orientation) {
+ return RestrictionBuilder
+ .createBuilder()
+ .label(label1)
+ .withOrientation(orientation)
+ .universalWord(
+ UniversalWordBuilder
+ .createBuilder()
+ .headWord(label2)
+ .addSimpleRestriction(label1, orientation, label3 )
+ .buildUniversalWord()
+ )
+ .buildRestriction();
+ }
+
+ public interface IOrientation {
+ IRequiredUniversalWord withOrientation(RestrictionOrientation orientation);
+ }
+
+ public interface IRequiredUniversalWord {
+ IBuild universalWord(UniversalWord universalWord);
+ }
+
+ public interface IBuild {
+ Restriction buildRestriction();
+ }
+
+ private static class Builder implements IRequiredLabel, IRequiredUniversalWord, IOrientation, IBuild {
+ private final RestrictionBuilder instance;
+
+ public Builder(){
+ instance = new RestrictionBuilder();
+ }
+
+ @Override
+ public IBuild universalWord(UniversalWord universalWord) {
+ instance.universalWord = universalWord;
+ return this;
+ }
+
+ @Override
+ public IRequiredUniversalWord withOrientation(RestrictionOrientation orientation) {
+ switch (orientation) {
+ case Left:
+ instance.orientation = '<';
+ break;
+ case None:
+ instance.orientation = ' ';
+ break;
+ case Right:
+ instance.orientation = '>';
+ break;
+ }
+
+ return this;
+ }
+
+ @Override
+ public Restriction buildRestriction() {
+ return new Restriction(instance.label, instance.orientation, instance.universalWord);
+ }
+
+ @Override
+ public IOrientation label(String label) {
+ if(null == label)
+ throw new IllegalArgumentException();
+ instance.label = label;
+
+ return this;
+ }
+ }
+}
diff --git a/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/RestrictionOrientation.java b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/RestrictionOrientation.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d61c1a581e999c7d4694e826ce06ed67101bc2e
--- /dev/null
+++ b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/RestrictionOrientation.java
@@ -0,0 +1,7 @@
+package fr.tetras_libre.unltools.unl.builders;
+
+public enum RestrictionOrientation {
+ None,
+ Right,
+ Left
+}
diff --git a/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/SubGraphReferenceNodeBuilder.java b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/SubGraphReferenceNodeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d8193e040d75c87fbeeeb82ce0fd01ac7222b14
--- /dev/null
+++ b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/SubGraphReferenceNodeBuilder.java
@@ -0,0 +1,61 @@
+package fr.tetras_libre.unltools.unl.builders;
+
+import fr.tetras_libre.unltools.unl.SubGraphReferenceNode;
+
+import java.util.HashSet;
+
+public class SubGraphReferenceNodeBuilder {
+ private String referenceNumber;
+ private HashSet<String> attributes;
+
+ public static IRequiredReferenceNumber createBuilder()
+ {
+ return new SubGraphReferenceNodeBuilder.Builder();
+ }
+
+ private SubGraphReferenceNodeBuilder() {
+ referenceNumber = null;
+ attributes = new HashSet<>();
+ }
+
+ public interface IRequiredReferenceNumber {
+ IBuild referenceNumber(String referenceNumber);
+ }
+
+ public interface IBuild {
+ IBuild addAttribute(String attribute);
+
+ SubGraphReferenceNode buildSubGraphReferenceNode();
+ }
+
+ private static class Builder implements IRequiredReferenceNumber, IBuild {
+ SubGraphReferenceNodeBuilder instance;
+
+ public Builder() {
+ instance = new SubGraphReferenceNodeBuilder();
+ }
+
+ @Override
+ public IBuild referenceNumber(String referenceNumber) {
+ if (null == referenceNumber || referenceNumber.isBlank())
+ throw new IllegalArgumentException();
+
+ this.instance.referenceNumber = referenceNumber;
+
+ return this;
+ }
+
+ @Override
+ public IBuild addAttribute(String attribute) {
+ if (null != attribute && !attribute.isBlank())
+ this.instance.attributes.add(attribute);
+
+ return this;
+ }
+
+ @Override
+ public SubGraphReferenceNode buildSubGraphReferenceNode() {
+ return new SubGraphReferenceNode(instance.referenceNumber, instance.attributes);
+ }
+ }
+}
diff --git a/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/UniversalWordBuilder.java b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/UniversalWordBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..b6bb120e7701a3eaea9acd64c55adc5532da697a
--- /dev/null
+++ b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/UniversalWordBuilder.java
@@ -0,0 +1,80 @@
+package fr.tetras_libre.unltools.unl.builders;
+
+import fr.tetras_libre.unltools.unl.Restriction;
+import fr.tetras_libre.unltools.unl.UniversalWord;
+
+import java.util.TreeSet;
+import java.util.function.Function;
+
+public class UniversalWordBuilder {
+ private final TreeSet<Restriction> restrictions;
+ private String headWord;
+
+ private UniversalWordBuilder() {
+ restrictions = new TreeSet<>();
+ }
+
+ public static IRequiredHeadWord createBuilder() {
+ return new UniversalWordBuilder.Builder();
+ }
+
+ public static UniversalWord simpleUniversalWord(String headWord) {
+ return UniversalWordBuilder.createBuilder()
+ .headWord(headWord)
+ .buildUniversalWord();
+ }
+
+ public interface IBuild {
+
+ IBuild addRestriction(Function<RestrictionBuilder.IRequiredLabel, RestrictionBuilder.IBuild> f);
+
+ IBuild addSimpleRestriction(String label1, RestrictionOrientation orientation, String label2);
+
+ IBuild addTernaryTransitiveRestriction(String firstLabel, String secondLabel, String thirdLabel, RestrictionOrientation orientation);
+
+ UniversalWord buildUniversalWord();
+ }
+
+ public interface IRequiredHeadWord {
+ IBuild headWord(String headword);
+ }
+
+ private static class Builder implements IRequiredHeadWord, IBuild {
+ private final UniversalWordBuilder instance;
+
+ Builder() {
+ instance = new UniversalWordBuilder();
+ }
+
+ @Override
+ public IBuild addRestriction(Function<RestrictionBuilder.IRequiredLabel, RestrictionBuilder.IBuild> f) {
+ instance.restrictions.add(f.apply(RestrictionBuilder.createBuilder()).buildRestriction());
+ return this;
+ }
+
+ @Override
+ public IBuild addSimpleRestriction(String label1, RestrictionOrientation orientation, String label2) {
+ instance.restrictions.add(RestrictionBuilder.simpleRestriction(label1, orientation, label2));
+ return this;
+ }
+
+ @Override
+ public IBuild addTernaryTransitiveRestriction(String firstLabel, String secondLabel, String thirdLabel, RestrictionOrientation orientation) {
+ instance.restrictions.add(RestrictionBuilder.ternaryTransitiveRestriction(firstLabel, secondLabel, thirdLabel, orientation));
+ return this;
+ }
+
+ @Override
+ public UniversalWord buildUniversalWord() {
+ return new UniversalWord(instance.headWord, instance.restrictions);
+ }
+
+ @Override
+ public IBuild headWord(String headword) {
+ if (null == headword)
+ throw new IllegalArgumentException();
+ instance.headWord = headword;
+ return this;
+ }
+ }
+}
diff --git a/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/UniversalWordNodeBuilder.java b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/UniversalWordNodeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..77021800087bc9adb62bc2c2195a145678d698b7
--- /dev/null
+++ b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/UniversalWordNodeBuilder.java
@@ -0,0 +1,80 @@
+package fr.tetras_libre.unltools.unl.builders;
+
+import fr.tetras_libre.unltools.unl.UniversalWord;
+import fr.tetras_libre.unltools.unl.UniversalWordNode;
+
+import java.util.HashSet;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class UniversalWordNodeBuilder {
+ private final HashSet<String> attributes;
+ private UniversalWord universalWord;
+ private String instanceNumber;
+
+ private UniversalWordNodeBuilder() {
+ this.attributes = new HashSet<>();
+ this.instanceNumber = "";
+ }
+
+ public static IRequiredUniversalWord createBuilder() {
+ return new UniversalWordNodeBuilder.Builder();
+ }
+
+ public interface IRequiredUniversalWord {
+ IBuild universalWord(Function<UniversalWordBuilder.IRequiredHeadWord, UniversalWordBuilder.IBuild> f);
+
+ IBuild simpleUniversalWord(Supplier<String> s);
+ }
+
+ public interface IBuild {
+ IBuild addAttribute(String attribute);
+
+ IBuild instanceNumber(String nodeReference);
+
+ UniversalWordNode buildUniversalWordNode();
+ }
+
+ private static class Builder implements IRequiredUniversalWord, IBuild {
+ private final UniversalWordNodeBuilder instance;
+
+ public Builder() {
+ this.instance = new UniversalWordNodeBuilder();
+ }
+
+ @Override
+ public IBuild addAttribute(String attribute) {
+ if (null != attribute
+ && !attribute.isBlank())
+ this.instance.attributes.add(attribute);
+
+ return this;
+ }
+
+ @Override
+ public IBuild instanceNumber(String nodeReference) {
+ if(null == nodeReference){
+ throw new IllegalArgumentException();
+ }
+ this.instance.instanceNumber = nodeReference;
+ return this;
+ }
+
+ @Override
+ public UniversalWordNode buildUniversalWordNode() {
+ return new UniversalWordNode(instance.universalWord, instance.attributes, instance.instanceNumber);
+ }
+
+ @Override
+ public IBuild universalWord(Function<UniversalWordBuilder.IRequiredHeadWord, UniversalWordBuilder.IBuild> f) {
+ instance.universalWord = f.apply(UniversalWordBuilder.createBuilder()).buildUniversalWord();
+ return this;
+ }
+
+ @Override
+ public IBuild simpleUniversalWord(Supplier<String> s) {
+ instance.universalWord = UniversalWordBuilder.simpleUniversalWord(s.get());
+ return this;
+ }
+ }
+}
diff --git a/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/UnlDocumentNodeBuilder.java b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/UnlDocumentNodeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..2db0555bdd5bebe449d391aebdd883eb481b3f33
--- /dev/null
+++ b/unl-tools-core/src/main/java/fr/tetras_libre/unltools/unl/builders/UnlDocumentNodeBuilder.java
@@ -0,0 +1,74 @@
+package fr.tetras_libre.unltools.unl.builders;
+
+import fr.tetras_libre.unltools.unl.Graph;
+import fr.tetras_libre.unltools.unl.UnlDocumentNode;
+import fr.tetras_libre.unltools.unl.UnlDocumentNodeType;
+
+import java.util.function.Function;
+
+public class UnlDocumentNodeBuilder {
+ private UnlDocumentNodeType unlDocumentNodeType;
+ private String docNodeLabel;
+ private Graph graph;
+
+ private UnlDocumentNodeBuilder() {
+ docNodeLabel = null;
+ graph = null;
+ }
+
+ public static IUnlDocumentNodeType createBuilder() {
+ return new UnlDocumentNodeBuilder.Builder();
+ }
+
+ public interface IUnlDocumentNodeType {
+ ILabel withNodeType(UnlDocumentNodeType nodeType);
+ }
+
+ public interface ILabel {
+ IGraph withLabel(String label);
+ }
+
+ public interface IGraph {
+ IBuild withGraph(Function<GraphBuilder.IBuild, GraphBuilder.IBuild> f);
+ }
+
+ public interface IBuild {
+ UnlDocumentNode buildUnlDocumentNode();
+ }
+
+ private static class Builder implements IBuild, ILabel, IGraph, IUnlDocumentNodeType {
+ private final UnlDocumentNodeBuilder instance;
+
+ Builder() {
+ instance = new UnlDocumentNodeBuilder();
+ }
+
+ @Override
+ public UnlDocumentNode buildUnlDocumentNode() {
+ return new UnlDocumentNode(instance.unlDocumentNodeType, instance.docNodeLabel, instance.graph);
+ }
+
+ @Override
+ public IGraph withLabel(String label) {
+ if (null == label || label.isBlank())
+ throw new IllegalArgumentException();
+
+ instance.docNodeLabel = label;
+ return this;
+ }
+
+ @Override
+ public IBuild withGraph(Function<GraphBuilder.IBuild, GraphBuilder.IBuild> f) {
+ if (null != instance.graph)
+ throw new IllegalStateException();
+ instance.graph = f.apply(GraphBuilder.graph()).buildGraph();
+ return this;
+ }
+
+ @Override
+ public ILabel withNodeType(UnlDocumentNodeType nodeType) {
+ instance.unlDocumentNodeType = nodeType;
+ return this;
+ }
+ }
+}
diff --git a/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParser.java b/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParser.java
index 4889a853c58d0151527c1d4fb42d577b416dc93f..67e2115a5b25f864f603b88c8e1f5f867fd578d5 100644
--- a/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParser.java
+++ b/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParser.java
@@ -2,25 +2,93 @@
/* Generated By:JavaCC: Do not edit this line. UnlParser.java */
package fr.tetras_libre.unltools.unl.parser;
-import fr.tetras_libre.unltools.unl.*;
-
-import java.util.Set;
+import java.io.FileInputStream;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
import java.util.SortedSet;
import java.util.TreeSet;
+import java.util.Set;
import java.util.Vector;
+import fr.tetras_libre.unltools.unl.*;
public class UnlParser implements UnlParserConstants {
/* Test program */
- /*public static void main(String args[]) throws ParseException, Exception {
+ public static void main(String args[]) throws ParseException, Exception {
if (args.length != 1) throw new Exception("Please pass the file name as first and only arg.");
UnlParser parser =
new UnlParser(new BufferedReader(new InputStreamReader(new FileInputStream(args[0]))));
parser.createUnlDocumentList();
- }*/
+ }
- private final java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
+/*---------------------------------
+ * Unl DOCUMENT STRUCTURE
+ *---------------------------------*/
+ final public
+UnlDocument unlDocument() throws ParseException, ParseException {Token docLabel;
+ UnlDocument doc = null;
+ UnlDocumentNode node;
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case DOC:{
+ docLabel = jj_consume_token(DOC);
+doc = new UnlDocument(docLabel.image);
+ break;
+ }
+ default:
+ jj_la1[0] = jj_gen;
+ ;
+ }
+// If there is no doc element, create it...
+ if (null == doc) { doc = new UnlDocument("[D]"); } ;
+ label_1:
+ while (true) {
+ try {
+ node = structuredElement();
+ label_2:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case DEUXPOINT:{
+ ;
+ break;
+ }
+ default:
+ jj_la1[1] = jj_gen;
+ break label_2;
+ }
+ jj_consume_token(DEUXPOINT);
+ }
+doc.add(node);
+ } catch (Exception ex) {
+node = new UnlDocumentNode(ex.getMessage());
+ doc.setError(ex.getMessage());
+ doc.add(node);
+ }
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case PARAGRAPH:
+ case TITLE:
+ case SENTENCE:
+ case END_PARAGRAPH:{
+ ;
+ break;
+ }
+ default:
+ jj_la1[2] = jj_gen;
+ break label_1;
+ }
+ }
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case END_DOC:{
+ jj_consume_token(END_DOC);
+ break;
+ }
+ default:
+ jj_la1[3] = jj_gen;
+ ;
+ }
+{if ("" != null) return doc;}
+ throw new Error("Missing return statement in function");
+}
final public UnlDocumentNode structuredElement() throws ParseException {Token t;
UnlDocumentNode sent;
@@ -54,362 +122,219 @@ public class UnlParser implements UnlParserConstants {
throw new ParseException();
}
throw new Error("Missing return statement in function");
- }
-
- final public UnlDocumentNode title() throws ParseException {
- Graph g;
- Token t;
- t = jj_consume_token(TITLE);
- g = relationList();
- jj_consume_token(END_TITLE);
- {
- if ("" != null) return new UnlDocumentNode(UnlDocumentNodeType.Title, t.image, g);
- }
- throw new Error("Missing return statement in function");
- }
-
- /**
- * Generated Token Manager.
- */
- public UnlParserTokenManager token_source;
- /**
- * Current token.
- */
- public Token token;
- /**
- * Next token.
- */
- public Token jj_nt;
- SimpleCharStream jj_input_stream;
- private int jj_ntk;
- private int jj_gen;
- private int[] jj_expentry;
- private int jj_kind = -1;
-
- final public UnlDocumentNode sentence() throws ParseException {
- Graph g;
- Token t;
- t = jj_consume_token(SENTENCE);
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case GENERIC_TOKEN: {
- g = relationList();
- break;
- }
- case NODELIST: {
- g = nodeAndRelations();
- break;
- }
- default:
- jj_la1[5] = jj_gen;
- jj_consume_token(-1);
- throw new ParseException();
- }
- jj_consume_token(END_SENTENCE);
- {
- if ("" != null) return new UnlDocumentNode(UnlDocumentNodeType.Sentence, t.image, g);
- }
- throw new Error("Missing return statement in function");
- }
+}
- /*---------------------------------
- * Unl DOCUMENT STRUCTURE
- *---------------------------------*/
- final public UnlDocument unlDocument() throws ParseException {
- Token docLabel;
- UnlDocument doc = null;
- UnlDocumentNode node;
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case DOC: {
- docLabel = jj_consume_token(DOC);
- doc = new UnlDocument(docLabel.image);
- break;
- }
- default:
- jj_la1[0] = jj_gen;
- }
-// If there is no doc element, create it...
- if (null == doc) {
- doc = new UnlDocument("[D]");
- }
- label_1:
- while (true) {
- try {
- node = structuredElement();
- label_2:
- while (true) {
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case DEUXPOINT: {
- break;
- }
- default:
- jj_la1[1] = jj_gen;
- break label_2;
- }
- jj_consume_token(DEUXPOINT);
- }
- doc.add(node);
- } catch (Exception ex) {
- node = new UnlDocumentNode(ex.getMessage());
- doc.setError(ex.getMessage());
- doc.add(node);
- }
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case PARAGRAPH:
- case TITLE:
- case SENTENCE:
- case END_PARAGRAPH: {
- break;
- }
- default:
- jj_la1[2] = jj_gen;
- break label_1;
- }
- }
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case END_DOC: {
- jj_consume_token(END_DOC);
- break;
- }
- default:
- jj_la1[3] = jj_gen;
- }
- {
- if ("" != null) return doc;
- }
- throw new Error("Missing return statement in function");
- }
+ final public UnlDocumentNode title() throws ParseException {Graph g;
+Token t;
+ t = jj_consume_token(TITLE);
+ g = relationList();
+ jj_consume_token(END_TITLE);
+{if ("" != null) return new UnlDocumentNode(UnlDocumentNodeType.Title, t.image, g);}
+ throw new Error("Missing return statement in function");
+}
- final public GraphRelation relation() throws ParseException {
- Token rl;
- Token subGraphNumber = null;
- GraphNode n1, n2;
- rl = jj_consume_token(GENERIC_TOKEN);
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case COLON_NUMBER: {
- subGraphNumber = jj_consume_token(COLON_NUMBER);
- break;
- }
- default:
- jj_la1[7] = jj_gen;
- }
- jj_consume_token(PARO);
- n1 = node();
- jj_consume_token(COMMA);
- n2 = node();
- jj_consume_token(PARF);
- if (null == subGraphNumber) {
- if ("" != null) return new GraphRelation(n1, n2, rl.image);
- } else {
- if ("" != null) return new GraphRelation(n1, n2, rl.image, subGraphNumber.image);
- }
- throw new Error("Missing return statement in function");
+ final public UnlDocumentNode sentence() throws ParseException {Graph g;
+Token t;
+ t = jj_consume_token(SENTENCE);
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case GENERIC_TOKEN:{
+ g = relationList();
+ break;
+ }
+ case NODELIST:{
+ g = nodeAndRelations();
+ break;
+ }
+ default:
+ jj_la1[5] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
}
+ jj_consume_token(END_SENTENCE);
+{if ("" != null) return new UnlDocumentNode(UnlDocumentNodeType.Sentence, t.image, g);}
+ throw new Error("Missing return statement in function");
+}
- final public Restriction restriction() throws ParseException {
- Token label;
- Token direction;
- UniversalWord uw;
- label = jj_consume_token(GENERIC_TOKEN);
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case CHEVRD: {
- direction = jj_consume_token(CHEVRD);
- break;
- }
- case CHEVRG: {
- direction = jj_consume_token(CHEVRG);
- break;
- }
- default:
- jj_la1[15] = jj_gen;
- jj_consume_token(-1);
- throw new ParseException();
- }
- uw = embeddedUniversalWord(label.image);
- {
- if ("" != null) return new Restriction(label.image, direction.image.charAt(0), uw);
- }
- throw new Error("Missing return statement in function");
+/*---------------------------------
+ * RELATIONS
+ *---------------------------------*/
+ final public
+Graph relationList() throws ParseException {GraphRelation rel;
+ Graph g = new Graph();
+ label_3:
+ while (true) {
+ rel = relation();
+g.add(rel);
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case GENERIC_TOKEN:{
+ ;
+ break;
+ }
+ default:
+ jj_la1[6] = jj_gen;
+ break label_3;
+ }
}
+{if ("" != null) return g;}
+ throw new Error("Missing return statement in function");
+}
- /*---------------------------------
- * RELATIONS
- *---------------------------------*/
- final public Graph relationList() throws ParseException {
- GraphRelation rel;
- Graph g = new Graph();
- label_3:
- while (true) {
- rel = relation();
- g.add(rel);
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case GENERIC_TOKEN: {
- break;
- }
- default:
- jj_la1[6] = jj_gen;
- break label_3;
- }
- }
- {
- if ("" != null) return g;
- }
- throw new Error("Missing return statement in function");
+ final public GraphRelation relation() throws ParseException {Token rl;
+ Token subGraphNumber = null;
+ GraphNode n1, n2;
+ rl = jj_consume_token(GENERIC_TOKEN);
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case COLON_NUMBER:{
+ subGraphNumber = jj_consume_token(COLON_NUMBER);
+ break;
+ }
+ default:
+ jj_la1[7] = jj_gen;
+ ;
}
+ jj_consume_token(PARO);
+ n1 = node();
+ jj_consume_token(COMMA);
+ n2 = node();
+ jj_consume_token(PARF);
+if (null == subGraphNumber)
+ {if ("" != null) return new GraphRelation(n1, n2, rl.image);}
+ else
+ {if ("" != null) return new GraphRelation(n1, n2, rl.image, subGraphNumber.image);}
+ throw new Error("Missing return statement in function");
+}
- final public SubGraphReferenceNode decoratedSubGraphNumber() throws ParseException {
- Token num;
- Set attr;
- num = jj_consume_token(COLON_NUMBER);
- attr = attributes();
- {
- if ("" != null) return new SubGraphReferenceNode(num.image, attr);
- }
- throw new Error("Missing return statement in function");
+ final public GraphNode node() throws ParseException {UniversalWordNode uwn;
+ SubGraphReferenceNode sgn;
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case DBLQUOTED:
+ case GENERIC_TOKEN:{
+ uwn = decoratedUniversalWord();
+{if ("" != null) return (GraphNode) uwn;}
+ break;
+ }
+ case COLON_NUMBER:{
+ sgn = decoratedSubGraphNumber();
+{if ("" != null) return (GraphNode) sgn;}
+ break;
+ }
+ default:
+ jj_la1[8] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
}
+ throw new Error("Missing return statement in function");
+}
- /*---------------------------------
- * RULES FOR TESTS
- *---------------------------------*/
+ final public SubGraphReferenceNode decoratedSubGraphNumber() throws ParseException {Token num;
+ Set attr;
+ num = jj_consume_token(COLON_NUMBER);
+ attr = attributes();
+{if ("" != null) return new SubGraphReferenceNode(num.image, attr);}
+ throw new Error("Missing return statement in function");
+}
- /*---------------------------------
- * NODES AND RELATIONS ([W] syntax)
- *---------------------------------*/
+/*---------------------------------
+ * NODES AND RELATIONS ([W] syntax)
+ *---------------------------------*/
// For the moment, only accept isolated node.
- final public Graph nodeAndRelations() throws ParseException {
- GraphNode n;
- Graph g = new Graph();
- jj_consume_token(NODELIST);
- n = node();
- jj_consume_token(END_NODELIST);
- g.add(n);
- {
- if ("" != null) return g;
- }
- throw new Error("Missing return statement in function");
- }
+ final public Graph nodeAndRelations() throws ParseException {GraphNode n;
+ Graph g = new Graph();
+ jj_consume_token(NODELIST);
+ n = node();
+ jj_consume_token(END_NODELIST);
+g.add(n);
+ {if ("" != null) return g;}
+ throw new Error("Missing return statement in function");
+}
- /*---------------------------------
- * DECORATED UW
- *---------------------------------*/
- final public UniversalWordNode decoratedUniversalWord() throws ParseException {
- UniversalWord uw;
- Token num = null;
- Set attr;
- uw = universalWord();
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case COLON_NUMBER: {
- num = jj_consume_token(COLON_NUMBER);
- break;
- }
- default:
- jj_la1[9] = jj_gen;
- }
- attr = attributes();
- if (null == num) {
- {
- if ("" != null) return new UniversalWordNode(uw, attr);
- }
- } else {
- {
- if ("" != null) return new UniversalWordNode(uw, attr, num.image);
- }
- }
- throw new Error("Missing return statement in function");
+/*---------------------------------
+ * DECORATED UW
+ *---------------------------------*/
+ final public UniversalWordNode decoratedUniversalWord() throws ParseException {UniversalWord uw;
+ Token num = null;
+ Set attr;
+ uw = universalWord();
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case COLON_NUMBER:{
+ num = jj_consume_token(COLON_NUMBER);
+ break;
+ }
+ default:
+ jj_la1[9] = jj_gen;
+ ;
}
-
- final public GraphNode node() throws ParseException {
- UniversalWordNode uwn;
- SubGraphReferenceNode sgn;
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case DBLQUOTED:
- case GENERIC_TOKEN: {
- uwn = decoratedUniversalWord();
- {
- if ("" != null) return uwn;
- }
- break;
- }
- case COLON_NUMBER: {
- sgn = decoratedSubGraphNumber();
- {
- if ("" != null) return sgn;
- }
- break;
- }
- default:
- jj_la1[8] = jj_gen;
- jj_consume_token(-1);
- throw new ParseException();
- }
- throw new Error("Missing return statement in function");
+ attr = attributes();
+if (null == num) {
+ {if ("" != null) return new UniversalWordNode(uw, attr);}
+ } else {
+ {if ("" != null) return new UniversalWordNode(uw, attr, num.image);}
}
+ throw new Error("Missing return statement in function");
+}
- /*---------------------------------
- * UNIVERSAL WORD
- *---------------------------------*/
- final public UniversalWord universalWord() throws ParseException {
- String hw;
- SortedSet restrictions;
- hw = headword();
- restrictions = restrictionList();
- {
- if ("" != null) return new UniversalWord(hw, restrictions);
- }
- throw new Error("Missing return statement in function");
+ final public Set attributes() throws ParseException {Set attr = (Set) new TreeSet();
+ Token a;
+ label_4:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case ATTR:{
+ ;
+ break;
+ }
+ default:
+ jj_la1[10] = jj_gen;
+ break label_4;
+ }
+ a = jj_consume_token(ATTR);
+attr.add(a.image);
}
+{if ("" != null) return attr;}
+ throw new Error("Missing return statement in function");
+}
- final public Set attributes() throws ParseException {
- Set attr = new TreeSet();
- Token a;
- label_4:
- while (true) {
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case ATTR: {
- break;
- }
- default:
- jj_la1[10] = jj_gen;
- break label_4;
- }
- a = jj_consume_token(ATTR);
- attr.add(a.image);
- }
- {
- if ("" != null) return attr;
- }
- throw new Error("Missing return statement in function");
- }
+/*---------------------------------
+ * UNIVERSAL WORD
+ *---------------------------------*/
+ final public
+UniversalWord universalWord() throws ParseException {String hw;
+SortedSet restrictions;
+ hw = headword();
+ restrictions = restrictionList();
+{if ("" != null) return new UniversalWord(hw, restrictions);}
+ throw new Error("Missing return statement in function");
+}
- final public String headword() throws ParseException {
- Token t;
- StringBuffer hw = new StringBuffer();
- label_5:
- while (true) {
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case GENERIC_TOKEN: {
- t = jj_consume_token(GENERIC_TOKEN);
- hw.append(t.image);
- hw.append(" ");
- break;
- }
- case DBLQUOTED: {
- t = jj_consume_token(DBLQUOTED);
- hw.append(t.image);
- hw.append(" ");
- break;
- }
- default:
- jj_la1[11] = jj_gen;
- jj_consume_token(-1);
- throw new ParseException();
- }
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case DBLQUOTED:
- case GENERIC_TOKEN: {
- break;
- }
- default:
- jj_la1[12] = jj_gen;
+ final public String headword() throws ParseException {Token t;
+ StringBuffer hw = new StringBuffer();
+ label_5:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case GENERIC_TOKEN:{
+ t = jj_consume_token(GENERIC_TOKEN);
+hw.append(t.image);
+ hw.append(" ");
+ break;
+ }
+ case DBLQUOTED:{
+ t = jj_consume_token(DBLQUOTED);
+hw.append(t.image);
+ hw.append(" ");
+ break;
+ }
+ default:
+ jj_la1[11] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case DBLQUOTED:
+ case GENERIC_TOKEN:{
+ ;
+ break;
+ }
+ default:
+ jj_la1[12] = jj_gen;
break label_5;
}
}
@@ -421,72 +346,173 @@ int last = hw.length()-1;
throw new Error("Missing return statement in function");
}
- /* Putain de syntaxe à la con ! */
+ final public SortedSet restrictionList() throws ParseException {Restriction r;
+ SortedSet restrictions = (SortedSet) new TreeSet();
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case PARO:{
+ jj_consume_token(PARO);
+ r = restriction();
+restrictions.add(r);
+ label_6:
+ while (true) {
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case COMMA:{
+ ;
+ break;
+ }
+ default:
+ jj_la1[13] = jj_gen;
+ break label_6;
+ }
+ jj_consume_token(COMMA);
+ r = restriction();
+restrictions.add(r);
+ }
+ jj_consume_token(PARF);
+ break;
+ }
+ default:
+ jj_la1[14] = jj_gen;
+ ;
+ }
+{if ("" != null) return restrictions;}
+ throw new Error("Missing return statement in function");
+}
+
+ final public Restriction restriction() throws ParseException {Token label;
+ Token direction;
+ UniversalWord uw;
+ label = jj_consume_token(GENERIC_TOKEN);
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case CHEVRD:{
+ direction = jj_consume_token(CHEVRD);
+ break;
+ }
+ case CHEVRG:{
+ direction = jj_consume_token(CHEVRG);
+ break;
+ }
+ default:
+ jj_la1[15] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ uw = embeddedUniversalWord(label.image);
+{if ("" != null) return new Restriction(label.image, direction.image.charAt(0), uw);}
+ throw new Error("Missing return statement in function");
+}
+
+/* Putain de syntaxe à la con ! */
/* Un UW dans une restriction n'a pas forcément la même syntaxe qu'une UW
"normale". En effet, la restricition peut être factorisée. */
- final public UniversalWord embeddedUniversalWord(String inheritedLabel) throws ParseException {
- String hw;
- SortedSet restrictions;
- hw = headword();
- restrictions = embeddedRestrictionList(inheritedLabel);
- {
- if ("" != null) return new UniversalWord(hw, restrictions);
- }
- throw new Error("Missing return statement in function");
+ final public UniversalWord embeddedUniversalWord(String inheritedLabel) throws ParseException {String hw;
+ SortedSet restrictions;
+ hw = headword();
+ restrictions = embeddedRestrictionList(inheritedLabel);
+{if ("" != null) return new UniversalWord(hw, restrictions);}
+ throw new Error("Missing return statement in function");
+}
+
+ final public SortedSet embeddedRestrictionList(String inheritedLabel) throws ParseException {UniversalWord uw;
+ SortedSet restrictions;
+ Token direction;
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case CHEVRD:
+ case CHEVRG:{
+restrictions = (SortedSet) new TreeSet();
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case CHEVRD:{
+ direction = jj_consume_token(CHEVRD);
+ break;
+ }
+ case CHEVRG:{
+ direction = jj_consume_token(CHEVRG);
+ break;
+ }
+ default:
+ jj_la1[16] = jj_gen;
+ jj_consume_token(-1);
+ throw new ParseException();
+ }
+ uw = embeddedUniversalWord(inheritedLabel);
+restrictions.add(new Restriction(inheritedLabel, direction.image.charAt(0), uw));
+ break;
+ }
+ default:
+ jj_la1[17] = jj_gen;
+ restrictions = restrictionList();
}
+{if ("" != null) return restrictions;}
+ throw new Error("Missing return statement in function");
+}
+
+/*---------------------------------
+ * RULES FOR TESTS
+ *---------------------------------*/
+
+/**
+ * List of universal words separated by commas.
+ */
+ final public void universalWordList() throws ParseException {
+ decoratedUniversalWord();
+System.out.println("UW");
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case COMMA:{
+ jj_consume_token(COMMA);
+ universalWordList();
+ break;
+ }
+ default:
+ jj_la1[18] = jj_gen;
- final public SortedSet restrictionList() throws ParseException {
- Restriction r;
- SortedSet restrictions = new TreeSet();
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case PARO: {
- jj_consume_token(PARO);
- r = restriction();
- restrictions.add(r);
- label_6:
- while (true) {
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case COMMA: {
- break;
- }
- default:
- jj_la1[13] = jj_gen;
- break label_6;
- }
- jj_consume_token(COMMA);
- r = restriction();
- restrictions.add(r);
- }
- jj_consume_token(PARF);
- break;
- }
- default:
- jj_la1[14] = jj_gen;
- }
- {
- if ("" != null) return restrictions;
- }
- throw new Error("Missing return statement in function");
}
+ jj_consume_token(0);
+}
- /**
- * List of universal words separated by commas.
- */
- final public void universalWordList() throws ParseException {
- decoratedUniversalWord();
- System.out.println("UW");
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case COMMA: {
- jj_consume_token(COMMA);
- universalWordList();
- break;
- }
- default:
- jj_la1[18] = jj_gen;
+/**
+ * Simple unl graph.
+ */
+ final public void isolatedUnlGraph() throws ParseException {
+ relationList();
+ jj_consume_token(0);
+}
- }
- jj_consume_token(0);
+/**
+ * Main entry point: unl document List.
+ */
+ final public Vector<UnlDocument> createUnlDocumentList() throws ParseException {UnlDocument doc;
+Vector<UnlDocument> list = new Vector<UnlDocument>();
+ label_7:
+ while (true) {
+ doc = unlDocument();
+list.add(doc);
+ switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
+ case DOC:
+ case PARAGRAPH:
+ case TITLE:
+ case SENTENCE:
+ case END_PARAGRAPH:{
+ ;
+ break;
+ }
+ default:
+ jj_la1[19] = jj_gen;
+ break label_7;
+ }
}
+{if ("" != null) return list;}
+ throw new Error("Missing return statement in function");
+}
+
+ /** Generated Token Manager. */
+ public UnlParserTokenManager token_source;
+ SimpleCharStream jj_input_stream;
+ /** Current token. */
+ public Token token;
+ /** Next token. */
+ public Token jj_nt;
+ private int jj_ntk;
+ private int jj_gen;
final private int[] jj_la1 = new int[20];
static private int[] jj_la1_0;
static private int[] jj_la1_1;
@@ -590,127 +616,52 @@ int last = hw.length()-1;
}
- /**
- * Get the next Token.
- */
- final public Token getNextToken() {
- if (token.next != null) token = token.next;
- else token = token.next = token_source.getNextToken();
- jj_ntk = -1;
- jj_gen++;
- return token;
- }
-
- /**
- * Simple unl graph.
- */
- final public void isolatedUnlGraph() throws ParseException {
- relationList();
- jj_consume_token(0);
- }
-
- final public SortedSet embeddedRestrictionList(String inheritedLabel) throws ParseException {
- UniversalWord uw;
- SortedSet restrictions;
- Token direction;
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case CHEVRD:
- case CHEVRG: {
- restrictions = new TreeSet();
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case CHEVRD: {
- direction = jj_consume_token(CHEVRD);
- break;
- }
- case CHEVRG: {
- direction = jj_consume_token(CHEVRG);
- break;
- }
- default:
- jj_la1[16] = jj_gen;
- jj_consume_token(-1);
- throw new ParseException();
- }
- uw = embeddedUniversalWord(inheritedLabel);
- restrictions.add(new Restriction(inheritedLabel, direction.image.charAt(0), uw));
- break;
- }
- default:
- jj_la1[17] = jj_gen;
- restrictions = restrictionList();
- }
- {
- if ("" != null) return restrictions;
- }
- throw new Error("Missing return statement in function");
- }
-
- /**
- * Get the specific Token.
- */
- final public Token getToken(int index) {
- Token t = token;
- for (int i = 0; i < index; i++) {
- if (t.next != null) t = t.next;
- else t = t.next = token_source.getNextToken();
- }
- return t;
- }
+/** Get the next Token. */
+ final public Token getNextToken() {
+ if (token.next != null) token = token.next;
+ else token = token.next = token_source.getNextToken();
+ jj_ntk = -1;
+ jj_gen++;
+ return token;
+ }
- private int jj_ntk_f() {
- if ((jj_nt = token.next) == null)
- return (jj_ntk = (token.next = token_source.getNextToken()).kind);
- else
- return (jj_ntk = jj_nt.kind);
- }
+/** Get the specific Token. */
+ final public Token getToken(int index) {
+ Token t = token;
+ for (int i = 0; i < index; i++) {
+ if (t.next != null) t = t.next;
+ else t = t.next = token_source.getNextToken();
+ }
+ return t;
+ }
- /**
- * Main entry point: unl document List.
- */
- final public Vector<UnlDocument> createUnlDocumentList() throws ParseException {
- UnlDocument doc;
- Vector<UnlDocument> list = new Vector<UnlDocument>();
- label_7:
- while (true) {
- doc = unlDocument();
- list.add(doc);
- switch ((jj_ntk == -1) ? jj_ntk_f() : jj_ntk) {
- case DOC:
- case PARAGRAPH:
- case TITLE:
- case SENTENCE:
- case END_PARAGRAPH: {
- break;
- }
- default:
- jj_la1[19] = jj_gen;
- break label_7;
- }
- }
- {
- if ("" != null) return list;
- }
- throw new Error("Missing return statement in function");
- }
+ private int jj_ntk_f() {
+ if ((jj_nt=token.next) == null)
+ return (jj_ntk = (token.next=token_source.getNextToken()).kind);
+ else
+ return (jj_ntk = jj_nt.kind);
+ }
- /**
- * Generate ParseException.
- */
- public ParseException generateParseException() {
- jj_expentries.clear();
- boolean[] la1tokens = new boolean[39];
- if (jj_kind >= 0) {
- la1tokens[jj_kind] = true;
- jj_kind = -1;
- }
- for (int i = 0; i < 20; i++) {
- if (jj_la1[i] == jj_gen) {
- for (int j = 0; j < 32; j++) {
- if ((jj_la1_0[i] & (1 << j)) != 0) {
- la1tokens[j] = true;
- }
- if ((jj_la1_1[i] & (1 << j)) != 0) {
- la1tokens[32 + j] = true;
+ private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
+ private int[] jj_expentry;
+ private int jj_kind = -1;
+
+ /** Generate ParseException. */
+ public ParseException generateParseException() {
+ jj_expentries.clear();
+ boolean[] la1tokens = new boolean[39];
+ if (jj_kind >= 0) {
+ la1tokens[jj_kind] = true;
+ jj_kind = -1;
+ }
+ for (int i = 0; i < 20; i++) {
+ if (jj_la1[i] == jj_gen) {
+ for (int j = 0; j < 32; j++) {
+ if ((jj_la1_0[i] & (1<<j)) != 0) {
+ la1tokens[j] = true;
+ }
+ if ((jj_la1_1[i] & (1<<j)) != 0) {
+ la1tokens[32+j] = true;
}
}
}
diff --git a/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParser.jj b/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParser.jj
index a05304d4e80f8642e6cab2d74dd3a12049c69be0..b5976bbc809ba1a02f203e16393e4b424a5c3afc 100644
--- a/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParser.jj
+++ b/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParser.jj
@@ -72,7 +72,7 @@ TOKEN : /* Character classes */
// QUESTION: Quels sont les caractères officiellement acceptés dans les headwords...
| <#HEADWORD_CHARACTERS : ( <ALPHANUM> | "'" | "#" | "&" | "/" |
["\u00c0"-"\u00ff"] |
- ("." ~["@"]) ) >
+ ("." ~["@"]) | "=" ) >
// | <#HEADWORD_CHARACTERS : ( <ALPHANUM> | "'" | "#" | "&" | "/" | "+" | "@" | "=" | "$" | "�" | "�" | "[" | "]" |
// "\u221a" | "\u00a9" |
diff --git a/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParserTokenManager.java b/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParserTokenManager.java
index b84e9b6f78aa7b2cb5db2697a08d94706b94aaa6..10808c7b830dba491b837f13129d6fc77d49c39b 100644
--- a/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParserTokenManager.java
+++ b/unl-tools-infrastructure/src/main/java/fr/tetras_libre/unltools/unl/parser/UnlParserTokenManager.java
@@ -1,6 +1,14 @@
/* UnlParserTokenManager.java */
/* Generated By:JavaCC: Do not edit this line. UnlParserTokenManager.java */
package fr.tetras_libre.unltools.unl.parser;
+import java.io.FileInputStream;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.Set;
+import java.util.Vector;
+import fr.tetras_libre.unltools.unl.*;
/** Token Manager. */
@SuppressWarnings ("unused")
@@ -201,7 +209,7 @@ private int jjMoveNfa_0(int startState, int curPos)
switch(jjstateSet[--i])
{
case 0:
- if ((0x3ffa0c800000000L & l) != 0L)
+ if ((0x23ffa0c800000000L & l) != 0L)
{
if (kind > 37)
kind = 37;
@@ -274,7 +282,7 @@ private int jjMoveNfa_0(int startState, int curPos)
kind = 36;
break;
case 21:
- if ((0x3ffa0c800000000L & l) == 0L)
+ if ((0x23ffa0c800000000L & l) == 0L)
break;
if (kind > 37)
kind = 37;
diff --git a/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/CatsUnl.java b/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/CatsUnl.java
index 951f79d7bb43909b9b76eccb287ce12f671a3ac5..9311784683757563c99999defc832ecc7c65da2d 100644
--- a/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/CatsUnl.java
+++ b/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/CatsUnl.java
@@ -1,9 +1,12 @@
package fr.tetras_libre.unltools.unl;
+import fr.tetras_libre.unltools.unl.builders.RestrictionOrientation;
+import fr.tetras_libre.unltools.unl.builders.UnlDocumentNodeBuilder;
+
import java.util.*;
public class CatsUnl extends AbstractFlyweightUnlArgumentProvider implements GraphImporter {
- public static UnlDocumentNode buildSentenceNode() {
+ private static UnlDocumentNode CreateWithOldBuilder() {
var graph = new Graph();
// mod
@@ -62,6 +65,110 @@ public class CatsUnl extends AbstractFlyweightUnlArgumentProvider implements Gra
return new UnlDocumentNode(UnlDocumentNodeType.Sentence, "[S:00]", graph);
}
+ private static UnlDocumentNode newBuilder(){
+ return UnlDocumentNodeBuilder
+ .createBuilder()
+ .withNodeType(UnlDocumentNodeType.Sentence)
+ .withLabel("[S:00]")
+ .withGraph(
+ gb ->
+ gb.addGraphRelation(
+ grb -> grb
+ .label("mod")
+ .reference(":01")
+ .leftNode(
+ lnb ->
+ lnb
+ .universalWord(
+ uwb ->
+ uwb
+ .headWord("cat1")
+ .addTernaryTransitiveRestriction("icl", "feline", "thing", RestrictionOrientation.Right)
+ )
+ .instanceNumber(":01")
+ .addAttribute(".@entry")
+ .addAttribute(".@def")
+ )
+ .rightNode(
+ rnb -> rnb
+ .universalWord(
+ uwb ->
+ uwb
+ .headWord("black")
+ .addSimpleRestriction("icl", RestrictionOrientation.Right, "adj")
+ )
+ )
+ )
+ .addGraphRelation(grb ->
+ grb.label("and")
+ .reference(":01")
+ .leftNode(
+ lnb -> lnb.universalWord(
+ uwb -> uwb.headWord("cat1")
+ .addTernaryTransitiveRestriction("icl", "feline", "thing", RestrictionOrientation.Right)
+ )
+ .instanceNumber(":01")
+ .addAttribute(".@entry")
+ .addAttribute(".@def")
+ )
+ .rightNode(
+ lnb -> lnb.universalWord(
+ uwb -> uwb.headWord("cat2")
+ .addTernaryTransitiveRestriction("icl", "feline", "thing", RestrictionOrientation.Right)
+ )
+ .instanceNumber(":02")
+ .addAttribute(".@entry")
+ .addAttribute(".@def")
+ )
+ )
+ .addGraphRelation(
+ grb -> grb.label("mod")
+ .reference(":01")
+ .leftNode(
+ lnb -> lnb.universalWord(
+ uwb -> uwb.headWord("cat2")
+ .addTernaryTransitiveRestriction("icl", "feline", "thing", RestrictionOrientation.Right)
+ )
+ .instanceNumber(":02")
+ .addAttribute(".@entry")
+ .addAttribute(".@def")
+ )
+ .rightNode(
+ rnb -> rnb.universalWord(
+ uwb -> uwb.headWord("white")
+ .addSimpleRestriction("icl", RestrictionOrientation.Right, "adj")
+ )
+ )
+ )
+ .addGraphRelation(
+ grb -> grb.label("agt")
+ .noReference()
+ .leftNode(
+ lnb -> lnb.universalWord(
+ uwb -> uwb.headWord("eat")
+ .addTernaryTransitiveRestriction("icl", "consume", "do", RestrictionOrientation.Right)
+ .addSimpleRestriction("agt", RestrictionOrientation.Right, "living_thing")
+ .addSimpleRestriction("obj", RestrictionOrientation.Right, "concrete_thing")
+ .addSimpleRestriction("ins", RestrictionOrientation.Right, "thing")
+ )
+ .addAttribute(".@entry")
+ .addAttribute(".@pl")
+ .addAttribute(".@present")
+ .addAttribute(".@progress")
+ )
+ .rightSubGraphNode(
+ rnb -> rnb.referenceNumber(":01")
+ .addAttribute(".@_hn-scope")
+ )
+ )
+ )
+ .buildUnlDocumentNode();
+ }
+
+ public static UnlDocumentNode buildSentenceNode() {
+ return newBuilder();
+ }
+
protected List<UnlDocument> buildUnlDocuments() {
var unlDocument = new UnlDocument("[D]");
diff --git a/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/Issue13Unl.java b/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/Issue13Unl.java
new file mode 100644
index 0000000000000000000000000000000000000000..05c871b6634c2f27c00ca05337c10a07fd0f392b
--- /dev/null
+++ b/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/Issue13Unl.java
@@ -0,0 +1,208 @@
+package fr.tetras_libre.unltools.unl;
+
+import fr.tetras_libre.unltools.unl.builders.RestrictionOrientation;
+import fr.tetras_libre.unltools.unl.builders.UnlDocumentNodeBuilder;
+
+import java.util.Collections;
+import java.util.List;
+
+public class Issue13Unl extends AbstractFlyweightUnlArgumentProvider {
+ private static UnlDocument unlDocument;
+
+ public static UnlDocumentNode buildSentenceNode1() {
+ return UnlDocumentNodeBuilder
+ .createBuilder()
+ .withNodeType(UnlDocumentNodeType.Sentence)
+ .withLabel("[S:00]")
+ .withGraph(gb -> gb
+ // mod relation
+ .addGraphRelation(s ->
+ s.label("mod")
+ .noReference()
+ .leftNode(
+ ln -> ln
+ .universalWord(uwb -> uwb.headWord("m")
+ .addTernaryTransitiveRestriction("icl", "metric_linear_unit", "thing", RestrictionOrientation.Right)
+ .addSimpleRestriction("equ", RestrictionOrientation.Right, "meter")
+ )
+ .addAttribute(".@entry")
+ .addAttribute(".@parenthesis"))
+ .rightNode(
+ rn -> rn
+ .simpleUniversalWord(() -> "=")
+ )
+ )
+ // second mod relation
+ .addGraphRelation(s ->
+ s
+ .label("mod")
+ .noReference()
+ .leftNode(
+ ln -> ln
+ .simpleUniversalWord(
+ () -> "="
+ )
+ )
+ .rightNode(
+ rn -> rn
+ .universalWord(
+ uwb -> uwb
+ .headWord("mandatory")
+ .addSimpleRestriction("icl", RestrictionOrientation.Right, "adj")
+ .addSimpleRestriction("equ", RestrictionOrientation.Right, "compulsory")
+ )
+ .addAttribute(".@maiuscul")
+ )
+ )
+ // obj relation
+ .addGraphRelation(
+ s ->
+ s.label("obj")
+ .noReference()
+ .leftNode(
+ ln -> ln
+ .universalWord(
+ uw -> uw
+ .headWord("respect")
+ .addTernaryTransitiveRestriction("icl", "consider", "be", RestrictionOrientation.Right)
+ .addSimpleRestriction("rsn", RestrictionOrientation.Right, "thing")
+ .addSimpleRestriction("obj", RestrictionOrientation.Right, "thing")
+ .addSimpleRestriction("aoj", RestrictionOrientation.Right, "person")
+ )
+ .addAttribute(".@present")
+ .addAttribute(".@promise")
+ )
+ .rightNode(
+ rn -> rn
+ .universalWord(
+ uw -> uw
+ .headWord("requirement")
+ .addTernaryTransitiveRestriction("icl", "duty", "thing", RestrictionOrientation.Right)
+ )
+ .addAttribute(".@def")
+ .addAttribute(".@topic")
+ )
+ )
+ // cnt relation
+ .addGraphRelation(
+ s ->
+ s.label("cnt")
+ .noReference()
+ .leftNode(
+ lnb -> lnb
+ .universalWord(
+ uw -> uw
+ .headWord("mandatory")
+ .addSimpleRestriction("icl", RestrictionOrientation.Right, "adj")
+ .addSimpleRestriction("equ", RestrictionOrientation.Right, "compulsory")
+ )
+ .addAttribute(".@maiuscul")
+ )
+ .rightNode(
+ rn -> rn
+ .universalWord(
+ uwb -> uwb
+ .headWord("respect")
+ .addTernaryTransitiveRestriction("icl", "consider", "be", RestrictionOrientation.Right)
+ .addSimpleRestriction("rsn", RestrictionOrientation.Right, "thing")
+ .addSimpleRestriction("obj", RestrictionOrientation.Right, "thing")
+ .addSimpleRestriction("aoj", RestrictionOrientation.Right, "person")
+ )
+ .addAttribute(".@present")
+ .addAttribute(".@promise")
+ )
+ )
+ // mod
+ .addGraphRelation(
+ s ->
+ s.label("mod")
+ .noReference()
+ .leftNode(
+ ln -> ln
+ .universalWord(
+ uwb -> uwb
+ .headWord("application")
+ .addSimpleRestriction("icl", RestrictionOrientation.Right, "information")
+ .addSimpleRestriction("equ", RestrictionOrientation.Right, "request")
+ .addSimpleRestriction("agt", RestrictionOrientation.Right, "thing")
+ .addSimpleRestriction("obj", RestrictionOrientation.Right, "uw")
+ )
+ )
+ .rightNode(
+ rn -> rn
+ .universalWord(
+ uwb -> uwb
+ .headWord("every")
+ .addSimpleRestriction("icl", RestrictionOrientation.Right, "quantity")
+ .addSimpleRestriction("per", RestrictionOrientation.Right, "thing")
+ )
+ )
+ )
+ // mod
+ .addGraphRelation(
+ s -> s
+ .label("mod")
+ .noReference()
+ .leftNode(
+ ln -> ln
+ .universalWord(
+ uwb -> uwb
+ .headWord("application")
+ .addSimpleRestriction("icl", RestrictionOrientation.Right, "information")
+ .addSimpleRestriction("equ", RestrictionOrientation.Right, "request")
+ .addSimpleRestriction("agt", RestrictionOrientation.Right, "thing")
+ .addSimpleRestriction("obj", RestrictionOrientation.Right, "uw")
+ )
+ )
+ .rightNode(
+ rn -> rn
+ .simpleUniversalWord(
+ () -> "etcs"
+ )
+ )
+ )
+ .addGraphRelation(
+ s ->
+ s
+ .label("scn")
+ .noReference()
+ .leftNode(
+ ln -> ln
+ .universalWord(
+ uwb -> uwb
+ .headWord("respect")
+ .addTernaryTransitiveRestriction("icl", "consider", "be", RestrictionOrientation.Right)
+ .addSimpleRestriction("rsn", RestrictionOrientation.Right, "thing")
+ .addSimpleRestriction("obj", RestrictionOrientation.Right, "thing")
+ .addSimpleRestriction("aoj", RestrictionOrientation.Right, "person")
+ )
+ .addAttribute(".@present")
+ .addAttribute(".@promise")
+ )
+ .rightNode(
+ rn -> rn
+ .universalWord(
+ uwb -> uwb
+ .headWord("application")
+ .addSimpleRestriction("icl", RestrictionOrientation.Right, "information")
+ .addSimpleRestriction("equ", RestrictionOrientation.Right, "request")
+ .addSimpleRestriction("agt", RestrictionOrientation.Right, "thing")
+ .addSimpleRestriction("obj", RestrictionOrientation.Right, "uw")
+ )
+ )
+ )
+ )
+ .buildUnlDocumentNode();
+
+ }
+
+
+ @Override
+ protected List<UnlDocument> buildUnlDocuments() {
+ if (null == Issue13Unl.unlDocument) {
+ Issue13Unl.unlDocument = new UnlDocument();
+ Issue13Unl.unlDocument.add(buildSentenceNode1());
+ }
+ return Collections.singletonList(Issue13Unl.unlDocument);
+ }
+}
diff --git a/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/UnlSentences.java b/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/UnlSentences.java
index 6c4c52527cd1caedf7d7090a10d26d500f7080bb..50d9ee9eac2e3267750c2ccd4b66cb2d72befacb 100644
--- a/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/UnlSentences.java
+++ b/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/UnlSentences.java
@@ -93,4 +93,19 @@ public class UnlSentences {
"{/unl}\n" +
"[/S]\n" +
"[/D]";
+
+ public static final String Issue13 = "[S:00]\n" +
+ "{org:en}\n" +
+ "(M) = Mandatory:The requirement shall be respected in every ETCS application. \n" +
+ "{/org}\n" +
+ "{unl}\n" +
+ "mod(m(icl>metric_linear_unit>thing,equ>meter).@entry.@parenthesis,=)\n" +
+ "mod(=,mandatory(icl>adj,equ>compulsory).@maiuscul)\n" +
+ "obj(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,requirement(icl>duty>thing).@def.@topic)\n" +
+ "cnt(mandatory(icl>adj,equ>compulsory).@maiuscul,respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise)\n" +
+ "mod(application(icl>information,equ>request,agt>thing,obj>uw),every(icl>quantity,per>thing))\n" +
+ "mod(application(icl>information,equ>request,agt>thing,obj>uw),etcs)\n" +
+ "scn(respect(icl>consider>be,rsn>thing,obj>thing,aoj>person).@present.@promise,application(icl>information,equ>request,agt>thing,obj>uw))\n" +
+ "{/unl}\n" +
+ "[/S]\n";
}
diff --git a/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/parser/Issue13WithExpectedUnlDocumentChecker.java b/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/parser/Issue13WithExpectedUnlDocumentChecker.java
new file mode 100644
index 0000000000000000000000000000000000000000..85a99cdc465e1f284bcb7e10b59665392da45c0e
--- /dev/null
+++ b/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/parser/Issue13WithExpectedUnlDocumentChecker.java
@@ -0,0 +1,10 @@
+package fr.tetras_libre.unltools.unl.parser;
+
+import fr.tetras_libre.unltools.unl.Issue13Unl;
+import fr.tetras_libre.unltools.unl.UnlSentences;
+
+public class Issue13WithExpectedUnlDocumentChecker extends SentenceWithExpectedUnlDocumentsChecker {
+ public Issue13WithExpectedUnlDocumentChecker() {
+ super(UnlSentences.Issue13, new Issue13Unl().getUnlDocuments());
+ }
+}
diff --git a/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/parser/UnlParserTest.java b/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/parser/UnlParserTest.java
index 7bc9410c46b7cfd8b6c8a661f7b236345b116839..4c77e1f8813920f799c9d133cd759bcf5caafcc5 100644
--- a/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/parser/UnlParserTest.java
+++ b/unl-tools-infrastructure/src/test/java/fr/tetras_libre/unltools/unl/parser/UnlParserTest.java
@@ -14,13 +14,14 @@ class UnlParserTest {
private static Stream<SentenceWithExpectedUnlDocumentsChecker> unlParserShouldParseSentenceAndGetExpectedUnlDocuments() {
return Stream.of(new R1SentenceWithExpectedUnlDocumentsChecker(),
- new R2SentenceWithExpectedUnlDocumentsChecker(),
- new CatsSentenceWithExpectedUnlDocumentsChecker(),
- new AllSentenceWithExpectedUnlDocumentsChecker());
+ new R2SentenceWithExpectedUnlDocumentsChecker(),
+ new CatsSentenceWithExpectedUnlDocumentsChecker(),
+ new AllSentenceWithExpectedUnlDocumentsChecker(),
+ new Issue13WithExpectedUnlDocumentChecker());
}
@ParameterizedTest
- @ValueSource(strings = {UnlSentences.R1, UnlSentences.R2, UnlSentences.Cats, UnlSentences.All})
+ @ValueSource(strings = {UnlSentences.R1, UnlSentences.R2, UnlSentences.Cats, UnlSentences.All, UnlSentences.Issue13})
void unlParserShouldParseSimpleSentenceWithoutException(String input) {
UnlParserFactory unlFactory = new UnlParserFactoryFromString(input);
var wrapper = createAndCheckUnlParserValidity(unlFactory);