antlr3 1.2.3

data/ANTLR-LICENSE.txt

@@ -0,0 +1,26 @@
+[The "BSD licence"]
+Copyright (c) 2003-2008 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.

data/History.txt

@@ -0,0 +1,66 @@
+h1(update). V1.1.1 2009-10-24 Kyle Yetter  <kcy5b@yahoo.com>
+
+h2(minor). minor alteration to TokenScheme
+
+* TokenScheme#register_name would raise an error if the token type was anonymous (i.e. T__19 or such) and the new name didn't have the format "'a string'". That works well for ANTLR tokens, but it's generally pointless, so I got rid of those restrictions. 
+
+|\2. MODIFIED |
+| lib/antlr3/token.rb | made minor changes to ANTLR3::TokenScheme#register_name |
+
+h1(update). V1.1.0 2009-10-19 Kyle Yetter  <kcy5b@yahoo.com>
+
+h2(major). moved FilterMode
+
+* since <tt>ANTLR3::Lexer::FilterMode</tt> is only necessary in lexers that specify filter=true, I moved it out of antlr3/recognizers.rb to its own file, antlr3/modes/filter.rb.
+
+* the FilterMode module is no longer in the Lexer namespace, but in the broader ANTLR3 namespace ... i.e. module ANTLR3::Lexer::FilterMode ==> module ANTLR3::FilterMode
+
+* I added an autoload entry to the ANTLR3 module in antlr3.rb for FilterMode, thus the module is autoloaded as needed whenever the constant ANTLR3::FilterMode is referenced
+
+|\2. MODIFIED                                                       |
+| lib/antlr3/recognizers.rb  | removed Lexer::FilterMode definition |
+| lib/antlr3.rb              | added autoload :FilterMode entry     |
+|\2. CREATED                                                        |
+| lib/antlr3/modes/filter.rb | contains FilterMode module extracted from recognizers.rb |
+
+h2(major). new module ASTBuilder
+  
+* created a new module, ANTLR3::ASTBuilder
+* all tree-building recognizers (parsers and tree parsers with the output=AST option) include this module
+* provides a way to test a recognizer to see if it is an AST-building recognizer (rec.is_a?(ANTLR3::ASTBuilder)) and it also added a number of methods to help clean up generated AST-parser code
+
+|\2. MODIFIED                                                       |
+| lib/antlr3.rb              | added the usual autoload entry for ASTBuilder |
+| templates/AST.stg          | added ``include ANTLR3::ASTBuilder'' to automatically include the module on all AST-output recognizers |
+|\2. CREATED                                                        |
+| lib/antlr3/modes/ast-builder.rb | defined new module ANTLR3::ASTBuilder |
+  
+h2(major). refactored debug and profile modes
+  
+* began process of organizing/cleaning-up the ANTLR3::Debug module (in file lib/antlr3/debug.rb), which contains all runtime support code and features for --debug and --profile option code output.
+* extracted profiling-oriented classes and modules from the Debug module and moved them to a new file, lib/antlr3/profile.rb.
+* since usually you're only using one particular type of Debug::EventListener at a time, I moved the six or so different EventListener classes out of Debug and into their own respective files in the antlr3/debug directory
+* since tree-oriented debugging hooks (Debug::TreeAdaptor and such) are only necessary for tree-oriented code, and thus are not part of the essential core, I moved the tree-related event modules out of Debug and into a separate file, lib/antlr3/tree/debug.rb
+* debug.rb now only defines the core EventListener interface module and the event-hook modules ParserEvents, TokenStream, and the expanded RecognizerSharedState class
+* as with most classes that aren't loaded by default in the runtime library, I strategically placed autoload statements in appropriate modules to autoload any of the Debug modules and classes I yanked out of the debug.rb, so there shouldn't be any need for extra 'require' statements to use the classes
+
+|\2. MODIFIED                                                       |
+| lib/antlr3/debug.rb | removed definitions: EventSocketProxy, RemoteEventSocketListener, TraceEventListener, RuleTracer, EventHub, TreeNodeStream, TreeAdaptor, ParserProfilingEvents, Profiler, Profiler::Profile, Profiler::DataSet |
+|\2. CREATED                                                        |
+| lib/antlr3/debug/event-hub.rb | new home for Debug::EventHub |
+| lib/antlr3/debug/record-event-listener.rb | new home for Debug::RecordEventListener |
+| lib/antlr3/debug/rule-tracer.rb | new home for Debug::RuleTracer |
+| lib/antlr3/debug/socket.rb | new home for Debug::EventSocketProxy and Debug::RemoteEventSocketListener |
+| lib/antlr3/debug/trace-event-listener.rb | new home for Debug::TraceEventListener |
+| lib/antlr3/profile.rb | new profile-oriented module, Profile, contains former debug classes Profile, ProfileEvents, and Profiler |
+| lib/antlr3/tree/debug.rb | new home for Debug::TreeAdaptor and Debug::TreeNodeStream |
+
+h2(minor). moved most of the core-extension code to new Util module
+
+* as handy as it is to add new functions to core classes, I moved most of the code in the core-extension directory to the new slightly-nebulous, catch-all dumping ground modules, ANTLR3::Util and ANTLR3::ClassMacros. String and Module methods defined in the extensions were only used in a small handful of places and thus it seemed intrusive to polute the core classes with these utility methods for little payoff.
+* ANTLR classes now extend ANTLR3::ClassMacros when necessary. It defines 'abstract' to easily create abstract methods. It also provides a new method, #shared_attribute, which defines an attribute accessor with a writer
+
+h1(update). V1.0.0 2009-10-14 Kyle Yetter  <kcy5b@yahoo.com>
+
+h2(major). Initial Release: Birthday!
+

