Child pages
  • Antlr3ActionScriptTarget
Skip to end of metadata
Go to start of metadata

The ActionScript code generation target

Note: The ActionScript target was last synced with the 3.2 version of ANTLR, and is no longer being actively maintained.

The ActionScript target closely follows the Java target. The API and runtime behavior are consistent to the extent possible.

Please send bug reports, feedback, patches to the antlr-interest mailing list.

Requirements

The runtime generates ActionScript 3 code designed to work with Flex version 2 or higher from Adobe. The runtime binary libraries are all compiled with the latest Flex 3.2 SDK.

To use generated code, you'll need to include ActionScript runtime package antlr3.swc in your library path. There are no other dependencies beyond the standard Flex libraries. Note, that the library contains some Adobe AIR class references, to use the library in a pure Flex project use the -library-path compiler option rather than the -include-library option when compiling from the command line.

Usage

Selecting ActionScript output

Just add language=ActionScript; to the options section of your grammar:

grammar T;
options {
    language=ActionScript;
    [other options]
}

...

For a grammar T.g ANTLR3 will then create the files TLexer.as and TParser.as which contain the classes TLexer and TParser (or just one of those, if you have a pure lexer/parser). For tree parsers, ANTLR3 creates T.as containing the class T.

Specifying an ActionScript package for your recognizer

You can specify that your generated recognizer should be declared within a specific package as shown below. By default all recognizers are generated as top-level types with no enclosing package.

grammar MyGrammar;

options
{
    language=ActionScript;
}

@parser::package { My.Custom.NameSpace.For.Parser.In.Combined.Grammar } // Or just @package { ... }

@lexer::package { My.Custom.NameSpace.For.Lexer.In.Combined.Grammar }

// rest of grammar follows
....
lexer grammar MyGrammar;

options
{
    language=ActionScript;
}

@package { My.Custom.NameSpace.For.Lexer }

// rest of grammar follows
....
parser grammar MyGrammar;

options
{
    language=ActionScript;
}

@package { My.Custom.NameSpace.For.Parser }

// rest of grammar follows
....
tree grammar MyGrammar;

options
{
    language=ActionScript;
}

@package { My.Custom.NameSpace.For.TreeParser }

// rest of grammar follows
....

Using the generated classes

To use a grammar T.g:

package {

	import org.antlr.runtime.*;

	public class AntlrActionScriptTest {
		public function AntlrActionScriptTest(input:String) {
			var lexer:TLexer = new TLexer(new ANTLRStringStream(input));
			var tokens:CommonTokenStream = new CommonTokenStream(lexer);

			var parser:TParser = new TParser(tokens);
			parser.entry_rule();
 		}
	}
}

For complex parsers, you may want to avoid creating the lexers and parsers each time you want to parse input. In this case you can do the following, which will reset the lexer and parser by setting the charStream or tokenStream property (as appropriate):

package {

	import org.antlr.runtime.*;

	public class AntlrActionScriptTest {

		private static var lexer:TLexer = new TLexer(null);
		private static var parser:TParser = new TParser(null);

		public function parseInput(input:String):void {
			lexer.charStream = new ANTLRStringStream(input);
			parser.tokenStream = new CommonTokenStream(lexer);
			parser.entry_rule();
 		}
	}
}

If you want to access the tokens types in your code, you'll have to import and access them from the lexer or parser module (e.g. TLexer.EOF, TLexer.IDENTIFIER):

Using tree parsers

For grammars T.g (parser and lexer) and TWalker.g (the tree parser):

package {

	import org.antlr.runtime.*;
	import org.antlr.runtime.tree.*;

	public class AntlrActionScriptTreeWalkerTest {
		public function AntlrActionScriptTest(input:String) {
			var lexer:TLexer = new TLexer(new ANTLRStringStream(input));
			var tokens:CommonTokenStream = new CommonTokenStream(lexer);

			var parser:TParser = new TParser(tokens);
			var r:ParserRuleReturnScope = parser.entry_rule();

			// This is the root of the AST.
			var root:Tree = r.tree;

			var nodes:CommonTreeNodeStream = new CommonTreeNodeStream(root);
			nodes.tokenStream = tokens;
			var walker:TWalker = new TWalker(nodes);
			walker.entry_rule();

 		}
	}
}

API documentation

Reference documentation for the runtime package can be found at http://www.antlr.org/api/ActionScript/.

Actions

This target currently supports the action scopes @lexer, @parser and @treeparser for global actions. The following action names are known:

  • package -Wrap the generated classes with the specified package.
  • header - Will be inserted right after ANTLRs own imports at the top of the generated file. Use it for import statements or any other functions/classes which you need in the package scope.
  • init - Will be inserted at the end of the constructor of the lexer/parser. Here you can setup your own instance attributes.
  • members - Will be inserted in the class body of the lexer/parser. This is the right place for custom methods and class attributes.

Unsupported features

  • -debug option: mostly useful for integration into ANTLRWorks.
  • output=template: StringTemplate has not been ported to ActionScript, so template-based recognizers are not supported.
  • No labels

2 Comments

  1. Unknown User (wrhinfl@yahoo.com)

    If I have a parser rule like:

    stat:   expr Semicolon                 -> expr
        |   ID '=' expr Semicolon -> ^('=' ID expr)
        |   Semicolon             ->
        ;

    How do I remove the compiler warning on my AS file because the same variable is defined twice, once for the assignment statement and a second time for the blank statement.  The variable being defined twice is:

    var stream_retval:RewriteRuleSubtreeStream=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

    I've started by getting the expression grammers in chapter three to work both ways, this is the second version that uses an AST.  The end result should be that the blank statement should put nothing in the AST.

  2. Unknown User (gscott)

    Wayne,

    There is no way to eliminate those compiler warnings, they should just be ignored as the generated code functions correctly. Unfortunately, it is non-trivial to fix the code generator to produce code that would not create the warning in all cases.