cocoon-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ovi...@apache.org
Subject cvs commit: xml-cocoon2/src/scratchpad/schecoon/src/org/apache/cocoon/flow flow.g
Date Mon, 11 Mar 2002 16:19:50 GMT
ovidiu      02/03/11 08:19:50

  Modified:    src/scratchpad/schecoon/src/org/apache/cocoon/flow flow.g
  Log:
  Updated.
  
  Revision  Changes    Path
  1.6       +155 -122  xml-cocoon2/src/scratchpad/schecoon/src/org/apache/cocoon/flow/flow.g
  
  Index: flow.g
  ===================================================================
  RCS file: /home/cvs/xml-cocoon2/src/scratchpad/schecoon/src/org/apache/cocoon/flow/flow.g,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- flow.g	7 Mar 2002 02:12:08 -0000	1.5
  +++ flow.g	11 Mar 2002 16:19:50 -0000	1.6
  @@ -10,22 +10,33 @@
   
   options {
       k = 1;
  +    exportVocab=jWeave;  // Call its vocabulary "jWeave"
  +    buildAST = true;     // uses CommonAST by default
  +    codeGenMakeSwitchThreshold = 2;  // Some optimizations
  +    codeGenBitsetTestThreshold = 3;
   }
   
   tokens {
  -    DOT;
  +    DOT; MTHINVOKE; FUNCALL; ARRAYIDX; SEQ; RETURN; ARRAY; DICT; FUNCTION;
  +    PARAMS; VARARGS;
   }
   
  -exprs
  -    :   (expr)? SEMI exprs
  +program
  +    :   exprs EOF!
  +    ;
  +
  +exprs!
  +    :   ( e:expr (SEMI!)+
  +          {#exprs = #([SEQ], #exprs, #e);}
  +        )+
       ;
   
   expr
  -    :   assignment  // Simple expressions
  -    |   block       // A sequence of expressions
  -    |   function    // Function declaration
  -    |   varDecl     // Variable declaration
  -    |   "if" LPAREN expr RPAREN expr
  +    :   assignment
  +    |   block           // A sequence of expressions
  +    |   varDecl         // Variable declaration
  +    |   function        // Function declaration
  +    |   "if"^ LPAREN! expr RPAREN! expr
           (
                           // CONFLICT: the old "dangling-else" problem...
                           //           ANTLR generates proper code matching
  @@ -35,8 +46,12 @@
               }:
               "else" expr
           )?
  -    |   "return" expr
  -    |   "try" expr
  +
  +        // The following expressions should be rewritten using macros,
  +        // when they become available
  +    |!  "return"^ return:expr
  +        {#expr = #([RETURN], return); }
  +    |   "try"^ expr
           (
               // CONFLICT: Similar with the dangling else
               options {
  @@ -44,130 +59,135 @@
               }:
               handler
           )+
  -    |   "throw" expr
  -
  -        // The following expressions should be rewritten using macros,
  -        // when they become available
  -    |   "import" identifierStar
  -    |   "while" LPAREN expr RPAREN expr
  -    |   "switch" LPAREN expr RPAREN casesGroup
  -    |   "for" LPAREN exprList SEMI exprList SEMI exprList RPAREN expr
  -    |   "foreach" LPAREN IDENT "in" expr RPAREN expr
  -    |   "do" expr "while" LPAREN expr RPAREN
  +    |   "throw"^ expr
  +    |   "import"^ identifierStar
  +    |   "while"^ LPAREN! expr RPAREN! expr
  +    |   "switch"^ LPAREN! expr RPAREN! casesGroup
  +    |   "for"^ LPAREN! exprList SEMI! exprList SEMI! exprList RPAREN! expr
  +    |   "foreach"^ LPAREN! IDENT "in" expr RPAREN! expr
  +    |   "do"^ expr "while" LPAREN! expr RPAREN!
       ;
   
   exprList
  -    :   expr
  +    :   assignment
           (
               // CONFLICT: Similar with the dangling else
               options {
                   warnWhenFollowAmbig = false;
               }:
  -            COMMA expr
  +            COMMA! assignment
           )*
       ;
   
   // A function is either named or unnamed. A named function is //
   // equivalent to a variable declaration whose value is an unnamed
   // function.
  -function
  -    :   "function" (IDENT)? parameters block
  +function!
  +    :   "function"^ (n:IDENT)? p:parameters b:block
  +        {#function = #([FUNCTION, "function"], n, #([PARAMS], p), b);}
  +    ;
  +
  +parameters!
  +    :   LPAREN!
  +          (funParam (COMMA! funParam)*)?
  +          (v:"*args" {#parameters.addChild(#[VARARGS, "*args"]);})? 
  +        RPAREN!
       ;
   
  -parameters
  -    :   LPAREN (IDENT)* RPAREN
  +funParam
  +    :   IDENT (ASSIGN^ (IDENT|constant))?
       ;
   
   // A sequence of expressions. The value of the block is the value of
   // the last expression evaluated inside the block.
   block
  -    :   LCURLY exprs RCURLY
  +    :   LCURLY! exprs RCURLY!
       ;
   
   // Variable declaration
   varDecl
  -    :   "var" exprList
  +    :   "var"^ exprList
       ;
   
   casesGroup
  -        :       (       // CONFLICT: to which case group do the statements bind?
  -                        //           ANTLR generates proper code: it groups the
  -                        //           many "case"/"default" labels together then
  -                        //           follows them with the statements
  -                        options {
  -                                warnWhenFollowAmbig = false;
  -                        }
  -                        :
  -                        aCase
  -                )+
  -                caseSList
  -        ;
  +    :   (   // CONFLICT: to which case group do the exprs bind?
  +            //           ANTLR generates proper code: it groups the
  +            //           many "case"/"default" labels together then
  +            //           follows them with the exprs
  +            options {
  +                warnWhenFollowAmbig = false;
  +            }
  +        :
  +            aCase
  +        )+
  +        caseSList
  +    ;
   
   aCase
  -        :       ("case" expr | "default") COLON
  -        ;
  +    :   ("case" expr | "default") COLON!
  +    ;
   
   caseSList
  -        :       exprs
  -        ;
  +    :   exprs
  +    ;
   
   // Handler for a try expression
   handler
  -    :   "catch" LPAREN expr IDENT RPAREN expr
  +    :   "catch" LPAREN! expr IDENT RPAREN! expr
       |   "finally" expr
       ;
   
   identifierStar
       :   IDENT
  -        (DOT (IDENT|STAR))*
  +        (DOT! (IDENT|STAR))*
       ;
   
   assignment
       :   logicalOr
  -        (   (   ASSIGN
  -            |   PLUS_ASSIGN
  -            |   MINUS_ASSIGN
  -            |   STAR_ASSIGN
  -            |   DIV_ASSIGN
  -            |   MOD_ASSIGN
  -            |   BAND_ASSIGN
  -            |   BXOR_ASSIGN
  -            |   BOR_ASSIGN
  +        (   ( ASSIGN^
  +            | PLUS_ASSIGN^
  +            | MINUS_ASSIGN^
  +            | STAR_ASSIGN^
  +            | DIV_ASSIGN^
  +            | MOD_ASSIGN^
  +            | BAND_ASSIGN^
  +            | BXOR_ASSIGN^
  +            | BOR_ASSIGN^
               )
               assignment
           )?
       ;
   
   logicalOr
  -    :   logicalAnd (LOR logicalAnd)*
  +    :   logicalAnd (LOR^ logicalAnd)*
       ;
   
   logicalAnd
  -    :   inclusiveOr (LAND inclusiveOr)*
  +    :   inclusiveOr (LAND^ inclusiveOr)*
       ;
   
   inclusiveOr
  -    :   exclusiveOr (BOR exclusiveOr)*
  +    :   exclusiveOr (BOR^ exclusiveOr)*
       ;
   
   exclusiveOr
  -    :   and (BXOR and)*
  +    :   and (BXOR^ and)*
       ;
   
   and
  -    :   equality (BAND equality)*
  +    :   equality (BAND^ equality)*
       ;
   
   equality
  -    :   relational ((NOT_EQUAL | EQUAL) relational)*
  +    :   relational ((NOT_EQUAL^ | EQUAL^) relational)*
       ;
   
   relational
       :   additive
  -        (   (   (   LT
  -                |   GT
  -                |   LE
  -                |   GE
  +        (   (   ( LT^
  +                | GT^
  +                | LE^
  +                | GE^
                   )
                   additive
               )*
  @@ -175,24 +195,25 @@
       ;
   
   additive
  -    :   multiplicative ((PLUS | MINUS) multiplicative)*
  +    :   multiplicative ((PLUS^ | MINUS^) multiplicative)*
       ;
   
   multiplicative
  -    :   unary ((STAR | DIV | MOD) unary)*
  +    :   unary ((STAR^ | DIV^ | MOD^) unary)*
       ;
   
   unary
  -    :   INC unary
  -    |   DEC unary
  -    |   MINUS unary
  -    |   PLUS unary
  +    :   INC^ unary
  +    |   DEC^ unary
  +    |   MINUS^ unary
  +    |   PLUS^ unary
       |   unaryNotPlusMinus
  +    |   arrayOrDict
       ;
   
   unaryNotPlusMinus
  -    :   BNOT unary
  -    |   LNOT unary
  +    :   BNOT^ unary
  +    |   LNOT^ unary
       |   postfix
       ;
   
  @@ -200,40 +221,45 @@
       :   primary
           (
               // Array indexing
  -            LBRACK assignment RBRACK
  +            LBRACK! a:assignment RBRACK!
  +            {#postfix = #([ARRAYIDX], a);}
   
               // Method invocation
  -        |   DOT LPAREN exprList RPAREN
  +        |   DOT! LPAREN! ma:exprList RPAREN!
  +            {#postfix = #([MTHINVOKE], ma);}
   
               // Function invocation
  -        |   LPAREN exprList RPAREN
  +        |   LPAREN! fa:exprList RPAREN!
  +            {#postfix = #([FUNCALL], fa);}
           )*
       ;
   
   primary
       :   IDENT
       |   constant
  -    |   arrayOrDict
  -    |   "true"
  -    |   "false"
  -    |   "null"
  -    |   LPAREN assignment RPAREN
  +    |   LPAREN! assignment RPAREN!
       ;
   
   constant
       :   NUMBER
       |   CHAR_LITERAL
       |   STRING_LITERAL
  +    |   "true"
  +    |   "false"
  +    |   "null"
       ;
   
   // An array or a dictionary:
   //   [a, b, c] -> array
   //   [a: 1, b: 2, c: 3] -> dictionary
   // Use a syntactic predicate to disambiguate on ':'
  -arrayOrDict
  -    :   (LBRACK expr COLON)=>
  -        LBRACK expr COLON expr (COMMA expr COLON expr)* RBRACK
  -    |   LBRACK exprList RBRACK
  +arrayOrDict!
  +    :   (LBRACK! expr COLON!)=>
  +        LBRACK! key:expr COLON! value:expr
  +        (COMMA! keys:expr COLON! values:expr)* RBRACK!
  +        {#arrayOrDict = #([DICT, "dict"], key, value, ([DICT], keys, values));}
  +    |   LBRACK! elems:exprList RBRACK!
  +        {#arrayOrDict = #([ARRAY, "array"], elems);}
       ;
   
   
  @@ -242,56 +268,62 @@
   
   options {
       k = 2;
  +    exportVocab=jWeave;    // Call its vocabulary "jWeave"
       testLiterals=false;    // don't automatically test for literals
   }
   
  -QUESTION                :       '?'             ;
  -LPAREN                  :       '('             ;
  -RPAREN                  :       ')'             ;
  -LBRACK                  :       '['             ;
  -RBRACK                  :       ']'             ;
  -LCURLY                  :       '{'             ;
  -RCURLY                  :       '}'             ;
  -COLON                   :       ':'             ;
  -COMMA                   :       ','             ;
  -ASSIGN                  :       '='             ;
  +QUESTION                :       '?'     ;
  +LPAREN                  :       '('     ;
  +RPAREN                  :       ')'     ;
  +LBRACK                  :       '['     ;
  +RBRACK                  :       ']'     ;
  +LCURLY                  :       '{'     ;
  +RCURLY                  :       '}'     ;
  +COLON                   :       ':'     ;
  +COMMA                   :       ','     ;
  +ASSIGN                  :       '='     ;
   EQUAL                   :       "=="    ;
  -LNOT                    :       '!'             ;
  -BNOT                    :       '~'             ;
  +LNOT                    :       '!'     ;
  +BNOT                    :       '~'     ;
   NOT_EQUAL               :       "!="    ;
  -DIV                             :       '/'             ;
  +DIV                     :       '/'     ;
   DIV_ASSIGN              :       "/="    ;
  -PLUS                    :       '+'             ;
  +PLUS                    :       '+'     ;
   PLUS_ASSIGN             :       "+="    ;
  -INC                             :       "++"    ;
  -MINUS                   :       '-'             ;
  -MINUS_ASSIGN    :       "-="    ;
  -DEC                             :       "--"    ;
  -STAR                    :       '*'             ;
  +INC                     :       "++"    ;
  +MINUS                   :       '-'     ;
  +MINUS_ASSIGN            :       "-="    ;
  +DEC                     :       "--"    ;
  +STAR                    :       '*'     ;
   STAR_ASSIGN             :       "*="    ;
  -MOD                             :       '%'             ;
  +MOD                     :       '%'     ;
   MOD_ASSIGN              :       "%="    ;
  -GE                              :       ">="    ;
  -GT                              :       ">"             ;
  -LE                              :       "<="    ;
  -LT                              :       '<'             ;
  -BXOR                    :       '^'             ;
  +GE                      :       ">="    ;
  +GT                      :       ">"     ;
  +LE                      :       "<="    ;
  +LT                      :       '<'     ;
  +BXOR                    :       '^'     ;
   BXOR_ASSIGN             :       "^="    ;
  -BOR                             :       '|'             ;
  +BOR                     :       '|'     ;
   BOR_ASSIGN              :       "|="    ;
  -LOR                             :       "||"    ;
  -BAND                    :       '&'             ;
  +LOR                     :       "||"    ;
  +BAND                    :       '&'     ;
   BAND_ASSIGN             :       "&="    ;
   LAND                    :       "&&"    ;
  -SEMI                    :       ';'             ;
  +SEMI                    :       ';'     ;
   
   protected
  -PANYS   :   ('a'..'z'|'A'..'Z'|'@'|'#'|'$'|'_'|'?');
  +PANY    :   ('a'..'z'|'A'..'Z'|'_');
   
   protected
  -ANY     :   (PANYS|COLON|'0'..'9'|'!');
  +SPECIAL :   ('@'|'#'|'$');
   
  -IDENT   :   PANYS (ANY)* PANYS;
  +protected
  +ANY     :   (PANY|COLON|'0'..'9');
  +
  +IDENT
  +	options {testLiterals=true;}
  +        :   (PANY (ANY)*) | (SPECIAL (ANY)+);
   
   //
   // The following are stolen from java.g in the ANTLR distribution.
  @@ -299,14 +331,15 @@
   WS  :   (   ' '
           |   '\t'
           |   '\f'
  -        // handle newlines
  -        |   (   "\r\n"  // Evil DOS
  +            // handle newlines
  +        |   (   options {generateAmbigWarnings=false;}
  +            :   "\r\n"  // Evil DOS
               |   '\r'    // Macintosh
               |   '\n'    // Unix (the right way)
               )
               { newline(); }
  -        )
  -        { $setType(Token.SKIP); }
  +        )+
  +        { _ttype = Token.SKIP;}
       ;
   
   // Single-line comments
  @@ -412,7 +445,7 @@
   
   
   // a numeric literal
  -NUM_INT
  +NUMBER
       {boolean isDecimal=false;}
       :   '.' {_ttype = DOT;}
               (('0'..'9')+ (EXPONENT)? (FLOAT_SUFFIX)? { _ttype = NUMBER; })?
  
  
  

----------------------------------------------------------------------
In case of troubles, e-mail:     webmaster@xml.apache.org
To unsubscribe, e-mail:          cocoon-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: cocoon-cvs-help@xml.apache.org


Mime
View raw message