Changeset 12700

Timestamp:

May 2, 2019 1:00:03 PM (7 months ago)

Author:

tgutzmann

Message:

#5764 Use ModelicaScanner in QualifiedName to increase robustness of the implementation.

Location:

trunk/Compiler/ModelicaFrontEnd

Files:

• src/java/org/jmodelica/util/QualifiedName.java (modified) (5 diffs)
• test/junit/org/jmodelica/test/common/QualifiedNameTest.java (modified) (5 diffs)

trunk/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/QualifiedName.java

@@ -16 +16 @@
 package org.jmodelica.util;
 
+import java.io.IOException;
+import java.io.StringReader;
 import java.util.ArrayList;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
+import java.util.Iterator;
 
+import org.jmodelica.modelica.parser.ModelicaParser.Terminals;
+import org.jmodelica.modelica.parser.ModelicaScanner;
 import org.jmodelica.util.exceptions.NameFormatException;
+
+import beaver.Scanner.Exception;
+import beaver.Symbol;
 
 /**
@@ -26 +32 @@
  */
 public class QualifiedName {
-    private boolean isGlobal;
-    private int i = 0;
-    ArrayList<String> names;
-    private boolean isUnQualifiedImport;
+    private final boolean isGlobal;
+    private final ArrayList<String> names = new ArrayList<>();
+    private final boolean isUnQualifiedImport;
+    private final Iterator<String> iterator;
 
     public QualifiedName(String name) {
-        if (name.length() == 0) {
-            throw new NameFormatException("A name must have atleast one caracter"); 
-        }
         isUnQualifiedImport = name.endsWith(".*");
         isGlobal = name.startsWith(".");
-        names = splitQualifiedClassName(name);
+        splitQualifiedClassName(name);
+        iterator = names.iterator();
     }
 
-    // Interpret name as global or not regardless or dot form or not.
+    // Interpret name as global or not regardless of dot form or not.
     public QualifiedName(String name, boolean isGlobal) {
-        if (name.length() == 0) {
-            throw new NameFormatException("A name must have atleast one caracter");
-        }
-        names = splitQualifiedClassName(name); 
-        this.isGlobal = isGlobal;
-    }
-
-    public boolean hasNext() {
-        return i < names.size();
+        isUnQualifiedImport = name.endsWith(".*");
+        splitQualifiedClassName(name); 
+        this.isGlobal = isGlobal; // Note: must be set after splitting
+        iterator = names.iterator();
     }
 
@@ -56 +55 @@
         return names.size();
     }
+    
+    public boolean hasNext() {
+        return iterator.hasNext();
+    }
+    
+    public String next() {
+        return iterator.next();
+    }
 
     /**
-     * Only parse if the name is not simple, don't store the actual parts.
-     * Skips some work.
-     * @return if the name has only a single part.
+     * Checks if the name is a valid and simple (unqualified) identifier.
+     * @param name The name.
+     * @param allowGlobal If <code>true</code>, then takes 'global' notation with a leading dot into account by 
+     * ignoring such a character. 
+     * @return Whether or not <code>name</code> is a valid identifier. 
      */
