The ActionScript code generation target
...
title | Coming soon in in V3.1 |
---|
Note: The ActionScript target
...
Please note that the ActionScript target is (compared to most other targets) rather young. I would consider it to be in alpha state. This means that most parts are working (big exception are template output), but bugs and problems are to be expected and documentation is pretty poor. It still has to prove itself in a real world application (which is currently being done).
Both the runtime module and the code generation templates should now be feature complete and in sync with the Java target (Version 3.0.1), except for the features listed below. But large parts of the runtime are still untested.
See this Example for a working tree-walking grammerwas 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 me or the 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 SDK 3 Beta .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
...
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.
Code Block |
---|
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
....
|
Code Block |
---|
lexer grammar MyGrammar;
options
{
language=ActionScript;
}
@package { My.Custom.NameSpace.For.Lexer }
// rest of grammar follows
....
|
Code Block |
---|
parser grammar MyGrammar;
options
{
language=ActionScript;
}
@package { My.Custom.NameSpace.For.Parser }
// rest of grammar follows
....
|
Code Block |
---|
tree grammar MyGrammar; options { language=ActionScript; } @package { My.Custom.NameSpace.For.TreeParser } // rest of grammar follows .... |
Using the generated classes
...
Code Block |
---|
package { import flash.display.Sprite; import org.antlr.runtime.*; public class AntlrActionScriptTest extends Sprite { public function AntlrActionScriptTest ( input:String):void { 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):
Code Block |
---|
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( tokens 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):
...
Code Block |
---|
package { import flashorg.antlr.displayruntime.Sprite*; import org.antlr.runtime.tree.*; public class AntlrActionScriptTreeWalkerTest extends Sprite { public function AntlrActionScriptTest ( input:String):void { 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/. Note: need to upload ActionScript HTML docs...
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 forimport
statements or any other functions/classes which you need in the module package scope.init
- Will be inserted at the end of the_init_
method 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 right after_init_
. This is the right place for custom methods and class attributes.
For rules the additional action @decorate
is recognized. The contents are placed right before the rule method and can be used for decorators.
Code Block |
---|
r
@decorate { @logThis }
: s ;
|
will create something like
Code Block |
---|
@logThis
def r(self):
...
|
Caveats
TBD.
Unsupported features
Anchor | ||||
---|---|---|---|---|
|
-debug
option: mostly useful for integration into ANTLRWorks.output=template
: StringTemplate has not been ported to ActionScript, so template-based recognizers are not supported.