You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@uima.apache.org by jo...@apache.org on 2011/08/01 17:25:50 UTC
svn commit: r1152824 [12/21] - in
/uima/sandbox/trunk/TextMarker/org.apache.uima.tm.textmarker.engine/src/main/java/org/apache/uima/tm/textmarker:
./ action/ batch/ condition/ engine/ kernel/ kernel/constraint/
kernel/expression/ kernel/expression/bool...
Added: uima/sandbox/trunk/TextMarker/org.apache.uima.tm.textmarker.engine/src/main/java/org/apache/uima/tm/textmarker/parser/Copy of TextMarker.g
URL: http://svn.apache.org/viewvc/uima/sandbox/trunk/TextMarker/org.apache.uima.tm.textmarker.engine/src/main/java/org/apache/uima/tm/textmarker/parser/Copy%20of%20TextMarker.g?rev=1152824&view=auto
==============================================================================
--- uima/sandbox/trunk/TextMarker/org.apache.uima.tm.textmarker.engine/src/main/java/org/apache/uima/tm/textmarker/parser/Copy of TextMarker.g (added)
+++ uima/sandbox/trunk/TextMarker/org.apache.uima.tm.textmarker.engine/src/main/java/org/apache/uima/tm/textmarker/parser/Copy of TextMarker.g Mon Aug 1 15:24:44 2011
@@ -0,0 +1,1772 @@
+grammar TextMarker;
+
+options {
+ language = Java;
+}
+
+tokens {
+ DocComment;
+ Annotation;
+ ListIdentifier;
+}
+
+@lexer::header {
+ package org.apache.uima.tm.textmarker.parser;
+}
+
+@parser::header {
+package org.apache.uima.tm.textmarker.parser;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+
+import org.antlr.runtime.BaseRecognizer;
+import org.antlr.runtime.BitSet;
+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.apache.uima.cas.CAS;
+import org.apache.uima.cas.CASException;
+import org.apache.uima.cas.Type;
+import org.apache.uima.jcas.tcas.DocumentAnnotation;
+
+import org.apache.uima.tm.textmarker.action.AbstractTextMarkerAction;
+import org.apache.uima.tm.textmarker.action.ActionFactory;
+import org.apache.uima.tm.textmarker.condition.AbstractTextMarkerCondition;
+import org.apache.uima.tm.textmarker.condition.ConditionFactory;
+import org.apache.uima.tm.textmarker.kernel.TextMarkerBlock;
+import org.apache.uima.tm.textmarker.kernel.TextMarkerModule;
+import org.apache.uima.tm.textmarker.kernel.TextMarkerScriptBlock;
+import org.apache.uima.tm.textmarker.kernel.TextMarkerScriptFactory;
+import org.apache.uima.tm.textmarker.kernel.TextMarkerStatement;
+import org.apache.uima.tm.textmarker.kernel.expression.bool.BooleanExpression;
+import org.apache.uima.tm.textmarker.kernel.expression.ExpressionFactory;
+import org.apache.uima.tm.textmarker.kernel.expression.resource.WordListExpression;
+import org.apache.uima.tm.textmarker.kernel.expression.number.NumberExpression;
+import org.apache.uima.tm.textmarker.kernel.expression.string.StringExpression;
+import org.apache.uima.tm.textmarker.kernel.expression.resource.WordTableExpression;
+import org.apache.uima.tm.textmarker.kernel.expression.TextMarkerExpression;
+import org.apache.uima.tm.textmarker.kernel.expression.type.TypeExpression;
+import org.apache.uima.tm.textmarker.kernel.extensions.TextMarkerExternalFactory;
+import org.apache.uima.tm.textmarker.kernel.rule.ComposedRuleElement;
+import org.apache.uima.tm.textmarker.kernel.rule.RuleElement;
+import org.apache.uima.tm.textmarker.kernel.rule.TextMarkerRule;
+import org.apache.uima.tm.textmarker.kernel.rule.TextMarkerRuleElement;
+import org.apache.uima.tm.textmarker.kernel.rule.quantifier.RuleElementQuantifier;
+}
+@lexer::members {
+ public int implicitLineJoiningLevel = 0;
+ public int startPos=-1;
+ public void emitErrorMessage(String msg) {
+ }
+}
+@parser::members {
+private List vars = new ArrayList();
+private int level = 0;
+private TextMarkerScriptFactory factory = new TextMarkerScriptFactory();
+private TextMarkerExternalFactory external;
+
+
+public void setExternalFactory(TextMarkerExternalFactory factory) {
+ external = factory;
+}
+
+public void emitErrorMessage(String msg) {
+ System.out.println(msg);
+ }
+ public void reportError(RecognitionException e) {
+ System.out.println(e);
+ }
+
+ //public void addVariable(String var, IntStream input) throws NoViableAltException {
+ // if(!vars.contains(var)) {
+ // vars.add(var);
+ // } else {
+ // throw new NoViableAltException("already declared \"" + var + "\"", 3, 0, input);
+ // }
+ //}
+ public void addVariable(TextMarkerBlock parent, String name, String type) {
+ parent.getEnvironment().addVariable(name, type);
+ }
+
+ public boolean ownsVariable(TextMarkerBlock parent, String name) {
+ return parent.getEnvironment().ownsVariable(name);
+ }
+ public boolean isVariable(TextMarkerBlock parent, String name) {
+ return parent.getEnvironment().isVariable(name);
+ }
+
+ public void setValue(TextMarkerBlock parent, String name, Object value) {
+ if(value != null) {
+ parent.getEnvironment().setVariableValue(name, value);
+ }
+ }
+
+ public boolean ownsVariableOfType(TextMarkerBlock parent, String name, String type) {
+ return parent.getEnvironment().ownsVariableOfType(name,type);
+ }
+
+ public boolean isVariableOfType(TextMarkerBlock parent, String name, String type) {
+ return parent.getEnvironment().isVariableOfType(name,type);
+ }
+
+ public void addType(TextMarkerBlock parent, String type) {
+ }
+
+ public void addType(TextMarkerBlock parent, String name, String parentType, List featuresTypes, List featuresNames) {
+ }
+
+ public boolean isType(TextMarkerBlock parent, String type) {
+ return parent.getEnvironment().getType(type) != null || type.equals("Document");
+ }
+
+ 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(TextMarkerBlock parent, String descriptor) {
+ //parent.getEnvironment().addTypeSystem(descriptor);
+ }
+ public void addImportScript(TextMarkerBlock parent, String namespace) {
+ parent.getScript().addScript(namespace, null);
+ }
+ public void addImportEngine(TextMarkerBlock parent, String namespace) {
+ parent.getScript().addEngine(namespace, null);
+ }
+
+
+ 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 CAS cas;
+ private String baseDir;
+
+ public void setCAS(CAS cas) {
+ this.cas = cas;
+ }
+
+ public void setBaseDir(String baseDir) {
+ this.baseDir = baseDir;
+ }
+}
+
+@rulecatch {
+ catch (RecognitionException exception1) {
+ emitErrorMessage(exception1.toString());
+ }
+ catch (Throwable exception2) {
+ emitErrorMessage(exception2.toString());
+ }
+}
+
+
+file_input [String moduleName] returns [TextMarkerModule module]
+@init{
+TextMarkerScriptBlock rootBlock = null;
+List<TextMarkerStatement> stmts = new ArrayList<TextMarkerStatement>();
+}
+ :
+ p = packageDeclaration
+ {
+ rootBlock = factory.createRootScriptBlock(moduleName, p, cas);
+
+ try {
+ Type documentType = cas.getJCas().getCasType(DocumentAnnotation.type);
+ rootBlock.getEnvironment().addType("Document", documentType);
+ Type annotationType = cas.getJCas().getCasType(org.apache.uima.jcas.tcas.Annotation.type);
+ rootBlock.getEnvironment().addType("Annotation", annotationType);
+ rootBlock.getEnvironment().setBaseDir(baseDir);
+ } catch (CASException e) {
+ e.printStackTrace();
+ }
+ rootBlock.setElements(stmts);
+ module = new TextMarkerModule(rootBlock);
+ rootBlock.setScript(module);
+ }
+ {$blockDeclaration.push(new blockDeclaration_scope());$blockDeclaration::env = rootBlock;}
+
+ gs = globalStatements {stmts.addAll(gs);}
+ s = statements {stmts.addAll(s);}
+
+ EOF
+ ;
+
+packageDeclaration returns [String pack = ""]
+ : PackageString p = dottedIdentifier SEMI {pack = p;}
+ ;
+
+statements returns [List<TextMarkerStatement> stmts = new ArrayList<TextMarkerStatement>()]
+ :
+ (stmt = statement {{if(stmt != null) {stmts.add(stmt);}}})*
+ ;
+
+globalStatements returns [List<TextMarkerStatement> stmts = new ArrayList<TextMarkerStatement>()]
+ :
+ (morestmts = globalStatement {if(morestmts != null) {stmts.addAll(morestmts);}})*
+ ;
+
+globalStatement returns [List<TextMarkerStatement> stmts = new ArrayList<TextMarkerStatement>()]
+ :
+ stmtImport = importStatement {stmts.add(stmtImport);}
+ ;
+
+statement returns [TextMarkerStatement stmt = null]
+ :
+ ( stmtDecl = declaration {stmt = stmtDecl;}
+ | stmtVariable = variableDeclaration {stmt = stmtVariable;}
+ | stmtRule = simpleStatement {stmt = stmtRule;}
+ | stmtBlock = blockDeclaration {stmt = stmtBlock;}
+ )
+ ;
+
+variableDeclaration returns [TextMarkerStatement stmt = null]
+ :
+ type = IntString
+ {!ownsVariable($blockDeclaration::env, input.LT(1).getText())}? id = Identifier {addVariable($blockDeclaration::env, id.getText(), type.getText());}
+ (COMMA {!ownsVariable($blockDeclaration::env, input.LT(1).getText())}? id = Identifier {addVariable($blockDeclaration::env, id.getText(), type.getText());}
+ )*(ASSIGN_EQUAL value1 = numberExpression)? {setValue($blockDeclaration::env, id.getText(), value1);} SEMI
+ |
+ type = DoubleString
+ {!ownsVariable($blockDeclaration::env, input.LT(1).getText())}? id = Identifier {addVariable($blockDeclaration::env, id.getText(), type.getText());}
+ (COMMA {!ownsVariable($blockDeclaration::env, input.LT(1).getText())}? id = Identifier {addVariable($blockDeclaration::env, id.getText(), type.getText());}
+ )* (ASSIGN_EQUAL value2 = numberExpression)? {setValue($blockDeclaration::env, id.getText(), value2);} SEMI
+ |
+ type = StringString
+ {!ownsVariable($blockDeclaration::env, input.LT(1).getText())}? id = Identifier {addVariable($blockDeclaration::env, id.getText(), type.getText());}
+ (COMMA {!ownsVariable($blockDeclaration::env, input.LT(1).getText())}? id = Identifier {addVariable($blockDeclaration::env, id.getText(), type.getText());}
+ )* (ASSIGN_EQUAL value3 = stringExpression)? {setValue($blockDeclaration::env, id.getText(), value3);} SEMI
+ |
+ type = BooleanString
+ {!ownsVariable($blockDeclaration::env, input.LT(1).getText())}? id = Identifier {addVariable($blockDeclaration::env, id.getText(), type.getText());}
+ (COMMA {!ownsVariable($blockDeclaration::env, input.LT(1).getText())}? id = Identifier {addVariable($blockDeclaration::env, id.getText(), type.getText());}
+ )* (ASSIGN_EQUAL value4 = booleanExpression)? {setValue($blockDeclaration::env, id.getText(), value4);} SEMI
+ |
+ type = TypeString
+ {!ownsVariable($blockDeclaration::env, input.LT(1).getText())}? id = Identifier {addVariable($blockDeclaration::env, id.getText(), type.getText());}
+ (COMMA {!ownsVariable($blockDeclaration::env, input.LT(1).getText())}? id = Identifier {addVariable($blockDeclaration::env, id.getText(), type.getText());}
+ )* (ASSIGN_EQUAL value5 = annotationType)? {setValue($blockDeclaration::env, id.getText(), value5);} SEMI
+ | LIST
+ {!isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "LIST")}?
+ name = Identifier (ASSIGN_EQUAL list = listExpression)? SEMI {addVariable($blockDeclaration::env, name.getText(), "LIST");if(list != null){setValue($blockDeclaration::env, name.getText(), list);}}
+ | TABLE
+ {!isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "TABLE")}?
+ name = Identifier (ASSIGN_EQUAL table = tableExpression)? SEMI {addVariable($blockDeclaration::env, name.getText(), "TABLE");if(table != null){setValue($blockDeclaration::env, name.getText(), table);}}
+ |
+ stmt1 = conditionDeclaration {stmt = stmt1;}
+ |
+ stmt2 = actionDeclaration {stmt = stmt2;}
+ ;
+
+//TODO added rule
+conditionDeclaration returns [TextMarkerStatement stmt = null]
+ :
+ type = CONDITION id = Identifier ASSIGN_EQUAL LPAREN cons = conditions RPAREN SEMI
+ {addVariable($blockDeclaration::env, id.getText(), type.getText());
+ AbstractTextMarkerCondition condition = ConditionFactory.createConditionAnd(cons,$blockDeclaration::env);
+ setValue($blockDeclaration::env, id.getText(), condition);}
+ ;
+
+//TODO added rule
+actionDeclaration returns [TextMarkerStatement stmt = null]
+ :
+ type = ACTION id = Identifier ASSIGN_EQUAL LPAREN a = actions RPAREN SEMI
+ {addVariable($blockDeclaration::env, id.getText(), type.getText());
+ AbstractTextMarkerAction action = ActionFactory.createComposedAction(a,$blockDeclaration::env);
+ setValue($blockDeclaration::env, id.getText(), action);}
+ ;
+
+importStatement returns [TextMarkerStatement stmt = null]
+ :
+ TypeSystemString ts = dottedIdentifier2{addImportTypeSystem($blockDeclaration::env, ts);} SEMI
+ | ScriptString ns = dottedIdentifier2{addImportScript($blockDeclaration::env, ns);} SEMI
+ | EngineString ns = dottedIdentifier2{addImportEngine($blockDeclaration::env, ns);} SEMI
+ ;
+
+declaration returns [TextMarkerStatement stmt = null]
+@init {
+List featureTypes = new ArrayList();
+List featureNames = new ArrayList();
+}
+ :
+ (
+ DECLARE
+ //{!isType($blockDeclaration::env, input.LT(1).getText())}?
+ lazyParent = annotationType?
+ id = Identifier //{addType($blockDeclaration::env, id.getText(), lazyParent);}
+ (COMMA
+ //{!isType($blockDeclaration::env, input.LT(1).getText())}?
+ id = Identifier //{addType($blockDeclaration::env, id.getText(), lazyParent);}
+ )* SEMI
+ |
+ DECLARE type = annotationType newName = Identifier
+ (LPAREN
+ (
+ obj1 = annotationType{featureTypes.add(obj1.getText());}
+ | obj2 = StringString{featureTypes.add(obj2.getText());}
+ | obj3 = DoubleString{featureTypes.add(obj3.getText());}
+ | obj4 = IntString{featureTypes.add(obj4.getText());}
+ | obj5 = BooleanString{featureTypes.add(obj5.getText());}
+ )
+ fname = Identifier{featureNames.add(fname.getText());}
+ (
+ COMMA
+ (
+ obj1 = annotationType{featureTypes.add(obj1.getText());}
+ | obj2 = StringString{featureTypes.add(obj2.getText());}
+ | obj3 = DoubleString{featureTypes.add(obj3.getText());}
+ | obj4 = IntString{featureTypes.add(obj4.getText());}
+ | obj5 = BooleanString{featureTypes.add(obj5.getText());}
+ )
+ fname = Identifier{featureNames.add(fname.getText());})*
+ RPAREN) SEMI
+ {addType($blockDeclaration::env, newName.getText(), type.getText(), featureTypes, featureNames);}
+ )
+ ;
+
+
+blockDeclaration returns [TextMarkerBlock block = null]
+options {
+ backtrack = true;
+}
+
+scope {
+ TextMarkerBlock env;
+}
+@init{
+TextMarkerRuleElement re = null;
+level++;
+}
+@after {
+level--;
+}
+
+ :
+ type = BlockString
+ LPAREN
+ id = Identifier
+ RPAREN
+ {block = factory.createScriptBlock(id, re, body, $blockDeclaration[level - 1]::env, cas);}
+ {$blockDeclaration::env = block;}
+ re1 = ruleElementWithCA {re = re1;}
+ {TextMarkerRule rule = factory.createRule(re, block);
+ if(block instanceof TextMarkerScriptBlock) {
+ ((TextMarkerScriptBlock)block).setMatchRule(rule);
+ }}
+ LCURLY body = statements RCURLY
+ {block.setElements(body);
+ $blockDeclaration::env.getScript().addBlock(id.getText(),block);
+ }
+ ;
+
+ruleElementWithCA returns [TextMarkerRuleElement re = null]
+ :
+ idRef=typeExpression quantifier = quantifierPart?
+ LCURLY c = conditions? (THEN a = actions)? RCURLY
+ {re = factory.createRuleElement(idRef,quantifier,c,a, $blockDeclaration::env);}
+ ;
+
+
+ruleElementWithoutCA returns [TextMarkerRuleElement re = null]
+ :
+ idRef=typeExpression quantifier = quantifierPart?
+ {re = factory.createRuleElement(idRef,quantifier,null,null, $blockDeclaration::env);}
+
+ ;
+
+simpleStatement returns [TextMarkerRule stmt = null]
+ :
+ elements = ruleElements SEMI
+ {stmt = factory.createRule(elements, $blockDeclaration::env);}
+ ;
+
+ruleElements returns [List<RuleElement> elements = new ArrayList<RuleElement>()]
+ :
+ re = ruleElement {elements.add(re);} (re = ruleElement {elements.add(re);})*
+ ;
+
+blockRuleElement returns [List<RuleElement> elements = new ArrayList<RuleElement>()]
+ :
+ re = ruleElementType {elements.add(re);}
+ ;
+
+
+ruleElement returns [RuleElement re = null]
+ :
+ re1 = ruleElementType {re = re1;}
+ | re2 = ruleElementLiteral {re = re2;}
+ | re3 = ruleElementComposed {re = re3;}
+ ;
+
+ruleElementComposed returns [ComposedRuleElement re = null]
+ :
+ LPAREN res = ruleElements RPAREN q = quantifierPart
+ {re = factory.createComposedRuleElement(res, q, $blockDeclaration::env);}
+ ;
+
+ruleElementType returns [TextMarkerRuleElement re = null]
+ :
+
+ (typeExpression)=>typeExpr = typeExpression quantifier = quantifierPart?
+ (LCURLY c = conditions? (THEN a = actions)? RCURLY)?
+ {re = factory.createRuleElement(typeExpr, quantifier, c, a, $blockDeclaration::env);}
+ ;
+
+ruleElementLiteral returns [TextMarkerRuleElement re = null]
+ :
+ (simpleStringExpression)=>stringExpr = simpleStringExpression quantifier = quantifierPart?
+ (LCURLY c = conditions? (THEN a = actions)? RCURLY)?
+ {re = factory.createRuleElement(stringExpr, quantifier, c, a, $blockDeclaration::env);}
+ ;
+
+conditions returns [List<AbstractTextMarkerCondition> conds = new ArrayList<AbstractTextMarkerCondition>()]
+ :
+ c = condition {conds.add(c);} (COMMA c = condition {conds.add(c);} )*
+ ;
+
+actions returns [List<AbstractTextMarkerAction> actions = new ArrayList<AbstractTextMarkerAction>()]
+ :
+ a = action {actions.add(a);} (COMMA a = action {actions.add(a);} )*
+ ;
+
+typeExpression returns [TypeExpression type = null]
+options {
+ backtrack = true;
+}
+ :
+ tf = typeFunction {type = tf;}
+ | st = simpleTypeExpression {type = st;}
+ ;
+
+
+// not checked
+typeFunction returns [TypeExpression expr = null]
+ :
+ (e = externalTypeFunction)=> e = externalTypeFunction {expr = e;}
+ ;
+
+// not checked
+externalTypeFunction returns [TypeExpression expr = null]
+ :
+ //{isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "TYPEFUNCTION")}?
+ id = Identifier LPAREN
+ args = varArgumentList RPAREN
+ {
+ expr = external.createExternalTypeFunction(id, args);
+ }
+ ;
+
+simpleTypeExpression returns [TypeExpression type = null]
+ :
+ {isVariableOfType($blockDeclaration::env,input.LT(1).getText(), "TYPE")}? var = Identifier
+ {type = ExpressionFactory.createReferenceTypeExpression(var);}
+ |
+ at = annotationType
+ {type = ExpressionFactory.createSimpleTypeExpression(at, $blockDeclaration::env);}
+
+
+ ;
+
+//typeExpressionOr returns [TypeExpression type = null]
+//@init {List<TypeExpression> exprs = new ArrayList<TypeExpression>();}
+// :
+// LBRACK e = typeExpressionAnd{exprs.add(e);} ( COMMA e = typeExpressionAnd{exprs.add(e);} )* RBRACK
+// {type = ExpressionFactory.createOrTypeExpression(exprs);}
+// ;
+
+//typeExpressionAnd returns [TypeExpression type = null]
+//@init {List<TypeExpression> exprs = new ArrayList<TypeExpression>();}
+// :
+// LBRACK e = simpleTypeExpression{exprs.add(e);} ( SEMI e = simpleTypeExpression{exprs.add(e);} )* RBRACK
+// {type = ExpressionFactory.createAndTypeExpression(exprs);}
+// ;
+
+quantifierPart returns [RuleElementQuantifier quantifier = null]
+ :
+ STAR q = QUESTION?
+ {if(q != null) {quantifier = TextMarkerScriptFactory.createStarReluctantQuantifier();}
+ else{quantifier = TextMarkerScriptFactory.createStarGreedyQuantifier();}}
+ | PLUS q = QUESTION?
+ {if(q != null) {quantifier = TextMarkerScriptFactory.createPlusReluctantQuantifier();}
+ else {quantifier = TextMarkerScriptFactory.createPlusGreedyQuantifier();}}
+ | QUESTION q = QUESTION?
+ {if(q != null) {quantifier = TextMarkerScriptFactory.createQuestionReluctantQuantifier();}
+ else {quantifier = TextMarkerScriptFactory.createQuestionGreedyQuantifier();}}
+ | LBRACK min = numberExpression (comma = COMMA (max = numberExpression)?)? RBRACK q = QUESTION?
+ {if(q != null) {quantifier = TextMarkerScriptFactory.createMinMaxReluctantQuantifier(min,max,comma);}
+ else {quantifier = TextMarkerScriptFactory.createMinMaxGreedyQuantifier(min,max,comma);}}
+ ;
+
+
+condition returns [AbstractTextMarkerCondition result = null]
+ :
+ (
+ c = conditionAnd
+ | c = conditionContains
+ | c = conditionContextCount
+ | c = conditionCount
+ | c = conditionCurrentCount
+ | c = conditionInList
+ | c = conditionIsInTag
+ | 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 = externalCondition)=> c = externalCondition
+ | c = variableCondition
+ ) {result = c;}
+ ;
+
+
+variableCondition returns [AbstractTextMarkerCondition condition = null]
+ :
+
+ id = Identifier
+ {
+ condition = ConditionFactory.createConditionVariable(id);
+ }
+ ;
+
+externalCondition returns [AbstractTextMarkerCondition condition = null]
+ :
+
+ id = Identifier LPAREN args = varArgumentList RPAREN
+ {
+ condition = external.createExternalCondition(id, args);
+ }
+ ;
+
+conditionAnd returns [AbstractTextMarkerCondition cond = null]
+ :
+ AND LPAREN conds = conditions RPAREN
+ {cond = ConditionFactory.createConditionAnd(conds, $blockDeclaration::env);}
+ ;
+conditionContains returns [AbstractTextMarkerCondition cond = null]
+ :
+ CONTAINS LPAREN type = typeExpression (COMMA min = numberExpression COMMA max = numberExpression (COMMA percent = booleanExpression)?)? RPAREN
+ {cond = ConditionFactory.createConditionContains(type, min, max, percent, $blockDeclaration::env);}
+ ;
+conditionContextCount returns [AbstractTextMarkerCondition cond = null]
+ :
+ CONTEXTCOUNT LPAREN type = typeExpression (COMMA min = numberExpression COMMA max = numberExpression)?
+ (COMMA var = numberVariable)? RPAREN
+ {cond = ConditionFactory.createConditionContextCount(type, min, max, var, $blockDeclaration::env);}
+ ;
+conditionCount returns [AbstractTextMarkerCondition cond = null]
+ :
+ COUNT LPAREN type = typeExpression (COMMA min = numberExpression COMMA max = numberExpression)?
+ (COMMA var = numberVariable)? RPAREN
+ {cond = ConditionFactory.createConditionCount(type, min, max, var, $blockDeclaration::env);}
+ ;
+conditionTotalCount returns [AbstractTextMarkerCondition cond = null]
+ :
+ TOTALCOUNT LPAREN type = typeExpression (COMMA min = numberExpression COMMA max = numberExpression)?
+ (COMMA var = numberVariable)? RPAREN
+ {cond = ConditionFactory.createConditionTotalCount(type, min, max, var, $blockDeclaration::env);}
+ ;
+conditionCurrentCount returns [AbstractTextMarkerCondition cond = null]
+ :
+ CURRENTCOUNT LPAREN type = typeExpression (COMMA min = numberExpression COMMA max = numberExpression)?
+ (COMMA var = numberVariable)? RPAREN
+ {cond = ConditionFactory.createConditionCurrentCount(type, min, max, var, $blockDeclaration::env);}
+ ;
+conditionInList returns [AbstractTextMarkerCondition cond = null]
+ :
+ INLIST LPAREN wordList = listExpression (COMMA dist = numberExpression (COMMA rel = booleanExpression)?)? RPAREN
+ {cond = ConditionFactory.createConditionInList(wordList, dist, rel, $blockDeclaration::env);}
+ | INLIST LPAREN list = innerList (COMMA dist = numberExpression (COMMA rel = booleanExpression)?)? RPAREN
+ {cond = ConditionFactory.createConditionInList(list, dist, rel, $blockDeclaration::env);}
+ ;
+conditionIsInTag returns [AbstractTextMarkerCondition cond = null]
+@init {
+List<StringExpression> list1 = new ArrayList<StringExpression>();
+List<StringExpression> list2 = new ArrayList<StringExpression>();
+}
+ :
+ ISINTAG LPAREN id = stringExpression (COMMA id1 = stringExpression ASSIGN_EQUAL id2 = stringExpression {list1.add(id1);list2.add(id2);})* RPAREN
+ {cond = ConditionFactory.createConditionIsInTag(id, list1, list2, $blockDeclaration::env);}
+ ;
+
+conditionLast returns [AbstractTextMarkerCondition cond = null]
+ :
+ LAST LPAREN type = typeExpression RPAREN
+ {cond = ConditionFactory.createConditionLast(type, $blockDeclaration::env);}
+ ;
+
+
+conditionMofN returns [AbstractTextMarkerCondition cond = null]
+ :
+ MOFN LPAREN min = numberExpression COMMA max = numberExpression COMMA conds = conditions RPAREN
+ {cond = ConditionFactory.createConditionMOfN(conds, min, max, $blockDeclaration::env);}
+ ;
+
+conditionNear returns [AbstractTextMarkerCondition cond = null]
+ :
+ NEAR LPAREN type = typeExpression COMMA min = numberExpression COMMA max = numberExpression (COMMA direction = booleanExpression (COMMA filtered = booleanExpression)?)? RPAREN
+ {cond = ConditionFactory.createConditionNear(type, min, max, direction, filtered, $blockDeclaration::env);}
+ ;
+conditionNot returns [AbstractTextMarkerCondition cond = null]
+ :
+ ((MINUS c = condition) | (NOT LPAREN c = condition RPAREN))
+ {cond = ConditionFactory.createConditionNot(c, $blockDeclaration::env);}
+ ;
+conditionOr returns [AbstractTextMarkerCondition cond = null]
+ :
+ OR LPAREN conds = conditions RPAREN
+ {cond = ConditionFactory.createConditionOr(conds, $blockDeclaration::env);}
+ ;
+conditionPartOf returns [AbstractTextMarkerCondition cond = null]
+ :
+ PARTOF LPAREN type = typeExpression RPAREN
+ {cond = ConditionFactory.createConditionPartOf(type, $blockDeclaration::env);}
+ ;
+conditionPartOfNeq returns [AbstractTextMarkerCondition cond = null]
+ :
+ PARTOFNEQ LPAREN type = typeExpression RPAREN
+ {cond = ConditionFactory.createConditionPartOfNeq(type, $blockDeclaration::env);}
+ ;
+
+conditionPosition returns [AbstractTextMarkerCondition cond = null]
+ :
+ POSITION LPAREN type = typeExpression COMMA pos = numberExpression RPAREN
+ {cond = ConditionFactory.createConditionPosition(type, pos, $blockDeclaration::env);}
+ ;
+conditionRegExp returns [AbstractTextMarkerCondition cond = null]
+ :
+ REGEXP LPAREN pattern = stringExpression (COMMA caseSensitive = booleanExpression)? RPAREN
+ {cond = ConditionFactory.createConditionRegExp(pattern, caseSensitive, $blockDeclaration::env);}
+ ;
+
+conditionScore returns [AbstractTextMarkerCondition cond = null]
+ :
+ SCORE LPAREN min = numberExpression (COMMA max = numberExpression
+ (COMMA var = numberVariable)?)? RPAREN
+ {cond = ConditionFactory.createConditionScore(min, max, var, $blockDeclaration::env);}
+ ;
+
+
+conditionVote returns [AbstractTextMarkerCondition cond = null]
+ :
+ VOTE LPAREN type1 = typeExpression COMMA type2 = typeExpression RPAREN
+ {cond = ConditionFactory.createConditionVote(type1, type2, $blockDeclaration::env);}
+ ;
+
+conditionIf returns [AbstractTextMarkerCondition cond = null]
+ :
+ IF LPAREN e = booleanExpression RPAREN
+ {cond = ConditionFactory.createConditionIf(e, $blockDeclaration::env);}
+ ;
+
+conditionFeature returns [AbstractTextMarkerCondition cond = null]
+ :
+ FEATURE LPAREN se = stringExpression COMMA v = argument RPAREN
+ {cond = ConditionFactory.createConditionFeature(se, v, $blockDeclaration::env);}
+ ;
+
+conditionParse returns [AbstractTextMarkerCondition cond = null]
+ :
+ PARSE LPAREN {isVariable($blockDeclaration::env,input.LT(1).getText())}? id = Identifier RPAREN
+ {cond = ConditionFactory.createConditionParse(id, $blockDeclaration::env);}
+ ;
+
+conditionIs returns [AbstractTextMarkerCondition cond = null]
+ :
+ IS LPAREN type = typeExpression RPAREN
+ {cond = ConditionFactory.createConditionIs(type, $blockDeclaration::env);}
+ ;
+
+conditionBefore returns [AbstractTextMarkerCondition cond = null]
+ :
+ BEFORE LPAREN type = typeExpression RPAREN
+ {cond = ConditionFactory.createConditionBefore(type, $blockDeclaration::env);}
+ ;
+
+conditionAfter returns [AbstractTextMarkerCondition cond = null]
+ :
+ AFTER LPAREN type = typeExpression RPAREN
+ {cond = ConditionFactory.createConditionAfter(type, $blockDeclaration::env);}
+ ;
+
+conditionStartsWith returns [AbstractTextMarkerCondition cond = null]
+ :
+ STARTSWITH LPAREN type = typeExpression RPAREN
+ {cond = ConditionFactory.createConditionStartsWith(type, $blockDeclaration::env);}
+ ;
+
+conditionEndsWith returns [AbstractTextMarkerCondition cond = null]
+ :
+ ENDSWITH LPAREN type = typeExpression RPAREN
+ {cond = ConditionFactory.createConditionEndsWith(type, $blockDeclaration::env);}
+ ;
+
+action returns [AbstractTextMarkerAction result = null]
+ :
+ (
+ a = actionColor
+ | a = actionDel
+ | a = actionLog
+ | a = actionMark
+ | a = actionMarkScore
+ | a = actionMarkFast
+ | a = actionMarkLast
+ | a = actionReplace
+ | a = actionFilterMarkup
+ | a = actionFilterType
+ | a = actionRetainMarkup
+ | a = actionRetainType
+ | a = actionCreate
+ | a = actionFill
+ | a = actionCall
+ | a = actionAssign
+ | a = actionFeature
+ | a = actionUnmark
+ | a = actionTransfer
+ | a = actionMarkOnce
+ | a = actionTrie
+ | a = actionGather
+ | a = actionExec
+ | a = actionMarkTable
+ | (a = externalAction)=> a = externalAction
+ | a = variableAction
+ ) {result = a;}
+ ;
+
+variableAction returns [AbstractTextMarkerAction action = null]
+ :
+
+ id = Identifier
+ {
+ action = ActionFactory.createActionVariable(id);
+ }
+ ;
+
+
+externalAction returns [AbstractTextMarkerAction action = null]
+ :
+
+ id = Identifier LPAREN args = varArgumentList RPAREN
+ {
+ action = external.createExternalAction(id, args);
+ }
+ ;
+
+
+
+actionCreate returns [AbstractTextMarkerAction action = null]
+@init {
+ Map<StringExpression, TextMarkerExpression> map = new HashMap<StringExpression, TextMarkerExpression>();
+ List<NumberExpression> indexes = new ArrayList<NumberExpression>();
+}
+ :
+ name = CREATE LPAREN structure = typeExpression
+ (COMMA
+ (
+ (index = numberExpression)=>index = numberExpression {indexes.add(index);} ((COMMA index = numberExpression)=> (COMMA index = numberExpression) {indexes.add(index);})* COMMA)?
+ (fname = stringExpression ASSIGN_EQUAL obj1 = argument {map.put(fname,obj1);}
+ (COMMA fname = stringExpression ASSIGN_EQUAL obj1 = argument {map.put(fname,obj1);})*)?
+ )? RPAREN
+ {action = ActionFactory.createCreateAction(structure, map, indexes, $blockDeclaration::env);}
+ ;
+
+
+actionMarkTable returns [AbstractTextMarkerAction action = null]
+@init {
+ Map<StringExpression, NumberExpression> map = new HashMap<StringExpression, NumberExpression>();
+}
+ :
+ name = MARKTABLE LPAREN
+ structure = typeExpression COMMA
+ index = numberExpression COMMA
+ table = tableExpression
+ (COMMA
+ fname = stringExpression ASSIGN_EQUAL obj1 = numberExpression {map.put(fname,obj1);}
+ (COMMA fname = stringExpression ASSIGN_EQUAL obj1 = numberExpression {map.put(fname,obj1);})*
+ )? RPAREN
+ {action = ActionFactory.createMarkTableAction(structure, index, table, map, $blockDeclaration::env);}
+ ;
+
+actionGather returns [AbstractTextMarkerAction action = null]
+@init {
+ Map<StringExpression, NumberExpression> map = new HashMap<StringExpression, NumberExpression>();
+ List<NumberExpression> indexes = new ArrayList<NumberExpression>();
+}
+ :
+ name = GATHER LPAREN structure = typeExpression
+ (COMMA
+ ((index = numberExpression)=>index = numberExpression {indexes.add(index);} ((COMMA index = numberExpression)=>(COMMA index = numberExpression) {indexes.add(index);})* COMMA)?
+ (fname = stringExpression ASSIGN_EQUAL obj1 = numberExpression {map.put(fname,obj1);}
+ (COMMA fname = stringExpression ASSIGN_EQUAL obj1 = numberExpression {map.put(fname,obj1);})*)?
+ )? RPAREN
+ {action = ActionFactory.createGatherAction(structure, map, indexes, $blockDeclaration::env);}
+ ;
+
+
+
+actionFill returns [AbstractTextMarkerAction action = null]
+@init {
+Map<StringExpression, TextMarkerExpression> map = new HashMap<StringExpression, TextMarkerExpression>();
+}
+ :
+ FILL LPAREN type = typeExpression (COMMA fname = stringExpression ASSIGN_EQUAL
+ (
+ obj1 = argument{map.put(fname,obj1);}
+ )
+ )+ RPAREN
+ {action = ActionFactory.createFillAction(type, map, $blockDeclaration::env);}
+ ;
+
+actionColor returns [AbstractTextMarkerAction action = null]
+ :
+ COLOR LPAREN type = typeExpression COMMA color = stringExpression RPAREN
+ {action = ActionFactory.createColorAction(type, color, $blockDeclaration::env);}
+ ;
+
+actionDel returns [AbstractTextMarkerAction action = null]
+ :
+ DEL
+ {action = ActionFactory.createDelAction($blockDeclaration::env);}
+ ;
+
+actionLog returns [AbstractTextMarkerAction action = null]
+ :
+ LOG LPAREN lit = stringExpression (COMMA log = LogLevel)? RPAREN
+ {action = ActionFactory.createLogAction(lit, log, $blockDeclaration::env);}
+ ;
+
+actionMark returns [AbstractTextMarkerAction action = null]
+@init {
+List<NumberExpression> list = new ArrayList<NumberExpression>();
+}
+ :
+ MARK LPAREN
+ type = typeExpression
+ (
+ COMMA (index = numberExpression) => index = numberExpression
+ {list.add(index);}
+ )*
+ RPAREN
+
+ {action = ActionFactory.createMarkAction(null, type, list, $blockDeclaration::env);}
+ ;
+
+
+actionMarkScore returns [AbstractTextMarkerAction action = null]
+@init {
+List<NumberExpression> list = new ArrayList<NumberExpression>();
+}
+ :
+ MARKSCORE LPAREN
+ score = numberExpression COMMA
+ type = typeExpression
+ (
+ COMMA (index = numberExpression) => index = numberExpression
+ {list.add(index);}
+ )*
+ RPAREN
+
+ {action = ActionFactory.createMarkAction(score, type, list, $blockDeclaration::env);}
+ ;
+
+actionMarkOnce returns [AbstractTextMarkerAction action = null]
+@init {
+List<NumberExpression> list = new ArrayList<NumberExpression>();
+}
+ :
+ MARKONCE LPAREN ((score = numberExpression) => score = numberExpression COMMA)? (type = typeExpression) => type = typeExpression
+ (
+ COMMA (index = numberExpression) => index = numberExpression
+ {list.add(index);}
+ )* RPAREN
+
+ {action = ActionFactory.createMarkOnceAction(score, type, list, $blockDeclaration::env);}
+ ;
+
+actionMarkFast returns [AbstractTextMarkerAction action = null]
+ :
+ MARKFAST LPAREN type = typeExpression COMMA list = listExpression (COMMA ignore = booleanExpression (COMMA ignoreLength = numberExpression)?)? RPAREN
+ {action = ActionFactory.createMarkFastAction(type, list, ignore, ignoreLength, $blockDeclaration::env);}
+ ;
+
+actionMarkLast returns [AbstractTextMarkerAction action = null]
+ :
+ MARKLAST LPAREN type = typeExpression RPAREN
+ {action = ActionFactory.createMarkLastAction(type, $blockDeclaration::env);}
+ ;
+
+actionReplace returns [AbstractTextMarkerAction action = null]
+ :
+ REPLACE LPAREN lit = stringExpression RPAREN
+ {action = ActionFactory.createReplaceAction(lit, $blockDeclaration::env);}
+ ;
+
+actionRetainMarkup returns [AbstractTextMarkerAction action = null]
+@init {
+List<StringExpression> list = new ArrayList<StringExpression>();
+}
+ :
+ RETAINMARKUP (LPAREN id = stringExpression {list.add(id);} (COMMA id = stringExpression {list.add(id);})* RPAREN)?
+ {action = ActionFactory.createRetainMarkupAction(list, $blockDeclaration::env);}
+ ;
+
+
+actionRetainType returns [AbstractTextMarkerAction action = null]
+@init {
+List<TypeExpression> list = new ArrayList<TypeExpression>();
+}
+ :
+ RETAINTYPE (LPAREN id = typeExpression {list.add(id);} (COMMA id = typeExpression {list.add(id);})* RPAREN)?
+ {action = ActionFactory.createRetainTypeAction(list, $blockDeclaration::env);}
+ ;
+
+actionFilterMarkup returns [AbstractTextMarkerAction action = null]
+@init {
+List<StringExpression> list = new ArrayList<StringExpression>();
+}
+ :
+ FILTERMARKUP (LPAREN id = stringExpression {list.add(id);} (COMMA id = stringExpression {list.add(id);})* RPAREN)?
+ {action = ActionFactory.createFilterMarkupAction(list, $blockDeclaration::env);}
+ ;
+
+
+actionFilterType returns [AbstractTextMarkerAction action = null]
+@init {
+List<TypeExpression> list = new ArrayList<TypeExpression>();
+}
+ :
+ FILTERTYPE (LPAREN id = typeExpression {list.add(id);} (COMMA id = typeExpression {list.add(id);})* RPAREN)?
+ {action = ActionFactory.createFilterTypeAction(list, $blockDeclaration::env);}
+ ;
+
+actionCall returns [AbstractTextMarkerAction action = null]
+ :
+ CALL LPAREN ns = dottedIdentifier RPAREN
+ {action = ActionFactory.createCallAction(ns, $blockDeclaration::env);}
+ ;
+
+actionExec returns [AbstractTextMarkerAction action = null]
+ :
+ EXEC LPAREN ns = dottedIdentifier RPAREN
+ {action = ActionFactory.createExecAction(ns, $blockDeclaration::env);}
+ ;
+
+actionAssign returns [AbstractTextMarkerAction action = null]
+ :
+ name = ASSIGN LPAREN
+ (
+ {isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "TYPE")}?
+ nv = Identifier COMMA e1 = typeExpression
+ {action = ActionFactory.createAssignAction(nv, e1, $blockDeclaration::env);}
+ |
+ {isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "BOOLEAN")}?
+ nv = Identifier COMMA e2 = booleanExpression
+ {action = ActionFactory.createAssignAction(nv, e2, $blockDeclaration::env);}
+ |
+ {isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "STRING")}?
+ nv = Identifier COMMA e3 = stringExpression
+ {action = ActionFactory.createAssignAction(nv, e3, $blockDeclaration::env);}
+ |
+ {isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "INT")}?
+ nv = Identifier COMMA e4 = numberExpression
+ {action = ActionFactory.createAssignAction(nv, e4, $blockDeclaration::env);}
+ |
+ {isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "DOUBLE")}?
+ nv = Identifier COMMA e5 = numberExpression
+ {action = ActionFactory.createAssignAction(nv, e5, $blockDeclaration::env);}
+ ) RPAREN
+ ;
+
+actionFeature returns [AbstractTextMarkerAction action = null]
+ :
+ name = SETFEATURE LPAREN f = stringExpression COMMA v = argument RPAREN
+ {action = ActionFactory.createFeatureAction(f, v, $blockDeclaration::env);}
+ ;
+
+actionUnmark returns [AbstractTextMarkerAction action = null]
+ :
+ name = UNMARK LPAREN f = typeExpression RPAREN
+ {action = ActionFactory.createUnmarkAction(f, $blockDeclaration::env);}
+ ;
+
+actionTransfer returns [AbstractTextMarkerAction action = null]
+ :
+ name = TRANSFER LPAREN f = typeExpression RPAREN
+ {action = ActionFactory.createTransferAction(f, $blockDeclaration::env);}
+ ;
+
+actionTrie returns [AbstractTextMarkerAction action = null]
+@init {
+Map<StringExpression, TypeExpression> map = new HashMap<StringExpression, TypeExpression>();
+}
+ :
+ name = TRIE LPAREN
+ key = stringExpression ASSIGN_EQUAL value = typeExpression{map.put(key,value);}
+ (COMMA key = stringExpression ASSIGN_EQUAL value = typeExpression{map.put(key,value);} )*
+ COMMA list = listExpression
+ COMMA ignoreCase = booleanExpression
+ COMMA ignoreLength = numberExpression
+ COMMA edit = booleanExpression
+ COMMA distance = numberExpression
+ COMMA ignoreChar = stringExpression
+ RPAREN
+ //TODO cost parameter
+ {action = ActionFactory.createTrieAction(list, map, ignoreCase, ignoreLength, edit, distance, ignoreChar, $blockDeclaration::env);}
+ ;
+
+
+varArgumentList returns [List args = new ArrayList()]
+ :
+ (LPAREN arg = argument {args.add(arg);}(COMMA arg = argument {args.add(arg);})* RPAREN)?
+ ;
+
+argument returns [TextMarkerExpression expr = null]
+options {
+ backtrack = true;
+}
+ :
+ a4 = stringExpression {expr = a4;}
+ | a2 = booleanExpression {expr = a2;}
+ | a3 = numberExpression {expr = a3;}
+ | a1 = typeExpression {expr = a1;}
+
+ //(a2 = booleanExpression)=> a2 = booleanExpression {expr = a2;}
+ //| (a3 = numberExpression)=> a3 = numberExpression {expr = a3;}
+ //| (a4 = stringExpression)=> a4 = stringExpression {expr = a4;}
+ //| (a1 = typeExpression)=> a1 = typeExpression {expr = a1;}
+ ;
+
+innerList returns [List<String> result = new ArrayList<String>();]
+ :
+ LBRACK id = Identifier {result.add(id.getText());}
+
+ ('|' id = Identifier {result.add(id.getText());} )* RBRACK
+ |
+ LBRACK id = StringLiteral {result.add(id.getText());}
+
+ ('|' id = StringLiteral {result.add(id.getText());} )* RBRACK
+ ;
+
+
+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|'-') {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;}
+ ;
+
+annotationType returns [Token ref = null]
+ :
+ (
+ //{isType($blockDeclaration::env, input.LT(1).getText())}?
+ token = BasicAnnotationType {ref = token;}
+ |
+ did = dottedId {ref = did;}
+ )
+ ;
+
+listExpression returns [ListExpression expr = null]
+ :
+ id = Identifier
+ {expr = ExpressionFactory.createReferenceListExpression(id);}
+ |
+ path = RessourceLiteral
+ {expr = ExpressionFactory.createLiteralListExpression(path);}
+ ;
+
+
+tableExpression returns [TableExpression expr = null]
+ :
+ id = Identifier
+ {expr = ExpressionFactory.createReferenceTableExpression(id);}
+ |
+ path = RessourceLiteral
+ {expr = ExpressionFactory.createLiteralTableExpression(path);}
+ ;
+
+// not checked
+numberFunction returns [NumberExpression expr = null]
+ :
+ (op=(EXP | LOGN | SIN | COS | TAN) numExprP=numberExpressionInPar)
+ {expr = ExpressionFactory.createComposedNumberExpression(numExprP,op);}
+ //| {root = ExpressionFactory.createNumberFunction(numExprP,op)}
+ | (e = externalNumberFunction)=> e = externalNumberFunction {expr = e;}
+ ;
+
+
+// not checked
+externalNumberFunction returns [NumberExpression expr = null]
+ :
+ //{isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "NUMBERFUNCTION")}?
+ id = Identifier LPAREN
+ args = varArgumentList RPAREN
+ {
+ expr = external.createExternalNumberFunction(id, args);
+ }
+ ;
+
+numberVariable returns [Token ref = null]
+ :
+ {isVariableOfType($blockDeclaration::env,input.LT(1).getText(), "INT")}? token1 = Identifier {ref = token1;}
+ |{isVariableOfType($blockDeclaration::env,input.LT(1).getText(), "DOUBLE")}? token2 = Identifier {ref = token2;}
+ ;
+
+
+additiveExpression returns [NumberExpression expr = null]
+@init{List<NumberExpression> exprs = new ArrayList<NumberExpression>();
+ List<Token> ops = new ArrayList<Token>();}
+ :
+ e = multiplicativeExpression{exprs.add(e);} ( op = (PLUS | MINUS){ops.add(op);} e = multiplicativeExpression{exprs.add(e);} )*
+ {expr = ExpressionFactory.createComposedNumberExpression(exprs,ops);}
+ ;
+
+multiplicativeExpression returns [NumberExpression expr = null]
+@init{List<NumberExpression> exprs = new ArrayList<NumberExpression>();
+ List<Token> ops = new ArrayList<Token>();}
+ :
+ (e = simpleNumberExpression{exprs.add(e);} ( op = ( STAR | SLASH | PERCENT ){ops.add(op);} e = simpleNumberExpression{exprs.add(e);} )*
+ {expr = ExpressionFactory.createComposedNumberExpression(exprs,ops);}
+ | e1 = numberFunction {expr = e1;})
+ ;
+
+numberExpression returns [NumberExpression expr = null]
+ :
+ e = additiveExpression {expr = e;}
+ ;
+
+numberExpressionInPar returns [NumberExpression expr = null]
+ :
+ LPAREN e = additiveExpression RPAREN {expr = e;}
+ ;
+
+simpleNumberExpression returns [NumberExpression expr = null]
+ :
+ m = MINUS? lit = DecimalLiteral {expr = ExpressionFactory.createIntegerExpression(lit,m);}
+ | m = MINUS? lit = FloatingPointLiteral {expr = ExpressionFactory.createDoubleExpression(lit,m);}
+ | m = MINUS? var = numberVariable {expr = ExpressionFactory.createReferenceNumberExpression(var,m);}
+ | e = numberExpressionInPar {expr = e;}
+ ;
+
+stringExpression returns [StringExpression expr = null]
+options {
+ backtrack = true;
+}
+@init {
+List<StringExpression> exprs = new ArrayList<StringExpression>();
+}
+ :
+ e = simpleStringExpression {exprs.add(e);}
+ (PLUS (e1 = simpleStringExpression {exprs.add(e1);}
+ | e2 = numberExpressionInPar {exprs.add(e2);}
+ | be = simpleBooleanExpression {exprs.add(be);}
+ | te = typeExpression {exprs.add(te);}
+ ))*
+ {expr = ExpressionFactory.createComposedStringExpression(exprs);}
+ |(e = stringFunction)=> e = stringFunction{expr = e;}
+ ;
+
+// not checked
+stringFunction returns [StringExpression expr = null]
+ :
+ (e = externalStringFunction)=> e = externalStringFunction {expr = e;}
+ ;
+
+// not checked
+externalStringFunction returns [StringExpression expr = null]
+ :
+ //{isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "STRINGFUNCTION")}?
+ id = Identifier LPAREN
+ args = varArgumentList RPAREN
+ {
+ expr = external.createExternalStringFunction(id, args);
+ }
+ ;
+
+simpleStringExpression returns [StringExpression expr = null]
+ :
+ lit = StringLiteral {expr = ExpressionFactory.createSimpleStringExpression(lit);}
+ | {isVariableOfType($blockDeclaration::env,input.LT(1).getText(), "STRING")}? id = Identifier {expr = ExpressionFactory.createReferenceStringExpression(id);}
+ ;
+
+
+booleanExpression returns [BooleanExpression expr = null]
+ :
+ (e = composedBooleanExpression)=> e = composedBooleanExpression {expr = e;}
+ |sbE = simpleBooleanExpression {expr = sbE;}
+ ;
+
+simpleBooleanExpression returns [BooleanExpression expr = null]
+ :
+ e = literalBooleanExpression {expr = e;}
+ | {isVariableOfType($blockDeclaration::env,input.LT(1).getText(), "BOOLEAN")}?
+ id = Identifier {expr = ExpressionFactory.createReferenceBooleanExpression(id);}
+ ;
+
+// not checked
+composedBooleanExpression returns [BooleanExpression expr = null]
+
+ :
+ (e2 = booleanCompare)=> e2 = booleanCompare {expr = e2;}
+ | (bte = booleanTypeExpression)=> bte = booleanTypeExpression{expr = bte;}
+ | (bne = booleanNumberExpression)=> bne = booleanNumberExpression{expr = bne;}
+ | e1 = booleanFunction {expr = e1;}
+ ;
+
+// not checked
+booleanFunction returns [BooleanExpression 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 [BooleanExpression expr = null]
+ :
+ //{isVariableOfType($blockDeclaration::env, input.LT(1).getText(), "BOOLEANFUNCTION")}?
+ id = Identifier LPAREN
+ args = varArgumentList RPAREN
+ {
+ expr = external.createExternalBooleanFunction(id, args);
+ }
+ ;
+
+// not checked
+booleanCompare returns [BooleanExpression expr = null]
+ :
+ (e1 = simpleBooleanExpression op = (EQUAL | NOTEQUAL) e2 = booleanExpression)
+ {expr = ExpressionFactory.createBooleanFunction(op,e1,e2);}
+ ;
+
+
+literalBooleanExpression returns [BooleanExpression expr = null]
+ :
+ v = TRUE {expr = ExpressionFactory.createSimpleBooleanExpression(v);}
+ | v = FALSE {expr = ExpressionFactory.createSimpleBooleanExpression(v);}
+ ;
+
+
+
+booleanTypeExpression returns [BooleanExpression expr = null]
+ :
+ e1 = typeExpression
+ op = (EQUAL | NOTEQUAL)
+ e2 = typeExpression
+ {expr = ExpressionFactory.createBooleanTypeExpression(e1,op,e2);}
+ ;
+
+booleanNumberExpression returns [BooleanExpression expr = null]
+ :
+ LPAREN
+ e1 = numberExpression//{exprs.add(e);}
+ op = (LESS | GREATER | GREATEREQUAL | LESSEQUAL | EQUAL | NOTEQUAL)//{ops.add(op);}
+ e2 = numberExpression//{exprs.add(e);}
+ RPAREN
+ {expr = ExpressionFactory.createBooleanNumberExpression(e1,op,e2);}
+ ;
+
+// Lexer
+
+
+TRIE
+ : 'TRIE'
+ ;
+
+CONTAINS
+ : 'CONTAINS'
+ ;
+
+DECLARE
+ : 'DECLARE'
+ ;
+
+LIST
+ : 'LIST'
+ ;
+
+TABLE
+ : 'TABLE'
+ ;
+
+AND
+ : 'AND'
+ ;
+
+CONTEXTCOUNT
+ : 'CONTEXTCOUNT'
+ ;
+
+COUNT
+ : 'COUNT'
+ ;
+
+TOTALCOUNT
+ : 'TOTALCOUNT'
+ ;
+
+CURRENTCOUNT
+ : 'CURRENTCOUNT'
+ ;
+
+INLIST
+ : 'INLIST'
+ ;
+
+ISINTAG
+ : 'ISINTAG'
+ ;
+
+LAST
+ : 'LAST'
+ ;
+
+MOFN
+ : 'MOFN'
+ ;
+
+NEAR
+ : 'NEAR'
+ ;
+
+OR
+ : 'OR'
+ ;
+
+PARTOF
+ : 'PARTOF'
+ ;
+
+PARTOFNEQ
+ : 'PARTOFNEQ'
+ ;
+
+POSITION
+ : 'POSITION'
+ ;
+
+REGEXP
+ : 'REGEXP'
+ ;
+
+SCORE
+ : 'SCORE'
+ ;
+
+VOTE
+ : 'VOTE'
+ ;
+
+IF
+ : 'IF'
+ ;
+
+FEATURE
+ : 'FEATURE'
+ ;
+
+PARSE
+ : 'PARSE'
+ ;
+
+CREATE
+ : 'CREATE'
+ ;
+
+GATHER
+ : 'GATHER'
+ ;
+
+FILL
+ : 'FILL'
+ ;
+
+ATTRIBUTE
+ : 'ATTRIBUTE'
+ ;
+
+COLOR
+ : 'COLOR'
+ ;
+
+DEL
+ : 'DEL'
+ ;
+
+LOG
+ : 'LOG'
+ ;
+
+MARK
+ : 'MARK'
+ ;
+
+MARKSCORE
+ : 'MARKSCORE'
+ ;
+
+MARKONCE
+ : 'MARKONCE'
+ ;
+
+MARKFAST
+ : 'MARKFAST'
+ ;
+
+MARKTABLE
+ : 'MARKTABLE'
+ ;
+
+MARKLAST
+ : 'MARKLAST'
+ ;
+
+REPLACE
+ : 'REPLACE'
+ ;
+
+RETAINMARKUP
+ : 'RETAINMARKUP'
+ ;
+
+RETAINTYPE
+ : 'RETAINTYPE'
+ ;
+
+FILTERMARKUP
+ : 'FILTERMARKUP'
+ ;
+
+FILTERTYPE
+ : 'FILTERTYPE'
+ ;
+
+CALL
+ : 'CALL'
+ ;
+
+
+EXEC
+ : 'EXEC'
+ ;
+
+ASSIGN
+ : 'ASSIGN'
+ ;
+
+SETFEATURE
+ : 'SETFEATURE'
+ ;
+
+UNMARK
+ : 'UNMARK'
+ ;
+
+
+TRANSFER
+ : 'TRANSFER'
+ ;
+
+BEFORE
+ : 'BEFORE'
+ ;
+
+AFTER
+ : 'AFTER'
+ ;
+
+IS
+ : 'IS'
+ ;
+
+
+STARTSWITH
+ : 'STARTSWITH'
+ ;
+
+ENDSWITH
+ : 'ENDSWITH'
+ ;
+
+NOT
+ : 'NOT'
+ ;
+
+THEN
+ : '->'
+ ;
+
+BasicAnnotationType
+ : 'COLON'| 'SW' | 'MARKUP' | 'PERIOD' | 'CW'| 'NUM' | 'QUESTION' | 'SPECIAL' | 'CAP' | 'COMMA' | 'EXCLAMATION' | 'SEMICOLON' | 'NBSP'| 'AMP' |
+ '_' | 'SENTENCEEND' | 'W' | 'PM' | 'ANY' | 'ALL' | 'SPACE' | 'BREAK'
+ ;
+
+LogLevel:
+ 'finest' | 'finer' | 'fine' | 'config' | 'info' | 'warning' | 'severe'
+ ;
+
+OldColor
+ : 'black' | 'maroon' | 'green' | 'olive' | 'navy' | 'purple' | 'teal' | 'gray' | 'silver' | 'red' | 'lime' | 'yellow' | 'blue' | 'fuchsia' | 'aqua'
+ ;
+
+PackageString : 'PACKAGE';
+ScriptString : 'SCRIPT';
+EngineString : 'ENGINE';
+BlockString : 'BLOCK';
+TypeString : 'TYPE';
+IntString : 'INT';
+DoubleString : 'DOUBLE';
+StringString : 'STRING';
+BooleanString : 'BOOLEAN';
+TypeSystemString: 'TYPESYSTEM';
+SymbolString : 'SYMBOL';
+CONDITION : 'CONDITION';
+ACTION : 'ACTION';
+
+EXP : 'EXP';
+LOGN : 'LOGN';
+SIN : 'SIN';
+COS : 'COS';
+TAN : 'TAN';
+XOR : 'XOR';
+TRUE : 'true';
+FALSE : 'false';
+
+HexLiteral : '0' ('x'|'X') HexDigit+ IntegerTypeSuffix? ;
+
+DecimalLiteral : ('0' | '1'..'9' '0'..'9'*) IntegerTypeSuffix? ;
+
+OctalLiteral : '0' ('0'..'7')+ IntegerTypeSuffix? ;
+
+fragment
+HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ;
+
+fragment
+IntegerTypeSuffix : ('l'|'L') ;
+
+FloatingPointLiteral
+ : ('0'..'9')+ '.' ('0'..'9')* Exponent? FloatTypeSuffix?
+ | '.' ('0'..'9')+ Exponent? FloatTypeSuffix?
+ //| ('0'..'9')+ Exponent FloatTypeSuffix?
+ //| ('0'..'9')+ Exponent? FloatTypeSuffix
+ ;
+
+fragment
+Exponent : ('e'|'E') ('+'|'-')? ('0'..'9')+ ;
+
+fragment
+FloatTypeSuffix : ('f'|'F'|'d'|'D') ;
+
+CharacterLiteral
+ : '\'' ( EscapeSequence | ~('\''|'\\') ) '\''
+ ;
+
+StringLiteral
+ : '"' ( EscapeSequence | ~('\\'|'"') )* '"'
+ ;
+
+RessourceLiteral
+ : '\'' ( EscapeSequence | ~('\\'|'\'') )* '\''
+ ;
+
+fragment
+EscapeSequence
+ : '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\')
+ | UnicodeEscape
+ | OctalEscape
+ ;
+
+fragment
+OctalEscape
+ : '\\' ('0'..'3') ('0'..'7') ('0'..'7')
+ | '\\' ('0'..'7') ('0'..'7')
+ | '\\' ('0'..'7')
+ ;
+
+fragment
+UnicodeEscape
+ : '\\' 'u' HexDigit HexDigit HexDigit HexDigit
+ ;
+
+
+Identifier
+ : Letter (Letter|JavaIDDigit)*
+ ;
+
+
+fragment
+Letter
+ : '\u0024' |
+ '\u0041'..'\u005a' |
+ '\u005f' |
+ '\u0061'..'\u007a' |
+ '\u00c0'..'\u00d6' |
+ '\u00d8'..'\u00f6' |
+ '\u00f8'..'\u00ff' |
+ '\u0100'..'\u1fff' |
+ '\u3040'..'\u318f' |
+ '\u3300'..'\u337f' |
+ '\u3400'..'\u3d2d' |
+ '\u4e00'..'\u9fff' |
+ '\uf900'..'\ufaff'
+ ;
+
+fragment
+JavaIDDigit
+ : '\u0030'..'\u0039' |
+ '\u0660'..'\u0669' |
+ '\u06f0'..'\u06f9' |
+ '\u0966'..'\u096f' |
+ '\u09e6'..'\u09ef' |
+ '\u0a66'..'\u0a6f' |
+ '\u0ae6'..'\u0aef' |
+ '\u0b66'..'\u0b6f' |
+ '\u0be7'..'\u0bef' |
+ '\u0c66'..'\u0c6f' |
+ '\u0ce6'..'\u0cef' |
+ '\u0d66'..'\u0d6f' |
+ '\u0e50'..'\u0e59' |
+ '\u0ed0'..'\u0ed9' |
+ '\u1040'..'\u1049'
+ ;
+
+
+
+LPAREN : '(' {implicitLineJoiningLevel++;} ;
+
+RPAREN : ')' {implicitLineJoiningLevel--;} ;
+
+LBRACK : '[' {implicitLineJoiningLevel++;} ;
+
+RBRACK : ']' {implicitLineJoiningLevel--;} ;
+
+LCURLY : '{' {implicitLineJoiningLevel++;} ;
+
+RCURLY : '}' {implicitLineJoiningLevel--;} ;
+
+CIRCUMFLEX : '^' ;
+
+AT : '@' ;
+
+DOT : '.' ;
+
+COLON : ':' ;
+
+COMMA : ',' ;
+
+SEMI : ';' ;
+
+PLUS : '+' ;
+
+MINUS : '-' ;
+
+STAR : '*' ;
+
+SLASH : '/' ;
+
+VBAR : '|' ;
+
+AMPER : '&' ;
+
+LESS : '<' ;
+
+GREATER : '>' ;
+
+ASSIGN_EQUAL : '=' ;
+
+PERCENT : '%' ;
+
+QUESTION : '?' ;
+
+EQUAL : '==' ;
+
+NOTEQUAL : '!=' ;
+
+ALT_NOTEQUAL: '<>' ;
+
+LESSEQUAL : '<=' ;
+
+
+GREATEREQUAL : '>=' ;
+
+WS : (' '|'\r'|'\t'|'\u000C'|'\n') {$channel=HIDDEN;}
+ ;
+
+
+
+
+
+
+
+COMMENT
+ : '/*'{if (input.LA(1)=='*') $type=DocComment; else $channel=HIDDEN;} ( options {greedy=false;} : . )* '*/'
+ ;
+
+LINE_COMMENT
+ : '//' ~('\n'|'\r')* '\r'? '\n' {$channel=HIDDEN;}
+ ;
+
+
+
+
+
+
+
Propchange: uima/sandbox/trunk/TextMarker/org.apache.uima.tm.textmarker.engine/src/main/java/org/apache/uima/tm/textmarker/parser/Copy of TextMarker.g
------------------------------------------------------------------------------
svn:executable = *