SF.net SVN: jython:[7267] trunk/jython/grammar/Python.g

Revision: 7267
          http://jython.svn.sourceforge.net/jython/?rev=7267&view=rev
Author:   fwierzbicki
Date:     2011-03-25 15:25:07 +0000 (Fri, 25 Mar 2011)

Log Message:
-----------
Reformat so that I can more easily script the removal of the grammar actions. I
am probably going to need another parser to check "from __future__".

Modified Paths:
--------------
    trunk/jython/grammar/Python.g

Modified: trunk/jython/grammar/Python.g
===================================================================
--- trunk/jython/grammar/Python.g	2011-03-24 20:12:46 UTC (rev 7266)
+++ trunk/jython/grammar/Python.g	2011-03-25 15:25:07 UTC (rev 7267)
@@ -267,6 +267,8 @@
     }
 }
 
+//START OF PARSER RULES
+
 //single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE
 single_input
 @init {
@@ -318,8 +320,9 @@
     : (NEWLINE
       | stmt
       {
-          if ($stmt.stypes != null)
-                 {stypes.addAll($stmt.stypes);}
+          if ($stmt.stypes != null) {
+              stypes.addAll($stmt.stypes);
+          }
       }
       )* EOF
          {
@@ -446,8 +449,13 @@
 
 //funcdef: [decorators] 'def' NAME parameters ':' suite
 funcdef
-@init { stmt stype = null; }
-@after { $funcdef.tree = stype; }
+@init {
+    stmt stype = null;
+}
+
+@after {
+    $funcdef.tree = stype;
+}
     : decorators? DEF NAME parameters COLON suite[false]
     {
         Token t = $DEF;
@@ -625,29 +633,53 @@
 augassign
     returns [operatorType op]
     : PLUSEQUAL
-        {$op = operatorType.Add;}
+        {
+            $op = operatorType.Add;
+        }
     | MINUSEQUAL
-        {$op = operatorType.Sub;}
+        {
+            $op = operatorType.Sub;
+        }
     | STAREQUAL
-        {$op = operatorType.Mult;}
+        {
+            $op = operatorType.Mult;
+        }
     | SLASHEQUAL
-        {$op = operatorType.Div;}
+        {
+            $op = operatorType.Div;
+        }
     | PERCENTEQUAL
-        {$op = operatorType.Mod;}
+        {
+            $op = operatorType.Mod;
+        }
     | AMPEREQUAL
-        {$op = operatorType.BitAnd;}
+        {
+            $op = operatorType.BitAnd;
+        }
     | VBAREQUAL
-        {$op = operatorType.BitOr;}
+        {
+            $op = operatorType.BitOr;
+        }
     | CIRCUMFLEXEQUAL
-        {$op = operatorType.BitXor;}
+        {
+            $op = operatorType.BitXor;
+        }
     | LEFTSHIFTEQUAL
-        {$op = operatorType.LShift;}
+        {
+            $op = operatorType.LShift;
+        }
     | RIGHTSHIFTEQUAL
-        {$op = operatorType.RShift;}
+        {
+            $op = operatorType.RShift;
+        }
     | DOUBLESTAREQUAL
-        {$op = operatorType.Pow;}
+        {
+            $op = operatorType.Pow;
+        }
     | DOUBLESLASHEQUAL
-        {$op = operatorType.FloorDiv;}
+        {
+            $op = operatorType.FloorDiv;
+        }
     ;
 
 //print_stmt: 'print' ( [ test (',' test)* [','] ] |
@@ -1085,7 +1117,10 @@
     [expr_contextType ctype] returns [Token leftTok]
     : NOT nt=not_test[ctype]
    -> ^(NOT<UnaryOp>[$NOT, unaryopType.Not, actions.castExpr($nt.tree)])
-    | comparison[ctype] {$leftTok = $comparison.leftTok;}
+    | comparison[ctype]
+      {
+          $leftTok = $comparison.leftTok;
+      }
     ;
 
 //comparison: expr (comp_op expr)*
@@ -1116,27 +1151,49 @@
 comp_op
     returns [cmpopType op]
     : LESS
-        {$op = cmpopType.Lt;}
+      {
+          $op = cmpopType.Lt;
+      }
     | GREATER
-        {$op = cmpopType.Gt;}
+      {
+          $op = cmpopType.Gt;
+      }
     | EQUAL
-        {$op = cmpopType.Eq;}
+      {
+          $op = cmpopType.Eq;
+      }
     | GREATEREQUAL
-        {$op = cmpopType.GtE;}
+      {
+          $op = cmpopType.GtE;
+      }
     | LESSEQUAL
-        {$op = cmpopType.LtE;}
+      {
+          $op = cmpopType.LtE;
+      }
     | ALT_NOTEQUAL
-        {$op = cmpopType.NotEq;}
+      {
+          $op = cmpopType.NotEq;
+      }
     | NOTEQUAL
-        {$op = cmpopType.NotEq;}
+      {
+          $op = cmpopType.NotEq;
+      }
     | IN
-        {$op = cmpopType.In;}
+      {
+          $op = cmpopType.In;
+      }
     | NOT IN
-        {$op = cmpopType.NotIn;}
+      {
+          $op = cmpopType.NotIn;
+      }
     | IS
-        {$op = cmpopType.Is;}
+      {
+          $op = cmpopType.Is;
+      }
     | IS NOT
-        {$op = cmpopType.IsNot;}
+      {
+          $op = cmpopType.IsNot;
+      }
     ;
 
 
@@ -1242,9 +1299,13 @@
 shift_op
     returns [operatorType op]
     : LEFTSHIFT
-        {$op = operatorType.LShift;}
+      {
+          $op = operatorType.LShift;
+      }
     | RIGHTSHIFT
-        {$op = operatorType.RShift;}
+      {
+          $op = operatorType.RShift;
+      }
     ;
 
 //arith_expr: term (('+'|'-') term)*
@@ -1287,9 +1348,13 @@
 arith_op
     returns [operatorType op]
     : PLUS
-        {$op = operatorType.Add;}
+      {
+          $op = operatorType.Add;
+      }
     | MINUS
-        {$op = operatorType.Sub;}
+      {
+          $op = operatorType.Sub;
+      }
     ;
 
 //term: factor (('*'|'/'|'%'|'//') factor)*
@@ -1323,14 +1388,22 @@
 
 term_op
     returns [operatorType op]
-    :STAR
-        {$op = operatorType.Mult;}
-    |SLASH
-        {$op = operatorType.Div;}
-    |PERCENT
-        {$op = operatorType.Mod;}
-    |DOUBLESLASH
-        {$op = operatorType.FloorDiv;}
+    : STAR
+      {
+          $op = operatorType.Mult;
+      }
+    | SLASH
+      {
+          $op = operatorType.Div;
+      }
+    | PERCENT
+      {
+          $op = operatorType.Mod;
+      }
+    | DOUBLESLASH
+      {
+          $op = operatorType.FloorDiv;
+      }
     ;
 
 //factor: ('+'|'-'|'~') factor | power
@@ -1340,11 +1413,17 @@
     $factor.tree = $etype;
 }
     : PLUS p=factor
-        {$etype = new UnaryOp($PLUS, unaryopType.UAdd, $p.etype);}
+      {
+          $etype = new UnaryOp($PLUS, unaryopType.UAdd, $p.etype);
+      }
     | MINUS m=factor
-        {$etype = actions.negate($MINUS, $m.etype);}
+      {
+          $etype = actions.negate($MINUS, $m.etype);
+      }
     | TILDE t=factor
-        {$etype = new UnaryOp($TILDE, unaryopType.Invert, $t.etype);}
+      {
+          $etype = new UnaryOp($TILDE, unaryopType.Invert, $t.etype);
+      }
     | power
       {
           $etype = actions.castExpr($power.tree);
@@ -1399,7 +1478,10 @@
 //       NAME | NUMBER | STRING+)
 atom
     returns [Token lparen = null]
-    : LPAREN {$lparen = $LPAREN;}
+    : LPAREN
+      {
+          $lparen = $LPAREN;
+      }
       ( yield_expr
      -> yield_expr
       | testlist_gexp
@@ -1475,8 +1557,7 @@
 }
     : t+=test[$expr::ctype]
         ( ((options {k=2;}: c1=COMMA t+=test[$expr::ctype])* (c2=COMMA)?
-         -> { $c1 != null || $c2 != null }?
-                ^(COMMA<Tuple>[$testlist_gexp.start, actions.castExprs($t), $expr::ctype])
+         -> { $c1 != null || $c2 != null }? ^(COMMA<Tuple>[$testlist_gexp.start, actions.castExprs($t), $expr::ctype])
          -> test
           )
         | (gen_for[gens]
@@ -1778,6 +1859,7 @@
    -> ^(YIELD<Yield>[$YIELD, actions.castExpr($testlist.tree)])
     ;
 
+//START OF LEXER RULES
 AS        : 'as' ;
 ASSERT    : 'assert' ;
 BREAK     : 'break' ;


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

------------------------------------------------------------------------------
Enable your software for Intel(R) Active Management Technology to meet the
growing manageability and security demands of your customers. Businesses
are taking advantage of Intel(R) vPro (TM) technology - will your software 
be a part of the solution? Download the Intel(R) Manageability Checker 
today! http://p.sf.net/sfu/intel-dev2devmar