Merge branch 'pattern-compiling'

Moderocky · Moderocky · commit 996d77bdb8fe · 2021-12-26T15:02:51.000Z
diff --git a/src/main/java/org/byteskript/skript/compiler/Pattern.java b/src/main/java/org/byteskript/skript/compiler/Pattern.java
@@ -45,12 +45,15 @@ public static Matcher fakeMatcher(String thing) {
     }
     
     protected void handle(final String string) {
-        final StringBuilder builder = new StringBuilder().append("^");
+        final StringBuilder builder = new StringBuilder();
         final List<String> types = new ArrayList<>();
-        boolean escape = false;
-        boolean input = false;
+        final List<Integer> nest = new ArrayList<>();
+        boolean escape = false,
+            input = false,
+            head = false;
+        char last = 0;
         StringBuilder current = builder;
-        for (char c : string.toCharArray()) {
+        for (final char c : string.toCharArray()) {
             if (escape) {
                 escape = false;
                 builder.append(c);
@@ -59,6 +62,7 @@ protected void handle(final String string) {
             switch (c) {
                 case ESCAPE -> escape = true;
                 case INPUT -> {
+                    if (last == END_OPTIONAL) current.append(")?");
                     if (input) {
                         input = false;
                         types.add(current.toString());
@@ -69,13 +73,37 @@ protected void handle(final String string) {
                         current = new StringBuilder();
                     }
                 }
-                case START_SWITCH, START_OPTIONAL -> current.append("(?:");
-                case END_OPTIONAL -> current.append(")?");
-                default -> current.append(c);
+                case START_SWITCH -> {
+                    if (last == END_OPTIONAL) current.append(")?");
+                    current.append("(?:");
+                }
+                case START_OPTIONAL -> {
+                    if (last == END_OPTIONAL) current.append(")?");
+                    if (last == ' ' || last == 0) nest.add(0, 1);
+                    else nest.add(0, 0);
+                    current.append("(?:");
+                }
+                case END_OPTIONAL -> {
+                    if (last == END_OPTIONAL) current.append(")?");
+                    if (nest.remove(0) > 0) head = true;
+                }
+                case ' ' -> {
+                    if (last == END_OPTIONAL && head) {
+                        current.append(c);
+                        current.append(")?");
+                    } else if (last == END_OPTIONAL) current.append(")?");
+                    else current.append(c);
+                }
+                default -> {
+                    if (last == END_OPTIONAL) current.append(")?");
+                    current.append(c);
+                    head = false;
+                }
             }
+            last = c;
         }
-        builder.append("$");
-        final java.util.regex.Pattern pattern = java.util.regex.Pattern.compile(builder.toString());
+        if (last == END_OPTIONAL) current.append(")?");
+        final java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("^" + builder.toString().trim() + "$");
         this.patternMap.put(pattern, types.toArray(new String[0]));
     }
     
@@ -125,18 +153,43 @@ protected Type[] convert(final Context context, final String... strings) {
         return types;
     }
     
-    public record Match(Matcher matcher, Object meta, Type... expected) {
+    public static final class Match {
+        private final Matcher matcher;
+        private final Object meta;
+        private final Type[] expected;
+        private final String[] groups;
+        
+        public Match(Matcher matcher, Object meta, Type... expected) {
+            this.matcher = matcher;
+            this.meta = meta;
+            this.expected = expected;
+            {
+                final List<String> list = new ArrayList<>();
+                for (int i = 1; i <= matcher.groupCount(); i++) {
+                    list.add(matcher.group(i).trim());
+                }
+                this.groups = list.toArray(new String[0]);
+            }
+        }
         
         public Match(Matcher matcher, Type... expected) {
             this(matcher, null, expected);
         }
         
         public String[] groups() {
-            final List<String> list = new ArrayList<>();
-            for (int i = 1; i <= matcher.groupCount(); i++) {
-                list.add(matcher.group(i));
-            }
-            return list.toArray(new String[0]);
+            return groups;
+        }
+        
+        public Matcher matcher() {
+            return matcher;
+        }
+        
+        public Object meta() {
+            return meta;
+        }
+        
+        public Type[] expected() {
+            return expected;
         }
         
     }
diff --git a/src/main/java/org/byteskript/skript/compiler/SimpleSkriptCompiler.java b/src/main/java/org/byteskript/skript/compiler/SimpleSkriptCompiler.java
@@ -15,6 +15,7 @@
 import org.byteskript.skript.api.syntax.Section;
 import org.byteskript.skript.compiler.structure.ProgrammaticSplitTree;
 import org.byteskript.skript.compiler.structure.SectionMeta;
+import org.byteskript.skript.error.ScriptCompileError;
 import org.byteskript.skript.error.ScriptParseError;
 
 import java.io.*;
@@ -99,7 +100,13 @@ public PostCompileClass[] compile(String file, Type path) {
             if (context.getMethod() != null) {
                 context.getMethod().writeCode(WriteInstruction.lineNumber(context.lineNumber));
             }
-            this.compileLine(line, context);
+            try {
+                this.compileLine(line, context);
+            } catch (ScriptCompileError ex) {
+                throw ex;
+            } catch (Throwable ex) {
+                throw new ScriptCompileError(context.lineNumber, "Error during compilation:", ex);
+            }
         }
         for (int i = 0; i < context.units.size(); i++) {
             context.destroyUnit();
diff --git a/src/main/java/org/byteskript/skript/lang/syntax/generic/SystemInputExpression.java b/src/main/java/org/byteskript/skript/lang/syntax/generic/SystemInputExpression.java
@@ -21,7 +21,7 @@
 public class SystemInputExpression extends SimpleExpression {
     
     public SystemInputExpression() {
-        super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[the ](system|console) input");
+        super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[the] (system|console) input");
     }
     
     @Override
diff --git a/src/main/java/org/byteskript/skript/lang/syntax/timing/MillisecondsExpression.java b/src/main/java/org/byteskript/skript/lang/syntax/timing/MillisecondsExpression.java
@@ -21,7 +21,7 @@
 public class MillisecondsExpression extends SimpleExpression {
     
     public MillisecondsExpression() {
-        super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "%Integer% m[illi[ ]]s[econd[s]]");
+        super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "%Number% (ms|millis|milli[ ]second[s])");
         try {
             handlers.put(StandardHandlers.FIND, this.getClass().getMethod("find", Object.class));
         } catch (NoSuchMethodException e) {
diff --git a/src/main/java/org/byteskript/skript/lang/syntax/timing/ThreadExpression.java b/src/main/java/org/byteskript/skript/lang/syntax/timing/ThreadExpression.java
@@ -19,7 +19,7 @@
 public class ThreadExpression extends SimpleExpression {
     
     public ThreadExpression() {
-        super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[the ][current ](process|thread)");
+        super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[the] [current] (process|thread)");
     }
     
     @Override
diff --git a/src/main/java/org/byteskript/skript/lang/syntax/type/TypeCreator.java b/src/main/java/org/byteskript/skript/lang/syntax/type/TypeCreator.java
@@ -20,7 +20,7 @@
 public class TypeCreator extends SimpleExpression {
     
     public TypeCreator() {
-        super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[a ]new %Type%");
+        super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[a] new %Type%");
         handlers.put(StandardHandlers.GET, findMethod(TypeCreator.class, "create", Object.class));
         handlers.put(StandardHandlers.FIND, findMethod(TypeCreator.class, "create", Object.class));
     }
diff --git a/src/test/java/org/byteskript/skript/test/PatternsTest.java b/src/test/java/org/byteskript/skript/test/PatternsTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2021 ByteSkript org (Moderocky)
+ * View the full licence information and permissions:
+ * https://github.com/Moderocky/ByteSkript/blob/master/LICENSE
+ */
+
+package org.byteskript.skript.test;
+
+import org.byteskript.skript.compiler.Pattern;
+import org.junit.Test;
+
+public class PatternsTest {
+    
+    @Test
+    public void simpleOptional() {
+        final Pattern pattern = new Pattern(new String[]{"[a] new thing"}, null);
+        final java.util.regex.Pattern result = pattern.getCompiledPatterns()[0];
+        assert result.pattern().equals("^(?:a )?new thing$");
+        assert result.matcher("a new thing").matches();
+        assert result.matcher("new thing").matches();
+    }
+    
+    @Test
+    public void simpleChoice() {
+        final Pattern pattern = new Pattern(new String[]{"the (new|old) thing"}, null);
+        final java.util.regex.Pattern result = pattern.getCompiledPatterns()[0];
+        assert result.pattern().equals("^the (?:new|old) thing$");
+        assert result.matcher("the new thing").matches();
+        assert result.matcher("the old thing").matches();
+    }
+    
+    @Test
+    public void optionalAndChoice() {
+        final Pattern pattern = new Pattern(new String[]{"[the] (new|old) thing"}, null);
+        final java.util.regex.Pattern result = pattern.getCompiledPatterns()[0];
+        assert result.pattern().equals("^(?:the )?(?:new|old) thing$");
+        assert result.matcher("new thing").matches();
+        assert result.matcher("old thing").matches();
+        assert result.matcher("the new thing").matches();
+    }
+    
+    @Test
+    public void optionalInChoice() {
+        final Pattern pattern = new Pattern(new String[]{"([a ]new|old) thing"}, null);
+        final java.util.regex.Pattern result = pattern.getCompiledPatterns()[0];
+        assert result.pattern().equals("^(?:(?:a )?new|old) thing$");
+        assert result.matcher("a new thing").matches();
+        assert result.matcher("old thing").matches();
+        assert result.matcher("new thing").matches();
+    }
+    
+    @Test
+    public void choiceInOptional() {
+        final Pattern pattern = new Pattern(new String[]{"[(new|old)] thing"}, null);
+        final java.util.regex.Pattern result = pattern.getCompiledPatterns()[0];
+        assert result.pattern().equals("^(?:(?:new|old) )?thing$");
+        assert result.matcher("thing").matches();
+        assert result.matcher("new thing").matches();
+        assert result.matcher("old thing").matches();
+    }
+    
+    @Test
+    public void strange() {
+        final Pattern pattern = new Pattern(new String[]{"[the] [current] (process|thread)"}, null);
+        final java.util.regex.Pattern result = pattern.getCompiledPatterns()[0];
+        assert result.pattern().equals("^(?:the )?(?:current )?(?:process|thread)$");
+        assert result.matcher("process").matches();
+        assert result.matcher("thread").matches();
+        assert result.matcher("the thread").matches();
+        assert result.matcher("current thread").matches();
+        assert result.matcher("the current thread").matches();
+    }
+    
+    @Test
+    public void strangeNested() {
+        final Pattern pattern = new Pattern(new String[]{"%Integer% (ms|millis|milli[ ]second[s])"}, null);
+        final java.util.regex.Pattern result = pattern.getCompiledPatterns()[0];
+        assert result.pattern().equals("^(.+) (?:ms|millis|milli(?: )?second(?:s)?)$");
+        assert result.matcher("4 millis").matches();
+        assert result.matcher("4 ms").matches();
+        assert !result.matcher("5 mseconds").matches();
+        assert result.matcher("5 milli seconds").matches();
+        assert result.matcher("5 milliseconds").matches();
+    }
+    
+    
+}

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@`
`21`	`21`	`public class SystemInputExpression extends SimpleExpression {`
`22`	`22`
`23`	`23`	`public SystemInputExpression() {`
`24`		`- super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[the ](system\|console) input");`
	`24`	`+ super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[the] (system\|console) input");`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`	`public class ThreadExpression extends SimpleExpression {`
`20`	`20`
`21`	`21`	`public ThreadExpression() {`
`22`		`- super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[the ][current ](process\|thread)");`
	`22`	`+ super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[the] [current] (process\|thread)");`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@`
`20`	`20`	`public class TypeCreator extends SimpleExpression {`
`21`	`21`
`22`	`22`	`public TypeCreator() {`
`23`		`- super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[a ]new %Type%");`
	`23`	`+ super(SkriptLangSpec.LIBRARY, StandardElements.EXPRESSION, "[a] new %Type%");`
`24`	`24`	`handlers.put(StandardHandlers.GET, findMethod(TypeCreator.class, "create", Object.class));`
`25`	`25`	`handlers.put(StandardHandlers.FIND, findMethod(TypeCreator.class, "create", Object.class));`
`26`	`26`	`}`