You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by pa...@apache.org on 2024/11/11 15:48:38 UTC
(lucenenet) branch master updated: Migrate to ANTLR v4 in Lucene.Net.Expressions, #977 (#996)
This is an automated email from the ASF dual-hosted git repository.
paulirwin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git
The following commit(s) were added to refs/heads/master by this push:
new e05e0ffdc Migrate to ANTLR v4 in Lucene.Net.Expressions, #977 (#996)
e05e0ffdc is described below
commit e05e0ffdc8e03993a9c0dbd424633442025f5014
Author: Paul Irwin <pa...@gmail.com>
AuthorDate: Mon Nov 11 08:48:33 2024 -0700
Migrate to ANTLR v4 in Lucene.Net.Expressions, #977 (#996)
* Migrate to ANTLR v4, #977
* Exclude generated code from ApiScanTestBase tests
* Make Antlr4BuildTasks a build-time-only dependency, and remove old ANTLRv3 transitive deps
* LICENSE.txt: Added BSD license for src/Lucene.Net.Expressions/JS/Javascript.g4. Normalized dividers between different license attributions.
---------
Co-authored-by: Shad Storhaug <sh...@shadstorhaug.com>
---
.build/dependencies.props | 3 +-
LICENSE.txt | 64 +-
src/Lucene.Net.Expressions/JS/Javascript.g4 | 249 +++
.../JS/JavascriptCompiler.cs | 741 ++++---
src/Lucene.Net.Expressions/JS/JavascriptLexer.cs | 2177 --------------------
src/Lucene.Net.Expressions/JS/JavascriptParser.cs | 1886 -----------------
.../Lucene.Net.Expressions.csproj | 17 +-
.../Support/ApiScanTestBase.cs | 38 +-
.../JS/TestJavascriptOperations.cs | 7 +-
9 files changed, 831 insertions(+), 4351 deletions(-)
diff --git a/.build/dependencies.props b/.build/dependencies.props
index c2c3ce6ab..5c1124752 100644
--- a/.build/dependencies.props
+++ b/.build/dependencies.props
@@ -20,7 +20,8 @@
-->
<Project>
<PropertyGroup Label="NuGet Package Reference Versions">
- <Antlr3RuntimePackageVersion>3.5.1</Antlr3RuntimePackageVersion>
+ <Antlr4RuntimeStandardPackageVersion>4.13.1</Antlr4RuntimeStandardPackageVersion>
+ <Antlr4BuildTasksPackageVersion>12.8.0</Antlr4BuildTasksPackageVersion>
<!-- LUCENENET TODO: When ICU4N is released to production,
be sure to lock down the version range below. The resource
files in Lucene.Net.ICU are not compatible with any other
diff --git a/LICENSE.txt b/LICENSE.txt
index ed5e1374b..fe107390a 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -201,7 +201,7 @@
See the License for the specific language governing permissions and
limitations under the License.
-
+========
Some code in src/Lucene.Net/Util/UnicodeUtil.cs was derived from unicode
conversion examples available at http://www.unicode.org/Public/PROGRAMS/CVTUTF.
@@ -230,6 +230,7 @@ Here is the copyright from those sources:
* remains attached.
*/
+========
Some code in src/Lucene.Net/Util/ArrayUtil.cs was derived from Python 2.4.2
sources available at http://www.python.org.
@@ -238,6 +239,7 @@ Full license is here:
http://www.python.org/download/releases/2.4.2/license/
+========
Some code in src/Lucene.Net/Util/UnicodeUtil.cs was
derived from Python 3.1.2 sources available at
@@ -245,6 +247,7 @@ http://www.python.org. Full license is here:
http://www.python.org/download/releases/3.1.2/license/
+========
Some code in src/Lucene.Net/Util/Automaton was
derived from Brics automaton sources available at
@@ -277,6 +280,7 @@ www.brics.dk/automaton/. Here is the copyright from those sources:
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+========
The levenshtein automata tables in src/Lucene.Net/Util/Automaton
were automatically generated with the moman/finenight FSA package.
@@ -305,6 +309,7 @@ Here is the copyright for those sources:
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
# OTHER DEALINGS IN THE SOFTWARE.
+========
Some code in src/Lucene.Net/Util/UnicodeUtil.cs was
derived from ICU (http://www.icu-project.org)
@@ -338,7 +343,8 @@ The full license is available here:
* dealings in this Software without prior written authorization of the
* copyright holder.
*/
-
+
+========
The following license applies to the Snowball stemmers:
@@ -369,6 +375,7 @@ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF this SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+========
The following license applies to src/Lucene.Net.Analysis.Common/Analysis/En/KStemmer.cs:
@@ -540,7 +547,7 @@ Office or Microsoft Dynamics).
Some code in src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer and
src/Lucene.Net.Tests.Analysis.Stempel/Egothor.Stemmer falls
-under the following license
+under the following license:
Egothor Software License version 1.00
Copyright (C) 1997-2004 Leo Galambos.
@@ -643,7 +650,7 @@ falls under the following license:
// Written by David Megginson
// NO WARRANTY! This class is in the public domain.
----
+========
The code in .build/psake/ falls under the following license:
@@ -668,7 +675,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
----
+========
src/Lucene.Net/Support/Compatibility/NullableAttributes.cs
src/Lucene.Net/Support/DateTimeOffsetUtil.cs
@@ -696,7 +703,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
----
+========
Some code in src/Lucene.Net/Support/ConcurrentHashSet.cs falls under the following license:
@@ -722,7 +729,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
----
+========
Some code in
src/Lucene.Net.TestFramework/Support/Util/DefaultNamespaceTypeWrapper.cs
@@ -749,3 +756,46 @@ falls under the following license:
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
+
+========
+
+The code in src/Lucene.Net.Expressions/JS/Javascript.g4 falls under the following license:
+
+Copyrights 2008-2009 Xebic Reasearch BV. All rights reserved..
+Original work by Patrick Hulsmeijer.
+
+This ANTLR 3 LL(*) grammar is based on Ecma-262 3rd edition (JavaScript 1.5, JScript 5.5).
+The annotations refer to the "A Grammar Summary" section (e.g. A.1 Lexical Grammar)
+and the numbers in parenthesis to the paragraph numbers (e.g. (7.8) ).
+This document is best viewed with ANTLRWorks (www.antlr.org).
+
+Software License Agreement (BSD License)
+
+Copyright (c) 2008-2010, Xebic Research B.V.
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+ * Neither the name of Xebic Research B.V. nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of Xebic Research B.V.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/src/Lucene.Net.Expressions/JS/Javascript.g4 b/src/Lucene.Net.Expressions/JS/Javascript.g4
new file mode 100644
index 000000000..90b169570
--- /dev/null
+++ b/src/Lucene.Net.Expressions/JS/Javascript.g4
@@ -0,0 +1,249 @@
+/*
+ Javascript.g
+ An expression syntax based on ECMAScript/Javascript.
+
+ This file was adapted from a general ECMAScript language definition at http://research.xebic.com/es3.
+ The major changes are the following:
+ * Stripped grammar of all parts not relevant for expression syntax.
+ * Stripped grammar of unicode character support.
+ * Added override function for customized error handling.
+ * Renaming of many grammar rules.
+ * Removal of annotations no longer relevant for stripped pieces.
+
+ The Original Copyright Notice is the following:
+
+ Copyrights 2008-2009 Xebic Reasearch BV. All rights reserved..
+ Original work by Patrick Hulsmeijer.
+
+ This ANTLR 3 LL(*) grammar is based on Ecma-262 3rd edition (JavaScript 1.5, JScript 5.5).
+ The annotations refer to the "A Grammar Summary" section (e.g. A.1 Lexical Grammar)
+ and the numbers in parenthesis to the paragraph numbers (e.g. (7.8) ).
+ This document is best viewed with ANTLRWorks (www.antlr.org).
+
+ Software License Agreement (BSD License)
+
+ Copyright (c) 2008-2010, Xebic Research B.V.
+ All rights reserved.
+
+ Redistribution and use of this software in source and binary forms, with or without modification, are
+ permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the
+ following disclaimer in the documentation and/or other
+ materials provided with the distribution.
+
+ * Neither the name of Xebic Research B.V. nor the names of its
+ contributors may be used to endorse or promote products
+ derived from this software without specific prior
+ written permission of Xebic Research B.V.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+ WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// ***********************************************************************
+// * ANTLRv4 grammar for Lucene expression language.
+//
+// LUCENENET-specific: ported from ANTLRv3 grammar. Inline C# code is no
+// longer necessary for error handling.
+// ***********************************************************************
+
+grammar Javascript;
+
+options {
+ language = CSharp;
+}
+
+// ***********************************************************************
+// * Parser Rules
+// ***********************************************************************
+
+expression
+ : conditional EOF
+ ;
+
+conditional
+ : logical_or (AT_COND_QUE conditional AT_COLON conditional)?
+ ;
+
+logical_or
+ : logical_and (AT_BOOL_OR logical_and)*
+ ;
+
+logical_and
+ : bitwise_or (AT_BOOL_AND bitwise_or)*
+ ;
+
+bitwise_or
+ : bitwise_xor (AT_BIT_OR bitwise_xor)*
+ ;
+
+bitwise_xor
+ : bitwise_and (AT_BIT_XOR bitwise_and)*
+ ;
+
+bitwise_and
+ : equality (AT_BIT_AND equality)*
+ ;
+
+equality
+ : relational ((AT_COMP_EQ | AT_COMP_NEQ) relational)*
+ ;
+
+relational
+ : shift ((AT_COMP_LT | AT_COMP_GT | AT_COMP_LTE | AT_COMP_GTE) shift)*
+ ;
+
+shift
+ : additive ((AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU) additive)*
+ ;
+
+additive
+ : multiplicative ((AT_ADD | AT_SUBTRACT) multiplicative)*
+ ;
+
+multiplicative
+ : unary ((AT_MULTIPLY | AT_DIVIDE | AT_MODULO) unary)*
+ ;
+
+unary
+ : postfix
+ | AT_ADD unary
+ | unary_operator unary
+ ;
+
+unary_operator
+ : AT_SUBTRACT
+ | AT_BIT_NOT
+ | AT_BOOL_NOT
+ ;
+
+postfix
+ : primary
+ | call // LUCENENET-specific: see note for call rule below (was AT_CALL)
+ ;
+
+// LUCENENET-specific: previously used blank AT_CALL token to detect function calls,
+// but this is not necessary in ANTLRv4. Instead, we can just make it a new rule
+call
+ : NAMESPACE_ID arguments?
+ ;
+
+primary
+ : NAMESPACE_ID
+ | numeric
+ | AT_LPAREN conditional AT_RPAREN
+ ;
+
+arguments
+ : AT_LPAREN (conditional (AT_COMMA conditional)*)? AT_RPAREN
+ ;
+
+numeric
+ : HEX | OCTAL | DECIMAL
+ ;
+
+// ***********************************************************************
+// * Lexer Rules
+// ***********************************************************************
+
+AT_LPAREN : '(' ;
+AT_RPAREN : ')' ;
+AT_DOT : '.' ;
+AT_COMMA : ',' ;
+AT_COLON : ':' ;
+
+AT_COMP_LT : '<' ;
+AT_COMP_LTE : '<=' ;
+AT_COMP_EQ : '==' ;
+AT_COMP_NEQ : '!=' ;
+AT_COMP_GTE : '>=' ;
+AT_COMP_GT : '>' ;
+
+AT_BOOL_NOT : '!' ;
+AT_BOOL_AND : '&&' ;
+AT_BOOL_OR : '||' ;
+AT_COND_QUE : '?' ;
+
+// AT_NEGATE ;
+AT_ADD : '+' ;
+AT_SUBTRACT : '-' ;
+AT_MULTIPLY : '*' ;
+AT_DIVIDE : '/' ;
+AT_MODULO : '%' ;
+
+AT_BIT_SHL : '<<' ;
+AT_BIT_SHR : '>>' ;
+AT_BIT_SHU : '>>>';
+AT_BIT_AND : '&' ;
+AT_BIT_OR : '|' ;
+AT_BIT_XOR : '^' ;
+AT_BIT_NOT : '~' ;
+
+// AT_CALL ;
+
+NAMESPACE_ID
+ : ID (AT_DOT ID)*
+ ;
+
+fragment
+ID
+ : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
+ ;
+
+WS
+ : (' '|'\t'|'\n'|'\r')+ -> skip
+ ;
+
+DECIMAL
+ : DECIMALINTEGER AT_DOT DECIMALDIGIT* EXPONENT?
+ | AT_DOT DECIMALDIGIT+ EXPONENT?
+ | DECIMALINTEGER EXPONENT?
+ ;
+
+OCTAL
+ : '0' OCTALDIGIT+
+ ;
+
+HEX
+ : ('0x'|'0X') HEXDIGIT+
+ ;
+
+fragment
+DECIMALINTEGER
+ : '0'
+ | '1'..'9' DECIMALDIGIT*
+ ;
+
+fragment
+EXPONENT
+ : ('e'|'E') ('+'|'-')? DECIMALDIGIT+
+ ;
+
+fragment
+DECIMALDIGIT
+ : '0'..'9'
+ ;
+
+fragment
+HEXDIGIT
+ : DECIMALDIGIT
+ | 'a'..'f'
+ | 'A'..'F'
+ ;
+
+fragment
+OCTALDIGIT
+ : '0'..'7'
+ ;
diff --git a/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs b/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs
index 7dea0c0a4..2a57c02af 100644
--- a/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs
+++ b/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs
@@ -1,19 +1,19 @@
-using J2N.Text;
-using Antlr.Runtime;
-using Antlr.Runtime.Tree;
+using Antlr4.Runtime;
+using Antlr4.Runtime.Tree;
+using J2N;
+using J2N.Text;
using Lucene.Net.Queries.Function;
using Lucene.Net.Support;
using System;
using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
-using JCG = J2N.Collections.Generic;
-using J2N;
using System.Text;
-using System.Diagnostics.CodeAnalysis;
+using JCG = J2N.Collections.Generic;
namespace Lucene.Net.Expressions.JS
{
@@ -79,7 +79,6 @@ namespace Lucene.Net.Expressions.JS
private static readonly MethodInfo DOUBLE_VAL_METHOD = GetMethod(FUNCTION_VALUES_TYPE, "DoubleVal",
new[] { typeof(int) });
-
// We use the same class name for all generated classes as they all have their own class loader.
// The source code is displayed as "source file name" in stack trace.
// to work around import clash:
@@ -96,14 +95,11 @@ namespace Lucene.Net.Expressions.JS
private readonly IDictionary<string, MethodInfo> functions;
-
-
private ILGenerator gen;
private AssemblyBuilder asmBuilder;
private MethodBuilder evalMethod;
private ModuleBuilder modBuilder;
-
// This maximum length is theoretically 65535 bytes, but as its CESU-8 encoded we dont know how large it is in bytes, so be safe
// rcmuir: "If your ranking function is that large you need to check yourself into a mental institution!"
/// <summary>Compiles the given expression.</summary>
@@ -174,10 +170,9 @@ namespace Lucene.Net.Expressions.JS
{
try
{
-
- ITree antlrTree = GetAntlrComputedExpressionTree();
+ var antlrTree = GetAntlrComputedExpressionTree();
BeginCompile();
- RecursiveCompile(antlrTree, typeof(double));
+ RecursiveCompile(antlrTree);
EndCompile();
return
(Expression)
@@ -220,343 +215,541 @@ namespace Lucene.Net.Expressions.JS
gen = evalMethod.GetILGenerator();
}
- private void RecursiveCompile(ITree current, Type expected)
+ private void RecursiveCompile(JavascriptParser.ExpressionContext context)
{
- int type = current.Type;
- string text = current.Text;
+ var listener = new JavascriptListener(this);
+ listener.EnterExpression(context);
+ }
+
+ // LUCENENET-specific: these methods use the ANTLRv4 listener API to
+ // be equivalent to what RecursiveCompile was doing previously
+ private class JavascriptListener : JavascriptBaseListener
+ {
+ private readonly JavascriptCompiler compiler;
+
+ public JavascriptListener(JavascriptCompiler compiler)
+ {
+ this.compiler = compiler;
+ }
+
+ public override void EnterExpression(JavascriptParser.ExpressionContext context)
+ {
+ EnterConditional(context.conditional());
+ }
- switch (type)
+ public override void EnterCall(JavascriptParser.CallContext context)
{
- case JavascriptParser.AT_CALL:
+ ITerminalNode identifier = context.NAMESPACE_ID();
+ string call = identifier.GetText();
+ // LUCENENET: logic changed to get arguments from parse context
+ var arguments = context.arguments().conditional();
+ int argumentCount = arguments.Length;
+ if (!compiler.functions.TryGetValue(call, out MethodInfo method) || method is null)
+ {
+ throw new ArgumentException("Unrecognized method call (" + call + ").");
+ }
+ int arity = method.GetParameters().Length;
+ if (argumentCount != arity)
+ {
+ throw new ArgumentException("Expected (" + arity + ") arguments for method call ("
+ + call + "), but found (" + argumentCount + ").");
+ }
+ for (int argument = 0; argument < argumentCount; ++argument) // LUCENENET: was 1 to and including arguments
+ {
+ EnterConditional(arguments[argument]);
+ }
+ compiler.Emit(OpCodes.Call, method);
+ }
+
+ public override void EnterPrimary(JavascriptParser.PrimaryContext context)
+ {
+ if (context.NAMESPACE_ID() is { } namespaceId)
+ {
+ string text = namespaceId.GetText();
+
+ if (!compiler.externalsMap.TryGetValue(text, out int index))
{
- ITree identifier = current.GetChild(0);
- string call = identifier.Text;
- int arguments = current.ChildCount - 1;
- if (!functions.TryGetValue(call, out MethodInfo method) || method is null)
- {
- throw new ArgumentException("Unrecognized method call (" + call + ").");
- }
- int arity = method.GetParameters().Length;
- if (arguments != arity)
- {
- throw new ArgumentException("Expected (" + arity + ") arguments for method call ("
- + call + "), but found (" + arguments + ").");
- }
- for (int argument = 1; argument <= arguments; ++argument)
- {
- RecursiveCompile(current.GetChild(argument), typeof(double));
- }
- gen.Emit(OpCodes.Call, method);
- break;
+ compiler.externalsMap[text] = index = compiler.externalsMap.Count;
}
- case JavascriptParser.NAMESPACE_ID:
- {
- if (!externalsMap.TryGetValue(text, out int index))
- {
- externalsMap[text] = index = externalsMap.Count;
- }
- gen.Emit(OpCodes.Nop);
+ compiler.Emit(OpCodes.Nop);
- gen.Emit(OpCodes.Ldarg_2);
- gen.Emit(OpCodes.Ldc_I4, index);
+ compiler.Emit(OpCodes.Ldarg_2);
+ compiler.Emit(OpCodes.Ldc_I4, index);
+
+ compiler.Emit(OpCodes.Ldelem_Ref);
+ compiler.Emit(OpCodes.Ldarg_1);
+ compiler.Emit(OpCodes.Callvirt, DOUBLE_VAL_METHOD);
+ }
+ else if (context.numeric() is { } numeric)
+ {
+ EnterNumeric(numeric);
+ }
+ else if (context.conditional() is { } conditional)
+ {
+ EnterConditional(conditional);
+ }
+ else
+ {
+ throw new ParseException("Unknown primary alternative", context.Start.StartIndex);
+ }
+ }
+
+ public override void EnterNumeric(JavascriptParser.NumericContext context)
+ {
+ string text = context.GetText();
+
+ if (context.HEX() is not null)
+ {
+ compiler.PushInt64(Convert.ToInt64(text, 16));
+ }
+ else if (context.OCTAL() is not null)
+ {
+ compiler.PushInt64(Convert.ToInt64(text, 8));
+ }
+ else
+ {
+ compiler.Emit(OpCodes.Ldc_R8, double.Parse(text, CultureInfo.InvariantCulture));
+ }
+ }
- gen.Emit(OpCodes.Ldelem_Ref);
- gen.Emit(OpCodes.Ldarg_1);
- gen.Emit(OpCodes.Callvirt, DOUBLE_VAL_METHOD);
- break;
+ public override void EnterPostfix(JavascriptParser.PostfixContext context)
+ {
+ if (context.primary() is { } primary)
+ {
+ EnterPrimary(primary);
+ }
+ else if (context.call() is { } call)
+ {
+ EnterCall(call);
+ }
+ else
+ {
+ throw new ParseException("Unknown postfix alternative", context.Start.StartIndex);
+ }
+ }
+
+ public override void EnterUnary(JavascriptParser.UnaryContext context)
+ {
+ if (context.postfix() is { } postfix)
+ {
+ EnterPostfix(postfix);
+ }
+ else if (context.AT_ADD() is not null)
+ {
+ EnterUnary(context.unary());
+ compiler.Emit(OpCodes.Conv_R8);
+ }
+ else if (context.unary_operator() is { } unaryOperator)
+ {
+ EnterUnary(context.unary());
+
+ if (unaryOperator.AT_SUBTRACT() is not null)
+ {
+ compiler.Emit(OpCodes.Neg);
}
- case JavascriptParser.HEX:
+ else if (unaryOperator.AT_BIT_NOT() is not null)
{
- PushInt64(Convert.ToInt64(text, 16));
- break;
+ compiler.Emit(OpCodes.Conv_I8); // cast to long (truncate)
+ compiler.Emit(OpCodes.Not);
+ compiler.Emit(OpCodes.Conv_R8);
}
- case JavascriptParser.OCTAL:
+ else if (unaryOperator.AT_BOOL_NOT() is not null)
{
- PushInt64(Convert.ToInt64(text, 8));
- break;
+ compiler.Emit(OpCodes.Ldc_I4_0);
+ compiler.Emit(OpCodes.Ceq);
+ compiler.Emit(OpCodes.Conv_R8);
}
-
- case JavascriptParser.DECIMAL:
+ else
{
- //.NET Port. This is a bit hack-y but was needed since .NET can't perform bitwise ops on longs & doubles
- var bitwiseOps = new[]{ ">>","<<","&","~","|","^"};
-
- if (bitwiseOps.Any(s => sourceText.Contains(s)))
- {
- if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out int val))
- {
- gen.Emit(OpCodes.Ldc_I4, val);
- }
- else
- {
- gen.Emit(OpCodes.Ldc_I8, long.Parse(text, CultureInfo.InvariantCulture));
- gen.Emit(OpCodes.Conv_Ovf_U4_Un);
- }
- }
- else
- {
- gen.Emit(OpCodes.Ldc_R8, double.Parse(text, CultureInfo.InvariantCulture));
- }
- break;
+ throw new ParseException("Unknown unary_operator alternative", context.Start.StartIndex);
}
+ }
+ else
+ {
+ throw new ParseException("Unknown unary alternative", context.Start.StartIndex);
+ }
+ }
- case JavascriptParser.AT_NEGATE:
+ public override void EnterAdditive(JavascriptParser.AdditiveContext context)
+ {
+ CompileBinary(context, context.multiplicative, EnterMultiplicative, terminalNode =>
+ {
+ if (terminalNode.Symbol.Type == JavascriptParser.AT_ADD)
{
- RecursiveCompile(current.GetChild(0), typeof(double));
- gen.Emit(OpCodes.Neg);
- break;
+ compiler.PushOpWithConvert(OpCodes.Add);
}
-
- case JavascriptParser.AT_ADD:
+ else if (terminalNode.Symbol.Type == JavascriptParser.AT_SUBTRACT)
{
- PushArith(OpCodes.Add, current, expected);
- break;
+ compiler.PushOpWithConvert(OpCodes.Sub);
}
-
- case JavascriptParser.AT_SUBTRACT:
+ else
{
- PushArith(OpCodes.Sub, current, expected);
- break;
+ throw new ParseException("Unknown additive token", context.Start.StartIndex);
}
+ });
+ }
- case JavascriptParser.AT_MULTIPLY:
+ public override void EnterMultiplicative(JavascriptParser.MultiplicativeContext context)
+ {
+ CompileBinary(context, context.unary, EnterUnary, terminalNode =>
+ {
+ if (terminalNode.Symbol.Type == JavascriptParser.AT_MULTIPLY)
{
- PushArith(OpCodes.Mul, current, expected);
- break;
+ compiler.PushOpWithConvert(OpCodes.Mul);
}
-
- case JavascriptParser.AT_DIVIDE:
+ else if (terminalNode.Symbol.Type == JavascriptParser.AT_DIVIDE)
{
- PushArith(OpCodes.Div, current, expected);
- break;
+ compiler.PushOpWithConvert(OpCodes.Div);
}
-
- case JavascriptParser.AT_MODULO:
+ else if (terminalNode.Symbol.Type == JavascriptParser.AT_MODULO)
{
- PushArith(OpCodes.Rem, current, expected);
- break;
+ compiler.PushOpWithConvert(OpCodes.Rem);
}
-
- case JavascriptParser.AT_BIT_SHL:
+ else
{
- PushShift(OpCodes.Shl, current);
- break;
+ throw new ParseException("Unknown multiplicative token", context.Start.StartIndex);
}
+ });
+ }
+
+ public override void EnterShift(JavascriptParser.ShiftContext context)
+ {
+ CompileBinary(context, context.additive, additiveContext =>
+ {
+ EnterAdditive(additiveContext);
- case JavascriptParser.AT_BIT_SHR:
+ if (context.children.Count > 1) // if we have a shift token
{
- PushShift(OpCodes.Shr, current);
- break;
+ compiler.Emit(OpCodes.Conv_I8); // cast to long (truncate)
}
-
- case JavascriptParser.AT_BIT_SHU:
+ }, terminalNode =>
+ {
+ if (terminalNode.Symbol.Type == JavascriptParser.AT_BIT_SHL)
{
- PushShift(OpCodes.Shr_Un, current);
- break;
+ compiler.PushOpWithConvert(OpCodes.Shl);
}
-
- case JavascriptParser.AT_BIT_AND:
+ else if (terminalNode.Symbol.Type == JavascriptParser.AT_BIT_SHR)
{
- PushBitwise(OpCodes.And, current);
- break;
+ compiler.PushOpWithConvert(OpCodes.Shr);
}
-
- case JavascriptParser.AT_BIT_OR:
+ else if (terminalNode.Symbol.Type == JavascriptParser.AT_BIT_SHU)
{
- PushBitwise(OpCodes.Or, current);
- break;
+ compiler.PushOpWithConvert(OpCodes.Shr_Un);
}
-
- case JavascriptParser.AT_BIT_XOR:
+ else
{
- PushBitwise(OpCodes.Xor, current);
- break;
+ throw new ParseException("Unknown shift token", context.Start.StartIndex);
}
+ });
+ }
- case JavascriptParser.AT_BIT_NOT:
+ public override void EnterRelational(JavascriptParser.RelationalContext context)
+ {
+ CompileBinary(context, context.shift, EnterShift, terminalNode => {
+ if (terminalNode.Symbol.Type == JavascriptParser.AT_COMP_LT)
{
- RecursiveCompile(current.GetChild(0), typeof(long));
- gen.Emit(OpCodes.Not);
- gen.Emit(OpCodes.Conv_R8);
- break;
+ compiler.PushOpWithConvert(OpCodes.Clt);
}
-
- case JavascriptParser.AT_COMP_EQ:
+ else if (terminalNode.Symbol.Type == JavascriptParser.AT_COMP_GT)
{
- PushCond(OpCodes.Ceq, current, expected);
- break;
+ compiler.PushOpWithConvert(OpCodes.Cgt);
}
-
- case JavascriptParser.AT_COMP_NEQ:
+ else if (terminalNode.Symbol.Type == JavascriptParser.AT_COMP_LTE)
{
- PushCondEq(OpCodes.Ceq, current, expected);
- break;
+ compiler.PushCondEq(OpCodes.Cgt);
}
-
- case JavascriptParser.AT_COMP_LT:
+ else if (terminalNode.Symbol.Type == JavascriptParser.AT_COMP_GTE)
+ {
+ compiler.PushCondEq(OpCodes.Clt);
+ }
+ else
{
- PushCond(OpCodes.Clt, current, expected);
- break;
+ throw new ParseException("Unknown relational token", context.Start.StartIndex);
}
+ });
+ }
- case JavascriptParser.AT_COMP_GT:
+ public override void EnterEquality(JavascriptParser.EqualityContext context)
+ {
+ CompileBinary(context, context.relational, EnterRelational, terminalNode =>
+ {
+ if (terminalNode.Symbol.Type == JavascriptParser.AT_COMP_EQ)
+ {
+ compiler.PushOpWithConvert(OpCodes.Ceq);
+ }
+ else if (terminalNode.Symbol.Type == JavascriptParser.AT_COMP_NEQ)
+ {
+ compiler.PushCondEq(OpCodes.Ceq);
+ }
+ else
{
- PushCond(OpCodes.Cgt, current, expected);
- break;
+ throw new ParseException("Unknown equality token", context.Start.StartIndex);
}
+ });
+ }
+
+ public override void EnterBitwise_and(JavascriptParser.Bitwise_andContext context)
+ {
+ CompileBinary(context, context.equality, equalityContext =>
+ {
+ EnterEquality(equalityContext);
- case JavascriptParser.AT_COMP_LTE:
+ if (context.children.Count > 1) // if we have a bitwise token
+ {
+ compiler.Emit(OpCodes.Conv_I8); // cast to long (truncate)
+ }
+ }, terminalNode =>
+ {
+ if (terminalNode.Symbol.Type == JavascriptParser.AT_BIT_AND)
{
- PushCondEq(OpCodes.Cgt, current, expected);
- break;
+ compiler.PushOpWithConvert(OpCodes.And);
}
+ else
+ {
+ throw new ParseException("Unknown bitwise_and token", context.Start.StartIndex);
+ }
+ });
+ }
- case JavascriptParser.AT_COMP_GTE:
+ public override void EnterBitwise_xor(JavascriptParser.Bitwise_xorContext context)
+ {
+ CompileBinary(context, context.bitwise_and, andContext =>
+ {
+ EnterBitwise_and(andContext);
+
+ if (context.children.Count > 1) // if we have a bitwise token
{
- PushCondEq(OpCodes.Clt, current, expected);
- break;
+ compiler.Emit(OpCodes.Conv_I8); // cast to long (truncate)
}
+ }, terminalNode =>
+ {
+ if (terminalNode.Symbol.Type == JavascriptParser.AT_BIT_XOR)
+ {
+ compiler.PushOpWithConvert(OpCodes.Xor);
+ }
+ else
+ {
+ throw new ParseException("Unknown bitwise_xor token", context.Start.StartIndex);
+ }
+ });
+ }
- case JavascriptParser.AT_BOOL_NOT:
+ public override void EnterBitwise_or(JavascriptParser.Bitwise_orContext context)
+ {
+ CompileBinary(context, context.bitwise_xor, xorContext =>
+ {
+ EnterBitwise_xor(xorContext);
+
+ if (context.children.Count > 1) // if we have a bitwise token
+ {
+ compiler.Emit(OpCodes.Conv_I8); // cast to long (truncate)
+ }
+ }, terminalNode =>
+ {
+ if (terminalNode.Symbol.Type == JavascriptParser.AT_BIT_OR)
+ {
+ compiler.PushOpWithConvert(OpCodes.Or);
+ }
+ else
{
- RecursiveCompile(current.GetChild(0), typeof(int));
- gen.Emit(OpCodes.Ldc_I4_0);
- gen.Emit(OpCodes.Ceq);
- gen.Emit(OpCodes.Conv_R8);
- break;
+ throw new ParseException("Unknown bitwise_or token", context.Start.StartIndex);
}
+ });
+ }
- case JavascriptParser.AT_BOOL_AND:
+ public override void EnterLogical_and(JavascriptParser.Logical_andContext context)
+ {
+ if (context.children.Count == 1)
+ {
+ EnterBitwise_or(context.bitwise_or(0));
+ }
+ else
+ {
+ // Evaluate the first operand and check if it is false
+ EnterBitwise_or(context.bitwise_or(0));
+ compiler.Emit(OpCodes.Ldc_I4_0);
+ compiler.Emit(OpCodes.Ceq);
+
+ // Iterate over the remaining operands
+ for (int i = 2; i < context.children.Count; i += 2)
{
+ if (context.children[i] is not JavascriptParser.Bitwise_orContext bitwiseOrContext)
+ {
+ throw new ParseException("Unexpected child of logical_and", context.Start.StartIndex);
+ }
- RecursiveCompile(current.GetChild(0), typeof(int));
- gen.Emit(OpCodes.Ldc_I4_0);
- gen.Emit(OpCodes.Ceq);
- RecursiveCompile(current.GetChild(1), typeof(int));
+ // Evaluate the next operand and check if it is false
+ EnterBitwise_or(bitwiseOrContext);
+ compiler.Emit(OpCodes.Ldc_I4_0);
+ compiler.Emit(OpCodes.Ceq);
- gen.Emit(OpCodes.Ldc_I4_0);
- gen.Emit(OpCodes.Ceq);
+ // Combine the results using OR
+ compiler.Emit(OpCodes.Or);
+ }
- gen.Emit(OpCodes.Or);
+ // Check if the combined result is false
+ compiler.Emit(OpCodes.Ldc_I4_0);
+ compiler.Emit(OpCodes.Ceq);
- gen.Emit(OpCodes.Ldc_I4_0);
- gen.Emit(OpCodes.Ceq);
+ // Convert the result to a double
+ compiler.Emit(OpCodes.Conv_R8);
+ }
+ }
+
+ public override void EnterLogical_or(JavascriptParser.Logical_orContext context)
+ {
+ if (context.children.Count == 1)
+ {
+ EnterLogical_and(context.logical_and(0));
+ }
+ else
+ {
+ // Evaluate the first operand and check if it is true
+ EnterLogical_and(context.logical_and(0));
+ compiler.Emit(OpCodes.Ldc_I4_0);
+ compiler.Emit(OpCodes.Ceq);
+ compiler.Emit(OpCodes.Ldc_I4_1);
+ compiler.Emit(OpCodes.Xor);
- gen.Emit(OpCodes.Conv_R8);
+ // Iterate over the remaining operands
+ for (int i = 2; i < context.children.Count; i += 2)
+ {
+ if (context.children[i] is not JavascriptParser.Logical_andContext logicalAndContext)
+ {
+ throw new ParseException("Unexpected child of logical_or", context.Start.StartIndex);
+ }
+ // Evaluate the next operand and check if it is true
+ EnterLogical_and(logicalAndContext);
+ compiler.Emit(OpCodes.Ldc_I4_0);
+ compiler.Emit(OpCodes.Ceq);
+ compiler.Emit(OpCodes.Ldc_I4_1);
+ compiler.Emit(OpCodes.Xor);
- break;
+ // Combine the results using OR
+ compiler.Emit(OpCodes.Or);
}
- case JavascriptParser.AT_BOOL_OR:
- {
- RecursiveCompile(current.GetChild(0), typeof(int));
- gen.Emit(OpCodes.Ldc_I4_0);
- gen.Emit(OpCodes.Ceq);
- gen.Emit(OpCodes.Ldc_I4_1);
- gen.Emit(OpCodes.Xor);
- RecursiveCompile(current.GetChild(1), typeof(int));
+ // Check if the combined result is true
+ compiler.Emit(OpCodes.Ldc_I4_1);
+ compiler.Emit(OpCodes.Ceq);
- gen.Emit(OpCodes.Ldc_I4_0);
- gen.Emit(OpCodes.Ceq);
- gen.Emit(OpCodes.Ldc_I4_1);
- gen.Emit(OpCodes.Xor);
- gen.Emit(OpCodes.Or);
+ // Convert the result to a double
+ compiler.Emit(OpCodes.Conv_R8);
+ }
+ }
+
+ public override void EnterConditional(JavascriptParser.ConditionalContext context)
+ {
+ if (context.children.Count == 1)
+ {
+ EnterLogical_or(context.logical_or());
+ }
+ else
+ {
+ Label condFalse = compiler.gen.DefineLabel();
+ Label condEnd = compiler.gen.DefineLabel();
- gen.Emit(OpCodes.Ldc_I4_1);
- gen.Emit(OpCodes.Ceq);
+ // Evaluate the condition
+ EnterLogical_or(context.logical_or());
+ compiler.Emit(OpCodes.Ldc_I4_0);
+ compiler.Emit(OpCodes.Beq, condFalse);
- gen.Emit(OpCodes.Conv_R8);
- break;
- }
+ // Evaluate the true branch
+ EnterConditional(context.conditional(0));
+ compiler.Emit(OpCodes.Br_S, condEnd);
+
+ // Evaluate the false branch
+ compiler.gen.MarkLabel(condFalse);
+ EnterConditional(context.conditional(1));
- case JavascriptParser.AT_COND_QUE:
+ // Mark the end of the conditional
+ compiler.gen.MarkLabel(condEnd);
+ }
+ }
+
+ private static void CompileBinary<TContext, TArg>(
+ TContext context,
+ Func<int, TArg> getArg,
+ Action<TArg> enterArg,
+ Action<ITerminalNode> enterOp)
+ where TContext : ParserRuleContext
+ where TArg : ParserRuleContext
+ {
+ int argIndex = 0;
+ enterArg(getArg(argIndex++));
+
+ for (int i = 1; i < context.children.Count; i += 2)
+ {
+ if (context.children[i] is ITerminalNode terminalNode)
{
- Label condFalse = gen.DefineLabel();
- Label condEnd = gen.DefineLabel();
- RecursiveCompile(current.GetChild(0), typeof(int));
- gen.Emit(OpCodes.Ldc_I4_0);
- gen.Emit(OpCodes.Beq,condFalse);
- RecursiveCompile(current.GetChild(1), expected);
- gen.Emit(OpCodes.Br_S,condEnd);
- gen.MarkLabel(condFalse);
- RecursiveCompile(current.GetChild(2), expected);
- gen.MarkLabel(condEnd);
- break;
+ enterArg(getArg(argIndex++));
+ enterOp(terminalNode);
}
-
- default:
+ else
{
- throw IllegalStateException.Create("Unknown operation specified: (" + current.Text + ").");
+ throw new ParseException("Unexpected child", context.Start.StartIndex);
}
+ }
}
-
}
- private void PushCondEq(OpCode opCode, ITree current, Type expected)
+ private void PushCondEq(OpCode opCode)
{
- RecursiveCompile(current.GetChild(0), expected);
- RecursiveCompile(current.GetChild(1), expected);
- gen.Emit(opCode);
- gen.Emit(OpCodes.Ldc_I4_1);
- gen.Emit(OpCodes.Xor);
- gen.Emit(OpCodes.Conv_R8);
+ Emit(opCode);
+ Emit(OpCodes.Ldc_I4_1);
+ Emit(OpCodes.Xor);
+ Emit(OpCodes.Conv_R8);
}
-#pragma warning disable IDE0060 // Remove unused parameter
- private void PushArith(OpCode op, ITree current, Type expected)
-#pragma warning restore IDE0060 // Remove unused parameter
+ private void PushOpWithConvert(OpCode opCode)
{
- PushBinaryOp(op, current, typeof(double), typeof(double));
+ Emit(opCode);
+ Emit(OpCodes.Conv_R8);
}
- private void PushShift(OpCode op, ITree current)
+ /// <summary>
+ /// NOTE: This was pushLong() in Lucene
+ /// </summary>
+ private void PushInt64(long i)
{
- PushBinaryShiftOp(op, current, typeof(int), typeof(int));
+ Emit(OpCodes.Ldc_I8, i);
+ if (!sourceText.Contains("<<"))
+ {
+ Emit(OpCodes.Conv_R8);
+ }
}
- private void PushBinaryShiftOp(OpCode op, ITree current, Type arg1, Type arg2)
+ // LUCENENET-specific - wrapping Emit methods which is helpful for debugging
+ private void Emit(OpCode opcode)
{
- gen.Emit(OpCodes.Nop);
- RecursiveCompile(current.GetChild(0), arg1);
- RecursiveCompile(current.GetChild(1), arg2);
- gen.Emit(op);
- gen.Emit(OpCodes.Conv_R8);
+ // Console.WriteLine(opcode);
+ gen.Emit(opcode);
}
- private void PushBitwise(OpCode op, ITree current)
+ private void Emit(OpCode opcode, Label label)
{
- PushBinaryOp(op, current, typeof(long), typeof(long));
+ // Console.WriteLine(opcode + " " + label);
+ gen.Emit(opcode, label);
}
- private void PushBinaryOp(OpCode op, ITree current, Type arg1, Type arg2)
+ private void Emit(OpCode opcode, double arg)
{
- gen.Emit(OpCodes.Nop);
- RecursiveCompile(current.GetChild(0), arg1);
- RecursiveCompile(current.GetChild(1), arg2);
- gen.Emit(op);
- gen.Emit(OpCodes.Conv_R8);
+ // Console.WriteLine(opcode + " " + arg);
+ gen.Emit(opcode, arg);
}
- private void PushCond(OpCode opCode, ITree current, Type expected)
+ private void Emit(OpCode opcode, long arg)
{
- RecursiveCompile(current.GetChild(0), expected);
- RecursiveCompile(current.GetChild(1), expected);
- gen.Emit(opCode);
- gen.Emit(OpCodes.Conv_R8);
+ // Console.WriteLine(opcode + " " + arg);
+ gen.Emit(opcode, arg);
}
- /// <summary>
- /// NOTE: This was pushLong() in Lucene
- /// </summary>
- private void PushInt64(long i)
+ private void Emit(OpCode opcode, MethodInfo arg)
{
- gen.Emit(OpCodes.Ldc_I8,i);
- if (!sourceText.Contains("<<"))
- {
- gen.Emit(OpCodes.Conv_R8);
- }
+ // Console.WriteLine(opcode + " " + arg);
+ gen.Emit(opcode, arg);
}
private void EndCompile()
@@ -565,23 +758,65 @@ namespace Lucene.Net.Expressions.JS
dynamicType.DefineMethodOverride(evalMethod, EVALUATE_METHOD);
}
- private ITree GetAntlrComputedExpressionTree()
+ private JavascriptParser.ExpressionContext GetAntlrComputedExpressionTree()
{
- ICharStream input = new ANTLRStringStream(sourceText);
+ ICharStream input = new AntlrInputStream(sourceText);
JavascriptLexer lexer = new JavascriptLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
JavascriptParser parser = new JavascriptParser(tokens);
+
try
{
- return parser.Expression().Tree;
+ parser.ErrorHandler = new ParseExceptionErrorStrategy(); // LUCENENET-specific
+ return parser.expression();
}
catch (RecognitionException re)
{
throw new ArgumentException(re.Message, re);
}
- // LUCENENET: Antlr 3.5.1 doesn't ever wrap ParseException, so the other catch block
- // for RuntimeException that wraps ParseException would have
- // been completely unnecesary in Java and is also unnecessary here.
+ }
+
+ // LUCENENET-specific: Throw a ParseException in the event of parsing errors
+ private class ParseExceptionErrorStrategy : DefaultErrorStrategy
+ {
+ public override void Recover(Parser recognizer, RecognitionException e)
+ {
+ int errorOffset = -1;
+
+ for (ParserRuleContext parserRuleContext = recognizer.Context; parserRuleContext != null; parserRuleContext = (ParserRuleContext)parserRuleContext.Parent)
+ {
+ if (errorOffset < 0)
+ {
+ errorOffset = parserRuleContext.Start.StartIndex;
+ }
+
+ parserRuleContext.exception = e;
+ }
+
+ throw new ParseException(e.Message, errorOffset);
+ }
+
+ public override IToken RecoverInline(Parser recognizer)
+ {
+ InputMismatchException cause = new InputMismatchException(recognizer);
+ int errorOffset = -1;
+
+ for (ParserRuleContext parserRuleContext = recognizer.Context; parserRuleContext != null; parserRuleContext = (ParserRuleContext)parserRuleContext.Parent)
+ {
+ if (errorOffset < 0)
+ {
+ errorOffset = parserRuleContext.Start.StartIndex;
+ }
+
+ parserRuleContext.exception = cause;
+ }
+
+ throw new ParseException(cause.Message, errorOffset);
+ }
+
+ public override void Sync(Parser recognizer)
+ {
+ }
}
/// <summary>The default set of functions available to expressions.</summary>
@@ -652,19 +887,19 @@ namespace Lucene.Net.Expressions.JS
{
var settings = new Dictionary<string, string>();
var type = typeof(JavascriptCompiler);
- using (var reader = new StreamReader(type.FindAndGetManifestResourceStream(type.Name + ".properties"), Encoding.UTF8))
- settings.LoadProperties(reader);
+ using var reader = new StreamReader(type.FindAndGetManifestResourceStream(type.Name + ".properties"), Encoding.UTF8);
+ settings.LoadProperties(reader);
return settings;
}
private static void CheckFunction(MethodInfo method)
{
// do some checks if the signature is "compatible":
- if (!(method.IsStatic))
+ if (!method.IsStatic)
{
throw new ArgumentException(method + " is not static.");
}
- if (!(method.IsPublic))
+ if (!method.IsPublic)
{
throw new ArgumentException(method + " is not public.");
}
diff --git a/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs b/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs
deleted file mode 100644
index 60c68aea7..000000000
--- a/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs
+++ /dev/null
@@ -1,2177 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-// ANTLR GENERATED CODE: DO NOT EDIT (LUCENENET: Not really auto generated in the port)
-
-using System;
-using Antlr.Runtime;
-using J2N.Text;
-using Lucene.Net.Support;
-
-namespace Lucene.Net.Expressions.JS
-{
- internal class JavascriptLexer : Lexer
- {
- public const int EOF = -1;
-
- public const int AT_ADD = 4;
-
- public const int AT_BIT_AND = 5;
-
- public const int AT_BIT_NOT = 6;
-
- public const int AT_BIT_OR = 7;
-
- public const int AT_BIT_SHL = 8;
-
- public const int AT_BIT_SHR = 9;
-
- public const int AT_BIT_SHU = 10;
-
- public const int AT_BIT_XOR = 11;
-
- public const int AT_BOOL_AND = 12;
-
- public const int AT_BOOL_NOT = 13;
-
- public const int AT_BOOL_OR = 14;
-
- public const int AT_CALL = 15;
-
- public const int AT_COLON = 16;
-
- public const int AT_COMMA = 17;
-
- public const int AT_COMP_EQ = 18;
-
- public const int AT_COMP_GT = 19;
-
- public const int AT_COMP_GTE = 20;
-
- public const int AT_COMP_LT = 21;
-
- public const int AT_COMP_LTE = 22;
-
- public const int AT_COMP_NEQ = 23;
-
- public const int AT_COND_QUE = 24;
-
- public const int AT_DIVIDE = 25;
-
- public const int AT_DOT = 26;
-
- public const int AT_LPAREN = 27;
-
- public const int AT_MODULO = 28;
-
- public const int AT_MULTIPLY = 29;
-
- public const int AT_NEGATE = 30;
-
- public const int AT_RPAREN = 31;
-
- public const int AT_SUBTRACT = 32;
-
- public const int DECIMAL = 33;
-
- public const int DECIMALDIGIT = 34;
-
- public const int DECIMALINTEGER = 35;
-
- public const int EXPONENT = 36;
-
- public const int HEX = 37;
-
- public const int HEXDIGIT = 38;
-
- public const int ID = 39;
-
- public const int NAMESPACE_ID = 40;
-
- public const int OCTAL = 41;
-
- public const int OCTALDIGIT = 42;
-
- public const int WS = 43;
-
- public override void DisplayRecognitionError(string[] tokenNames, RecognitionException re)
- {
- string message = " unexpected character '" + (char)re.Character + "' at position (" + re.CharPositionInLine + ").";
- throw new ParseException(message, re.CharPositionInLine, re);
- }
-
- // delegates
- // delegators
- public virtual Lexer[] GetDelegates()
- {
- return Array.Empty<Lexer>();
- }
-
- public JavascriptLexer()
- {
- m_dfa9 = new JavascriptLexer.DFA9(this, this);
- }
-
- public JavascriptLexer(ICharStream input) : this(input, new RecognizerSharedState(
- ))
- {
- m_dfa9 = new JavascriptLexer.DFA9(this, this);
- }
-
- public JavascriptLexer(ICharStream input, RecognizerSharedState state) : base(input
- , state)
- {
- m_dfa9 = new JavascriptLexer.DFA9(this, this);
- }
-
- public override string GrammarFileName => "";
-
- // $ANTLR start "AT_ADD"
-
- public void MAT_ADD()
- {
- try
- {
- int _type = AT_ADD;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:25:8: ( '+' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:25:10: '+'
- Match('+');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_ADD"
- // $ANTLR start "AT_BIT_AND"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_BIT_AND()
- {
- int _type = AT_BIT_AND;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:26:12: ( '&' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:26:14: '&'
- Match('&');
- }
- state.type = _type;
- state.channel = _channel;
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_BIT_AND"
- // $ANTLR start "AT_BIT_NOT"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_BIT_NOT()
- {
- try
- {
- int _type = AT_BIT_NOT;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:27:12: ( '~' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:27:14: '~'
- Match('~');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_BIT_NOT"
- // $ANTLR start "AT_BIT_OR"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_BIT_OR()
- {
- try
- {
- int _type = AT_BIT_OR;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:28:11: ( '|' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:28:13: '|'
- Match('|');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_BIT_OR"
- // $ANTLR start "AT_BIT_SHL"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_BIT_SHL()
- {
- try
- {
- int _type = AT_BIT_SHL;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:29:12: ( '<<' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:29:14: '<<'
- Match("<<");
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_BIT_SHL"
- // $ANTLR start "AT_BIT_SHR"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_BIT_SHR()
- {
- try
- {
- int _type = AT_BIT_SHR;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:30:12: ( '>>' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:30:14: '>>'
- Match(">>");
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_BIT_SHR"
- // $ANTLR start "AT_BIT_SHU"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_BIT_SHU()
- {
- try
- {
- int _type = AT_BIT_SHU;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:31:12: ( '>>>' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:31:14: '>>>'
- Match(">>>");
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_BIT_SHU"
- // $ANTLR start "AT_BIT_XOR"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_BIT_XOR()
- {
- try
- {
- int _type = AT_BIT_XOR;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:32:12: ( '^' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:32:14: '^'
- Match('^');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_BIT_XOR"
- // $ANTLR start "AT_BOOL_AND"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_BOOL_AND()
- {
- try
- {
- int _type = AT_BOOL_AND;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:33:13: ( '&&' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:33:15: '&&'
- Match("&&");
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_BOOL_AND"
- // $ANTLR start "AT_BOOL_NOT"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_BOOL_NOT()
- {
- try
- {
- int _type = AT_BOOL_NOT;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:34:13: ( '!' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:34:15: '!'
- Match('!');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_BOOL_NOT"
- // $ANTLR start "AT_BOOL_OR"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_BOOL_OR()
- {
- try
- {
- int _type = AT_BOOL_OR;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:35:12: ( '||' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:35:14: '||'
- Match("||");
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_BOOL_OR"
- // $ANTLR start "AT_COLON"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_COLON()
- {
- try
- {
- int _type = AT_COLON;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:36:10: ( ':' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:36:12: ':'
- Match(':');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_COLON"
- // $ANTLR start "AT_COMMA"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_COMMA()
- {
- try
- {
- int _type = AT_COMMA;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:37:10: ( ',' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:37:12: ','
- Match(',');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_COMMA"
- // $ANTLR start "AT_COMP_EQ"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_COMP_EQ()
- {
- try
- {
- int _type = AT_COMP_EQ;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:38:12: ( '==' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:38:14: '=='
- Match("==");
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_COMP_EQ"
- // $ANTLR start "AT_COMP_GT"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_COMP_GT()
- {
- try
- {
- int _type = AT_COMP_GT;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:39:12: ( '>' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:39:14: '>'
- Match('>');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_COMP_GT"
- // $ANTLR start "AT_COMP_GTE"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_COMP_GTE()
- {
- try
- {
- int _type = AT_COMP_GTE;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:40:13: ( '>=' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:40:15: '>='
- Match(">=");
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_COMP_GTE"
- // $ANTLR start "AT_COMP_LT"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_COMP_LT()
- {
- try
- {
- int _type = AT_COMP_LT;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:41:12: ( '<' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:41:14: '<'
- Match('<');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_COMP_LT"
- // $ANTLR start "AT_COMP_LTE"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_COMP_LTE()
- {
- try
- {
- int _type = AT_COMP_LTE;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:42:13: ( '<=' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:42:15: '<='
- Match("<=");
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_COMP_LTE"
- // $ANTLR start "AT_COMP_NEQ"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_COMP_NEQ()
- {
- try
- {
- int _type = AT_COMP_NEQ;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:43:13: ( '!=' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:43:15: '!='
- Match("!=");
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_COMP_NEQ"
- // $ANTLR start "AT_COND_QUE"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_COND_QUE()
- {
- try
- {
- int _type = AT_COND_QUE;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:44:13: ( '?' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:44:15: '?'
- Match('?');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_COND_QUE"
- // $ANTLR start "AT_DIVIDE"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_DIVIDE()
- {
- try
- {
- int _type = AT_DIVIDE;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:45:11: ( '/' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:45:13: '/'
- Match('/');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_DIVIDE"
- // $ANTLR start "AT_DOT"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_DOT()
- {
- try
- {
- int _type = AT_DOT;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:46:8: ( '.' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:46:10: '.'
- Match('.');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_DOT"
- // $ANTLR start "AT_LPAREN"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_LPAREN()
- {
- try
- {
- int _type = AT_LPAREN;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:47:11: ( '(' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:47:13: '('
- Match('(');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_LPAREN"
- // $ANTLR start "AT_MODULO"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_MODULO()
- {
- try
- {
- int _type = AT_MODULO;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:48:11: ( '%' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:48:13: '%'
- Match('%');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_MODULO"
- // $ANTLR start "AT_MULTIPLY"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_MULTIPLY()
- {
- try
- {
- int _type = AT_MULTIPLY;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:49:13: ( '*' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:49:15: '*'
- Match('*');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_MULTIPLY"
- // $ANTLR start "AT_RPAREN"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_RPAREN()
- {
- try
- {
- int _type = AT_RPAREN;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:50:11: ( ')' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:50:13: ')'
- Match(')');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_RPAREN"
- // $ANTLR start "AT_SUBTRACT"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MAT_SUBTRACT()
- {
- try
- {
- int _type = AT_SUBTRACT;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:51:13: ( '-' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:51:15: '-'
- Match('-');
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "AT_SUBTRACT"
- // $ANTLR start "NAMESPACE_ID"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MNAMESPACE_ID()
- {
- try
- {
- int _type = NAMESPACE_ID;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:334:5: ( ID ( AT_DOT ID )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:334:7: ID ( AT_DOT ID )*
- MID();
- // src/java/org/apache/lucene/expressions/js/Javascript.g:334:10: ( AT_DOT ID )*
- while (true)
- {
- int alt1 = 2;
- int LA1_0 = input.LA(1);
- if ((LA1_0 == '.'))
- {
- alt1 = 1;
- }
- switch (alt1)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:334:11: AT_DOT ID
- MAT_DOT();
- MID();
- break;
- }
-
- default:
- {
- goto loop1_break;
- }
- }
-//loop1_continue: // LUCENENET NOTE: Not used
- }
-loop1_break: {/* LUCENENET: intentionally blank */}
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "NAMESPACE_ID"
- // $ANTLR start "ID"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MID()
- {
- try
- {
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:340:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:340:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
- if ((input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA
- (1) >= 'a' && input.LA(1) <= 'z'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- // src/java/org/apache/lucene/expressions/js/Javascript.g:340:31: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
- while (true)
- {
- int alt2 = 2;
- int LA2_0 = input.LA(1);
- if (((LA2_0 >= '0' && LA2_0 <= '9') || (LA2_0 >= 'A' && LA2_0 <= 'Z') || LA2_0 ==
- '_' || (LA2_0 >= 'a' && LA2_0 <= 'z')))
- {
- alt2 = 1;
- }
- switch (alt2)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA
- (1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- break;
- }
-
- default:
- {
- goto loop2_break;
- }
- }
-//loop2_continue: // LUCENENET NOTE: Not used
- }
-loop2_break: {/* LUCENENET: intentionally blank */}
- }
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "ID"
- // $ANTLR start "WS"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MWS()
- {
- try
- {
- int _type = WS;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:343:5: ( ( ' ' | '\\t' | '\\n' | '\\r' )+ )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:343:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
- // src/java/org/apache/lucene/expressions/js/Javascript.g:343:7: ( ' ' | '\\t' | '\\n' | '\\r' )+
- int cnt3 = 0;
- while (true)
- {
- int alt3 = 2;
- int LA3_0 = input.LA(1);
- if (((LA3_0 >= '\t' && LA3_0 <= '\n') || LA3_0 == '\r' || LA3_0 == ' '))
- {
- alt3 = 1;
- }
- switch (alt3)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '\t' && input.LA(1) <= '\n') || input.LA(1) == '\r' || input.
- LA(1) == ' ')
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- break;
- }
-
- default:
- {
- if (cnt3 >= 1)
- {
- goto loop3_break;
- }
- EarlyExitException eee = new EarlyExitException(3, input);
- throw eee;
- }
- }
- cnt3++;
- //loop3_continue: // LUCENENET NOTE: Not used
- }
- loop3_break:
- Skip();
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "WS"
- // $ANTLR start "DECIMAL"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MDECIMAL()
- {
- try
- {
- int type = DECIMAL;
- int channel = TokenChannels.Default;
- // src/java/org/apache/lucene/expressions/js/Javascript.g:347:5: ( DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )? | AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )? | DECIMALINTEGER ( EXPONENT )? )
- int alt9 = m_dfa9.Predict(input); // LUCENENET: IDE0059: Remove unnecessary value assignment
- switch (alt9)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:347:7: DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )?
- MDECIMALINTEGER();
- MAT_DOT();
- // src/java/org/apache/lucene/expressions/js/Javascript.g:347:29: ( DECIMALDIGIT )*
- while (true)
- {
- int alt4 = 2;
- int LA4_0 = input.LA(1);
- if (((LA4_0 >= '0' && LA4_0 <= '9')))
- {
- alt4 = 1;
- }
- switch (alt4)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- break;
- }
-
- default:
- {
- goto loop4_break;
- }
- }
- //loop4_continue: // LUCENENET NOTE: Not used
- }
- loop4_break:
- // src/java/org/apache/lucene/expressions/js/Javascript.g:347:43: ( EXPONENT )?
- int alt5 = 2;
- int LA5_0 = input.LA(1);
- if ((LA5_0 == 'E' || LA5_0 == 'e'))
- {
- alt5 = 1;
- }
- switch (alt5)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:347:43: EXPONENT
- MEXPONENT();
- break;
- }
- }
- break;
- }
-
- case 2:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:348:7: AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )?
- MAT_DOT();
- // src/java/org/apache/lucene/expressions/js/Javascript.g:348:14: ( DECIMALDIGIT )+
- int cnt6 = 0;
- while (true)
- {
- int alt6 = 2;
- int LA6_0 = input.LA(1);
- if (((LA6_0 >= '0' && LA6_0 <= '9')))
- {
- alt6 = 1;
- }
- switch (alt6)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- break;
- }
-
- default:
- {
- if (cnt6 >= 1)
- {
- goto loop6_break;
- }
- EarlyExitException eee = new EarlyExitException(6, input);
- throw eee;
- }
- }
- cnt6++;
- //loop6_continue: // LUCENENET NOTE: Not used
- }
- loop6_break:
- // src/java/org/apache/lucene/expressions/js/Javascript.g:348:28: ( EXPONENT )?
- int alt7 = 2;
- int LA7_0 = input.LA(1);
- if ((LA7_0 == 'E' || LA7_0 == 'e'))
- {
- alt7 = 1;
- }
- switch (alt7)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:348:28: EXPONENT
- MEXPONENT();
- break;
- }
- }
- break;
- }
-
- case 3:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:349:7: DECIMALINTEGER ( EXPONENT )?
- MDECIMALINTEGER();
- // src/java/org/apache/lucene/expressions/js/Javascript.g:349:22: ( EXPONENT )?
- int alt8 = 2;
- int LA8_0 = input.LA(1);
- if ((LA8_0 == 'E' || LA8_0 == 'e'))
- {
- alt8 = 1;
- }
- switch (alt8)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:349:22: EXPONENT
- MEXPONENT();
- break;
- }
- }
- break;
- }
- }
- state.type = type;
- state.channel = channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "DECIMAL"
- // $ANTLR start "OCTAL"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MOCTAL()
- {
- try
- {
- int _type = OCTAL;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:353:5: ( '0' ( OCTALDIGIT )+ )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:353:7: '0' ( OCTALDIGIT )+
- Match('0');
- // src/java/org/apache/lucene/expressions/js/Javascript.g:353:11: ( OCTALDIGIT )+
- int cnt10 = 0;
- while (true)
- {
- int alt10 = 2;
- int LA10_0 = input.LA(1);
- if (((LA10_0 >= '0' && LA10_0 <= '7')))
- {
- alt10 = 1;
- }
- switch (alt10)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '0' && input.LA(1) <= '7'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- break;
- }
-
- default:
- {
- if (cnt10 >= 1)
- {
- goto loop10_break;
- }
- EarlyExitException eee = new EarlyExitException(10, input);
- throw eee;
- }
- }
- cnt10++;
- //loop10_continue: // LUCENENET NOTE: Not used
- }
- loop10_break: {/* LUCENENET: intentionally blank */}
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "OCTAL"
- // $ANTLR start "HEX"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MHEX()
- {
- try
- {
- int _type = HEX;
- int _channel = TokenChannels.Default;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:357:5: ( ( '0x' | '0X' ) ( HEXDIGIT )+ )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:357:7: ( '0x' | '0X' ) ( HEXDIGIT )+
- // src/java/org/apache/lucene/expressions/js/Javascript.g:357:7: ( '0x' | '0X' )
- int alt11/* = 2*/; // LUCENENET: IDE0059: Remove unnecessary value assignment
- int LA11_0 = input.LA(1);
- if ((LA11_0 == '0'))
- {
- int LA11_1 = input.LA(2);
- if ((LA11_1 == 'x'))
- {
- alt11 = 1;
- }
- else
- {
- if ((LA11_1 == 'X'))
- {
- alt11 = 2;
- }
- else
- {
- int nvaeMark = input.Mark();
- try
- {
- input.Consume();
- NoViableAltException nvae = new NoViableAltException(string.Empty, 11, 1, input);
- throw nvae;
- }
- finally
- {
- input.Rewind(nvaeMark);
- }
- }
- }
- }
- else
- {
- NoViableAltException nvae = new NoViableAltException(string.Empty, 11, 0, input);
- throw nvae;
- }
- switch (alt11)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:357:8: '0x'
- Match("0x");
- break;
- }
-
- case 2:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:357:13: '0X'
- Match("0X");
- break;
- }
- }
- // src/java/org/apache/lucene/expressions/js/Javascript.g:357:19: ( HEXDIGIT )+
- int cnt12 = 0;
- while (true)
- {
- int alt12 = 2;
- int LA12_0 = input.LA(1);
- if (((LA12_0 >= '0' && LA12_0 <= '9') || (LA12_0 >= 'A' && LA12_0 <= 'F') || (LA12_0
- >= 'a' && LA12_0 <= 'f')))
- {
- alt12 = 1;
- }
- switch (alt12)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA
- (1) <= 'F') || (input.LA(1) >= 'a' && input.LA(1) <= 'f'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- break;
- }
-
- default:
- {
- if (cnt12 >= 1)
- {
- goto loop12_break;
- }
- EarlyExitException eee = new EarlyExitException(12, input);
- throw eee;
- }
- }
- cnt12++;
- //loop12_continue: // LUCENENET NOTE: Not used
- }
- loop12_break: {/* LUCENENET: intentionally blank */}
- }
- state.type = _type;
- state.channel = _channel;
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "HEX"
- // $ANTLR start "DECIMALINTEGER"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MDECIMALINTEGER()
- {
- try
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:363:5: ( '0' | '1' .. '9' ( DECIMALDIGIT )* )
- int alt14/* = 2*/; // LUCENENET: IDE0059: Remove unnecessary value assignment
- int LA14_0 = input.LA(1);
- if ((LA14_0 == '0'))
- {
- alt14 = 1;
- }
- else
- {
- if (((LA14_0 >= '1' && LA14_0 <= '9')))
- {
- alt14 = 2;
- }
- else
- {
- NoViableAltException nvae = new NoViableAltException(string.Empty, 14, 0, input);
- throw nvae;
- }
- }
- switch (alt14)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:363:7: '0'
- Match('0');
- break;
- }
-
- case 2:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:364:7: '1' .. '9' ( DECIMALDIGIT )*
- MatchRange('1', '9');
- // src/java/org/apache/lucene/expressions/js/Javascript.g:364:16: ( DECIMALDIGIT )*
- while (true)
- {
- int alt13 = 2;
- int LA13_0 = input.LA(1);
- if (((LA13_0 >= '0' && LA13_0 <= '9')))
- {
- alt13 = 1;
- }
- switch (alt13)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- break;
- }
-
- default:
- {
- goto loop13_break;
- }
- }
- //loop13_continue: // LUCENENET NOTE: Not used
- }
- loop13_break:
- break;
- }
- }
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "DECIMALINTEGER"
- // $ANTLR start "EXPONENT"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MEXPONENT()
- {
- try
- {
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:369:5: ( ( 'e' | 'E' ) ( '+' | '-' )? ( DECIMALDIGIT )+ )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:369:7: ( 'e' | 'E' ) ( '+' | '-' )? ( DECIMALDIGIT )+
- if (input.LA(1) == 'E' || input.LA(1) == 'e')
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- // src/java/org/apache/lucene/expressions/js/Javascript.g:369:17: ( '+' | '-' )?
- int alt15 = 2;
- int LA15_0 = input.LA(1);
- if ((LA15_0 == '+' || LA15_0 == '-'))
- {
- alt15 = 1;
- }
- switch (alt15)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if (input.LA(1) == '+' || input.LA(1) == '-')
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- break;
- }
- }
- // src/java/org/apache/lucene/expressions/js/Javascript.g:369:28: ( DECIMALDIGIT )+
- int cnt16 = 0;
- while (true)
- {
- int alt16 = 2;
- int LA16_0 = input.LA(1);
- if (((LA16_0 >= '0' && LA16_0 <= '9')))
- {
- alt16 = 1;
- }
- switch (alt16)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- break;
- }
-
- default:
- {
- if (cnt16 >= 1)
- {
- goto loop16_break;
- }
- EarlyExitException eee = new EarlyExitException(16, input);
- throw eee;
- }
- }
- cnt16++;
- //loop16_continue: // LUCENENET NOTE: Not used
- }
- loop16_break: {/* LUCENENET: intentionally blank */}
- }
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "EXPONENT"
- // $ANTLR start "DECIMALDIGIT"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MDECIMALDIGIT()
- {
- try
- {
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:374:5: ( '0' .. '9' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- }
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "DECIMALDIGIT"
- // $ANTLR start "HEXDIGIT"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MHEXDIGIT()
- {
- try
- {
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:379:5: ( DECIMALDIGIT | 'a' .. 'f' | 'A' .. 'F' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA
- (1) <= 'F') || (input.LA(1) >= 'a' && input.LA(1) <= 'f'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- }
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "HEXDIGIT"
- // $ANTLR start "OCTALDIGIT"
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public void MOCTALDIGIT()
- {
- try
- {
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:386:5: ( '0' .. '7' )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- if ((input.LA(1) >= '0' && input.LA(1) <= '7'))
- {
- input.Consume();
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- Recover(mse);
- throw mse;
- }
- }
- }
- finally
- {
- }
- }
-
- // do for sure before leaving
- // $ANTLR end "OCTALDIGIT"
-
- public override void mTokens()
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:8: ( AT_ADD | AT_BIT_AND | AT_BIT_NOT | AT_BIT_OR | AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU | AT_BIT_XOR | AT_BOOL_AND | AT_BOOL_NOT | AT_BOOL_OR | AT_COLON | AT_COMMA | AT_COMP_EQ | AT_COMP_GT | AT_COMP_GTE | AT_COMP_LT | AT_COMP_LTE | AT_COMP_NEQ | AT_COND_QUE | AT_DIVIDE | AT_DOT | AT_LPAREN | AT_MODULO | AT_MULTIPLY | AT_RPAREN | AT_SUBTRACT | NAMESPACE_ID | WS | DECIMAL | OCTAL | HEX )
- int alt17/* = 32*/; // LUCENENET: IDE0059: Remove unnecessary value assignment
- switch (input.LA(1))
- {
- case '+':
- {
- alt17 = 1;
- break;
- }
-
- case '&':
- {
- int LA17_2 = input.LA(2);
- if ((LA17_2 == '&'))
- {
- alt17 = 9;
- }
- else
- {
- alt17 = 2;
- }
- break;
- }
-
- case '~':
- {
- alt17 = 3;
- break;
- }
-
- case '|':
- {
- int LA17_4 = input.LA(2);
- if ((LA17_4 == '|'))
- {
- alt17 = 11;
- }
- else
- {
- alt17 = 4;
- }
- break;
- }
-
- case '<':
- {
- switch (input.LA(2))
- {
- case '<':
- {
- alt17 = 5;
- break;
- }
-
- case '=':
- {
- alt17 = 18;
- break;
- }
-
- default:
- {
- alt17 = 17;
- break;
- }
- }
- break;
- }
-
- case '>':
- {
- switch (input.LA(2))
- {
- case '>':
- {
- int LA17_31 = input.LA(3);
- if ((LA17_31 == '>'))
- {
- alt17 = 7;
- }
- else
- {
- alt17 = 6;
- }
- break;
- }
-
- case '=':
- {
- alt17 = 16;
- break;
- }
-
- default:
- {
- alt17 = 15;
- break;
- }
- }
- break;
- }
-
- case '^':
- {
- alt17 = 8;
- break;
- }
-
- case '!':
- {
- int LA17_8 = input.LA(2);
- if ((LA17_8 == '='))
- {
- alt17 = 19;
- }
- else
- {
- alt17 = 10;
- }
- break;
- }
-
- case ':':
- {
- alt17 = 12;
- break;
- }
-
- case ',':
- {
- alt17 = 13;
- break;
- }
-
- case '=':
- {
- alt17 = 14;
- break;
- }
-
- case '?':
- {
- alt17 = 20;
- break;
- }
-
- case '/':
- {
- alt17 = 21;
- break;
- }
-
- case '.':
- {
- int LA17_14 = input.LA(2);
- if (((LA17_14 >= '0' && LA17_14 <= '9')))
- {
- alt17 = 30;
- }
- else
- {
- alt17 = 22;
- }
- break;
- }
-
- case '(':
- {
- alt17 = 23;
- break;
- }
-
- case '%':
- {
- alt17 = 24;
- break;
- }
-
- case '*':
- {
- alt17 = 25;
- break;
- }
-
- case ')':
- {
- alt17 = 26;
- break;
- }
-
- case '-':
- {
- alt17 = 27;
- break;
- }
-
- case 'A':
- case 'B':
- case 'C':
- case 'D':
- case 'E':
- case 'F':
- case 'G':
- case 'H':
- case 'I':
- case 'J':
- case 'K':
- case 'L':
- case 'M':
- case 'N':
- case 'O':
- case 'P':
- case 'Q':
- case 'R':
- case 'S':
- case 'T':
- case 'U':
- case 'V':
- case 'W':
- case 'X':
- case 'Y':
- case 'Z':
- case '_':
- case 'a':
- case 'b':
- case 'c':
- case 'd':
- case 'e':
- case 'f':
- case 'g':
- case 'h':
- case 'i':
- case 'j':
- case 'k':
- case 'l':
- case 'm':
- case 'n':
- case 'o':
- case 'p':
- case 'q':
- case 'r':
- case 's':
- case 't':
- case 'u':
- case 'v':
- case 'w':
- case 'x':
- case 'y':
- case 'z':
- {
- alt17 = 28;
- break;
- }
-
- case '\t':
- case '\n':
- case '\r':
- case ' ':
- {
- alt17 = 29;
- break;
- }
-
- case '0':
- {
- switch (input.LA(2))
- {
- case 'X':
- case 'x':
- {
- alt17 = 32;
- break;
- }
-
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- {
- alt17 = 31;
- break;
- }
-
- default:
- {
- alt17 = 30;
- break;
- }
- }
- break;
- }
-
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- {
- alt17 = 30;
- break;
- }
-
- default:
- {
- NoViableAltException nvae = new NoViableAltException(string.Empty, 17, 0, input);
- throw nvae;
- }
- }
- switch (alt17)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:10: AT_ADD
- MAT_ADD();
- break;
- }
-
- case 2:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:17: AT_BIT_AND
- MAT_BIT_AND();
- break;
- }
-
- case 3:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:28: AT_BIT_NOT
- MAT_BIT_NOT();
- break;
- }
-
- case 4:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:39: AT_BIT_OR
- MAT_BIT_OR();
- break;
- }
-
- case 5:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:49: AT_BIT_SHL
- MAT_BIT_SHL();
- break;
- }
-
- case 6:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:60: AT_BIT_SHR
- MAT_BIT_SHR();
- break;
- }
-
- case 7:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:71: AT_BIT_SHU
- MAT_BIT_SHU();
- break;
- }
-
- case 8:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:82: AT_BIT_XOR
- MAT_BIT_XOR();
- break;
- }
-
- case 9:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:93: AT_BOOL_AND
- MAT_BOOL_AND();
- break;
- }
-
- case 10:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:105: AT_BOOL_NOT
- MAT_BOOL_NOT();
- break;
- }
-
- case 11:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:117: AT_BOOL_OR
- MAT_BOOL_OR();
- break;
- }
-
- case 12:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:128: AT_COLON
- MAT_COLON();
- break;
- }
-
- case 13:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:137: AT_COMMA
- MAT_COMMA();
- break;
- }
-
- case 14:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:146: AT_COMP_EQ
- MAT_COMP_EQ();
- break;
- }
-
- case 15:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:157: AT_COMP_GT
- MAT_COMP_GT();
- break;
- }
-
- case 16:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:168: AT_COMP_GTE
- MAT_COMP_GTE();
- break;
- }
-
- case 17:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:180: AT_COMP_LT
- MAT_COMP_LT();
- break;
- }
-
- case 18:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:191: AT_COMP_LTE
- MAT_COMP_LTE();
- break;
- }
-
- case 19:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:203: AT_COMP_NEQ
- MAT_COMP_NEQ();
- break;
- }
-
- case 20:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:215: AT_COND_QUE
- MAT_COND_QUE();
- break;
- }
-
- case 21:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:227: AT_DIVIDE
- MAT_DIVIDE();
- break;
- }
-
- case 22:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:237: AT_DOT
- MAT_DOT();
- break;
- }
-
- case 23:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:244: AT_LPAREN
- MAT_LPAREN();
- break;
- }
-
- case 24:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:254: AT_MODULO
- MAT_MODULO();
- break;
- }
-
- case 25:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:264: AT_MULTIPLY
- MAT_MULTIPLY();
- break;
- }
-
- case 26:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:276: AT_RPAREN
- MAT_RPAREN();
- break;
- }
-
- case 27:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:286: AT_SUBTRACT
- MAT_SUBTRACT();
- break;
- }
-
- case 28:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:298: NAMESPACE_ID
- MNAMESPACE_ID();
- break;
- }
-
- case 29:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:311: WS
- MWS();
- break;
- }
-
- case 30:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:314: DECIMAL
- MDECIMAL();
- break;
- }
-
- case 31:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:322: OCTAL
- MOCTAL();
- break;
- }
-
- case 32:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:1:328: HEX
- MHEX();
- break;
- }
- }
- }
-
- protected JavascriptLexer.DFA9 m_dfa9;
-
- internal const string DFA9_eotS = "\x1\uffff\x2\x4\x3\uffff\x1\x4";
-
- internal const string DFA9_eofS = "\x7\uffff";
-
- internal const string DFA9_minS = "\x3\x30\x3\uffff\x1\x30";
-
- internal const string DFA9_maxS = "\x1\x49\x1\x30\x1\x49\x3\uffff\x1\x49";
-
- internal const string DFA9_acceptS = "\x3\uffff\x1\x2\x1\x3\x1\x1\x1\uffff";
-
- internal const string DFA9_specialS = "\x7\uffff}>";
-
- internal static readonly string[] DFA9_transitionS = new string[] { "\x1\x3\x1\uffff\x1\x1\xb\x2"
- , "\x1\x5", "\x1\x5\x1\uffff\xc\x6", string.Empty, string.Empty, string.Empty, "\x1\x5\x1\uffff\xc\x6"
- };
-
- internal static readonly short[] DFA9_eot = DFA.UnpackEncodedString(DFA9_eotS);
-
- internal static readonly short[] DFA9_eof = DFA.UnpackEncodedString(DFA9_eofS);
-
- internal static readonly char[] DFA9_min = {'.','.','.','?','?','?','.'}; //DFA.UnpackEncodedStringToUnsignedChars(DFA9_minS);
-
- internal static readonly char[] DFA9_max = {'9', '.', '9', '?', '?', '?', '9'}; //DFA.UnpackEncodedStringToUnsignedChars(DFA9_maxS);
-
- internal static readonly short[] DFA9_accept = DFA.UnpackEncodedString(DFA9_acceptS
- );
-
- internal static readonly short[] DFA9_special = DFA.UnpackEncodedString(DFA9_specialS
- );
-
- internal static readonly short[][] DFA9_transition = LoadDFA9Transition();
-
- private static short[][] LoadDFA9Transition() // LUCENENET: Avoid static constructors (see https://github.com/apache/lucenenet/pull/224#issuecomment-469284006)
- {
- int numStates = DFA9_transitionS.Length;
- var DFA9_transition = new short[numStates][];
- for (int i = 0; i < numStates; i++)
- {
- DFA9_transition[i] = DFA.UnpackEncodedString(DFA9_transitionS[i]);
- }
- return DFA9_transition;
- }
-
- protected class DFA9 : DFA
- {
- public DFA9(JavascriptLexer _enclosing, BaseRecognizer recognizer)
- {
- this._enclosing = _enclosing;
- this.recognizer = recognizer;
- this.decisionNumber = 9;
- this.eot = DFA9_eot;
- this.eof = DFA9_eof;
- this.min = DFA9_min;
- this.max = DFA9_max;
- this.accept = DFA9_accept;
- this.special = DFA9_special;
- this.transition = DFA9_transition;
- }
-
- public override string Description
- => "346:1: DECIMAL : ( DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )? | AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )? | DECIMALINTEGER ( EXPONENT )? );";
-
-#pragma warning disable IDE0052 // Remove unread private members
- private readonly JavascriptLexer _enclosing;
-#pragma warning restore IDE0052 // Remove unread private members
- }
- }
-}
diff --git a/src/Lucene.Net.Expressions/JS/JavascriptParser.cs b/src/Lucene.Net.Expressions/JS/JavascriptParser.cs
deleted file mode 100644
index f5e6fe8db..000000000
--- a/src/Lucene.Net.Expressions/JS/JavascriptParser.cs
+++ /dev/null
@@ -1,1886 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-// ANTLR GENERATED CODE: DO NOT EDIT (LUCENENET: Not really auto generated in the port)
-
-using Antlr.Runtime;
-using Antlr.Runtime.Tree;
-using J2N.Text;
-using Lucene.Net.Support;
-using System;
-using System.Diagnostics.CodeAnalysis;
-
-namespace Lucene.Net.Expressions.JS
-{
- internal class JavascriptParser : Parser
- {
- public static readonly string[] tokenNames =
- {
- "<invalid>", "<EOR>", "<DOWN>", "<UP>", "AT_ADD", "AT_BIT_AND", "AT_BIT_NOT",
- "AT_BIT_OR", "AT_BIT_SHL", "AT_BIT_SHR", "AT_BIT_SHU", "AT_BIT_XOR", "AT_BOOL_AND",
- "AT_BOOL_NOT", "AT_BOOL_OR", "AT_CALL", "AT_COLON", "AT_COMMA", "AT_COMP_EQ",
- "AT_COMP_GT", "AT_COMP_GTE", "AT_COMP_LT", "AT_COMP_LTE", "AT_COMP_NEQ",
- "AT_COND_QUE", "AT_DIVIDE", "AT_DOT", "AT_LPAREN", "AT_MODULO", "AT_MULTIPLY",
- "AT_NEGATE", "AT_RPAREN", "AT_SUBTRACT", "DECIMAL", "DECIMALDIGIT", "DECIMALINTEGER",
- "EXPONENT", "HEX", "HEXDIGIT", "ID", "NAMESPACE_ID", "OCTAL", "OCTALDIGIT",
- "WS"
- };
-
- public const int EOF = -1;
-
- public const int AT_ADD = 4;
-
- public const int AT_BIT_AND = 5;
-
- public const int AT_BIT_NOT = 6;
-
- public const int AT_BIT_OR = 7;
-
- public const int AT_BIT_SHL = 8;
-
- public const int AT_BIT_SHR = 9;
-
- public const int AT_BIT_SHU = 10;
-
- public const int AT_BIT_XOR = 11;
-
- public const int AT_BOOL_AND = 12;
-
- public const int AT_BOOL_NOT = 13;
-
- public const int AT_BOOL_OR = 14;
-
- public const int AT_CALL = 15;
-
- public const int AT_COLON = 16;
-
- public const int AT_COMMA = 17;
-
- public const int AT_COMP_EQ = 18;
-
- public const int AT_COMP_GT = 19;
-
- public const int AT_COMP_GTE = 20;
-
- public const int AT_COMP_LT = 21;
-
- public const int AT_COMP_LTE = 22;
-
- public const int AT_COMP_NEQ = 23;
-
- public const int AT_COND_QUE = 24;
-
- public const int AT_DIVIDE = 25;
-
- public const int AT_DOT = 26;
-
- public const int AT_LPAREN = 27;
-
- public const int AT_MODULO = 28;
-
- public const int AT_MULTIPLY = 29;
-
- public const int AT_NEGATE = 30;
-
- public const int AT_RPAREN = 31;
-
- public const int AT_SUBTRACT = 32;
-
- public const int DECIMAL = 33;
-
- public const int DECIMALDIGIT = 34;
-
- public const int DECIMALINTEGER = 35;
-
- public const int EXPONENT = 36;
-
- public const int HEX = 37;
-
- public const int HEXDIGIT = 38;
-
- public const int ID = 39;
-
- public const int NAMESPACE_ID = 40;
-
- public const int OCTAL = 41;
-
- public const int OCTALDIGIT = 42;
-
- public const int WS = 43;
-
- // delegates
- public virtual Parser[] GetDelegates()
- {
- return Array.Empty<Parser>();
- }
-
- public JavascriptParser(CommonTokenStream input)
- : this(input, new RecognizerSharedState())
- {
- }
-
- public JavascriptParser(CommonTokenStream input, RecognizerSharedState state)
- : base(input, state)
- {
- }
-
- protected ITreeAdaptor m_adaptor = new CommonTreeAdaptor();
-
- public virtual ITreeAdaptor TreeAdaptor
- {
- get => m_adaptor;
- set => m_adaptor = value;
- }
-
- // delegators
-
- [WritableArray]
- [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
- public override string[] TokenNames => tokenNames;
-
- public override string GrammarFileName
- => "src/java/org/apache/lucene/expressions/js/Javascript.g";
-
- public override void DisplayRecognitionError(string[] tokenNames, RecognitionException re)
- {
- string message;
- if (re.Token is null)
- {
- message = " unknown error (missing token).";
- }
- else
- {
- if (re is UnwantedTokenException)
- {
- message = " extraneous " + GetReadableTokenString(re.Token) + " at position (" + re.CharPositionInLine + ").";
- }
- else
- {
- if (re is MissingTokenException)
- {
- message = " missing " + GetReadableTokenString(re.Token) + " at position (" + re.CharPositionInLine + ").";
- }
- else
- {
- if (re is NoViableAltException)
- {
- switch (re.Token.Type)
- {
- case EOF:
- {
- message = " unexpected end of expression.";
- break;
- }
-
- default:
- {
- message = " invalid sequence of tokens near " + GetReadableTokenString(re.Token)
- + " at position (" + re.CharPositionInLine + ").";
- break;
- }
- }
- }
- else
- {
- message = " unexpected token " + GetReadableTokenString(re.Token) + " at position ("
- + re.CharPositionInLine + ").";
- }
- }
- }
- }
- throw new ParseException(message, re.CharPositionInLine, re);
- }
-
- public static string GetReadableTokenString(IToken token)
- {
- if (token is null)
- {
- return "unknown token";
- }
- switch (token.Type)
- {
- case AT_LPAREN:
- {
- return "open parenthesis '('";
- }
-
- case AT_RPAREN:
- {
- return "close parenthesis ')'";
- }
-
- case AT_COMP_LT:
- {
- return "less than '<'";
- }
-
- case AT_COMP_LTE:
- {
- return "less than or equal '<='";
- }
-
- case AT_COMP_GT:
- {
- return "greater than '>'";
- }
-
- case AT_COMP_GTE:
- {
- return "greater than or equal '>='";
- }
-
- case AT_COMP_EQ:
- {
- return "equal '=='";
- }
-
- case AT_NEGATE:
- {
- return "negate '!='";
- }
-
- case AT_BOOL_NOT:
- {
- return "boolean not '!'";
- }
-
- case AT_BOOL_AND:
- {
- return "boolean and '&&'";
- }
-
- case AT_BOOL_OR:
- {
- return "boolean or '||'";
- }
-
- case AT_COND_QUE:
- {
- return "conditional '?'";
- }
-
- case AT_ADD:
- {
- return "addition '+'";
- }
-
- case AT_SUBTRACT:
- {
- return "subtraction '-'";
- }
-
- case AT_MULTIPLY:
- {
- return "multiplication '*'";
- }
-
- case AT_DIVIDE:
- {
- return "division '/'";
- }
-
- case AT_MODULO:
- {
- return "modulo '%'";
- }
-
- case AT_BIT_SHL:
- {
- return "bit shift left '<<'";
- }
-
- case AT_BIT_SHR:
- {
- return "bit shift right '>>'";
- }
-
- case AT_BIT_SHU:
- {
- return "unsigned bit shift right '>>>'";
- }
-
- case AT_BIT_AND:
- {
- return "bitwise and '&'";
- }
-
- case AT_BIT_OR:
- {
- return "bitwise or '|'";
- }
-
- case AT_BIT_XOR:
- {
- return "bitwise xor '^'";
- }
-
- case AT_BIT_NOT:
- {
- return "bitwise not '~'";
- }
-
- case ID:
- {
- return "identifier '" + token.Text + "'";
- }
-
- case DECIMAL:
- {
- return "decimal '" + token.Text + "'";
- }
-
- case OCTAL:
- {
- return "octal '" + token.Text + "'";
- }
-
- case HEX:
- {
- return "hex '" + token.Text + "'";
- }
-
- case EOF:
- {
- return "end of expression";
- }
-
- default:
- {
- return "'" + token.Text + "'";
- }
- }
- }
-
- public class ExpressionReturn<TToken> : ParserRuleReturnScope<TToken>
- {
-
- }
-
- // $ANTLR start "expression"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:250:1: expression : conditional EOF !;
-
- public AstParserRuleReturnScope<ITree, IToken> Expression()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- CommonTree root; // LUCENENET: IDE0059: Remove unnecessary value assignment
- IToken EOF2; // LUCENENET: IDE0059: Remove unnecessary value assignment
- AstParserRuleReturnScope<ITree, IToken> conditional1;
- //CommonTree EOF2_tree = null; // LUCENENET NOTE: Not used
- try
- {
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:251:5: ( conditional EOF !)
- // src/java/org/apache/lucene/expressions/js/Javascript.g:251:7: conditional EOF !
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_conditional_in_expression737);
- conditional1 = Conditional();
- state._fsp--;
- m_adaptor.AddChild(root, conditional1.Tree);
- EOF2 = (IToken)Match(input, EOF, FOLLOW_EOF_in_expression739);
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
- }
- // do for sure before leaving
- return retval;
- }
-
-
- // $ANTLR start "conditional"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:254:1: conditional : logical_or ( AT_COND_QUE ^ conditional AT_COLON ! conditional )? ;
- /// <exception cref="Antlr.Runtime.RecognitionException"></exception>
- public AstParserRuleReturnScope<ITree, IToken> Conditional()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- CommonTree root_0;
- IToken AT_COND_QUE4;
- //IToken AT_COLON6 = null; // LUCENENET: IDE0059: Remove unnecessary value assignment
- AstParserRuleReturnScope<ITree, IToken> logical_or3;
- AstParserRuleReturnScope<ITree, IToken> conditional5;
- AstParserRuleReturnScope<ITree, IToken> conditional7;
- CommonTree AT_COND_QUE4_tree;
- //CommonTree AT_COLON6_tree = null; // LUCENENET NOTE: Not used
- try
- {
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:255:5: ( logical_or ( AT_COND_QUE ^ conditional AT_COLON ! conditional )? )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:255:7: logical_or ( AT_COND_QUE ^ conditional AT_COLON ! conditional )?
- root_0 = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_logical_or_in_conditional757);
- logical_or3 = Logical_Or();
- state._fsp--;
- m_adaptor.AddChild(root_0, logical_or3.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:255:18: ( AT_COND_QUE ^ conditional AT_COLON ! conditional )?
- int alt1 = 2;
- int LA1_0 = input.LA(1);
- if ((LA1_0 == AT_COND_QUE))
- {
- alt1 = 1;
- }
- switch (alt1)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:255:19: AT_COND_QUE ^ conditional AT_COLON ! conditional
- AT_COND_QUE4 = (IToken)Match(input, AT_COND_QUE, FOLLOW_AT_COND_QUE_in_conditional760);
- AT_COND_QUE4_tree = (CommonTree)m_adaptor.Create(AT_COND_QUE4);
- root_0 = (CommonTree)m_adaptor.BecomeRoot(AT_COND_QUE4_tree, root_0);
- PushFollow(FOLLOW_conditional_in_conditional763);
- conditional5 = Conditional();
- state._fsp--;
- m_adaptor.AddChild(root_0, conditional5.Tree);
- /*AT_COLON6 = (IToken)*/Match(input, AT_COLON, FOLLOW_AT_COLON_in_conditional765); // LUCENENET: IDE0059: Remove unnecessary value assignment
- PushFollow(FOLLOW_conditional_in_conditional768);
- conditional7 = Conditional();
- state._fsp--;
- m_adaptor.AddChild(root_0, conditional7.Tree);
- break;
- }
- }
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root_0);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
- }
- // do for sure before leaving
- return retval;
- }
-
- // $ANTLR start "logical_or"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:258:1: logical_or : logical_and ( AT_BOOL_OR ^ logical_and )* ;
-
- public AstParserRuleReturnScope<ITree, IToken> Logical_Or()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- CommonTree root_0;
- IToken AT_BOOL_OR9;
- AstParserRuleReturnScope<ITree, IToken> logical_and8;
- AstParserRuleReturnScope<ITree, IToken> logical_and10;
- CommonTree AT_BOOL_OR9_tree;
- try
- {
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:259:5: ( logical_and ( AT_BOOL_OR ^ logical_and )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:259:7: logical_and ( AT_BOOL_OR ^ logical_and )*
- root_0 = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_logical_and_in_logical_or787);
- logical_and8 = Logical_And();
- state._fsp--;
- m_adaptor.AddChild(root_0, logical_and8.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:259:19: ( AT_BOOL_OR ^ logical_and )*
- while (true)
- {
- int alt2 = 2;
- int LA2_0 = input.LA(1);
- if ((LA2_0 == AT_BOOL_OR))
- {
- alt2 = 1;
- }
- switch (alt2)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:259:20: AT_BOOL_OR ^ logical_and
- AT_BOOL_OR9 = (IToken)Match(input, AT_BOOL_OR, FOLLOW_AT_BOOL_OR_in_logical_or790);
- AT_BOOL_OR9_tree = (CommonTree)m_adaptor.Create(AT_BOOL_OR9);
- root_0 = (CommonTree)m_adaptor.BecomeRoot(AT_BOOL_OR9_tree, root_0);
- PushFollow(FOLLOW_logical_and_in_logical_or793);
- logical_and10 = Logical_And();
- state._fsp--;
- m_adaptor.AddChild(root_0, logical_and10.Tree);
- break;
- }
-
- default:
- {
- goto loop2_break;
- }
- }
- //loop2_continue: // LUCENENET NOTE: Not used
- }
- loop2_break: {/* LUCENENET: intentionally blank */}
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root_0);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
- }
- // do for sure before leaving
- return retval;
- }
-
-
-
- // $ANTLR start "logical_and"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:262:1: logical_and : bitwise_or ( AT_BOOL_AND ^ bitwise_or )* ;
-
- public AstParserRuleReturnScope<ITree, IToken> Logical_And()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- CommonTree root;
- IToken AT_BOOL_AND12;
- AstParserRuleReturnScope<ITree, IToken> bitwise_or11;
- AstParserRuleReturnScope<ITree, IToken> bitwise_or13;
- CommonTree AT_BOOL_AND12_tree; // LUCENENET: IDE0059: Remove unnecessary value assignment
- try
- {
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:263:5: ( bitwise_or ( AT_BOOL_AND ^ bitwise_or )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:263:7: bitwise_or ( AT_BOOL_AND ^ bitwise_or )*
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_bitwise_or_in_logical_and812);
- bitwise_or11 = Bitwise_Or();
- state._fsp--;
- m_adaptor.AddChild(root, bitwise_or11.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:263:18: ( AT_BOOL_AND ^ bitwise_or )*
- while (true)
- {
- int alt3 = 2;
- int LA3_0 = input.LA(1);
- if ((LA3_0 == AT_BOOL_AND))
- {
- alt3 = 1;
- }
- switch (alt3)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:263:19: AT_BOOL_AND ^ bitwise_or
- AT_BOOL_AND12 = (IToken)Match(input, AT_BOOL_AND, FOLLOW_AT_BOOL_AND_in_logical_and815);
- AT_BOOL_AND12_tree = (CommonTree)m_adaptor.Create(AT_BOOL_AND12);
- root = (CommonTree)m_adaptor.BecomeRoot(AT_BOOL_AND12_tree, root);
- PushFollow(FOLLOW_bitwise_or_in_logical_and818);
- bitwise_or13 = Bitwise_Or();
- state._fsp--;
- m_adaptor.AddChild(root, bitwise_or13.Tree);
- break;
- }
-
- default:
- {
- goto loop3_break;
- }
- }
- //loop3_continue: // LUCENENET NOTE: Not used
- }
- loop3_break: {/* LUCENENET: intentionally blank */}
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
- // $ANTLR start "bitwise_or"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:266:1: bitwise_or : bitwise_xor ( AT_BIT_OR ^ bitwise_xor )* ;
-
- public AstParserRuleReturnScope<ITree, IToken> Bitwise_Or()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- try
- {
- CommonTree root = null;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:267:5: ( bitwise_xor ( AT_BIT_OR ^ bitwise_xor )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:267:7: bitwise_xor ( AT_BIT_OR ^ bitwise_xor )*
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_bitwise_xor_in_bitwise_or837);
- AstParserRuleReturnScope<ITree, IToken> bitwise_xor14 = Bitwise_XOr();
- state._fsp--;
- m_adaptor.AddChild(root, bitwise_xor14.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:267:19: ( AT_BIT_OR ^ bitwise_xor )*
- while (true)
- {
- int alt4 = 2;
- int LA4_0 = input.LA(1);
- if ((LA4_0 == AT_BIT_OR))
- {
- alt4 = 1;
- }
- switch (alt4)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:267:20: AT_BIT_OR ^ bitwise_xor
- IToken AT_BIT_OR15 = (IToken)Match(input, AT_BIT_OR, FOLLOW_AT_BIT_OR_in_bitwise_or840);
- CommonTree AT_BIT_OR15_tree = (CommonTree)m_adaptor.Create(AT_BIT_OR15);
- root = (CommonTree)m_adaptor.BecomeRoot(AT_BIT_OR15_tree, root);
- PushFollow(FOLLOW_bitwise_xor_in_bitwise_or843);
- AstParserRuleReturnScope<ITree, IToken> bitwise_xor16 = Bitwise_XOr();
- state._fsp--;
- m_adaptor.AddChild(root, bitwise_xor16.Tree);
- break;
- }
-
- default:
- {
- goto loop4_break;
- }
- }
- //loop4_continue: // LUCENENET NOTE: Not used
- }
- loop4_break: {/* LUCENENET: intentionally blank */}
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
- }
- // do for sure before leaving
- return retval;
- }
-
- // $ANTLR start "bitwise_xor"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:270:1: bitwise_xor : bitwise_and ( AT_BIT_XOR ^ bitwise_and )* ;
-
- public AstParserRuleReturnScope<ITree, IToken> Bitwise_XOr()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- try
- {
- CommonTree root = null;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:271:5: ( bitwise_and ( AT_BIT_XOR ^ bitwise_and )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:271:7: bitwise_and ( AT_BIT_XOR ^ bitwise_and )*
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_bitwise_and_in_bitwise_xor862);
- AstParserRuleReturnScope<ITree, IToken> bitwise_and17 = Bitwise_And();
- state._fsp--;
- m_adaptor.AddChild(root, bitwise_and17.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:271:19: ( AT_BIT_XOR ^ bitwise_and )*
- while (true)
- {
- int alt5 = 2;
- int LA5_0 = input.LA(1);
- if ((LA5_0 == AT_BIT_XOR))
- {
- alt5 = 1;
- }
- switch (alt5)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:271:20: AT_BIT_XOR ^ bitwise_and
- IToken AT_BIT_XOR18 = (IToken)Match(input, AT_BIT_XOR, FOLLOW_AT_BIT_XOR_in_bitwise_xor865
- );
- CommonTree AT_BIT_XOR18_tree = (CommonTree)m_adaptor.Create(AT_BIT_XOR18);
- root = (CommonTree)m_adaptor.BecomeRoot(AT_BIT_XOR18_tree, root);
- PushFollow(FOLLOW_bitwise_and_in_bitwise_xor868);
- AstParserRuleReturnScope<ITree, IToken> bitwise_and19 = Bitwise_And();
- state._fsp--;
- m_adaptor.AddChild(root, bitwise_and19.Tree);
- break;
- }
-
- default:
- {
- goto loop5_break;
- }
- }
- //loop5_continue: // LUCENENET NOTE: Not used
- }
- loop5_break: {/* LUCENENET: intentionally blank */}
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
-
- // $ANTLR start "bitwise_and"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:274:1: bitwise_and : equality ( AT_BIT_AND ^ equality )* ;
-
- public AstParserRuleReturnScope<ITree, IToken> Bitwise_And()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- try
- {
- CommonTree root = null;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:275:5: ( equality ( AT_BIT_AND ^ equality )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:275:8: equality ( AT_BIT_AND ^ equality )*
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_equality_in_bitwise_and888);
- AstParserRuleReturnScope<ITree, IToken> equality20 = Equality();
- state._fsp--;
- m_adaptor.AddChild(root, equality20.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:275:17: ( AT_BIT_AND ^ equality )*
- while (true)
- {
- int alt6 = 2;
- int LA6_0 = input.LA(1);
- if ((LA6_0 == AT_BIT_AND))
- {
- alt6 = 1;
- }
- switch (alt6)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:275:18: AT_BIT_AND ^ equality
- IToken AT_BIT_AND21 = (IToken)Match(input, AT_BIT_AND, FOLLOW_AT_BIT_AND_in_bitwise_and891
- );
- CommonTree AT_BIT_AND21_tree = (CommonTree)m_adaptor.Create(AT_BIT_AND21);
- root = (CommonTree)m_adaptor.BecomeRoot(AT_BIT_AND21_tree, root);
- PushFollow(FOLLOW_equality_in_bitwise_and894);
- AstParserRuleReturnScope<ITree, IToken> equality22 = Equality();
- state._fsp--;
- m_adaptor.AddChild(root, equality22.Tree);
- break;
- }
-
- default:
- {
- goto loop6_break;
- }
- }
- //loop6_continue: // LUCENENET NOTE: Not used
- }
- loop6_break: {/* LUCENENET: intentionally blank */}
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
- }
- // do for sure before leaving
- return retval;
- }
-
- // $ANTLR start "equality"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:278:1: equality : relational ( ( AT_COMP_EQ | AT_COMP_NEQ ) ^ relational )* ;
-
- public AstParserRuleReturnScope<ITree, IToken> Equality()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- //CommonTree set24_tree = null; // LUCENENET NOTE: Not used
- try
- {
- CommonTree root = null;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:279:5: ( relational ( ( AT_COMP_EQ | AT_COMP_NEQ ) ^ relational )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:279:7: relational ( ( AT_COMP_EQ | AT_COMP_NEQ ) ^ relational )*
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_relational_in_equality913);
- AstParserRuleReturnScope<ITree, IToken> relational23 = Relational();
- state._fsp--;
- m_adaptor.AddChild(root, relational23.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:279:18: ( ( AT_COMP_EQ | AT_COMP_NEQ ) ^ relational )*
- while (true)
- {
- int alt7 = 2;
- int LA7_0 = input.LA(1);
- if ((LA7_0 == AT_COMP_EQ || LA7_0 == AT_COMP_NEQ))
- {
- alt7 = 1;
- }
- switch (alt7)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:279:19: ( AT_COMP_EQ | AT_COMP_NEQ ) ^ relational
- IToken set24 = input.LT(1);
- set24 = input.LT(1);
- if (input.LA(1) == AT_COMP_EQ || input.LA(1) == AT_COMP_NEQ)
- {
- input.Consume();
- root = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(set24), root
- );
- state.errorRecovery = false;
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- throw mse;
- }
- PushFollow(FOLLOW_relational_in_equality925);
- AstParserRuleReturnScope<ITree, IToken> relational25 = Relational();
- state._fsp--;
- m_adaptor.AddChild(root, relational25.Tree);
- break;
- }
-
- default:
- {
- goto loop7_break;
- }
- }
- //loop7_continue: // LUCENENET NOTE: Not used
- }
- loop7_break: {/* LUCENENET: intentionally blank */}
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
-
- // $ANTLR start "relational"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:282:1: relational : shift ( ( AT_COMP_LT | AT_COMP_GT | AT_COMP_LTE | AT_COMP_GTE ) ^ shift )* ;
-
- public AstParserRuleReturnScope<ITree, IToken> Relational()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- //CommonTree set27_tree = null; // LUCENENET NOTE: Not used
- try
- {
- CommonTree root = null;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:283:5: ( shift ( ( AT_COMP_LT | AT_COMP_GT | AT_COMP_LTE | AT_COMP_GTE ) ^ shift )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:283:7: shift ( ( AT_COMP_LT | AT_COMP_GT | AT_COMP_LTE | AT_COMP_GTE ) ^ shift )*
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_shift_in_relational944);
- AstParserRuleReturnScope<ITree, IToken> shift26 = Shift();
- state._fsp--;
- m_adaptor.AddChild(root, shift26.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:283:13: ( ( AT_COMP_LT | AT_COMP_GT | AT_COMP_LTE | AT_COMP_GTE ) ^ shift )*
- while (true)
- {
- int alt8 = 2;
- int LA8_0 = input.LA(1);
- if (((LA8_0 >= AT_COMP_GT && LA8_0 <= AT_COMP_LTE)))
- {
- alt8 = 1;
- }
- switch (alt8)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:283:14: ( AT_COMP_LT | AT_COMP_GT | AT_COMP_LTE | AT_COMP_GTE ) ^ shift
- IToken set27 = input.LT(1);
- set27 = input.LT(1);
- if ((input.LA(1) >= AT_COMP_GT && input.LA(1) <= AT_COMP_LTE))
- {
- input.Consume();
- root = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(set27), root
- );
- state.errorRecovery = false;
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- throw mse;
- }
- PushFollow(FOLLOW_shift_in_relational964);
- AstParserRuleReturnScope<ITree, IToken> shift28 = Shift();
- state._fsp--;
- m_adaptor.AddChild(root, shift28.Tree);
- break;
- }
-
- default:
- {
- goto loop8_break;
- }
- }
- //loop8_continue: // LUCENENET NOTE: Not used
- }
- loop8_break: {/* LUCENENET: intentionally blank */}
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
-
- // $ANTLR start "shift"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:286:1: shift : additive ( ( AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU ) ^ additive )* ;
-
- public AstParserRuleReturnScope<ITree, IToken> Shift()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- //CommonTree set30_tree = null; // LUCENENET NOTE: Not used
- try
- {
- CommonTree root = null;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:287:5: ( additive ( ( AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU ) ^ additive )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:287:7: additive ( ( AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU ) ^ additive )*
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_additive_in_shift983);
- AstParserRuleReturnScope<ITree, IToken> additive29 = Additive();
- state._fsp--;
- m_adaptor.AddChild(root, additive29.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:287:16: ( ( AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU ) ^ additive )*
- while (true)
- {
- int alt9 = 2;
- int LA9_0 = input.LA(1);
- if (((LA9_0 >= AT_BIT_SHL && LA9_0 <= AT_BIT_SHU)))
- {
- alt9 = 1;
- }
- switch (alt9)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:287:17: ( AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU ) ^ additive
- IToken set30 = input.LT(1);
- set30 = input.LT(1);
- if ((input.LA(1) >= AT_BIT_SHL && input.LA(1) <= AT_BIT_SHU))
- {
- input.Consume();
- root = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(set30), root
- );
- state.errorRecovery = false;
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- throw mse;
- }
- PushFollow(FOLLOW_additive_in_shift999);
- AstParserRuleReturnScope<ITree, IToken> additive31 = Additive();
- state._fsp--;
- m_adaptor.AddChild(root, additive31.Tree);
- break;
- }
-
- default:
- {
- goto loop9_break;
- }
- }
- //loop9_continue: // LUCENENET NOTE: Not used
- }
- loop9_break: {/* LUCENENET: intentionally blank */}
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
-
- // $ANTLR start "additive"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:290:1: additive : multiplicative ( ( AT_ADD | AT_SUBTRACT ) ^ multiplicative )* ;
-
- public AstParserRuleReturnScope<ITree, IToken> Additive()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- //CommonTree set33_tree = null; // LUCENENET NOTE: Not used
- try
- {
- CommonTree root = null;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:291:5: ( multiplicative ( ( AT_ADD | AT_SUBTRACT ) ^ multiplicative )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:291:7: multiplicative ( ( AT_ADD | AT_SUBTRACT ) ^ multiplicative )*
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_multiplicative_in_additive1018);
- AstParserRuleReturnScope<ITree, IToken> multiplicative32 = Multiplicative();
- state._fsp--;
- m_adaptor.AddChild(root, multiplicative32.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:291:22: ( ( AT_ADD | AT_SUBTRACT ) ^ multiplicative )*
- while (true)
- {
- int alt10 = 2;
- int LA10_0 = input.LA(1);
- if ((LA10_0 == AT_ADD || LA10_0 == AT_SUBTRACT))
- {
- alt10 = 1;
- }
- switch (alt10)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:291:23: ( AT_ADD | AT_SUBTRACT ) ^ multiplicative
- IToken set33 = input.LT(1);
- set33 = input.LT(1);
- if (input.LA(1) == AT_ADD || input.LA(1) == AT_SUBTRACT)
- {
- input.Consume();
- root = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(set33), root
- );
- state.errorRecovery = false;
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- throw mse;
- }
- PushFollow(FOLLOW_multiplicative_in_additive1030);
- AstParserRuleReturnScope<ITree, IToken> multiplicative34 = Multiplicative();
- state._fsp--;
- m_adaptor.AddChild(root, multiplicative34.Tree);
- break;
- }
-
- default:
- {
- goto loop10_break;
- }
- }
- //loop10_continue: // LUCENENET NOTE: Not used
- }
- loop10_break: {/* LUCENENET: intentionally blank */}
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
- // $ANTLR start "multiplicative"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:294:1: multiplicative : unary ( ( AT_MULTIPLY | AT_DIVIDE | AT_MODULO ) ^ unary )* ;
-
- public AstParserRuleReturnScope<ITree, IToken> Multiplicative()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- //CommonTree set36_tree = null; // LUCENENET NOTE: Not used
- try
- {
- CommonTree root = null;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:295:5: ( unary ( ( AT_MULTIPLY | AT_DIVIDE | AT_MODULO ) ^ unary )* )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:295:7: unary ( ( AT_MULTIPLY | AT_DIVIDE | AT_MODULO ) ^ unary )*
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_unary_in_multiplicative1049);
- AstParserRuleReturnScope<ITree, IToken> unary35 = Unary();
- state._fsp--;
- m_adaptor.AddChild(root, unary35.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:295:13: ( ( AT_MULTIPLY | AT_DIVIDE | AT_MODULO ) ^ unary )*
- while (true)
- {
- int alt11 = 2;
- int LA11_0 = input.LA(1);
- if ((LA11_0 == AT_DIVIDE || (LA11_0 >= AT_MODULO && LA11_0 <= AT_MULTIPLY)))
- {
- alt11 = 1;
- }
- switch (alt11)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:295:14: ( AT_MULTIPLY | AT_DIVIDE | AT_MODULO ) ^ unary
- IToken set36 = input.LT(1);
- set36 = input.LT(1);
- if (input.LA(1) == AT_DIVIDE || (input.LA(1) >= AT_MODULO && input.LA(1) <= AT_MULTIPLY
- ))
- {
- input.Consume();
- root = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(set36), root
- );
- state.errorRecovery = false;
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- throw mse;
- }
- PushFollow(FOLLOW_unary_in_multiplicative1065);
- AstParserRuleReturnScope<ITree, IToken> unary37 = Unary();
- state._fsp--;
- m_adaptor.AddChild(root, unary37.Tree);
- break;
- }
-
- default:
- {
- goto loop11_break;
- }
- }
- //loop11_continue: // LUCENENET NOTE: Not used
- }
- loop11_break: {/* LUCENENET: intentionally blank */}
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
-
- // $ANTLR start "unary"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:298:1: unary : ( postfix | AT_ADD ! unary | unary_operator ^ unary );
-
- public AstParserRuleReturnScope<ITree, IToken> Unary()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- CommonTree root = null;
- //CommonTree AT_ADD39_tree = null; // LUCENENET NOTE: Not used
- try
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:299:5: ( postfix | AT_ADD ! unary | unary_operator ^ unary )
- int alt12 = 3;
- switch (input.LA(1))
- {
- case AT_LPAREN:
- case DECIMAL:
- case HEX:
- case NAMESPACE_ID:
- case OCTAL:
- {
- alt12 = 1;
- break;
- }
-
- case AT_ADD:
- {
- alt12 = 2;
- break;
- }
-
- case AT_BIT_NOT:
- case AT_BOOL_NOT:
- case AT_SUBTRACT:
- {
- alt12 = 3;
- break;
- }
-
- default:
- {
- NoViableAltException nvae = new NoViableAltException(string.Empty, 12, 0, input);
- throw nvae;
- }
- }
- switch (alt12)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:299:7: postfix
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_postfix_in_unary1084);
- AstParserRuleReturnScope<ITree, IToken> postfix38 = Postfix();
- state._fsp--;
- m_adaptor.AddChild(root, postfix38.Tree);
- break;
- }
-
- case 2:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:300:7: AT_ADD ! unary
- root = (CommonTree)m_adaptor.Nil();
- IToken AT_ADD39 = (IToken)Match(input, AT_ADD, FOLLOW_AT_ADD_in_unary1092);
- PushFollow(FOLLOW_unary_in_unary1095);
- AstParserRuleReturnScope<ITree, IToken> unary40 = Unary();
- state._fsp--;
- m_adaptor.AddChild(root, unary40.Tree);
- break;
- }
-
- case 3:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:301:7: unary_operator ^ unary
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_unary_operator_in_unary1103);
- AstParserRuleReturnScope<ITree, IToken> unary_operator41 = Unary_Operator();
- state._fsp--;
- root = (CommonTree)m_adaptor.BecomeRoot(unary_operator41.Tree, root);
- PushFollow(FOLLOW_unary_in_unary1106);
- AstParserRuleReturnScope<ITree, IToken> unary42 = Unary();
- state._fsp--;
- m_adaptor.AddChild(root, unary42.Tree);
- break;
- }
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
-
- // $ANTLR start "unary_operator"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:304:1: unary_operator : ( AT_SUBTRACT -> AT_NEGATE | AT_BIT_NOT | AT_BOOL_NOT );
-
- public AstParserRuleReturnScope<ITree, IToken> Unary_Operator()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- CommonTree root = null;
- //CommonTree AT_SUBTRACT43_tree = null; // LUCENENET NOTE: Not used
- RewriteRuleTokenStream stream_AT_SUBTRACT = new RewriteRuleTokenStream(m_adaptor, "token AT_SUBTRACT"
- );
- try
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:305:5: ( AT_SUBTRACT -> AT_NEGATE | AT_BIT_NOT | AT_BOOL_NOT )
- int alt13 = 3;
- switch (input.LA(1))
- {
- case AT_SUBTRACT:
- {
- alt13 = 1;
- break;
- }
-
- case AT_BIT_NOT:
- {
- alt13 = 2;
- break;
- }
-
- case AT_BOOL_NOT:
- {
- alt13 = 3;
- break;
- }
-
- default:
- {
- NoViableAltException nvae = new NoViableAltException(string.Empty, 13, 0, input);
- throw nvae;
- }
- }
- switch (alt13)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:305:7: AT_SUBTRACT
- IToken AT_SUBTRACT43 = (IToken)Match(input, AT_SUBTRACT, FOLLOW_AT_SUBTRACT_in_unary_operator1123
- );
- stream_AT_SUBTRACT.Add(AT_SUBTRACT43);
- // AST REWRITE
- // elements:
- // token labels:
- // rule labels: retval
- // token list labels:
- // rule list labels:
- // wildcard labels:
- retval.Tree = root;
- RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(m_adaptor, "rule retval"
- , retval != null ? ((CommonTree)retval.Tree) : null);
- root = (CommonTree)m_adaptor.Nil();
- {
- // 305:19: -> AT_NEGATE
- m_adaptor.AddChild(root, (CommonTree)m_adaptor.Create(AT_NEGATE, "AT_NEGATE"));
- }
- retval.Tree = root;
- break;
- }
-
- case 2:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:306:7: AT_BIT_NOT
- root = (CommonTree)m_adaptor.Nil();
- IToken AT_BIT_NOT44 = (IToken)Match(input, AT_BIT_NOT, FOLLOW_AT_BIT_NOT_in_unary_operator1135
- );
- CommonTree AT_BIT_NOT44_tree = (CommonTree)m_adaptor.Create(AT_BIT_NOT44);
- m_adaptor.AddChild(root, AT_BIT_NOT44_tree);
- break;
- }
-
- case 3:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:307:7: AT_BOOL_NOT
- root = (CommonTree)m_adaptor.Nil();
- IToken AT_BOOL_NOT45 = (IToken)Match(input, AT_BOOL_NOT, FOLLOW_AT_BOOL_NOT_in_unary_operator1143
- );
- CommonTree AT_BOOL_NOT45_tree = (CommonTree)m_adaptor.Create(AT_BOOL_NOT45);
- m_adaptor.AddChild(root, AT_BOOL_NOT45_tree);
- break;
- }
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
- // $ANTLR start "postfix"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:310:1: postfix : ( primary | NAMESPACE_ID arguments -> ^( AT_CALL NAMESPACE_ID ( arguments )? ) );
-
- public AstParserRuleReturnScope<ITree, IToken> Postfix()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- CommonTree root = null;
- //CommonTree NAMESPACE_ID47_tree = null; // LUCENENET NOTE: Not used
- var streamNamespaceId = new RewriteRuleTokenStream(m_adaptor, "token NAMESPACE_ID");
- var streamArguments = new RewriteRuleSubtreeStream(m_adaptor, "rule arguments");
- try
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:311:5: ( primary | NAMESPACE_ID arguments -> ^( AT_CALL NAMESPACE_ID ( arguments )? ) )
- int alt14 = 2;
- int LA14_0 = input.LA(1);
- if ((LA14_0 == NAMESPACE_ID))
- {
- int LA14_1 = input.LA(2);
- if ((LA14_1 == EOF || (LA14_1 >= AT_ADD && LA14_1 <= AT_BIT_AND) || (LA14_1 >= AT_BIT_OR
- && LA14_1 <= AT_BOOL_AND) || LA14_1 == AT_BOOL_OR || (LA14_1 >= AT_COLON && LA14_1
- <= AT_DIVIDE) || (LA14_1 >= AT_MODULO && LA14_1 <= AT_MULTIPLY) || (LA14_1 >= AT_RPAREN
- && LA14_1 <= AT_SUBTRACT)))
- {
- alt14 = 1;
- }
- else
- {
- if ((LA14_1 == AT_LPAREN))
- {
- alt14 = 2;
- }
- else
- {
- int nvaeMark = input.Mark();
- try
- {
- input.Consume();
- NoViableAltException nvae = new NoViableAltException(string.Empty, 14, 1, input);
- throw nvae;
- }
- finally
- {
- input.Rewind(nvaeMark);
- }
- }
- }
- }
- else
- {
- if ((LA14_0 == AT_LPAREN || LA14_0 == DECIMAL || LA14_0 == HEX || LA14_0 == OCTAL
- ))
- {
- alt14 = 1;
- }
- else
- {
- NoViableAltException nvae = new NoViableAltException(string.Empty, 14, 0, input);
- throw nvae;
- }
- }
- switch (alt14)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:311:7: primary
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_primary_in_postfix1160);
- AstParserRuleReturnScope<ITree, IToken> primary46 = Primary();
- state._fsp--;
- m_adaptor.AddChild(root, primary46.Tree);
- break;
- }
-
- case 2:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:312:7: NAMESPACE_ID arguments
- IToken NAMESPACE_ID47 = (IToken)Match(input, NAMESPACE_ID, FOLLOW_NAMESPACE_ID_in_postfix1168
- );
- streamNamespaceId.Add(NAMESPACE_ID47);
- PushFollow(FOLLOW_arguments_in_postfix1170);
- AstParserRuleReturnScope<ITree, IToken> arguments48 = Arguments();
- state._fsp--;
- streamArguments.Add(arguments48.Tree);
- // AST REWRITE
- // elements: NAMESPACE_ID, arguments
- // token labels:
- // rule labels: retval
- // token list labels:
- // rule list labels:
- // wildcard labels:
- retval.Tree = root;
- RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(m_adaptor, "rule retval"
- , retval != null ? ((CommonTree)retval.Tree) : null);
- root = (CommonTree)m_adaptor.Nil();
- {
- {
- // 312:30: -> ^( AT_CALL NAMESPACE_ID ( arguments )? )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:312:33: ^( AT_CALL NAMESPACE_ID ( arguments )? )
- CommonTree root_1 = (CommonTree)m_adaptor.Nil();
- root_1 = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(AT_CALL, "AT_CALL"
- ), root_1);
- m_adaptor.AddChild(root_1, streamNamespaceId.NextNode());
- // src/java/org/apache/lucene/expressions/js/Javascript.g:312:56: ( arguments )?
- if (streamArguments.HasNext)
- {
- m_adaptor.AddChild(root_1, streamArguments.NextTree());
- }
- streamArguments.Reset();
- m_adaptor.AddChild(root, root_1);
- }
- }
- retval.Tree = root;
- break;
- }
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
-
- // $ANTLR start "primary"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:315:1: primary : ( NAMESPACE_ID | numeric | AT_LPAREN ! conditional AT_RPAREN !);
-
- public AstParserRuleReturnScope<ITree, IToken> Primary()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- CommonTree root = null;
- IToken AT_LPAREN51; // LUCENENET: IDE0059: Remove unnecessary value assignment
- IToken AT_RPAREN53; // LUCENENET: IDE0059: Remove unnecessary value assignment
- CommonTree NAMESPACE_ID49_tree; // LUCENENET: IDE0059: Remove unnecessary value assignment
- //CommonTree AT_LPAREN51_tree = null; // LUCENENET NOTE: Not used
- //CommonTree AT_RPAREN53_tree = null; // LUCENENET NOTE: Not used
- try
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:316:5: ( NAMESPACE_ID | numeric | AT_LPAREN ! conditional AT_RPAREN !)
- int alt15 = 3;
- switch (input.LA(1))
- {
- case NAMESPACE_ID:
- {
- alt15 = 1;
- break;
- }
-
- case DECIMAL:
- case HEX:
- case OCTAL:
- {
- alt15 = 2;
- break;
- }
-
- case AT_LPAREN:
- {
- alt15 = 3;
- break;
- }
-
- default:
- {
- NoViableAltException nvae = new NoViableAltException(string.Empty, 15, 0, input);
- throw nvae;
- }
- }
- switch (alt15)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:316:7: NAMESPACE_ID
- root = (CommonTree)m_adaptor.Nil();
- IToken NAMESPACE_ID49 = (IToken)Match(input, NAMESPACE_ID, FOLLOW_NAMESPACE_ID_in_primary1198
- );
- NAMESPACE_ID49_tree = (CommonTree)m_adaptor.Create(NAMESPACE_ID49);
- m_adaptor.AddChild(root, NAMESPACE_ID49_tree);
- break;
- }
-
- case 2:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:317:7: numeric
- root = (CommonTree)m_adaptor.Nil();
- PushFollow(FOLLOW_numeric_in_primary1206);
- AstParserRuleReturnScope<ITree, IToken> numeric50 = Numeric();
- state._fsp--;
- m_adaptor.AddChild(root, numeric50.Tree);
- break;
- }
-
- case 3:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:318:7: AT_LPAREN ! conditional AT_RPAREN !
- root = (CommonTree)m_adaptor.Nil();
- AT_LPAREN51 = (IToken)Match(input, AT_LPAREN, FOLLOW_AT_LPAREN_in_primary1214);
- PushFollow(FOLLOW_conditional_in_primary1217);
- AstParserRuleReturnScope<ITree, IToken> conditional52 = Conditional();
- state._fsp--;
- m_adaptor.AddChild(root, conditional52.Tree);
- AT_RPAREN53 = (IToken)Match(input, AT_RPAREN, FOLLOW_AT_RPAREN_in_primary1219);
- break;
- }
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
- // $ANTLR start "arguments"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:321:1: arguments : AT_LPAREN ! ( conditional ( AT_COMMA ! conditional )* )? AT_RPAREN !;
-
- public AstParserRuleReturnScope<ITree, IToken> Arguments()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
- CommonTree root; // LUCENENET: IDE0059: Remove unnecessary value assignment
- IToken AT_LPAREN54; // LUCENENET: IDE0059: Remove unnecessary value assignment
- IToken AT_COMMA56; // LUCENENET: IDE0059: Remove unnecessary value assignment
- IToken AT_RPAREN58; // LUCENENET: IDE0059: Remove unnecessary value assignment
- //CommonTree AT_LPAREN54_tree = null; // LUCENENET NOTE: Not used
- //CommonTree AT_COMMA56_tree = null; // LUCENENET NOTE: Not used
- //CommonTree AT_RPAREN58_tree = null; // LUCENENET NOTE: Not used
- try
- {
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:322:5: ( AT_LPAREN ! ( conditional ( AT_COMMA ! conditional )* )? AT_RPAREN !)
- // src/java/org/apache/lucene/expressions/js/Javascript.g:322:7: AT_LPAREN ! ( conditional ( AT_COMMA ! conditional )* )? AT_RPAREN !
- root = (CommonTree)m_adaptor.Nil();
- AT_LPAREN54 = (IToken)Match(input, AT_LPAREN, FOLLOW_AT_LPAREN_in_arguments1237);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:322:18: ( conditional ( AT_COMMA ! conditional )* )?
- int alt17 = 2;
- int LA17_0 = input.LA(1);
- if ((LA17_0 == AT_ADD || LA17_0 == AT_BIT_NOT || LA17_0 == AT_BOOL_NOT || LA17_0
- == AT_LPAREN || (LA17_0 >= AT_SUBTRACT && LA17_0 <= DECIMAL) || LA17_0 == HEX ||
- (LA17_0 >= NAMESPACE_ID && LA17_0 <= OCTAL)))
- {
- alt17 = 1;
- }
- switch (alt17)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:322:19: conditional ( AT_COMMA ! conditional )*
- PushFollow(FOLLOW_conditional_in_arguments1241);
- AstParserRuleReturnScope<ITree, IToken> conditional55 = Conditional();
- state._fsp--;
- m_adaptor.AddChild(root, conditional55.Tree);
- // src/java/org/apache/lucene/expressions/js/Javascript.g:322:31: ( AT_COMMA ! conditional )*
- while (true)
- {
- int alt16 = 2;
- int LA16_0 = input.LA(1);
- if ((LA16_0 == AT_COMMA))
- {
- alt16 = 1;
- }
- switch (alt16)
- {
- case 1:
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:322:32: AT_COMMA ! conditional
- AT_COMMA56 = (IToken)Match(input, AT_COMMA, FOLLOW_AT_COMMA_in_arguments1244);
- PushFollow(FOLLOW_conditional_in_arguments1247);
- AstParserRuleReturnScope<ITree, IToken> conditional57 = Conditional();
- state._fsp--;
- m_adaptor.AddChild(root, conditional57.Tree);
- break;
- }
-
- default:
- {
- goto loop16_break;
- }
- }
- //loop16_continue: // LUCENENET NOTE: Not used
- }
- loop16_break:
- break;
- }
- }
- AT_RPAREN58 = (IToken)Match(input, AT_RPAREN, FOLLOW_AT_RPAREN_in_arguments1253);
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
-
- // $ANTLR start "numeric"
- // src/java/org/apache/lucene/expressions/js/Javascript.g:325:1: numeric : ( HEX | OCTAL | DECIMAL );
-
- public AstParserRuleReturnScope<ITree, IToken> Numeric()
- {
- var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
-
- //CommonTree set59_tree = null; // LUCENENET NOTE: Not used
- try
- {
- CommonTree root = null;
- {
- // src/java/org/apache/lucene/expressions/js/Javascript.g:326:5: ( HEX | OCTAL | DECIMAL )
- // src/java/org/apache/lucene/expressions/js/Javascript.g:
- root = (CommonTree)m_adaptor.Nil();
- IToken set59 = input.LT(1);
- if (input.LA(1) == DECIMAL || input.LA(1) == HEX || input.LA(1) == OCTAL)
- {
- input.Consume();
- m_adaptor.AddChild(root, (CommonTree)m_adaptor.Create(set59));
- state.errorRecovery = false;
- }
- else
- {
- MismatchedSetException mse = new MismatchedSetException(null, input);
- throw mse;
- }
- }
- retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
- m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
- }
- catch (RecognitionException re)
- {
- ReportError(re);
- Recover(input, re);
- retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
- );
- }
- // do for sure before leaving
- return retval;
- }
-
- public static readonly BitSet FOLLOW_conditional_in_expression737 = new BitSet(new[] { ((ulong)(0x0000000000000000L)) });
-
- public static readonly BitSet FOLLOW_EOF_in_expression739 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_logical_or_in_conditional757 = new BitSet(new[] { ((ulong)(0x0000000001000002L)) });
-
- public static readonly BitSet FOLLOW_AT_COND_QUE_in_conditional760 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_conditional_in_conditional763 = new BitSet(new[] { ((ulong)(0x0000000000010000L)) });
-
- public static readonly BitSet FOLLOW_AT_COLON_in_conditional765 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_conditional_in_conditional768 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_logical_and_in_logical_or787 = new BitSet(new[] { ((ulong)(0x0000000000004002L)) });
-
- public static readonly BitSet FOLLOW_AT_BOOL_OR_in_logical_or790 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_logical_and_in_logical_or793 = new BitSet(new[] { ((ulong)(0x0000000000004002L)) });
-
- public static readonly BitSet FOLLOW_bitwise_or_in_logical_and812 = new BitSet(new[] { ((ulong)(0x0000000000001002L)) });
-
- public static readonly BitSet FOLLOW_AT_BOOL_AND_in_logical_and815 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_bitwise_or_in_logical_and818 = new BitSet(new[] { ((ulong)(0x0000000000001002L)) });
-
- public static readonly BitSet FOLLOW_bitwise_xor_in_bitwise_or837 = new BitSet(new[] { ((ulong)(0x0000000000000082L)) });
-
- public static readonly BitSet FOLLOW_AT_BIT_OR_in_bitwise_or840 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_bitwise_xor_in_bitwise_or843 = new BitSet(new[] { ((ulong)(0x0000000000000082L)) });
-
- public static readonly BitSet FOLLOW_bitwise_and_in_bitwise_xor862 = new BitSet(new[] { ((ulong)(0x0000000000000802L)) });
-
- public static readonly BitSet FOLLOW_AT_BIT_XOR_in_bitwise_xor865 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_bitwise_and_in_bitwise_xor868 = new BitSet(new[] { ((ulong)(0x0000000000000802L)) });
-
- public static readonly BitSet FOLLOW_equality_in_bitwise_and888 = new BitSet(new[] { ((ulong)(0x0000000000000022L)) });
-
- public static readonly BitSet FOLLOW_AT_BIT_AND_in_bitwise_and891 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_equality_in_bitwise_and894 = new BitSet(new[] { ((ulong)(0x0000000000000022L)) });
-
- public static readonly BitSet FOLLOW_relational_in_equality913 = new BitSet(new[] { ((ulong)(0x0000000000840002L)) });
-
- public static readonly BitSet FOLLOW_set_in_equality916 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_relational_in_equality925 = new BitSet(new[] { ((ulong)(0x0000000000840002L)) });
-
- public static readonly BitSet FOLLOW_shift_in_relational944 = new BitSet(new[] { ((ulong)(0x0000000000780002L)) });
-
- public static readonly BitSet FOLLOW_set_in_relational947 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_shift_in_relational964 = new BitSet(new[] { ((ulong)(0x0000000000780002L)) });
-
- public static readonly BitSet FOLLOW_additive_in_shift983 = new BitSet(new[] { ((ulong)(0x0000000000000702L)) });
-
- public static readonly BitSet FOLLOW_set_in_shift986 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_additive_in_shift999 = new BitSet(new[] { ((ulong)(0x0000000000000702L)) });
-
- public static readonly BitSet FOLLOW_multiplicative_in_additive1018 = new BitSet(new[] { ((ulong)(0x0000000100000012L)) });
-
- public static readonly BitSet FOLLOW_set_in_additive1021 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_multiplicative_in_additive1030 = new BitSet(new[] { ((ulong)(0x0000000100000012L)) });
-
- public static readonly BitSet FOLLOW_unary_in_multiplicative1049 = new BitSet(new[] { ((ulong)(0x0000000032000002L)) });
-
- public static readonly BitSet FOLLOW_set_in_multiplicative1052 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_unary_in_multiplicative1065 = new BitSet(new[] { ((ulong)(0x0000000032000002L)) });
-
- public static readonly BitSet FOLLOW_postfix_in_unary1084 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_AT_ADD_in_unary1092 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_unary_in_unary1095 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_unary_operator_in_unary1103 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_unary_in_unary1106 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_AT_SUBTRACT_in_unary_operator1123 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_AT_BIT_NOT_in_unary_operator1135 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_AT_BOOL_NOT_in_unary_operator1143 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_primary_in_postfix1160 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_NAMESPACE_ID_in_postfix1168 = new BitSet(new[] { ((ulong)(0x0000000008000000L)) });
-
- public static readonly BitSet FOLLOW_arguments_in_postfix1170 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_NAMESPACE_ID_in_primary1198 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_numeric_in_primary1206 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_AT_LPAREN_in_primary1214 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_conditional_in_primary1217 = new BitSet(new[] { ((ulong)(0x0000000080000000L)) });
-
- public static readonly BitSet FOLLOW_AT_RPAREN_in_primary1219 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
-
- public static readonly BitSet FOLLOW_AT_LPAREN_in_arguments1237 = new BitSet(new[] { ((ulong)(0x0000032388002050L)) });
-
- public static readonly BitSet FOLLOW_conditional_in_arguments1241 = new BitSet(new[] { ((ulong)(0x0000000080020000L)) });
-
- public static readonly BitSet FOLLOW_AT_COMMA_in_arguments1244 = new BitSet(new[] { ((ulong)(0x0000032308002050L)) });
-
- public static readonly BitSet FOLLOW_conditional_in_arguments1247 = new BitSet(new[] { ((ulong)(0x0000000080020000L)) });
-
- public static readonly BitSet FOLLOW_AT_RPAREN_in_arguments1253 = new BitSet(new[] { ((ulong)(0x0000000000000002L)) });
- // $ANTLR end "numeric"
- // Delegated rules
- }
-}
diff --git a/src/Lucene.Net.Expressions/Lucene.Net.Expressions.csproj b/src/Lucene.Net.Expressions/Lucene.Net.Expressions.csproj
index 0c62f265f..8c0099097 100644
--- a/src/Lucene.Net.Expressions/Lucene.Net.Expressions.csproj
+++ b/src/Lucene.Net.Expressions/Lucene.Net.Expressions.csproj
@@ -38,18 +38,13 @@
<NoWarn>$(NoWarn);1591;1573</NoWarn>
</PropertyGroup>
-
-
<ItemGroup>
<ProjectReference Include="..\Lucene.Net.Queries\Lucene.Net.Queries.csproj" />
</ItemGroup>
<ItemGroup>
- <PackageReference Include="Antlr3.Runtime" Version="$(Antlr3RuntimePackageVersion)" />
-
- <!-- These are transitive dependencies, but Antlr3.Runtime doesn't provide a secure alternative on netstandard2.0, so we need to include them. -->
- <PackageReference Include="System.Net.Http" Version="$(SystemNetHttpPackageVersion)" />
- <PackageReference Include="System.Text.RegularExpressions" Version="$(SystemTextRegularExpressionsPackageVersion)" />
+ <PackageReference Include="Antlr4.Runtime.Standard" Version="$(Antlr4RuntimeStandardPackageVersion)" />
+ <PackageReference Include="Antlr4BuildTasks" Version="$(Antlr4BuildTasksPackageVersion)" PrivateAssets="all" IncludeAssets="build" />
</ItemGroup>
<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.1' ">
@@ -68,4 +63,12 @@
<EmbeddedResource Include="JS\JavascriptCompiler.properties" />
</ItemGroup>
+ <ItemGroup>
+ <Antlr4 Include="JS\Javascript.g4">
+ <Listener>true</Listener>
+ <Visitor>false</Visitor>
+ <Package>Lucene.Net.Expressions.JS</Package>
+ </Antlr4>
+ </ItemGroup>
+
</Project>
diff --git a/src/Lucene.Net.TestFramework/Support/ApiScanTestBase.cs b/src/Lucene.Net.TestFramework/Support/ApiScanTestBase.cs
index bb5ac1fd7..99b0d359a 100644
--- a/src/Lucene.Net.TestFramework/Support/ApiScanTestBase.cs
+++ b/src/Lucene.Net.TestFramework/Support/ApiScanTestBase.cs
@@ -1,5 +1,6 @@
using Lucene.Net.Support;
using System;
+using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
@@ -407,7 +408,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var classes = assembly.GetTypes().Where(t => t.IsClass);
+ var classes = GetTypesToTest(assembly).Where(t => t.IsClass);
foreach (var c in classes)
{
@@ -443,7 +444,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var classes = assembly.GetTypes().Where(t => t.IsClass);
+ var classes = GetTypesToTest(assembly).Where(t => t.IsClass);
foreach (var c in classes)
{
@@ -489,7 +490,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var classes = assembly.GetTypes().Where(t => t.IsClass && !t.HasAttribute<CompilerGeneratedAttribute>(inherit: false));
+ var classes = GetTypesToTest(assembly).Where(t => t.IsClass);
foreach (var c in classes)
{
@@ -535,7 +536,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var classes = assembly.GetTypes().Where(t => t.IsClass);
+ var classes = GetTypesToTest(assembly).Where(t => t.IsClass);
foreach (var c in classes)
{
@@ -567,7 +568,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var interfaces = assembly.GetTypes().Where(t => t.IsInterface);
+ var interfaces = GetTypesToTest(assembly).Where(t => t.IsInterface);
foreach (var i in interfaces)
{
@@ -584,7 +585,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var classes = assembly.GetTypes().Where(t => t.IsClass);
+ var classes = GetTypesToTest(assembly).Where(t => t.IsClass);
foreach (var c in classes)
{
@@ -611,7 +612,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var classes = assembly.GetTypes().Where(t => t.IsClass);
+ var classes = GetTypesToTest(assembly).Where(t => t.IsClass);
foreach (var c in classes)
{
@@ -633,7 +634,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var classes = assembly.GetTypes().Where(t => t.IsClass);
+ var classes = GetTypesToTest(assembly).Where(t => t.IsClass);
foreach (var c in classes)
{
@@ -667,7 +668,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var classes = assembly.GetTypes().Where(t => t.IsClass);
+ var classes = GetTypesToTest(assembly).Where(t => t.IsClass);
foreach (var c in classes)
{
@@ -699,7 +700,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var types = assembly.GetTypes();
+ var types = GetTypesToTest(assembly);
foreach (var t in types)
{
@@ -737,7 +738,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var types = assembly.GetTypes();
+ var types = GetTypesToTest(assembly);
foreach (var t in types)
{
@@ -772,7 +773,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var types = assembly.GetTypes();
+ var types = GetTypesToTest(assembly);
foreach (var t in types)
{
@@ -816,7 +817,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var types = assembly.GetTypes();
+ var types = GetTypesToTest(assembly);
foreach (var t in types)
{
@@ -838,7 +839,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var classes = assembly.GetTypes().Where(t => t.IsClass);
+ var classes = GetTypesToTest(assembly).Where(t => t.IsClass);
foreach (var c in classes)
{
@@ -892,7 +893,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var types = assembly.GetTypes();
+ var types = GetTypesToTest(assembly);
foreach (var t in types)
{
@@ -1004,7 +1005,7 @@ namespace Lucene.Net.Util
{
var result = new List<string>();
- var types = assembly.GetTypes();
+ var types = GetTypesToTest(assembly);
foreach (var t in types)
{
@@ -1105,5 +1106,10 @@ namespace Lucene.Net.Util
return result.ToArray();
}
+
+ private static IEnumerable<Type> GetTypesToTest(Assembly assembly) =>
+ assembly.GetTypes()
+ .Where(t => !t.HasAttribute<GeneratedCodeAttribute>(inherit: false)
+ && !t.HasAttribute<CompilerGeneratedAttribute>(inherit: false));
}
}
diff --git a/src/Lucene.Net.Tests.Expressions/JS/TestJavascriptOperations.cs b/src/Lucene.Net.Tests.Expressions/JS/TestJavascriptOperations.cs
index 2bcea6cc3..595580a19 100644
--- a/src/Lucene.Net.Tests.Expressions/JS/TestJavascriptOperations.cs
+++ b/src/Lucene.Net.Tests.Expressions/JS/TestJavascriptOperations.cs
@@ -269,7 +269,7 @@ namespace Lucene.Net.Expressions.JS
AssertEvaluatesTo("4195 << 6", 268480);
AssertEvaluatesTo("4195 << 70", 268480);
AssertEvaluatesTo("-4195 << 70", -268480);
- AssertEvaluatesTo("-15 << 62", 1073741824);
+ AssertEvaluatesTo("-15 << 62", 4611686018427387904L);
}
[Test]
@@ -295,13 +295,12 @@ namespace Lucene.Net.Expressions.JS
AssertEvaluatesTo("2 >>> 1", 1);
AssertEvaluatesTo("-1 >>> 37", 134217727);
AssertEvaluatesTo("-2 >>> 62", 3);
- //.NET Port. CLR returns different values for unsigned shift ops
- AssertEvaluatesTo("-5 >>> 33", 2147483645);
+ AssertEvaluatesTo("-5 >>> 33", 2147483647);
AssertEvaluatesTo("536960 >>> 7", 4195);
AssertEvaluatesTo("16780 >>> 66", 4195);
AssertEvaluatesTo("268480 >>> 6", 4195);
AssertEvaluatesTo("268480 >>> 70", 4195);
- AssertEvaluatesTo("-268480 >>> 102", 67104669);
+ AssertEvaluatesTo("-268480 >>> 102", 67108863);
AssertEvaluatesTo("2147483648 >>> 1", 1073741824);
}