Spring.NET 1.3.0 RC1 for .NET 2.0 API Reference

TokenStreamRewriteEngine Class

This token stream tracks the *entire* token stream coming from a lexer, but does not pass on the whitespace (or whatever else you want to discard) to the parser.

For a list of all members of this type, see TokenStreamRewriteEngine Members .

System.Object
   TokenStreamRewriteEngine

[Visual Basic]
Public Class TokenStreamRewriteEngine
    Implements TokenStream
[C#]
public class TokenStreamRewriteEngine : TokenStream

Thread Safety

Public static (Shared in Visual Basic) members of this type are safe for multithreaded operations. Instance members are not guaranteed to be thread-safe.

Remarks

This class can then be asked for the ith token in the input stream. Useful for dumping out the input stream exactly after doing some augmentation or other manipulations. Tokens are index from 0..n-1

You can insert stuff, replace, and delete chunks. Note that the operations are done lazily--only if you convert the buffer to a string. This is very efficient because you are not moving data around all the time. As the buffer of tokens is converted to strings, the toString() method(s) check to see if there is an operation at the current index. If so, the operation is done and then normal string rendering continues on the buffer. This is like having multiple Turing machine instruction streams (programs) operating on a single input tape. :)

Since the operations are done lazily at toString-time, operations do not screw up the token index values. That is, an insert operation at token index i does not change the index values for tokens i+1..n-1.

Because operations never actually alter the buffer, you may always get the original token stream back without undoing anything. Since the instructions are queued up, you can easily simulate transactions and roll back any changes if there is an error just by removing instructions. For example,

For example:
TokenStreamRewriteEngine rewriteEngine = new TokenStreamRewriteEngine(lexer);
JavaRecognizer           parser        = new JavaRecognizer(rewriteEngine);
...
rewriteEngine.insertAfter("pass1", t, "foobar");}
rewriteEngine.insertAfter("pass2", u, "start");}
System.Console.Out.WriteLine(rewriteEngine.ToString("pass1"));
System.Console.Out.WriteLine(rewriteEngine.ToString("pass2"));

You can also have multiple "instruction streams" and get multiple rewrites from a single pass over the input. Just name the instruction streams and use that name again when printing the buffer. This could be useful for generating a C file and also its header file--all from the same buffer.

If you don't use named rewrite streams, a "default" stream is used.

Terence Parr, parrt@cs.usfca.edu University of San Francisco February 2004

Requirements

Namespace: Spring.Expressions.Parser.antlr

Assembly: Spring.Core (in Spring.Core.dll)

See Also

TokenStreamRewriteEngine Members | Spring.Expressions.Parser.antlr Namespace