mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-27 10:03:11 +07:00
Merge remote-tracking branch 'origin/master'
This commit is contained in:
Vladislav.Soroka
@@ -1,78 +0,0 @@
|
||||
/*
|
||||
* Copyright 2006 Sascha Weinreuter
|
||||
*
|
||||
* Licensed 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.
|
||||
*/
|
||||
package org.intellij.lang.regexp;
|
||||
|
||||
import com.intellij.openapi.application.PathManager;
|
||||
import com.intellij.openapi.application.Result;
|
||||
import com.intellij.openapi.command.WriteCommandAction;
|
||||
import com.intellij.openapi.fileTypes.FileTypeManager;
|
||||
import com.intellij.openapi.project.Project;
|
||||
import com.intellij.testFramework.UsefulTestCase;
|
||||
import com.intellij.testFramework.fixtures.CodeInsightTestFixture;
|
||||
import com.intellij.testFramework.fixtures.IdeaProjectTestFixture;
|
||||
import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory;
|
||||
import com.intellij.testFramework.fixtures.TestFixtureBuilder;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import java.io.File;
|
||||
|
||||
public abstract class BaseParseTestCase extends UsefulTestCase {
|
||||
protected CodeInsightTestFixture myFixture;
|
||||
|
||||
@Override
|
||||
protected void setUp() throws Exception {
|
||||
super.setUp();
|
||||
final IdeaTestFixtureFactory fixtureFactory = IdeaTestFixtureFactory.getFixtureFactory();
|
||||
final TestFixtureBuilder<IdeaProjectTestFixture> builder = fixtureFactory.createFixtureBuilder(getName());
|
||||
|
||||
myFixture = fixtureFactory.createCodeInsightFixture(builder.getFixture());
|
||||
myFixture.setTestDataPath(getTestDataPath());
|
||||
myFixture.setUp();
|
||||
|
||||
final Project project = myFixture.getProject();
|
||||
|
||||
new WriteCommandAction(project) {
|
||||
@Override
|
||||
protected void run(@NotNull Result result) throws Throwable {
|
||||
FileTypeManager.getInstance().registerFileType(RegExpFileType.INSTANCE, new String[]{"regexp"});
|
||||
}
|
||||
}.execute();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void tearDown() throws Exception {
|
||||
try {
|
||||
myFixture.tearDown();
|
||||
}
|
||||
finally {
|
||||
myFixture = null;
|
||||
super.tearDown();
|
||||
}
|
||||
}
|
||||
|
||||
public static String getTestDataRoot() {
|
||||
String homePath = PathManager.getHomePath();
|
||||
File candidate = new File(homePath, "community/RegExpSupport");
|
||||
if (candidate.isDirectory()) {
|
||||
return new File(candidate, "testData").getPath();
|
||||
}
|
||||
return new File(homePath, "RegExpSupport/testData").getPath();
|
||||
}
|
||||
|
||||
protected String getTestDataPath() {
|
||||
return getTestDataRoot() + "/psi";
|
||||
}
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
/*
|
||||
* Copyright 2006 Sascha Weinreuter
|
||||
*
|
||||
* Licensed 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.
|
||||
*/
|
||||
package org.intellij.lang.regexp;
|
||||
|
||||
public class ParseTest extends BaseParseTestCase {
|
||||
|
||||
//public void test0() throws Throwable {
|
||||
// myFixture.testHighlighting("test0.regexp");
|
||||
//}
|
||||
public void test1() throws Throwable {
|
||||
myFixture.testHighlighting("test1.regexp");
|
||||
}
|
||||
public void test2() throws Throwable {
|
||||
myFixture.testHighlighting("test2.regexp");
|
||||
}
|
||||
public void test3() throws Throwable {
|
||||
myFixture.testHighlighting("test3.regexp");
|
||||
}
|
||||
public void test4() throws Throwable {
|
||||
myFixture.testHighlighting("test4.regexp");
|
||||
}
|
||||
}
|
||||
+49
-70
@@ -15,8 +15,11 @@
|
||||
*/
|
||||
package org.intellij.lang.regexp;
|
||||
|
||||
import com.intellij.openapi.application.PathManager;
|
||||
import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixtureTestCase;
|
||||
import org.jdom.Document;
|
||||
import org.jdom.Element;
|
||||
import org.jdom.JDOMException;
|
||||
import org.jdom.input.SAXBuilder;
|
||||
import org.jdom.xpath.XPath;
|
||||
|
||||
@@ -27,19 +30,19 @@ import java.util.Map;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.regex.PatternSyntaxException;
|
||||
|
||||
public class RegExpParseTest extends BaseParseTestCase {
|
||||
public class RegExpHighlightingTest extends LightPlatformCodeInsightFixtureTestCase {
|
||||
|
||||
private ByteArrayOutputStream myOut;
|
||||
private static final ByteArrayOutputStream myOut;
|
||||
|
||||
enum Result {
|
||||
OK, ERR
|
||||
}
|
||||
|
||||
static class Test {
|
||||
String pattern;
|
||||
final String pattern;
|
||||
final Result expectedResult;
|
||||
boolean showWarnings = true;
|
||||
boolean showInfo = false;
|
||||
Result expectedResult;
|
||||
String regExpHost = null;
|
||||
|
||||
Test(String pattern, Result result, boolean warn, boolean info, String host) {
|
||||
@@ -51,56 +54,52 @@ public class RegExpParseTest extends BaseParseTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
private final Map<String, Test> myMap = new LinkedHashMap<String, Test>();
|
||||
private static final Map<String, Test> myMap = new LinkedHashMap<String, Test>();
|
||||
static {
|
||||
try {
|
||||
final Document document = new SAXBuilder().build(new File(PathManager.getHomePath(),"community/RegExpSupport/testData/RETest.xml"));
|
||||
final List<Element> list = XPath.selectNodes(document.getRootElement(), "//test");
|
||||
|
||||
@Override
|
||||
protected void setUp() throws Exception {
|
||||
final Document document = new SAXBuilder().build(new File(getTestDataRoot(), "/RETest.xml"));
|
||||
final List<Element> list = XPath.selectNodes(document.getRootElement(), "//test");
|
||||
|
||||
int i = 0;
|
||||
for (Element element : list) {
|
||||
final String name;
|
||||
final Element parent = (Element)element.getParent();
|
||||
final String s = parent.getName();
|
||||
final String t = parent.getAttribute("id") == null ? "" : parent.getAttribute("id").getValue() + "-";
|
||||
if (!"tests".equals(s)) {
|
||||
name = s + "/test-" + t + ++i + ".regexp";
|
||||
}
|
||||
else {
|
||||
name = "test-" + t + ++i + ".regexp";
|
||||
}
|
||||
final Result result = Result.valueOf((String)XPath.selectSingleNode(element, "string(expected)"));
|
||||
final boolean warn = !"false".equals(element.getAttributeValue("warning"));
|
||||
final boolean info = "true".equals(element.getAttributeValue("info"));
|
||||
final String host = element.getAttributeValue("host");
|
||||
|
||||
final String pattern = (String)XPath.selectSingleNode(element, "string(pattern)");
|
||||
myMap.put(name, new Test(pattern, result, warn, info, host));
|
||||
if (!"false".equals(element.getAttributeValue("verify")) && host == null) {
|
||||
try {
|
||||
Pattern.compile(pattern);
|
||||
if (result == Result.ERR) {
|
||||
System.out.println("Incorrect FAIL value for " + pattern);
|
||||
}
|
||||
int i = 0;
|
||||
for (Element element : list) {
|
||||
final String name;
|
||||
final Element parent = (Element)element.getParent();
|
||||
final String s = parent.getName();
|
||||
final String t = parent.getAttribute("id") == null ? "" : parent.getAttribute("id").getValue() + "-";
|
||||
if (!"tests".equals(s)) {
|
||||
name = s + "/test-" + t + ++i + ".regexp";
|
||||
}
|
||||
catch (PatternSyntaxException e) {
|
||||
if (result == Result.OK) {
|
||||
System.out.println("Incorrect OK value for " + pattern);
|
||||
else {
|
||||
name = "test-" + t + ++i + ".regexp";
|
||||
}
|
||||
final Result result = Result.valueOf((String)XPath.selectSingleNode(element, "string(expected)"));
|
||||
final boolean warn = !"false".equals(element.getAttributeValue("warning"));
|
||||
final boolean info = "true".equals(element.getAttributeValue("info"));
|
||||
final String host = element.getAttributeValue("host");
|
||||
|
||||
final String pattern = (String)XPath.selectSingleNode(element, "string(pattern)");
|
||||
myMap.put(name, new Test(pattern, result, warn, info, host));
|
||||
if (!"false".equals(element.getAttributeValue("verify")) && host == null) {
|
||||
try {
|
||||
Pattern.compile(pattern);
|
||||
if (result == Result.ERR) {
|
||||
System.out.println("Incorrect FAIL value for " + pattern);
|
||||
}
|
||||
}
|
||||
catch (PatternSyntaxException e) {
|
||||
if (result == Result.OK) {
|
||||
System.out.println("Incorrect OK value for " + pattern);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
myOut = new ByteArrayOutputStream();
|
||||
System.setErr(new PrintStream(myOut));
|
||||
}
|
||||
catch (JDOMException | IOException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
|
||||
super.setUp();
|
||||
|
||||
myOut = new ByteArrayOutputStream();
|
||||
System.setErr(new PrintStream(myOut));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String getTestDataPath() {
|
||||
return super.getTestDataPath() + "/gen/";
|
||||
}
|
||||
|
||||
public void testOptions() throws Exception {
|
||||
@@ -127,10 +126,6 @@ public class RegExpParseTest extends BaseParseTestCase {
|
||||
doTest("escapes/");
|
||||
}
|
||||
|
||||
public void testAnchors() throws Exception {
|
||||
doTest("anchors/");
|
||||
}
|
||||
|
||||
public void testNamedchars() throws Exception {
|
||||
doTest("namedchars/");
|
||||
}
|
||||
@@ -139,18 +134,6 @@ public class RegExpParseTest extends BaseParseTestCase {
|
||||
doTest("backrefs/");
|
||||
}
|
||||
|
||||
public void testComplex() throws Exception {
|
||||
doTest("complex/");
|
||||
}
|
||||
|
||||
public void testIncomplete() throws Exception {
|
||||
doTest("incomplete/");
|
||||
}
|
||||
|
||||
public void testRealLife() throws Exception {
|
||||
doTest("real-life/");
|
||||
}
|
||||
|
||||
public void testRegressions() throws Exception {
|
||||
doTest("regressions/");
|
||||
}
|
||||
@@ -159,10 +142,6 @@ public class RegExpParseTest extends BaseParseTestCase {
|
||||
doTest("bug/");
|
||||
}
|
||||
|
||||
public void testFromXML() throws Exception {
|
||||
doTest(null);
|
||||
}
|
||||
|
||||
private void doTest(String prefix) throws IOException {
|
||||
int n = 0;
|
||||
int failed = 0;
|
||||
@@ -176,7 +155,7 @@ public class RegExpParseTest extends BaseParseTestCase {
|
||||
System.out.print("filename = " + name);
|
||||
n++;
|
||||
|
||||
final RegExpParseTest.Test test = myMap.get(name);
|
||||
final Test test = myMap.get(name);
|
||||
try {
|
||||
if (test.regExpHost != null) {
|
||||
final Class<RegExpLanguageHost> aClass = (Class<RegExpLanguageHost>)Class.forName(test.regExpHost);
|
||||
@@ -218,7 +197,7 @@ public class RegExpParseTest extends BaseParseTestCase {
|
||||
}
|
||||
}
|
||||
else {
|
||||
System.out.println("ERROR: " + myOut.toString());
|
||||
System.out.println("ERROR: " + myOut);
|
||||
}
|
||||
}
|
||||
failed++;
|
||||
@@ -0,0 +1,326 @@
|
||||
/*
|
||||
* Copyright 2000-2016 JetBrains s.r.o.
|
||||
*
|
||||
* Licensed 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.
|
||||
*/
|
||||
package org.intellij.lang.regexp;
|
||||
|
||||
import com.intellij.openapi.application.PathManager;
|
||||
import com.intellij.testFramework.ParsingTestCase;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* @author Bas Leijdekkers
|
||||
*/
|
||||
public class RegExpParsingTest extends ParsingTestCase {
|
||||
|
||||
public RegExpParsingTest() {
|
||||
super("psi", "regexp", new RegExpParserDefinition());
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String getTestDataPath() {
|
||||
return PathManager.getHomePath() + "/community/RegExpSupport/testData/";
|
||||
}
|
||||
|
||||
public void testSimple1() throws IOException { doCodeTest("|"); }
|
||||
public void testSimple2() throws IOException { doCodeTest("(|\\$.*)\\.class"); }
|
||||
public void testSimple3() throws IOException { doCodeTest("abc"); }
|
||||
public void testSimple4() throws IOException { doCodeTest("multiple words of text"); }
|
||||
public void testSimple5() throws IOException { doCodeTest("ab|cd"); }
|
||||
public void testSimple6() throws IOException { doCodeTest("a*"); }
|
||||
public void testSimple7() throws IOException { doCodeTest("ab*c"); }
|
||||
public void testSimple8() throws IOException { doCodeTest("ab*bc"); }
|
||||
public void testSimple9() throws IOException { doCodeTest("ab+bc"); }
|
||||
public void testSimple10() throws IOException { doCodeTest("ab?bc"); }
|
||||
public void testSimple11() throws IOException { doCodeTest("ab?c"); }
|
||||
public void testSimple12() throws IOException { doCodeTest("a.c"); }
|
||||
public void testSimple13() throws IOException { doCodeTest("a.*c"); }
|
||||
public void testSimple14() throws IOException { doCodeTest("*a"); }
|
||||
public void testSimple15() throws IOException { doCodeTest("a{1}"); }
|
||||
public void testSimple16() throws IOException { doCodeTest("a{}"); }
|
||||
public void testSimple17() throws IOException { doCodeTest("a{"); }
|
||||
public void testSimple18() throws IOException { doCodeTest("a}"); }
|
||||
public void testSimple19() throws IOException { doCodeTest("a{1,}"); }
|
||||
public void testSimple20() throws IOException { doCodeTest("a{1,2}"); }
|
||||
public void testSimple21() throws IOException { doCodeTest("a{1,foo}"); }
|
||||
public void testSimple22() throws IOException { doCodeTest("\\;"); }
|
||||
|
||||
public void testQuantifiers1() throws IOException { doCodeTest("a?"); }
|
||||
public void testQuantifiers2() throws IOException { doCodeTest("a+"); }
|
||||
public void testQuantifiers3() throws IOException { doCodeTest("a*"); }
|
||||
public void testQuantifiers4() throws IOException { doCodeTest("a??"); }
|
||||
public void testQuantifiers5() throws IOException { doCodeTest("a+?"); }
|
||||
public void testQuantifiers6() throws IOException { doCodeTest("a*?"); }
|
||||
public void testQuantifiers7() throws IOException { doCodeTest("a?+"); }
|
||||
public void testQuantifiers8() throws IOException { doCodeTest("a++"); }
|
||||
public void testQuantifiers9() throws IOException { doCodeTest("a*+"); }
|
||||
public void testQuantifiers10() throws IOException { doCodeTest("a**"); }
|
||||
public void testQuantifiers11() throws IOException { doCodeTest("a{2}"); }
|
||||
public void testQuantifiers12() throws IOException { doCodeTest("a{1,2}"); }
|
||||
public void testQuantifiers13() throws IOException { doCodeTest("a{2,1}"); }
|
||||
public void testQuantifiers14() throws IOException { doCodeTest("a{0,1}"); }
|
||||
public void testQuantifiers15() throws IOException { doCodeTest("a{1,}"); }
|
||||
public void testQuantifiers16() throws IOException { doCodeTest("a{0,}"); }
|
||||
public void testQuantifiers17() throws IOException { doCodeTest("a{1}"); }
|
||||
public void testQuantifiers18() throws IOException { doCodeTest("a{3,3}"); }
|
||||
public void testQuantifiers19() throws IOException { doCodeTest("a{"); }
|
||||
public void testQuantifiers20() throws IOException { doCodeTest("a}"); }
|
||||
public void testQuantifiers21() throws IOException { doCodeTest("a{}"); }
|
||||
|
||||
public void testCharclasses1() throws IOException { doCodeTest("a[bc]d"); }
|
||||
public void testCharclasses2() throws IOException { doCodeTest("a[b-d]e"); }
|
||||
public void testCharclasses3() throws IOException { doCodeTest("a[b-d]"); }
|
||||
public void testCharclasses4() throws IOException { doCodeTest("a[b-a]"); }
|
||||
public void testCharclasses5() throws IOException { doCodeTest("a[-b]"); }
|
||||
public void testCharclasses6() throws IOException { doCodeTest("a[b-]"); }
|
||||
public void testCharclasses7() throws IOException { doCodeTest("[a-[b]]"); }
|
||||
public void testCharclasses8() throws IOException { doCodeTest("a[b&&[cd]]"); }
|
||||
public void testCharclasses9() throws IOException { doCodeTest("a[b-&&[cd]]"); }
|
||||
public void testCharclasses10() throws IOException { doCodeTest("a[b&&-]"); }
|
||||
public void testCharclasses11() throws IOException { doCodeTest("a[b&&-b]"); }
|
||||
public void testCharclasses12() throws IOException { doCodeTest("[&&]"); }
|
||||
public void testCharclasses13() throws IOException { doCodeTest("[&&[^\\d]]"); }
|
||||
public void testCharclasses14() throws IOException { doCodeTest("[a&&]"); }
|
||||
public void testCharclasses15() throws IOException { doCodeTest("a[b&&c&&d]"); }
|
||||
public void testCharclasses16() throws IOException { doCodeTest("a[b&&c&&d-e&&f]"); }
|
||||
public void testCharclasses17() throws IOException { doCodeTest("[a&&]"); }
|
||||
public void testCharclasses18() throws IOException { doCodeTest("a[a[b][c]]"); }
|
||||
public void testCharclasses19() throws IOException { doCodeTest("[a-[]]"); }
|
||||
public void testCharclasses20() throws IOException { doCodeTest("[a-[b"); }
|
||||
public void testCharclasses21() throws IOException { doCodeTest("[a[^b]]"); }
|
||||
public void testCharclasses22() throws IOException { doCodeTest("a[a[b[c]][d]]"); }
|
||||
public void testCharclasses23() throws IOException { doCodeTest("a[\\t--]"); }
|
||||
public void testCharclasses24() throws IOException { doCodeTest("a[\\t--]"); }
|
||||
public void testCharclasses25() throws IOException { doCodeTest("a[\\t---]"); }
|
||||
public void testCharclasses26() throws IOException { doCodeTest("a[-]?c"); }
|
||||
public void testCharclasses27() throws IOException { doCodeTest("a["); }
|
||||
public void testCharclasses28() throws IOException { doCodeTest("a]"); }
|
||||
public void testCharclasses29() throws IOException { doCodeTest("[a-["); }
|
||||
public void testCharclasses30() throws IOException { doCodeTest("a[]]"); }
|
||||
public void testCharclasses31() throws IOException { doCodeTest("a[^bc]d"); }
|
||||
public void testCharclasses32() throws IOException { doCodeTest("a[^bc]"); }
|
||||
public void testCharclasses33() throws IOException { doCodeTest("a[]b"); }
|
||||
public void testCharclasses34() throws IOException { doCodeTest("[^]"); }
|
||||
public void testCharclasses35() throws IOException { doCodeTest("[abhgefdc]ij"); }
|
||||
public void testCharclasses36() throws IOException { doCodeTest("[a-zA-Z_][a-zA-Z0-9_]*"); }
|
||||
public void testCharclasses37() throws IOException { doCodeTest("([a-c]+?)c"); }
|
||||
public void testCharclasses38() throws IOException { doCodeTest("([ab]*?)b"); }
|
||||
public void testCharclasses39() throws IOException { doCodeTest("([ab]*)b"); }
|
||||
public void testCharclasses40() throws IOException { doCodeTest("([ab]??)b"); }
|
||||
public void testCharclasses41() throws IOException { doCodeTest("(c[ab]?)b"); }
|
||||
public void testCharclasses42() throws IOException { doCodeTest("(c[ab]??)b"); }
|
||||
public void testCharclasses43() throws IOException { doCodeTest("(c[ab]*?)b"); }
|
||||
public void testCharclasses44() throws IOException { doCodeTest("a[bcd]+dcdcde"); }
|
||||
public void testCharclasses45() throws IOException { doCodeTest("[k]"); }
|
||||
public void testCharclasses46() throws IOException { doCodeTest("a[bcd]*dcdcde"); }
|
||||
public void testCharclasses47() throws IOException { doCodeTest("[^ab]*"); }
|
||||
public void testCharclasses48() throws IOException { doCodeTest("a[.]b"); }
|
||||
public void testCharclasses49() throws IOException { doCodeTest("a[+*?]b"); }
|
||||
public void testCharclasses50() throws IOException { doCodeTest("a[\\p{IsDigit}\\p{IsAlpha}]b"); }
|
||||
public void testCharclasses51() throws IOException { doCodeTest("[\\p{L}&&[^\\p{Lu}]]"); }
|
||||
public void testCharclasses52() throws IOException { doCodeTest("\\pL\\pM\\pZ\\pS\\pN\\pP\\pC\\PL\\PM\\PZ\\PS\\PN\\PP\\PC"); }
|
||||
public void testCharclasses53() throws IOException { doCodeTest("\\pA"); }
|
||||
public void testCharclasses54() throws IOException { doCodeTest("\\pl"); }
|
||||
public void testCharclasses55() throws IOException { doCodeTest("a\\p"); }
|
||||
public void testCharclasses56() throws IOException { doCodeTest("a\\p{}"); }
|
||||
public void testCharclasses57() throws IOException { doCodeTest("a\\p}"); }
|
||||
public void testCharclasses58() throws IOException { doCodeTest("a\\p{123}"); }
|
||||
public void testCharclasses59() throws IOException { doCodeTest("[\\p{nothing}]"); }
|
||||
public void testCharclasses60() throws IOException { doCodeTest("a\\p{*}b"); }
|
||||
public void testCharclasses61() throws IOException { doCodeTest("[\\w-\\w]"); }
|
||||
public void testCharclasses62() throws IOException { doCodeTest("[a-\\w]"); }
|
||||
public void testCharclasses63() throws IOException { doCodeTest("(?x)abc #foo \\q bar\n# foo\n(?-xi)xyz(?i:ABC)"); }
|
||||
public void testCharclasses64() throws IOException { doCodeTest("[\\ud800\\udc00-\\udbff\\udfff]"); }
|
||||
public void testCharclasses65() throws IOException { doCodeTest("\\R"); }
|
||||
public void testCharclasses66() throws IOException { doCodeTest("\\X"); }
|
||||
public void testCharclasses67() throws IOException { doCodeTest("\\-[\\*\\-\\[\\]\\\\\\+]"); }
|
||||
public void testCharclasses68() throws IOException { doCodeTest("[\\b]"); }
|
||||
|
||||
public void testGroups1() throws IOException { doCodeTest("()ef"); }
|
||||
public void testGroups2() throws IOException { doCodeTest("()*"); }
|
||||
public void testGroups3() throws IOException { doCodeTest("()"); }
|
||||
public void testGroups4() throws IOException { doCodeTest("(|)"); }
|
||||
public void testGroups5() throws IOException { doCodeTest("(*)b"); }
|
||||
public void testGroups6() throws IOException { doCodeTest("((a))"); }
|
||||
public void testGroups7() throws IOException { doCodeTest("(a)b(c)"); }
|
||||
public void testGroups8() throws IOException { doCodeTest("(a*)*"); }
|
||||
public void testGroups9() throws IOException { doCodeTest("(a*)+"); }
|
||||
public void testGroups10() throws IOException { doCodeTest("(a|)*"); }
|
||||
public void testGroups11() throws IOException { doCodeTest("(ab|cd)e"); }
|
||||
public void testGroups12() throws IOException { doCodeTest("(.*)c(.*)"); }
|
||||
public void testGroups13() throws IOException { doCodeTest("\\((.*), (.*)\\)"); }
|
||||
public void testGroups14() throws IOException { doCodeTest("a(bc)d"); }
|
||||
public void testGroups15() throws IOException { doCodeTest("([abc])*d"); }
|
||||
public void testGroups16() throws IOException { doCodeTest("((((((((((a)))))))))"); }
|
||||
public void testGroups17() throws IOException { doCodeTest("([abc])*bcd"); }
|
||||
public void testGroups18() throws IOException { doCodeTest("(a|b)c*d"); }
|
||||
public void testGroups19() throws IOException { doCodeTest("a([bc]*)c*"); }
|
||||
public void testGroups20() throws IOException { doCodeTest("((a)(b)c)(d)"); }
|
||||
public void testGroups21() throws IOException { doCodeTest("(ab|a)b*c"); }
|
||||
public void testGroups22() throws IOException { doCodeTest("(ab|ab*)bc"); }
|
||||
public void testGroups23() throws IOException { doCodeTest("(a|b|c|d|e)f"); }
|
||||
public void testGroups24() throws IOException { doCodeTest("a([bc]*)(c*d)"); }
|
||||
public void testGroups25() throws IOException { doCodeTest("a([bc]+)(c*d)"); }
|
||||
public void testGroups26() throws IOException { doCodeTest("a([bc]*)(c+d)"); }
|
||||
public void testGroups27() throws IOException { doCodeTest("(a+|b)*"); }
|
||||
public void testGroups28() throws IOException { doCodeTest("(a+|b)+"); }
|
||||
public void testGroups29() throws IOException { doCodeTest("(a+|b)?"); }
|
||||
public void testGroups30() throws IOException { doCodeTest("(^*"); }
|
||||
public void testGroups31() throws IOException { doCodeTest(")("); }
|
||||
public void testGroups32() throws IOException { doCodeTest("(?i:*)"); }
|
||||
public void testGroups33() throws IOException { doCodeTest("(?<asdf>[a-c])\\1"); }
|
||||
public void testGroups34() throws IOException { doCodeTest("(?<asdf>[a-c])\\k<asdf>"); }
|
||||
public void testGroups35() throws IOException { doCodeTest("\\k<adsf>"); }
|
||||
|
||||
public void testEscapes1() throws IOException { doCodeTest("\\q"); }
|
||||
public void testEscapes2() throws IOException { doCodeTest("\\#"); }
|
||||
public void testEscapes3() throws IOException { doCodeTest("a\\"); }
|
||||
public void testEscapes4() throws IOException { doCodeTest("a\\(b"); }
|
||||
public void testEscapes5() throws IOException { doCodeTest("a\\(*b"); }
|
||||
public void testEscapes6() throws IOException { doCodeTest("a\\\\b"); }
|
||||
public void testEscapes7() throws IOException { doCodeTest("\\u004a"); }
|
||||
public void testEscapes8() throws IOException { doCodeTest("\\0123"); }
|
||||
public void testEscapes9() throws IOException { doCodeTest("\\0"); }
|
||||
public void testEscapes10() throws IOException { doCodeTest("\\x4a"); }
|
||||
public void testEscapes11() throws IOException { doCodeTest("\\x{0}"); }
|
||||
public void testEscapes12() throws IOException { doCodeTest("\\x{2011F}"); }
|
||||
public void testEscapes13() throws IOException { doCodeTest("[\\x4a-\\x4b]"); }
|
||||
public void testEscapes14() throws IOException { doCodeTest("[a-a]"); }
|
||||
public void testEscapes15() throws IOException { doCodeTest("[\\x4a-\\x3f]"); }
|
||||
public void testEscapes16() throws IOException { doCodeTest("[\\udbff\\udfff-\\ud800\\udc00]"); }
|
||||
public void testEscapes17() throws IOException { doCodeTest("[\\ud800\\udc00-\\udbff\\udfff]"); }
|
||||
public void testEscapes18() throws IOException { doCodeTest("[z-a]"); }
|
||||
public void testEscapes19() throws IOException { doCodeTest("[a-z]"); }
|
||||
public void testEscapes20() throws IOException { doCodeTest("a\\Qabc?*+.))]][]\\Eb"); }
|
||||
public void testEscapes21() throws IOException { doCodeTest("(a\\Qabc?*+.))]][]\\Eb)"); }
|
||||
public void testEscapes22() throws IOException { doCodeTest("[\\Qabc?*+.))]][]\\E]"); }
|
||||
public void testEscapes23() throws IOException { doCodeTest("a\\Qabc?*+.))]][]\\E)"); }
|
||||
public void testEscapes24() throws IOException { doCodeTest("\\Q\\j\\E"); }
|
||||
public void testEscapes25() throws IOException { doCodeTest("\\c0"); }
|
||||
|
||||
public void testAnchors1() throws IOException { doCodeTest("^*"); }
|
||||
public void testAnchors2() throws IOException { doCodeTest("$*"); }
|
||||
public void testAnchors3() throws IOException { doCodeTest("^abc"); }
|
||||
public void testAnchors4() throws IOException { doCodeTest("^abc$"); }
|
||||
public void testAnchors5() throws IOException { doCodeTest("abc$"); }
|
||||
public void testAnchors6() throws IOException { doCodeTest("^"); }
|
||||
public void testAnchors7() throws IOException { doCodeTest("$"); }
|
||||
public void testAnchors8() throws IOException { doCodeTest("$b"); }
|
||||
public void testAnchors9() throws IOException { doCodeTest("^(ab|cd)e"); }
|
||||
public void testAnchors10() throws IOException { doCodeTest("^a(bc+|b[eh])g|.h$"); }
|
||||
|
||||
public void testNamedchars1() throws IOException { doCodeTest("a*b\\s+c"); }
|
||||
public void testNamedchars2() throws IOException { doCodeTest("\\d+"); }
|
||||
public void testNamedchars3() throws IOException { doCodeTest("^\\p{javaJavaIdentifierStart}+\\p{javaJavaIdentifierPart}+$"); }
|
||||
public void testNamedchars4() throws IOException { doCodeTest("\\p{IsDigit}\\p{IsAlpha}"); }
|
||||
public void testNamedchars5() throws IOException { doCodeTest("\\p{InLATIN_1_SUPPLEMENT}"); }
|
||||
public void testNamedchars6() throws IOException { doCodeTest("[a-e]?d\\\\e"); }
|
||||
public void testNamedchars7() throws IOException { doCodeTest("((\\w+)/)*(\\w+)"); }
|
||||
public void testNamedchars8() throws IOException { doCodeTest("\\p{Digit}+"); }
|
||||
public void testNamedchars9() throws IOException { doCodeTest("[:xdigit:]+"); }
|
||||
public void testNamedchars10() throws IOException { doCodeTest("\\p{unknown}+"); }
|
||||
|
||||
public void testBackrefs1() throws IOException { doCodeTest("(ac*)c*d[ac]*\\1"); }
|
||||
public void testBackrefs2() throws IOException { doCodeTest("(.)=\\1"); }
|
||||
public void testBackrefs3() throws IOException { doCodeTest("([ab])=\\1"); }
|
||||
public void testBackrefs4() throws IOException { doCodeTest("([ab]+)=\\1"); }
|
||||
public void testBackrefs5() throws IOException { doCodeTest("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\\105"); }
|
||||
public void testBackrefs6() throws IOException { doCodeTest("(.)\\11"); }
|
||||
public void testBackrefs7() throws IOException { doCodeTest("([ab]+)=\\2"); }
|
||||
public void testBackrefs8() throws IOException { doCodeTest("([ab]+)=\\3"); }
|
||||
public void testBackrefs9() throws IOException { doCodeTest("([ab]+=\\1)"); }
|
||||
|
||||
public void testComplex1() throws IOException { doCodeTest("z(\\w\\s+(?:\\w\\s+\\w)+)z"); }
|
||||
public void testComplex2() throws IOException { doCodeTest("(([hH][tT]{2}[pP]|[fF][tT][pP]):\\/\\/)?[a-zA-Z0-9\\-]+(\\.[a-zA-Z0-9\\-]+)*"); }
|
||||
public void testComplex3() throws IOException { doCodeTest("((?:[hH][tT]{2}[pP]|[fF][tT][pP]):\\/\\/)?[a-zA-Z0-9\\-]+(\\.[a-zA-Z0-9\\-]+)*"); }
|
||||
public void testComplex4() throws IOException { doCodeTest("(([hH][tT]{2}[pP]|[fF][tT][pP]):\\/\\/)?[a-zA-Z0-9\\-]+(?:\\.[a-zA-Z0-9\\-]+)*"); }
|
||||
public void testComplex5() throws IOException { doCodeTest("(?:([hH][tT]{2}[pP]|[fF][tT][pP]):\\/\\/)?[a-zA-Z0-9\\-]+(\\.[a-zA-Z0-9\\-]+)*"); }
|
||||
public void testComplex6() throws IOException { doCodeTest("^(?:([hH][tT]{2}[pP]|[fF][tT][pP]):\\/\\/)?[a-zA-Z0-9\\-]+(\\.[a-zA-Z0-9\\-]+)*$"); }
|
||||
public void testComplex7() throws IOException { doCodeTest("^(?:(?:[hH][tT]{2}[pP]|[fF][tT][pP]):\\/\\/)?[a-zA-Z0-9\\-]+(?:\\.[a-zA-Z0-9\\-]+)*$"); }
|
||||
|
||||
public void testIncomplete1() throws IOException { doCodeTest("abc\\"); }
|
||||
public void testIncomplete2() throws IOException { doCodeTest("abc[\\"); }
|
||||
public void testIncomplete3() throws IOException { doCodeTest("abc\\x"); }
|
||||
public void testIncomplete4() throws IOException { doCodeTest("abc\\x1"); }
|
||||
public void testIncomplete5() throws IOException { doCodeTest("abc\\x{"); }
|
||||
public void testIncomplete6() throws IOException { doCodeTest("abc\\x{}"); }
|
||||
public void testIncomplete7() throws IOException { doCodeTest("abc\\x{0"); }
|
||||
public void testIncomplete8() throws IOException { doCodeTest("abc\\u"); }
|
||||
public void testIncomplete9() throws IOException { doCodeTest("abc\\u22"); }
|
||||
public void testIncomplete10() throws IOException { doCodeTest("\\Qabc"); }
|
||||
public void testIncomplete11() throws IOException { doCodeTest("\\Q"); }
|
||||
public void testIncomplete12() throws IOException { doCodeTest("\\E"); }
|
||||
public void testIncomplete13() throws IOException { doCodeTest("a|*"); }
|
||||
|
||||
public void testRegressions1() throws IOException { doCodeTest("("); }
|
||||
public void testRegressions2() throws IOException { doCodeTest("[^^]"); }
|
||||
public void testRegressions3() throws IOException { doCodeTest("a)b"); }
|
||||
public void testRegressions4() throws IOException { doCodeTest("\\s*@return(?:s)?\\s*(?:(?:\\{|:)?\\s*(?([^\\s\\}]+)\\s*\\}?\\s*)?(.*)"); }
|
||||
|
||||
public void testOptions1() throws IOException { doCodeTest("(?iZm)abc"); }
|
||||
public void testOptions2() throws IOException { doCodeTest("(?idmsuxU)nice"); }
|
||||
public void testOptions3() throws IOException { doCodeTest("(?idm-suxU)one(?suxU-idm)two"); }
|
||||
|
||||
public void testTests1() throws IOException { doCodeTest("abc)"); }
|
||||
public void testTests2() throws IOException { doCodeTest("(abc"); }
|
||||
public void testTests3() throws IOException { doCodeTest("a+b+c"); }
|
||||
public void testTests4() throws IOException { doCodeTest("a**"); }
|
||||
public void testTests5() throws IOException { doCodeTest("a++"); }
|
||||
public void testTests6() throws IOException { doCodeTest("ab*"); }
|
||||
public void testTests7() throws IOException { doCodeTest("abcd*efg"); }
|
||||
public void testTests8() throws IOException { doCodeTest("a|b|c|d|e"); }
|
||||
public void testTests9() throws IOException { doCodeTest("(bc+d$|ef*g.|h?i(j|k))"); }
|
||||
public void testTests10() throws IOException { doCodeTest("a*(b*c*)"); }
|
||||
public void testTests11() throws IOException { doCodeTest("a?b+c*"); }
|
||||
public void testTests12() throws IOException { doCodeTest("i am a green (giant|man|martian)"); }
|
||||
public void testTests13() throws IOException { doCodeTest("(wee|week)(knights|knight)"); }
|
||||
public void testTests14() throws IOException { doCodeTest("(a.*b)(a.*b)"); }
|
||||
public void testTests15() throws IOException { doCodeTest("(\\s*\\w+)?"); }
|
||||
public void testTests16() throws IOException { doCodeTest("(?:a)"); }
|
||||
public void testTests17() throws IOException { doCodeTest("(?:\\w)"); }
|
||||
public void testTests18() throws IOException { doCodeTest("(?:\\w\\s\\w)+"); }
|
||||
public void testTests19() throws IOException { doCodeTest("(a\\w)(?:,(a\\w))+"); }
|
||||
public void testTests20() throws IOException { doCodeTest("abc.*?x+yz"); }
|
||||
public void testTests21() throws IOException { doCodeTest("abc.+?x+yz"); }
|
||||
public void testTests22() throws IOException { doCodeTest("a.+?(c|d)"); }
|
||||
public void testTests23() throws IOException { doCodeTest("a.+(c|d)"); }
|
||||
public void testTests24() throws IOException { doCodeTest("a+?b+?c+?"); }
|
||||
|
||||
public void testRealLife1() throws IOException { doCodeTest("x:found=\"(true|false)\""); }
|
||||
public void testRealLife2() throws IOException { doCodeTest("(?:\\s)|(?:/\\*.*\\*/)|(?://[^\\n]*)"); }
|
||||
public void testRealLife3() throws IOException { doCodeTest("((?:\\p{Alpha}\\:)?[0-9 a-z_A-Z\\-\\\\./]+)"); }
|
||||
public void testRealLife4() throws IOException { doCodeTest("^[\\w\\+\\.\\-]{2,}:"); }
|
||||
public void testRealLife5() throws IOException { doCodeTest("#(.*)$"); }
|
||||
public void testRealLife6() throws IOException { doCodeTest("^(([^:]+)://)?([^:/]+)(:([0-9]+))?(/.*)"); }
|
||||
public void testRealLife7() throws IOException { doCodeTest("(([^:]+)://)?([^:/]+)(:([0-9]+))?(/.*)"); }
|
||||
public void testRealLife8() throws IOException { doCodeTest("usd [+-]?[0-9]+.[0-9][0-9]"); }
|
||||
public void testRealLife9() throws IOException { doCodeTest("\\b(\\w+)(\\s+\\1)+\\b"); }
|
||||
public void testRealLife10() throws IOException { doCodeTest(".*?(<(error|warning|info)(?: descr=\"((?:[^\"\\\\]|\\\\\")*)\")?(?: type=\"([0-9A-Z_]+)\")?(?: foreground=\"([0-9xa-f]+)\")?(?: background=\"([0-9xa-f]+)\")?(?: effectcolor=\"([0-9xa-f]+)\")?(?: effecttype=\"([A-Z]+)\")?(?: fonttype=\"([0-9]+)\")?(/)?>)(.*)"); }
|
||||
|
||||
public void testBug1() throws IOException { doCodeTest("[{][\\w\\.]*[}]"); }
|
||||
public void testBug2() throws IOException { doCodeTest("[a-z0-9!\\#$%&'*+/=?^_`{|}~-]+"); }
|
||||
public void testBug3() throws IOException { doCodeTest("[\\{]"); }
|
||||
public void testBug4() throws IOException { doCodeTest("{"); }
|
||||
public void testBug5() throws IOException { doCodeTest("\\{"); }
|
||||
public void testBug6() throws IOException { doCodeTest("(<=\\s)-{3,}(?>\\s)"); }
|
||||
public void testBug7() throws IOException { doCodeTest("(?x)a\\ b\\ c"); }
|
||||
public void testBug8() throws IOException { doCodeTest("a\\ b"); }
|
||||
public void testBug9() throws IOException { doCodeTest("(^|\\.)\\*(?=(\\.|$))"); }
|
||||
public void testBug10() throws IOException { doCodeTest("\\h \\H \\v \\V"); }
|
||||
|
||||
public void testParse1() throws IOException { doCodeTest("123 | 456"); }
|
||||
public void testParse2() throws IOException { doCodeTest("1**"); }
|
||||
public void testParse3() throws IOException { doCodeTest("(([hH][tT]{2}[pP]|[fF][tT][pP])://)?[a-zA-Z0-9\\-]+(\\.[a-zA-Z0-9\\-]+)*"); }
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,8 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <^*>
|
||||
RegExpBranchImpl: <^*>
|
||||
RegExpClosureImpl: <^*>
|
||||
RegExpBoundaryImpl: <^>
|
||||
PsiElement(CARET)('^')
|
||||
RegExpQuantifierImpl: <*>
|
||||
PsiElement(STAR)('*')
|
||||
@@ -0,0 +1,41 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <^a(bc+|b[eh])g|.h$>
|
||||
RegExpBranchImpl: <^a(bc+|b[eh])g>
|
||||
RegExpBoundaryImpl: <^>
|
||||
PsiElement(CARET)('^')
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpGroupImpl: <(bc+|b[eh])>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <bc+|b[eh]>
|
||||
RegExpBranchImpl: <bc+>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpClosureImpl: <c+>
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpQuantifierImpl: <+>
|
||||
PsiElement(PLUS)('+')
|
||||
PsiElement(UNION)('|')
|
||||
RegExpBranchImpl: <b[eh]>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpClassImpl: <[eh]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <eh>
|
||||
RegExpCharImpl: <e>
|
||||
PsiElement(CHARACTER)('e')
|
||||
RegExpCharImpl: <h>
|
||||
PsiElement(CHARACTER)('h')
|
||||
PsiElement(CLASS_END)(']')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <g>
|
||||
PsiElement(CHARACTER)('g')
|
||||
PsiElement(UNION)('|')
|
||||
RegExpBranchImpl: <.h$>
|
||||
RegExpSimpleClassImpl: <.>
|
||||
PsiElement(DOT)('.')
|
||||
RegExpCharImpl: <h>
|
||||
PsiElement(CHARACTER)('h')
|
||||
RegExpBoundaryImpl: <$>
|
||||
PsiElement(DOLLAR)('$')
|
||||
@@ -0,0 +1,8 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <$*>
|
||||
RegExpBranchImpl: <$*>
|
||||
RegExpClosureImpl: <$*>
|
||||
RegExpBoundaryImpl: <$>
|
||||
PsiElement(DOLLAR)('$')
|
||||
RegExpQuantifierImpl: <*>
|
||||
PsiElement(STAR)('*')
|
||||
@@ -0,0 +1,11 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <^abc>
|
||||
RegExpBranchImpl: <^abc>
|
||||
RegExpBoundaryImpl: <^>
|
||||
PsiElement(CARET)('^')
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
@@ -0,0 +1,13 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <^abc$>
|
||||
RegExpBranchImpl: <^abc$>
|
||||
RegExpBoundaryImpl: <^>
|
||||
PsiElement(CARET)('^')
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpBoundaryImpl: <$>
|
||||
PsiElement(DOLLAR)('$')
|
||||
@@ -0,0 +1,11 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <abc$>
|
||||
RegExpBranchImpl: <abc$>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpBoundaryImpl: <$>
|
||||
PsiElement(DOLLAR)('$')
|
||||
@@ -0,0 +1,5 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <^>
|
||||
RegExpBranchImpl: <^>
|
||||
RegExpBoundaryImpl: <^>
|
||||
PsiElement(CARET)('^')
|
||||
@@ -0,0 +1,5 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <$>
|
||||
RegExpBranchImpl: <$>
|
||||
RegExpBoundaryImpl: <$>
|
||||
PsiElement(DOLLAR)('$')
|
||||
@@ -0,0 +1,7 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <$b>
|
||||
RegExpBranchImpl: <$b>
|
||||
RegExpBoundaryImpl: <$>
|
||||
PsiElement(DOLLAR)('$')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,22 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <^(ab|cd)e>
|
||||
RegExpBranchImpl: <^(ab|cd)e>
|
||||
RegExpBoundaryImpl: <^>
|
||||
PsiElement(CARET)('^')
|
||||
RegExpGroupImpl: <(ab|cd)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <ab|cd>
|
||||
RegExpBranchImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(UNION)('|')
|
||||
RegExpBranchImpl: <cd>
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <e>
|
||||
PsiElement(CHARACTER)('e')
|
||||
@@ -0,0 +1,35 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(ac*)c*d[ac]*\1>
|
||||
RegExpBranchImpl: <(ac*)c*d[ac]*\1>
|
||||
RegExpGroupImpl: <(ac*)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <ac*>
|
||||
RegExpBranchImpl: <ac*>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClosureImpl: <c*>
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpQuantifierImpl: <*>
|
||||
PsiElement(STAR)('*')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpClosureImpl: <c*>
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpQuantifierImpl: <*>
|
||||
PsiElement(STAR)('*')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
RegExpClosureImpl: <[ac]*>
|
||||
RegExpClassImpl: <[ac]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ac>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <*>
|
||||
PsiElement(STAR)('*')
|
||||
RegExpBackrefImpl: <\1>
|
||||
PsiElement(BACKREF)('\1')
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(.)=\1>
|
||||
RegExpBranchImpl: <(.)=\1>
|
||||
RegExpGroupImpl: <(.)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <.>
|
||||
RegExpBranchImpl: <.>
|
||||
RegExpSimpleClassImpl: <.>
|
||||
PsiElement(DOT)('.')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <=>
|
||||
PsiElement(CHARACTER)('=')
|
||||
RegExpBackrefImpl: <\1>
|
||||
PsiElement(BACKREF)('\1')
|
||||
@@ -0,0 +1,20 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <([ab])=\1>
|
||||
RegExpBranchImpl: <([ab])=\1>
|
||||
RegExpGroupImpl: <([ab])>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <[ab]>
|
||||
RegExpBranchImpl: <[ab]>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <=>
|
||||
PsiElement(CHARACTER)('=')
|
||||
RegExpBackrefImpl: <\1>
|
||||
PsiElement(BACKREF)('\1')
|
||||
@@ -0,0 +1,23 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <([ab]+)=\1>
|
||||
RegExpBranchImpl: <([ab]+)=\1>
|
||||
RegExpGroupImpl: <([ab]+)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <[ab]+>
|
||||
RegExpBranchImpl: <[ab]+>
|
||||
RegExpClosureImpl: <[ab]+>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <+>
|
||||
PsiElement(PLUS)('+')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <=>
|
||||
PsiElement(CHARACTER)('=')
|
||||
RegExpBackrefImpl: <\1>
|
||||
PsiElement(BACKREF)('\1')
|
||||
@@ -0,0 +1,77 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\105>
|
||||
RegExpBranchImpl: <(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\105>
|
||||
RegExpGroupImpl: <(a)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <a>
|
||||
RegExpBranchImpl: <a>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpGroupImpl: <(b)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <b>
|
||||
RegExpBranchImpl: <b>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpGroupImpl: <(c)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <c>
|
||||
RegExpBranchImpl: <c>
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpGroupImpl: <(d)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <d>
|
||||
RegExpBranchImpl: <d>
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpGroupImpl: <(e)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <e>
|
||||
RegExpBranchImpl: <e>
|
||||
RegExpCharImpl: <e>
|
||||
PsiElement(CHARACTER)('e')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpGroupImpl: <(f)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <f>
|
||||
RegExpBranchImpl: <f>
|
||||
RegExpCharImpl: <f>
|
||||
PsiElement(CHARACTER)('f')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpGroupImpl: <(g)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <g>
|
||||
RegExpBranchImpl: <g>
|
||||
RegExpCharImpl: <g>
|
||||
PsiElement(CHARACTER)('g')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpGroupImpl: <(h)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <h>
|
||||
RegExpBranchImpl: <h>
|
||||
RegExpCharImpl: <h>
|
||||
PsiElement(CHARACTER)('h')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpGroupImpl: <(i)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <i>
|
||||
RegExpBranchImpl: <i>
|
||||
RegExpCharImpl: <i>
|
||||
PsiElement(CHARACTER)('i')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpGroupImpl: <(j)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <j>
|
||||
RegExpBranchImpl: <j>
|
||||
RegExpCharImpl: <j>
|
||||
PsiElement(CHARACTER)('j')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpBackrefImpl: <\10>
|
||||
PsiElement(BACKREF)('\10')
|
||||
RegExpCharImpl: <5>
|
||||
PsiElement(CHARACTER)('5')
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(.)\11>
|
||||
RegExpBranchImpl: <(.)\11>
|
||||
RegExpGroupImpl: <(.)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <.>
|
||||
RegExpBranchImpl: <.>
|
||||
RegExpSimpleClassImpl: <.>
|
||||
PsiElement(DOT)('.')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpBackrefImpl: <\1>
|
||||
PsiElement(BACKREF)('\1')
|
||||
RegExpCharImpl: <1>
|
||||
PsiElement(CHARACTER)('1')
|
||||
@@ -0,0 +1,23 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <([ab]+)=\2>
|
||||
RegExpBranchImpl: <([ab]+)=\2>
|
||||
RegExpGroupImpl: <([ab]+)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <[ab]+>
|
||||
RegExpBranchImpl: <[ab]+>
|
||||
RegExpClosureImpl: <[ab]+>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <+>
|
||||
PsiElement(PLUS)('+')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <=>
|
||||
PsiElement(CHARACTER)('=')
|
||||
RegExpBackrefImpl: <\2>
|
||||
PsiElement(BACKREF)('\2')
|
||||
@@ -0,0 +1,23 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <([ab]+)=\3>
|
||||
RegExpBranchImpl: <([ab]+)=\3>
|
||||
RegExpGroupImpl: <([ab]+)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <[ab]+>
|
||||
RegExpBranchImpl: <[ab]+>
|
||||
RegExpClosureImpl: <[ab]+>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <+>
|
||||
PsiElement(PLUS)('+')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <=>
|
||||
PsiElement(CHARACTER)('=')
|
||||
RegExpBackrefImpl: <\3>
|
||||
PsiElement(BACKREF)('\3')
|
||||
@@ -0,0 +1,23 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <([ab]+=\1)>
|
||||
RegExpBranchImpl: <([ab]+=\1)>
|
||||
RegExpGroupImpl: <([ab]+=\1)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <[ab]+=\1>
|
||||
RegExpBranchImpl: <[ab]+=\1>
|
||||
RegExpClosureImpl: <[ab]+>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <+>
|
||||
PsiElement(PLUS)('+')
|
||||
RegExpCharImpl: <=>
|
||||
PsiElement(CHARACTER)('=')
|
||||
RegExpBackrefImpl: <\1>
|
||||
PsiElement(BACKREF)('\1')
|
||||
PsiElement(GROUP_END)(')')
|
||||
@@ -0,0 +1,24 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[{][\w\.]*[}]>
|
||||
RegExpBranchImpl: <[{][\w\.]*[}]>
|
||||
RegExpClassImpl: <[{]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <{>
|
||||
PsiElement(LBRACE)('{')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpClosureImpl: <[\w\.]*>
|
||||
RegExpClassImpl: <[\w\.]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <\w\.>
|
||||
RegExpSimpleClassImpl: <\w>
|
||||
PsiElement(CHAR_CLASS)('\w')
|
||||
RegExpCharImpl: <\.>
|
||||
PsiElement(REDUNDANT_ESCAPE)('\.')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <*>
|
||||
PsiElement(STAR)('*')
|
||||
RegExpClassImpl: <[}]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <}>
|
||||
PsiElement(CHARACTER)('}')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,17 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <\h \H \v \V>
|
||||
RegExpBranchImpl: <\h \H \v \V>
|
||||
RegExpSimpleClassImpl: <\h>
|
||||
PsiElement(CHAR_CLASS)('\h')
|
||||
RegExpCharImpl: < >
|
||||
PsiElement(CHARACTER)(' ')
|
||||
RegExpSimpleClassImpl: <\H>
|
||||
PsiElement(CHAR_CLASS)('\H')
|
||||
RegExpCharImpl: < >
|
||||
PsiElement(CHARACTER)(' ')
|
||||
RegExpSimpleClassImpl: <\v>
|
||||
PsiElement(CHAR_CLASS)('\v')
|
||||
RegExpCharImpl: < >
|
||||
PsiElement(CHARACTER)(' ')
|
||||
RegExpSimpleClassImpl: <\V>
|
||||
PsiElement(CHAR_CLASS)('\V')
|
||||
@@ -0,0 +1,60 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[a-z0-9!\#$%&'*+/=?^_`{|}~-]+>
|
||||
RegExpBranchImpl: <[a-z0-9!\#$%&'*+/=?^_`{|}~-]+>
|
||||
RegExpClosureImpl: <[a-z0-9!\#$%&'*+/=?^_`{|}~-]+>
|
||||
RegExpClassImpl: <[a-z0-9!\#$%&'*+/=?^_`{|}~-]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <a-z0-9!\#$%&'*+/=?^_`{|}~->
|
||||
RegExpCharRangeImpl: <a-z>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <z>
|
||||
PsiElement(CHARACTER)('z')
|
||||
RegExpCharRangeImpl: <0-9>
|
||||
RegExpCharImpl: <0>
|
||||
PsiElement(CHARACTER)('0')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <9>
|
||||
PsiElement(CHARACTER)('9')
|
||||
RegExpCharImpl: <!>
|
||||
PsiElement(CHARACTER)('!')
|
||||
RegExpCharImpl: <\#>
|
||||
PsiElement(REDUNDANT_ESCAPE)('\#')
|
||||
RegExpCharImpl: <$>
|
||||
PsiElement(CHARACTER)('$')
|
||||
RegExpCharImpl: <%>
|
||||
PsiElement(CHARACTER)('%')
|
||||
RegExpCharImpl: <&>
|
||||
PsiElement(CHARACTER)('&')
|
||||
RegExpCharImpl: <'>
|
||||
PsiElement(CHARACTER)(''')
|
||||
RegExpCharImpl: <*>
|
||||
PsiElement(CHARACTER)('*')
|
||||
RegExpCharImpl: <+>
|
||||
PsiElement(CHARACTER)('+')
|
||||
RegExpCharImpl: </>
|
||||
PsiElement(CHARACTER)('/')
|
||||
RegExpCharImpl: <=>
|
||||
PsiElement(CHARACTER)('=')
|
||||
RegExpCharImpl: <?>
|
||||
PsiElement(CHARACTER)('?')
|
||||
RegExpCharImpl: <^>
|
||||
PsiElement(CARET)('^')
|
||||
RegExpCharImpl: <_>
|
||||
PsiElement(CHARACTER)('_')
|
||||
RegExpCharImpl: <`>
|
||||
PsiElement(CHARACTER)('`')
|
||||
RegExpCharImpl: <{>
|
||||
PsiElement(LBRACE)('{')
|
||||
RegExpCharImpl: <|>
|
||||
PsiElement(CHARACTER)('|')
|
||||
RegExpCharImpl: <}>
|
||||
PsiElement(CHARACTER)('}')
|
||||
RegExpCharImpl: <~>
|
||||
PsiElement(CHARACTER)('~')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <+>
|
||||
PsiElement(PLUS)('+')
|
||||
@@ -0,0 +1,8 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[\{]>
|
||||
RegExpBranchImpl: <[\{]>
|
||||
RegExpClassImpl: <[\{]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <\{>
|
||||
PsiElement(REDUNDANT_ESCAPE)('\{')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,4 @@
|
||||
REGEXP_FILE
|
||||
PsiErrorElement:Dangling metacharacter
|
||||
<empty list>
|
||||
PsiElement(LBRACE)('{')
|
||||
@@ -0,0 +1,5 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <\{>
|
||||
RegExpBranchImpl: <\{>
|
||||
RegExpCharImpl: <\{>
|
||||
PsiElement(ESC_CHARACTER)('\{')
|
||||
@@ -0,0 +1,29 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(<=\s)-{3,}(?>\s)>
|
||||
RegExpBranchImpl: <(<=\s)-{3,}(?>\s)>
|
||||
RegExpGroupImpl: <(<=\s)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <<=\s>
|
||||
RegExpBranchImpl: <<=\s>
|
||||
RegExpCharImpl: <<>
|
||||
PsiElement(CHARACTER)('<')
|
||||
RegExpCharImpl: <=>
|
||||
PsiElement(CHARACTER)('=')
|
||||
RegExpSimpleClassImpl: <\s>
|
||||
PsiElement(CHAR_CLASS)('\s')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpClosureImpl: <-{3,}>
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpQuantifierImpl: <{3,}>
|
||||
PsiElement(LBRACE)('{')
|
||||
PsiElement(NUMBER)('3')
|
||||
PsiElement(COMMA)(',')
|
||||
PsiElement(RBRACE)('}')
|
||||
RegExpGroupImpl: <(?>\s)>
|
||||
PsiElement(NON_CAPT_GROUP)('(?>')
|
||||
RegExpPatternImpl: <\s>
|
||||
RegExpBranchImpl: <\s>
|
||||
RegExpSimpleClassImpl: <\s>
|
||||
PsiElement(CHAR_CLASS)('\s')
|
||||
PsiElement(GROUP_END)(')')
|
||||
@@ -0,0 +1,18 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(?x)a\ b\ c>
|
||||
RegExpBranchImpl: <(?x)a\ b\ c>
|
||||
RegExpSetOptionsImpl: <(?x)>
|
||||
PsiElement(SET_OPTIONS)('(?')
|
||||
RegExpOptionsImpl: <x>
|
||||
PsiElement(OPTIONS_ON)('x')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <\ >
|
||||
PsiElement(CHARACTER)('\ ')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <\ >
|
||||
PsiElement(CHARACTER)('\ ')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
@@ -0,0 +1,9 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a\ b>
|
||||
RegExpBranchImpl: <a\ b>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <\ >
|
||||
PsiElement(REDUNDANT_ESCAPE)('\ ')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,32 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(^|\.)\*(?=(\.|$))>
|
||||
RegExpBranchImpl: <(^|\.)\*(?=(\.|$))>
|
||||
RegExpGroupImpl: <(^|\.)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <^|\.>
|
||||
RegExpBranchImpl: <^>
|
||||
RegExpBoundaryImpl: <^>
|
||||
PsiElement(CARET)('^')
|
||||
PsiElement(UNION)('|')
|
||||
RegExpBranchImpl: <\.>
|
||||
RegExpCharImpl: <\.>
|
||||
PsiElement(ESC_CHARACTER)('\.')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <\*>
|
||||
PsiElement(ESC_CHARACTER)('\*')
|
||||
RegExpGroupImpl: <(?=(\.|$))>
|
||||
PsiElement(POS_LOOKAHEAD)('(?=')
|
||||
RegExpPatternImpl: <(\.|$)>
|
||||
RegExpBranchImpl: <(\.|$)>
|
||||
RegExpGroupImpl: <(\.|$)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <\.|$>
|
||||
RegExpBranchImpl: <\.>
|
||||
RegExpCharImpl: <\.>
|
||||
PsiElement(ESC_CHARACTER)('\.')
|
||||
PsiElement(UNION)('|')
|
||||
RegExpBranchImpl: <$>
|
||||
RegExpBoundaryImpl: <$>
|
||||
PsiElement(DOLLAR)('$')
|
||||
PsiElement(GROUP_END)(')')
|
||||
PsiElement(GROUP_END)(')')
|
||||
@@ -0,0 +1,15 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[bc]d>
|
||||
RegExpBranchImpl: <a[bc]d>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[bc]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <bc>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[b&&-]>
|
||||
RegExpBranchImpl: <a[b&&-]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[b&&-]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpIntersectionImpl: <b&&->
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(ANDAND)('&&')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,17 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[b&&-b]>
|
||||
RegExpBranchImpl: <a[b&&-b]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[b&&-b]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpIntersectionImpl: <b&&-b>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(ANDAND)('&&')
|
||||
RegExpUnionImpl: <-b>
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,8 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[&&]>
|
||||
RegExpBranchImpl: <[&&]>
|
||||
RegExpClassImpl: <[&&]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpIntersectionImpl: <&&>
|
||||
PsiElement(ANDAND)('&&')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[&&[^\d]]>
|
||||
RegExpBranchImpl: <[&&[^\d]]>
|
||||
RegExpClassImpl: <[&&[^\d]]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpIntersectionImpl: <&&[^\d]>
|
||||
PsiElement(ANDAND)('&&')
|
||||
RegExpClassImpl: <[^\d]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
PsiElement(CARET)('^')
|
||||
RegExpSimpleClassImpl: <\d>
|
||||
PsiElement(CHAR_CLASS)('\d')
|
||||
PsiElement(CLASS_END)(']')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,10 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[a&&]>
|
||||
RegExpBranchImpl: <[a&&]>
|
||||
RegExpClassImpl: <[a&&]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpIntersectionImpl: <a&&>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
PsiElement(ANDAND)('&&')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,17 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[b&&c&&d]>
|
||||
RegExpBranchImpl: <a[b&&c&&d]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[b&&c&&d]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpIntersectionImpl: <b&&c&&d>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(ANDAND)('&&')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(ANDAND)('&&')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,24 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[b&&c&&d-e&&f]>
|
||||
RegExpBranchImpl: <a[b&&c&&d-e&&f]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[b&&c&&d-e&&f]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpIntersectionImpl: <b&&c&&d-e&&f>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(ANDAND)('&&')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(ANDAND)('&&')
|
||||
RegExpCharRangeImpl: <d-e>
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <e>
|
||||
PsiElement(CHARACTER)('e')
|
||||
PsiElement(ANDAND)('&&')
|
||||
RegExpCharImpl: <f>
|
||||
PsiElement(CHARACTER)('f')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,10 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[a&&]>
|
||||
RegExpBranchImpl: <[a&&]>
|
||||
RegExpClassImpl: <[a&&]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpIntersectionImpl: <a&&>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
PsiElement(ANDAND)('&&')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,21 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[a[b][c]]>
|
||||
RegExpBranchImpl: <a[a[b][c]]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[a[b][c]]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <a[b][c]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[b]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpClassImpl: <[c]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(CLASS_END)(']')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,16 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[a-[]]>
|
||||
RegExpBranchImpl: <[a-[]]>
|
||||
RegExpClassImpl: <[a-[]]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpClassImpl: <[]]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <]>
|
||||
PsiElement(CHARACTER)(']')
|
||||
PsiElement(CLASS_END)(']')
|
||||
PsiErrorElement:Unclosed character class
|
||||
<empty list>
|
||||
@@ -0,0 +1,16 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[b-d]e>
|
||||
RegExpBranchImpl: <a[b-d]e>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[b-d]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharRangeImpl: <b-d>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpCharImpl: <e>
|
||||
PsiElement(CHARACTER)('e')
|
||||
@@ -0,0 +1,15 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[a-[b>
|
||||
RegExpBranchImpl: <[a-[b>
|
||||
RegExpClassImpl: <[a-[b>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpClassImpl: <[b>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiErrorElement:Unclosed character class
|
||||
<empty list>
|
||||
@@ -0,0 +1,15 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[a[^b]]>
|
||||
RegExpBranchImpl: <[a[^b]]>
|
||||
RegExpClassImpl: <[a[^b]]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <a[^b]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[^b]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
PsiElement(CARET)('^')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,27 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[a[b[c]][d]]>
|
||||
RegExpBranchImpl: <a[a[b[c]][d]]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[a[b[c]][d]]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <a[b[c]][d]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[b[c]]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <b[c]>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpClassImpl: <[c]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(CLASS_END)(']')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpClassImpl: <[d]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
PsiElement(CLASS_END)(']')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[\t--]>
|
||||
RegExpBranchImpl: <a[\t--]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[\t--]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharRangeImpl: <\t-->
|
||||
RegExpCharImpl: <\t>
|
||||
PsiElement(ESC_CTRL_CHARACTER)('\t')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[\t--]>
|
||||
RegExpBranchImpl: <a[\t--]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[\t--]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharRangeImpl: <\t-->
|
||||
RegExpCharImpl: <\t>
|
||||
PsiElement(ESC_CTRL_CHARACTER)('\t')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,17 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[\t---]>
|
||||
RegExpBranchImpl: <a[\t---]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[\t---]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <\t--->
|
||||
RegExpCharRangeImpl: <\t-->
|
||||
RegExpCharImpl: <\t>
|
||||
PsiElement(ESC_CTRL_CHARACTER)('\t')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,15 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[-]?c>
|
||||
RegExpBranchImpl: <a[-]?c>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClosureImpl: <[-]?>
|
||||
RegExpClassImpl: <[-]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <?>
|
||||
PsiElement(QUEST)('?')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
@@ -0,0 +1,9 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[>
|
||||
RegExpBranchImpl: <a[>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
PsiErrorElement:Unclosed character class
|
||||
<empty list>
|
||||
@@ -0,0 +1,7 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a]>
|
||||
RegExpBranchImpl: <a]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <]>
|
||||
PsiElement(CHARACTER)(']')
|
||||
@@ -0,0 +1,13 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[a-[>
|
||||
RegExpBranchImpl: <[a-[>
|
||||
RegExpClassImpl: <[a-[>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpClassImpl: <[>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
PsiErrorElement:Unclosed character class
|
||||
<empty list>
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[b-d]>
|
||||
RegExpBranchImpl: <a[b-d]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[b-d]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharRangeImpl: <b-d>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,10 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[]]>
|
||||
RegExpBranchImpl: <a[]]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[]]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <]>
|
||||
PsiElement(CHARACTER)(']')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,16 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[^bc]d>
|
||||
RegExpBranchImpl: <a[^bc]d>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[^bc]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
PsiElement(CARET)('^')
|
||||
RegExpUnionImpl: <bc>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[^bc]>
|
||||
RegExpBranchImpl: <a[^bc]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[^bc]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
PsiElement(CARET)('^')
|
||||
RegExpUnionImpl: <bc>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[]b>
|
||||
RegExpBranchImpl: <a[]b>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[]b>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <]b>
|
||||
RegExpCharImpl: <]>
|
||||
PsiElement(CHARACTER)(']')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiErrorElement:Unclosed character class
|
||||
<empty list>
|
||||
@@ -0,0 +1,10 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[^]>
|
||||
RegExpBranchImpl: <[^]>
|
||||
RegExpClassImpl: <[^]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
PsiElement(CARET)('^')
|
||||
RegExpCharImpl: <]>
|
||||
PsiElement(CHARACTER)(']')
|
||||
PsiErrorElement:Unclosed character class
|
||||
<empty list>
|
||||
@@ -0,0 +1,27 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[abhgefdc]ij>
|
||||
RegExpBranchImpl: <[abhgefdc]ij>
|
||||
RegExpClassImpl: <[abhgefdc]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <abhgefdc>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <h>
|
||||
PsiElement(CHARACTER)('h')
|
||||
RegExpCharImpl: <g>
|
||||
PsiElement(CHARACTER)('g')
|
||||
RegExpCharImpl: <e>
|
||||
PsiElement(CHARACTER)('e')
|
||||
RegExpCharImpl: <f>
|
||||
PsiElement(CHARACTER)('f')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpCharImpl: <i>
|
||||
PsiElement(CHARACTER)('i')
|
||||
RegExpCharImpl: <j>
|
||||
PsiElement(CHARACTER)('j')
|
||||
@@ -0,0 +1,48 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[a-zA-Z_][a-zA-Z0-9_]*>
|
||||
RegExpBranchImpl: <[a-zA-Z_][a-zA-Z0-9_]*>
|
||||
RegExpClassImpl: <[a-zA-Z_]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <a-zA-Z_>
|
||||
RegExpCharRangeImpl: <a-z>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <z>
|
||||
PsiElement(CHARACTER)('z')
|
||||
RegExpCharRangeImpl: <A-Z>
|
||||
RegExpCharImpl: <A>
|
||||
PsiElement(CHARACTER)('A')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <Z>
|
||||
PsiElement(CHARACTER)('Z')
|
||||
RegExpCharImpl: <_>
|
||||
PsiElement(CHARACTER)('_')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpClosureImpl: <[a-zA-Z0-9_]*>
|
||||
RegExpClassImpl: <[a-zA-Z0-9_]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <a-zA-Z0-9_>
|
||||
RegExpCharRangeImpl: <a-z>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <z>
|
||||
PsiElement(CHARACTER)('z')
|
||||
RegExpCharRangeImpl: <A-Z>
|
||||
RegExpCharImpl: <A>
|
||||
PsiElement(CHARACTER)('A')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <Z>
|
||||
PsiElement(CHARACTER)('Z')
|
||||
RegExpCharRangeImpl: <0-9>
|
||||
RegExpCharImpl: <0>
|
||||
PsiElement(CHARACTER)('0')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <9>
|
||||
PsiElement(CHARACTER)('9')
|
||||
RegExpCharImpl: <_>
|
||||
PsiElement(CHARACTER)('_')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <*>
|
||||
PsiElement(STAR)('*')
|
||||
@@ -0,0 +1,23 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <([a-c]+?)c>
|
||||
RegExpBranchImpl: <([a-c]+?)c>
|
||||
RegExpGroupImpl: <([a-c]+?)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <[a-c]+?>
|
||||
RegExpBranchImpl: <[a-c]+?>
|
||||
RegExpClosureImpl: <[a-c]+?>
|
||||
RegExpClassImpl: <[a-c]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharRangeImpl: <a-c>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <+?>
|
||||
PsiElement(PLUS)('+')
|
||||
PsiElement(QUEST)('?')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
@@ -0,0 +1,22 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <([ab]*?)b>
|
||||
RegExpBranchImpl: <([ab]*?)b>
|
||||
RegExpGroupImpl: <([ab]*?)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <[ab]*?>
|
||||
RegExpBranchImpl: <[ab]*?>
|
||||
RegExpClosureImpl: <[ab]*?>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <*?>
|
||||
PsiElement(STAR)('*')
|
||||
PsiElement(QUEST)('?')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,21 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <([ab]*)b>
|
||||
RegExpBranchImpl: <([ab]*)b>
|
||||
RegExpGroupImpl: <([ab]*)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <[ab]*>
|
||||
RegExpBranchImpl: <[ab]*>
|
||||
RegExpClosureImpl: <[ab]*>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <*>
|
||||
PsiElement(STAR)('*')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[b-a]>
|
||||
RegExpBranchImpl: <a[b-a]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[b-a]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharRangeImpl: <b-a>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,22 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <([ab]??)b>
|
||||
RegExpBranchImpl: <([ab]??)b>
|
||||
RegExpGroupImpl: <([ab]??)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <[ab]??>
|
||||
RegExpBranchImpl: <[ab]??>
|
||||
RegExpClosureImpl: <[ab]??>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <??>
|
||||
PsiElement(QUEST)('?')
|
||||
PsiElement(QUEST)('?')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,23 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(c[ab]?)b>
|
||||
RegExpBranchImpl: <(c[ab]?)b>
|
||||
RegExpGroupImpl: <(c[ab]?)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <c[ab]?>
|
||||
RegExpBranchImpl: <c[ab]?>
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpClosureImpl: <[ab]?>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <?>
|
||||
PsiElement(QUEST)('?')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,24 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(c[ab]??)b>
|
||||
RegExpBranchImpl: <(c[ab]??)b>
|
||||
RegExpGroupImpl: <(c[ab]??)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <c[ab]??>
|
||||
RegExpBranchImpl: <c[ab]??>
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpClosureImpl: <[ab]??>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <??>
|
||||
PsiElement(QUEST)('?')
|
||||
PsiElement(QUEST)('?')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,24 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(c[ab]*?)b>
|
||||
RegExpBranchImpl: <(c[ab]*?)b>
|
||||
RegExpGroupImpl: <(c[ab]*?)>
|
||||
PsiElement(GROUP_BEGIN)('(')
|
||||
RegExpPatternImpl: <c[ab]*?>
|
||||
RegExpBranchImpl: <c[ab]*?>
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpClosureImpl: <[ab]*?>
|
||||
RegExpClassImpl: <[ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <*?>
|
||||
PsiElement(STAR)('*')
|
||||
PsiElement(QUEST)('?')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,30 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[bcd]+dcdcde>
|
||||
RegExpBranchImpl: <a[bcd]+dcdcde>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClosureImpl: <[bcd]+>
|
||||
RegExpClassImpl: <[bcd]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <bcd>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <+>
|
||||
PsiElement(PLUS)('+')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
RegExpCharImpl: <e>
|
||||
PsiElement(CHARACTER)('e')
|
||||
@@ -0,0 +1,8 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[k]>
|
||||
RegExpBranchImpl: <[k]>
|
||||
RegExpClassImpl: <[k]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <k>
|
||||
PsiElement(CHARACTER)('k')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,30 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[bcd]*dcdcde>
|
||||
RegExpBranchImpl: <a[bcd]*dcdcde>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClosureImpl: <[bcd]*>
|
||||
RegExpClassImpl: <[bcd]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <bcd>
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <*>
|
||||
PsiElement(STAR)('*')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
RegExpCharImpl: <d>
|
||||
PsiElement(CHARACTER)('d')
|
||||
RegExpCharImpl: <e>
|
||||
PsiElement(CHARACTER)('e')
|
||||
@@ -0,0 +1,15 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[^ab]*>
|
||||
RegExpBranchImpl: <[^ab]*>
|
||||
RegExpClosureImpl: <[^ab]*>
|
||||
RegExpClassImpl: <[^ab]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
PsiElement(CARET)('^')
|
||||
RegExpUnionImpl: <ab>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpQuantifierImpl: <*>
|
||||
PsiElement(STAR)('*')
|
||||
@@ -0,0 +1,12 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[.]b>
|
||||
RegExpBranchImpl: <a[.]b>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[.]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <.>
|
||||
PsiElement(CHARACTER)('.')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,17 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[+*?]b>
|
||||
RegExpBranchImpl: <a[+*?]b>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[+*?]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <+*?>
|
||||
RegExpCharImpl: <+>
|
||||
PsiElement(CHARACTER)('+')
|
||||
RegExpCharImpl: <*>
|
||||
PsiElement(CHARACTER)('*')
|
||||
RegExpCharImpl: <?>
|
||||
PsiElement(CHARACTER)('?')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,13 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[-b]>
|
||||
RegExpBranchImpl: <a[-b]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[-b]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <-b>
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,21 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[\p{IsDigit}\p{IsAlpha}]b>
|
||||
RegExpBranchImpl: <a[\p{IsDigit}\p{IsAlpha}]b>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[\p{IsDigit}\p{IsAlpha}]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <\p{IsDigit}\p{IsAlpha}>
|
||||
RegExpPropertyImpl: <\p{IsDigit}>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(LBRACE)('{')
|
||||
PsiElement(NAME)('IsDigit')
|
||||
PsiElement(RBRACE)('}')
|
||||
RegExpPropertyImpl: <\p{IsAlpha}>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(LBRACE)('{')
|
||||
PsiElement(NAME)('IsAlpha')
|
||||
PsiElement(RBRACE)('}')
|
||||
PsiElement(CLASS_END)(']')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,22 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[\p{L}&&[^\p{Lu}]]>
|
||||
RegExpBranchImpl: <[\p{L}&&[^\p{Lu}]]>
|
||||
RegExpClassImpl: <[\p{L}&&[^\p{Lu}]]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpIntersectionImpl: <\p{L}&&[^\p{Lu}]>
|
||||
RegExpPropertyImpl: <\p{L}>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(LBRACE)('{')
|
||||
PsiElement(NAME)('L')
|
||||
PsiElement(RBRACE)('}')
|
||||
PsiElement(ANDAND)('&&')
|
||||
RegExpClassImpl: <[^\p{Lu}]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
PsiElement(CARET)('^')
|
||||
RegExpPropertyImpl: <\p{Lu}>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(LBRACE)('{')
|
||||
PsiElement(NAME)('Lu')
|
||||
PsiElement(RBRACE)('}')
|
||||
PsiElement(CLASS_END)(']')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,45 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <\pL\pM\pZ\pS\pN\pP\pC\PL\PM\PZ\PS\PN\PP\PC>
|
||||
RegExpBranchImpl: <\pL\pM\pZ\pS\pN\pP\pC\PL\PM\PZ\PS\PN\PP\PC>
|
||||
RegExpPropertyImpl: <\pL>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('L')
|
||||
RegExpPropertyImpl: <\pM>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('M')
|
||||
RegExpPropertyImpl: <\pZ>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('Z')
|
||||
RegExpPropertyImpl: <\pS>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('S')
|
||||
RegExpPropertyImpl: <\pN>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('N')
|
||||
RegExpPropertyImpl: <\pP>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('P')
|
||||
RegExpPropertyImpl: <\pC>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('C')
|
||||
RegExpPropertyImpl: <\PL>
|
||||
PsiElement(PROPERTY)('\P')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('L')
|
||||
RegExpPropertyImpl: <\PM>
|
||||
PsiElement(PROPERTY)('\P')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('M')
|
||||
RegExpPropertyImpl: <\PZ>
|
||||
PsiElement(PROPERTY)('\P')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('Z')
|
||||
RegExpPropertyImpl: <\PS>
|
||||
PsiElement(PROPERTY)('\P')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('S')
|
||||
RegExpPropertyImpl: <\PN>
|
||||
PsiElement(PROPERTY)('\P')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('N')
|
||||
RegExpPropertyImpl: <\PP>
|
||||
PsiElement(PROPERTY)('\P')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('P')
|
||||
RegExpPropertyImpl: <\PC>
|
||||
PsiElement(PROPERTY)('\P')
|
||||
PsiElement(CATEGORY_SHORT_HAND)('C')
|
||||
@@ -0,0 +1,10 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <\pA>
|
||||
RegExpBranchImpl: <\pA>
|
||||
RegExpPropertyImpl: <\pA>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiErrorElement:Character category expected
|
||||
<empty list>
|
||||
PsiElement(CHARACTER)('A')
|
||||
PsiErrorElement:Unclosed character family
|
||||
<empty list>
|
||||
@@ -0,0 +1,10 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <\pl>
|
||||
RegExpBranchImpl: <\pl>
|
||||
RegExpPropertyImpl: <\pl>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiErrorElement:Character category expected
|
||||
<empty list>
|
||||
PsiElement(CHARACTER)('l')
|
||||
PsiErrorElement:Unclosed character family
|
||||
<empty list>
|
||||
@@ -0,0 +1,9 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a\p>
|
||||
RegExpBranchImpl: <a\p>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpPropertyImpl: <\p>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiErrorElement:Character category expected
|
||||
<empty list>
|
||||
@@ -0,0 +1,11 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a\p{}>
|
||||
RegExpBranchImpl: <a\p{}>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpPropertyImpl: <\p{}>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(LBRACE)('{')
|
||||
PsiErrorElement:Empty character family
|
||||
<empty list>
|
||||
PsiElement(RBRACE)('}')
|
||||
@@ -0,0 +1,12 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a\p}>
|
||||
RegExpBranchImpl: <a\p}>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpPropertyImpl: <\p}>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiErrorElement:Character category expected
|
||||
<empty list>
|
||||
PsiElement(CHARACTER)('}')
|
||||
PsiErrorElement:Unclosed character family
|
||||
<empty list>
|
||||
@@ -0,0 +1,12 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a\p{123}>
|
||||
RegExpBranchImpl: <a\p{123}>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpPropertyImpl: <\p{123}>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(LBRACE)('{')
|
||||
PsiErrorElement:Character family name expected
|
||||
<empty list>
|
||||
PsiElement(NUMBER)('123')
|
||||
PsiElement(RBRACE)('}')
|
||||
@@ -0,0 +1,11 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[\p{nothing}]>
|
||||
RegExpBranchImpl: <[\p{nothing}]>
|
||||
RegExpClassImpl: <[\p{nothing}]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpPropertyImpl: <\p{nothing}>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(LBRACE)('{')
|
||||
PsiElement(NAME)('nothing')
|
||||
PsiElement(RBRACE)('}')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,12 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a[b-]>
|
||||
RegExpBranchImpl: <a[b-]>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpClassImpl: <[b-]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,14 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <a\p{*}b>
|
||||
RegExpBranchImpl: <a\p{*}b>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpPropertyImpl: <\p{*}>
|
||||
PsiElement(PROPERTY)('\p')
|
||||
PsiElement(LBRACE)('{')
|
||||
PsiErrorElement:Character family name expected
|
||||
<empty list>
|
||||
PsiElement(BAD_CHARACTER)('*')
|
||||
PsiElement(RBRACE)('}')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
@@ -0,0 +1,12 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[\w-\w]>
|
||||
RegExpBranchImpl: <[\w-\w]>
|
||||
RegExpClassImpl: <[\w-\w]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharRangeImpl: <\w-\w>
|
||||
RegExpSimpleClassImpl: <\w>
|
||||
PsiElement(CHAR_CLASS)('\w')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpSimpleClassImpl: <\w>
|
||||
PsiElement(CHAR_CLASS)('\w')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,12 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[a-\w]>
|
||||
RegExpBranchImpl: <[a-\w]>
|
||||
RegExpClassImpl: <[a-\w]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharRangeImpl: <a-\w>
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpSimpleClassImpl: <\w>
|
||||
PsiElement(CHAR_CLASS)('\w')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,48 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <(?x)abc #foo \q bar
|
||||
# foo
|
||||
(?-xi)xyz(?i:ABC)>
|
||||
RegExpBranchImpl: <(?x)abc #foo \q bar
|
||||
# foo
|
||||
(?-xi)xyz(?i:ABC)>
|
||||
RegExpSetOptionsImpl: <(?x)>
|
||||
PsiElement(SET_OPTIONS)('(?')
|
||||
RegExpOptionsImpl: <x>
|
||||
PsiElement(OPTIONS_ON)('x')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
RegExpCharImpl: <c>
|
||||
PsiElement(CHARACTER)('c')
|
||||
PsiWhiteSpace(' ')
|
||||
PsiComment(COMMENT)('#')
|
||||
PsiComment(COMMENT)('foo \q bar\n')
|
||||
PsiComment(COMMENT)('#')
|
||||
PsiComment(COMMENT)(' foo\n')
|
||||
RegExpSetOptionsImpl: <(?-xi)>
|
||||
PsiElement(SET_OPTIONS)('(?')
|
||||
RegExpOptionsImpl: <-xi>
|
||||
PsiElement(OPTIONS_OFF)('-xi')
|
||||
PsiElement(GROUP_END)(')')
|
||||
RegExpCharImpl: <x>
|
||||
PsiElement(CHARACTER)('x')
|
||||
RegExpCharImpl: <y>
|
||||
PsiElement(CHARACTER)('y')
|
||||
RegExpCharImpl: <z>
|
||||
PsiElement(CHARACTER)('z')
|
||||
RegExpGroupImpl: <(?i:ABC)>
|
||||
PsiElement(SET_OPTIONS)('(?')
|
||||
RegExpOptionsImpl: <i>
|
||||
PsiElement(OPTIONS_ON)('i')
|
||||
PsiElement(COLON)(':')
|
||||
RegExpPatternImpl: <ABC>
|
||||
RegExpBranchImpl: <ABC>
|
||||
RegExpCharImpl: <A>
|
||||
PsiElement(CHARACTER)('A')
|
||||
RegExpCharImpl: <B>
|
||||
PsiElement(CHARACTER)('B')
|
||||
RegExpCharImpl: <C>
|
||||
PsiElement(CHARACTER)('C')
|
||||
PsiElement(GROUP_END)(')')
|
||||
@@ -0,0 +1,17 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[\ud800\udc00-\udbff\udfff]>
|
||||
RegExpBranchImpl: <[\ud800\udc00-\udbff\udfff]>
|
||||
RegExpClassImpl: <[\ud800\udc00-\udbff\udfff]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <\ud800\udc00-\udbff\udfff>
|
||||
RegExpCharImpl: <\ud800>
|
||||
PsiElement(UNICODE_CHAR)('\ud800')
|
||||
RegExpCharRangeImpl: <\udc00-\udbff>
|
||||
RegExpCharImpl: <\udc00>
|
||||
PsiElement(UNICODE_CHAR)('\udc00')
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpCharImpl: <\udbff>
|
||||
PsiElement(UNICODE_CHAR)('\udbff')
|
||||
RegExpCharImpl: <\udfff>
|
||||
PsiElement(UNICODE_CHAR)('\udfff')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,5 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <\R>
|
||||
RegExpBranchImpl: <\R>
|
||||
RegExpSimpleClassImpl: <\R>
|
||||
PsiElement(CHAR_CLASS)('\R')
|
||||
@@ -0,0 +1,5 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <\X>
|
||||
RegExpBranchImpl: <\X>
|
||||
RegExpSimpleClassImpl: <\X>
|
||||
PsiElement(CHAR_CLASS)('\X')
|
||||
@@ -0,0 +1,21 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <\-[\*\-\[\]\\\+]>
|
||||
RegExpBranchImpl: <\-[\*\-\[\]\\\+]>
|
||||
RegExpCharImpl: <\->
|
||||
PsiElement(REDUNDANT_ESCAPE)('\-')
|
||||
RegExpClassImpl: <[\*\-\[\]\\\+]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpUnionImpl: <\*\-\[\]\\\+>
|
||||
RegExpCharImpl: <\*>
|
||||
PsiElement(REDUNDANT_ESCAPE)('\*')
|
||||
RegExpCharImpl: <\->
|
||||
PsiElement(ESC_CHARACTER)('\-')
|
||||
RegExpCharImpl: <\[>
|
||||
PsiElement(ESC_CHARACTER)('\[')
|
||||
RegExpCharImpl: <\]>
|
||||
PsiElement(REDUNDANT_ESCAPE)('\]')
|
||||
RegExpCharImpl: <\\>
|
||||
PsiElement(ESC_CHARACTER)('\\')
|
||||
RegExpCharImpl: <\+>
|
||||
PsiElement(REDUNDANT_ESCAPE)('\+')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,8 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[\b]>
|
||||
RegExpBranchImpl: <[\b]>
|
||||
RegExpClassImpl: <[\b]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <\b>
|
||||
PsiElement(ESC_CHARACTER)('\b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
@@ -0,0 +1,15 @@
|
||||
REGEXP_FILE
|
||||
RegExpPatternImpl: <[a-[b]]>
|
||||
RegExpBranchImpl: <[a-[b]]>
|
||||
RegExpClassImpl: <[a-[b]]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <a>
|
||||
PsiElement(CHARACTER)('a')
|
||||
RegExpCharImpl: <->
|
||||
PsiElement(MINUS)('-')
|
||||
RegExpClassImpl: <[b]>
|
||||
PsiElement(CLASS_BEGIN)('[')
|
||||
RegExpCharImpl: <b>
|
||||
PsiElement(CHARACTER)('b')
|
||||
PsiElement(CLASS_END)(']')
|
||||
PsiElement(CLASS_END)(']')
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user