parser grammar RutaParser; | |
options { | |
language = Java; | |
tokenVocab = RutaLexer; | |
} | |
@parser::header { | |
/* | |
* 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. | |
*/ | |
package org.apache.uima.ruta.ide.core.parser; | |
import java.util.ArrayList; | |
import java.util.Collection; | |
import java.util.HashMap; | |
import java.util.LinkedHashMap; | |
import java.util.List; | |
import java.util.Map; | |
import java.util.Map.Entry; | |
import java.util.Set; | |
import java.util.Stack; | |
import org.antlr.runtime.BaseRecognizer; | |
import org.antlr.runtime.BitSet; | |
import org.antlr.runtime.CommonToken; | |
import org.antlr.runtime.DFA; | |
import org.antlr.runtime.EarlyExitException; | |
import org.antlr.runtime.FailedPredicateException; | |
import org.antlr.runtime.IntStream; | |
import org.antlr.runtime.MismatchedSetException; | |
import org.antlr.runtime.NoViableAltException; | |
import org.antlr.runtime.Parser; | |
import org.antlr.runtime.RecognitionException; | |
import org.antlr.runtime.RecognizerSharedState; | |
import org.antlr.runtime.Token; | |
import org.antlr.runtime.TokenStream; | |
import org.eclipse.dltk.ast.ASTNode; | |
import org.eclipse.dltk.ast.DLTKToken; | |
import org.eclipse.dltk.ast.declarations.Declaration; | |
import org.eclipse.dltk.ast.declarations.ModuleDeclaration; | |
import org.eclipse.dltk.ast.expressions.BooleanLiteral; | |
import org.eclipse.dltk.ast.expressions.Expression; | |
import org.eclipse.dltk.ast.references.VariableReference; | |
import org.eclipse.dltk.ast.statements.Statement; | |
import org.apache.commons.lang3.StringUtils; | |
import org.apache.uima.ruta.descriptor.RutaDescriptorInformation; | |
import org.apache.uima.ruta.ide.core.extensions.RutaExternalFactory; | |
import org.apache.uima.ruta.ide.parser.ast.ActionFactory; | |
import org.apache.uima.ruta.ide.parser.ast.ComponentDeclaration; | |
import org.apache.uima.ruta.ide.parser.ast.ComponentReference; | |
import org.apache.uima.ruta.ide.parser.ast.ComposedRuleElement; | |
import org.apache.uima.ruta.ide.parser.ast.ConditionFactory; | |
import org.apache.uima.ruta.ide.parser.ast.ExpressionFactory; | |
import org.apache.uima.ruta.ide.parser.ast.ScriptFactory; | |
import org.apache.uima.ruta.ide.parser.ast.StatementFactory; | |
import org.apache.uima.ruta.ide.parser.ast.RutaTypeConstants; | |
import org.apache.uima.ruta.ide.parser.ast.RutaBlock; | |
import org.apache.uima.ruta.ide.parser.ast.RutaExpression; | |
import org.apache.uima.ruta.ide.parser.ast.RutaRule; | |
import org.apache.uima.ruta.ide.parser.ast.RutaRuleElement; | |
import org.apache.uima.ruta.ide.parser.ast.RutaScriptBlock; | |
import org.apache.uima.ruta.ide.parser.ast.RutaAction; | |
import org.apache.uima.ruta.ide.parser.ast.RutaCondition; | |
import org.apache.uima.ruta.ide.parser.ast.RutaFeatureDeclaration; | |
import org.apache.uima.ruta.ide.parser.ast.RutaPackageDeclaration; | |
} | |
@parser::members { | |
public DLTKRutaErrorReporter reporter; | |
public ModuleDeclaration md; | |
private List<String> vars = new ArrayList<String>(); | |
private Map<String, String> varTypeMap = new HashMap<String, String>(); | |
private Map<String, String> lists = new HashMap<String, String>(); | |
private Map<String, String> tables = new HashMap<String, String>(); | |
private Collection<String> knownExternalBlocks = new ArrayList(); | |
public int length; | |
public DLTKTokenConverter converter; | |
public RutaDescriptorInformation descriptor; | |
private int level = 0; | |
private RutaExternalFactory external = new RutaExternalFactory(); | |
private String module; | |
private String packageString; | |
private ScriptFactory scriptFactory = new ScriptFactory(); | |
public void setKnownExternalBlocks(Collection<String> knownExternalBlocks) { | |
this.knownExternalBlocks = knownExternalBlocks; | |
} | |
private boolean isBlockExtension(String name) { | |
return knownExternalBlocks.contains(name); | |
} | |
public List<String> getVariables() { | |
return vars; | |
} | |
public Map<String, String> getVariableTypes() { | |
return varTypeMap; | |
} | |
DLTKToken toDLTK(Token token) { | |
return converter.convert(token); | |
} | |
public void emitErrorMessage(String msg) { | |
reporter.reportMessage(msg); | |
} | |
public void reportError(RecognitionException e) { | |
if( reporter != null ) { | |
reporter.reportError(e); | |
} | |
} | |
public void addType(RutaBlock parent, String type, VariableReference parentTypeExpr) { | |
String parentType = "uima.tcas.Annotation"; | |
if(parentTypeExpr != null) { | |
parentType = parentTypeExpr.getName(); | |
} | |
vars.add(type); | |
String descriptionString = null; | |
if(packageString == null) { | |
descriptionString = "Type defined in " + module; | |
} else { | |
descriptionString = "Type defined in " + packageString + "." + module; | |
} | |
descriptor.addType(parent.getNamespace()+"."+type.trim(), descriptionString, parentType); | |
} | |
public void addPredefinedType(String type) { | |
vars.add(type); | |
varTypeMap.put(type, "TYPE"); | |
} | |
public void addType(RutaBlock parent, String name, VariableReference parentTypeExpr, List featuresTypes, | |
List<Token> featuresNames) { | |
String parentType = "uima.tcas.Annotation"; | |
if(parentTypeExpr != null) { | |
parentType = parentTypeExpr.getName(); | |
} | |
name = parent.getNamespace() + "." + name.trim(); | |
String descriptionString = null; | |
if(packageString == null) { | |
descriptionString = "Type defined in " + module; | |
} else { | |
descriptionString = "Type defined in " + packageString + "." + module; | |
} | |
descriptor.addType(name, descriptionString, parentType); | |
for (int i = 0; i < featuresTypes.size(); i++) { | |
Object object = featuresTypes.get(i); | |
String ftype = ""; | |
if (object instanceof ASTNode) { | |
ftype = ((ASTNode) object).toString(); | |
} else if (object instanceof Token) { | |
ftype = ((Token) object).getText(); | |
} | |
String fname = featuresNames.get(i).getText(); | |
descriptor.addFeature(name, fname, fname, ftype); | |
} | |
} | |
public void addWordList(RutaBlock parent, String name, String list) { | |
lists.put(name, list); | |
} | |
public void addCSVTable(RutaBlock parent, String name, String table) { | |
tables.put(name, table); | |
} | |
public boolean isType(RutaBlock parent, String type) { | |
return vars.contains(type); | |
} | |
public void addVariable(String var, String type, IntStream input) throws NoViableAltException { | |
if(!vars.contains(var)) { | |
vars.add(var); | |
varTypeMap.put(var, type); | |
} | |
} | |
public void addVariable(String var, String type) { | |
if(!vars.contains(var)) { | |
vars.add(var); | |
varTypeMap.put(var, type); | |
} | |
} | |
public boolean isVariable(String var) { | |
return vars.contains(var)|| isTemporaryVariable(var); | |
} | |
public boolean isVariableOfType(String var, String type) { | |
return isTemporaryVariable(var, type) || (vars.contains(var) && type.equals(varTypeMap.get(var))); | |
} | |
public void checkVariable(String var, IntStream input) throws NoViableAltException { | |
if(!vars.contains(var)) { | |
throw new NoViableAltException("not declared \"" + var + "\"", 3, 0, input); | |
} | |
} | |
public void addImportTypeSystem(ComponentDeclaration ts) { | |
if(ts != null){ | |
descriptor.addTypeSystem(ts.getName()); | |
} | |
} | |
public void addImportScript(ComponentDeclaration module) { | |
descriptor.addScript(module.getName()); | |
} | |
public void addImportEngine(ComponentDeclaration module) { | |
descriptor.addEngine(module.getName()); | |
} | |
public void addImportUimafitEngine(ComponentDeclaration module) { | |
descriptor.addUimafitEngine(module.getName()); | |
} | |
protected static final int[] getBounds(Token t) { | |
if (t instanceof CommonToken) { | |
CommonToken ct = (CommonToken) t; | |
int[] bounds = {ct.getStartIndex(), ct.getStopIndex()}; | |
return bounds; | |
} | |
return null; | |
} | |
private Map<String,String> temporaryVariables = new HashMap<>(); | |
private boolean isTemporaryVariable(String name, String type) { | |
return StringUtils.equals(temporaryVariables.get(name), type); | |
} | |
private boolean isTemporaryVariable(String name) { | |
return temporaryVariables.keySet().contains(name); | |
} | |
private void addTemporaryVariables(Map<Token, Token> def) { | |
Set<Entry<Token,Token>> entrySet = def.entrySet(); | |
for (Entry<Token, Token> entry : entrySet) { | |
temporaryVariables.put(entry.getKey().getText(), entry.getValue().getText()); | |
} | |
} | |
private void removeTemporaryVariables(Map<Token, Token> def) { | |
Set<Token> keySet = def.keySet(); | |
for (Token key : keySet) { | |
temporaryVariables.remove(key.getText()); | |
} | |
} | |
} | |
@rulecatch { | |
catch (RecognitionException exception1) { | |
if( reporter != null ) { | |
reporter.reportError(exception1); | |
} | |
recover(input,exception1); | |
} | |
catch (Throwable exception2) { | |
if( reporter != null ) { | |
reporter.reportThrowable(exception2); | |
} | |
} | |
} | |
file_input [String module] | |
@init { | |
RutaScriptBlock rootBlock = null; | |
List<Statement> stmts = new ArrayList<Statement>(); | |
} | |
: | |
p = packageDeclaration? | |
{ | |
String packageName = ""; | |
if(p != null) {packageName = p.getName();} | |
if(descriptor != null) { | |
descriptor.setPackageString(packageName); | |
} | |
rootBlock = scriptFactory.createScriptBlock(0,0,0,0,module, null, null, packageName); | |
stmts.add(p); | |
this.module = module; | |
if(p != null) { | |
this.packageString = p.getName(); | |
} | |
} | |
{$blockDeclaration.push(new blockDeclaration_scope());$blockDeclaration::env = rootBlock;} | |
gs = globalStatements | |
s = statements | |
{ | |
stmts.addAll(gs); | |
stmts.addAll(s); | |
for (Statement stmt : stmts){ | |
if (stmt != null) { | |
md.addStatement(stmt); | |
} | |
}; | |
} | |
EOF | |
; | |
packageDeclaration returns [RutaPackageDeclaration pack] | |
: pString = PackageString | |
{ | |
pack = StatementFactory.createPkgDeclaration(p, pString); | |
} | |
p = dottedId | |
{ | |
pack = StatementFactory.createPkgDeclaration(p, pString); | |
} | |
SEMI | |
{ | |
pack = StatementFactory.createPkgDeclaration(p, pString); | |
} | |
; | |
statements returns [List<Statement> stmts = new ArrayList<Statement>()] | |
: | |
(morestmts = statement {if(morestmts != null) {stmts.addAll(morestmts);}})* | |
; | |
globalStatements returns [List<Statement> stmts = new ArrayList<Statement>()] | |
: | |
(morestmts = globalStatement {if(morestmts != null) {stmts.addAll(morestmts);}})* | |
; | |
globalStatement returns [List<Statement> stmts = new ArrayList<Statement>()] | |
: | |
stmtImport = importStatement {stmts.add(stmtImport);} | |
; | |
statement returns [List<Statement> stmts = new ArrayList<Statement>()] | |
: | |
( stmts1 = declaration {stmts.addAll(stmts1);} | |
| stmtVariable = variableDeclaration {stmts.addAll(stmtVariable);} | |
| stmtCM = macroConditionDeclaration {stmts.add(stmtCM);} | |
| stmtAM = macroActionDeclaration {stmts.add(stmtAM);} | |
| stmt3 = blockDeclaration {stmts.add(stmt3);} | |
| (externalBlock)=> stmt4 = externalBlock {stmts.add(stmt4);} | |
| stmt2 = simpleStatement {stmts.add(stmt2);} | |
) | |
; | |
macroConditionDeclaration returns [Statement stmt = null] | |
@init { | |
Map<Token,Token> def = new LinkedHashMap<>(); | |
} | |
: | |
kind = CONDITION name = Identifier | |
LPAREN | |
(VAR? argType = varTypeToken argName = Identifier {def.put(argName,argType);} | |
(COMMA VAR? argType = varTypeToken argName = Identifier {def.put(argName,argType);})*)? | |
{addTemporaryVariables(def);} | |
RPAREN ASSIGN_EQUAL cs = conditions SEMI | |
{removeTemporaryVariables(def);} | |
{stmt = StatementFactory.createMacroStatement(kind, name, def, cs);} | |
; | |
macroActionDeclaration returns [Statement stmt = null] | |
@init { | |
Map<Token,Token> def = new LinkedHashMap<>(); | |
} | |
: | |
kind = ACTION name = Identifier | |
LPAREN | |
(VAR? argType = varTypeToken argName = Identifier {def.put(argName,argType);} | |
(COMMA VAR? argType = varTypeToken argName = Identifier {def.put(argName,argType);})*)? | |
{addTemporaryVariables(def);} | |
RPAREN ASSIGN_EQUAL as = actions SEMI | |
{removeTemporaryVariables(def);} | |
{stmt = StatementFactory.createMacroStatement(kind, name, def, as);} | |
; | |
varTypeToken returns [Token token = null ] | |
: | |
t = (ANNOTATION | ANNOTATIONLIST | StringString | STRINGLIST | |
| BooleanString | BOOLEANLIST | IntString | INTLIST | |
| DoubleString | DOUBLELIST | FloatString | FLOATLIST | |
| TypeString | TYPELIST) {token = t;} | |
; | |
importStatement returns [Statement stmt = null] | |
: | |
im = TypeSystemString | |
{stmt = StatementFactory.createImportTypeSystem(StatementFactory.createEmptyComponentDeclaration(im),im);} | |
name = dottedComponentDeclaration | |
{if(name != null) {stmt = StatementFactory.createImportTypeSystem(name,im);addImportTypeSystem(name);}} | |
SEMI | |
| im = ScriptString | |
{stmt = StatementFactory.createImportScript(StatementFactory.createEmptyComponentDeclaration(im),im);} | |
name = dottedComponentDeclaration | |
{if(name != null) {stmt = StatementFactory.createImportScript(name,im);addImportScript(name);}} | |
SEMI | |
| im = EngineString | |
{stmt = StatementFactory.createImportEngine(StatementFactory.createEmptyComponentDeclaration(im),im);} | |
name = dottedComponentDeclaration | |
{if(name != null) {stmt = StatementFactory.createImportEngine(name,im);addImportEngine(name);}} | |
SEMI | |
| im = UimafitString | |
{stmt = StatementFactory.createImportEngine(StatementFactory.createEmptyComponentDeclaration(im),im);} | |
name = dottedComponentDeclaration | |
(LPAREN dottedIdentifier2 (COMMA dottedIdentifier2)+ RPAREN)? | |
{if(name != null) {stmt = StatementFactory.createImportEngine(name,im);addImportUimafitEngine(name);}} | |
SEMI | |
| im = ImportString type = dottedId (FromString ts = dottedComponentDeclaration)? (AsString alias = Identifier)? SEMI | |
{stmt = StatementFactory.createImportType(im,type,ts,alias);addImportTypeSystem(ts);} | |
| im = ImportString STAR FromString ts = dottedComponentDeclaration SEMI | |
{stmt = StatementFactory.createImportTypeSystem(ts,im);addImportTypeSystem(ts);} | |
| im = ImportString PackageString pkg = dottedId (FromString ts = dottedComponentDeclaration)? (AsString alias = Identifier)? SEMI | |
{stmt = StatementFactory.createImportPackage(im,pkg,ts,alias);addImportTypeSystem(ts);} | |
| im = ImportString PackageString STAR FromString ts = dottedComponentDeclaration (AsString alias = Identifier)? SEMI | |
{stmt = StatementFactory.createImportAllPackagew(im,ts,alias);addImportTypeSystem(ts);} | |
; | |
variableDeclaration returns [List<Statement> stmts = new ArrayList<Statement>()] | |
@init { | |
List decls = new ArrayList(); | |
} | |
: | |
type = IntString id = Identifier {addVariable(id.getText(), type.getText()); decls.add(StatementFactory.createIntVariable(id, type));} | |
(COMMA id= Identifier {addVariable(id.getText(), type.getText()); decls.add(StatementFactory.createIntVariable(id, type));} | |
)* (ASSIGN_EQUAL init = numberExpression)? SEMI | |
{ | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, init)); | |
} | |
| | |
type = DoubleString id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createDoubleVariable(id, type));} | |
(COMMA id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createDoubleVariable(id, type));} | |
)* (ASSIGN_EQUAL init = numberExpression)? SEMI | |
{ | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, init)); | |
} | |
| | |
type = FloatString id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createFloatVariable(id, type));} | |
(COMMA id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createFloatVariable(id, type));} | |
)* (ASSIGN_EQUAL init = numberExpression)? SEMI | |
{ | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, init)); | |
} | |
| | |
type = StringString id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createStringVariable(id, type));} | |
(COMMA id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createStringVariable(id, type));} | |
)* (ASSIGN_EQUAL init = stringExpression)? SEMI | |
{ | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, init)); | |
} | |
| | |
type = BooleanString id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createBooleanVariable(id, type));} | |
(COMMA id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createBooleanVariable(id, type));} | |
)* (ASSIGN_EQUAL init = booleanExpression)? SEMI | |
{ | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, init)); | |
} | |
| | |
type = TypeString id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createTypeVariable(id,type));} | |
(COMMA id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createTypeVariable(id,type));} | |
)* (ASSIGN_EQUAL init = typeExpression)? SEMI | |
{ | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, init)); | |
} | |
| | |
type = WORDLIST id = Identifier (ASSIGN_EQUAL wl = wordListOrStringExpression )? SEMI | |
{ | |
addVariable(id.getText(), type.getText()); | |
decls.add(StatementFactory.createListVariable(id,type,wl)); | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, wl)); | |
} | |
| | |
type = WORDTABLE id = Identifier (ASSIGN_EQUAL wt = wordTableOrStringExpression)? SEMI | |
{ | |
addVariable(id.getText(), type.getText()); | |
decls.add(StatementFactory.createTableVariable(id,type,wt)); | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, wt)); | |
} | |
| | |
type = BOOLEANLIST id = Identifier (ASSIGN_EQUAL list = booleanListExpression)? SEMI | |
{ | |
addVariable(id.getText(), type.getText()); | |
decls.add(StatementFactory.createVarListVariable(id,type,list, RutaTypeConstants.RUTA_TYPE_BL)); | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, list)); | |
} | |
| | |
type = INTLIST id = Identifier (ASSIGN_EQUAL list = numberListExpression)? SEMI | |
{ | |
addVariable(id.getText(), type.getText()); | |
decls.add(StatementFactory.createVarListVariable(id,type,list, RutaTypeConstants.RUTA_TYPE_NL)); | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, list)); | |
} | |
| | |
type = DOUBLELIST id = Identifier (ASSIGN_EQUAL list = numberListExpression)? SEMI | |
{ | |
addVariable(id.getText(), type.getText()); | |
decls.add(StatementFactory.createVarListVariable(id,type,list, RutaTypeConstants.RUTA_TYPE_NL)); | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, list)); | |
} | |
| | |
type = FLOATLIST id = Identifier (ASSIGN_EQUAL list = numberListExpression)? SEMI | |
{ | |
addVariable(id.getText(), type.getText()); | |
decls.add(StatementFactory.createVarListVariable(id,type,list, RutaTypeConstants.RUTA_TYPE_NL)); | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, list)); | |
} | |
| | |
type = STRINGLIST id = Identifier (ASSIGN_EQUAL list = stringListExpression)? SEMI | |
{ | |
addVariable(id.getText(), type.getText()); | |
decls.add(StatementFactory.createVarListVariable(id,type,list, RutaTypeConstants.RUTA_TYPE_SL)); | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, list)); | |
} | |
| | |
type = TYPELIST id = Identifier (ASSIGN_EQUAL list = typeListExpression)? SEMI | |
{ | |
addVariable(id.getText(), type.getText()); | |
decls.add(StatementFactory.createVarListVariable(id,type,list, RutaTypeConstants.RUTA_TYPE_TL)); | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, list)); | |
} | |
| | |
type = ANNOTATION id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createTypeVariable(id,type));} | |
(COMMA id = Identifier {addVariable(id.getText(), type.getText());decls.add(StatementFactory.createTypeVariable(id,type));} | |
)* (ASSIGN_EQUAL init = annotationExpression)? SEMI | |
{ | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, init)); | |
} | |
| | |
type = ANNOTATIONLIST id = Identifier (ASSIGN_EQUAL al = annotationExpression)? SEMI | |
{ | |
addVariable(id.getText(), type.getText()); | |
decls.add(StatementFactory.createVarListVariable(id,type,list, RutaTypeConstants.RUTA_TYPE_UAL)); | |
stmts.add(StatementFactory.createDeclarationsStatement(type, decls, list)); | |
} | |
//| | |
//stmt = conditionDeclaration {stmts.add(stmt);} | |
//| | |
//stmt = actionDeclaration {stmts.add(stmt);} | |
; | |
//conditionDeclaration returns [Statement stmt = null] | |
// : | |
// declareToken = CONDITION id = Identifier {addVariable(id.getText(), declareToken.getText());} | |
// ASSIGN_EQUAL | |
// LPAREN cons = conditions RPAREN SEMI | |
// {stmt = StatementFactory.createComposedVariableConditionDeclaration(id, cons);} | |
// ; | |
//TODO added rule | |
//actionDeclaration returns [Statement stmt = null] | |
// : | |
// declareToken = ACTION id = Identifier {addVariable(id.getText(), declareToken.getText());} | |
// ASSIGN_EQUAL | |
// LPAREN a = actions RPAREN SEMI | |
// {stmt = StatementFactory.createComposedVariableActionDeclaration(id, a);} | |
// ; | |
declaration returns [List<Statement> stmts = new ArrayList<Statement>()] | |
@init { | |
Statement stmt = null; | |
List<Object> featureTypes = new ArrayList<Object>(); | |
List<Token> featureNames = new ArrayList<Token>(); | |
List<Declaration> declarations = new ArrayList<Declaration>(); | |
} | |
: | |
declareToken=DECLARE lazyParent = annotationType? | |
id = Identifier {addVariable(id.getText(), declareToken.getText());} | |
( | |
{addType($blockDeclaration::env, id.getText(), lazyParent); | |
declarations.add(StatementFactory.createAnnotationType(id,declareToken));} | |
( | |
COMMA | |
id = Identifier {addVariable(id.getText(), declareToken.getText());} | |
{addType($blockDeclaration::env, id.getText(), lazyParent); | |
declarations.add(StatementFactory.createAnnotationType(id,declareToken));} | |
)* end = SEMI | |
{ | |
stmt = StatementFactory.createDeclareDeclarationsStatement(declareToken, declarations, lazyParent); | |
stmts.add(stmt); | |
} | |
| | |
(LPAREN | |
( | |
obj1 = annotationType{featureTypes.add(obj1);} | |
| obj2 = StringString{featureTypes.add(obj2);} | |
| obj3 = DoubleString{featureTypes.add(obj3);} | |
| obj6 = FloatString{featureTypes.add(obj6);} | |
| obj4 = IntString{featureTypes.add(obj4);} | |
| obj5 = BooleanString{featureTypes.add(obj5);} | |
//| obj6 = fsType{featureTypes.add(obj6.getText());} | |
) | |
fname = Identifier{featureNames.add(fname);} | |
( | |
COMMA | |
( | |
obj1 = annotationType{featureTypes.add(obj1);} | |
| obj2 = StringString{featureTypes.add(obj2);} | |
| obj3 = DoubleString{featureTypes.add(obj3);} | |
| obj6 = FloatString{featureTypes.add(obj6);} | |
| obj4 = IntString{featureTypes.add(obj4);} | |
| obj5 = BooleanString{featureTypes.add(obj5);} | |
//| obj6 = fsType{featureTypes.add(obj5.getText());} | |
) | |
fname = Identifier{featureNames.add(fname);})* | |
RPAREN) SEMI // TODO removed question mark | |
{ | |
List<RutaFeatureDeclaration> features = new ArrayList<RutaFeatureDeclaration>(); | |
int i = 0; | |
for (Object eachTO : featureTypes) { | |
Token eachName = featureNames.get(i); | |
features.add(StatementFactory.createFeatureDeclaration(eachTO, eachName)); | |
i++; | |
} | |
addType($blockDeclaration::env, id.getText(), lazyParent, featureTypes, featureNames); | |
declarations.add( StatementFactory.createAnnotationType(id,declareToken, lazyParent, features)); | |
stmt = StatementFactory.createDeclareDeclarationsStatement(declareToken, declarations, lazyParent, features); | |
stmts.add(stmt); | |
} | |
) | |
; | |
blockDeclaration returns [RutaBlock block = null] | |
options{ | |
backtrack = true; | |
} | |
scope { | |
RutaBlock env; | |
} | |
@init{ | |
RutaRule rule = null; | |
level++; | |
} | |
@after { | |
level--; | |
} | |
: | |
(declareToken = (BlockString | ForEachString)) | |
LPAREN | |
id = Identifier {addVariable(id.getText(), declareToken.getText());} | |
{ | |
block = scriptFactory.createScriptBlock(id, declareToken, $blockDeclaration[level - 1]::env); | |
$blockDeclaration::env = block; | |
} | |
(COMMA booleanExpression)? | |
RPAREN | |
re1 = ruleElementWithCA | |
{ | |
rule = scriptFactory.createRule(re1); | |
scriptFactory.finalizeBlock(block, rc, rule, body);} | |
LCURLY body = statements rc = RCURLY | |
{scriptFactory.finalizeBlock(block, rc, rule, body);} | |
; | |
externalBlock returns [RutaBlock block = null] | |
options{ | |
backtrack = true; | |
} | |
@init{ | |
RutaRule rule = null; | |
} | |
@after { | |
} | |
: | |
{isBlockExtension(input.LT(1).getText())}? | |
(type = Identifier) | |
{block = scriptFactory.createExternalBlock(type, $blockDeclaration[level]::env); | |
$blockDeclaration::env = block;} | |
(LPAREN | |
args = varArgumentList {block.setArguments(args);} | |
RPAREN)? | |
re1 = ruleElementWithCA | |
{ | |
rule = scriptFactory.createRule(re1); | |
scriptFactory.finalizeBlock(block, rc, rule, body);} | |
LCURLY body = statements rc = RCURLY | |
{scriptFactory.finalizeBlock(block, rc, rule, body);} | |
; | |
ruleElementWithCA returns [RutaRuleElement re = null] | |
: | |
idRef=typeMatchExpression quantifier = quantifierPart? {re = scriptFactory.createRuleElement(idRef,quantifier,c,a, end);} | |
LCURLY c = conditions? (THEN a = actions)? end = RCURLY | |
{re = scriptFactory.createRuleElement(idRef,quantifier,c,a, end);} | |
; | |
ruleElementWithoutCA returns [RutaRuleElement re = null] | |
: | |
idRef=typeMatchExpression quantifier = quantifierPart? | |
{re = scriptFactory.createRuleElement(idRef,quantifier,null,null, null);} | |
; | |
simpleStatement returns [RutaRule stmt = null] | |
options { | |
backtrack = true; | |
} | |
: | |
(regexpRule)=> rer = regexpRule {stmt = rer;} | |
| | |
as = rawActions s = SEMI | |
{stmt = scriptFactory.createImplicitRule(as, s);} | |
| | |
elements=ruleElementsRoot | |
{stmt = scriptFactory.createRule(elements, null, false);} | |
s = SEMI | |
{stmt = scriptFactory.createRule(elements, s);} | |
; | |
regexpRule returns [RutaRule stmt = null] | |
@init{ | |
List<Expression> exprs = new ArrayList<Expression>(); | |
Map<Expression, Map<Expression, Expression>> fa = new HashMap<Expression, Map<Expression, Expression>>(); | |
Map<Expression, Expression> fmap = null; | |
} | |
: | |
regexp = stringExpression {exprs.add(regexp);} {stmt = scriptFactory.createRegExpRule(exprs, fa, s);} THEN | |
( | |
(numberExpression ASSIGN_EQUAL)=> | |
indexCG = numberExpression {exprs.add(indexCG);}{stmt = scriptFactory.createRegExpRule(exprs, fa, s);} ASSIGN_EQUAL indexTE = typeExpression {exprs.add(indexTE);} | |
(LPAREN {fmap = new HashMap<Expression, Expression>();} fk = stringExpression ASSIGN_EQUAL arg = argument {fmap.put(fk, arg);} | |
(COMMA fk = stringExpression ASSIGN_EQUAL arg = argument {fmap.put(fk, arg);} )* RPAREN {fa.put(indexTE, fmap);})? | |
| | |
te = typeExpression {exprs.add(te);} {stmt = scriptFactory.createRegExpRule(exprs, fa, s);} | |
(LPAREN {fmap = new HashMap<Expression, Expression>();} fk = stringExpression ASSIGN_EQUAL arg = argument {fmap.put(fk, arg);} | |
(COMMA fk = stringExpression ASSIGN_EQUAL arg = argument {fmap.put(fk, arg);} )* RPAREN {fa.put(te, fmap);})? | |
) | |
( | |
COMMA | |
( | |
(numberExpression ASSIGN_EQUAL)=> | |
indexCG = numberExpression {exprs.add(indexCG);}{stmt = scriptFactory.createRegExpRule(exprs, fa, s);} ASSIGN_EQUAL indexTE = typeExpression {exprs.add(indexTE);} | |
(LPAREN {fmap = new HashMap<Expression, Expression>();} fk = stringExpression ASSIGN_EQUAL arg = argument {fmap.put(fk, arg);} | |
(COMMA fk = stringExpression ASSIGN_EQUAL arg = argument {fmap.put(fk, arg);} )* RPAREN {fa.put(indexTE, fmap);})? | |
| | |
te = typeExpression {exprs.add(te);}{stmt = scriptFactory.createRegExpRule(exprs, fa, s);} | |
(LPAREN {fmap = new HashMap<Expression, Expression>();} fk = stringExpression ASSIGN_EQUAL arg = argument {fmap.put(fk, arg);} | |
(COMMA fk = stringExpression ASSIGN_EQUAL arg = argument {fmap.put(fk, arg);} )* RPAREN {fa.put(te, fmap);})? | |
) | |
)* | |
s = SEMI | |
{stmt = scriptFactory.createRegExpRule(exprs, fa, s, true);} | |
; | |
ruleElementsRoot returns [List<Expression> elements = new ArrayList<Expression>()] | |
: | |
re = ruleElement {if(re!=null) elements.add(re);} (p = PERCENT? re = ruleElement {if(re!=null) {elements.add(re);re.setAfterConcat(p);}})* | |
; | |
ruleElements returns [List<Expression> elements = new ArrayList<Expression>()] | |
: | |
re = ruleElement {if(re!=null) elements.add(re);} (re = ruleElement {if(re!=null) elements.add(re);})* | |
; | |
blockRuleElement returns [RutaRuleElement rElement = null] //[List<RutaRuleElement> elements = new ArrayList<RutaRuleElement>()] | |
: | |
re = ruleElementType {rElement = re;} | |
; | |
ruleElement returns [RutaRuleElement re = null] | |
@init{ | |
List<RutaRule> innerRules = new ArrayList<RutaRule>(); | |
String label = null; | |
} | |
: | |
(l = Identifier {label = l.getText();} COLON)? | |
STARTANCHOR? | |
( | |
re1 = ruleElementType {re = re1;} | |
| re2 = ruleElementLiteral {re = re2;} | |
| re3 = ruleElementComposed {re = re3;} | |
| re4 = ruleElementWildCard {re = re4;} | |
) | |
{re.setLabel(label);} | |
(t = THEN2 LCURLY (rule = simpleStatement {innerRules.add(rule);})+ | |
RCURLY {re.setInlinedRules(innerRules);re.setInlineMode(t == null ? null : t.getText());})? | |
(t = THEN LCURLY (rule = simpleStatement {innerRules.add(rule);})+ | |
RCURLY {re.setInlinedRules(innerRules);re.setInlineMode(t == null ? null : t.getText());})? | |
; | |
ruleElementWildCard returns [RutaRuleElement re = null] | |
@init{ | |
List<RutaCondition> dummyConds = new ArrayList<RutaCondition>(); | |
} | |
: | |
w = WILDCARD | |
(LCURLY | |
{ | |
dummyConds.add(ConditionFactory.createEmptyCondition(input.LT(1))); | |
} | |
c = conditions? | |
{ | |
if(c==null) { | |
c = dummyConds; | |
} | |
} | |
(THEN a = actions)? end = RCURLY)? | |
{ | |
re = scriptFactory.createRuleElement(w,c,a,end);} | |
; | |
ruleElementComposed returns [ComposedRuleElement re = null] | |
@init{ | |
Boolean disjunctive = null; | |
List<Expression> res = new ArrayList<Expression>(); | |
} | |
: | |
ft = LPAREN | |
( | |
(ruleElement VBAR)=> re1 = ruleElement {res.add(re1);} (VBAR re1 = ruleElement {disjunctive = true; res.add(re1);})+ | |
| | |
(ruleElement AMPER)=> re2 = ruleElement {res.add(re2);} (AMPER re2 = ruleElement {disjunctive = false; res.add(re2);})+ | |
| | |
res2 = ruleElements {res = res2;} | |
) | |
lt1 = RPAREN q = quantifierPart? (LCURLY c = conditions? (THEN a = actions)? lt2 = RCURLY)? | |
{re = scriptFactory.createComposedRuleElement(res, q, c, a, disjunctive, $blockDeclaration::env, ft, lt1, lt2);} | |
; | |
ruleElementType returns [RutaRuleElement re = null] | |
@init{ | |
List<RutaCondition> dummyConds = new ArrayList<RutaCondition>(); | |
} | |
: | |
(typeMatchExpression)=>idRef=typeMatchExpression quantifier = quantifierPart? | |
(LCURLY | |
{ | |
dummyConds.add(ConditionFactory.createEmptyCondition(input.LT(1))); | |
} | |
c = conditions? | |
{ | |
if(c==null) { | |
c = dummyConds; | |
} | |
} | |
(THEN a = actions)? end = RCURLY)? | |
{ | |
// TODO handle quantifierPart. | |
re = scriptFactory.createRuleElement(idRef,quantifier,c,a,end);} | |
//start, end, "", cp, ap, "", $blockDeclaration::env);} | |
; | |
ruleElementLiteral returns [RutaRuleElement re = null] | |
: | |
(simpleStringExpression)=>idRef=simpleStringExpression quantifier = quantifierPart? | |
(LCURLY | |
c = conditions? | |
(THEN a = actions)? | |
end = RCURLY)? | |
{ | |
// TODO handle quantifierPart. | |
re = scriptFactory.createRuleElement(idRef,quantifier,c,a,end);} | |
//start, end, "", cp, ap, "", $blockDeclaration::env);} | |
; | |
conditions returns [List<RutaCondition> conds = new ArrayList<RutaCondition>()] | |
@init { | |
conds.add(ConditionFactory.createEmptyCondition(input.LT(1))); | |
} | |
: | |
c = condition {conds.remove(0);conds.add(c);} (COMMA c = condition {conds.add(c);} )* | |
; | |
actions returns [List<RutaAction> actions = new ArrayList<RutaAction>()] | |
: | |
a = action {actions.add(a);} (COMMA a = action {actions.add(a);} )* | |
; | |
rawActions returns [List<RutaAction> actions = new ArrayList<RutaAction>()] | |
: | |
a = rawAction {actions.add(a);} (COMMA a = rawAction {actions.add(a);} )* | |
; | |
listExpression returns [Expression expr = null] | |
: | |
(booleanListExpression)=> e = booleanListExpression {expr = e;} | |
| (intListExpression)=> e = intListExpression {expr = e;} | |
| (doubleListExpression)=> e = doubleListExpression {expr = e;} | |
| (floatListExpression)=> e = floatListExpression {expr = e;} | |
| (stringListExpression)=> e = stringListExpression {expr = e;} | |
| (typeListExpression)=> e = typeListExpression {expr = e;} | |
| (annotationListExpression)=> e = annotationListExpression {expr = e;} | |
| (untypedListExpression)=> utl = untypedListExpression {expr = utl;} | |
| (featureExpression)=>fe = featureExpression {expr = fe;} | |
; | |
untypedListExpression returns [Expression expr = null] | |
@init{ | |
List<Expression> list = new ArrayList<Expression>(); | |
} : | |
LCURLY (e = argument {list.add(e);} (COMMA e = argument {list.add(e);})*)? RCURLY | |
{expr = ExpressionFactory.createListExpression(list, RutaTypeConstants.RUTA_TYPE_UTL);} | |
; | |
booleanListExpression returns [Expression expr = null] | |
: | |
e = simpleBooleanListExpression {expr = e;} | |
; | |
simpleBooleanListExpression returns [Expression expr = null] | |
@init{ | |
List<Expression> list = new ArrayList<Expression>(); | |
} : | |
LCURLY (e = simpleBooleanExpression {list.add(e);} (COMMA e = simpleBooleanExpression {list.add(e);})*)? RCURLY | |
{expr = ExpressionFactory.createListExpression(list, RutaTypeConstants.RUTA_TYPE_BL);} | |
| | |
{isVariableOfType(input.LT(1).getText(), "BOOLEANLIST")}? | |
var = Identifier | |
{expr = ExpressionFactory.createListExpression(var, RutaTypeConstants.RUTA_TYPE_BL);} | |
; | |
intListExpression returns [Expression expr = null] | |
: | |
e = simpleIntListExpression {expr = e;} | |
; | |
simpleIntListExpression returns [Expression expr = null] | |
@init{ | |
List<Expression> list = new ArrayList<Expression>(); | |
} : | |
LCURLY (e = simpleNumberExpression {list.add(e);} (COMMA e = simpleNumberExpression {list.add(e);})*)? RCURLY | |
{expr = ExpressionFactory.createListExpression(list, RutaTypeConstants.RUTA_TYPE_NL);} | |
| | |
{isVariableOfType(input.LT(1).getText(), "INTLIST")}? | |
var = Identifier | |
{expr = ExpressionFactory.createListExpression(var, RutaTypeConstants.RUTA_TYPE_NL);} | |
; | |
numberListExpression returns [Expression expr = null] | |
: | |
(e1 = doubleListExpression)=> e1 = doubleListExpression {expr = e1;} | |
| | |
(e1 = floatListExpression)=> e1 = floatListExpression {expr = e1;} | |
| | |
e2 = intListExpression {expr = e2;} | |
; | |
doubleListExpression returns [Expression expr = null] | |
: | |
e = simpleDoubleListExpression {expr = e;} | |
; | |
simpleDoubleListExpression returns [Expression expr = null] | |
@init{ | |
List<Expression> list = new ArrayList<Expression>(); | |
} : | |
LCURLY (e = simpleNumberExpression {list.add(e);} (COMMA e = simpleNumberExpression {list.add(e);})*)? RCURLY | |
{expr = ExpressionFactory.createListExpression(list, RutaTypeConstants.RUTA_TYPE_NL);} | |
| | |
{isVariableOfType(input.LT(1).getText(), "DOUBLELIST")}? | |
var = Identifier | |
{expr = ExpressionFactory.createListExpression(var, RutaTypeConstants.RUTA_TYPE_NL);} | |
; | |
floatListExpression returns [Expression expr = null] | |
: | |
e = simpleFloatListExpression {expr = e;} | |
; | |
simpleFloatListExpression returns [Expression expr = null] | |
@init{ | |
List<Expression> list = new ArrayList<Expression>(); | |
} : | |
LCURLY (e = simpleNumberExpression {list.add(e);} (COMMA e = simpleNumberExpression {list.add(e);})*)? RCURLY | |
{expr = ExpressionFactory.createListExpression(list, RutaTypeConstants.RUTA_TYPE_NL);} | |
| | |
{isVariableOfType(input.LT(1).getText(), "FLOATLIST")}? | |
var = Identifier | |
{expr = ExpressionFactory.createListExpression(var, RutaTypeConstants.RUTA_TYPE_NL);} | |
; | |
stringListExpression returns [Expression expr = null] | |
: | |
e = simpleStringListExpression {expr = e;} | |
; | |
simpleStringListExpression returns [Expression expr = null] | |
@init{ | |
List<Expression> list = new ArrayList<Expression>(); | |
} : | |
LCURLY (e = simpleStringExpression {list.add(e);} (COMMA e = simpleStringExpression {list.add(e);})*)? RCURLY | |
{expr = ExpressionFactory.createListExpression(list, RutaTypeConstants.RUTA_TYPE_SL);} | |
| | |
{isVariableOfType(input.LT(1).getText(), "STRINGLIST")}? | |
var = Identifier | |
{expr = ExpressionFactory.createListExpression(var, RutaTypeConstants.RUTA_TYPE_SL);} | |
; | |
typeListExpression returns [Expression expr = null] | |
: | |
e = simpleTypeListExpression {expr = e;} | |
; | |
simpleTypeListExpression returns [Expression expr = null] | |
@init{ | |
List<Expression> list = new ArrayList<Expression>(); | |
} : | |
LCURLY (e = simpleTypeExpression {list.add(e);} (COMMA e = simpleTypeExpression {list.add(e);})*)? RCURLY | |
{expr = ExpressionFactory.createListExpression(list, RutaTypeConstants.RUTA_TYPE_TL);} | |
| | |
{isVariableOfType(input.LT(1).getText(), "TYPELIST")}? | |
var = Identifier | |
{expr = ExpressionFactory.createListExpression(var, RutaTypeConstants.RUTA_TYPE_TL);} | |
; | |
typeMatchExpression returns [Expression expr = null] | |
options { | |
backtrack = true; | |
} | |
@init { | |
expr = ExpressionFactory.createEmptyTypeExpression(input.LT(1)); | |
} | |
: | |
( | |
(featureTypeExpression)=> ft = featureTypeExpression {expr = ft;} | |
| | |
(typeFunction)=> tf = typeFunction {expr = tf;} | |
| | |
st = simpleTypeExpression | |
{expr = ExpressionFactory.createTypeExpression(st); | |
} | |
) | |
; | |
typeExpression returns [Expression expr = null] | |
@init { | |
expr = ExpressionFactory.createEmptyTypeExpression(input.LT(1)); | |
} | |
: | |
(typeFunction)=> tf = typeFunction {expr = tf;} | |
| st = simpleTypeExpression | |
{expr = ExpressionFactory.createTypeExpression(st); | |
} | |
; | |
// not checked | |
typeFunction returns [Expression expr = null] | |
: | |
(e = externalTypeFunction)=> e = externalTypeFunction {expr = e;} | |
; | |
// not checked | |
externalTypeFunction returns [Expression expr = null] | |
: | |
id = Identifier | |
LPAREN | |
args = varArgumentList? | |
RPAREN | |
{ | |
expr = external.createExternalTypeFunction(id, args); | |
} | |
; | |
featureAssignmentExpression returns [Expression expr = null] | |
: | |
feature = dottedIdWithIndex comp = ASSIGN_EQUAL value = argument {expr = ExpressionFactory.createFeatureMatch(feature, comp, value);} | |
; | |
featureTypeExpression returns [Expression expr = null] | |
: | |
feature = dottedIdWithIndex (comp = LESS | comp = GREATER | comp = GREATEREQUAL | comp = LESSEQUAL |comp = EQUAL | comp = NOTEQUAL) value = argument {expr = ExpressionFactory.createFeatureMatch(feature, comp, value);} | |
; | |
featureExpression returns [Expression expr = null] | |
: | |
f = dottedIdWithIndex {expr = ExpressionFactory.createFeatureExpression(f);} | |
; | |
simpleTypeExpression returns [Expression type = null] | |
: | |
at = annotationType {type = at;} | |
; | |
variable returns [Expression var = null] | |
: | |
{vars.contains(input.LT(1).getText())}? v = Identifier {var=ExpressionFactory.createGenericVariableReference(v);} | |
; | |
variableAssignmentAction returns [RutaAction a = null] | |
: | |
var = variable op = ASSIGN_EQUAL arg = argument | |
{ | |
a = ActionFactory.createAction(var, arg); | |
} | |
; | |
listVariable returns [Expression var = null] | |
: | |
{isVariableOfType(input.LT(1).getText(), "BOOLEANLIST") | |
||isVariableOfType(input.LT(1).getText(), "INTLIST") | |
||isVariableOfType(input.LT(1).getText(), "FLOATLIST") | |
||isVariableOfType(input.LT(1).getText(), "DOUBLELIST") | |
||isVariableOfType(input.LT(1).getText(), "STRINGLIST") | |
||isVariableOfType(input.LT(1).getText(), "TYPELIST") | |
||isVariableOfType(input.LT(1).getText(), "ANNOTATIONLIST") | |
}? v = Identifier {var=ExpressionFactory.createGenericVariableReference(v);} | |
; | |
quantifierPart returns [List<Expression> exprs = new ArrayList<Expression>()] | |
options { | |
backtrack = true; | |
} | |
: | |
s = STAR q = QUESTION? {exprs.add(ExpressionFactory.createQuantifierLiteralExpression(s,q));} | |
| p = PLUS q = QUESTION? {exprs.add(ExpressionFactory.createQuantifierLiteralExpression(p,q));} | |
| q1 = QUESTION q = QUESTION? {exprs.add(ExpressionFactory.createQuantifierLiteralExpression(q1,q));} | |
| (b1 = LBRACK min = numberExpression COMMA max = numberExpression b2 = RBRACK q = QUESTION? | |
{if(min!=null) {exprs.add(min);} if(max!=null) {exprs.add(max);} | |
if(q!=null) {exprs.add(ExpressionFactory.createQuantifierLiteralExpression(q, null));}} | |
) | |
| b1 = LBRACK COMMA max = numberExpression b2 = RBRACK q = QUESTION? | |
{if(min!=null) {exprs.add(min);} if(max!=null) {exprs.add(max);} | |
if(q!=null) {exprs.add(ExpressionFactory.createQuantifierLiteralExpression(q, null));}} | |
| b1 = LBRACK min = numberExpression COMMA b2 = RBRACK q = QUESTION? | |
{if(min!=null) {exprs.add(min);} if(max!=null) {exprs.add(max);} | |
if(q!=null) {exprs.add(ExpressionFactory.createQuantifierLiteralExpression(q, null));}} | |
; | |
condition returns [RutaCondition result = null] | |
@init { | |
result = ConditionFactory.createEmptyCondition(input.LT(1)); | |
} | |
: | |
( | |
c = conditionAnd | |
| c = conditionContains | |
| c = conditionContextCount | |
| c = conditionCount | |
| c = conditionCurrentCount | |
| c = conditionInList | |
| c = conditionLast | |
| c = conditionMofN | |
| c = conditionNear | |
| c = conditionNot | |
| c = conditionOr | |
| c = conditionPartOf | |
| c = conditionPosition | |
| c = conditionRegExp | |
| c = conditionScore | |
| c = conditionTotalCount | |
| c = conditionVote | |
| c = conditionIf | |
| c = conditionFeature | |
| c = conditionParse | |
| c = conditionIs | |
| c = conditionBefore | |
| c = conditionAfter | |
| c = conditionStartsWith | |
| c = conditionEndsWith | |
| c = conditionPartOfNeq | |
| c = conditionSize | |
| (booleanExpression)=> b = booleanExpression {c = ConditionFactory.createCondition(b);} | |
| (externalCondition)=> c = externalCondition | |
) {result = c;} | |
; | |
//TODO added rule | |
variableCondition returns [RutaCondition condition = null] | |
: | |
// also create condition for auto-completion | |
//{isVariableOfType(input.LT(1).getText(), "CONDITION")}? | |
id = Identifier | |
{ | |
condition = ConditionFactory.createCondition(id); | |
} | |
; | |
externalCondition returns [RutaCondition condition = null] | |
: | |
id = Identifier | |
{condition = external.createExternalCondition(id, args);} | |
LPAREN | |
args = varArgumentList? | |
RPAREN | |
{condition = external.createExternalCondition(id, args);} | |
; | |
conditionAnd returns [RutaCondition cond = null] | |
: | |
name = AND LPAREN conds = conditions | |
{cond = ConditionFactory.createCondition(name, conds);} | |
RPAREN | |
; | |
conditionContains returns [RutaCondition cond = null] | |
@init { | |
List<Expression> args = new ArrayList<>(); | |
} | |
: | |
name = CONTAINS LPAREN | |
a = argument {args.add(a);} | |
(COMMA a = argument{args.add(a);})* | |
RPAREN | |
//(type = typeExpression | list = plainListExpression COMMA a = argument) | |
//(COMMA min = numberExpression COMMA max = numberExpression (COMMA percent = booleanExpression)?)? RPAREN | |
{ | |
cond = ConditionFactory.createCondition(name, args); | |
//if(type != null) {cond = ConditionFactory.createConditionContains(type, min, max, percent,$blockDeclaration::env);} | |
//else if(list != null) {cond = ConditionFactory.createConditionContains(list, a, min, max, percent, $blockDeclaration::env);} | |
} | |
; | |
conditionContextCount returns [RutaCondition cond = null] | |
: | |
name = CONTEXTCOUNT LPAREN typeExpr = typeExpression | |
{cond = ConditionFactory.createCondition(name, typeExpr, min, max, var);} | |
(COMMA min = numberExpression COMMA max = numberExpression)? | |
{cond = ConditionFactory.createCondition(name, typeExpr, min, max, var);} | |
(COMMA var = numberVariable)? | |
{cond = ConditionFactory.createCondition(name, typeExpr, min, max, var);} | |
RPAREN | |
; | |
conditionCount returns [RutaCondition cond = null] | |
options { | |
backtrack = true; | |
} | |
: | |
name = COUNT LPAREN type = listExpression | |
{cond = ConditionFactory.createCondition(name, type, a, min, max, var);} | |
COMMA a = argument | |
{cond = ConditionFactory.createCondition(name, type, a, min, max, var);} | |
(COMMA min = numberExpression COMMA max = numberExpression)? | |
{cond = ConditionFactory.createCondition(name, type, a, min, max, var);} | |
(COMMA var = numberVariable)? | |
{cond = ConditionFactory.createCondition(name, type, a, min, max, var);} | |
RPAREN | |
| | |
name = COUNT LPAREN type = typeExpression | |
{cond = ConditionFactory.createCondition(name, type, min, max, var);} | |
(COMMA min = numberExpression COMMA max = numberExpression)? | |
{cond = ConditionFactory.createCondition(name, type, min, max, var);} | |
(COMMA var = numberVariable)? | |
{cond = ConditionFactory.createCondition(name, type, min, max, var);} | |
RPAREN | |
; | |
conditionCurrentCount returns [RutaCondition cond = null] | |
: | |
name = CURRENTCOUNT LPAREN type = typeExpression | |
{cond = ConditionFactory.createCondition(name,type, min, max, var);} | |
(COMMA min = numberExpression COMMA max = numberExpression)? | |
{cond = ConditionFactory.createCondition(name,type, min, max, var);} | |
(COMMA var = numberVariable)? | |
{cond = ConditionFactory.createCondition(name,type, min, max, var);} | |
RPAREN | |
; | |
conditionTotalCount returns [RutaCondition cond = null] | |
: | |
name = TOTALCOUNT LPAREN type = typeExpression | |
{cond = ConditionFactory.createCondition(name,type, min, max, var);} | |
(COMMA min = numberExpression COMMA max = numberExpression)? | |
{cond = ConditionFactory.createCondition(name,type, min, max, var);} | |
(COMMA var = numberVariable)? | |
{cond = ConditionFactory.createCondition(name, type, min, max, var);} | |
RPAREN | |
; | |
conditionInList returns [RutaCondition cond = null] | |
options { | |
backtrack = true; | |
} | |
: | |
name = INLIST LPAREN ((list2 = stringListExpression)=>list2 = stringListExpression | list1 = wordListExpression) | |
(COMMA arg = stringExpression)? | |
//(COMMA dist = numberExpression (COMMA rel = booleanExpression)?)? | |
{if(list1 != null) {cond = ConditionFactory.createCondition(name, list1, arg);} | |
else {cond = ConditionFactory.createCondition(name, list2, arg);};} | |
RPAREN | |
; | |
conditionLast returns [RutaCondition cond = null] | |
: | |
name = LAST LPAREN type = typeExpression | |
{cond = ConditionFactory.createCondition(name, type);} | |
RPAREN | |
; | |
conditionMofN returns [RutaCondition cond = null] | |
: | |
name = MOFN LPAREN min = numberExpression COMMA max = numberExpression COMMA conds = conditions | |
{List exprs = new ArrayList(); | |
exprs.add(min); | |
exprs.add(max); | |
exprs.addAll(conds); | |
cond = ConditionFactory.createCondition(name, exprs);} | |
RPAREN | |
; | |
conditionNear returns [RutaCondition cond = null] | |
: | |
name = NEAR LPAREN type = typeExpression COMMA min = numberExpression COMMA max = numberExpression | |
(COMMA direction = booleanExpression (COMMA filtered = booleanExpression)?)? | |
{cond = ConditionFactory.createCondition(name, type, min, max, direction, filtered);} | |
RPAREN | |
; | |
conditionNot returns [RutaCondition cond = null] | |
: | |
((name = MINUS c = condition) | (name = NOT LPAREN c = condition RPAREN)) | |
{cond = ConditionFactory.createCondition(name, c);} | |
; | |
conditionOr returns [RutaCondition cond = null] | |
: | |
name = OR LPAREN conds = conditions | |
{cond = ConditionFactory.createCondition(name, conds);} | |
RPAREN | |
; | |
conditionPartOf returns [RutaCondition cond = null] | |
: | |
name = PARTOF LPAREN (type = typeExpression|type = typeListExpression) | |
{cond = ConditionFactory.createCondition(name, type);} | |
RPAREN | |
; | |
conditionPartOfNeq returns [RutaCondition cond = null] | |
: | |
name = PARTOFNEQ LPAREN (type = typeExpression|type = typeListExpression) | |
{cond = ConditionFactory.createCondition(name, type);} | |
RPAREN | |
; | |
conditionPosition returns [RutaCondition cond = null] | |
: | |
name = POSITION LPAREN type = typeExpression | |
{cond = ConditionFactory.createCondition(name, type, pos, rel);} | |
COMMA pos = numberExpression | |
{cond = ConditionFactory.createCondition(name, type, pos, rel);} | |
(COMMA rel = booleanExpression)? | |
{cond = ConditionFactory.createCondition(name, type, pos, rel);} | |
RPAREN | |
; | |
conditionRegExp returns [RutaCondition cond = null] | |
: | |
name = REGEXP LPAREN | |
((stringExpression COMMA stringExpression)=> v = stringExpression COMMA pattern = stringExpression | |
| pattern = stringExpression | |
) (COMMA caseSensitive = booleanExpression)? | |
{cond = ConditionFactory.createCondition(name, v, pattern, caseSensitive);} | |
RPAREN | |
; | |
conditionScore returns [RutaCondition cond = null] | |
: | |
name = SCORE LPAREN min = numberExpression (COMMA max = numberExpression | |
(COMMA var = numberVariable)?)? | |
{cond = ConditionFactory.createCondition(name, min, max, var);} | |
RPAREN | |
; | |
conditionVote returns [RutaCondition cond = null] | |
: | |
name = VOTE LPAREN type1 = typeExpression COMMA type2 = typeExpression | |
{cond = ConditionFactory.createCondition(name, type1, type2);} | |
RPAREN | |
; | |
conditionIf returns [RutaCondition cond = null] | |
: | |
name = IF LPAREN e = booleanExpression | |
{cond = ConditionFactory.createCondition(name, e);} | |
RPAREN | |
; | |
conditionFeature returns [RutaCondition cond = null] | |
: | |
name = FEATURE LPAREN se = stringExpression COMMA v = argument | |
{cond = ConditionFactory.createCondition(name, se, v);} | |
RPAREN | |
; | |
conditionParse returns [RutaCondition cond = null] | |
: | |
name = PARSE LPAREN | |
var=genericVariableReference (COMMA locale = stringExpression)? | |
{cond = ConditionFactory.createCondition(name, var, locale);} | |
RPAREN | |
; | |
conditionIs returns [RutaCondition cond = null] | |
: | |
name = IS LPAREN (type = typeExpression|type = typeListExpression) | |
{cond = ConditionFactory.createCondition(name, type);} | |
RPAREN | |
; | |
conditionBefore returns [RutaCondition cond = null] | |
: | |
name = BEFORE LPAREN (type = typeExpression|type = typeListExpression) | |
{cond = ConditionFactory.createCondition(name, type);} | |
RPAREN | |
; | |
conditionAfter returns [RutaCondition cond = null] | |
: | |
name = AFTER LPAREN (type = typeExpression|type = typeListExpression) | |
{cond = ConditionFactory.createCondition(name, type);} | |
RPAREN | |
; | |
conditionStartsWith returns [RutaCondition cond = null] | |
: | |
name = STARTSWITH LPAREN (type = typeExpression|type = typeListExpression) | |
{cond = ConditionFactory.createCondition(name, type);} | |
RPAREN | |
; | |
conditionEndsWith returns [RutaCondition cond = null] | |
: | |
name = ENDSWITH LPAREN (type = typeExpression|type = typeListExpression) | |
{cond = ConditionFactory.createCondition(name, type);} | |
RPAREN | |
; | |
conditionSize returns [RutaCondition cond = null] | |
: | |
name = SIZE LPAREN list = listExpression (COMMA min = numberExpression COMMA max = numberExpression)? (COMMA var = numberVariable)? | |
{cond = ConditionFactory.createCondition(name, list, min, max, var);} | |
RPAREN | |
; | |
rawAction returns [RutaAction result = null] | |
@init { | |
result = ActionFactory.createEmptyAction(input.LT(1)); | |
} | |
: | |
( | |
a = actionColor | |
| a = actionDel | |
| a = actionLog | |
| a = actionMark | |
| a = actionMarkScore | |
| a = actionMarkFast | |
| a = actionMarkLast | |
| a = actionMarkFirst | |
| a = actionReplace | |
| a = actionRetainType | |
| a = actionFilterType | |
| a = actionCreate | |
| a = actionFill | |
| a = actionCall | |
| a = actionAssign | |
| a = actionSetFeature | |
| a = actionGetFeature | |
| a = actionUnmark | |
| a = actionUnmarkAll | |
| a = actionTransfer | |
| a = actionMarkOnce | |
| a = actionTrie | |
| a = actionGather | |
| a = actionExec | |
| a = actionMarkTable | |
| a = actionAdd | |
| a = actionRemove | |
| a = actionRemoveDuplicate | |
| a = actionMerge | |
| a = actionGet | |
| a = actionGetList | |
| a = actionMatchedText | |
| a = actionClear | |
| a = actionShift | |
| a = actionSplit | |
| a = actionConfigure | |
| a = actionDynamicAnchoring | |
| a = actionGreedyAnchoring | |
| a = actionTrim | |
| a = actionAddFilterType | |
| a = actionAddRetainType | |
| a = actionRemoveFilterType | |
| a = actionRemoveRetainType | |
| (externalAction)=> a = externalAction | |
// | a = variableAction | |
) {result = a;} | |
; | |
action returns [RutaAction result = null] | |
@init { | |
result = ActionFactory.createEmptyAction(input.LT(1)); | |
} | |
: | |
( | |
a = actionColor | |
| a = actionDel | |
| a = actionLog | |
| a = actionMark | |
| a = actionMarkScore | |
| a = actionMarkFast | |
| a = actionMarkLast | |
| a = actionMarkFirst | |
| a = actionReplace | |
| a = actionRetainType | |
| a = actionFilterType | |
| a = actionCreate | |
| a = actionFill | |
| a = actionCall | |
| a = actionAssign | |
| a = actionSetFeature | |
| a = actionGetFeature | |
| a = actionUnmark | |
| a = actionUnmarkAll | |
| a = actionTransfer | |
| a = actionMarkOnce | |
| a = actionTrie | |
| a = actionGather | |
| a = actionExec | |
| a = actionMarkTable | |
| a = actionAdd | |
| a = actionRemove | |
| a = actionRemoveDuplicate | |
| a = actionMerge | |
| a = actionGet | |
| a = actionGetList | |
| a = actionMatchedText | |
| a = actionClear | |
| a = actionShift | |
| a = actionSplit | |
| a = actionConfigure | |
| a = actionDynamicAnchoring | |
| a = actionGreedyAnchoring | |
| a = actionTrim | |
| a = actionAddFilterType | |
| a = actionAddRetainType | |
| a = actionRemoveFilterType | |
| a = actionRemoveRetainType | |
| (variableAssignmentAction)=> vae = variableAssignmentAction {a = vae;} | |
| (externalAction)=> a = externalAction | |
| (featureAssignmentExpression)=> fae = featureAssignmentExpression {a = ActionFactory.createAction(fae);} | |
| (typeExpression)=> te = typeExpression {a = ActionFactory.createAction(te);} | |
// | a = variableAction | |
) {result = a;} | |
; | |
variableAction returns [RutaAction action = null] | |
: | |
// also create an dummy action for auto-completion | |
//{isVariableOfType(input.LT(1).getText(), "ACTION")}? | |
id = Identifier | |
{ | |
action = ActionFactory.createAction(id); | |
} | |
; | |
externalAction returns [RutaAction action = null] | |
: | |
id = Identifier | |
LPAREN | |
args = varArgumentList? | |
RPAREN | |
{ | |
action = external.createExternalAction(id, args); | |
} | |
; | |
actionCreate returns [RutaAction action = null] | |
@init { | |
List left = new ArrayList(); | |
List right = new ArrayList(); | |
List indexes = new ArrayList(); | |
} | |
: | |
name = CREATE LPAREN structure = typeExpression | |
(COMMA | |
((numberExpression)=> index = numberExpression {indexes.add(index);} ((COMMA index = numberExpression)=> (COMMA index = numberExpression){indexes.add(index);})* COMMA)? | |
((stringExpression ASSIGN_EQUAL)=> fname = stringExpression ASSIGN_EQUAL obj1 = argument {left.add(fname); right.add(obj1);} | |
(COMMA fname = stringExpression ASSIGN_EQUAL obj1 = argument {left.add(fname);right.add(obj1);})*)? | |
)? | |
{action = ActionFactory.createStructureAction(name, structure, indexes, left, right);} | |
RPAREN | |
; | |
actionMarkTable returns [RutaAction action = null] | |
@init { | |
List<Expression> left = new ArrayList<Expression>(); | |
List<Expression> right = new ArrayList<Expression>(); | |
} | |
: | |
name = MARKTABLE LPAREN | |
structure = typeExpression COMMA | |
index = numberExpression COMMA | |
table = wordTableExpression | |
COMMA | |
( (booleanExpression)=> ignoreCase = booleanExpression | |
COMMA ignoreLength = numberExpression | |
COMMA ignoreChar = stringExpression | |
COMMA maxIgnoreChar = numberExpression COMMA)? | |
key = stringExpression {left.add(key);} ASSIGN_EQUAL value = numberExpression{right.add(value);} | |
(COMMA key = stringExpression {left.add(key);} ASSIGN_EQUAL value = numberExpression{right.add(value);} )* | |
{ | |
List<Expression> args = new ArrayList<Expression>(); | |
args.add(index); | |
args.add(table); | |
args.add(ignoreCase); | |
args.add(ignoreLength); | |
args.add(ignoreChar); | |
args.add(maxIgnoreChar); | |
action = ActionFactory.createStructureAction(name, args, left, right, structure);} | |
RPAREN | |
; | |
actionGather returns [RutaAction action = null] | |
@init { | |
List left = new ArrayList(); | |
List right = new ArrayList(); | |
List indexes = new ArrayList(); | |
} | |
: | |
name = GATHER LPAREN structure = typeExpression | |
{action = ActionFactory.createStructureAction(name, structure, indexes, left, right);} | |
(COMMA | |
((numberExpression)=> index = numberExpression {indexes.add(index);} ((COMMA index = numberExpression)=>(COMMA index = numberExpression) {indexes.add(index);})* COMMA)? | |
(fname = stringExpression ASSIGN_EQUAL (obj1 = numberExpression | obj2 = numberListExpression) {left.add(fname); right.add(obj1 != null? obj1 : obj2);} | |
(COMMA fname = stringExpression ASSIGN_EQUAL (obj1 = numberExpression | obj2 = numberListExpression) {left.add(fname);right.add(obj1 != null? obj1 : obj2);})*)? | |
)? | |
{action = ActionFactory.createStructureAction(name, structure, indexes, left, right);} | |
RPAREN | |
; | |
actionFill returns [RutaAction action = null] | |
@init { | |
List left = new ArrayList(); | |
List right = new ArrayList(); | |
} | |
: | |
name = FILL LPAREN structure = typeExpression | |
{action = ActionFactory.createStructureAction(name, structure, null, left, right);} | |
( | |
COMMA fname = stringExpression ASSIGN_EQUAL | |
obj1 = argument {left.add(fname); right.add(obj1);} | |
)+ | |
{action = ActionFactory.createStructureAction(name, structure, null, left, right);} | |
RPAREN | |
; | |
actionColor returns [RutaAction action = null] | |
: | |
name = COLOR LPAREN type = typeExpression | |
{action = ActionFactory.createAction(name, type, bgcolor, fgcolor, selected);} | |
COMMA | |
bgcolor = stringExpression | |
{action = ActionFactory.createAction(name, type, bgcolor, fgcolor, selected);} | |
(COMMA | |
fgcolor = stringExpression | |
{action = ActionFactory.createAction(name, type, bgcolor, fgcolor, selected);} | |
(COMMA | |
selected = booleanExpression)?)? | |
{action = ActionFactory.createAction(name, type, bgcolor, fgcolor, selected);} | |
RPAREN | |
; | |
actionDel returns [RutaAction action = null] | |
: | |
name = DEL | |
{action = ActionFactory.createAction(name, new ArrayList());} | |
; | |
actionLog returns [RutaAction action = null] | |
: | |
name = LOG LPAREN lit = stringExpression (COMMA log = LogLevel)? | |
{action = ActionFactory.createLogAction(name, lit, log);} //TODO handle logLevel | |
RPAREN | |
; | |
actionMark returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = MARK LPAREN | |
type = typeExpression | |
{list.add(type);} | |
( | |
COMMA (index = numberExpression) => index = numberExpression {list.add(index);} | |
)* | |
{action = ActionFactory.createAction(name, list);} | |
RPAREN | |
; | |
actionShift returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = SHIFT LPAREN | |
type = typeExpression | |
{list.add(type);} | |
COMMA index1 = numberExpression {list.add(index1);} | |
COMMA index2 = numberExpression {list.add(index2);} | |
(COMMA all= booleanExpression {list.add(all);})? | |
{action = ActionFactory.createAction(name, list);} | |
RPAREN | |
; | |
actionSplit returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = SPLIT | |
LPAREN | |
type = typeExpression | |
{list.add(type);} | |
( | |
COMMA | |
complete = booleanExpression | |
{list.add(complete);} | |
( | |
COMMA | |
appendToBegin = booleanExpression | |
{list.add(appendToBegin);} | |
COMMA | |
appendToEnd = booleanExpression | |
{list.add(appendToEnd);} | |
)? | |
)? | |
RPAREN | |
{action = ActionFactory.createAction(name, list);} | |
; | |
actionMarkScore returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = MARKSCORE LPAREN score = numberExpression COMMA type = typeExpression | |
{list.add(score); list.add(type);} | |
( | |
COMMA (index = numberExpression) => index = numberExpression {list.add(index);} | |
)* | |
{action = ActionFactory.createAction(name, list);} | |
RPAREN | |
; | |
actionMarkOnce returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = MARKONCE LPAREN ((score = numberExpression) => score = numberExpression COMMA)? (type = typeExpression) => type = typeExpression | |
{list.add(score); list.add(type);} | |
( | |
COMMA (index = numberExpression) => index = numberExpression {list.add(index);} | |
)* | |
{action = ActionFactory.createAction(name, list);} | |
RPAREN | |
; | |
actionMarkFast returns [RutaAction action = null] | |
@init { | |
Expression list = null; | |
} | |
: | |
name = MARKFAST LPAREN type = typeExpression | |
{action = ActionFactory.createAction(name, type, list, ignore, numExpr);} | |
COMMA (list1 = wordListExpression | list2 = stringListExpression) {list = list1 == null ? list2 : list1;} | |
{action = ActionFactory.createAction(name, type, list, ignore, numExpr);} | |
(COMMA ignore = booleanExpression (COMMA numExpr = numberExpression (COMMA ignoreWS = booleanExpression)?)?)? | |
{action = ActionFactory.createAction(name, type, list, ignore, numExpr, ignoreWS);} // TODO handle list | |
RPAREN | |
; | |
actionMarkLast returns [RutaAction action = null] | |
: | |
name = MARKLAST LPAREN type = typeExpression | |
{action = ActionFactory.createAction(name, type);} | |
RPAREN | |
; | |
actionMarkFirst returns [RutaAction action = null] | |
: | |
name = MARKFIRST LPAREN type = typeExpression | |
{action = ActionFactory.createAction(name, type);} | |
RPAREN | |
; | |
actionReplace returns [RutaAction action = null] | |
: | |
name = REPLACE LPAREN lit = stringExpression | |
{action = ActionFactory.createAction(name, lit);} | |
RPAREN | |
; | |
actionRetainType returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = RETAINTYPE (LPAREN id = typeExpression {list.add(id);} | |
{action = ActionFactory.createAction(name, list);} | |
(COMMA id = typeExpression {list.add(id);})* | |
{action = ActionFactory.createAction(name, list);} | |
RPAREN)? | |
{action = ActionFactory.createAction(name, list);} | |
; | |
actionFilterType returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = FILTERTYPE (LPAREN id = typeExpression {list.add(id);} | |
{action = ActionFactory.createAction(name, list);} | |
(COMMA id = typeExpression {list.add(id);})* | |
{action = ActionFactory.createAction(name, list);} | |
RPAREN)? | |
{action = ActionFactory.createAction(name, list);} | |
; | |
actionAddFilterType returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = ADDFILTERTYPE (LPAREN id = typeExpression {list.add(id);} | |
{action = ActionFactory.createAction(name, list);} | |
(COMMA id = typeExpression {list.add(id);})* | |
{action = ActionFactory.createAction(name, list);} | |
RPAREN) | |
{action = ActionFactory.createAction(name, list);} | |
; | |
actionAddRetainType returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = ADDRETAINTYPE (LPAREN id = typeExpression {list.add(id);} | |
{action = ActionFactory.createAction(name, list);} | |
(COMMA id = typeExpression {list.add(id);})* | |
{action = ActionFactory.createAction(name, list);} | |
RPAREN) | |
{action = ActionFactory.createAction(name, list);} | |
; | |
actionRemoveFilterType returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = REMOVEFILTERTYPE (LPAREN id = typeExpression {list.add(id);} | |
{action = ActionFactory.createAction(name, list);} | |
(COMMA id = typeExpression {list.add(id);})* | |
{action = ActionFactory.createAction(name, list);} | |
RPAREN) | |
{action = ActionFactory.createAction(name, list);} | |
; | |
actionRemoveRetainType returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = REMOVERETAINTYPE (LPAREN id = typeExpression {list.add(id);} | |
{action = ActionFactory.createAction(name, list);} | |
(COMMA id = typeExpression {list.add(id);})* | |
{action = ActionFactory.createAction(name, list);} | |
RPAREN) | |
{action = ActionFactory.createAction(name, list);} | |
; | |
actionCall returns [RutaAction action = null] | |
@init { | |
String string = ""; | |
} | |
: | |
name = CALL lp = LPAREN | |
{ action = ActionFactory.createCallAction(name, StatementFactory.createEmtpyComponentReference(lp));} | |
ns = dottedComponentReference | |
{ if(ns != null) {action = ActionFactory.createCallAction(name, ns);}} | |
RPAREN | |
; | |
actionConfigure returns [RutaAction action = null] | |
@init { | |
List left = new ArrayList(); | |
List right = new ArrayList(); | |
} | |
: | |
name = CONFIGURE lp = LPAREN | |
{ action = ActionFactory.createConfigureAction(name, StatementFactory.createEmtpyComponentReference(lp), null , null);} | |
ns = dottedComponentReference | |
{ if(ns != null) {action = ActionFactory.createConfigureAction(name, ns, null , null);}} | |
(COMMA fname = stringExpression ASSIGN_EQUAL obj1 = argument {left.add(fname); right.add(obj1);} | |
(COMMA fname = stringExpression ASSIGN_EQUAL obj1 = argument {left.add(fname);right.add(obj1);})*)? | |
{ action = ActionFactory.createConfigureAction(name, ns, left , right);} | |
RPAREN | |
; | |
actionExec returns [RutaAction action = null] | |
@init { | |
String string = ""; | |
} | |
: | |
name = EXEC lp = LPAREN | |
{ action = ActionFactory.createCallAction(name, StatementFactory.createEmtpyComponentReference(lp));} | |
((stringExpression)=> view = stringExpression COMMA)? | |
{ if(view != null) {action = ActionFactory.createCallAction(name, ns, null, view);}} | |
ns = dottedComponentReference | |
{ if(ns != null) {action = ActionFactory.createCallAction(name, ns, null, view);}} | |
(COMMA tl = typeListExpression)? | |
{ if(ns != null) {action = ActionFactory.createCallAction(name, ns, tl, view);}} | |
RPAREN | |
; | |
actionAssign returns [RutaAction action = null] | |
@init{ | |
VariableReference ref = null; | |
} | |
: | |
name = ASSIGN LPAREN | |
(id = Identifier | |
{ | |
ref = ExpressionFactory.createGenericVariableReference(id); | |
action = ActionFactory.createAction(name, ref, e);} | |
COMMA e = argument | |
) RPAREN | |
{ | |
ref = ExpressionFactory.createGenericVariableReference(id); | |
action = ActionFactory.createAction(name, ref, e);} | |
; | |
//unknown | |
actionSetFeature returns [RutaAction action = null] | |
: | |
name = SETFEATURE LPAREN f = stringExpression | |
{action = ActionFactory.createAction(name, f, v);} | |
COMMA v = argument | |
{action = ActionFactory.createAction(name, f, v);} | |
RPAREN | |
; | |
actionGetFeature returns [RutaAction action = null] | |
: | |
name = GETFEATURE LPAREN f = stringExpression | |
{action = ActionFactory.createAction(name, f, v);} | |
COMMA v = variable | |
{action = ActionFactory.createAction(name, f, v);} | |
RPAREN | |
; | |
//unknown | |
actionDynamicAnchoring returns [RutaAction action = null] | |
: | |
name = DYNAMICANCHORING LPAREN active = booleanExpression | |
{action = ActionFactory.createAction(name, active);} | |
(COMMA penalty = numberExpression | |
{action = ActionFactory.createAction(name, active, penalty);} | |
(COMMA factor = numberExpression)?)? | |
{action = ActionFactory.createAction(name, active, penalty, factor);} | |
RPAREN | |
; | |
actionGreedyAnchoring returns [RutaAction action = null] | |
: | |
name = GREEDYANCHORING | |
{action = ActionFactory.createAction(name, active);} | |
LPAREN active = booleanExpression (COMMA active2 = booleanExpression)? | |
{action = ActionFactory.createAction(name, active, active2);} | |
RPAREN | |
; | |
actionTrim returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = TRIM LPAREN | |
{action = ActionFactory.createAction(name, list);} | |
( | |
t1 = typeExpression {list.add(t1); action = ActionFactory.createAction(name, list);} | |
(COMMA t2 = typeExpression {list.add(t1); action = ActionFactory.createAction(name, list);})* | |
| | |
tl = typeListExpression {action = ActionFactory.createAction(name, tl);} | |
) | |
RPAREN | |
; | |
//unknown | |
actionUnmark returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = UNMARK LPAREN ( | |
f = typeExpression | |
{action = ActionFactory.createAction(name, f);} | |
(COMMA | |
( | |
(b = booleanExpression) => b = booleanExpression | |
{action = ActionFactory.createAction(name, f, b);} | |
| | |
( | |
index = numberExpression {list.add(index);} | |
{action = ActionFactory.createAction(name, f, list);} | |
(COMMA index = numberExpression {list.add(index);})* | |
{action = ActionFactory.createAction(name, f, list);} | |
) | |
) | |
)? | |
{action = ActionFactory.createAction(name, f , b, list);} | |
RPAREN | |
) | |
; | |
actionUnmarkAll returns [RutaAction action = null] | |
: | |
name = UNMARKALL LPAREN f = typeExpression | |
{action = ActionFactory.createAction(name, f, list);} | |
(COMMA list = typeListExpression)? | |
{action = ActionFactory.createAction(name, f, list);} | |
RPAREN | |
; | |
//unknown | |
actionTransfer returns [RutaAction action = null] | |
: | |
name = TRANSFER LPAREN f = typeExpression | |
{action = ActionFactory.createAction(name, f);} | |
RPAREN | |
; | |
actionTrie returns [RutaAction action = null] | |
@init { | |
Map<Expression, Expression> map = new HashMap<Expression, Expression>(); | |
List<Expression> left = new ArrayList<Expression>(); | |
List<Expression> right = new ArrayList<Expression>(); | |
} | |
: | |
name = TRIE LPAREN | |
key = stringExpression {left.add(key);}ASSIGN_EQUAL | |
(value = typeExpression{right.add(value);} | listValue = untypedListExpression {right.add(listValue);}) | |
(COMMA key = stringExpression {left.add(key);} ASSIGN_EQUAL | |
(value = typeExpression{right.add(value);} | listValue = untypedListExpression {right.add(listValue);}) | |
)* | |
COMMA list = wordListExpression | |
COMMA ignoreCase = booleanExpression | |
COMMA ignoreLength = numberExpression | |
COMMA edit = booleanExpression | |
COMMA distance = numberExpression | |
COMMA ignoreChar = stringExpression | |
//TODO cost parameter | |
{ | |
List<Expression> args = new ArrayList<Expression>(); | |
args.add(ignoreCase); | |
args.add(ignoreLength); | |
args.add(edit); | |
args.add(distance); | |
args.add(ignoreChar); | |
action = ActionFactory.createStructureAction(name, args, left, right, list);} | |
RPAREN | |
; | |
actionAdd returns [RutaAction action = null] | |
@init{ | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = ADD LPAREN f = listVariable | |
{action = ActionFactory.createAction(name, f, list);} | |
(COMMA a = argument {list.add(a);})+ | |
{action = ActionFactory.createAction(name, f, list);} | |
RPAREN | |
; | |
actionRemove returns [RutaAction action = null] | |
@init{ | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = REMOVE LPAREN f = listVariable | |
{action = ActionFactory.createAction(name, f, list);} | |
(COMMA a = argument {list.add(a);})+ | |
{action = ActionFactory.createAction(name, f, list);} | |
RPAREN | |
; | |
actionRemoveDuplicate returns [RutaAction action = null] | |
: | |
name = REMOVEDUPLICATE LPAREN f = listVariable | |
{action = ActionFactory.createAction(name, f);} | |
RPAREN | |
; | |
actionMerge returns [RutaAction action = null] | |
@init{ | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = MERGE LPAREN join = booleanExpression | |
{action = ActionFactory.createAction(name, join, t, list);} | |
COMMA t = listVariable | |
{action = ActionFactory.createAction(name, join, t, list);} | |
COMMA f = listExpression {list.add(f);} | |
(COMMA f = listExpression {list.add(f);})+ | |
{action = ActionFactory.createAction(name, join, t, list);} | |
RPAREN | |
; | |
actionGet returns [RutaAction action = null] | |
: | |
name = GET LPAREN f = listExpression | |
{action = ActionFactory.createAction(name, f, var, op);} | |
COMMA var = variable | |
{action = ActionFactory.createAction(name, f, var, op);} | |
COMMA op = stringExpression | |
{action = ActionFactory.createAction(name, f, var, op);} | |
RPAREN | |
; | |
actionGetList returns [RutaAction action = null] | |
: | |
name = GETLIST LPAREN var = listVariable | |
{action = ActionFactory.createAction(name, var, op);} | |
COMMA op = stringExpression | |
{action = ActionFactory.createAction(name, var, op);} | |
RPAREN | |
; | |
actionMatchedText returns [RutaAction action = null] | |
@init { | |
List<Expression> list = new ArrayList<Expression>(); | |
} | |
: | |
name = MATCHEDTEXT LPAREN | |
var = variable | |
( | |
COMMA index = numberExpression {list.add(index);} | |
)* | |
{action = ActionFactory.createAction(name, var, list);} | |
RPAREN | |
; | |
actionClear returns [RutaAction action = null] | |
: | |
name = CLEAR LPAREN var = listVariable | |
{action = ActionFactory.createAction(name, var);} | |
RPAREN | |
; | |
//OKdc | |
varArgumentList returns [List<Expression> args = new ArrayList<Expression>()] | |
: | |
arg = argument {args.add(arg);} (COMMA arg = argument {args.add(arg);})* | |
; | |
//changed but unknown statuslistExpression | |
argument returns [Expression expr = null] //SimpleReference arg1 = null] | |
//options { | |
// backtrack = true; | |
//} | |
: | |
(nullExpression) => a5 = nullExpression {expr = a5;} | |
| (featureExpression)=> fe = featureExpression {expr = fe;} | |
| (booleanExpression)=> a2 = booleanExpression {expr = a2;} | |
| (numberExpression)=> a3 = numberExpression {expr = a3;} | |
| (stringExpression)=> a4 = stringExpression {expr = a4;} | |
| (listExpression)=> l = listExpression {expr = l;} | |
| a1 = typeExpression {expr = a1;} | |
//token = ( | |
//(booleanExpression[par]) => booleanExpression[par] | |
//| (numberExpression[par]) => numberExpression[par] | |
//| (stringExpression[par]) => stringExpression[par] | |
//| (typeExpression[par]) => typeExpression[par] | |
//) | |
//{arg = token;} | |
; | |
nullExpression returns [Expression expr = null] | |
: | |
t = NULL {expr = ExpressionFactory.createNullExpression(t);} | |
; | |
primitiveArgument returns [Expression expr = null] | |
options { | |
backtrack = true; | |
} | |
: | |
a4 = simpleStringExpression {expr = a4;} | |
| a2 = simpleBooleanExpression {expr = a2;} | |
| a3 = simpleNumberExpression {expr = a3;} | |
| a1 = simpleTypeExpression {expr = a1;} | |
//token = ( | |
//(booleanExpression[par]) => booleanExpression[par] | |
//| (numberExpression[par]) => numberExpression[par] | |
//| (stringExpression[par]) => stringExpression[par] | |
//| (typeExpression[par]) => typeExpression[par] | |
//) | |
//{arg = token;} | |
; | |
//snooze | |
dottedIdentifier returns [String idString = ""] | |
: | |
id = Identifier {idString += id.getText();} | |
( | |
dot = DOT {idString += dot.getText();} | |
idn = Identifier {idString += idn.getText();} | |
)* | |
; | |
dottedIdentifier2 returns [String idString = ""] | |
: | |
id = Identifier {idString += id.getText();} | |
( | |
dot = (DOT|MINUS) {idString += dot.getText();} | |
idn = Identifier {idString += idn.getText();} | |
)* | |
; | |
//snooze | |
dottedId returns [Token token = null ] | |
@init {CommonToken ct = null;} | |
: | |
id = Identifier { | |
ct = new CommonToken(id); | |
} | |
( | |
dot = DOT {ct.setText(ct.getText() + dot.getText());} | |
id = Identifier {ct.setStopIndex(getBounds(id)[1]); | |
ct.setText(ct.getText() + id.getText());} | |
)* | |
{token = ct; | |
return token;} | |
; | |
dottedId2 returns [Token token = null ] | |
@init {CommonToken ct = null;} | |
: | |
id = Identifier { | |
ct = new CommonToken(id); | |
} | |
( | |
dot = (DOT| MINUS) {ct.setText(ct.getText() + dot.getText());} | |
id = Identifier {ct.setStopIndex(getBounds(id)[1]); | |
ct.setText(ct.getText() + id.getText());} | |
)+ | |
{token = ct; | |
return token;} | |
; | |
dottedId3 returns [Token token = null ] | |
@init {CommonToken ct = null;} | |
: | |
// at least one dot! | |
id = Identifier { | |
ct = new CommonToken(id); | |
} | |
( | |
dot = DOT {ct.setText(ct.getText() + dot.getText());} | |
id = Identifier {ct.setStopIndex(getBounds(id)[1]); | |
ct.setText(ct.getText() + id.getText());} | |
)+ | |
{token = ct; | |
return token;} | |
; | |
dottedIdWithIndex returns [Token token = null ] | |
@init {CommonToken ct = null;} | |
: | |
id = Identifier {ct = new CommonToken(id);} | |
( | |
lb = LBRACK {ct.setText(ct.getText() + lb.getText());} | |
index = DecimalLiteral {ct.setText(ct.getText() + index.getText());} | |
rb = RBRACK {ct.setStopIndex(getBounds(rb)[1]);ct.setText(ct.getText() + rb.getText());} | |
| | |
dot = DOT {ct.setText(ct.getText() + dot.getText());} | |
id = Identifier {ct.setStopIndex(getBounds(id)[1]);ct.setText(ct.getText() + id.getText());} | |
)+ | |
{token = ct; return token;} | |
; | |
//snooze | |
dottedComponentReference returns [ComponentReference ref = null ] | |
@init {CommonToken ct = null;} | |
: | |
id = Identifier { | |
ct = new CommonToken(id); | |
//if (ct.getText().equals("<missing Identifier>")) { | |
// CommonTokenStream cts = (CommonTokenStream) input; | |
// Token lt = cts.LT(1); | |
// ct = new CommonToken(lt); | |
// } | |
} | |
( | |
dot = (DOT | MINUS) {ct.setText(ct.getText() + dot.getText());} | |
id = Identifier {ct.setStopIndex(getBounds(id)[1]); | |
ct.setText(ct.getText() + id.getText());} | |
)* | |
{ | |
if (!ct.getText().equals("<missing Identifier>")) ref = StatementFactory.createComponentReference(ct);} | |
; | |
dottedComponentDeclaration returns [ComponentDeclaration ref = null ] | |
@init {CommonToken ct = null;} | |
: | |
id = Identifier { | |
ct = new CommonToken(id); | |
ref = StatementFactory.createComponentDeclaration(ct); | |
} | |
( | |
{(input.get(id.getTokenIndex()+1).getChannel() != Token.HIDDEN_CHANNEL)}? | |
dot = (DOT | MINUS) {ct.setText(ct.getText() + dot.getText());ref = StatementFactory.createComponentDeclaration(ct);} | |
{(input.get(dot.getTokenIndex()+1).getChannel() != Token.HIDDEN_CHANNEL)}? | |
id = Identifier {ct.setStopIndex(getBounds(id)[1]); | |
ct.setText(ct.getText() + id.getText()); | |
ref = StatementFactory.createComponentDeclaration(ct);} | |
)* | |
{ | |
if (!ct.getText().equals("<missing Identifier>")) ref = StatementFactory.createComponentDeclaration(ct);} | |
; | |
//seems OK | |
annotationType returns [VariableReference at = null] | |
: | |
( | |
atRef = annotationTypeVariableReference {at = atRef;} | |
) | |
; | |
annotationTypeVariableReference returns [VariableReference typeVar = null] | |
: | |
atRef = dottedId | |
{typeVar = ExpressionFactory.createAnnotationTypeVariableReference(atRef);} | |
; | |
wordListExpression returns [Expression expr = null] | |
: | |
id = Identifier | |
{expr = ExpressionFactory.createListVariableReference(id);} | |
| | |
path = RessourceLiteral | |
{expr = ExpressionFactory.createRessourceReference(path);} | |
; | |
wordListOrStringExpression returns [Expression expr = null] | |
: | |
(stringExpression)=>id = stringExpression | |
{expr = ExpressionFactory.createListVariableReference(id);} | |
| | |
e = wordListExpression | |
{expr = e;} | |
; | |
wordTableExpression returns [Expression expr = null] | |
: | |
id = Identifier | |
{expr = ExpressionFactory.createTableVariableReference(id);} | |
| | |
path = RessourceLiteral | |
{expr = ExpressionFactory.createRessourceReference(path);} | |
; | |
wordTableOrStringExpression returns [Expression expr = null] | |
: | |
(stringExpression)=>id = stringExpression | |
{expr = ExpressionFactory.createTableVariableReference(id);} | |
| | |
e = wordTableExpression | |
{expr = e;} | |
; | |
//seems OK | |
numberExpression returns [Expression expr = null] | |
@init { | |
expr = ExpressionFactory.createEmptyNumberExpression(input.LT(1)); | |
} | |
: | |
e = additiveExpression | |
{if(e!=null) expr = ExpressionFactory.createNumberExpression(e);} | |
; | |
//seems OK | |
additiveExpression returns [Expression root = null] | |
: expr1=multiplicativeExpression {root=expr1;} | |
((PLUS | MINUS)=> op=(PLUS | MINUS) expr2=multiplicativeExpression {root=ExpressionFactory.createBinaryArithmeticExpr(root,expr2,op);})* | |
; | |
//NOT OK TODO | |
multiplicativeExpression returns [Expression root = null] | |
: | |
((simpleNumberExpression)=> expr1 = simpleNumberExpression {root=expr1;} | |
( ( STAR | SLASH | PERCENT )=> op=( STAR | SLASH | PERCENT ) sNE = simpleNumberExpression {root=ExpressionFactory.createBinaryArithmeticExpr(root,sNE,op);} )* | |
| e1 = numberFunction {root = e1;}) | |
; | |
//seems OK | |
numberExpressionInPar returns [RutaExpression expr = null] | |
: | |
lp = LPAREN numE = numberExpression rp = RPAREN | |
{expr = ExpressionFactory.createNumberExpression((RutaExpression)numE); | |
expr.setInParantheses(true); | |
expr.setStart(((CommonToken) lp).getStartIndex()); | |
expr.setEnd(((CommonToken) rp).getStopIndex()+1);} | |
; | |
//seems OK | |
simpleNumberExpression returns [Expression expr = null] | |
: | |
(featureExpression)=> fe = featureExpression {expr = ExpressionFactory.createNumberExpression(fe);} | |
| | |
m = MINUS? numVarRef = numberVariable | |
{if(m == null) {expr = numVarRef;} else {expr = ExpressionFactory.createNegatedNumberExpression(m, numVarRef);}} | |
| (m = MINUS)? decLit = DecimalLiteral | |
{expr = ExpressionFactory.createDecimalLiteral(decLit,m);} | |
| m = MINUS? fpLit = FloatingPointLiteral | |
{expr = ExpressionFactory.createFloatingPointLiteral(fpLit,m);} | |
| numExprPar = numberExpressionInPar | |
{expr = numExprPar;} | |
; | |
// not checked | |
numberFunction returns [Expression expr = null] | |
: | |
(op=(EXP | LOGN | SIN | COS | TAN) numExprP=numberExpressionInPar) | |
{expr = ExpressionFactory.createUnaryArithmeticExpr(numExprP,op);} | |
| op = POW LPAREN n1 = numberExpression COMMA n2 = numberExpression RPAREN | |
{expr = ExpressionFactory.createBinaryArithmeticExpr(n1, n2, op);} | |
//| {root = ExpressionFactory.createNumberFunction(numExprP,op)} | |
| (e = externalNumberFunction)=> e = externalNumberFunction {expr = e;} | |
; | |
// not checked | |
externalNumberFunction returns [Expression expr = null] | |
: | |
id = Identifier | |
LPAREN | |
args = varArgumentList? | |
RPAREN | |
{ | |
expr = external.createExternalNumberFunction(id, args); | |
} | |
; | |
//OK | |
numberVariable returns [Expression expr = null] | |
: | |
( {isVariableOfType(input.LT(1).getText(), "INT")}? numVarRef = Identifier // | |
| {isVariableOfType(input.LT(1).getText(), "DOUBLE")}? numVarRef = Identifier | |
| {isVariableOfType(input.LT(1).getText(), "FLOAT")}? numVarRef = Identifier) | |
{ expr = ExpressionFactory.createNumberVariableReference(numVarRef);} | |
; | |
catch [Exception e]{expr = ExpressionFactory.createNumberVariableReference(input.LT(1));} | |
//OK - interface to flag stringExpressions? | |
stringExpression returns [Expression expr = null] | |
@init { | |
List<Expression> exprList = new ArrayList<Expression>(); | |
{expr = ExpressionFactory.createEmptyStringExpression(input.LT(1));} | |
} | |
: | |
(featureExpression)=> fe = featureExpression {expr = ExpressionFactory.createStringExpression(fe);} | |
| | |
(stringFunction)=> e = stringFunction {expr = e;} | |
| | |
strExpr1 = simpleStringExpression {if (strExpr1!=null) exprList.add(strExpr1);} | |
((PLUS)=> PLUS (nextstrExpr = simpleStringExpression {if (nextstrExpr!=null) exprList.add(nextstrExpr);} | |
| ne = numberExpressionInPar {if (ne!=null) exprList.add(ne);} | |
| be = simpleBooleanExpression {if (be!=null) exprList.add(be);} | |
| (listExpression)=> le = listExpression {if (le!=null) exprList.add(le);} | |
| te = typeExpression {if (te!=null) exprList.add(te);} | |
))* | |
{expr = ExpressionFactory.createStringExpression(exprList);} | |
; | |
// not checked | |
stringFunction returns [Expression expr = null] | |
@init {List<Expression> list = new ArrayList<Expression>();} | |
: | |
name = REMOVESTRING LPAREN var = variable (COMMA s = stringExpression{list.add(s);})+ RPAREN | |
{expr = ExpressionFactory.createStringFunction(name,var,list);} | |
| | |
(e = externalStringFunction)=> e = externalStringFunction {expr = e;} | |
; | |
// not checked | |
externalStringFunction returns [Expression expr = null] | |
: | |
id = Identifier | |
LPAREN | |
args = varArgumentList? | |
RPAREN | |
{ | |
expr = external.createExternalStringFunction(id, args); | |
} | |
; | |
//OK - interface to flag stringExpressions? | |
simpleStringExpression returns [Expression expr = null] | |
: | |
lit = StringLiteral {expr = ExpressionFactory.createSimpleString(lit);} | |
| {isVariableOfType(input.LT(1).getText(), "STRING")}? variableId = Identifier {expr = ExpressionFactory.createStringVariableReference(variableId);} | |
; /*{isVariableOfType(input.LT(1).getText(), "STRING")}?*/ | |
// commented thu, 19.02.09 => rewritten 'stringExpression' | |
//simpleStringExpressionOrNumberExpression returns [Expression expr = null] | |
// : StringLiteral | |
// | {isVariableOfType(input.LT(1).getText(), "STRING")}? id = Identifier | |
// | e = numberExpressionInPar {} | |
// ; | |
//OK - interface to flag booleanExpressions? | |
booleanExpression returns [Expression expr = null] | |
@init{ | |
expr = ExpressionFactory.createEmptyBooleanExpression(input.LT(1)); | |
} | |
: | |
(featureTypeExpression)=>fmbe = featureTypeExpression {expr = ExpressionFactory.createBooleanExpression(fmbe);} | |
| (featureExpression)=> fe = featureExpression {expr = ExpressionFactory.createBooleanExpression(fe);} | |
| (composedBooleanExpression)=> bcE = composedBooleanExpression {expr = bcE;} | |
| sbE = simpleBooleanExpression {expr = sbE;} | |
; | |
simpleBooleanExpression returns [Expression expr = null] | |
: | |
(lbE = literalBooleanExpression {expr = lbE;} | |
| {isVariableOfType(input.LT(1).getText(), "BOOLEAN")}?(variableId = Identifier | |
{expr = ExpressionFactory.createBooleanVariableReference(variableId);}) | |
) | |
{expr = ExpressionFactory.createBooleanExpression(expr);} | |
; | |
// not checked | |
composedBooleanExpression returns [Expression expr = null] | |
: | |
(e2 = booleanCompare)=> e2 = booleanCompare {expr = e2;} | |
| (bne = booleanNumberExpression)=> bne = booleanNumberExpression{expr = bne;} | |
| (bse = booleanStringExpression)=> bse = booleanStringExpression{expr = bse;} | |
| (bte = booleanTypeExpression)=> bte = booleanTypeExpression{expr = bte;} | |
| e1 = booleanFunction {expr = e1;} | |
| LPAREN ep = booleanExpression RPAREN {expr = ep;} | |
; | |
// not checked | |
booleanFunction returns [Expression expr = null] | |
: | |
(op = XOR LPAREN e1 = booleanExpression COMMA e2 = booleanExpression RPAREN) | |
{expr = ExpressionFactory.createBooleanFunction(op,e1,e2);} | |
| (e = externalBooleanFunction)=> e = externalBooleanFunction {expr = e;} | |
; | |
// not checked | |
externalBooleanFunction returns [Expression expr = null] | |
: | |
id = Identifier | |
LPAREN | |
args = varArgumentList? | |
RPAREN | |
{ | |
expr = external.createExternalBooleanFunction(id, args); | |
} | |
; | |
// not checked | |
booleanCompare returns [Expression expr = null] | |
: | |
(e1 = simpleBooleanExpression op = (EQUAL | NOTEQUAL) e2 = booleanExpression) | |
{expr = ExpressionFactory.createBooleanFunction(op,e1,e2);} | |
; | |
//OK | |
literalBooleanExpression returns [BooleanLiteral expr = null] | |
: | |
(value = TRUE | |
| value = FALSE) | |
{expr = ExpressionFactory.createSimpleBooleanExpression(value);} | |
; | |
//not checked | |
booleanTypeExpression returns [Expression expr = null] | |
: | |
e1 = typeExpression | |
op = (EQUAL | NOTEQUAL) | |
e2 = typeExpression | |
{expr = ExpressionFactory.createBooleanTypeExpression(e1,op,e2);} | |
; | |
// TODO requires numberExpression first! | |
//nearly OK | |
booleanNumberExpression returns [Expression expr = null] | |
: | |
//LPAREN | |
e1 = numberExpression | |
op = (LESS | GREATER | GREATEREQUAL | LESSEQUAL | EQUAL | NOTEQUAL) | |
e2 = numberExpression | |
//RPAREN | |
{expr = ExpressionFactory.createBooleanNumberExpression(e1,op,e2);} | |
; | |
booleanStringExpression returns [Expression expr = null] | |
: | |
//LPAREN | |
e1 = stringExpression | |
op = (EQUAL | NOTEQUAL) | |
e2 = stringExpression | |
//RPAREN | |
{expr = ExpressionFactory.createBooleanStringExpression(e1,op,e2);} | |
; | |
genericVariableReference returns[Expression varRef] | |
: | |
id=Identifier | |
{return ExpressionFactory.createGenericVariableReference(id);} | |
; | |
annotationExpression returns [Expression expr = null] | |
: | |
{isVariableOfType(input.LT(1).getText(), "ANNOTATION")}? | |
id = Identifier {expr = ExpressionFactory.createAnnotationTypeVariableReference(id);} | |
| | |
ale = annotationListExpression {expr = ale;} | |
| | |
aae = annotationAddressExpression {expr = aae;} | |
| | |
ale = annotationLabelExpression {expr = ale;} | |
; | |
annotationListExpression returns [Expression expr = null] | |
: | |
{isVariableOfType(input.LT(1).getText(), "ANNOTATIONLIST")}? | |
id = Identifier {expr = ExpressionFactory.createAnnotationTypeVariableReference(id);} | |
; | |
annotationAddressExpression returns [Expression expr = null] | |
: | |
ADDRESS_PREFIX address = DecimalLiteral {expr = ExpressionFactory.createAnnotationTypeVariableReference(address);} | |
; | |
annotationLabelExpression returns [Expression expr = null] | |
: | |
label = Identifier {expr = ExpressionFactory.createAnnotationTypeVariableReference(label);} | |
; | |