data/README.txt

@@ -0,0 +1,139 @@
+ANTLR 3 for Ruby
+    by Kyle Yetter (kcy5b@yahoo.com)
+    http://antlr3.rubyforge.org
+
+== DESCRIPTION:
+
+Fully-featured ANTLR 3 parser generation for Ruby.
+
+ANTLR (ANother Tool for Language Recognition) is a tool that is used to generate
+code for performing a variety of language recognition tasks: lexing, parsing,
+abstract syntax tree construction and manipulation, tree structure recognition,
+and input translation. The tool operates simillarly to other parser generators,
+taking in a grammar specification written in the special ANTLR metalanguage and
+producing source code that implements the recognition functionality.
+
+While the tool itself is implemented in Java, it has an extensible design that
+allows for code generation in other programming languages. To implement an
+ANTLR language target, a developer may supply a set of templates written in the
+StringTemplate (http://www.stringtemplate.org) language.
+
+ANTLR is currently distributed with a fairly limited Ruby target implementation.
+While it does provide implementation for basic lexer and parser classes, the
+target does not provide any implementation for abstract syntax tree
+construction, tree parser class generation, input translation, or a number of
+the other ANTLR features that give the program an edge over traditional code
+generators.
+
+This gem packages together a complete implementation of the majority of features
+ANTLR provides for other language targets, such as Java and Python. It contains:
+
+* A customized version of the latest ANTLR program, bundling all necessary
+  java code and templates for producing fully featured language recognition
+  in ruby code
+
+* a ruby runtime library that collects classes used throughout the code that
+  ANTLR generates
+  
+* a wrapper script, `antlr4ruby', which executes the ANTLR command line tool
+  after ensuring the ANTLR jar is java's class path
+
+== FEATURES
+
+1. generates ruby code capable of:
+   * lexing text input
+   * parsing lexical output and responding with arbitrary actions 
+   * constructing Abstract Syntax Trees (ASTs)
+   * parsing AST structure and responding with arbitrary actions
+   * translating input source to some desired output format
+
+2. This package can serve as a powerful assistant when performing tasks
+   such as:
+   * code compilation
+   * source code highlighting and formatting
+   * domain-specific language implementation
+   * source code extraction and analysis
+
+== USAGE
+
+1. Write an ANTLR grammar specification for a language
+
+   grammar SomeLanguage;
+   
+   options {
+     language = Ruby;    // <- this option must be set to Ruby
+     output   = AST;
+   }
+   
+   top: expr ( ',' expr )*
+      ;
+    
+   and so on...
+   
+
+2. Run the ANTLR tool with the antlr4ruby command to generate output:
+   
+   antlr4ruby SomeLanguage.g
+   # creates:
+   #   SomeLanguageParser.rb
+   #   SomeLanguageLexer.rb
+   #   SomeLanguage.g
+
+3. Try out the results directly, if you like:
+
+  # see how the lexer tokenizes some input
+  ruby SomeLanguageLexer.rb < path/to/source-code.xyz
+  
+  # check whether the parser successfully matches some input
+  ruby SomeLanguageParser.rb --rule=top < path/to/source-code.xyz
+
+-> Read up on the package documentation for more specific details
+   about loading the recognizers and using their class definitions
+
+== ISSUES
+
+* Currently, there are a few nuanced ways in which using the ruby output differs
+  from the conventions and examples covered in the ANTLR standard documentation.
+  I am still working on documenting these details.
+
+* While the target is intended to be complete, I do not provide any
+  implementation of the template-construction mode available for Java and Python
+  targets. While I'm interested in having this capability, I have not implemented
+  it yet because ANTLR forces you to use its StringTemplate templating language.
+  Thus, I would have to port the StringTemplate library to Ruby and write a target
+  for ST parser generation. I would prefer to permit template generation that uses
+  ruby's standard ERB templating library.
+
+* So far, this has only been tested on Linux with ruby 1.8.7 and ruby 1.9.1.
+  I'm currently working on verifying behavior on other systems and with
+  slightly older versions of ruby. 
+
+== LICENSE
+
+[The "BSD licence"]
+Copyright (c) 2009 Kyle Yetter
+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.
+

data/bin/antlr4ruby

@@ -0,0 +1,33 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+__DIR__ = File.expand_path( File.dirname __FILE__ )
+project_top = File.dirname __DIR__
+load( File.join( project_top, 'lib', 'antlr3', 'version.rb' ) )
+
+jar_name = "antlr-full-#{ ANTLR_VERSION_STRING }.jar"
+jar_path = File.join( project_top, 'java', jar_name )
+
+unless File.exist?( jar_path )
+  $stderr.puts(<<-END.strip!.gsub!(/\s+/, ' '))
+    the ANTLR #{ ANTLR_VERSION_STRING } jar is expected
+    to be located at #{ jar_path }, but it does not
+    appear to exist.
+  END
+  exit( 1 )
+end
+
+escape = proc do | a |
+  if a.empty? then "''"
+  else
+    a.gsub( /([^A-Za-z0-9_\-.,:\/@\n])/n, '\\\1' ).
+      gsub( /\n/, "'\n'" )
+  end
+end
+
+command = %w(java -jar) << escape[ antlr_jar ]
+for arg in ARGV
+  command << escape[ arg ]
+end
+
+exec command.join(' ')

data/java/RubyTarget.java

@@ -0,0 +1,524 @@
+/*
+ [The "BSD licence"]
+ Copyright (c) 2005 Martin Traverso
+ 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.
+ */
+
+package org.antlr.codegen;
+
+import java.io.IOException;
+import java.util.*;
+
+import org.antlr.Tool;
+import org.antlr.stringtemplate.*;
+import org.antlr.tool.Grammar;
+
+public class RubyTarget
+extends Target
+{
+	public static final Set rubyKeywords =
+		new HashSet() {
+		{
+			add("alias");    add("end");     add("retry"); 
+			add("and");      add("ensure");  add("return");
+			add("BEGIN");    add("false");   add("self");  
+			add("begin");    add("for");     add("super"); 
+			add("break");    add("if");      add("then");  
+			add("case");     add("in");      add("true");  
+			add("class");    add("module");  add("undef"); 
+			add("def");      add("next");    add("unless");
+			add("defined");  add("nil");     add("until"); 
+			add("do");       add("not");     add("when");  
+			add("else");     add("or");      add("while"); 
+			add("elsif");    add("redo");    add("yield"); 
+			add("END");      add("rescue");
+		}
+	};
+
+	public class RubyRenderer 
+	implements AttributeRenderer 
+	{
+		public String toString(Object o) {
+			return o.toString();
+		}
+		public String toString(Object o, String formatName) {
+			String idString = o.toString();
+
+			if (idString.isEmpty()) return idString;
+
+			if (formatName.equals("snakecase")) {
+				return snakecase(idString);
+			} else if (formatName.equals("camelcase")) {
+				return camelcase(idString);
+			} else if (formatName.equals("subcamelcase")) {
+				return subcamelcase(idString);
+			} else if (formatName.equals("constant")) {
+				return constantcase(idString);
+			} else if (formatName.equals("platform")) {
+				return platform(idString);
+			} else if (formatName.equals("lexerRule")) {
+				return lexerRule(idString);
+			} else if (formatName.equals("constantPath")) {
+				return constantPath(idString);
+			} else if (formatName.equals("label")) {
+				return label(idString);
+			} else if (formatName.equals("symbol")) {
+				return symbol(idString);
+			} else {
+				throw new IllegalArgumentException("Unsupported format name");
+			}
+		}
+		/** given an input string, which is presumed
+		 * to contain a word, which may potentially be camelcased,
+		 * and convert it to snake_case underscore style.
+		 *
+		 * algorithm --
+		 *   iterate through the string with a sliding window 3 chars wide
+		 *
+		 * example -- aGUIWhatNot
+		 *   c   c+1 c+2  action
+		 *   a   G        << 'a' << '_'  // a lower-upper word edge
+		 *   G   U   I    << 'g'
+		 *   U   I   W    << 'w'
+		 *   I   W   h    << 'i' << '_'  // the last character in an acronym run of uppers
+		 *   W   h        << 'w'
+		 *   ... and so on
+		 */
+		private String snakecase(String value) {
+			StringBuilder output_buffer = new StringBuilder();
+			int l = value.length();
+			int cliff = l - 1;
+			char cur;
+			char next;
+			char peek;
+
+			if (value.isEmpty()) return value;
+			if (l == 1) return value.toLowerCase();
+
+			for (int i = 0; i < cliff; i++) {
+				cur  = value.charAt(i);
+				next = value.charAt(i + 1);
+
+				if ( Character.isLetter( cur ) ) {
+					output_buffer.append( Character.toLowerCase( cur ) );
+
+					if ( Character.isDigit( next ) || Character.isWhitespace( next ) ) {
+						output_buffer.append( '_' );
+					} else if ( Character.isLowerCase( cur ) && Character.isUpperCase( next ) ) {
+						// at camelcase word edge
+						output_buffer.append( '_' );
+					} else if ( (i < cliff - 1) && Character.isUpperCase( cur ) && Character.isUpperCase( next ) ) {
+						// cur is part of an acronym
+
+						peek = value.charAt(i + 2);
+						if ( Character.isLowerCase( peek ) ) {
+							/* if next is the start of word (indicated when peek is lowercase)
+                                         then the acronym must be completed by appending an underscore */ 
+							output_buffer.append('_');
+						}
+					}
+				} else if( Character.isDigit( cur ) ) {
+					output_buffer.append( cur );
+					if ( Character.isLetter( next ) ) {
+						output_buffer.append('_');
+					}
+				} else if (Character.isWhitespace( cur )) {
+					// do nothing
+				} else {
+					output_buffer.append( cur );
+				}
+
+			}
+
+			cur  = value.charAt(cliff);
+			if (! Character.isWhitespace(cur) ) {
+				output_buffer.append( Character.toLowerCase( cur ) );
+			}
+
+			return output_buffer.toString();
+		}
+		private String constantcase(String value) {
+			return snakecase(value).toUpperCase();
+		}
+		private String platform(String value) {
+			return ("__" + value + "__");
+		}
+		private String symbol(String value) {
+			if (value.matches("[a-zA-Z_]\\w*[\\?\\!\\=]?")) {
+				return (":" + value);
+			} else {
+				return ("%s(" + value + ")");
+			}
+		}
+		private String lexerRule(String value) {
+			if (value.equals("Tokens")) {
+				return "token!";
+			} else {
+				return (snakecase(value) + "!");
+			}
+		}
+		private String constantPath(String value) {
+			return value.replaceAll("\\.", "::");
+		}
+		private String camelcase(String value) {
+			StringBuilder output_buffer = new StringBuilder();
+			int cliff = value.length();
+			char cur;
+			char next;
+			boolean at_edge = true;
+
+			if (value.isEmpty()) return value;
+			if (cliff == 1) return value.toUpperCase();
+
+			for (int i = 0; i < cliff; i++) {
+				cur  = value.charAt(i);
+
+				if ( Character.isWhitespace( cur ) ) {
+					at_edge = true;
+					continue;
+				} else if ( cur == '_' ) {
+					at_edge = true;
+					continue;
+				} else if ( Character.isDigit( cur ) ) {
+					output_buffer.append( cur );
+					at_edge = true;
+					continue;
+				}
+
+				if (at_edge) {
+					output_buffer.append( Character.toUpperCase( cur ) );
+					if ( Character.isLetter( cur ) ) at_edge = false;
+				} else {
+					output_buffer.append( cur );
+				}
+			}
+
+			return output_buffer.toString();
+		}
+		private String label(String value) {
+			if (rubyKeywords.contains(value)) {
+				return platform(value);
+			} else if (Character.isUpperCase(value.charAt(0)) && 
+					(!value.equals("FILE")) && 
+					(!value.equals("LINE"))) {
+				return platform(value);
+			} else if (value.equals("FILE")) {
+				return "_FILE_";
+			} else if (value.equals("LINE")) {
+				return "_LINE_";
+			} else {
+				return value;
+			}
+		}
+		private String subcamelcase(String value) {
+			value = camelcase(value);
+			if (value.isEmpty())
+				return value;
+			Character head = Character.toLowerCase( value.charAt(0) );
+			String tail = value.substring(1);
+			return head.toString().concat(tail);
+		}
+	}
+
+	protected void genRecognizerFile(Tool tool,
+			CodeGenerator generator,
+			Grammar grammar,
+			StringTemplate outputFileST)
+	throws IOException
+	{
+		StringTemplateGroup group = generator.getTemplates();
+		RubyRenderer renderer = new RubyRenderer();
+		try {
+			group.registerRenderer(Class.forName("java.lang.String"), renderer);
+		} catch (ClassNotFoundException e) {
+			// this shouldn't happen
+			System.err.println("ClassNotFoundException: " + e.getMessage());
+			e.printStackTrace(System.err);
+		}
+		String fileName =
+			generator.getRecognizerFileName(grammar.name, grammar.type);
+		generator.write(outputFileST, fileName);
+	}
+	public String getTargetCharLiteralFromANTLRCharLiteral(
+			CodeGenerator generator,
+			String literal)
+	{
+		literal = literal.substring(1, literal.length() - 1);
+
+		String result = "?";
+
+		if (literal.equals("\\")) {
+			result += "\\\\";
+		}
+		else if (literal.equals(" ")) {
+			result += "\\s";
+		}
+		else if (literal.startsWith("\\u")) {
+			result = "0x" + literal.substring(2);
+		}
+		else {
+			result += literal;
+		}
+
+		return result;
+	}
+	public int getMaxCharValue(CodeGenerator generator)
+	{
+		// we don't support unicode, yet.
+		return 0xFF;
+	}
+	public String getTokenTypeAsTargetLabel(CodeGenerator generator, int ttype)
+	{
+		String name = generator.grammar.getTokenDisplayName(ttype);
+		// If name is a literal, return the token type instead
+		if ( name.charAt(0)=='\'' ) {
+			return generator.grammar.computeTokenNameFromLiteral(ttype, name);
+		}
+		return name;
+	}
+	/** Is scope in @scope::name {action} valid for this kind of grammar?
+	 *  Targets like C++ may want to allow new scopes like headerfile or
+	 *  some such.  The action names themselves are not policed at the
+	 *  moment so targets can add template actions w/o having to recompile
+	 *  ANTLR.
+	 */
+	public boolean isValidActionScope(int grammarType, String scope) {
+		switch (grammarType) {
+		case Grammar.LEXER:
+			if (scope.equals("lexer")) {
+				return true;
+			}
+			if (scope.equals("token")) {
+				return true;
+			}
+			if (scope.equals("module")) {
+				return true;
+			}
+			if (scope.equals("overrides")) {
+				return true;
+			}
+			break;
+		case Grammar.PARSER:
+			if (scope.equals("parser")) {
+				return true;
+			}
+			if (scope.equals("token")) {
+				return true;
+			}
+			if (scope.equals("module")) {
+				return true;
+			}
+			if (scope.equals("overrides")) {
+				return true;
+			}
+			break;
+		case Grammar.COMBINED:
+			if (scope.equals("parser")) {
+				return true;
+			}
+			if (scope.equals("lexer")) {
+				return true;
+			}
+			if (scope.equals("token")) {
+				return true;
+			}
+			if (scope.equals("module")) {
+				return true;
+			}
+			if (scope.equals("overrides")) {
+				return true;
+			}
+			break;
+		case Grammar.TREE_PARSER:
+			if (scope.equals("treeparser")) {
+				return true;
+			}
+			if (scope.equals("token")) {
+				return true;
+			}
+			if (scope.equals("module")) {
+				return true;
+			}
+			if (scope.equals("overrides")) {
+				return true;
+			}
+			break;
+		}
+		return false;
+	}
+	/*
+    public String getTargetStringLiteralFromString(String s)
+    {
+        System.out.print(s + "\n");
+        return super.getTargetStringLiteralFromString(s);
+    }
+
+    public String getTargetStringLiteralFromString(String s, boolean quoted)
+    {
+        // System.out.print(s + "\n");
+        String ret_value = super.getTargetStringLiteralFromString(s, quoted);
+        System.out.print(ret_value + "\n");
+        return(ret_value);
+    }
+
+    public String getTarget64BitStringFromValue(long word)
+    {
+        System.out.print(((Long)word).toString() + "\n");
+        String result = super.getTarget64BitStringFromValue(word);
+        System.out.print(result + "\n");
+        return result;
+    }
+	 */
+	public String encodeIntAsCharEscape(final int v) {
+		final int intValue;
+
+		if (v == 65535) {
+			intValue = -1;
+		} else {
+			intValue = v;
+		}
+
+		return String.valueOf(intValue);
+	}
+//    public List postProcessAction(List chunks, antlr.Token actionToken) {
+//		List nChunks = new ArrayList();
+//		
+//		for (int i = 0; i < chunks.size(); i++) {
+//			Object chunk = chunks.get(i);
+//
+//			if ( chunk instanceof String ) {
+//				String text = (String)chunks.get(i);
+//				if ( nChunks.size() == 0 && actionToken.getColumn() > 0 ) {
+//					// first chunk and some 'virtual' WS at beginning
+//					// prepend to this chunk
+//
+//					String ws = "";
+//					for ( int j = 0 ; j < actionToken.getColumn() ; j++ ) {
+//						ws += " ";
+//					}
+//					text = ws + text;
+//				}
+//
+//				String[] parts = text.split("\r?\n");
+//				for ( String line : parts  ) {
+//					nChunks.add(line);
+//				}
+//			}
+//			else {
+//				if ( nChunks.size() == 0 && actionToken.getColumn() > 0 ) {
+//					// first chunk and some 'virtual' WS at beginning
+//					// add as a chunk of its own
+//
+//					String ws = "";
+//					for ( int j = 0 ; j < actionToken.getColumn() ; j++ ) {
+//						ws += " ";
+//					}
+//					nChunks.add(ws);
+//				}
+//
+//				nChunks.add(chunk);
+//			}
+//		}
+//
+//		int lineNo = actionToken.getLine();
+//		int col = 0;
+//
+//		// strip trailing empty lines
+//		int lastChunk = nChunks.size() - 1;
+//		while ( lastChunk > 0
+//				&& nChunks.get(lastChunk) instanceof String
+//				&& ((String)nChunks.get(lastChunk)).trim().length() == 0 )
+//			lastChunk--;
+//
+//		// string leading empty lines
+//		int firstChunk = 0;
+//		while ( firstChunk <= lastChunk
+//				&& nChunks.get(firstChunk) instanceof String
+//				&& ((String)nChunks.get(firstChunk)).trim().length() == 0
+//				&& ((String)nChunks.get(firstChunk)).endsWith("\n") ) {
+//			lineNo++;
+//			firstChunk++;
+//		}
+//
+//		int indent = -1;
+//		for ( int i = firstChunk ; i <= lastChunk ; i++ ) {
+//			Object chunk = nChunks.get(i);
+//
+//			//System.out.println(lineNo + ":" + col + " " + quote(chunk.toString()));
+//
+//			if ( chunk instanceof String ) {
+//				String text = (String)chunk;
+//
+//				if ( col == 0 ) {
+//					if ( indent == -1 ) {
+//						// first non-blank line
+//						// count number of leading whitespaces
+//
+//						indent = 0;
+//						for ( int j = 0; j < text.length(); j++ ) {
+//							if ( !Character.isWhitespace(text.charAt(j)) )
+//								break;
+//			
+//							indent++;
+//						}
+//					}
+//
+//					if ( text.length() >= indent ) {
+//						int j;
+//						for ( j = 0; j < indent ; j++ ) {
+//							if ( !Character.isWhitespace(text.charAt(j)) ) {
+//								// should do real error reporting here...
+//								System.err.println("Warning: badly indented line " + lineNo + " in action:");
+//								System.err.println(text);
+//								break;
+//							}
+//						}
+//
+//						nChunks.set(i, text.substring(j));
+//					}
+//					else if ( text.trim().length() > 0 ) {
+//						// should do real error reporting here...
+//						System.err.println("Warning: badly indented line " + lineNo + " in action:");
+//						System.err.println(text);
+//					}
+//				}
+//
+//				if ( text.endsWith("\n") ) {
+//					lineNo++;
+//					col = 0;
+//				}
+//				else {
+//					col += text.length();
+//				}
+//			}
+//			else {
+//				// not really correct, but all I need is col to increment...
+//				col += 1;
+//			}
+//		}
+//
+//		return nChunks;
+//    }
+}