You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by cd...@apache.org on 2022/02/22 15:46:07 UTC

[plc4x] branch develop updated: feat(codegen): Ensured the VariableLiterals are able to provide their type.

This is an automated email from the ASF dual-hosted git repository.

cdutz pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git


The following commit(s) were added to refs/heads/develop by this push:
     new 0a99ac6  feat(codegen): Ensured the VariableLiterals are able to provide their type.
0a99ac6 is described below

commit 0a99ac62094c98abcd41071d5dd85b10c237afc7
Author: cdutz <ch...@c-ware.de>
AuthorDate: Tue Feb 22 16:45:54 2022 +0100

    feat(codegen): Ensured the VariableLiterals are able to provide their type.
---
 .../mspec/LazyTypeDefinitionConsumer.java}         | 31 ++-------
 .../mspec/expression/ExpressionStringListener.java | 77 +++++++++++++++++++++-
 .../mspec/expression/ExpressionStringParser.java   | 12 +++-
 .../mspec/parser/MessageFormatListener.java        | 21 ++++--
 .../expression/ExpressionStringParserTest.java     |  2 +-
 .../mspec/parser/MessageFormatParserTest.java      |  6 ++
 .../src/test/resources/mspec.example3              | 35 ++++++++++
 .../plc4x/protocol/knxnetip/KnxNetIpProtocol.java  |  2 +-
 .../apache/plc4x/protocol/opcua/OpcuaProtocol.java |  2 +-
 9 files changed, 150 insertions(+), 38 deletions(-)

diff --git a/code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatParserTest.java b/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/LazyTypeDefinitionConsumer.java
similarity index 52%
copy from code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatParserTest.java
copy to code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/LazyTypeDefinitionConsumer.java
index 3094a0a..65fc977 100644
--- a/code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatParserTest.java
+++ b/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/LazyTypeDefinitionConsumer.java
@@ -16,35 +16,14 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.apache.plc4x.plugins.codegenerator.language.mspec.parser;
+package org.apache.plc4x.plugins.codegenerator.language.mspec;
 
-import org.apache.plc4x.plugins.codegenerator.protocol.TypeContext;
 import org.apache.plc4x.plugins.codegenerator.types.definitions.TypeDefinition;
-import org.junit.jupiter.api.Test;
 
-import java.util.Map;
+import java.util.function.Consumer;
 
-import static org.junit.jupiter.api.Assertions.assertThrows;
+public interface LazyTypeDefinitionConsumer {
 
-class MessageFormatParserTest {
+    void setOrScheduleTypeDefinitionConsumer(String typeRefName, Consumer<TypeDefinition> setTypeDefinition);
 
-    MessageFormatParser SUT = new MessageFormatParser();
-
-    @Test
-    void parseNull() {
-        assertThrows(NullPointerException.class, () -> SUT.parse(null));
-    }
-
-    @Test
-    void parseSomething() {
-        TypeContext parse = SUT.parse(getClass().getResourceAsStream("/mspec.example"));
-        System.out.println(parse);
-    }
-
-    @Test
-    void parseSomethingElse() {
-        TypeContext parse = SUT.parse(getClass().getResourceAsStream("/mspec.example2"));
-        System.out.println(parse);
-    }
-
-}
\ No newline at end of file
+}
diff --git a/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringListener.java b/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringListener.java
index 6b2b1ad..14ecca2 100644
--- a/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringListener.java
+++ b/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringListener.java
@@ -18,17 +18,39 @@
  */
 package org.apache.plc4x.plugins.codegenerator.language.mspec.expression;
 
