pygments.rb 0.6.3 → 1.0.0

data/vendor/pygments-main/tests/examplefiles/Sudoku.lhs

@@ -1,382 +0,0 @@
-% Copyright 2005 Brian Alliet
-
-\documentclass[11pt]{article}
-\usepackage{palatino}
-\usepackage{fullpage}
-\usepackage{parskip}
-\usepackage{lhs}
-
-\begin{document}
-
-\title{Sudoku Solver}
-\author{Brian Alliet}
-\maketitle
-
-\ignore{
-\begin{code}
-module Sudoku (
-    Sudoku,
-    makeSudoku, solve, eliminate, analyze, backtrack,
-    main
-    ) where
-
-import Array
-import Monad
-import List (union,intersperse,transpose,(\\),nub,nubBy)
-\end{code}
-}
-
-\section{Introduction}
-
-This Haskell module implements a solver for Sudoku~\footnote{http://en.wikipedia.org/wiki/Sudoku} puzzles. It can solve
-any Sudoku puzzle, even those that require backtracking.
-
-\section{Data Types}
-
-\begin{code}
-data CellState a = Known a | Unknown [a] | Impossible deriving Eq
-\end{code}
-
-Each cell in a Sudoku grid can be in one of three states: ``Known'' if it has a known correct value~\footnote{Actually
-this doesn't always means it is correct. While we are in the backtracking stage we make our guesses ``Known''.},
-``Unknown'' if there is still more than one possible correct value, or ``Impossible'' if there is no value that can
-possibly fit the cell. Sudoku grids with ``Impossible'' cells are quickly discarded by the {\tt solve} function.
-
-\begin{code}
-type Coords = (Int,Int)
-type Grid a = Array Coords (CellState a)
-newtype Sudoku a = Sudoku { unSudoku :: Grid a } deriving Eq
-\end{code}
-
-We represent a Sudoku grid as an Array indexed by integer coordinates. We additionally define a newtype wrapper for the
-grid. The smart constructor, {\tt makeSudoku} verifies some invariants before creating the Sudoku value. All the public
-API functions operate on the Sudoku type.
-
-\begin{code}
-instance Show a => Show (Sudoku a) where showsPrec p = showParen (p>0) . showsGrid . unSudoku
-instance Show a => Show (CellState a) where showsPrec _ = showsCell
-\end{code}
-
-We define {\tt Show} instances for the above types.
-
-\section{Internal Functions}
-
-\begin{code}
-size :: Grid a -> Int
-size = (+1).fst.snd.bounds
-\end{code}
-
-{\tt size} returns the size (the width, height, and number of subboxes) for a Sudoku grid. We ensure Grid's are always
-square and indexed starting at $(0,0)$ so simply incrementing either of the array's upper bounds is correct.
-
-\begin{code}
-getRow,getCol,getBox :: Grid a -> Int -> [(Coords,CellState a)]
-getRow grid r = [let l = (r,c) in (l,grid!l)|c <- [0..size grid - 1]]
-getCol grid c = [let l = (r,c) in (l,grid!l)|r <- [0..size grid - 1]]
-getBox grid b = [let l = (r,c) in (l,grid!l)|r <- [boxR..boxR+boxN-1],c <- [boxC..boxC+boxN-1]]
-    where
-        boxN = intSqrt (size grid); boxR = b `quot` boxN * boxN; boxC = b `rem`  boxN * boxN
-
-getBoxOf :: Grid a -> Coords -> [(Coords,CellState a)]
-getBoxOf grid (r,c) = grid `getBox` ((r `quot` boxN * boxN) + (c `quot` boxN))
-    where boxN = intSqrt (size grid)
-\end{code}
-
-{\tt getRow}, {\tt getCol}, and {\tt getBox} return the coordinates and values of the cell in row, column, or box
-number {\tt n}, {\tt r}, or {\tt b}.
-
-\begin{code}
-getNeighbors :: Eq a => Grid a -> Coords -> [(Coords,CellState a)]
-getNeighbors grid l@(r,c) = filter ((/=l).fst) 
-                          $ foldr (union.($grid)) [] 
-                          [(`getRow`r),(`getCol`c),(`getBoxOf`l)]
-\end{code}
-
-{\tt getNeighbors} returns the coordinates and values of all the neighbors of this cell.
-
-\begin{code}
-impossible :: Eq a => Grid a -> Coords -> [a]
-impossible grid l = map snd $ justKnowns $ grid `getNeighbors` l
-\end{code}
-
-{\tt impossible} returns a list of impossible values for a given cell. The impossible values consist of the values any
-``Known'' neighbors.
-
-\begin{code}
-justUnknowns :: [(Coords,CellState a)] -> [(Coords,[a])]
-justUnknowns = foldr (\c -> case c of (p,Unknown xs) -> ((p,xs):); _ -> id) []
-
-justKnowns :: [(Coords,CellState a)] -> [(Coords,a)]
-justKnowns = foldr (\c -> case c of (p,Known x) -> ((p,x):); _ -> id) []
-\end{code}
-
-{\tt justUnknowns} and {\tt justKnowns} return only the Known or Unknown values (with the constructor stripped off)
-from a list of cells.
-
-\begin{code}
-updateGrid :: Grid a -> [(Coords,CellState a)] -> Maybe (Grid a)
-updateGrid _ [] = Nothing
-updateGrid grid xs = Just $ grid // nubBy (\(x,_) (y,_) -> x==y) xs
-\end{code}
-
-{\tt updateGrid} applies a set of updates to a grid and returns the new grid only if it was updated.
-
-\section{Public API}
-
-\begin{code}
-makeSudoku :: (Num a, Ord a, Enum a) => [[a]] -> Sudoku a
-makeSudoku xs
-    | not (all ((==size).length) xs) = error "error not a square"
-    | (intSqrt size)^(2::Int) /= size = error "error dims aren't perfect squares"
-    | any (\x -> x < 0 || x > fromIntegral size) (concat xs) = error "value out of range"
-    | otherwise = Sudoku (listArray ((0,0),(size-1,size-1)) states)
-    where
-        size = length xs
-        states = map f (concat xs)
-        f 0 = Unknown [1..fromIntegral size]
-        f x = Known x
-\end{code}
-
-{\tt makeSudoku} makes a {\tt Sudoku} value from a list of numbers. The given matrix must be square and have dimensions
-that are a perfect square. The possible values for each cell range from 1 to the dimension of the square with ``0''
-representing unknown values.\footnote{The rest of the code doesn't depend on any of this weird ``0'' is unknown
-representation. In fact, it doesn't depend on numeric values at all. ``0'' is just used here because it makes
-representing grids in Haskell source code easier.}
-
-\begin{code}
-eliminate :: Eq a => Sudoku a -> Maybe (Sudoku a)
-eliminate (Sudoku grid) = fmap Sudoku $ updateGrid grid changes >>= sanitize
-    where
-        changes = concatMap findChange $ assocs grid
-        findChange (l,Unknown xs) 
-            = map ((,) l) 
-            $ case filter (not.(`elem`impossible grid l)) xs of
-                [] -> return Impossible
-                [x] -> return $ Known x
-                xs'
-                    | xs' /= xs -> return $ Unknown xs'
-                    | otherwise -> mzero
-        findChange _ = mzero
-        sanitize grid = return $ grid // [(l,Impossible) | 
-            (l,x) <- justKnowns changes, x `elem` impossible grid l]
-\end{code}
-
-The {\tt eliminate} phase tries to remove possible choices for ``Unknowns'' based on ``Known'' values in the same row,
-column, or box as the ``Unknown'' value. For each cell on the grid we find its ``neighbors'', that is, cells in the
-same row, column, or box. Out of those neighbors we get a list of all the ``Known'' values. We can eliminate all of
-these from our list of candidates for this cell. If we're lucky enough to eliminate all the candidates but one we have
-a new ``Known'' value. If we're unlucky enough to have eliminates {\bf all} the possible candidates we have a new
-``Impossible'' value.
-
-After iterating though every cell we make one more pass looking for conflicting changes. {\tt sanitize} marks cells as
-``Impossible'' if we have conflicting ``Known'' values.
-
-\begin{code}
-analyze :: Eq a => Sudoku a -> Maybe (Sudoku a)
-analyze (Sudoku grid) = fmap Sudoku $ updateGrid grid $ nub [u |
-            f <- map ($grid) [getRow,getCol,getBox],
-            n <- [0..size grid - 1],
-            u <- unique (f n)]
-    where
-        unique xs = foldr f [] $ foldr (union.snd) [] unknowns \\ map snd (justKnowns xs)
-            where
-                unknowns = justUnknowns xs
-                f c = case filter ((c`elem`).snd) unknowns of
-                    [(p,_)] -> ((p,Known c):)
-                    _ -> id
-\end{code}
-
-The {\tt analyze} phase tries to turn ``Unknowns'' into ``Knowns'' when a certain ``Unknown'' is the only cell that
-contains a value needed in a given row, column, or box. We apply each of the functions {\tt getRow}, {\tt getCol}, and
-{\tt getBox} to all the indices on the grid, apply {\tt unique} to each group, and update the array with the
-results. {\tt unique}  gets a list of all  the unknown cells in the group and finds all the unknown values in each of
-those cells. Each of these values are iterated though looking for a value that is only contained in one cell. If such a
-value is found the cell containing it must be that value.
-
-\begin{code}
-backtrack :: (MonadPlus m, Eq a) => Sudoku a -> m (Sudoku a)
-backtrack (Sudoku grid) = case (justUnknowns (assocs grid)) of
-    [] -> return $ Sudoku grid
-    ((p,xs):_) -> msum $ map (\x -> solve $ Sudoku $ grid // [(p,Known x)]) xs
-\end{code}
-
-Sometimes the above two phases still aren't enough to solve a puzzle. For these rare puzzles backtracking is required.
-We attempt to solve the puzzle by replacing the first ``Unknown'' value with each of the candidate values and solving
-the resulting puzzles. Hopefully at least one of our choices will result in a solvable puzzle.
-
-We could actually solve any puzzle using backtracking alone, although this would be very inefficient. The above
-functions simplify most puzzles enough that the backtracking phase has to do hardly any work.
-
-\begin{code}
-solve :: (MonadPlus m, Eq a) => Sudoku a -> m (Sudoku a)
-solve sudoku = 
-    case eliminate sudoku of
-        Just new 
-            | any (==Impossible) (elems (unSudoku new))-> mzero
-            | otherwise -> solve new
-        Nothing -> case analyze sudoku of
-            Just new -> solve new
-            Nothing -> backtrack sudoku
-\end{code}
-
-{\tt solve} glues all the above phases together. First we run the {\tt eliminate} phase. If that found the puzzle  to
-be unsolvable we abort immediately. If {\tt eliminate} changed the grid we go though the {\tt eliminate} phase again
-hoping to eliminate more. Once {\tt eliminate} can do no more work we move on to the {\tt analyze} phase. If this
-succeeds in doing some work we start over again with the {\tt eliminate} phase. Once {\tt analyze} can do no more work
-we have no choice but to resort to backtracking. (However in most cases backtracking won't actually do anything because
-the puzzle is already solved.)
-
-\begin{code}
-showsCell :: Show a => CellState a -> ShowS
-showsCell (Known x) = shows x
-showsCell (Impossible) = showChar 'X'
-showsCell (Unknown xs) = \rest -> ('(':) 
-                       $ foldr id (')':rest)
-                       $ intersperse (showChar ' ')
-                       $ map shows xs
-\end{code}
-
-{\tt showCell} shows a cell.
-
-\begin{code}
-showsGrid :: Show a => Grid a -> ShowS
-showsGrid grid = showsTable [[grid!(r,c) | c <- [0..size grid-1]] | r <- [0..size grid-1]]
-\end{code}
-
-{\tt showGrid} show a grid.
-
-\begin{code}
--- FEATURE: This is pretty inefficient
-showsTable :: Show a => [[a]] -> ShowS
-showsTable xs = (showChar '\n' .) $ showString $ unlines $ map (concat . intersperse " ") xs''
-    where
-        xs' = (map.map) show xs
-        colWidths = map (max 2 . maximum . map length) (transpose xs')
-        xs'' = map (zipWith (\n s -> s ++ (replicate (n - length s) ' ')) colWidths) xs'
-\end{code}
-
-{\tt showsTable} shows a table (or matrix). Every column has the same width so things line up.
-
-\begin{code}
-intSqrt :: Integral a => a -> a
-intSqrt n
-    | n < 0 = error "intSqrt: negative n"
-    | otherwise = f n
-    where
-        f x = if y < x then f y else x
-            where y = (x + (n `quot` x)) `quot` 2
-\end{code}
-
-{\tt intSqrt} is Newton`s Iteration for finding integral square roots.
-
-\ignore{
-\begin{code}
-test :: Sudoku Int
-test = makeSudoku [
-    [0,6,0,1,0,4,0,5,0],
-    [0,0,8,3,0,5,6,0,0],
-    [2,0,0,0,0,0,0,0,1],
-    [8,0,0,4,0,7,0,0,6],
-    [0,0,6,0,0,0,3,0,0],
-    [7,0,0,9,0,1,0,0,4],
-    [5,0,0,0,0,0,0,0,2],
-    [0,0,7,2,0,6,9,0,0],
-    [0,4,0,5,0,8,0,7,0]]
-
-test2 :: Sudoku Int
-test2 = makeSudoku [
-    [0,7,0,0,0,0,8,0,0],
-    [0,0,0,2,0,4,0,0,0],
-    [0,0,6,0,0,0,0,3,0],
-    [0,0,0,5,0,0,0,0,6],
-    [9,0,8,0,0,2,0,4,0],
-    [0,5,0,0,3,0,9,0,0],
-    [0,0,2,0,8,0,0,6,0],
-    [0,6,0,9,0,0,7,0,1],
-    [4,0,0,0,0,3,0,0,0]]
-
-testSmall :: Sudoku Int
-testSmall = makeSudoku [
-    [1,0,0,0,0,0,0,0,0],
-    [0,0,2,7,4,0,0,0,0],
-    [0,0,0,5,0,0,0,0,4],
-    [0,3,0,0,0,0,0,0,0],
-    [7,5,0,0,0,0,0,0,0],
-    [0,0,0,0,0,9,6,0,0],
-    [0,4,0,0,0,6,0,0,0],
-    [0,0,0,0,0,0,0,7,1],
-    [0,0,0,0,0,1,0,3,0]]
-
-testHard :: Sudoku Int
-testHard = makeSudoku [
-    [0,0,0,8,0,2,0,0,0],
-    [5,0,0,0,0,0,0,0,1],
-    [0,0,6,0,5,0,3,0,0],
-    [0,0,9,0,1,0,8,0,0],
-    [1,0,0,0,0,0,0,0,2],
-    [0,0,0,9,0,7,0,0,0],
-    [0,6,1,0,3,0,7,8,0],
-    [0,5,0,0,0,0,0,4,0],
-    [0,7,2,0,4,0,1,5,0]]
-
-testHard2 :: Sudoku Int
-testHard2 = makeSudoku [
-    [3,0,0,2,0,0,9,0,0],
-    [0,0,0,0,0,0,0,0,5],
-    [0,7,0,1,0,4,0,0,0],
-    [0,0,9,0,0,0,8,0,0],
-    [5,0,0,0,7,0,0,0,6],
-    [0,0,1,0,0,0,2,0,0],
-    [0,0,0,3,0,9,0,4,0],
-    [8,0,0,0,0,0,0,0,0],
-    [0,0,6,0,0,5,0,0,7]]
-
-testHW :: Sudoku Int
-testHW = makeSudoku [
-    [0,0,0,1,0,0,7,0,2],    
-    [0,3,0,9,5,0,0,0,0],
-    [0,0,1,0,0,2,0,0,3],
-    [5,9,0,0,0,0,3,0,1],
-    [0,2,0,0,0,0,0,7,0],
-    [7,0,3,0,0,0,0,9,8],
-    [8,0,0,2,0,0,1,0,0],
-    [0,0,0,0,8,5,0,6,0],
-    [6,0,5,0,0,9,0,0,0]]
-
-testTough :: Sudoku Int
-testTough = makeSudoku $ map (map read . words) $ lines $
- "8 3 0  0 0 0  0 4 6\n"++
- "0 2 0  1 0 4  0 3 0\n"++
- "0 0 0  0 0 0  0 0 0\n"++
- "0 0 2  9 0 6  5 0 0\n"++
- "1 4 0  0 0 0  0 2 3\n"++
- "0 0 5  4 0 3  1 0 0\n"++
- "0 0 0  0 0 0  0 0 0\n"++
- "0 6 0  3 0 8  0 7 0\n"++
- "9 5 0  0 0 0  0 6 2\n"
-
-testDiabolical :: Sudoku Int 
-testDiabolical = makeSudoku $ map (map read . words) $ lines $
-  "8 0 0  7 0 1  0 0 2\n"++
-  "0 0 6  0 0 0  7 0 0\n"++
-  "0 1 7  0 0 0  8 9 0\n"++
-  "0 0 0  1 7 3  0 0 0\n"++
-  "7 0 0  0 0 0  0 0 6\n"++
-  "0 0 0  9 5 6  0 0 0\n"++
-  "0 9 5  0 0 0  4 1 0\n"++
-  "0 0 8  0 0 0  5 0 0\n"++
-  "3 0 0  6 0 5  0 0 7\n"
-
-main :: IO ()
-main = do
-    let
-        solve' p = case solve p of
-            [] -> fail $ "couldn't solve: " ++ show p
-            sols -> return sols
-    mapM_ (\p -> solve' p >>= putStrLn.show) [test,test2,testSmall,testHard,testHard2,testHW,testTough,testDiabolical]
-    return ()
-
-\end{code}
-}
-
-\end{document}

data/vendor/pygments-main/tests/examplefiles/addressbook.proto

@@ -1,30 +0,0 @@
-// See README.txt for information and build instructions.
-
-package tutorial;
-
-option java_package = "com.example.tutorial";
-option java_outer_classname = "AddressBookProtos";
-
-message Person {
-  required string name = 1;
-  required int32 id = 2;        // Unique ID number for this person.
-  optional string email = 3;
-
-  enum PhoneType {
-    MOBILE = 0;
-    HOME = 1;
-    WORK = 2;
-  }
-
-  message PhoneNumber {
-    required string number = 1;
-    optional PhoneType type = 2 [default = HOME];
-  }
-
-  repeated PhoneNumber phone = 4;
-}
-
-// Our address book file is just one of these.
-message AddressBook {
-  repeated Person person = 1;
-}

data/vendor/pygments-main/tests/examplefiles/antlr_ANTLRv3.g

@@ -1,608 +0,0 @@
-/*
- [The "BSD licence"]
- Copyright (c) 2005-2007 Terence Parr
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions
- are met:
- 1. Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
- 3. The name of the author may not be used to endorse or promote products
-    derived from this software without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/** ANTLR v3 grammar written in ANTLR v3 with AST construction */
-grammar ANTLRv3;
-
-options {
-	output=AST;
-	ASTLabelType=CommonTree;
-}
-
-tokens {
-	DOC_COMMENT;
-	PARSER;	
-    LEXER;
-    RULE;
-    BLOCK;
-    OPTIONAL;
-    CLOSURE;
-    POSITIVE_CLOSURE;
-    SYNPRED;
-    RANGE;
-    CHAR_RANGE;
-    EPSILON;
-    ALT;
-    EOR;
-    EOB;
-    EOA; // end of alt
-    ID;
-    ARG;
-    ARGLIST;
-    RET;
-    LEXER_GRAMMAR;
-    PARSER_GRAMMAR;
-    TREE_GRAMMAR;
-    COMBINED_GRAMMAR;
-    INITACTION;
-    LABEL; // $x used in rewrite rules
-    TEMPLATE;
-    SCOPE='scope';
-    SEMPRED;
-    GATED_SEMPRED; // {p}? =>
-    SYN_SEMPRED; // (...) =>   it's a manually-specified synpred converted to sempred
-    BACKTRACK_SEMPRED; // auto backtracking mode syn pred converted to sempred
-    FRAGMENT='fragment';
-    TREE_BEGIN='^(';
-    ROOT='^';
-    BANG='!';
-    RANGE='..';
-    REWRITE='->';
-}
-
-@members {
-	int gtype;
-}
-
-grammarDef
-    :   DOC_COMMENT?
-    	(	'lexer'  {gtype=LEXER_GRAMMAR;}    // pure lexer
-    	|   'parser' {gtype=PARSER_GRAMMAR;}   // pure parser
-    	|   'tree'   {gtype=TREE_GRAMMAR;}     // a tree parser
-    	|		     {gtype=COMBINED_GRAMMAR;} // merged parser/lexer
-    	)
-    	g='grammar' id ';' optionsSpec? tokensSpec? attrScope* action*
-    	rule+
-    	EOF
-    	-> ^( {adaptor.create(gtype,$g)}
-    		  id DOC_COMMENT? optionsSpec? tokensSpec? attrScope* action* rule+
-    		)
-    ;
-
-tokensSpec
-	:	TOKENS tokenSpec+ '}' -> ^(TOKENS tokenSpec+)
-	;
-
-tokenSpec
-	:	TOKEN_REF
-		(	'=' (lit=STRING_LITERAL|lit=CHAR_LITERAL)	-> ^('=' TOKEN_REF $lit)
-		|												-> TOKEN_REF
-		)
-		';'
-	;
-
-attrScope
-	:	'scope' id ACTION -> ^('scope' id ACTION)
-	;
-
-/** Match stuff like @parser::members {int i;} */
-action
-	:	'@' (actionScopeName '::')? id ACTION -> ^('@' actionScopeName? id ACTION)
-	;
-
-/** Sometimes the scope names will collide with keywords; allow them as
- *  ids for action scopes.
- */
-actionScopeName
-	:	id
-	|	l='lexer'	-> ID[$l]
-    |   p='parser'	-> ID[$p]
-	;
-
-optionsSpec
-	:	OPTIONS (option ';')+ '}' -> ^(OPTIONS option+)
-	;
-
-option
-    :   id '=' optionValue -> ^('=' id optionValue)
- 	;
- 	
-optionValue
-    :   id
-    |   STRING_LITERAL
-    |   CHAR_LITERAL
-    |   INT
-    |	s='*' -> STRING_LITERAL[$s]  // used for k=*
-    ;
-
-rule
-scope {
-	String name;
-}
-	:	DOC_COMMENT?
-		( modifier=('protected'|'public'|'private'|'fragment') )?
-		id {$rule::name = $id.text;}
-		'!'?
-		( arg=ARG_ACTION )?
-		( 'returns' rt=ARG_ACTION  )?
-		throwsSpec? optionsSpec? ruleScopeSpec? ruleAction*
-		':'	altList	';'
-		exceptionGroup?
-	    -> ^( RULE id {modifier!=null?adaptor.create(modifier):null} ^(ARG $arg)? ^(RET $rt)?
-	    	  optionsSpec? ruleScopeSpec? ruleAction*
-	    	  altList
-	    	  exceptionGroup?
-	    	  EOR["EOR"]
-	    	)
-	;
-
-/** Match stuff like @init {int i;} */
-ruleAction
-	:	'@' id ACTION -> ^('@' id ACTION)
-	;
-
-throwsSpec
-	:	'throws' id ( ',' id )* -> ^('throws' id+)
-	;
-
-ruleScopeSpec
-	:	'scope' ACTION -> ^('scope' ACTION)
-	|	'scope' id (',' id)* ';' -> ^('scope' id+)
-	|	'scope' ACTION
-		'scope' id (',' id)* ';'
-		-> ^('scope' ACTION id+ )
-	;
-
-block
-    :   lp='('
-		( (opts=optionsSpec)? ':' )?
-		a1=alternative rewrite ( '|' a2=alternative rewrite )*
-        rp=')'
-        -> ^( BLOCK[$lp,"BLOCK"] optionsSpec? alternative+ EOB[$rp,"EOB"] )
-    ;
-
-altList
-@init {
-	// must create root manually as it's used by invoked rules in real antlr tool.
-	// leave here to demonstrate use of {...} in rewrite rule
-	// it's really BLOCK[firstToken,"BLOCK"]; set line/col to previous ( or : token.
-    CommonTree blkRoot = (CommonTree)adaptor.create(BLOCK,input.LT(-1),"BLOCK");
-}
-    :   a1=alternative rewrite ( '|' a2=alternative rewrite )*
-		-> ^( {blkRoot} (alternative rewrite?)+ EOB["EOB"] )
-    ;
-
-alternative
-@init {
-	Token firstToken = input.LT(1);
-	Token prevToken = input.LT(-1); // either : or | I think
-}
-    :   element+ -> ^(ALT[firstToken,"ALT"] element+ EOA["EOA"])
-    |   -> ^(ALT[prevToken,"ALT"] EPSILON[prevToken,"EPSILON"] EOA["EOA"])
-    ;
-
-exceptionGroup
-	:	( exceptionHandler )+ ( finallyClause )?
-	|	finallyClause
-    ;
-
-exceptionHandler
-    :    'catch' ARG_ACTION ACTION -> ^('catch' ARG_ACTION ACTION)
-    ;
-
-finallyClause
-    :    'finally' ACTION -> ^('finally' ACTION)
-    ;
-
-element
-	:	elementNoOptionSpec
-	;
-
-elementNoOptionSpec
-	:	id (labelOp='='|labelOp='+=') atom
-		(	ebnfSuffix	-> ^( ebnfSuffix ^(BLOCK["BLOCK"] ^(ALT["ALT"] ^($labelOp id atom) EOA["EOA"]) EOB["EOB"]))
-		|				-> ^($labelOp id atom)
-		)
-	|	id (labelOp='='|labelOp='+=') block
-		(	ebnfSuffix	-> ^( ebnfSuffix ^(BLOCK["BLOCK"] ^(ALT["ALT"] ^($labelOp id block) EOA["EOA"]) EOB["EOB"]))
-		|				-> ^($labelOp id block)
-		)
-	|	atom
-		(	ebnfSuffix	-> ^(BLOCK["BLOCK"] ^(ALT["ALT"] atom EOA["EOA"]) EOB["EOB"])
-		|				-> atom
-		)
-	|	ebnf
-	|   ACTION
-	|   SEMPRED ( '=>' -> GATED_SEMPRED | -> SEMPRED )
-	|   treeSpec
-	;
-
-atom:   range ( (op='^'|op='!') -> ^($op range) | -> range )
-    |   terminal
-    |	notSet ( (op='^'|op='!') -> ^($op notSet) | -> notSet )
-    |   RULE_REF ( arg=ARG_ACTION )? ( (op='^'|op='!') )?
-    	-> {$arg!=null&&op!=null}?	^($op RULE_REF $arg)
-    	-> {$arg!=null}?			^(RULE_REF $arg)
-    	-> {$op!=null}?				^($op RULE_REF)
-    	-> RULE_REF
-    ;
-
-notSet
-	:	'~'
-		(	notTerminal	-> ^('~' notTerminal)
-		|	block		-> ^('~' block)
-		)
-	;
-
-treeSpec
-	:	'^(' element ( element )+ ')' -> ^(TREE_BEGIN element+)
-	;
-
-/** Matches ENBF blocks (and token sets via block rule) */
-ebnf
-@init {
-    Token firstToken = input.LT(1);
-}
-@after {
-	$ebnf.tree.getToken().setLine(firstToken.getLine());
-	$ebnf.tree.getToken().setCharPositionInLine(firstToken.getCharPositionInLine());
-}
-	:	block {Token op=input.LT(1);}
-		(	'?'		-> ^(OPTIONAL[op] block)
-		|	'*'		-> ^(CLOSURE[op] block)
-		|	'+'		-> ^(POSITIVE_CLOSURE[op] block)
-		|   '^'		-> ^('^' block)
-		|   '!'		-> ^('!' block)
-		|   '=>'	// syntactic predicate
-					-> {gtype==COMBINED_GRAMMAR &&
-					    Character.isUpperCase($rule::name.charAt(0))}?
-					   // if lexer rule in combined, leave as pred for lexer
-					   ^(SYNPRED["=>"] block)
-					// in real antlr tool, text for SYN_SEMPRED is predname
-					-> SYN_SEMPRED
-        |			-> block
-		)
-	;
-
-range!
-	:	c1=CHAR_LITERAL RANGE c2=CHAR_LITERAL -> ^(CHAR_RANGE[$c1,".."] $c1 $c2)
-	;
-
-terminal
-    :   (	CHAR_LITERAL				-> CHAR_LITERAL
-    		// Args are only valid for lexer rules
-		|   TOKEN_REF
-			( ARG_ACTION				-> ^(TOKEN_REF ARG_ACTION)
-			|							-> TOKEN_REF
-			)
-		|   STRING_LITERAL				-> STRING_LITERAL
-		|   '.'							-> '.'
-		)	
-		(	'^'							-> ^('^' $terminal)
-		|	'!' 						-> ^('!' $terminal)
-		)?
-	;
-
-notTerminal
-	:   CHAR_LITERAL
-	|	TOKEN_REF
-	|	STRING_LITERAL
-	;
-	
-ebnfSuffix
-@init {
-	Token op = input.LT(1);
-}
-	:	'?'	-> OPTIONAL[op]
-  	|	'*' -> CLOSURE[op]
-   	|	'+' -> POSITIVE_CLOSURE[op]
-	;
-	
-
-
-// R E W R I T E  S Y N T A X
-
-rewrite
-@init {
-	Token firstToken = input.LT(1);
-}
-	:	(rew+='->' preds+=SEMPRED predicated+=rewrite_alternative)*
-		rew2='->' last=rewrite_alternative
-        -> ^($rew $preds $predicated)* ^($rew2 $last)
-	|
-	;
-
-rewrite_alternative
-	:	rewrite_template
-	|	rewrite_tree_alternative
-   	|   /* empty rewrite */ -> ^(ALT["ALT"] EPSILON["EPSILON"] EOA["EOA"])
-	;
-	
-rewrite_template_block
-    :   lp='(' rewrite_template ')' -> ^(BLOCK[$lp,"BLOCK"] rewrite_template EOB[$lp,"EOB"])
-    ;
-
-rewrite_tree_block
-    :   lp='(' rewrite_tree_alternative ')'
-    	-> ^(BLOCK[$lp,"BLOCK"] rewrite_tree_alternative EOB[$lp,"EOB"])
-    ;
-
-rewrite_tree_alternative
-    :	rewrite_tree_element+ -> ^(ALT["ALT"] rewrite_tree_element+ EOA["EOA"])
-    ;
-
-rewrite_tree_element
-	:	rewrite_tree_atom
-	|	rewrite_tree_atom ebnfSuffix
-		-> ^( ebnfSuffix ^(BLOCK["BLOCK"] ^(ALT["ALT"] rewrite_tree_atom EOA["EOA"]) EOB["EOB"]))
-	|   rewrite_tree
-		(	ebnfSuffix
-			-> ^(BLOCK["BLOCK"] ^(ALT["ALT"] rewrite_tree EOA["EOA"]) EOB["EOB"])
-		|	-> rewrite_tree
-		)
-	|   rewrite_tree_ebnf
-	;
-
-rewrite_tree_atom
-    :   CHAR_LITERAL
-	|   TOKEN_REF ARG_ACTION? -> ^(TOKEN_REF ARG_ACTION?) // for imaginary nodes
-    |   RULE_REF
-	|   STRING_LITERAL
-	|   d='$' id -> LABEL[$d,$id.text] // reference to a label in a rewrite rule
-	|	ACTION
-	;
-
-rewrite_tree_ebnf
-@init {
-    Token firstToken = input.LT(1);
-}
-@after {
-	$rewrite_tree_ebnf.tree.getToken().setLine(firstToken.getLine());
-	$rewrite_tree_ebnf.tree.getToken().setCharPositionInLine(firstToken.getCharPositionInLine());
-}
-	:	rewrite_tree_block ebnfSuffix -> ^(ebnfSuffix rewrite_tree_block)
-	;
-	
-rewrite_tree
-	:	'^(' rewrite_tree_atom rewrite_tree_element* ')'
-		-> ^(TREE_BEGIN rewrite_tree_atom rewrite_tree_element* )
-	;
-
-/** Build a tree for a template rewrite:
-      ^(TEMPLATE (ID|ACTION) ^(ARGLIST ^(ARG ID ACTION) ...) )
-    where ARGLIST is always there even if no args exist.
-    ID can be "template" keyword.  If first child is ACTION then it's
-    an indirect template ref
-
-    -> foo(a={...}, b={...})
-    -> ({string-e})(a={...}, b={...})  // e evaluates to template name
-    -> {%{$ID.text}} // create literal template from string (done in ActionTranslator)
-	-> {st-expr} // st-expr evaluates to ST
- */
-rewrite_template
-	:   // -> template(a={...},...) "..."    inline template
-		{input.LT(1).getText().equals("template")}?
-		id lp='(' rewrite_template_args	')'
-		st=( DOUBLE_QUOTE_STRING_LITERAL | DOUBLE_ANGLE_STRING_LITERAL )
-		-> ^(TEMPLATE[$lp,"TEMPLATE"] id rewrite_template_args $st)
-
-	|	// -> foo(a={...}, ...)
-		rewrite_template_ref
-
-	|	// -> ({expr})(a={...}, ...)
-		rewrite_indirect_template_head
-
-	|	// -> {...}
-		ACTION
-	;
-
-/** -> foo(a={...}, ...) */
-rewrite_template_ref
-	:	id lp='(' rewrite_template_args	')'
-		-> ^(TEMPLATE[$lp,"TEMPLATE"] id rewrite_template_args)
-	;
-
-/** -> ({expr})(a={...}, ...) */
-rewrite_indirect_template_head
-	:	lp='(' ACTION ')' '(' rewrite_template_args ')'
-		-> ^(TEMPLATE[$lp,"TEMPLATE"] ACTION rewrite_template_args)
-	;
-
-rewrite_template_args
-	:	rewrite_template_arg (',' rewrite_template_arg)*
-		-> ^(ARGLIST rewrite_template_arg+)
-	|	-> ARGLIST
-	;
-
-rewrite_template_arg
-	:   id '=' ACTION -> ^(ARG[$id.start] id ACTION)
-	;
-
-id	:	TOKEN_REF -> ID[$TOKEN_REF]
-	|	RULE_REF  -> ID[$RULE_REF]
-	;
-
-// L E X I C A L   R U L E S
-
-SL_COMMENT
- 	:	'//'
- 	 	(	' $ANTLR ' SRC // src directive
- 		|	~('\r'|'\n')*
-		)
-		'\r'? '\n'
-		{$channel=HIDDEN;}
-	;
-
-ML_COMMENT
-	:	'/*' {if (input.LA(1)=='*') $type=DOC_COMMENT; else $channel=HIDDEN;} .* '*/'
-	;
-
-CHAR_LITERAL
-	:	'\'' LITERAL_CHAR '\''
-	;
-
-STRING_LITERAL
-	:	'\'' LITERAL_CHAR LITERAL_CHAR* '\''
-	;
-
-fragment
-LITERAL_CHAR
-	:	ESC
-	|	~('\''|'\\')
-	;
-
-DOUBLE_QUOTE_STRING_LITERAL
-	:	'"' LITERAL_CHAR* '"'
-	;
-
-DOUBLE_ANGLE_STRING_LITERAL
-	:	'<<' .* '>>'
-	;
-
-fragment
-ESC	:	'\\'
-		(	'n'
-		|	'r'
-		|	't'
-		|	'b'
-		|	'f'
-		|	'"'
-		|	'\''
-		|	'\\'
-		|	'>'
-		|	'u' XDIGIT XDIGIT XDIGIT XDIGIT
-		|	. // unknown, leave as it is
-		)
-	;
-
-fragment
-XDIGIT :
-		'0' .. '9'
-	|	'a' .. 'f'
-	|	'A' .. 'F'
-	;
-
-INT	:	'0'..'9'+
-	;
-
-ARG_ACTION
-	:	NESTED_ARG_ACTION
-	;
-
-fragment
-NESTED_ARG_ACTION :
-	'['
-	(	options {greedy=false; k=1;}
-	:	NESTED_ARG_ACTION
-	|	ACTION_STRING_LITERAL
-	|	ACTION_CHAR_LITERAL
-	|	.
-	)*
-	']'
-	{setText(getText().substring(1, getText().length()-1));}
-	;
-
-ACTION
-	:	NESTED_ACTION ( '?' {$type = SEMPRED;} )?
-	;
-
-fragment
-NESTED_ACTION :
-	'{'
-	(	options {greedy=false; k=3;}
-	:	NESTED_ACTION
-	|	SL_COMMENT
-	|	ML_COMMENT
-	|	ACTION_STRING_LITERAL
-	|	ACTION_CHAR_LITERAL
-	|	.
-	)*
-	'}'
-	{$channel = DEFAULT_TOKEN_CHANNEL;}
-   ;
-
-fragment
-ACTION_CHAR_LITERAL
-	:	'\'' (ACTION_ESC|~('\\'|'\'')) '\''
-	;
-
-fragment
-ACTION_STRING_LITERAL
-	:	'"' (ACTION_ESC|~('\\'|'"'))+ '"'
-	;
-
-fragment
-ACTION_ESC
-	:	'\\\''
-	|	'\\"'
-	|	'\\' ~('\''|'"')
-	;
-
-TOKEN_REF
-	:	'A'..'Z' ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*
-	;
-
-RULE_REF
-	:	'a'..'z' ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*
-	;
-
-/** Match the start of an options section.  Don't allow normal
- *  action processing on the {...} as it's not a action.
- */
-OPTIONS
-	:	'options' WS_LOOP '{' {$channel=DEFAULT_TOKEN_CHANNEL;} // WS_LOOP sets channel
-	;
-	
-TOKENS
-	:	'tokens' WS_LOOP '{' {$channel=DEFAULT_TOKEN_CHANNEL;}
-	;
-
-/** Reset the file and line information; useful when the grammar
- *  has been generated so that errors are shown relative to the
- *  original file like the old C preprocessor used to do.
- */
-fragment
-SRC	:	'src' ' ' file=ACTION_STRING_LITERAL ' ' line=INT {$channel=HIDDEN;}
-	;
-
-WS	:	(	' '
-		|	'\t'
-		|	'\r'? '\n'
-		)+
-		{$channel=HIDDEN;}
-	;
-
-fragment
-WS_LOOP
-	:	(	WS
-		|	SL_COMMENT
-		|	ML_COMMENT
-		)*
-		{$channel=HIDDEN;}
-	;
-