<html>
<head>
<style><!--
body {background-color:#ffffff;}
.file {border:1px solid #eeeeee;margin-top:1em;margin-bottom:1em;}
.pathname {font-family:monospace; float:right;}
.fileheader {margin-bottom:.5em;}
.diff {margin:0;}
.tasklist {padding:4px;border:1px dashed #000000;margin-top:1em;}
.tasklist ul {margin-top:0;margin-bottom:0;}
tr.alt {background-color:#eeeeee}
#added {background-color:#ddffdd;}
#addedchars {background-color:#99ff99;font-weight:bolder;}
tr.alt #added {background-color:#ccf7cc;}
#removed {background-color:#ffdddd;}
#removedchars {background-color:#ff9999;font-weight:bolder;}
tr.alt #removed {background-color:#f7cccc;}
#copied {background-color:#ccccff;}
tr.alt #copied {background-color:#bbbbf7;}
#info {color:#888888;}
#context {background-color:#eeeeee;}
td {padding-left:.3em;padding-right:.3em;}
tr.head {border-bottom-width:1px;border-bottom-style:solid;}
tr.head td {padding:0;padding-top:.2em;}
.task {background-color:#ffff00;}
.comment {white-space:-moz-pre-wrap;white-space:-pre-wrap;white-space:-o-pre-wrap;white-space:pre-wrap;word-wrap:break-word;padding:4px;border:1px dashed #000000;background-color:#ffffdd}
.error {color:red;}
hr {border-width:0px;height:2px;background:black;}
--></style>
</head>
<body>
<table cellspacing="0" cellpadding="0" border="0" rules="cols">
<tr class="head"><td colspan="5">Commit in <b><tt>metaas/trunk/src/main/antlr/org/asdt/core/internal/antlr</tt></b></td></tr>
<tr><td><tt><a href="#file1"><span id="removed">as3.g3</span></a></tt> </td><td></td><td></td><td align="right" id="removed">-1151</td><td nowrap="nowrap">377 removed</td></tr>
</table>
<pre class="comment">
changed case of filename to match grammar name
</pre>
<hr /><a name="file1" /><div class="file">
<span class="pathname" id="removed">metaas/trunk/src/main/antlr/org/asdt/core/internal/antlr</span><br />
<div class="fileheader" id="removed"><big><b>as3.g3</b></big> <small id="info">removed after 377</small></div>
<pre class="diff"><small id="info">--- trunk/src/main/antlr/org/asdt/core/internal/antlr/as3.g3 2007-01-31 00:20:19 UTC (rev 377)
+++ trunk/src/main/antlr/org/asdt/core/internal/antlr/as3.g3 2007-02-01 08:39:42 UTC (rev 378)
@@ -1,1151 +0,0 @@
</small></pre><pre class="diff" id="removed">-
-
-/**********************************************************
- * ActionScript Development Tool
- * Copyright (C) 2005 asdt.org
- *
- * http://www.asdt.org
- * http://sourceforge.net/projects/aseclipseplugin/
- *
- * This program is free software;
- * you can redistribute it and/or modify it under the terms of
- * the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License,
- * or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the
- * Free Software Foundation, Inc.,
- * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
- *
- * Created on 29 sept 2005
- *
- **********************************************************
-
-
-**
- * @author Martin Schnabel
- */
-grammar AS3Parser;
-
-options {
- k = 2;
- output=AST;
- ASTLabelType=LinkedListTree;
-}
-
-tokens {
- COMPILATION_UNIT;
- TYPE_BLOCK; METHOD_DEF; VAR_DEF;
- ANNOTATIONS; ANNOTATION; ANNOTATION_PARAMS; ANNOTATION_PARAM;
- MODIFIERS; NAMESPACE_DEF;
- CLASS_DEF; INTERFACE_DEF;
- PARAMS;
- PARAM; TYPE_SPEC;
- BLOCK; EXPR; ELIST;
- EXPR_STMNT;
- ENCPS_EXPR;
- VAR_INIT;
- METHOD_CALL; PROPERTY_OR_IDENTIFIER; PROPERTY_ACCESS; TYPE_NAME;
- ARRAY_ACC;
- UNARY_PLUS; UNARY_MINUS; POST_INC; POST_DEC;
- ARRAY_LITERAL;
- ELEMENT; OBJECT_LITERAL;
- OBJECT_FIELD; FUNC_DEF;
- FOR_INIT; FOR_CONDITION; FOR_ITERATOR;
- FOR_EACH;
- SWITCH_STATEMENT_LIST;
- IDENTIFIER;
- GET; SET; IS; DYNAMIC; USE;
- DEFAULT_XML_NAMESPACE;
-}
-
-@parser::header {
-package org.asdt.core.internal.antlr;
-
-import uk.co.badgersinfoil.metaas.impl.antlr.LinkedListTree;
-import uk.co.badgersinfoil.metaas.impl.antlr.LinkedListTreeAdaptor;
-import uk.co.badgersinfoil.metaas.impl.antlr.LinkedListToken;
-import uk.co.badgersinfoil.metaas.impl.antlr.LinkedListTokenStream;
-import uk.co.badgersinfoil.metaas.impl.antlr.LinkedListTokenSource;
-import java.io.StringReader;
-import java.io.Reader;
-import java.io.IOException;
-import uk.co.badgersinfoil.metaas.impl.parser.E4XHelper;
-import uk.co.badgersinfoil.metaas.impl.parser.RegexSimpleHelper;
-import uk.co.badgersinfoil.metaas.impl.ASTUtils;
-}
-@lexer::header {
-package org.asdt.core.internal.antlr;
-}
-
-// disable standard error handling; be strict
-@rulecatch { }
-
-@parser::members {
-
- public static final int ALLOW_IN = 1;
- public static final int NO_IN = 2;
-
- protected void mismatch(IntStream input, int ttype, BitSet follow)
- throws RecognitionException
- {
- throw new MismatchedTokenException(ttype, input);
- }
-
- private AS3ParserLexer lexer;
- private CharStream cs;
-
- public void setInput(AS3ParserLexer lexer, CharStream cs) {
- this.lexer = lexer;
- this.cs = cs;
- }
-
- /**
- * Handle 'island grammar' for embeded XML-literal elements.
- */
- private LinkedListTree parseXMLLiteral(LinkedListToken startMarker) throws RecognitionException {
- return E4XHelper.parseXMLLiteral(startMarker, lexer, cs, (LinkedListTokenStream)input);
- }
-
- /**
- * Handle 'island grammar' for skipping over embeded
- * regular-expression-literal values.
- */
- private LinkedListTree parseRegexpLiteral(LinkedListToken startMarker) throws RecognitionException {
- return RegexSimpleHelper.parseRegexpLiteral(startMarker, lexer, cs, (LinkedListTokenStream)input);
- }
-}
-
-
-/**
- * this is the start rule for this parser
- */
-compilationUnit
- : ( as2CompilationUnit
- | as3CompilationUnit
- ) -> ^(COMPILATION_UNIT as2CompilationUnit? as3CompilationUnit?)
-
-
-as2CompilationUnit
- : importDefinition*
- as2Type
-
-
-as2Type
- : annos=annotations! mods=modifiers!
- ( as2ClassDefinition[$annos.tree,$mods.tree]
- | as2InterfaceDefinition[$annos.tree,$mods.tree]
- )
-
-
-as3CompilationUnit
- : packageDecl
- packageBlockEntry*
- EOF!
-
-
-packageDecl
- : PACKAGE^ identifier?
- packageBlock
-
-
-packageBlock
- : LCURLY
- packageBlockEntry*
- RCURLY
- -> ^(BLOCK packageBlockEntry*)
-
-
-packageBlockEntry
- : ( importDefinition
- | includeDirective
- | annos=annotations! mods=modifiers!
- ( classDefinition[$annos.tree,$mods.tree]
- | interfaceDefinition[$annos.tree,$mods.tree]
- | variableDefinition[$annos.tree,$mods.tree]
- | methodDefinition[$annos.tree,$mods.tree]
- | namespaceDefinition[$annos.tree,$mods.tree]
- | useNamespaceDirective
- )
- | SEMI!
-// | statement
- )
-
-
-endOfFile
- : EOF!
-
-
-importDefinition
- : IMPORT^ identifierStar semi
-
-
-semi
- : ((SEMI)=>SEMI!)?
-
-
-classDefinition[LinkedListTree annos, LinkedListTree mods]
- : CLASS IDENT
- classExtendsClause
- implementsClause
- typeBlock
- -> ^(CLASS_DEF {$mods} CLASS IDENT classExtendsClause implementsClause typeBlock)
-
-
-as2ClassDefinition[LinkedListTree annos, LinkedListTree mods]
- : CLASS identifier
- classExtendsClause
- implementsClause
- typeBlock
- -> ^(CLASS_DEF {$mods} CLASS IDENT classExtendsClause implementsClause typeBlock)
-
-
-interfaceDefinition[LinkedListTree annos, Tree mods]
- : INTERFACE IDENT
- interfaceExtendsClause
- typeBlock
- -> ^(INTERFACE_DEF INTERFACE IDENT interfaceExtendsClause typeBlock) // TODO: mods?
-
-
-as2InterfaceDefinition[LinkedListTree annos, Tree mods]
- : INTERFACE identifier
- interfaceExtendsClause
- typeBlock
- -> ^(INTERFACE_DEF INTERFACE IDENT interfaceExtendsClause typeBlock) // TODO: mods?
-
-
-classExtendsClause
- : (EXTENDS^ identifier)?
-
-interfaceExtendsClause
- : (EXTENDS^ identifier ( COMMA! identifier)*)?
-
-implementsClause
- : (IMPLEMENTS^ identifier ( COMMA! identifier)*)?
-
-typeBlock
- : LCURLY
- typeBlockEntry*
- RCURLY
- -> ^(TYPE_BLOCK typeBlockEntry*)
-
-
-typeBlockEntry
- : annos=annotations! m=modifiers!
- ( variableDefinition[$annos.tree,$m.tree]
- | methodDefinition[$annos.tree,$m.tree]
- )
- | SEMI
- | importDefinition
- | as2IncludeDirective
- | includeDirective
-
-
-
-as2IncludeDirective
- : INCLUDE_DIRECTIVE
- STRING_LITERAL
-
-
-includeDirective
- : 'include'
- STRING_LITERAL
- semi
-
-
-
-methodDefinition[LinkedListTree annos, Tree mods]
- : functionDecl IDENT
- parameterDeclarationList
- typeExpression?
- (block)?
- -> ^(METHOD_DEF {$annos} {$mods}
- functionDecl IDENT
- parameterDeclarationList
- typeExpression?
- block?)
-
-
-functionDecl
- : FUNCTION^ (role=accessorRole)?
-
-
-accessorRole
- : getKeyword | setKeyword
-
-
-getKeyword
- : {input.LT(1).getText().equals("get")}? i=IDENT
- -> GET[$i]
-
-
-setKeyword
- : {input.LT(1).getText().equals("set")}? i=IDENT
- -> SET[$i]
-
-
-namespaceDefinition[LinkedListTree annos, Tree mods]
- : namespaceKeyword IDENT
- -> ^(NAMESPACE_DEF {$annos} {$mods} namespaceKeyword IDENT)
-
-namespaceKeyword
- : {input.LT(1).getText().equals("namespace")}? IDENT
-
-
-useNamespaceDirective
- : useKeyword namespaceKeyword IDENT semi
-
-
-useKeyword
- : {input.LT(1).getText().equals("use")}? i=IDENT
- -> USE[$i]
-
-
-xmlKeyword
- : {input.LT(1).getText().equals("xml")}? IDENT
-
-
-variableDefinition[LinkedListTree annos, Tree mods]
- : decl=varOrConst variableDeclarator[ALLOW_IN]
- (COMMA variableDeclarator[ALLOW_IN])*
- -> ^(VAR_DEF {$annos} {$mods} $decl variableDeclarator+)
-
-
-varOrConst
- : VAR | CONST
-
-
-variableDeclarator[int inAllowed]
- : IDENT^ typeExpression? variableInitializer[inAllowed]?
-
-declaration[int inAllowed]
- : varOrConst^ variableDeclarator[inAllowed]
- (COMMA! variableDeclarator[ALLOW_IN])*
-
-variableInitializer[int inAllowed]
- : ASSIGN^ assignmentExpression[inAllowed]
-
-// A list of formal parameters
-// TODO: shouldn't the 'rest' parameter only be allowed in the last position?
-parameterDeclarationList
- : LPAREN
- ( parameterDeclaration
- (COMMA parameterDeclaration)*
- )?
- RPAREN
- -> ^(PARAMS parameterDeclaration*)
-
-
-
-parameterDeclaration
- : basicParameterDeclaration | parameterRestDeclaration
-
-
-basicParameterDeclaration
- : CONST? IDENT typeExpression? parameterDefault?
- -> ^(PARAM CONST? IDENT typeExpression? parameterDefault?)
-
-
-parameterDefault
- // TODO: can we be more strict about allowed values?
- : ASSIGN^ assignmentExpression[ALLOW_IN]
-
-
-parameterRestDeclaration
- : REST CONST? IDENT
- -> ^(PARAM REST CONST? IDENT)
-
-block
- : LCURLY (statement)* RCURLY
- -> ^(BLOCK statement*)
-
-
-condition
- : LPAREN! expression RPAREN!
-
-
-statement
- : {input.LA(1)==LCURLY}?(block)
- | declarationStatement
- | expressionStatement
- | ifStatement
- // For statement
- | forEachStatement
- | forStatement
-
- // While statement
- | WHILE condition statement
-
- // do-while statement
- | DO statement WHILE! condition
-
- // with statement
- | 'with' condition statement
-
- // switch statement
- | switchStatement
-
- // get out of a loop (or switch)
- | breakStatement
-
- // do next iteration of a loop
- | continueStatement
-
- // Return an expression
- | returnStatement
-
- // throw an exception
- | throwStatement
-
- // handle exceptions
- | tryStatement
-
- // handle 'default xml namespace = "foo"'
- | defaultXMLNamespaceStatement
-
- // empty statement
- | SEMI!
-
-
-declarationStatement
- : declaration[ALLOW_IN] semi
-
-
-expressionStatement
- : expressionList[ALLOW_IN] semi
- -> ^(EXPR_STMNT expressionList)
-
-
-ifStatement
- : IF^ condition statement
- (ELSE statement)?
-
-
-throwStatement
- : 'throw'^ expression semi
-
-
-tryStatement
- : 'try'
- block
- catchBlock*
- finallyBlock?
-
-
-catchBlock
- : 'catch' LPAREN! IDENT typeExpression? RPAREN!
- block
-
-
-finallyBlock
- : 'finally' block
-
-
-returnStatement
- : 'return'^ (expression)? semi
-
-
-continueStatement
- : 'continue'^ semi
-
-
-breakStatement
- : 'break'^ semi
-
-
-switchStatement
- : SWITCH^ condition
- switchBlock
-
-
-switchBlock
- : LCURLY
- (caseStatement)*
- (defaultStatement)?
- RCURLY
- -> ^(BLOCK caseStatement* defaultStatement?)
-
-
-caseStatement
- : CASE^ expression COLON! switchStatementList
-
-
-defaultStatement
- : DEFAULT^ COLON! switchStatementList
-
-
-switchStatementList
- : statement* -> ^(SWITCH_STATEMENT_LIST statement*)
-
-
-forEachStatement
- : FOR EACH
- LPAREN
- forInClause
- RPAREN
- statement
- -> ^(FOR_EACH forInClause statement)
-
-forStatement
- : FOR^
- LPAREN!
- ( ((declaration[NO_IN] | IDENT) IN)=>forInClause
- | traditionalForClause
- )
- RPAREN!
- statement // statement to loop over
-
-traditionalForClause
- : forInit SEMI! // initializer
- forCond SEMI! // condition test
- forIter // updater
-
-
-forInClause
- : (declaration[NO_IN] | IDENT) IN expressionList[ALLOW_IN]
-
-// The initializer for a for loop
-forInit
- : ((declaration)=> declaration[NO_IN] | expressionList[NO_IN] )?
- -> ^(FOR_INIT $forInit)
-
-
-forCond
- : expressionList[ALLOW_IN]?
- -> ^(FOR_CONDITION expressionList?)
-
-
-forIter
- : expressionList[ALLOW_IN]?
- -> ^(FOR_ITERATOR expressionList?)
-
-
-
-defaultXMLNamespaceStatement
- : DEFAULT xmlKeyword namespaceKeyword ASSIGN expression semi
- -> ^(DEFAULT_XML_NAMESPACE expression)
-
-
-typeExpression
- : c=COLON
- // TODO: identifier allows namespaces, and I suspect a type:spec shouldn't
- (identifier | 'void' | STAR)
- -> ^(TYPE_SPEC[$c] identifier? 'void'? STAR?)
-
-
-identifier
- : qualifiedIdent
- ( options{greedy=true;}
- : DOT qualifiedIdent
- )*
- -> ^(IDENTIFIER qualifiedIdent+)
-
-
-qualifiedIdent
- : IDENT (DBL_COLON^^ IDENT)?
-
-
-identifierStar
- : IDENT
- ( options{greedy=true;}
- : DOT IDENT
- )*
- ( DOT STAR
- )?
- -> ^(IDENTIFIER IDENT+ STAR?)
-
-
-annotations
- : ( annotation
- | includeDirective
- )*
- -> ^(ANNOTATIONS annotation*)
-
-
-annotation
- : LBRACK
- IDENT
- annotationParamList?
- RBRACK
- -> ^(ANNOTATION IDENT annotationParamList?)
-
-
-annotationParamList
- :
- LPAREN
- ( annotationParam
- (COMMA annotationParam)*
- )?
- RPAREN
- -> ^(ANNOTATION_PARAMS annotationParam*)
-
-
-/*
-[Inspectable(name="Icon Offset", verbose = 1,type=Boolean, defaultValue=true)]
-[Inspectable(defaultValue="circular")]
-[Bindable]
-[ChangeEvent("event")]
-[Inspectable("danger", 1, true, maybe)]
-[InspectableList("flavorStr","colorStr")]
-[Event("click")]
-[Collection (name="name", variable="varname", collectionClass="mx.utils.CollectionImpl", collectionItem="coll-item-classname", identifier="string")]
-*/
-
-annotationParam
- :
- IDENT ASSIGN constant -> ^(ASSIGN IDENT constant)
- | constant -> constant
- | IDENT -> IDENT
-
-
-modifiers
- : modifier*
- -> ^(MODIFIERS modifier*)
-
-
-modifier
- : PUBLIC
- | PRIVATE
- | 'protected'
- | 'internal'
- | STATIC
- | 'final'
- | 'enumerable'
- | 'explicit'
- | 'override'
- | dynamicKeyword
- | 'intrinsic'
- | IDENT // a namespace
-
-
-dynamicKeyword
- : {input.LT(1).getText().equals("dynamic")}? i=IDENT
- -> DYNAMIC[$i]
-
-
-arguments
- : LPAREN
- ( expressionList[ALLOW_IN]
- | /*nothing*/
- )
- RPAREN
- -> ^(ELIST $arguments)
-
-// This is an initializer used to set up an array.
-arrayLiteral
- : LBRACK elementList? RBRACK
- -> ^(ARRAY_LITERAL elementList?)
-
-
-elementList
- : COMMA!
- | nonemptyElementList
-
-nonemptyElementList
- : assignmentExpression[ALLOW_IN] (COMMA! assignmentExpression[ALLOW_IN])*
-
-
-element
- : assignmentExpression[ALLOW_IN]
- -> ^(ELEMENT assignmentExpression)
-
-
-// This is an initializer used to set up an object.
-objectLiteral
- : LCURLY fieldList? RCURLY
- -> ^(OBJECT_LITERAL fieldList?)
-
-
-fieldList
- : literalField (COMMA! literalField?)*
-
-
-literalField
- : fieldName COLON element
- -> ^(OBJECT_FIELD fieldName element)
-
-
-fieldName
- : IDENT
- | number
-
-
-// the mother of all expressions
-expression
- : assignmentExpression[ALLOW_IN]
- -> ^(EXPR assignmentExpression)
-
-
-// This is a list of expressions.
-expressionList[int inAllowed]
- : assignmentExpression[inAllowed] (COMMA assignmentExpression[inAllowed])*
- -> ^(ELIST assignmentExpression+)
-
-
-// assignment expression (level 13)
-assignmentExpression[int inAllowed]
- : conditionalExpression[inAllowed]
- ( (assignmentOperator)=> assignmentOperator
- assignmentExpression[inAllowed]
- )*
-
-
-assignmentOperator
- : ASSIGN
- | STAR_ASSIGN
- | DIV_ASSIGN
- | MOD_ASSIGN
- | PLUS_ASSIGN
- | MINUS_ASSIGN
- | SL_ASSIGN
- | SR_ASSIGN
- | BSR_ASSIGN
- | BAND_ASSIGN
- | BXOR_ASSIGN
- | BOR_ASSIGN
- | LAND_ASSIGN
- | LOR_ASSIGN
-
-
-// conditional test (level 12)
-conditionalExpression[int inAllowed]
- : logicalOrExpression[inAllowed]
- (
- QUESTION^^
- conditionalSubExpression[inAllowed]
- )?
-
-conditionalSubExpression[int inAllowed]
- : assignmentExpression[inAllowed] COLON^^ assignmentExpression[inAllowed]
-
-
-// TODO: should 'and'/'or' have same precidence as '&&'/'||' ?
-
-// logical or (||) (level 11)
-logicalOrExpression[int inAllowed]
- : logicalAndExpression[inAllowed] (logicalOrOperator^^ logicalAndExpression[inAllowed])*
-
-
-logicalOrOperator
- : LOR | 'or'
-
-
-// logical and (&&) (level 10)
-logicalAndExpression[int inAllowed]
- : bitwiseOrExpression[inAllowed] (logicalAndOperator^^ bitwiseOrExpression[inAllowed])*
-
-
-logicalAndOperator
- : LAND | 'and'
-
-
-// bitwise or non-short-circuiting or (|) (level 9)
-bitwiseOrExpression[int inAllowed]
- : bitwiseXorExpression[inAllowed] (BOR^^ bitwiseXorExpression[inAllowed])*
-
-// exclusive or (^) (level 8)
-bitwiseXorExpression[int inAllowed]
- : bitwiseAndExpression[inAllowed] (BXOR^^ bitwiseAndExpression[inAllowed])*
-
-// bitwise or non-short-circuiting and (&) (level 7)
-bitwiseAndExpression[int inAllowed]
- : equalityExpression[inAllowed] (BAND^^ equalityExpression[inAllowed])*
-
-// equality/inequality (==/!=) (level 6)
-equalityExpression[int inAllowed]
- : relationalExpression[inAllowed]
- ( equalityOperator^^
- relationalExpression[inAllowed]
- )*
-
-
-equalityOperator
- : STRICT_EQUAL | STRICT_NOT_EQUAL | NOT_EQUAL | EQUAL
-
-
-// boolean relational expressions (level 5)
-relationalExpression[int inAllowed]
- : shiftExpression (relationalOperator[inAllowed]^^ shiftExpression)*
-
-
-relationalOperator[int inAllowed]
- : {inAllowed==ALLOW_IN}? IN
- | LT | GT | LE | GE | isKeyword | asKeyword | 'instanceof'
-
-
-isKeyword
- : {input.LT(1).getText().equals("is")}? i=IDENT
- -> IS[$i]
-
-
-asKeyword
- : {input.LT(1).getText().equals("as")}? i=IDENT
- -> IS[$i]
-
-
-// bit shift expressions (level 4)
-shiftExpression
- : additiveExpression (shiftOperator^^ additiveExpression)*
-
-
-shiftOperator
- : SL | SR | BSR
-
-
-// binary addition/subtraction (level 3)
-additiveExpression
- : multiplicativeExpression (additiveOperator^^ multiplicativeExpression)*
-
-
-additiveOperator
- : PLUS | MINUS
-
-
-// multiplication/division/modulo (level 2)
-multiplicativeExpression
- : unaryExpression (multiplicativeOperator^^ unaryExpression)*
-
-
-multiplicativeOperator
- : STAR | DIV | MOD
-
-
-// (level 1)
-unaryExpression
- : INC^^ unaryExpression
- | DEC^^ unaryExpression
- | MINUS unaryExpression -> ^(UNARY_MINUS unaryExpression)
- | PLUS unaryExpression -> ^(UNARY_PLUS unaryExpression)
- | unaryExpressionNotPlusMinus
-
-
-unaryExpressionNotPlusMinus
- : 'delete'^^ postfixExpression
- | 'void'^^ unaryExpression
- | 'typeof'^^ unaryExpression
- | LNOT^^ unaryExpression
- | BNOT^^ unaryExpression
- | postfixExpression
-
-
-// qualified names, array expressions, method invocation, post inc/dec
-postfixExpression
- : (primaryExpression -> primaryExpression)
- ( options{greedy=true;} :
- ( DOT
- (
- qualifiedIdent
- | e4xExpression
- )
- | ( LBRACK expression RBRACK
- -> ^(ARRAY_ACC $postfixExpression expression)
- )
- | E4X_DESC e4xExpression
- )
- methodCall
- )*
- ( options {greedy=true;}
- : in=INC -> ^(POST_INC[$in] $postfixExpression)
- | de=DEC -> ^(POST_DEC[$de] $postfixExpression)
- )?
-
-
-methodCall
- : ( options {greedy=true;}
- : arguments
- -> ^(METHOD_CALL arguments)
- )*
-
-e4xExpression
- : IDENT
- | STAR^
- | e4xAttributeIdentifier
- | e4xFilterPredicate
-
-
-e4xAttributeIdentifier
- : E4X_ATTRI
- ( qualifiedIdent
- | STAR
- | LBRACK expression RBRACK
- )
-
-
-e4xFilterPredicate
- : LPAREN!
- expression
- RPAREN!
-
-
-primaryExpression
- : identPrimary
- | 'undefined'
- | constant
- | arrayLiteral
- | objectLiteral
- | functionDefinition
- | newExpression
- | encapsulatedExpression
- | e4xAttributeIdentifier
-
-
-
-identPrimary
- : (qualifiedIdent -> qualifiedIdent)
- ( options{greedy=true;}
- /* yuk! tree building doesn't set the start/stop values
- we need without some hand-holding, */
- : ( poi=propOrIdent[root_0, retval.start] -> $poi
- )
- | ( LBRACK expr=expression RBRACK
- -> ^(ARRAY_ACC $identPrimary $expr)
- )
- )*
- ( options {greedy=true;}
- : a=arguments
- -> ^(METHOD_CALL $identPrimary $a)
- )*
- ;
-
-propOrIdent[LinkedListTree identPrimary, Token startToken]
- :
- { retval.start = startToken; }
- DOT propId=qualifiedIdent
- /* without further semantic analysis, we can't
- tell if a.b is an access of the property 'b'
- from the var 'a' or a reference to the type
- 'b' in the package 'a'. (This could be
- resolved in an AST post-processing step) */
- -> ^(PROPERTY_OR_IDENTIFIER {$identPrimary} $propId)
-
-
-constant
- : xmlLiteral
- | regexpLiteral
- | number
- | STRING_LITERAL
- | TRUE
- | FALSE
- | 'null'
-
-
-number : HEX_LITERAL
- | DECIMAL_LITERAL
- | OCTAL_LITERAL
- | FLOAT_LITERAL
-
-
-
-xmlLiteral
- @init {
- LinkedListTree xml = null;
- }
- : s=LT { xml=parseXMLLiteral((LinkedListToken)$s); }
- -> ^({xml})
-
-
-regexpLiteral
- @init {
- LinkedListTree regexp = null;
- }
- : s=DIV { regexp=parseRegexpLiteral((LinkedListToken)$s); }
- -> ^({regexp})
-
-
-newExpression
- : 'new'^ postfixExpression
-
-encapsulatedExpression
- : LPAREN assignmentExpression[ALLOW_IN] RPAREN
- -> ^(ENCPS_EXPR assignmentExpression)
-
-
-// TODO: should anonymous and named functions have seperate definitions so that
-// we can dissallow named functions in expressions?
-
-functionDefinition
- : FUNCTION IDENT? parameterDeclarationList typeExpression? block
- -> ^(FUNC_DEF IDENT? parameterDeclarationList typeExpression? block)
-
-
-
-PACKAGE : 'package';
-PUBLIC : 'public';
-PRIVATE : 'private';
-FUNCTION : 'function';
-EXTENDS : 'extends';
-IMPLEMENTS : 'implements';
-VAR : 'var';
-STATIC : 'static';
-IF : 'if';
-IMPORT : 'import';
-FOR : 'for';
-EACH : 'each';
-IN : 'in';
-WHILE : 'while';
-DO : 'do';
-SWITCH : 'switch';
-CASE : 'case';
-DEFAULT : 'default';
-ELSE : 'else';
-CONST : 'const';
</pre></pre>
<strong class="error">[truncated at 1000 lines; 154 more skipped]</strong>
</div>
<center><small><a href="http://www.badgers-in-foil.co.uk/projects/cvsspam/" title="commit -> email">CVSspam</a> 0.2.12</small></center>
</body></html>