+import org.apache.plc4x.plugins.codegenerator.language.mspec.LazyTypeDefinitionConsumer;
+import org.apache.plc4x.plugins.codegenerator.language.mspec.parser.MessageFormatListener;
+import org.apache.plc4x.plugins.codegenerator.types.definitions.ComplexTypeDefinition;
+import org.apache.plc4x.plugins.codegenerator.types.definitions.TypeDefinition;
+import org.apache.plc4x.plugins.codegenerator.types.fields.PropertyField;
+import org.apache.plc4x.plugins.codegenerator.types.references.TypeReference;
 import org.apache.plc4x.plugins.codegenerator.types.terms.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.*;
+import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 
 public class ExpressionStringListener extends ExpressionBaseListener {
 
+    private static final Logger LOGGER = LoggerFactory.getLogger(ExpressionStringListener.class);
+
+    private final LazyTypeDefinitionConsumer lazyTypeDefinitionConsumer;
+
+    private final String rootTypeName;
+
     private Stack<List<Term>> parserContexts;
 
+    private Stack<CompletableFuture<TypeReference>> futureStack;
+
     private Term root;
 
+    public ExpressionStringListener(LazyTypeDefinitionConsumer lazyTypeDefinitionConsumer, String rootTypeName) {
+        this.lazyTypeDefinitionConsumer = lazyTypeDefinitionConsumer;
+        this.rootTypeName = rootTypeName;
+    }
+
     public Term getRoot() {
         return root;
     }
@@ -88,9 +110,48 @@ public class ExpressionStringListener extends ExpressionBaseListener {
 
     @Override
     public void enterIdentifierSegment(ExpressionParser.IdentifierSegmentContext ctx) {
+        String propertyName = ctx.name.getText();
+
+        CompletableFuture<TypeReference> typeReferenceFuture = new CompletableFuture<>();
+        if (futureStack == null) {
+            schedulePropertyResolution(propertyName, typeReferenceFuture, rootTypeName);
+            futureStack = new Stack<>();
+        } else {
+            futureStack.peek().whenComplete((typeReference, throwable) -> {
+                if (throwable != null) {
+                    LOGGER.debug("Error processing variables", throwable);
+                    return;
+                }
+                String typeName = typeReference.asComplexTypeReference().orElseThrow().getName();
+                schedulePropertyResolution(propertyName, typeReferenceFuture, typeName);
+            });
+        }
+        futureStack.push(typeReferenceFuture);
         parserContexts.push(new LinkedList<>());
     }
 
+    private void schedulePropertyResolution(String propertyName, CompletableFuture<TypeReference> typeReferenceFuture, String typeName) {
+        lazyTypeDefinitionConsumer.setOrScheduleTypeDefinitionConsumer(typeName, (TypeDefinition typeDefinition)->{
+            if (!typeDefinition.isComplexTypeDefinition()) {
+                typeReferenceFuture.completeExceptionally(new RuntimeException("is not a complex type"));
+                return;
+            }
+            final ComplexTypeDefinition complexTypeDefinition = typeDefinition
+                .asComplexTypeDefinition()
+                .orElseThrow();
+            final Optional<PropertyField> propertyFieldByName = complexTypeDefinition
+                .getPropertyFieldByName(propertyName);
+            if (propertyFieldByName.isEmpty()) {
+                typeReferenceFuture.completeExceptionally(new RuntimeException("Field with name " + propertyName + " not found on "+typeName));
+                return;
+            }
+            TypeReference propertyTypeReference = propertyFieldByName
+                .orElseThrow()
+                .getType();
+            typeReferenceFuture.complete(propertyTypeReference);
+        });
+    }
+
     @Override
     public void exitIdentifierSegment(ExpressionParser.IdentifierSegmentContext ctx) {
         List<Term> args = parserContexts.pop();
@@ -108,16 +169,30 @@ public class ExpressionStringListener extends ExpressionBaseListener {
         }
 
         String name = ctx.name.getText();
+        // TODO: Based on the current context type-definition, get the type of the property with name ctx.name.getText()
 
         int index = VariableLiteral.NO_INDEX;
         if (indexContext != null) {
+            // TODO: Add a check, that the field providing the property is an "array" or "manualArray" field.
             index = indexContext.getFirst().getNumber().intValue();
         }
         VariableLiteral rest = null;
         if (restContext != null) {
+            // TODO: Add a check, that the field providing the property references a complex type (or uses one of the built-ins)
             rest = restContext.getFirst();
         }
-        parserContexts.peek().add(new DefaultVariableLiteral(name, argsContext, index, rest));
+
+        final DefaultVariableLiteral variableLiteral = new DefaultVariableLiteral(name, argsContext, index, rest);
+        futureStack.pop().whenComplete((typeReference, throwable) -> {
+            // TODO: check throwable
+            String typeName= typeReference.asComplexTypeReference().orElseThrow().getName();
+            lazyTypeDefinitionConsumer.setOrScheduleTypeDefinitionConsumer(typeName, variableLiteral::setTypeDefinition);
+        });
+        if (futureStack.empty()) {
+            futureStack = null;
+        }
+
+        parserContexts.peek().add(variableLiteral);
     }
 
     @Override
diff --git a/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringParser.java b/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringParser.java
index 9343ceb..6f7cf27 100644
--- a/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringParser.java
+++ b/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringParser.java
@@ -21,6 +21,7 @@ package org.apache.plc4x.plugins.codegenerator.language.mspec.expression;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
+import org.apache.plc4x.plugins.codegenerator.language.mspec.LazyTypeDefinitionConsumer;
 import org.apache.plc4x.plugins.codegenerator.types.terms.Term;
 
 import java.io.IOException;
@@ -28,6 +29,15 @@ import java.io.InputStream;
 
 public class ExpressionStringParser {
 
+    private final LazyTypeDefinitionConsumer lazyTypeDefinitionConsumer;
+
+    private final String rootTypeName;
+
+    public ExpressionStringParser(LazyTypeDefinitionConsumer lazyTypeDefinitionConsumer, String rootTypeName) {
+        this.lazyTypeDefinitionConsumer = lazyTypeDefinitionConsumer;
+        this.rootTypeName = rootTypeName;
+    }
+
     public Term parse(InputStream source) {
         ExpressionLexer lexer;
         try {
@@ -35,7 +45,7 @@ public class ExpressionStringParser {
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
-        ExpressionStringListener listener = new ExpressionStringListener();
+        ExpressionStringListener listener = new ExpressionStringListener(lazyTypeDefinitionConsumer, rootTypeName);
         new ParseTreeWalker().walk(listener, new ExpressionParser(new CommonTokenStream(lexer)).expressionString());
         return listener.getRoot();
     }
diff --git a/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatListener.java b/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatListener.java
index 1cff5f6..7cda954 100644
--- a/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatListener.java
+++ b/code-generation/protocol-base-mspec/src/main/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatListener.java
@@ -20,6 +20,7 @@ package org.apache.plc4x.plugins.codegenerator.language.mspec.parser;
 
 import org.antlr.v4.runtime.RuleContext;
 import org.apache.commons.io.IOUtils;
+import org.apache.plc4x.plugins.codegenerator.language.mspec.LazyTypeDefinitionConsumer;
 import org.apache.plc4x.plugins.codegenerator.language.mspec.MSpecBaseListener;
 import org.apache.plc4x.plugins.codegenerator.language.mspec.MSpecParser;
 import org.apache.plc4x.plugins.codegenerator.language.mspec.expression.ExpressionStringParser;
@@ -45,7 +46,7 @@ import java.util.*;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
-public class MessageFormatListener extends MSpecBaseListener {
+public class MessageFormatListener extends MSpecBaseListener implements LazyTypeDefinitionConsumer {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(MessageFormatListener.class);
 
@@ -67,6 +68,8 @@ public class MessageFormatListener extends MSpecBaseListener {
         return enumContexts;
     }
 
+    private String currentTypeName;
+
     @Override
     public void enterFile(MSpecParser.FileContext ctx) {
         parserContexts = new LinkedList<>();
@@ -76,6 +79,7 @@ public class MessageFormatListener extends MSpecBaseListener {
 
     @Override
     public void enterComplexType(MSpecParser.ComplexTypeContext ctx) {
+        currentTypeName = getIdString(ctx.name);
         // Set a map of attributes that should be set for all fields.
         Map<String, Term> curBatchSetAttributes = new HashMap<>();
         // Add all attributes defined in the current batchSet field.
@@ -491,7 +495,9 @@ public class MessageFormatListener extends MSpecBaseListener {
         String expressionString = getExprString(expressionContext);
         Objects.requireNonNull(expressionString, "Expression string should not be null");
         InputStream inputStream = IOUtils.toInputStream(expressionString, Charset.defaultCharset());
-        ExpressionStringParser parser = new ExpressionStringParser();
+
+        Objects.requireNonNull(currentTypeName, "expression term can only occur within a type");
+        ExpressionStringParser parser = new ExpressionStringParser(this, currentTypeName);
         try {
             return parser.parse(inputStream);
         } catch (Exception e) {
@@ -504,7 +510,7 @@ public class MessageFormatListener extends MSpecBaseListener {
         // TODO: make nullsafe
         final String variableLiteral = variableLiteralContext.getText();
         InputStream inputStream = IOUtils.toInputStream(variableLiteral, Charset.defaultCharset());
-        ExpressionStringParser parser = new ExpressionStringParser();
+        ExpressionStringParser parser = new ExpressionStringParser(this, currentTypeName);
         try {
             // As this come from a VariableLiteralContext we know that it is a VariableLiteral
             return (VariableLiteral) parser.parse(inputStream);
@@ -518,7 +524,7 @@ public class MessageFormatListener extends MSpecBaseListener {
         // TODO: make nullsafe
         final String valueLiteralContextText = valueLiteralContext.getText();
         InputStream inputStream = IOUtils.toInputStream(valueLiteralContextText, Charset.defaultCharset());
-        ExpressionStringParser parser = new ExpressionStringParser();
+        ExpressionStringParser parser = new ExpressionStringParser(this, currentTypeName);
         try {
             // As this come from a ValueLiteralContext we know that it is a Literal
             return (Literal) parser.parse(inputStream);
@@ -607,7 +613,7 @@ public class MessageFormatListener extends MSpecBaseListener {
 
     private Term parseExpression(String expressionString) {
         InputStream inputStream = IOUtils.toInputStream(expressionString, Charset.defaultCharset());
-        ExpressionStringParser parser = new ExpressionStringParser();
+        ExpressionStringParser parser = new ExpressionStringParser(this, currentTypeName);
         try {
             Term term = parser.parse(inputStream);
             return term;
@@ -654,7 +660,7 @@ public class MessageFormatListener extends MSpecBaseListener {
         return null;
     }
 
-    private void dispatchType(String typeName, TypeDefinition type) {
+    public void dispatchType(String typeName, TypeDefinition type) {
         LOGGER.debug("dispatching {}:{}", typeName, type);
         List<Consumer<TypeDefinition>> waitingConsumers = typeDefinitionConsumers.getOrDefault(typeName, new LinkedList<>());
         LOGGER.debug("{} waiting for {}", waitingConsumers.size(), typeName);
@@ -669,7 +675,8 @@ public class MessageFormatListener extends MSpecBaseListener {
         types.put(typeName, type);
     }
 
-    private void setOrScheduleTypeDefinitionConsumer(String typeRefName, Consumer<TypeDefinition> setTypeDefinition) {
+    @Override
+    public void setOrScheduleTypeDefinitionConsumer(String typeRefName, Consumer<TypeDefinition> setTypeDefinition) {
         LOGGER.debug("set or schedule {}", typeRefName);
         TypeDefinition typeDefinition = types.get(typeRefName);
         if (typeDefinition != null) {
diff --git a/code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringParserTest.java b/code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringParserTest.java
index 4034b45..bdd7581 100644
--- a/code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringParserTest.java
+++ b/code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/expression/ExpressionStringParserTest.java
@@ -32,7 +32,7 @@ import static org.hamcrest.Matchers.*;
 
 class ExpressionStringParserTest {
 
-    ExpressionStringParser SUT = new ExpressionStringParser();
+    ExpressionStringParser SUT = new ExpressionStringParser((typeRefName, setTypeDefinition) -> {}, "hurz");
 
     @Test
     void parseSimple() {
diff --git a/code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatParserTest.java b/code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatParserTest.java
index 3094a0a..63e92b5 100644
--- a/code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatParserTest.java
+++ b/code-generation/protocol-base-mspec/src/test/java/org/apache/plc4x/plugins/codegenerator/language/mspec/parser/MessageFormatParserTest.java
@@ -47,4 +47,10 @@ class MessageFormatParserTest {
         System.out.println(parse);
     }
 
+    @Test
+    void parseNothingElse() {
+        TypeContext parse = SUT.parse(getClass().getResourceAsStream("/mspec.example3"));
+        System.out.println(parse);
+    }
+
 }
\ No newline at end of file
diff --git a/code-generation/protocol-base-mspec/src/test/resources/mspec.example3 b/code-generation/protocol-base-mspec/src/test/resources/mspec.example3
new file mode 100644
index 0000000..8fa3849
--- /dev/null
+++ b/code-generation/protocol-base-mspec/src/test/resources/mspec.example3
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+[type Root
+    [simple A a]
+    [virtual uint 8 doesIt 'a.b.c']
+]
+
+[type A
+    [simple B b]
+]
+
+[type B
+    [simple C c]
+]
+
+[type C
+    [simple uint 8 nothingElseMatters]
+]
\ No newline at end of file
diff --git a/protocols/knxnetip/src/main/java/org/apache/plc4x/protocol/knxnetip/KnxNetIpProtocol.java b/protocols/knxnetip/src/main/java/org/apache/plc4x/protocol/knxnetip/KnxNetIpProtocol.java
index c926e19..5a6fd46 100644
--- a/protocols/knxnetip/src/main/java/org/apache/plc4x/protocol/knxnetip/KnxNetIpProtocol.java
+++ b/protocols/knxnetip/src/main/java/org/apache/plc4x/protocol/knxnetip/KnxNetIpProtocol.java
@@ -75,7 +75,7 @@ public class KnxNetIpProtocol implements Protocol {
         typeDefinitionMap.putAll(typeContext.getTypeDefinitions());
 
         if (typeContext.getUnresolvedTypeReferences().size() > 0) {
-            throw new GenerationException("Unresolved types left");
+            throw new GenerationException("Unresolved types left: " + typeContext.getUnresolvedTypeReferences());
         }
 
         return new TypeContext() {
diff --git a/protocols/opcua/src/main/java/org/apache/plc4x/protocol/opcua/OpcuaProtocol.java b/protocols/opcua/src/main/java/org/apache/plc4x/protocol/opcua/OpcuaProtocol.java
index 3785f82..938ed07 100644
--- a/protocols/opcua/src/main/java/org/apache/plc4x/protocol/opcua/OpcuaProtocol.java
+++ b/protocols/opcua/src/main/java/org/apache/plc4x/protocol/opcua/OpcuaProtocol.java
@@ -80,7 +80,7 @@ public class OpcuaProtocol implements Protocol {
         typeDefinitionMap.putAll(typeContext.getTypeDefinitions());
 
         if (typeContext.getUnresolvedTypeReferences().size() > 0) {
-            throw new GenerationException("Unresolved types left");
+            throw new GenerationException("Unresolved types left: " + typeContext.getUnresolvedTypeReferences());
         }
 
         return new TypeContext() {