-    public static int numberOfParts(String name) {
-        boolean isGlobal = name.startsWith(".");
-        if (isGlobal) {
+    public static boolean isValidSimpleIdentifier(String name, boolean allowGlobal) {
+        if (allowGlobal && name.startsWith(".")) {
             name = name.substring(1, name.length());
         }
-        Matcher m = p.matcher(name);
-        ArrayList<Integer> nameSeparations = new ArrayList<Integer>();
-        findNameSeparations(m, nameSeparations);
-        return nameSeparations.size() + 1;
-    }
-
-    public String next() {
-        return names.get(i++);
-    }
-
-    public ArrayList<String> getNames() {
-        return names;
+        ModelicaScanner ms = new ModelicaScanner(new StringReader(name));
+        try {
+           if (ms.nextToken().getId() != Terminals.ID)
+               return false;
+           if (ms.nextToken().getId() != Terminals.EOF)
+               return false;
+           return true;
+        } catch (IOException e) {
+            // This shouldn't happen when using a StringReader.
+            throw new RuntimeException("Unhandled internal error", e);
+        } catch (Exception e) {
+            // Scanner cannot handle this, so this is not a valid identifier.
+            return false;
+        }
     }
 
     @Override
     public String toString() {
-        return names.toString();
+        return (isGlobal ? "(global) " : "") + (isUnQualifiedImport ? ".* " : "") + names.toString();
     }
 
@@ -90 +100 @@
     }
 
-    static final Pattern p = Pattern.compile("(?<![\\\\])['.]");
-
-    private static void checkNameLength(int start,int end) {
-        if (end - start < 2)
-            throw new NameFormatException("Names must have a length greater than zero");
-    }
-
-    private static void findNameSeparations(Matcher m, ArrayList<Integer> list) {
-        boolean inquoted = false;
-        int prev = -1;
-        while (m.find()) {
-            String token = m.group();
-            if (token.equals("'")) {
-                if (inquoted) {
-                    checkNameLength(prev, m.start());
-                } else {
-                    if (m.start() - prev > 2) {
-                        throw new NameFormatException("Quotes not allowed inside unqouted name");
-                    }
-                }
-                prev = inquoted ? prev : m.start();
-                inquoted = !inquoted;
-            } else if (!inquoted) {
-                checkNameLength(prev, m.start());
-                prev = m.start();
-                list.add(m.start() + 1);
-            }
+    /**
+     * Splits a composite class name into all its partial accesses
+     */
+    private final void splitQualifiedClassName(String name) {
+        if (name.length() == 0) {
+            throw new NameFormatException("A name must have at least one caracter");
         }
-        if (inquoted) {
-            throw new NameFormatException("Qualified Name couldn't be interpreted due to unmatched quotes");
-        }
-    }
-
-    /**
-     * Splits a composite class name into all the partial access
-     * 
-     * @param name
-     * @return array with the names of all accessed classes.
-     */
-    private final ArrayList<String> splitQualifiedClassName(String name) {
         if (isGlobal || isUnQualifiedImport) {
             int start = isGlobal ? 1 : 0;
@@ -135 +112 @@
             name = name.substring(start, end);
         }
-        Matcher m = p.matcher(name);
-        ArrayList<Integer> nameSeparations = new ArrayList<Integer>();
-        findNameSeparations(m, nameSeparations);
-        nameSeparations.add(name.length() + 1);
-        ArrayList<String> parts = new ArrayList<String>();
-        int partEnd = 0;
-        for (int namePart = 0; namePart < nameSeparations.size() ; namePart++) {
-            parts.add(name.substring(partEnd, nameSeparations.get(namePart) - 1));
-            partEnd = nameSeparations.get(namePart);
+        ModelicaScanner ms = new ModelicaScanner(new StringReader(name));
+        try {
+            Symbol sym;
+            do {
+                sym = ms.nextToken();
+                if (sym.getId() != Terminals.ID)
+                    throw new NameFormatException("The qualified name is not valid");
+                names.add((String)sym.value);
+            } while ((sym = ms.nextToken()).getId() == Terminals.DOT);
+            if (sym.getId() != Terminals.EOF)
+                throw new NameFormatException("Invalid name: " + name);
+        } catch (IOException e) {
+            // This shouldn't happen when using a StringReader.
+            throw new RuntimeException("Unhandled internal error", e);
+        } catch (Exception e) {
+            // Identifier not valid.
+            throw new NameFormatException("Invalid name: " + name);
         }
-        return parts;
     }
 }

trunk/Compiler/ModelicaFrontEnd/test/junit/org/jmodelica/test/common/QualifiedNameTest.java

@@ -2 +2 @@
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
 
 import org.jmodelica.util.QualifiedName;
@@ -11 +13 @@
     @Test
     public void globalWithQuotedContainingExcapedDot() {
-        assertEquals("['quotedWith.Dot\\'.', secondPart]", 
+        assertEquals("(global) ['quotedWith.Dot\\'.', secondPart]", 
                 new QualifiedName(".'quotedWith.Dot\\'.'.secondPart").toString());
     }
@@ -17 +19 @@
     @Test
     public void globalDotted()  {
-        assertEquals("[first, second, third]", 
+        assertEquals("(global) [first, second, third]", 
                 new QualifiedName(".first.second.third").toString());
     }
@@ -23 +25 @@
     @Test
     public void global() {
-        assertEquals("[global]", 
+        assertEquals("(global) [global]", 
                 new QualifiedName(".global").toString());
     }
@@ -52 +54 @@
     @Test
     public void countNumberOfParts() {
-        assertEquals(4, new QualifiedName(("A.'B'.C.D")).numberOfParts());
+        assertEquals(4, new QualifiedName("A.'B'.C.D").numberOfParts());
     }
 
     @Test
     public void nonSimpleNameParts() {
-        assertEquals(4, QualifiedName.numberOfParts(".A.'B'.C.D"));
+        assertEquals(4, new QualifiedName(".A.'B'.C.D").numberOfParts());
     }
     
     @Test
     public void globalSimpleNameParts() {
-        assertEquals(1, QualifiedName.numberOfParts(".'A'"));
+        assertTrue(QualifiedName.isValidSimpleIdentifier(".'A'", true));
     }
-    
+
+    @Test
+    public void globalSimpleNamePartsNegative() {
+        assertFalse(QualifiedName.isValidSimpleIdentifier(".'A'", false));
+    }
+
     @Test
     public void nameFromUnqualifiedImport() {
-        assertEquals("[A, B, C]", new QualifiedName("A.B.C.*").toString());
+        assertEquals(".* [A, B, C]", new QualifiedName("A.B.C.*").toString());
     }