rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/external/antlr/runtime/Delphi/Sources/Antlr3.Runtime/Antlr.Runtime.Tree.pas

5064 lines
152 KiB
ObjectPascal
Raw Blame History

unit Antlr.Runtime.Tree;
(*
[The "BSD licence"]
Copyright (c) 2008 Erik van Bilsen
Copyright (c) 2005-2007 Kunle Odutola
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.
4. Unless explicitly state otherwise, any contribution intentionally
submitted for inclusion in this work to the copyright owner or licensor
shall be under the terms and conditions of this license, without any
additional terms or conditions.
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.
*)
interface
{$IF CompilerVersion < 20}
{$MESSAGE ERROR 'You need Delphi 2009 or higher to use the Antlr runtime'}
{$IFEND}
uses
Classes,
SysUtils,
Antlr.Runtime,
Antlr.Runtime.Tools,
Antlr.Runtime.Collections;
type
/// <summary>
/// How to create and navigate trees. Rather than have a separate factory
/// and adaptor, I've merged them. Makes sense to encapsulate.
///
/// This takes the place of the tree construction code generated in the
/// generated code in 2.x and the ASTFactory.
///
/// I do not need to know the type of a tree at all so they are all
/// generic Objects. This may increase the amount of typecasting needed. :(
/// </summary>
ITreeAdaptor = interface(IANTLRInterface)
['{F9DEB286-F555-4CC8-A51A-93F3F649B248}']
{ Methods }
// C o n s t r u c t i o n
/// <summary>
/// Create a tree node from Token object; for CommonTree type trees,
/// then the token just becomes the payload.
/// </summary>
/// <remarks>
/// This is the most common create call. Override if you want another kind of node to be built.
/// </remarks>
function CreateNode(const Payload: IToken): IANTLRInterface; overload;
/// <summary>Duplicate a single tree node </summary>
/// <remarks> Override if you want another kind of node to be built.</remarks>
function DupNode(const TreeNode: IANTLRInterface): IANTLRInterface;
/// <summary>Duplicate tree recursively, using DupNode() for each node </summary>
function DupTree(const Tree: IANTLRInterface): IANTLRInterface;
/// <summary>
/// Return a nil node (an empty but non-null node) that can hold
/// a list of element as the children. If you want a flat tree (a list)
/// use "t=adaptor.nil(); t.AddChild(x); t.AddChild(y);"
/// </summary>
function GetNilNode: IANTLRInterface;
/// <summary>
/// Return a tree node representing an error. This node records the
/// tokens consumed during error recovery. The start token indicates the
/// input symbol at which the error was detected. The stop token indicates
/// the last symbol consumed during recovery.
/// </summary>
/// <remarks>
/// <para>You must specify the input stream so that the erroneous text can
/// be packaged up in the error node. The exception could be useful
/// to some applications; default implementation stores ptr to it in
/// the CommonErrorNode.</para>
///
/// <para>This only makes sense during token parsing, not tree parsing.
/// Tree parsing should happen only when parsing and tree construction
/// succeed.</para>
/// </remarks>
function ErrorNode(const Input: ITokenStream; const Start, Stop: IToken;
const E: ERecognitionException): IANTLRInterface;
/// <summary>
/// Is tree considered a nil node used to make lists of child nodes?
/// </summary>
function IsNil(const Tree: IANTLRInterface): Boolean;
/// <summary>
/// Add a child to the tree t. If child is a flat tree (a list), make all
/// in list children of t.
/// </summary>
/// <remarks>
/// <para>
/// Warning: if t has no children, but child does and child isNil then you
/// can decide it is ok to move children to t via t.children = child.children;
/// i.e., without copying the array. Just make sure that this is consistent
/// with have the user will build ASTs. Do nothing if t or child is null.
/// </para>
/// <para>
/// This is for construction and I'm not sure it's completely general for
/// a tree's addChild method to work this way. Make sure you differentiate
/// between your tree's addChild and this parser tree construction addChild
/// if it's not ok to move children to t with a simple assignment.
/// </para>
/// </remarks>
procedure AddChild(const T, Child: IANTLRInterface);
/// <summary>
/// If oldRoot is a nil root, just copy or move the children to newRoot.
/// If not a nil root, make oldRoot a child of newRoot.
/// </summary>
/// <remarks>
///
/// old=^(nil a b c), new=r yields ^(r a b c)
/// old=^(a b c), new=r yields ^(r ^(a b c))
///
/// If newRoot is a nil-rooted single child tree, use the single
/// child as the new root node.
///
/// old=^(nil a b c), new=^(nil r) yields ^(r a b c)
/// old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
///
/// If oldRoot was null, it's ok, just return newRoot (even if isNil).
///
/// old=null, new=r yields r
/// old=null, new=^(nil r) yields ^(nil r)
///
/// Return newRoot. Throw an exception if newRoot is not a
/// simple node or nil root with a single child node--it must be a root
/// node. If newRoot is ^(nil x) return x as newRoot.
///
/// Be advised that it's ok for newRoot to point at oldRoot's
/// children; i.e., you don't have to copy the list. We are
/// constructing these nodes so we should have this control for
/// efficiency.
/// </remarks>
function BecomeRoot(const NewRoot, OldRoot: IANTLRInterface): IANTLRInterface; overload;
/// <summary>
/// Given the root of the subtree created for this rule, post process
/// it to do any simplifications or whatever you want. A required
/// behavior is to convert ^(nil singleSubtree) to singleSubtree
/// as the setting of start/stop indexes relies on a single non-nil root
/// for non-flat trees.
///
/// Flat trees such as for lists like "idlist : ID+ ;" are left alone
/// unless there is only one ID. For a list, the start/stop indexes
/// are set in the nil node.
///
/// This method is executed after all rule tree construction and right
/// before SetTokenBoundaries().
/// </summary>
function RulePostProcessing(const Root: IANTLRInterface): IANTLRInterface;
/// <summary>
/// For identifying trees. How to identify nodes so we can say "add node
/// to a prior node"?
/// </summary>
/// <remarks>
/// Even BecomeRoot is an issue. Ok, we could:
/// <list type="number">
/// <item>Number the nodes as they are created?</item>
/// <item>
/// Use the original framework assigned hashcode that's unique
/// across instances of a given type.
/// WARNING: This is usually implemented either as IL to make a
/// non-virt call to object.GetHashCode() or by via a call to
/// System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode().
/// Both have issues especially on .NET 1.x and Mono.
/// </item>
/// </list>
/// </remarks>
function GetUniqueID(const Node: IANTLRInterface): Integer;
// R e w r i t e R u l e s
/// <summary>
/// Create a node for newRoot make it the root of oldRoot.
/// If oldRoot is a nil root, just copy or move the children to newRoot.
/// If not a nil root, make oldRoot a child of newRoot.
///
/// Return node created for newRoot.
/// </summary>
function BecomeRoot(const NewRoot: IToken; const OldRoot: IANTLRInterface): IANTLRInterface; overload;
/// <summary>Create a new node derived from a token, with a new token type.
/// This is invoked from an imaginary node ref on right side of a
/// rewrite rule as IMAG[$tokenLabel].
///
/// This should invoke createToken(Token).
/// </summary>
function CreateNode(const TokenType: Integer; const FromToken: IToken): IANTLRInterface; overload;
/// <summary>Same as Create(tokenType,fromToken) except set the text too.
/// This is invoked from an imaginary node ref on right side of a
/// rewrite rule as IMAG[$tokenLabel, "IMAG"].
///
/// This should invoke createToken(Token).
/// </summary>
function CreateNode(const TokenType: Integer; const FromToken: IToken;
const Text: String): IANTLRInterface; overload;
/// <summary>Create a new node derived from a token, with a new token type.
/// This is invoked from an imaginary node ref on right side of a
/// rewrite rule as IMAG["IMAG"].
///
/// This should invoke createToken(int,String).
/// </summary>
function CreateNode(const TokenType: Integer; const Text: String): IANTLRInterface; overload;
// C o n t e n t
/// <summary>For tree parsing, I need to know the token type of a node </summary>
function GetNodeType(const T: IANTLRInterface): Integer;
/// <summary>Node constructors can set the type of a node </summary>
procedure SetNodeType(const T: IANTLRInterface; const NodeType: Integer);
function GetNodeText(const T: IANTLRInterface): String;
/// <summary>Node constructors can set the text of a node </summary>
procedure SetNodeText(const T: IANTLRInterface; const Text: String);
/// <summary>
/// Return the token object from which this node was created.
/// </summary>
/// <remarks>
/// Currently used only for printing an error message. The error
/// display routine in BaseRecognizer needs to display where the
/// input the error occurred. If your tree of limitation does not
/// store information that can lead you to the token, you can create
/// a token filled with the appropriate information and pass that back.
/// <see cref="BaseRecognizer.GetErrorMessage"/>
/// </remarks>
function GetToken(const TreeNode: IANTLRInterface): IToken;
/// <summary>
/// Where are the bounds in the input token stream for this node and
/// all children?
/// </summary>
/// <remarks>
/// Each rule that creates AST nodes will call this
/// method right before returning. Flat trees (i.e., lists) will
/// still usually have a nil root node just to hold the children list.
/// That node would contain the start/stop indexes then.
/// </remarks>
procedure SetTokenBoundaries(const T: IANTLRInterface; const StartToken,
StopToken: IToken);
/// <summary>
/// Get the token start index for this subtree; return -1 if no such index
/// </summary>
function GetTokenStartIndex(const T: IANTLRInterface): Integer;
/// <summary>
/// Get the token stop index for this subtree; return -1 if no such index
/// </summary>
function GetTokenStopIndex(const T: IANTLRInterface): Integer;
// N a v i g a t i o n / T r e e P a r s i n g
/// <summary>Get a child 0..n-1 node </summary>
function GetChild(const T: IANTLRInterface; const I: Integer): IANTLRInterface;
/// <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary>
procedure SetChild(const T: IANTLRInterface; const I: Integer; const Child: IANTLRInterface);
/// <summary>Remove ith child and shift children down from right.</summary>
function DeleteChild(const T: IANTLRInterface; const I: Integer): IANTLRInterface;
/// <summary>How many children? If 0, then this is a leaf node </summary>
function GetChildCount(const T: IANTLRInterface): Integer;
/// <summary>
/// Who is the parent node of this node; if null, implies node is root.
/// </summary>
/// <remarks>
/// If your node type doesn't handle this, it's ok but the tree rewrites
/// in tree parsers need this functionality.
/// </remarks>
function GetParent(const T: IANTLRInterface): IANTLRInterface;
procedure SetParent(const T, Parent: IANTLRInterface);
/// <summary>
/// What index is this node in the child list? Range: 0..n-1
/// </summary>
/// <remarks>
/// If your node type doesn't handle this, it's ok but the tree rewrites
/// in tree parsers need this functionality.
/// </remarks>
function GetChildIndex(const T: IANTLRInterface): Integer;
procedure SetChildIdex(const T: IANTLRInterface; const Index: Integer);
/// <summary>
/// Replace from start to stop child index of parent with t, which might
/// be a list. Number of children may be different after this call.
/// </summary>
/// <remarks>
/// If parent is null, don't do anything; must be at root of overall tree.
/// Can't replace whatever points to the parent externally. Do nothing.
/// </remarks>
procedure ReplaceChildren(const Parent: IANTLRInterface; const StartChildIndex,
StopChildIndex: Integer; const T: IANTLRInterface);
end;
/// <summary>A stream of tree nodes, accessing nodes from a tree of some kind </summary>
ITreeNodeStream = interface(IIntStream)
['{75EA5C06-8145-48F5-9A56-43E481CE86C6}']
{ Property accessors }
function GetTreeSource: IANTLRInterface;
function GetTokenStream: ITokenStream;
function GetTreeAdaptor: ITreeAdaptor;
procedure SetHasUniqueNavigationNodes(const Value: Boolean);
{ Methods }
/// <summary>Get a tree node at an absolute index i; 0..n-1.</summary>
/// <remarks>
/// If you don't want to buffer up nodes, then this method makes no
/// sense for you.
/// </remarks>
function Get(const I: Integer): IANTLRInterface;
/// <summary>
/// Get tree node at current input pointer + i ahead where i=1 is next node.
/// i&lt;0 indicates nodes in the past. So LT(-1) is previous node, but
/// implementations are not required to provide results for k &lt; -1.
/// LT(0) is undefined. For i&gt;=n, return null.
/// Return null for LT(0) and any index that results in an absolute address
/// that is negative.
///
/// This is analogus to the LT() method of the TokenStream, but this
/// returns a tree node instead of a token. Makes code gen identical
/// for both parser and tree grammars. :)
/// </summary>
function LT(const K: Integer): IANTLRInterface;
/// <summary>Return the text of all nodes from start to stop, inclusive.
/// If the stream does not buffer all the nodes then it can still
/// walk recursively from start until stop. You can always return
/// null or "" too, but users should not access $ruleLabel.text in
/// an action of course in that case.
/// </summary>
function ToString(const Start, Stop: IANTLRInterface): String; overload;
function ToString: String; overload;
// REWRITING TREES (used by tree parser)
/// <summary>
/// Replace from start to stop child index of parent with t, which might
/// be a list. Number of children may be different after this call.
/// </summary>
/// <remarks>
/// The stream is notified because it is walking the tree and might need
/// to know you are monkeying with the underlying tree. Also, it might be
/// able to modify the node stream to avoid restreaming for future phases.
///
/// If parent is null, don't do anything; must be at root of overall tree.
/// Can't replace whatever points to the parent externally. Do nothing.
/// </remarks>
procedure ReplaceChildren(const Parent: IANTLRInterface; const StartChildIndex,
StopChildIndex: Integer; const T: IANTLRInterface);
{ Properties }
/// <summary>
/// Where is this stream pulling nodes from? This is not the name, but
/// the object that provides node objects.
///
/// TODO: do we really need this?
/// </summary>
property TreeSource: IANTLRInterface read GetTreeSource;
/// <summary>
/// Get the ITokenStream from which this stream's Tree was created
/// (may be null)
/// </summary>
/// <remarks>
/// If the tree associated with this stream was created from a
/// TokenStream, you can specify it here. Used to do rule $text
/// attribute in tree parser. Optional unless you use tree parser
/// rule text attribute or output=template and rewrite=true options.
/// </remarks>
property TokenStream: ITokenStream read GetTokenStream;
/// <summary>
/// What adaptor can tell me how to interpret/navigate nodes and trees.
/// E.g., get text of a node.
/// </summary>
property TreeAdaptor: ITreeAdaptor read GetTreeAdaptor;
/// <summary>
/// As we flatten the tree, we use UP, DOWN nodes to represent
/// the tree structure. When debugging we need unique nodes
/// so we have to instantiate new ones. When doing normal tree
/// parsing, it's slow and a waste of memory to create unique
/// navigation nodes. Default should be false;
/// </summary>
property HasUniqueNavigationNodes: Boolean write SetHasUniqueNavigationNodes;
end;
/// <summary>
/// What does a tree look like? ANTLR has a number of support classes
/// such as CommonTreeNodeStream that work on these kinds of trees. You
/// don't have to make your trees implement this interface, but if you do,
/// you'll be able to use more support code.
///
/// NOTE: When constructing trees, ANTLR can build any kind of tree; it can
/// even use Token objects as trees if you add a child list to your tokens.
///
/// This is a tree node without any payload; just navigation and factory stuff.
/// </summary>
ITree = interface(IANTLRInterface)
['{4B6EFB53-EBF6-4647-BA4D-48B68134DC2A}']
{ Property accessors }
function GetChildCount: Integer;
function GetParent: ITree;
procedure SetParent(const Value: ITree);
function GetChildIndex: Integer;
procedure SetChildIndex(const Value: Integer);
function GetIsNil: Boolean;
function GetTokenType: Integer;
function GetText: String;
function GetLine: Integer;
function GetCharPositionInLine: Integer;
function GetTokenStartIndex: Integer;
procedure SetTokenStartIndex(const Value: Integer);
function GetTokenStopIndex: Integer;
procedure SetTokenStopIndex(const Value: Integer);
{ Methods }
/// <summary>Set (or reset) the parent and child index values for all children</summary>
procedure FreshenParentAndChildIndexes;
function GetChild(const I: Integer): ITree;
/// <summary>
/// Add t as a child to this node. If t is null, do nothing. If t
/// is nil, add all children of t to this' children.
/// </summary>
/// <param name="t">Tree to add</param>
procedure AddChild(const T: ITree);
/// <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary>
procedure SetChild(const I: Integer; const T: ITree);
function DeleteChild(const I: Integer): IANTLRInterface;
/// <summary>
/// Delete children from start to stop and replace with t even if t is
/// a list (nil-root tree). num of children can increase or decrease.
/// For huge child lists, inserting children can force walking rest of
/// children to set their childindex; could be slow.
/// </summary>
procedure ReplaceChildren(const StartChildIndex, StopChildIndex: Integer;
const T: IANTLRInterface);
function DupNode: ITree;
function ToStringTree: String;
function ToString: String;
{ Properties }
property ChildCount: Integer read GetChildCount;
// Tree tracks parent and child index now > 3.0
property Parent: ITree read GetParent write SetParent;
/// <summary>This node is what child index? 0..n-1</summary>
property ChildIndex: Integer read GetChildIndex write SetChildIndex;
/// <summary>
/// Indicates the node is a nil node but may still have children, meaning
/// the tree is a flat list.
/// </summary>
property IsNil: Boolean read GetIsNil;
/// <summary>Return a token type; needed for tree parsing </summary>
property TokenType: Integer read GetTokenType;
property Text: String read GetText;
/// <summary>In case we don't have a token payload, what is the line for errors? </summary>
property Line: Integer read GetLine;
property CharPositionInLine: Integer read GetCharPositionInLine;
/// <summary>
/// What is the smallest token index (indexing from 0) for this node
/// and its children?
/// </summary>
property TokenStartIndex: Integer read GetTokenStartIndex write SetTokenStartIndex;
/// <summary>
/// What is the largest token index (indexing from 0) for this node
/// and its children?
/// </summary>
property TokenStopIndex: Integer read GetTokenStopIndex write SetTokenStopIndex;
end;
/// <summary>
/// A generic tree implementation with no payload. You must subclass to
/// actually have any user data. ANTLR v3 uses a list of children approach
/// instead of the child-sibling approach in v2. A flat tree (a list) is
/// an empty node whose children represent the list. An empty, but
/// non-null node is called "nil".
/// </summary>
IBaseTree = interface(ITree)
['{6772F6EA-5FE0-40C6-BE5C-800AB2540E55}']
{ Property accessors }
function GetChildren: IList<IBaseTree>;
function GetChildIndex: Integer;
procedure SetChildIndex(const Value: Integer);
function GetParent: ITree;
procedure SetParent(const Value: ITree);
function GetTokenType: Integer;
function GetTokenStartIndex: Integer;
procedure SetTokenStartIndex(const Value: Integer);
function GetTokenStopIndex: Integer;
procedure SetTokenStopIndex(const Value: Integer);
function GetText: String;
{ Methods }
/// <summary>
/// Add all elements of kids list as children of this node
/// </summary>
/// <param name="kids"></param>
procedure AddChildren(const Kids: IList<IBaseTree>);
procedure SetChild(const I: Integer; const T: ITree);
procedure FreshenParentAndChildIndexes(const Offset: Integer);
procedure SanityCheckParentAndChildIndexes; overload;
procedure SanityCheckParentAndChildIndexes(const Parent: ITree;
const I: Integer); overload;
/// <summary>
/// Print out a whole tree not just a node
/// </summary>
function ToStringTree: String;
function DupNode: ITree;
{ Properties }
/// <summary>
/// Get the children internal list of children. Manipulating the list
/// directly is not a supported operation (i.e. you do so at your own risk)
/// </summary>
property Children: IList<IBaseTree> read GetChildren;
/// <summary>BaseTree doesn't track child indexes.</summary>
property ChildIndex: Integer read GetChildIndex write SetChildIndex;
/// <summary>BaseTree doesn't track parent pointers.</summary>
property Parent: ITree read GetParent write SetParent;
/// <summary>Return a token type; needed for tree parsing </summary>
property TokenType: Integer read GetTokenType;
/// <summary>
/// What is the smallest token index (indexing from 0) for this node
/// and its children?
/// </summary>
property TokenStartIndex: Integer read GetTokenStartIndex write SetTokenStartIndex;
/// <summary>
/// What is the largest token index (indexing from 0) for this node
/// and its children?
/// </summary>
property TokenStopIndex: Integer read GetTokenStopIndex write SetTokenStopIndex;
property Text: String read GetText;
end;
/// <summary>A tree node that is wrapper for a Token object. </summary>
/// <remarks>
/// After 3.0 release while building tree rewrite stuff, it became clear
/// that computing parent and child index is very difficult and cumbersome.
/// Better to spend the space in every tree node. If you don't want these
/// extra fields, it's easy to cut them out in your own BaseTree subclass.
/// </remarks>
ICommonTree = interface(IBaseTree)
['{791C0EA6-1E4D-443E-83E2-CC1EFEAECC8B}']
{ Property accessors }
function GetToken: IToken;
function GetStartIndex: Integer;
procedure SetStartIndex(const Value: Integer);
function GetStopIndex: Integer;
procedure SetStopIndex(const Value: Integer);
{ Properties }
property Token: IToken read GetToken;
property StartIndex: Integer read GetStartIndex write SetStartIndex;
property StopIndex: Integer read GetStopIndex write SetStopIndex;
end;
// A node representing erroneous token range in token stream
ICommonErrorNode = interface(ICommonTree)
['{20FF30BA-C055-4E8F-B3E7-7FFF6313853E}']
end;
/// <summary>
/// A TreeAdaptor that works with any Tree implementation
/// </summary>
IBaseTreeAdaptor = interface(ITreeAdaptor)
['{B9CE670A-E53F-494C-B700-E4A3DF42D482}']
/// <summary>
/// This is generic in the sense that it will work with any kind of
/// tree (not just the ITree interface). It invokes the adaptor routines
/// not the tree node routines to do the construction.
/// </summary>
function DupTree(const Tree: IANTLRInterface): IANTLRInterface; overload;
function DupTree(const T, Parent: IANTLRInterface): IANTLRInterface; overload;
/// <summary>
/// Tell me how to create a token for use with imaginary token nodes.
/// For example, there is probably no input symbol associated with imaginary
/// token DECL, but you need to create it as a payload or whatever for
/// the DECL node as in ^(DECL type ID).
///
/// If you care what the token payload objects' type is, you should
/// override this method and any other createToken variant.
/// </summary>
function CreateToken(const TokenType: Integer; const Text: String): IToken; overload;
/// <summary>
/// Tell me how to create a token for use with imaginary token nodes.
/// For example, there is probably no input symbol associated with imaginary
/// token DECL, but you need to create it as a payload or whatever for
/// the DECL node as in ^(DECL type ID).
///
/// This is a variant of createToken where the new token is derived from
/// an actual real input token. Typically this is for converting '{'
/// tokens to BLOCK etc... You'll see
///
/// r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
///
/// If you care what the token payload objects' type is, you should
/// override this method and any other createToken variant.
/// </summary>
function CreateToken(const FromToken: IToken): IToken; overload;
end;
/// <summary>
/// A TreeAdaptor that works with any Tree implementation. It provides
/// really just factory methods; all the work is done by BaseTreeAdaptor.
/// If you would like to have different tokens created than ClassicToken
/// objects, you need to override this and then set the parser tree adaptor to
/// use your subclass.
///
/// To get your parser to build nodes of a different type, override
/// Create(Token).
/// </summary>
ICommonTreeAdaptor = interface(IBaseTreeAdaptor)
['{B067EE7A-38EB-4156-9447-CDD6DDD6D13B}']
end;
/// <summary>
/// A buffered stream of tree nodes. Nodes can be from a tree of ANY kind.
/// </summary>
/// <remarks>
/// This node stream sucks all nodes out of the tree specified in the
/// constructor during construction and makes pointers into the tree
/// using an array of Object pointers. The stream necessarily includes
/// pointers to DOWN and UP and EOF nodes.
///
/// This stream knows how to mark/release for backtracking.
///
/// This stream is most suitable for tree interpreters that need to
/// jump around a lot or for tree parsers requiring speed (at cost of memory).
/// There is some duplicated functionality here with UnBufferedTreeNodeStream
/// but just in bookkeeping, not tree walking etc...
///
/// <see cref="UnBufferedTreeNodeStream"/>
///
/// </remarks>
ICommonTreeNodeStream = interface(ITreeNodeStream)
['{0112FB31-AA1E-471C-ADC3-D97AC5D77E05}']
{ Property accessors }
function GetCurrentSymbol: IANTLRInterface;
function GetTreeSource: IANTLRInterface;
function GetSourceName: String;
function GetTokenStream: ITokenStream;
procedure SetTokenStream(const Value: ITokenStream);
function GetTreeAdaptor: ITreeAdaptor;
procedure SetTreeAdaptor(const Value: ITreeAdaptor);
function GetHasUniqueNavigationNodes: Boolean;
procedure SetHasUniqueNavigationNodes(const Value: Boolean);
{ Methods }
/// <summary>
/// Walk tree with depth-first-search and fill nodes buffer.
/// Don't do DOWN, UP nodes if its a list (t is isNil).
/// </summary>
procedure FillBuffer(const T: IANTLRInterface);
function Get(const I: Integer): IANTLRInterface;
function LT(const K: Integer): IANTLRInterface;
/// <summary>
/// Look backwards k nodes
/// </summary>
function LB(const K: Integer): IANTLRInterface;
/// <summary>
/// Make stream jump to a new location, saving old location.
/// Switch back with pop().
/// </summary>
procedure Push(const Index: Integer);
/// <summary>
/// Seek back to previous index saved during last Push() call.
/// Return top of stack (return index).
/// </summary>
function Pop: Integer;
procedure Reset;
// Debugging
function ToTokenString(const Start, Stop: Integer): String;
function ToString(const Start, Stop: IANTLRInterface): String; overload;
function ToString: String; overload;
{ Properties }
property CurrentSymbol: IANTLRInterface read GetCurrentSymbol;
/// <summary>
/// Where is this stream pulling nodes from? This is not the name, but
/// the object that provides node objects.
/// </summary>
property TreeSource: IANTLRInterface read GetTreeSource;
property SourceName: String read GetSourceName;
property TokenStream: ITokenStream read GetTokenStream write SetTokenStream;
property TreeAdaptor: ITreeAdaptor read GetTreeAdaptor write SetTreeAdaptor;
property HasUniqueNavigationNodes: Boolean read GetHasUniqueNavigationNodes write SetHasUniqueNavigationNodes;
end;
/// <summary>
/// A record of the rules used to Match a token sequence. The tokens
/// end up as the leaves of this tree and rule nodes are the interior nodes.
/// This really adds no functionality, it is just an alias for CommonTree
/// that is more meaningful (specific) and holds a String to display for a node.
/// </summary>
IParseTree = interface(IANTLRInterface)
['{1558F260-CAF8-4488-A242-3559BCE4E573}']
{ Methods }
// Emit a token and all hidden nodes before. EOF node holds all
// hidden tokens after last real token.
function ToStringWithHiddenTokens: String;
// Print out the leaves of this tree, which means printing original
// input back out.
function ToInputString: String;
procedure _ToStringLeaves(const Buf: TStringBuilder);
end;
/// <summary>
/// A generic list of elements tracked in an alternative to be used in
/// a -> rewrite rule. We need to subclass to fill in the next() method,
/// which returns either an AST node wrapped around a token payload or
/// an existing subtree.
///
/// Once you start next()ing, do not try to add more elements. It will
/// break the cursor tracking I believe.
///
/// <see cref="RewriteRuleSubtreeStream"/>
/// <see cref="RewriteRuleTokenStream"/>
///
/// TODO: add mechanism to detect/puke on modification after reading from stream
/// </summary>
IRewriteRuleElementStream = interface(IANTLRInterface)
['{3CB6C521-F583-40DC-A1E3-4D7D57B98C74}']
{ Property accessors }
function GetDescription: String;
{ Methods }
procedure Add(const El: IANTLRInterface);
/// <summary>
/// Reset the condition of this stream so that it appears we have
/// not consumed any of its elements. Elements themselves are untouched.
/// </summary>
/// <remarks>
/// Once we reset the stream, any future use will need duplicates. Set
/// the dirty bit.
/// </remarks>
procedure Reset;
function HasNext: Boolean;
/// <summary>
/// Return the next element in the stream.
/// </summary>
function NextTree: IANTLRInterface;
function NextNode: IANTLRInterface;
function Size: Integer;
{ Properties }
property Description: String read GetDescription;
end;
/// <summary>
/// Queues up nodes matched on left side of -> in a tree parser. This is
/// the analog of RewriteRuleTokenStream for normal parsers.
/// </summary>
IRewriteRuleNodeStream = interface(IRewriteRuleElementStream)
['{F60D1D36-FE13-4312-99DA-11E5F4BEBB66}']
{ Methods }
function NextNode: IANTLRInterface;
end;
IRewriteRuleSubtreeStream = interface(IRewriteRuleElementStream)
['{C6BDA145-D926-45BC-B293-67490D72829B}']
{ Methods }
/// <summary>
/// Treat next element as a single node even if it's a subtree.
/// </summary>
/// <remarks>
/// This is used instead of next() when the result has to be a
/// tree root node. Also prevents us from duplicating recently-added
/// children; e.g., ^(type ID)+ adds ID to type and then 2nd iteration
/// must dup the type node, but ID has been added.
///
/// Referencing a rule result twice is ok; dup entire tree as
/// we can't be adding trees as root; e.g., expr expr.
/// </remarks>
function NextNode: IANTLRInterface;
end;
IRewriteRuleTokenStream = interface(IRewriteRuleElementStream)
['{4D46AB00-7A19-4F69-B159-1EF09DB8C09C}']
/// <summary>
/// Get next token from stream and make a node for it.
/// </summary>
/// <remarks>
/// ITreeAdaptor.Create() returns an object, so no further restrictions possible.
/// </remarks>
function NextNode: IANTLRInterface;
function NextToken: IToken;
end;
/// <summary>
/// A parser for a stream of tree nodes. "tree grammars" result in a subclass
/// of this. All the error reporting and recovery is shared with Parser via
/// the BaseRecognizer superclass.
/// </summary>
ITreeParser = interface(IBaseRecognizer)
['{20611FB3-9830-444D-B385-E8C2D094484B}']
{ Property accessors }
function GetTreeNodeStream: ITreeNodeStream;
procedure SetTreeNodeStream(const Value: ITreeNodeStream);
{ Methods }
procedure TraceIn(const RuleName: String; const RuleIndex: Integer);
procedure TraceOut(const RuleName: String; const RuleIndex: Integer);
{ Properties }
property TreeNodeStream: ITreeNodeStream read GetTreeNodeStream write SetTreeNodeStream;
end;
ITreePatternLexer = interface(IANTLRInterface)
['{C3FEC614-9E6F-48D2-ABAB-59FC83D8BC2F}']
{ Methods }
function NextToken: Integer;
function SVal: String;
end;
IContextVisitor = interface(IANTLRInterface)
['{92B80D23-C63E-48B4-A9CD-EC2639317E43}']
{ Methods }
procedure Visit(const T, Parent: IANTLRInterface; const ChildIndex: Integer;
const Labels: IDictionary<String, IANTLRInterface>);
end;
/// <summary>
/// Build and navigate trees with this object. Must know about the names
/// of tokens so you have to pass in a map or array of token names (from which
/// this class can build the map). I.e., Token DECL means nothing unless the
/// class can translate it to a token type.
/// </summary>
/// <remarks>
/// In order to create nodes and navigate, this class needs a TreeAdaptor.
///
/// This class can build a token type -> node index for repeated use or for
/// iterating over the various nodes with a particular type.
///
/// This class works in conjunction with the TreeAdaptor rather than moving
/// all this functionality into the adaptor. An adaptor helps build and
/// navigate trees using methods. This class helps you do it with string
/// patterns like "(A B C)". You can create a tree from that pattern or
/// match subtrees against it.
/// </remarks>
ITreeWizard = interface(IANTLRInterface)
['{4F440E19-893A-4E52-A979-E5377EAFA3B8}']
{ Methods }
/// <summary>
/// Compute a Map&lt;String, Integer&gt; that is an inverted index of
/// tokenNames (which maps int token types to names).
/// </summary>
function ComputeTokenTypes(const TokenNames: TStringArray): IDictionary<String, Integer>;
/// <summary>
/// Using the map of token names to token types, return the type.
/// </summary>
function GetTokenType(const TokenName: String): Integer;
/// <summary>
/// Walk the entire tree and make a node name to nodes mapping.
/// </summary>
/// <remarks>
/// For now, use recursion but later nonrecursive version may be
/// more efficient. Returns Map&lt;Integer, List&gt; where the List is
/// of your AST node type. The Integer is the token type of the node.
///
/// TODO: save this index so that find and visit are faster
/// </remarks>
function Index(const T: IANTLRInterface): IDictionary<Integer, IList<IANTLRInterface>>;
/// <summary>Return a List of tree nodes with token type ttype</summary>
function Find(const T: IANTLRInterface; const TokenType: Integer): IList<IANTLRInterface>; overload;
/// <summary>Return a List of subtrees matching pattern</summary>
function Find(const T: IANTLRInterface; const Pattern: String): IList<IANTLRInterface>; overload;
function FindFirst(const T: IANTLRInterface; const TokenType: Integer): IANTLRInterface; overload;
function FindFirst(const T: IANTLRInterface; const Pattern: String): IANTLRInterface; overload;
/// <summary>
/// Visit every ttype node in t, invoking the visitor.
/// </summary>
/// <remarks>
/// This is a quicker
/// version of the general visit(t, pattern) method. The labels arg
/// of the visitor action method is never set (it's null) since using
/// a token type rather than a pattern doesn't let us set a label.
/// </remarks>
procedure Visit(const T: IANTLRInterface; const TokenType: Integer;
const Visitor: IContextVisitor); overload;
/// <summary>
/// For all subtrees that match the pattern, execute the visit action.
/// </summary>
/// <remarks>
/// The implementation uses the root node of the pattern in combination
/// with visit(t, ttype, visitor) so nil-rooted patterns are not allowed.
/// Patterns with wildcard roots are also not allowed.
/// </remarks>
procedure Visit(const T: IANTLRInterface; const Pattern: String;
const Visitor: IContextVisitor); overload;
/// <summary>
/// Given a pattern like (ASSIGN %lhs:ID %rhs:.) with optional labels
/// on the various nodes and '.' (dot) as the node/subtree wildcard,
/// return true if the pattern matches and fill the labels Map with
/// the labels pointing at the appropriate nodes. Return false if
/// the pattern is malformed or the tree does not match.
/// </summary>
/// <remarks>
/// If a node specifies a text arg in pattern, then that must match
/// for that node in t.
///
/// TODO: what's a better way to indicate bad pattern? Exceptions are a hassle
/// </remarks>
function Parse(const T: IANTLRInterface; const Pattern: String;
const Labels: IDictionary<String, IANTLRInterface>): Boolean; overload;
function Parse(const T: IANTLRInterface; const Pattern: String): Boolean; overload;
/// <summary>
/// Create a tree or node from the indicated tree pattern that closely
/// follows ANTLR tree grammar tree element syntax:
///
/// (root child1 ... child2).
///
/// </summary>
/// <remarks>
/// You can also just pass in a node: ID
///
/// Any node can have a text argument: ID[foo]
/// (notice there are no quotes around foo--it's clear it's a string).
///
/// nil is a special name meaning "give me a nil node". Useful for
/// making lists: (nil A B C) is a list of A B C.
/// </remarks>
function CreateTreeOrNode(const Pattern: String): IANTLRInterface;
/// <summary>
/// Compare type, structure, and text of two trees, assuming adaptor in
/// this instance of a TreeWizard.
/// </summary>
function Equals(const T1, T2: IANTLRInterface): Boolean; overload;
/// <summary>
/// Compare t1 and t2; return true if token types/text, structure match exactly.
/// The trees are examined in their entirety so that (A B) does not match
/// (A B C) nor (A (B C)).
/// </summary>
/// <remarks>
/// TODO: allow them to pass in a comparator
/// TODO: have a version that is nonstatic so it can use instance adaptor
///
/// I cannot rely on the tree node's equals() implementation as I make
/// no constraints at all on the node types nor interface etc...
/// </remarks>
function Equals(const T1, T2: IANTLRInterface; const Adaptor: ITreeAdaptor): Boolean; overload;
end;
ITreePatternParser = interface(IANTLRInterface)
['{0CE3DF2A-7E4C-4A7C-8FE8-F1D7AFF97CAE}']
{ Methods }
function Pattern: IANTLRInterface;
function ParseTree: IANTLRInterface;
function ParseNode: IANTLRInterface;
end;
/// <summary>
/// This is identical to the ParserRuleReturnScope except that
/// the start property is a tree node and not a Token object
/// when you are parsing trees. To be generic the tree node types
/// have to be Object :(
/// </summary>
ITreeRuleReturnScope = interface(IRuleReturnScope)
['{FA2B1766-34E5-4D92-8996-371D5CFED999}']
end;
/// <summary>
/// A stream of tree nodes, accessing nodes from a tree of ANY kind.
/// </summary>
/// <remarks>
/// No new nodes should be created in tree during the walk. A small buffer
/// of tokens is kept to efficiently and easily handle LT(i) calls, though
/// the lookahead mechanism is fairly complicated.
///
/// For tree rewriting during tree parsing, this must also be able
/// to replace a set of children without "losing its place".
/// That part is not yet implemented. Will permit a rule to return
/// a different tree and have it stitched into the output tree probably.
///
/// <see cref="CommonTreeNodeStream"/>
///
/// </remarks>
IUnBufferedTreeNodeStream = interface(ITreeNodeStream)
['{E46367AD-ED41-4D97-824E-575A48F7435D}']
{ Property accessors }
function GetHasUniqueNavigationNodes: Boolean;
procedure SetHasUniqueNavigationNodes(const Value: Boolean);
function GetCurrent: IANTLRInterface;
function GetTokenStream: ITokenStream;
procedure SetTokenStream(const Value: ITokenStream);
{ Methods }
procedure Reset;
function MoveNext: Boolean;
{ Properties }
property HasUniqueNavigationNodes: Boolean read GetHasUniqueNavigationNodes write SetHasUniqueNavigationNodes;
property Current: IANTLRInterface read GetCurrent;
property TokenStream: ITokenStream read GetTokenStream write SetTokenStream;
end;
/// <summary>Base class for all exceptions thrown during AST rewrite construction.</summary>
/// <remarks>
/// This signifies a case where the cardinality of two or more elements
/// in a subrule are different: (ID INT)+ where |ID|!=|INT|
/// </remarks>
ERewriteCardinalityException = class(Exception)
strict private
FElementDescription: String;
public
constructor Create(const AElementDescription: String);
property ElementDescription: String read FElementDescription write FElementDescription;
end;
/// <summary>
/// No elements within a (...)+ in a rewrite rule
/// </summary>
ERewriteEarlyExitException = class(ERewriteCardinalityException)
// No new declarations
end;
/// <summary>
/// Ref to ID or expr but no tokens in ID stream or subtrees in expr stream
/// </summary>
ERewriteEmptyStreamException = class(ERewriteCardinalityException)
// No new declarations
end;
type
TTree = class sealed
strict private
class var
FINVALID_NODE: ITree;
private
class procedure Initialize; static;
public
class property INVALID_NODE: ITree read FINVALID_NODE;
end;
TBaseTree = class abstract(TANTLRObject, IBaseTree, ITree)
protected
{ ITree / IBaseTree }
function GetParent: ITree; virtual;
procedure SetParent(const Value: ITree); virtual;
function GetChildIndex: Integer; virtual;
procedure SetChildIndex(const Value: Integer); virtual;
function GetTokenType: Integer; virtual; abstract;
function GetText: String; virtual; abstract;
function GetTokenStartIndex: Integer; virtual; abstract;
procedure SetTokenStartIndex(const Value: Integer); virtual; abstract;
function GetTokenStopIndex: Integer; virtual; abstract;
procedure SetTokenStopIndex(const Value: Integer); virtual; abstract;
function DupNode: ITree; virtual; abstract;
function ToStringTree: String; virtual;
function GetChildCount: Integer; virtual;
function GetIsNil: Boolean; virtual;
function GetLine: Integer; virtual;
function GetCharPositionInLine: Integer; virtual;
function GetChild(const I: Integer): ITree; virtual;
procedure AddChild(const T: ITree);
function DeleteChild(const I: Integer): IANTLRInterface;
procedure FreshenParentAndChildIndexes; overload;
procedure ReplaceChildren(const StartChildIndex, StopChildIndex: Integer;
const T: IANTLRInterface);
protected
{ IBaseTree }
function GetChildren: IList<IBaseTree>;
procedure AddChildren(const Kids: IList<IBaseTree>);
procedure SetChild(const I: Integer; const T: ITree); virtual;
procedure FreshenParentAndChildIndexes(const Offset: Integer); overload;
procedure SanityCheckParentAndChildIndexes; overload; virtual;
procedure SanityCheckParentAndChildIndexes(const Parent: ITree;
const I: Integer); overload; virtual;
strict protected
FChildren: IList<IBaseTree>;
/// <summary>Override in a subclass to change the impl of children list </summary>
function CreateChildrenList: IList<IBaseTree>; virtual;
public
constructor Create; overload;
/// <summary>Create a new node from an existing node does nothing for BaseTree
/// as there are no fields other than the children list, which cannot
/// be copied as the children are not considered part of this node.
/// </summary>
constructor Create(const ANode: ITree); overload;
function ToString: String; override; abstract;
end;
TCommonTree = class(TBaseTree, ICommonTree)
strict protected
/// <summary>A single token is the payload </summary>
FToken: IToken;
/// <summary>
/// What token indexes bracket all tokens associated with this node
/// and below?
/// </summary>
FStartIndex: Integer;
FStopIndex: Integer;
/// <summary>Who is the parent node of this node; if null, implies node is root</summary>
/// <remarks>
/// FParent should be of type ICommonTree, but that would introduce a
/// circular reference because the tree also maintains links to it's
/// children. This circular reference would cause a memory leak because
/// the reference count will never reach 0. This is avoided by making
/// FParent a regular pointer and letting the GetParent and SetParent
/// property accessors do the conversion to/from ICommonTree.
/// </remarks>
FParent: Pointer; { ICommonTree ; }
/// <summary>What index is this node in the child list? Range: 0..n-1</summary>
FChildIndex: Integer;
protected
{ ITree / IBaseTree }
function GetIsNil: Boolean; override;
function GetTokenType: Integer; override;
function GetText: String; override;
function GetLine: Integer; override;
function GetCharPositionInLine: Integer; override;
function GetTokenStartIndex: Integer; override;
procedure SetTokenStartIndex(const Value: Integer); override;
function GetTokenStopIndex: Integer; override;
procedure SetTokenStopIndex(const Value: Integer); override;
function GetChildIndex: Integer; override;
procedure SetChildIndex(const Value: Integer); override;
function GetParent: ITree; override;
procedure SetParent(const Value: ITree); override;
function DupNode: ITree; override;
protected
{ ICommonTree }
function GetToken: IToken;
function GetStartIndex: Integer;
procedure SetStartIndex(const Value: Integer);
function GetStopIndex: Integer;
procedure SetStopIndex(const Value: Integer);
public
constructor Create; overload;
constructor Create(const ANode: ICommonTree); overload;
constructor Create(const AToken: IToken); overload;
function ToString: String; override;
end;
TCommonErrorNode = class(TCommonTree, ICommonErrorNode)
strict private
FInput: IIntStream;
FStart: IToken;
FStop: IToken;
FTrappedException: ERecognitionException;
protected
{ ITree / IBaseTree }
function GetIsNil: Boolean; override;
function GetTokenType: Integer; override;
function GetText: String; override;
public
constructor Create(const AInput: ITokenStream; const AStart, AStop: IToken;
const AException: ERecognitionException);
function ToString: String; override;
end;
TBaseTreeAdaptor = class abstract(TANTLRObject, IBaseTreeAdaptor, ITreeAdaptor)
strict private
/// <summary>A map of tree node to unique IDs.</summary>
FTreeToUniqueIDMap: IDictionary<IANTLRInterface, Integer>;
/// <summary>Next available unique ID.</summary>
FUniqueNodeID: Integer;
protected
{ ITreeAdaptor }
function CreateNode(const Payload: IToken): IANTLRInterface; overload; virtual; abstract;
function DupNode(const TreeNode: IANTLRInterface): IANTLRInterface; virtual; abstract;
function DupTree(const Tree: IANTLRInterface): IANTLRInterface; overload; virtual;
function GetNilNode: IANTLRInterface; virtual;
function ErrorNode(const Input: ITokenStream; const Start, Stop: IToken;
const E: ERecognitionException): IANTLRInterface; virtual;
function IsNil(const Tree: IANTLRInterface): Boolean; virtual;
procedure AddChild(const T, Child: IANTLRInterface); virtual;
function BecomeRoot(const NewRoot, OldRoot: IANTLRInterface): IANTLRInterface; overload; virtual;
function RulePostProcessing(const Root: IANTLRInterface): IANTLRInterface; virtual;
function GetUniqueID(const Node: IANTLRInterface): Integer;
function BecomeRoot(const NewRoot: IToken; const OldRoot: IANTLRInterface): IANTLRInterface; overload; virtual;
function CreateNode(const TokenType: Integer; const FromToken: IToken): IANTLRInterface; overload; virtual;
function CreateNode(const TokenType: Integer; const FromToken: IToken;
const Text: String): IANTLRInterface; overload; virtual;
function CreateNode(const TokenType: Integer; const Text: String): IANTLRInterface; overload; virtual;
function GetNodeType(const T: IANTLRInterface): Integer; virtual;
procedure SetNodeType(const T: IANTLRInterface; const NodeType: Integer); virtual;
function GetNodeText(const T: IANTLRInterface): String; virtual;
procedure SetNodeText(const T: IANTLRInterface; const Text: String); virtual;
function GetToken(const TreeNode: IANTLRInterface): IToken; virtual; abstract;
procedure SetTokenBoundaries(const T: IANTLRInterface; const StartToken,
StopToken: IToken); virtual; abstract;
function GetTokenStartIndex(const T: IANTLRInterface): Integer; virtual; abstract;
function GetTokenStopIndex(const T: IANTLRInterface): Integer; virtual; abstract;
function GetChild(const T: IANTLRInterface; const I: Integer): IANTLRInterface; virtual;
procedure SetChild(const T: IANTLRInterface; const I: Integer; const Child: IANTLRInterface); virtual;
function DeleteChild(const T: IANTLRInterface; const I: Integer): IANTLRInterface; virtual;
function GetChildCount(const T: IANTLRInterface): Integer; virtual;
function GetParent(const T: IANTLRInterface): IANTLRInterface; virtual; abstract;
procedure SetParent(const T, Parent: IANTLRInterface); virtual; abstract;
function GetChildIndex(const T: IANTLRInterface): Integer; virtual; abstract;
procedure SetChildIdex(const T: IANTLRInterface; const Index: Integer); virtual; abstract;
procedure ReplaceChildren(const Parent: IANTLRInterface; const StartChildIndex,
StopChildIndex: Integer; const T: IANTLRInterface); virtual; abstract;
protected
{ IBaseTreeAdaptor }
function DupTree(const T, Parent: IANTLRInterface): IANTLRInterface; overload; virtual;
function CreateToken(const TokenType: Integer; const Text: String): IToken; overload; virtual; abstract;
function CreateToken(const FromToken: IToken): IToken; overload; virtual; abstract;
public
constructor Create;
end;
TCommonTreeAdaptor = class(TBaseTreeAdaptor, ICommonTreeAdaptor)
protected
{ ITreeAdaptor }
function DupNode(const TreeNode: IANTLRInterface): IANTLRInterface; override;
function CreateNode(const Payload: IToken): IANTLRInterface; overload; override;
procedure SetTokenBoundaries(const T: IANTLRInterface; const StartToken,
StopToken: IToken); override;
function GetTokenStartIndex(const T: IANTLRInterface): Integer; override;
function GetTokenStopIndex(const T: IANTLRInterface): Integer; override;
function GetNodeText(const T: IANTLRInterface): String; override;
function GetToken(const TreeNode: IANTLRInterface): IToken; override;
function GetNodeType(const T: IANTLRInterface): Integer; override;
function GetChild(const T: IANTLRInterface; const I: Integer): IANTLRInterface; override;
function GetChildCount(const T: IANTLRInterface): Integer; override;
function GetParent(const T: IANTLRInterface): IANTLRInterface; override;
procedure SetParent(const T, Parent: IANTLRInterface); override;
function GetChildIndex(const T: IANTLRInterface): Integer; override;
procedure SetChildIdex(const T: IANTLRInterface; const Index: Integer); override;
procedure ReplaceChildren(const Parent: IANTLRInterface; const StartChildIndex,
StopChildIndex: Integer; const T: IANTLRInterface); override;
protected
{ IBaseTreeAdaptor }
function CreateToken(const TokenType: Integer; const Text: String): IToken; overload; override;
function CreateToken(const FromToken: IToken): IToken; overload; override;
end;
TCommonTreeNodeStream = class(TANTLRObject, ICommonTreeNodeStream, ITreeNodeStream)
public
const
DEFAULT_INITIAL_BUFFER_SIZE = 100;
INITIAL_CALL_STACK_SIZE = 10;
strict private
// all these navigation nodes are shared and hence they
// cannot contain any line/column info
FDown: IANTLRInterface;
FUp: IANTLRInterface;
FEof: IANTLRInterface;
/// <summary>
/// The complete mapping from stream index to tree node. This buffer
/// includes pointers to DOWN, UP, and EOF nodes.
///
/// It is built upon ctor invocation. The elements are type Object
/// as we don't what the trees look like. Load upon first need of
/// the buffer so we can set token types of interest for reverseIndexing.
/// Slows us down a wee bit to do all of the if p==-1 testing everywhere though.
/// </summary>
FNodes: IList<IANTLRInterface>;
/// <summary>Pull nodes from which tree? </summary>
FRoot: IANTLRInterface;
/// <summary>IF this tree (root) was created from a token stream, track it</summary>
FTokens: ITokenStream;
/// <summary>What tree adaptor was used to build these trees</summary>
FAdaptor: ITreeAdaptor;
/// <summary>
/// Reuse same DOWN, UP navigation nodes unless this is true
/// </summary>
FUniqueNavigationNodes: Boolean;
/// <summary>
/// The index into the nodes list of the current node (next node
/// to consume). If -1, nodes array not filled yet.
/// </summary>
FP: Integer;
/// <summary>
/// Track the last mark() call result value for use in rewind().
/// </summary>
FLastMarker: Integer;
/// <summary>
/// Stack of indexes used for push/pop calls
/// </summary>
FCalls: IStackList<Integer>;
protected
{ IIntStream }
function GetSourceName: String; virtual;
procedure Consume; virtual;
function LA(I: Integer): Integer; virtual;
function LAChar(I: Integer): Char;
function Mark: Integer; virtual;
function Index: Integer; virtual;
procedure Rewind(const Marker: Integer); overload; virtual;
procedure Rewind; overload;
procedure Release(const Marker: Integer); virtual;
procedure Seek(const Index: Integer); virtual;
function Size: Integer; virtual;
protected
{ ITreeNodeStream }
function GetTreeSource: IANTLRInterface; virtual;
function GetTokenStream: ITokenStream; virtual;
function GetTreeAdaptor: ITreeAdaptor;
procedure SetHasUniqueNavigationNodes(const Value: Boolean);
function Get(const I: Integer): IANTLRInterface;
function LT(const K: Integer): IANTLRInterface;
function ToString(const Start, Stop: IANTLRInterface): String; reintroduce; overload;
procedure ReplaceChildren(const Parent: IANTLRInterface; const StartChildIndex,
StopChildIndex: Integer; const T: IANTLRInterface);
protected
{ ICommonTreeNodeStream }
function GetCurrentSymbol: IANTLRInterface; virtual;
procedure SetTokenStream(const Value: ITokenStream); virtual;
procedure SetTreeAdaptor(const Value: ITreeAdaptor);
function GetHasUniqueNavigationNodes: Boolean;
procedure FillBuffer(const T: IANTLRInterface); overload;
function LB(const K: Integer): IANTLRInterface;
procedure Push(const Index: Integer);
function Pop: Integer;
procedure Reset;
function ToTokenString(const Start, Stop: Integer): String;
strict protected
/// <summary>
/// Walk tree with depth-first-search and fill nodes buffer.
/// Don't do DOWN, UP nodes if its a list (t is isNil).
/// </summary>
procedure FillBuffer; overload;
/// <summary>
/// As we flatten the tree, we use UP, DOWN nodes to represent
/// the tree structure. When debugging we need unique nodes
/// so instantiate new ones when uniqueNavigationNodes is true.
/// </summary>
procedure AddNavigationNode(const TokenType: Integer);
/// <summary>
/// Returns the stream index for the spcified node in the range 0..n-1 or,
/// -1 if node not found.
/// </summary>
function GetNodeIndex(const Node: IANTLRInterface): Integer;
public
constructor Create; overload;
constructor Create(const ATree: IANTLRInterface); overload;
constructor Create(const AAdaptor: ITreeAdaptor;
const ATree: IANTLRInterface); overload;
constructor Create(const AAdaptor: ITreeAdaptor;
const ATree: IANTLRInterface; const AInitialBufferSize: Integer); overload;
function ToString: String; overload; override;
end;
TParseTree = class(TBaseTree, IParseTree)
strict private
FPayload: IANTLRInterface;
FHiddenTokens: IList<IToken>;
protected
{ ITree / IBaseTree }
function GetTokenType: Integer; override;
function GetText: String; override;
function GetTokenStartIndex: Integer; override;
procedure SetTokenStartIndex(const Value: Integer); override;
function GetTokenStopIndex: Integer; override;
procedure SetTokenStopIndex(const Value: Integer); override;
function DupNode: ITree; override;
protected
{ IParseTree }
function ToStringWithHiddenTokens: String;
function ToInputString: String;
procedure _ToStringLeaves(const Buf: TStringBuilder);
public
constructor Create(const ALabel: IANTLRInterface);
function ToString: String; override;
end;
TRewriteRuleElementStream = class abstract(TANTLRObject, IRewriteRuleElementStream)
private
/// <summary>
/// Cursor 0..n-1. If singleElement!=null, cursor is 0 until you next(),
/// which bumps it to 1 meaning no more elements.
/// </summary>
FCursor: Integer;
/// <summary>
/// Track single elements w/o creating a list. Upon 2nd add, alloc list
/// </summary>
FSingleElement: IANTLRInterface;
/// <summary>
/// The list of tokens or subtrees we are tracking
/// </summary>
FElements: IList<IANTLRInterface>;
/// <summary>
/// Tracks whether a node or subtree has been used in a stream
/// </summary>
/// <remarks>
/// Once a node or subtree has been used in a stream, it must be dup'd
/// from then on. Streams are reset after subrules so that the streams
/// can be reused in future subrules. So, reset must set a dirty bit.
/// If dirty, then next() always returns a dup.
/// </remarks>
FDirty: Boolean;
/// <summary>
/// The element or stream description; usually has name of the token or
/// rule reference that this list tracks. Can include rulename too, but
/// the exception would track that info.
/// </summary>
FElementDescription: String;
FAdaptor: ITreeAdaptor;
protected
{ IRewriteRuleElementStream }
function GetDescription: String;
procedure Add(const El: IANTLRInterface);
procedure Reset; virtual;
function HasNext: Boolean;
function NextTree: IANTLRInterface; virtual;
function NextNode: IANTLRInterface; virtual; abstract;
function Size: Integer;
strict protected
/// <summary>
/// Do the work of getting the next element, making sure that
/// it's a tree node or subtree.
/// </summary>
/// <remarks>
/// Deal with the optimization of single-element list versus
/// list of size > 1. Throw an exception if the stream is
/// empty or we're out of elements and size>1.
/// </remarks>
function _Next: IANTLRInterface;
/// <summary>
/// Ensure stream emits trees; tokens must be converted to AST nodes.
/// AST nodes can be passed through unmolested.
/// </summary>
function ToTree(const El: IANTLRInterface): IANTLRInterface; virtual;
public
constructor Create(const AAdaptor: ITreeAdaptor;
const AElementDescription: String); overload;
/// <summary>
/// Create a stream with one element
/// </summary>
constructor Create(const AAdaptor: ITreeAdaptor;
const AElementDescription: String; const AOneElement: IANTLRInterface); overload;
/// <summary>
/// Create a stream, but feed off an existing list
/// </summary>
constructor Create(const AAdaptor: ITreeAdaptor;
const AElementDescription: String; const AElements: IList<IANTLRInterface>); overload;
end;
TRewriteRuleNodeStream = class(TRewriteRuleElementStream, IRewriteRuleNodeStream)
protected
{ IRewriteRuleElementStream }
function NextNode: IANTLRInterface; override;
function ToTree(const El: IANTLRInterface): IANTLRInterface; override;
end;
TRewriteRuleSubtreeStream = class(TRewriteRuleElementStream, IRewriteRuleSubtreeStream)
public
type
/// <summary>
/// This delegate is used to allow the outfactoring of some common code.
/// </summary>
/// <param name="o">The to be processed object</param>
TProcessHandler = function(const O: IANTLRInterface): IANTLRInterface of Object;
strict private
/// <summary>
/// This method has the common code of two other methods, which differed in only one
/// function call.
/// </summary>
/// <param name="ph">The delegate, which has the chosen function</param>
/// <returns>The required object</returns>
function FetchObject(const PH: TProcessHandler): IANTLRInterface;
function DupNode(const O: IANTLRInterface): IANTLRInterface;
/// <summary>
/// Tests, if the to be returned object requires duplication
/// </summary>
/// <returns><code>true</code>, if positive, <code>false</code>, if negative.</returns>
function RequiresDuplication: Boolean;
/// <summary>
/// When constructing trees, sometimes we need to dup a token or AST
/// subtree. Dup'ing a token means just creating another AST node
/// around it. For trees, you must call the adaptor.dupTree()
/// unless the element is for a tree root; then it must be a node dup
/// </summary>
function Dup(const O: IANTLRInterface): IANTLRInterface;
protected
{ IRewriteRuleElementStream }
function NextNode: IANTLRInterface; override;
function NextTree: IANTLRInterface; override;
end;
TRewriteRuleTokenStream = class(TRewriteRuleElementStream, IRewriteRuleTokenStream)
protected
{ IRewriteRuleElementStream }
function NextNode: IANTLRInterface; override;
function NextToken: IToken;
function ToTree(const El: IANTLRInterface): IANTLRInterface; override;
end;
TTreeParser = class(TBaseRecognizer, ITreeParser)
public
const
DOWN = TToken.DOWN;
UP = TToken.UP;
strict private
FInput: ITreeNodeStream;
strict protected
property Input: ITreeNodeStream read FInput;
protected
{ IBaseRecognizer }
function GetSourceName: String; override;
procedure Reset; override;
procedure MatchAny(const Input: IIntStream); override;
function GetInput: IIntStream; override;
function GetErrorHeader(const E: ERecognitionException): String; override;
function GetErrorMessage(const E: ERecognitionException;
const TokenNames: TStringArray): String; override;
protected
{ ITreeParser }
function GetTreeNodeStream: ITreeNodeStream; virtual;
procedure SetTreeNodeStream(const Value: ITreeNodeStream); virtual;
procedure TraceIn(const RuleName: String; const RuleIndex: Integer); reintroduce; overload; virtual;
procedure TraceOut(const RuleName: String; const RuleIndex: Integer); reintroduce; overload; virtual;
strict protected
function GetCurrentInputSymbol(const Input: IIntStream): IANTLRInterface; override;
function GetMissingSymbol(const Input: IIntStream;
const E: ERecognitionException; const ExpectedTokenType: Integer;
const Follow: IBitSet): IANTLRInterface; override;
procedure Mismatch(const Input: IIntStream; const TokenType: Integer;
const Follow: IBitSet); override;
public
constructor Create(const AInput: ITreeNodeStream); overload;
constructor Create(const AInput: ITreeNodeStream;
const AState: IRecognizerSharedState); overload;
end;
TTreePatternLexer = class(TANTLRObject, ITreePatternLexer)
public
const
EOF = -1;
START = 1;
STOP = 2;
ID = 3;
ARG = 4;
PERCENT = 5;
COLON = 6;
DOT = 7;
strict private
/// <summary>The tree pattern to lex like "(A B C)"</summary>
FPattern: String;
/// <summary>Index into input string</summary>
FP: Integer;
/// <summary>Current char</summary>
FC: Integer;
/// <summary>How long is the pattern in char?</summary>
FN: Integer;
/// <summary>
/// Set when token type is ID or ARG (name mimics Java's StreamTokenizer)
/// </summary>
FSVal: TStringBuilder;
FError: Boolean;
protected
{ ITreePatternLexer }
function NextToken: Integer;
function SVal: String;
strict protected
procedure Consume;
public
constructor Create; overload;
constructor Create(const APattern: String); overload;
destructor Destroy; override;
end;
TTreeWizard = class(TANTLRObject, ITreeWizard)
strict private
FAdaptor: ITreeAdaptor;
FTokenNameToTypeMap: IDictionary<String, Integer>;
public
type
/// <summary>
/// When using %label:TOKENNAME in a tree for parse(), we must track the label.
/// </summary>
ITreePattern = interface(ICommonTree)
['{893C6B4E-8474-4A1E-BEAA-8B704868401B}']
{ Property accessors }
function GetHasTextArg: Boolean;
procedure SetHasTextArg(const Value: Boolean);
function GetTokenLabel: String;
procedure SetTokenLabel(const Value: String);
{ Properties }
property HasTextArg: Boolean read GetHasTextArg write SetHasTextArg;
property TokenLabel: String read GetTokenLabel write SetTokenLabel;
end;
IWildcardTreePattern = interface(ITreePattern)
['{4778789A-5EAB-47E3-A05B-7F35CD87ECE4}']
end;
type
TVisitor = class abstract(TANTLRObject, IContextVisitor)
protected
{ IContextVisitor }
procedure Visit(const T, Parent: IANTLRInterface; const ChildIndex: Integer;
const Labels: IDictionary<String, IANTLRInterface>); overload;
strict protected
procedure Visit(const T: IANTLRInterface); overload; virtual; abstract;
end;
TTreePattern = class(TCommonTree, ITreePattern)
strict private
FLabel: String;
FHasTextArg: Boolean;
protected
{ ITreePattern }
function GetHasTextArg: Boolean;
procedure SetHasTextArg(const Value: Boolean);
function GetTokenLabel: String;
procedure SetTokenLabel(const Value: String);
public
function ToString: String; override;
end;
TWildcardTreePattern = class(TTreePattern, IWildcardTreePattern)
end;
/// <summary>
/// This adaptor creates TreePattern objects for use during scan()
/// </summary>
TTreePatternTreeAdaptor = class(TCommonTreeAdaptor)
protected
{ ITreeAdaptor }
function CreateNode(const Payload: IToken): IANTLRInterface; overload; override;
end;
strict private
type
TRecordAllElementsVisitor = class sealed(TVisitor)
strict private
FList: IList<IANTLRInterface>;
strict protected
procedure Visit(const T: IANTLRInterface); override;
public
constructor Create(const AList: IList<IANTLRInterface>);
end;
type
TPatternMatchingContextVisitor = class sealed(TANTLRObject, IContextVisitor)
strict private
FOwner: TTreeWizard;
FPattern: ITreePattern;
FList: IList<IANTLRInterface>;
protected
{ IContextVisitor }
procedure Visit(const T, Parent: IANTLRInterface; const ChildIndex: Integer;
const Labels: IDictionary<String, IANTLRInterface>); overload;
public
constructor Create(const AOwner: TTreeWizard; const APattern: ITreePattern;
const AList: IList<IANTLRInterface>);
end;
type
TInvokeVisitorOnPatternMatchContextVisitor = class sealed(TANTLRObject, IContextVisitor)
strict private
FOwner: TTreeWizard;
FPattern: ITreePattern;
FVisitor: IContextVisitor;
FLabels: IDictionary<String, IANTLRInterface>;
protected
{ IContextVisitor }
procedure Visit(const T, Parent: IANTLRInterface; const ChildIndex: Integer;
const UnusedLabels: IDictionary<String, IANTLRInterface>); overload;
public
constructor Create(const AOwner: TTreeWizard; const APattern: ITreePattern;
const AVisitor: IContextVisitor);
end;
protected
{ ITreeWizard }
function ComputeTokenTypes(const TokenNames: TStringArray): IDictionary<String, Integer>;
function GetTokenType(const TokenName: String): Integer;
function Index(const T: IANTLRInterface): IDictionary<Integer, IList<IANTLRInterface>>;
function Find(const T: IANTLRInterface; const TokenType: Integer): IList<IANTLRInterface>; overload;
function Find(const T: IANTLRInterface; const Pattern: String): IList<IANTLRInterface>; overload;
function FindFirst(const T: IANTLRInterface; const TokenType: Integer): IANTLRInterface; overload;
function FindFirst(const T: IANTLRInterface; const Pattern: String): IANTLRInterface; overload;
procedure Visit(const T: IANTLRInterface; const TokenType: Integer;
const Visitor: IContextVisitor); overload;
procedure Visit(const T: IANTLRInterface; const Pattern: String;
const Visitor: IContextVisitor); overload;
function Parse(const T: IANTLRInterface; const Pattern: String;
const Labels: IDictionary<String, IANTLRInterface>): Boolean; overload;
function Parse(const T: IANTLRInterface; const Pattern: String): Boolean; overload;
function CreateTreeOrNode(const Pattern: String): IANTLRInterface;
function Equals(const T1, T2: IANTLRInterface): Boolean; reintroduce; overload;
function Equals(const T1, T2: IANTLRInterface;
const Adaptor: ITreeAdaptor): Boolean; reintroduce; overload;
strict protected
function _Parse(const T1: IANTLRInterface; const T2: ITreePattern;
const Labels: IDictionary<String, IANTLRInterface>): Boolean;
/// <summary>Do the work for index</summary>
procedure _Index(const T: IANTLRInterface;
const M: IDictionary<Integer, IList<IANTLRInterface>>);
/// <summary>Do the recursive work for visit</summary>
procedure _Visit(const T, Parent: IANTLRInterface; const ChildIndex,
TokenType: Integer; const Visitor: IContextVisitor);
class function _Equals(const T1, T2: IANTLRInterface;
const Adaptor: ITreeAdaptor): Boolean; static;
public
constructor Create(const AAdaptor: ITreeAdaptor); overload;
constructor Create(const AAdaptor: ITreeAdaptor;
const ATokenNameToTypeMap: IDictionary<String, Integer>); overload;
constructor Create(const AAdaptor: ITreeAdaptor;
const TokenNames: TStringArray); overload;
constructor Create(const TokenNames: TStringArray); overload;
end;
TTreePatternParser = class(TANTLRObject, ITreePatternParser)
strict private
FTokenizer: ITreePatternLexer;
FTokenType: Integer;
FWizard: ITreeWizard;
FAdaptor: ITreeAdaptor;
protected
{ ITreePatternParser }
function Pattern: IANTLRInterface;
function ParseTree: IANTLRInterface;
function ParseNode: IANTLRInterface;
public
constructor Create(const ATokenizer: ITreePatternLexer;
const AWizard: ITreeWizard; const AAdaptor: ITreeAdaptor);
end;
TTreeRuleReturnScope = class(TRuleReturnScope, ITreeRuleReturnScope)
strict private
/// <summary>First node or root node of tree matched for this rule.</summary>
FStart: IANTLRInterface;
protected
{ IRuleReturnScope }
function GetStart: IANTLRInterface; override;
procedure SetStart(const Value: IANTLRInterface); override;
end;
TUnBufferedTreeNodeStream = class(TANTLRObject, IUnBufferedTreeNodeStream, ITreeNodeStream)
public
const
INITIAL_LOOKAHEAD_BUFFER_SIZE = 5;
strict protected
type
/// <summary>
/// When walking ahead with cyclic DFA or for syntactic predicates,
/// we need to record the state of the tree node stream. This
/// class wraps up the current state of the UnBufferedTreeNodeStream.
/// Calling Mark() will push another of these on the markers stack.
/// </summary>
ITreeWalkState = interface(IANTLRInterface)
['{506D1014-53CF-4B9D-BE0E-1666E9C22091}']
{ Property accessors }
function GetCurrentChildIndex: Integer;
procedure SetCurrentChildIndex(const Value: Integer);
function GetAbsoluteNodeIndex: Integer;
procedure SetAbsoluteNodeIndex(const Value: Integer);
function GetCurrentNode: IANTLRInterface;
procedure SetCurrentNode(const Value: IANTLRInterface);
function GetPreviousNode: IANTLRInterface;
procedure SetPreviousNode(const Value: IANTLRInterface);
function GetNodeStackSize: Integer;
procedure SetNodeStackSize(const Value: Integer);
function GetIndexStackSize: integer;
procedure SetIndexStackSize(const Value: integer);
function GetLookAhead: TANTLRInterfaceArray;
procedure SetLookAhead(const Value: TANTLRInterfaceArray);
{ Properties }
property CurrentChildIndex: Integer read GetCurrentChildIndex write SetCurrentChildIndex;
property AbsoluteNodeIndex: Integer read GetAbsoluteNodeIndex write SetAbsoluteNodeIndex;
property CurrentNode: IANTLRInterface read GetCurrentNode write SetCurrentNode;
property PreviousNode: IANTLRInterface read GetPreviousNode write SetPreviousNode;
///<summary>Record state of the nodeStack</summary>
property NodeStackSize: Integer read GetNodeStackSize write SetNodeStackSize;
///<summary>Record state of the indexStack</summary>
property IndexStackSize: integer read GetIndexStackSize write SetIndexStackSize;
property LookAhead: TANTLRInterfaceArray read GetLookAhead write SetLookAhead;
end;
TTreeWalkState = class(TANTLRObject, ITreeWalkState)
strict private
FCurrentChildIndex: Integer;
FAbsoluteNodeIndex: Integer;
FCurrentNode: IANTLRInterface;
FPreviousNode: IANTLRInterface;
///<summary>Record state of the nodeStack</summary>
FNodeStackSize: Integer;
///<summary>Record state of the indexStack</summary>
FIndexStackSize: integer;
FLookAhead: TANTLRInterfaceArray;
protected
{ ITreeWalkState }
function GetCurrentChildIndex: Integer;
procedure SetCurrentChildIndex(const Value: Integer);
function GetAbsoluteNodeIndex: Integer;
procedure SetAbsoluteNodeIndex(const Value: Integer);
function GetCurrentNode: IANTLRInterface;
procedure SetCurrentNode(const Value: IANTLRInterface);
function GetPreviousNode: IANTLRInterface;
procedure SetPreviousNode(const Value: IANTLRInterface);
function GetNodeStackSize: Integer;
procedure SetNodeStackSize(const Value: Integer);
function GetIndexStackSize: integer;
procedure SetIndexStackSize(const Value: integer);
function GetLookAhead: TANTLRInterfaceArray;
procedure SetLookAhead(const Value: TANTLRInterfaceArray);
end;
strict private
/// <summary>Reuse same DOWN, UP navigation nodes unless this is true</summary>
FUniqueNavigationNodes: Boolean;
/// <summary>Pull nodes from which tree? </summary>
FRoot: IANTLRInterface;
/// <summary>IF this tree (root) was created from a token stream, track it.</summary>
FTokens: ITokenStream;
/// <summary>What tree adaptor was used to build these trees</summary>
FAdaptor: ITreeAdaptor;
/// <summary>
/// As we walk down the nodes, we must track parent nodes so we know
/// where to go after walking the last child of a node. When visiting
/// a child, push current node and current index.
/// </summary>
FNodeStack: IStackList<IANTLRInterface>;
/// <summary>
/// Track which child index you are visiting for each node we push.
/// TODO: pretty inefficient...use int[] when you have time
/// </summary>
FIndexStack: IStackList<Integer>;
/// <summary>Which node are we currently visiting? </summary>
FCurrentNode: IANTLRInterface;
/// <summary>Which node did we visit last? Used for LT(-1) calls. </summary>
FPreviousNode: IANTLRInterface;
/// <summary>
/// Which child are we currently visiting? If -1 we have not visited
/// this node yet; next Consume() request will set currentIndex to 0.
/// </summary>
FCurrentChildIndex: Integer;
/// <summary>
/// What node index did we just consume? i=0..n-1 for n node trees.
/// IntStream.next is hence 1 + this value. Size will be same.
/// </summary>
FAbsoluteNodeIndex: Integer;
/// <summary>
/// Buffer tree node stream for use with LT(i). This list grows
/// to fit new lookahead depths, but Consume() wraps like a circular
/// buffer.
/// </summary>
FLookahead: TANTLRInterfaceArray;
/// <summary>lookahead[head] is the first symbol of lookahead, LT(1). </summary>
FHead: Integer;
/// <summary>
/// Add new lookahead at lookahead[tail]. tail wraps around at the
/// end of the lookahead buffer so tail could be less than head.
/// </summary>
FTail: Integer;
/// <summary>
/// Calls to Mark() may be nested so we have to track a stack of them.
/// The marker is an index into this stack. This is a List&lt;TreeWalkState&gt;.
/// Indexed from 1..markDepth. A null is kept at index 0. It is created
/// upon first call to Mark().
/// </summary>
FMarkers: IList<ITreeWalkState>;
///<summary>
/// tracks how deep Mark() calls are nested
/// </summary>
FMarkDepth: Integer;
///<summary>
/// Track the last Mark() call result value for use in Rewind().
/// </summary>
FLastMarker: Integer;
// navigation nodes
FDown: IANTLRInterface;
FUp: IANTLRInterface;
FEof: IANTLRInterface;
FCurrentEnumerationNode: ITree;
protected
{ IIntStream }
function GetSourceName: String;
procedure Consume; virtual;
function LA(I: Integer): Integer; virtual;
function LAChar(I: Integer): Char;
function Mark: Integer; virtual;
function Index: Integer; virtual;
procedure Rewind(const Marker: Integer); overload; virtual;
procedure Rewind; overload;
procedure Release(const Marker: Integer); virtual;
procedure Seek(const Index: Integer); virtual;
function Size: Integer; virtual;
protected
{ ITreeNodeStream }
function GetTreeSource: IANTLRInterface; virtual;
function GetTokenStream: ITokenStream;
function GetTreeAdaptor: ITreeAdaptor;
function Get(const I: Integer): IANTLRInterface; virtual;
function LT(const K: Integer): IANTLRInterface; virtual;
function ToString(const Start, Stop: IANTLRInterface): String; reintroduce; overload; virtual;
procedure ReplaceChildren(const Parent: IANTLRInterface; const StartChildIndex,
StopChildIndex: Integer; const T: IANTLRInterface);
protected
{ IUnBufferedTreeNodeStream }
function GetHasUniqueNavigationNodes: Boolean;
procedure SetHasUniqueNavigationNodes(const Value: Boolean);
function GetCurrent: IANTLRInterface; virtual;
procedure SetTokenStream(const Value: ITokenStream);
procedure Reset; virtual;
/// <summary>
/// Navigates to the next node found during a depth-first walk of root.
/// Also, adds these nodes and DOWN/UP imaginary nodes into the lokoahead
/// buffer as a side-effect. Normally side-effects are bad, but because
/// we can Emit many tokens for every MoveNext() call, it's pretty hard to
/// use a single return value for that. We must add these tokens to
/// the lookahead buffer.
///
/// This routine does *not* cause the 'Current' property to ever return the
/// DOWN/UP nodes; those are only returned by the LT() method.
///
/// Ugh. This mechanism is much more complicated than a recursive
/// solution, but it's the only way to provide nodes on-demand instead
/// of walking once completely through and buffering up the nodes. :(
/// </summary>
function MoveNext: Boolean; virtual;
strict protected
/// <summary>Make sure we have at least k symbols in lookahead buffer </summary>
procedure Fill(const K: Integer); virtual;
function LookaheadSize: Integer;
/// <summary>
/// Add a node to the lookahead buffer. Add at lookahead[tail].
/// If you tail+1 == head, then we must create a bigger buffer
/// and copy all the nodes over plus reset head, tail. After
/// this method, LT(1) will be lookahead[0].
/// </summary>
procedure AddLookahead(const Node: IANTLRInterface); virtual;
procedure ToStringWork(const P, Stop: IANTLRInterface;
const Buf: TStringBuilder); virtual;
function HandleRootNode: IANTLRInterface; virtual;
function VisitChild(const Child: Integer): IANTLRInterface; virtual;
/// <summary>
/// Walk upwards looking for a node with more children to walk.
/// </summary>
procedure WalkBackToMostRecentNodeWithUnvisitedChildren; virtual;
/// <summary>
/// As we flatten the tree, we use UP, DOWN nodes to represent
/// the tree structure. When debugging we need unique nodes
/// so instantiate new ones when uniqueNavigationNodes is true.
/// </summary>
procedure AddNavigationNode(const TokenType: Integer); virtual;
public
constructor Create; overload;
constructor Create(const ATree: IANTLRInterface); overload;
constructor Create(const AAdaptor: ITreeAdaptor; const ATree: IANTLRInterface); overload;
function ToString: String; overload; override;
end;
{ These functions return X or, if X = nil, an empty default instance }
function Def(const X: ICommonTree): ICommonTree; overload;
implementation
uses
Math;
{ TTree }
class procedure TTree.Initialize;
begin
FINVALID_NODE := TCommonTree.Create(TToken.INVALID_TOKEN);
end;
{ TBaseTree }
constructor TBaseTree.Create;
begin
inherited;
end;
procedure TBaseTree.AddChild(const T: ITree);
var
ChildTree: IBaseTree;
C: IBaseTree;
begin
if (T = nil) then
Exit;
ChildTree := T as IBaseTree;
if ChildTree.IsNil then // t is an empty node possibly with children
begin
if Assigned(FChildren) and SameObj(FChildren, ChildTree.Children) then
raise EInvalidOperation.Create('Attempt to add child list to itself');
// just add all of childTree's children to this
if Assigned(ChildTree.Children) then
begin
if Assigned(FChildren) then // must copy, this has children already
begin
for C in ChildTree.Children do
begin
FChildren.Add(C);
// handle double-link stuff for each child of nil root
C.Parent := Self;
C.ChildIndex := FChildren.Count - 1;
end;
end
else begin
// no children for this but t has children; just set pointer
// call general freshener routine
FChildren := ChildTree.Children;
FreshenParentAndChildIndexes;
end;
end;
end
else
begin
// child is not nil (don't care about children)
if (FChildren = nil) then
begin
FChildren := CreateChildrenList; // create children list on demand
end;
FChildren.Add(ChildTree);
ChildTree.Parent := Self;
ChildTree.ChildIndex := FChildren.Count - 1;
end;
end;
procedure TBaseTree.AddChildren(const Kids: IList<IBaseTree>);
var
T: IBaseTree;
begin
for T in Kids do
AddChild(T);
end;
constructor TBaseTree.Create(const ANode: ITree);
begin
Create;
// No default implementation
end;
function TBaseTree.CreateChildrenList: IList<IBaseTree>;
begin
Result := TList<IBaseTree>.Create;
end;
function TBaseTree.DeleteChild(const I: Integer): IANTLRInterface;
begin
if (FChildren = nil) then
Result := nil
else
begin
Result := FChildren[I];
FChildren.Delete(I);
// walk rest and decrement their child indexes
FreshenParentAndChildIndexes(I);
end;
end;
procedure TBaseTree.FreshenParentAndChildIndexes(const Offset: Integer);
var
N, C: Integer;
Child: ITree;
begin
N := GetChildCount;
for C := Offset to N - 1 do
begin
Child := GetChild(C);
Child.ChildIndex := C;
Child.Parent := Self;
end;
end;
procedure TBaseTree.FreshenParentAndChildIndexes;
begin
FreshenParentAndChildIndexes(0);
end;
function TBaseTree.GetCharPositionInLine: Integer;
begin
Result := 0;
end;
function TBaseTree.GetChild(const I: Integer): ITree;
begin
if (FChildren = nil) or (I >= FChildren.Count) then
Result := nil
else
Result := FChildren[I];
end;
function TBaseTree.GetChildCount: Integer;
begin
if Assigned(FChildren) then
Result := FChildren.Count
else
Result := 0;
end;
function TBaseTree.GetChildIndex: Integer;
begin
// No default implementation
Result := 0;
end;
function TBaseTree.GetChildren: IList<IBaseTree>;
begin
Result := FChildren;
end;
function TBaseTree.GetIsNil: Boolean;
begin
Result := False;
end;
function TBaseTree.GetLine: Integer;
begin
Result := 0;
end;
function TBaseTree.GetParent: ITree;
begin
// No default implementation
Result := nil;
end;
procedure TBaseTree.ReplaceChildren(const StartChildIndex,
StopChildIndex: Integer; const T: IANTLRInterface);
var
ReplacingHowMany, ReplacingWithHowMany, NumNewChildren, Delta, I, J: Integer;
IndexToDelete, C, ReplacedSoFar: Integer;
NewTree, Killed: IBaseTree;
NewChildren: IList<IBaseTree>;
Child: IBaseTree;
begin
if (FChildren = nil) then
raise EArgumentException.Create('indexes invalid; no children in list');
ReplacingHowMany := StopChildIndex - StartChildIndex + 1;
NewTree := T as IBaseTree;
// normalize to a list of children to add: newChildren
if (NewTree.IsNil) then
NewChildren := NewTree.Children
else
begin
NewChildren := TList<IBaseTree>.Create;
NewChildren.Add(NewTree);
end;
ReplacingWithHowMany := NewChildren.Count;
NumNewChildren := NewChildren.Count;
Delta := ReplacingHowMany - ReplacingWithHowMany;
// if same number of nodes, do direct replace
if (Delta = 0) then
begin
J := 0; // index into new children
for I := StartChildIndex to StopChildIndex do
begin
Child := NewChildren[J];
FChildren[I] := Child;
Child.Parent := Self;
Child.ChildIndex := I;
Inc(J);
end;
end
else
if (Delta > 0) then
begin
// fewer new nodes than there were
// set children and then delete extra
for J := 0 to NumNewChildren - 1 do
FChildren[StartChildIndex + J] := NewChildren[J];
IndexToDelete := StartChildIndex + NumNewChildren;
for C := IndexToDelete to StopChildIndex do
begin
// delete same index, shifting everybody down each time
Killed := FChildren[IndexToDelete];
FChildren.Delete(IndexToDelete);
end;
FreshenParentAndChildIndexes(StartChildIndex);
end
else
begin
// more new nodes than were there before
// fill in as many children as we can (replacingHowMany) w/o moving data
ReplacedSoFar := 0;
while (ReplacedSoFar < ReplacingHowMany) do
begin
FChildren[StartChildIndex + ReplacedSoFar] := NewChildren[ReplacedSoFar];
Inc(ReplacedSoFar);
end;
// replacedSoFar has correct index for children to add
while (ReplacedSoFar < ReplacingWithHowMany) do
begin
FChildren.Insert(StartChildIndex + ReplacedSoFar,NewChildren[ReplacedSoFar]);
Inc(ReplacedSoFar);
end;
FreshenParentAndChildIndexes(StartChildIndex);
end;
end;
procedure TBaseTree.SanityCheckParentAndChildIndexes;
begin
SanityCheckParentAndChildIndexes(nil, -1);
end;
procedure TBaseTree.SanityCheckParentAndChildIndexes(const Parent: ITree;
const I: Integer);
var
N, C: Integer;
Child: ICommonTree;
begin
if not SameObj(Parent, GetParent) then
raise EArgumentException.Create('parents don''t match; expected '
+ Parent.ToString + ' found ' + GetParent.ToString);
if (I <> GetChildIndex) then
raise EArgumentException.Create('child indexes don''t match; expected '
+ IntToStr(I) + ' found ' + IntToStr(GetChildIndex));
N := GetChildCount;
for C := 0 to N - 1 do
begin
Child := GetChild(C) as ICommonTree;
Child.SanityCheckParentAndChildIndexes(Self, C);
end;
end;
procedure TBaseTree.SetChild(const I: Integer; const T: ITree);
begin
if (T = nil) then
Exit;
if T.IsNil then
raise EArgumentException.Create('Cannot set single child to a list');
if (FChildren = nil) then
begin
FChildren := CreateChildrenList;
end;
FChildren[I] := T as IBaseTree;
T.Parent := Self;
T.ChildIndex := I;
end;
procedure TBaseTree.SetChildIndex(const Value: Integer);
begin
// No default implementation
end;
procedure TBaseTree.SetParent(const Value: ITree);
begin
// No default implementation
end;
function TBaseTree.ToStringTree: String;
var
Buf: TStringBuilder;
I: Integer;
T: IBaseTree;
begin
if (FChildren = nil) or (FChildren.Count = 0) then
Result := ToString
else
begin
Buf := TStringBuilder.Create;
try
if (not GetIsNil) then
begin
Buf.Append('(');
Buf.Append(ToString);
Buf.Append(' ');
end;
for I := 0 to FChildren.Count - 1 do
begin
T := FChildren[I];
if (I > 0) then
Buf.Append(' ');
Buf.Append(T.ToStringTree);
end;
if (not GetIsNil) then
Buf.Append(')');
Result := Buf.ToString;
finally
Buf.Free;
end;
end;
end;
{ TCommonTree }
constructor TCommonTree.Create;
begin
inherited;
FStartIndex := -1;
FStopIndex := -1;
FChildIndex := -1;
end;
constructor TCommonTree.Create(const ANode: ICommonTree);
begin
inherited Create(ANode);
FToken := ANode.Token;
FStartIndex := ANode.StartIndex;
FStopIndex := ANode.StopIndex;
FChildIndex := -1;
end;
constructor TCommonTree.Create(const AToken: IToken);
begin
Create;
FToken := AToken;
end;
function TCommonTree.DupNode: ITree;
begin
Result := TCommonTree.Create(Self) as ICommonTree;
end;
function TCommonTree.GetCharPositionInLine: Integer;
begin
if (FToken = nil) or (FToken.CharPositionInLine = -1) then
begin
if (GetChildCount > 0) then
Result := GetChild(0).CharPositionInLine
else
Result := 0;
end
else
Result := FToken.CharPositionInLine;
end;
function TCommonTree.GetChildIndex: Integer;
begin
Result := FChildIndex;
end;
function TCommonTree.GetIsNil: Boolean;
begin
Result := (FToken = nil);
end;
function TCommonTree.GetLine: Integer;
begin
if (FToken = nil) or (FToken.Line = 0) then
begin
if (GetChildCount > 0) then
Result := GetChild(0).Line
else
Result := 0
end
else
Result := FToken.Line;
end;
function TCommonTree.GetParent: ITree;
begin
Result := ITree(FParent);
end;
function TCommonTree.GetStartIndex: Integer;
begin
Result := FStartIndex;
end;
function TCommonTree.GetStopIndex: Integer;
begin
Result := FStopIndex;
end;
function TCommonTree.GetText: String;
begin
if (FToken = nil) then
Result := ''
else
Result := FToken.Text;
end;
function TCommonTree.GetToken: IToken;
begin
Result := FToken;
end;
function TCommonTree.GetTokenStartIndex: Integer;
begin
if (FStartIndex = -1) and (FToken <> nil) then
Result := FToken.TokenIndex
else
Result := FStartIndex;
end;
function TCommonTree.GetTokenStopIndex: Integer;
begin
if (FStopIndex = -1) and (FToken <> nil) then
Result := FToken.TokenIndex
else
Result := FStopIndex;
end;
function TCommonTree.GetTokenType: Integer;
begin
if (FToken = nil) then
Result := TToken.INVALID_TOKEN_TYPE
else
Result := FToken.TokenType;
end;
procedure TCommonTree.SetChildIndex(const Value: Integer);
begin
FChildIndex := Value;
end;
procedure TCommonTree.SetParent(const Value: ITree);
begin
FParent := Pointer(Value as ICommonTree);
end;
procedure TCommonTree.SetStartIndex(const Value: Integer);
begin
FStartIndex := Value;
end;
procedure TCommonTree.SetStopIndex(const Value: Integer);
begin
FStopIndex := Value;
end;
procedure TCommonTree.SetTokenStartIndex(const Value: Integer);
begin
FStartIndex := Value;
end;
procedure TCommonTree.SetTokenStopIndex(const Value: Integer);
begin
FStopIndex := Value;
end;
function TCommonTree.ToString: String;
begin
if (GetIsNil) then
Result := 'nil'
else
if (GetTokenType = TToken.INVALID_TOKEN_TYPE) then
Result := '<errornode>'
else
if (FToken = nil) then
Result := ''
else
Result := FToken.Text;
end;
{ TCommonErrorNode }
constructor TCommonErrorNode.Create(const AInput: ITokenStream; const AStart,
AStop: IToken; const AException: ERecognitionException);
begin
inherited Create;
if (AStop = nil) or ((AStop.TokenIndex < AStart.TokenIndex)
and (AStop.TokenType <> TToken.EOF))
then
// sometimes resync does not consume a token (when LT(1) is
// in follow set). So, stop will be 1 to left to start. adjust.
// Also handle case where start is the first token and no token
// is consumed during recovery; LT(-1) will return null.
FStop := AStart
else
FStop := AStop;
FInput := AInput;
FStart := AStart;
FTrappedException := AException;
end;
function TCommonErrorNode.GetIsNil: Boolean;
begin
Result := False;
end;
function TCommonErrorNode.GetText: String;
var
I, J: Integer;
begin
I := FStart.TokenIndex;
if (FStop.TokenType = TToken.EOF) then
J := (FInput as ITokenStream).Size
else
J := FStop.TokenIndex;
Result := (FInput as ITokenStream).ToString(I, J);
end;
function TCommonErrorNode.GetTokenType: Integer;
begin
Result := TToken.INVALID_TOKEN_TYPE;
end;
function TCommonErrorNode.ToString: String;
begin
if (FTrappedException is EMissingTokenException) then
Result := '<missing type: '
+ IntToStr(EMissingTokenException(FTrappedException).MissingType) + '>'
else
if (FTrappedException is EUnwantedTokenException) then
Result := '<extraneous: '
+ EUnwantedTokenException(FTrappedException).UnexpectedToken.ToString
+ ', resync=' + GetText + '>'
else
if (FTrappedException is EMismatchedTokenException) then
Result := '<mismatched token: ' + FTrappedException.Token.ToString
+ ', resync=' + GetText + '>'
else
if (FTrappedException is ENoViableAltException) then
Result := '<unexpected: ' + FTrappedException.Token.ToString
+ ', resync=' + GetText + '>'
else
Result := '<error: ' + GetText + '>';
end;
{ TBaseTreeAdaptor }
procedure TBaseTreeAdaptor.AddChild(const T, Child: IANTLRInterface);
begin
if Assigned(T) and Assigned(Child) then
(T as ITree).AddChild(Child as ITree);
end;
function TBaseTreeAdaptor.BecomeRoot(const NewRoot,
OldRoot: IANTLRInterface): IANTLRInterface;
var
NewRootTree, OldRootTree: ITree;
NC: Integer;
begin
NewRootTree := NewRoot as ITree;
OldRootTree := OldRoot as ITree;
if (OldRoot = nil) then
Result := NewRoot
else
begin
// handle ^(nil real-node)
if (NewRootTree.IsNil) then
begin
NC := NewRootTree.ChildCount;
if (NC = 1) then
NewRootTree := NewRootTree.GetChild(0)
else
if (NC > 1) then
raise Exception.Create('more than one node as root');
end;
// add oldRoot to newRoot; AddChild takes care of case where oldRoot
// is a flat list (i.e., nil-rooted tree). All children of oldRoot
// are added to newRoot.
NewRootTree.AddChild(OldRootTree);
Result := NewRootTree;
end;
end;
function TBaseTreeAdaptor.BecomeRoot(const NewRoot: IToken;
const OldRoot: IANTLRInterface): IANTLRInterface;
begin
Result := BecomeRoot(CreateNode(NewRoot), OldRoot);
end;
function TBaseTreeAdaptor.CreateNode(const TokenType: Integer;
const FromToken: IToken): IANTLRInterface;
var
Token: IToken;
begin
Token := CreateToken(FromToken);
Token.TokenType := TokenType;
Result := CreateNode(Token);
end;
function TBaseTreeAdaptor.CreateNode(const TokenType: Integer;
const Text: String): IANTLRInterface;
var
Token: IToken;
begin
Token := CreateToken(TokenType, Text);
Result := CreateNode(Token);
end;
function TBaseTreeAdaptor.CreateNode(const TokenType: Integer;
const FromToken: IToken; const Text: String): IANTLRInterface;
var
Token: IToken;
begin
Token := CreateToken(FromToken);
Token.TokenType := TokenType;
Token.Text := Text;
Result := CreateNode(Token);
end;
constructor TBaseTreeAdaptor.Create;
begin
inherited Create;
FUniqueNodeID := 1;
end;
function TBaseTreeAdaptor.DeleteChild(const T: IANTLRInterface;
const I: Integer): IANTLRInterface;
begin
Result := (T as ITree).DeleteChild(I);
end;
function TBaseTreeAdaptor.DupTree(const T,
Parent: IANTLRInterface): IANTLRInterface;
var
I, N: Integer;
Child, NewSubTree: IANTLRInterface;
begin
if (T = nil) then
Result := nil
else
begin
Result := DupNode(T);
// ensure new subtree root has parent/child index set
SetChildIdex(Result, GetChildIndex(T));
SetParent(Result, Parent);
N := GetChildCount(T);
for I := 0 to N - 1 do
begin
Child := GetChild(T, I);
NewSubTree := DupTree(Child, T);
AddChild(Result, NewSubTree);
end;
end;
end;
function TBaseTreeAdaptor.DupTree(const Tree: IANTLRInterface): IANTLRInterface;
begin
Result := DupTree(Tree, nil);
end;
function TBaseTreeAdaptor.ErrorNode(const Input: ITokenStream; const Start,
Stop: IToken; const E: ERecognitionException): IANTLRInterface;
begin
Result := TCommonErrorNode.Create(Input, Start, Stop, E);
end;
function TBaseTreeAdaptor.GetChild(const T: IANTLRInterface;
const I: Integer): IANTLRInterface;
begin
Result := (T as ITree).GetChild(I);
end;
function TBaseTreeAdaptor.GetChildCount(const T: IANTLRInterface): Integer;
begin
Result := (T as ITree).ChildCount;
end;
function TBaseTreeAdaptor.GetNilNode: IANTLRInterface;
begin
Result := CreateNode(nil);
end;
function TBaseTreeAdaptor.GetNodeText(const T: IANTLRInterface): String;
begin
Result := (T as ITree).Text;
end;
function TBaseTreeAdaptor.GetNodeType(const T: IANTLRInterface): Integer;
begin
Result := 0;
end;
function TBaseTreeAdaptor.GetUniqueID(const Node: IANTLRInterface): Integer;
begin
if (FTreeToUniqueIDMap = nil) then
FTreeToUniqueIDMap := TDictionary<IANTLRInterface, Integer>.Create;
if (not FTreeToUniqueIDMap.TryGetValue(Node, Result)) then
begin
Result := FUniqueNodeID;
FTreeToUniqueIDMap[Node] := Result;
Inc(FUniqueNodeID);
end;
end;
function TBaseTreeAdaptor.IsNil(const Tree: IANTLRInterface): Boolean;
begin
Result := (Tree as ITree).IsNil;
end;
function TBaseTreeAdaptor.RulePostProcessing(
const Root: IANTLRInterface): IANTLRInterface;
var
R: ITree;
begin
R := Root as ITree;
if Assigned(R) and (R.IsNil) then
begin
if (R.ChildCount = 0) then
R := nil
else
if (R.ChildCount = 1) then
begin
R := R.GetChild(0);
// whoever invokes rule will set parent and child index
R.Parent := nil;
R.ChildIndex := -1;
end;
end;
Result := R;
end;
procedure TBaseTreeAdaptor.SetChild(const T: IANTLRInterface; const I: Integer;
const Child: IANTLRInterface);
begin
(T as ITree).SetChild(I, Child as ITree);
end;
procedure TBaseTreeAdaptor.SetNodeText(const T: IANTLRInterface;
const Text: String);
begin
raise EInvalidOperation.Create('don''t know enough about Tree node');
end;
procedure TBaseTreeAdaptor.SetNodeType(const T: IANTLRInterface;
const NodeType: Integer);
begin
raise EInvalidOperation.Create('don''t know enough about Tree node');
end;
{ TCommonTreeAdaptor }
function TCommonTreeAdaptor.CreateNode(const Payload: IToken): IANTLRInterface;
begin
Result := TCommonTree.Create(Payload);
end;
function TCommonTreeAdaptor.CreateToken(const TokenType: Integer;
const Text: String): IToken;
begin
Result := TCommonToken.Create(TokenType, Text);
end;
function TCommonTreeAdaptor.CreateToken(const FromToken: IToken): IToken;
begin
Result := TCommonToken.Create(FromToken);
end;
function TCommonTreeAdaptor.DupNode(
const TreeNode: IANTLRInterface): IANTLRInterface;
begin
if (TreeNode = nil) then
Result := nil
else
Result := (TreeNode as ITree).DupNode;
end;
function TCommonTreeAdaptor.GetChild(const T: IANTLRInterface;
const I: Integer): IANTLRInterface;
begin
if (T = nil) then
Result := nil
else
Result := (T as ITree).GetChild(I);
end;
function TCommonTreeAdaptor.GetChildCount(const T: IANTLRInterface): Integer;
begin
if (T = nil) then
Result := 0
else
Result := (T as ITree).ChildCount;
end;
function TCommonTreeAdaptor.GetChildIndex(const T: IANTLRInterface): Integer;
begin
Result := (T as ITree).ChildIndex;
end;
function TCommonTreeAdaptor.GetNodeText(const T: IANTLRInterface): String;
begin
if (T = nil) then
Result := ''
else
Result := (T as ITree).Text;
end;
function TCommonTreeAdaptor.GetNodeType(const T: IANTLRInterface): Integer;
begin
if (T = nil) then
Result := TToken.INVALID_TOKEN_TYPE
else
Result := (T as ITree).TokenType;
end;
function TCommonTreeAdaptor.GetParent(
const T: IANTLRInterface): IANTLRInterface;
begin
Result := (T as ITree).Parent;
end;
function TCommonTreeAdaptor.GetToken(const TreeNode: IANTLRInterface): IToken;
var
CommonTree: ICommonTree;
begin
if Supports(TreeNode, ICommonTree, CommonTree) then
Result := CommonTree.Token
else
Result := nil; // no idea what to do
end;
function TCommonTreeAdaptor.GetTokenStartIndex(
const T: IANTLRInterface): Integer;
begin
if (T = nil) then
Result := -1
else
Result := (T as ITree).TokenStartIndex;
end;
function TCommonTreeAdaptor.GetTokenStopIndex(
const T: IANTLRInterface): Integer;
begin
if (T = nil) then
Result := -1
else
Result := (T as ITree).TokenStopIndex;
end;
procedure TCommonTreeAdaptor.ReplaceChildren(const Parent: IANTLRInterface;
const StartChildIndex, StopChildIndex: Integer; const T: IANTLRInterface);
begin
if Assigned(Parent) then
(Parent as ITree).ReplaceChildren(StartChildIndex, StopChildIndex, T);
end;
procedure TCommonTreeAdaptor.SetChildIdex(const T: IANTLRInterface;
const Index: Integer);
begin
(T as ITree).ChildIndex := Index;
end;
procedure TCommonTreeAdaptor.SetParent(const T, Parent: IANTLRInterface);
begin
(T as ITree).Parent := (Parent as ITree);
end;
procedure TCommonTreeAdaptor.SetTokenBoundaries(const T: IANTLRInterface;
const StartToken, StopToken: IToken);
var
Start, Stop: Integer;
begin
if Assigned(T) then
begin
if Assigned(StartToken) then
Start := StartToken.TokenIndex
else
Start := 0;
if Assigned(StopToken) then
Stop := StopToken.TokenIndex
else
Stop := 0;
(T as ITree).TokenStartIndex := Start;
(T as ITree).TokenStopIndex := Stop;
end;
end;
{ TCommonTreeNodeStream }
procedure TCommonTreeNodeStream.AddNavigationNode(const TokenType: Integer);
var
NavNode: IANTLRInterface;
begin
if (TokenType = TToken.DOWN) then
begin
if (GetHasUniqueNavigationNodes) then
NavNode := FAdaptor.CreateNode(TToken.DOWN, 'DOWN')
else
NavNode := FDown;
end
else
begin
if (GetHasUniqueNavigationNodes) then
NavNode := FAdaptor.CreateNode(TToken.UP, 'UP')
else
NavNode := FUp;
end;
FNodes.Add(NavNode);
end;
procedure TCommonTreeNodeStream.Consume;
begin
if (FP = -1) then
FillBuffer;
Inc(FP);
end;
constructor TCommonTreeNodeStream.Create;
begin
inherited;
FP := -1;
end;
constructor TCommonTreeNodeStream.Create(const ATree: IANTLRInterface);
begin
Create(TCommonTreeAdaptor.Create, ATree);
end;
constructor TCommonTreeNodeStream.Create(const AAdaptor: ITreeAdaptor;
const ATree: IANTLRInterface);
begin
Create(AAdaptor, ATree, DEFAULT_INITIAL_BUFFER_SIZE);
end;
constructor TCommonTreeNodeStream.Create(const AAdaptor: ITreeAdaptor;
const ATree: IANTLRInterface; const AInitialBufferSize: Integer);
begin
Create;
FRoot := ATree;
FAdaptor := AAdaptor;
FNodes := TList<IANTLRInterface>.Create;
FNodes.Capacity := AInitialBufferSize;
FDown := FAdaptor.CreateNode(TToken.DOWN, 'DOWN');
FUp := FAdaptor.CreateNode(TToken.UP, 'UP');
FEof := FAdaptor.CreateNode(TToken.EOF, 'EOF');
end;
procedure TCommonTreeNodeStream.FillBuffer;
begin
FillBuffer(FRoot);
FP := 0; // buffer of nodes intialized now
end;
procedure TCommonTreeNodeStream.FillBuffer(const T: IANTLRInterface);
var
IsNil: Boolean;
C, N: Integer;
begin
IsNil := FAdaptor.IsNil(T);
if (not IsNil) then
FNodes.Add(T); // add this node
// add DOWN node if t has children
N := FAdaptor.GetChildCount(T);
if (not IsNil) and (N > 0) then
AddNavigationNode(TToken.DOWN);
// and now add all its children
for C := 0 to N - 1 do
FillBuffer(FAdaptor.GetChild(T, C));
// add UP node if t has children
if (not IsNil) and (N > 0) then
AddNavigationNode(TToken.UP);
end;
function TCommonTreeNodeStream.Get(const I: Integer): IANTLRInterface;
begin
if (FP = -1) then
FillBuffer;
Result := FNodes[I];
end;
function TCommonTreeNodeStream.GetCurrentSymbol: IANTLRInterface;
begin
Result := LT(1);
end;
function TCommonTreeNodeStream.GetHasUniqueNavigationNodes: Boolean;
begin
Result := FUniqueNavigationNodes;
end;
function TCommonTreeNodeStream.GetNodeIndex(
const Node: IANTLRInterface): Integer;
var
T: IANTLRInterface;
begin
if (FP = -1) then
FillBuffer;
for Result := 0 to FNodes.Count - 1 do
begin
T := FNodes[Result];
if (T = Node) then
Exit;
end;
Result := -1;
end;
function TCommonTreeNodeStream.GetSourceName: String;
begin
Result := GetTokenStream.SourceName;
end;
function TCommonTreeNodeStream.GetTokenStream: ITokenStream;
begin
Result := FTokens;
end;
function TCommonTreeNodeStream.GetTreeAdaptor: ITreeAdaptor;
begin
Result := FAdaptor;
end;
function TCommonTreeNodeStream.GetTreeSource: IANTLRInterface;
begin
Result := FRoot;
end;
function TCommonTreeNodeStream.Index: Integer;
begin
Result := FP;
end;
function TCommonTreeNodeStream.LA(I: Integer): Integer;
begin
Result := FAdaptor.GetNodeType(LT(I));
end;
function TCommonTreeNodeStream.LAChar(I: Integer): Char;
begin
Result := Char(LA(I));
end;
function TCommonTreeNodeStream.LB(const K: Integer): IANTLRInterface;
begin
if (K = 0) then
Result := nil
else
if ((FP - K) < 0) then
Result := nil
else
Result := FNodes[FP - K];
end;
function TCommonTreeNodeStream.LT(const K: Integer): IANTLRInterface;
begin
if (FP = -1) then
FillBuffer;
if (K = 0) then
Result := nil
else
if (K < 0) then
Result := LB(-K)
else
if ((FP + K - 1) >= FNodes.Count) then
Result := FEof
else
Result := FNodes[FP + K - 1];
end;
function TCommonTreeNodeStream.Mark: Integer;
begin
if (FP = -1) then
FillBuffer;
FLastMarker := Index;
Result := FLastMarker;
end;
function TCommonTreeNodeStream.Pop: Integer;
begin
Result := FCalls.Pop;
Seek(Result);
end;
procedure TCommonTreeNodeStream.Push(const Index: Integer);
begin
if (FCalls = nil) then
FCalls := TStackList<Integer>.Create;
FCalls.Push(FP); // save current index
Seek(Index);
end;
procedure TCommonTreeNodeStream.Release(const Marker: Integer);
begin
// no resources to release
end;
procedure TCommonTreeNodeStream.ReplaceChildren(const Parent: IANTLRInterface;
const StartChildIndex, StopChildIndex: Integer; const T: IANTLRInterface);
begin
if Assigned(Parent) then
FAdaptor.ReplaceChildren(Parent, StartChildIndex, StopChildIndex, T);
end;
procedure TCommonTreeNodeStream.Reset;
begin
FP := -1;
FLastMarker := 0;
if Assigned(FCalls) then
FCalls.Clear;
end;
procedure TCommonTreeNodeStream.Rewind(const Marker: Integer);
begin
Seek(Marker);
end;
procedure TCommonTreeNodeStream.Rewind;
begin
Seek(FLastMarker);
end;
procedure TCommonTreeNodeStream.Seek(const Index: Integer);
begin
if (FP = -1) then
FillBuffer;
FP := Index;
end;
procedure TCommonTreeNodeStream.SetHasUniqueNavigationNodes(
const Value: Boolean);
begin
FUniqueNavigationNodes := Value;
end;
procedure TCommonTreeNodeStream.SetTokenStream(const Value: ITokenStream);
begin
FTokens := Value;
end;
procedure TCommonTreeNodeStream.SetTreeAdaptor(const Value: ITreeAdaptor);
begin
FAdaptor := Value;
end;
function TCommonTreeNodeStream.Size: Integer;
begin
if (FP = -1) then
FillBuffer;
Result := FNodes.Count;
end;
function TCommonTreeNodeStream.ToString(const Start,
Stop: IANTLRInterface): String;
var
CommonTree: ICommonTree;
I, BeginTokenIndex, EndTokenIndex: Integer;
T: IANTLRInterface;
Buf: TStringBuilder;
Text: String;
begin
WriteLn('ToString');
if (Start = nil) or (Stop = nil) then
Exit;
if (FP = -1) then
FillBuffer;
if Supports(Start, ICommonTree, CommonTree) then
Write('ToString: ' + CommonTree.Token.ToString + ', ')
else
WriteLn(Start.ToString);
if Supports(Stop, ICommonTree, CommonTree) then
WriteLn(CommonTree.Token.ToString)
else
WriteLn(Stop.ToString);
// if we have the token stream, use that to dump text in order
if Assigned(FTokens) then
begin
BeginTokenIndex := FAdaptor.GetTokenStartIndex(Start);
EndTokenIndex := FAdaptor.GetTokenStartIndex(Stop);
// if it's a tree, use start/stop index from start node
// else use token range from start/stop nodes
if (FAdaptor.GetNodeType(Stop) = TToken.UP) then
EndTokenIndex := FAdaptor.GetTokenStopIndex(Start)
else
if (FAdaptor.GetNodeType(Stop) = TToken.EOF) then
EndTokenIndex := Size - 2; // don't use EOF
Result := FTokens.ToString(BeginTokenIndex, EndTokenIndex);
Exit;
end;
// walk nodes looking for start
T := nil;
I := 0;
while (I < FNodes.Count) do
begin
T := FNodes[I];
if SameObj(T, Start) then
Break;
Inc(I);
end;
// now walk until we see stop, filling string buffer with text
Buf := TStringBuilder.Create;
try
T := FNodes[I];
while (T <> Stop) do
begin
Text := FAdaptor.GetNodeText(T);
if (Text = '') then
Text := ' ' + IntToStr(FAdaptor.GetNodeType(T));
Buf.Append(Text);
Inc(I);
T := FNodes[I];
end;
// include stop node too
Text := FAdaptor.GetNodeText(Stop);
if (Text = '') then
Text := ' ' + IntToStr(FAdaptor.GetNodeType(Stop));
Buf.Append(Text);
Result := Buf.ToString;
finally
Buf.Free;
end;
end;
function TCommonTreeNodeStream.ToString: String;
var
Buf: TStringBuilder;
T: IANTLRInterface;
begin
if (FP = -1) then
FillBuffer;
Buf := TStringBuilder.Create;
try
for T in FNodes do
begin
Buf.Append(' ');
Buf.Append(FAdaptor.GetNodeType(T));
end;
Result := Buf.ToString;
finally
Buf.Free;
end;
end;
function TCommonTreeNodeStream.ToTokenString(const Start,
Stop: Integer): String;
var
I: Integer;
T: IANTLRInterface;
Buf: TStringBuilder;
begin
if (FP = -1) then
FillBuffer;
Buf := TStringBuilder.Create;
try
for I := Stop to Min(FNodes.Count - 1, Stop) do
begin
T := FNodes[I];
Buf.Append(' ');
Buf.Append(FAdaptor.GetToken(T).ToString);
end;
Result := Buf.ToString;
finally
Buf.Free;
end;
end;
{ TParseTree }
constructor TParseTree.Create(const ALabel: IANTLRInterface);
begin
inherited Create;
FPayload := ALabel;
end;
function TParseTree.DupNode: ITree;
begin
Result := nil;
end;
function TParseTree.GetText: String;
begin
Result := ToString;
end;
function TParseTree.GetTokenStartIndex: Integer;
begin
Result := 0;
end;
function TParseTree.GetTokenStopIndex: Integer;
begin
Result := 0;
end;
function TParseTree.GetTokenType: Integer;
begin
Result := 0;
end;
procedure TParseTree.SetTokenStartIndex(const Value: Integer);
begin
// No implementation
end;
procedure TParseTree.SetTokenStopIndex(const Value: Integer);
begin
// No implementation
end;
function TParseTree.ToInputString: String;
var
Buf: TStringBuilder;
begin
Buf := TStringBuilder.Create;
try
_ToStringLeaves(Buf);
Result := Buf.ToString;
finally
Buf.Free;
end;
end;
function TParseTree.ToString: String;
var
T: IToken;
begin
if Supports(FPayload, IToken, T) then
begin
if (T.TokenType = TToken.EOF) then
Result := '<EOF>'
else
Result := T.Text;
end
else
Result := FPayload.ToString;
end;
function TParseTree.ToStringWithHiddenTokens: String;
var
Buf: TStringBuilder;
Hidden: IToken;
NodeText: String;
begin
Buf := TStringBuilder.Create;
try
if Assigned(FHiddenTokens) then
begin
for Hidden in FHiddenTokens do
Buf.Append(Hidden.Text);
end;
NodeText := ToString;
if (NodeText <> '<EOF>') then
Buf.Append(NodeText);
Result := Buf.ToString;
finally
Buf.Free;
end;
end;
procedure TParseTree._ToStringLeaves(const Buf: TStringBuilder);
var
T: IBaseTree;
begin
if Supports(FPayload, IToken) then
begin
// leaf node token?
Buf.Append(ToStringWithHiddenTokens);
Exit;
end;
if Assigned(FChildren) then
for T in FChildren do
(T as IParseTree)._ToStringLeaves(Buf);
end;
{ ERewriteCardinalityException }
constructor ERewriteCardinalityException.Create(
const AElementDescription: String);
begin
inherited Create(AElementDescription);
FElementDescription := AElementDescription;
end;
{ TRewriteRuleElementStream }
procedure TRewriteRuleElementStream.Add(const El: IANTLRInterface);
begin
if (El = nil) then
Exit;
if Assigned(FElements) then
// if in list, just add
FElements.Add(El)
else
if (FSingleElement = nil) then
// no elements yet, track w/o list
FSingleElement := El
else
begin
// adding 2nd element, move to list
FElements := TList<IANTLRInterface>.Create;
FElements.Capacity := 5;
FElements.Add(FSingleElement);
FSingleElement := nil;
FElements.Add(El);
end;
end;
constructor TRewriteRuleElementStream.Create(const AAdaptor: ITreeAdaptor;
const AElementDescription: String);
begin
inherited Create;
FAdaptor := AAdaptor;
FElementDescription := AElementDescription;
end;
constructor TRewriteRuleElementStream.Create(const AAdaptor: ITreeAdaptor;
const AElementDescription: String; const AOneElement: IANTLRInterface);
begin
Create(AAdaptor, AElementDescription);
Add(AOneElement);
end;
constructor TRewriteRuleElementStream.Create(const AAdaptor: ITreeAdaptor;
const AElementDescription: String; const AElements: IList<IANTLRInterface>);
begin
Create(AAdaptor, AElementDescription);
FElements := AElements;
end;
function TRewriteRuleElementStream.GetDescription: String;
begin
Result := FElementDescription;
end;
function TRewriteRuleElementStream.HasNext: Boolean;
begin
Result := ((FSingleElement <> nil) and (FCursor < 1))
or ((FElements <> nil) and (FCursor < FElements.Count));
end;
function TRewriteRuleElementStream.NextTree: IANTLRInterface;
begin
Result := _Next;
end;
procedure TRewriteRuleElementStream.Reset;
begin
FCursor := 0;
FDirty := True;
end;
function TRewriteRuleElementStream.Size: Integer;
begin
if Assigned(FSingleElement) then
Result := 1
else
if Assigned(FElements) then
Result := FElements.Count
else
Result := 0;
end;
function TRewriteRuleElementStream.ToTree(const El: IANTLRInterface): IANTLRInterface;
begin
Result := El;
end;
function TRewriteRuleElementStream._Next: IANTLRInterface;
var
Size: Integer;
begin
Size := Self.Size;
if (Size = 0) then
raise ERewriteEmptyStreamException.Create(FElementDescription);
if (FCursor >= Size) then
begin
// out of elements?
if (Size = 1) then
// if size is 1, it's ok; return and we'll dup
Result := ToTree(FSingleElement)
else
// out of elements and size was not 1, so we can't dup
raise ERewriteCardinalityException.Create(FElementDescription);
end
else
begin
// we have elements
if Assigned(FSingleElement) then
begin
Inc(FCursor); // move cursor even for single element list
Result := ToTree(FSingleElement);
end
else
begin
// must have more than one in list, pull from elements
Result := ToTree(FElements[FCursor]);
Inc(FCursor);
end;
end;
end;
{ TRewriteRuleNodeStream }
function TRewriteRuleNodeStream.NextNode: IANTLRInterface;
begin
Result := _Next;
end;
function TRewriteRuleNodeStream.ToTree(
const El: IANTLRInterface): IANTLRInterface;
begin
Result := FAdaptor.DupNode(El);
end;
{ TRewriteRuleSubtreeStream }
function TRewriteRuleSubtreeStream.Dup(
const O: IANTLRInterface): IANTLRInterface;
begin
Result := FAdaptor.DupTree(O);
end;
function TRewriteRuleSubtreeStream.DupNode(
const O: IANTLRInterface): IANTLRInterface;
begin
Result := FAdaptor.DupNode(O);
end;
function TRewriteRuleSubtreeStream.FetchObject(
const PH: TProcessHandler): IANTLRInterface;
begin
if (RequiresDuplication) then
// process the object
Result := PH(_Next)
else
// test above then fetch
Result := _Next;
end;
function TRewriteRuleSubtreeStream.NextNode: IANTLRInterface;
begin
// if necessary, dup (at most a single node since this is for making root nodes).
Result := FetchObject(DupNode);
end;
function TRewriteRuleSubtreeStream.NextTree: IANTLRInterface;
begin
// if out of elements and size is 1, dup
Result := FetchObject(Dup);
end;
function TRewriteRuleSubtreeStream.RequiresDuplication: Boolean;
var
Size: Integer;
begin
Size := Self.Size;
// if dirty or if out of elements and size is 1
Result := FDirty or ((FCursor >= Size) and (Size = 1));
end;
{ TRewriteRuleTokenStream }
function TRewriteRuleTokenStream.NextNode: IANTLRInterface;
begin
Result := FAdaptor.CreateNode(_Next as IToken)
end;
function TRewriteRuleTokenStream.NextToken: IToken;
begin
Result := _Next as IToken;
end;
function TRewriteRuleTokenStream.ToTree(
const El: IANTLRInterface): IANTLRInterface;
begin
Result := El;
end;
{ TTreeParser }
constructor TTreeParser.Create(const AInput: ITreeNodeStream);
begin
inherited Create; // highlight that we go to super to set state object
SetTreeNodeStream(AInput);
end;
constructor TTreeParser.Create(const AInput: ITreeNodeStream;
const AState: IRecognizerSharedState);
begin
inherited Create(AState); // share the state object with another parser
SetTreeNodeStream(AInput);
end;
function TTreeParser.GetCurrentInputSymbol(
const Input: IIntStream): IANTLRInterface;
begin
Result := FInput.LT(1);
end;
function TTreeParser.GetErrorHeader(const E: ERecognitionException): String;
begin
Result := GetGrammarFileName + ': node from ';
if (E.ApproximateLineInfo) then
Result := Result + 'after ';
Result := Result + 'line ' + IntToStr(E.Line) + ':' + IntToStr(E.CharPositionInLine);
end;
function TTreeParser.GetErrorMessage(const E: ERecognitionException;
const TokenNames: TStringArray): String;
var
Adaptor: ITreeAdaptor;
begin
if (Self is TTreeParser) then
begin
Adaptor := (E.Input as ITreeNodeStream).TreeAdaptor;
E.Token := Adaptor.GetToken(E.Node);
if (E.Token = nil) then
// could be an UP/DOWN node
E.Token := TCommonToken.Create(Adaptor.GetNodeType(E.Node),
Adaptor.GetNodeText(E.Node));
end;
Result := inherited GetErrorMessage(E, TokenNames);
end;
function TTreeParser.GetInput: IIntStream;
begin
Result := FInput;
end;
function TTreeParser.GetMissingSymbol(const Input: IIntStream;
const E: ERecognitionException; const ExpectedTokenType: Integer;
const Follow: IBitSet): IANTLRInterface;
var
TokenText: String;
begin
TokenText := '<missing ' + GetTokenNames[ExpectedTokenType] + '>';
Result := TCommonTree.Create(TCommonToken.Create(ExpectedTokenType, TokenText));
end;
function TTreeParser.GetSourceName: String;
begin
Result := FInput.SourceName;
end;
function TTreeParser.GetTreeNodeStream: ITreeNodeStream;
begin
Result := FInput;
end;
procedure TTreeParser.MatchAny(const Input: IIntStream);
var
Look: IANTLRInterface;
Level, TokenType: Integer;
begin
FState.ErrorRecovery := False;
FState.Failed := False;
Look := FInput.LT(1);
if (FInput.TreeAdaptor.GetChildCount(Look) = 0) then
begin
FInput.Consume; // not subtree, consume 1 node and return
Exit;
end;
// current node is a subtree, skip to corresponding UP.
// must count nesting level to get right UP
Level := 0;
TokenType := FInput.TreeAdaptor.GetNodeType(Look);
while (TokenType <> TToken.EOF) and not ((TokenType = UP) and (Level = 0)) do
begin
FInput.Consume;
Look := FInput.LT(1);
TokenType := FInput.TreeAdaptor.GetNodeType(Look);
if (TokenType = DOWN) then
Inc(Level)
else
if (TokenType = UP) then
Dec(Level);
end;
FInput.Consume; // consume UP
end;
procedure TTreeParser.Mismatch(const Input: IIntStream;
const TokenType: Integer; const Follow: IBitSet);
begin
raise EMismatchedTreeNodeException.Create(TokenType, FInput);
end;
procedure TTreeParser.Reset;
begin
inherited; // reset all recognizer state variables
if Assigned(FInput) then
FInput.Seek(0); // rewind the input
end;
procedure TTreeParser.SetTreeNodeStream(const Value: ITreeNodeStream);
begin
FInput := Value;
end;
procedure TTreeParser.TraceIn(const RuleName: String; const RuleIndex: Integer);
begin
inherited TraceIn(RuleName, RuleIndex, FInput.LT(1).ToString);
end;
procedure TTreeParser.TraceOut(const RuleName: String;
const RuleIndex: Integer);
begin
inherited TraceOut(RuleName, RuleIndex, FInput.LT(1).ToString);
end;
{ TTreePatternLexer }
constructor TTreePatternLexer.Create;
begin
inherited;
FSVal := TStringBuilder.Create;
end;
procedure TTreePatternLexer.Consume;
begin
Inc(FP);
if (FP > FN) then
FC := EOF
else
FC := Integer(FPattern[FP]);
end;
constructor TTreePatternLexer.Create(const APattern: String);
begin
Create;
FPattern := APattern;
FN := Length(FPattern);
Consume;
end;
destructor TTreePatternLexer.Destroy;
begin
FSVal.Free;
inherited;
end;
function TTreePatternLexer.NextToken: Integer;
begin
FSVal.Length := 0; // reset, but reuse buffer
while (FC <> EOF) do
begin
if (FC = 32) or (FC = 10) or (FC = 13) or (FC = 9) then
begin
Consume;
Continue;
end;
if ((FC >= Ord('a')) and (FC <= Ord('z')))
or ((FC >= Ord('A')) and (FC <= Ord('Z')))
or (FC = Ord('_'))
then begin
FSVal.Append(Char(FC));
Consume;
while ((FC >= Ord('a')) and (FC <= Ord('z')))
or ((FC >= Ord('A')) and (FC <= Ord('Z')))
or ((FC >= Ord('0')) and (FC <= Ord('9')))
or (FC = Ord('_')) do
begin
FSVal.Append(Char(FC));
Consume;
end;
Exit(ID);
end;
if (FC = Ord('(')) then
begin
Consume;
Exit(START);
end;
if (FC = Ord(')')) then
begin
Consume;
Exit(STOP);
end;
if (FC = Ord('%')) then
begin
Consume;
Exit(PERCENT);
end;
if (FC = Ord(':')) then
begin
Consume;
Exit(COLON);
end;
if (FC = Ord('.')) then
begin
Consume;
Exit(DOT);
end;
if (FC = Ord('[')) then
begin
// grab [x] as a string, returning x
Consume;
while (FC <> Ord(']')) do
begin
if (FC = Ord('\')) then
begin
Consume;
if (FC <> Ord(']')) then
FSVal.Append('\');
FSVal.Append(Char(FC));
end
else
FSVal.Append(Char(FC));
Consume;
end;
Consume;
Exit(ARG);
end;
Consume;
FError := True;
Exit(EOF);
end;
Result := EOF;
end;
function TTreePatternLexer.SVal: String;
begin
Result := FSVal.ToString;
end;
{ TTreeWizard }
function TTreeWizard.ComputeTokenTypes(
const TokenNames: TStringArray): IDictionary<String, Integer>;
var
TokenType: Integer;
begin
Result := TDictionary<String, Integer>.Create;
if (Length(TokenNames) > 0)then
begin
for TokenType := TToken.MIN_TOKEN_TYPE to Length(TokenNames) - 1 do
Result.Add(TokenNames[TokenType], TokenType);
end;
end;
constructor TTreeWizard.Create(const AAdaptor: ITreeAdaptor);
begin
inherited Create;
FAdaptor := AAdaptor;
end;
constructor TTreeWizard.Create(const AAdaptor: ITreeAdaptor;
const ATokenNameToTypeMap: IDictionary<String, Integer>);
begin
inherited Create;
FAdaptor := AAdaptor;
FTokenNameToTypeMap := ATokenNameToTypeMap;
end;
constructor TTreeWizard.Create(const AAdaptor: ITreeAdaptor;
const TokenNames: TStringArray);
begin
inherited Create;
FAdaptor := AAdaptor;
FTokenNameToTypeMap := ComputeTokenTypes(TokenNames);
end;
function TTreeWizard.CreateTreeOrNode(const Pattern: String): IANTLRInterface;
var
Tokenizer: ITreePatternLexer;
Parser: ITreePatternParser;
begin
Tokenizer := TTreePatternLexer.Create(Pattern);
Parser := TTreePatternParser.Create(Tokenizer, Self, FAdaptor);
Result := Parser.Pattern;
end;
function TTreeWizard.Equals(const T1, T2: IANTLRInterface;
const Adaptor: ITreeAdaptor): Boolean;
begin
Result := _Equals(T1, T2, Adaptor);
end;
function TTreeWizard.Equals(const T1, T2: IANTLRInterface): Boolean;
begin
Result := _Equals(T1, T2, FAdaptor);
end;
function TTreeWizard.Find(const T: IANTLRInterface;
const Pattern: String): IList<IANTLRInterface>;
var
Tokenizer: ITreePatternLexer;
Parser: ITreePatternParser;
TreePattern: ITreePattern;
RootTokenType: Integer;
Visitor: IContextVisitor;
begin
Result := TList<IANTLRInterface>.Create;
// Create a TreePattern from the pattern
Tokenizer := TTreePatternLexer.Create(Pattern);
Parser := TTreePatternParser.Create(Tokenizer, Self, TTreePatternTreeAdaptor.Create);
TreePattern := Parser.Pattern as ITreePattern;
// don't allow invalid patterns
if (TreePattern = nil) or (TreePattern.IsNil)
or Supports(TreePattern, IWildcardTreePattern)
then
Exit(nil);
RootTokenType := TreePattern.TokenType;
Visitor := TPatternMatchingContextVisitor.Create(Self, TreePattern, Result);
Visit(T, RootTokenType, Visitor);
end;
function TTreeWizard.Find(const T: IANTLRInterface;
const TokenType: Integer): IList<IANTLRInterface>;
begin
Result := TList<IANTLRInterface>.Create;
Visit(T, TokenType, TRecordAllElementsVisitor.Create(Result));
end;
function TTreeWizard.FindFirst(const T: IANTLRInterface;
const TokenType: Integer): IANTLRInterface;
begin
Result := nil;
end;
function TTreeWizard.FindFirst(const T: IANTLRInterface;
const Pattern: String): IANTLRInterface;
begin
Result := nil;
end;
function TTreeWizard.GetTokenType(const TokenName: String): Integer;
begin
if (FTokenNameToTypeMap = nil) then
Exit(TToken.INVALID_TOKEN_TYPE);
if (not FTokenNameToTypeMap.TryGetValue(TokenName, Result)) then
Result := TToken.INVALID_TOKEN_TYPE;
end;
function TTreeWizard.Index(
const T: IANTLRInterface): IDictionary<Integer, IList<IANTLRInterface>>;
begin
Result := TDictionary<Integer, IList<IANTLRInterface>>.Create;
_Index(T, Result);
end;
function TTreeWizard.Parse(const T: IANTLRInterface;
const Pattern: String): Boolean;
begin
Result := Parse(T, Pattern, nil);
end;
function TTreeWizard.Parse(const T: IANTLRInterface; const Pattern: String;
const Labels: IDictionary<String, IANTLRInterface>): Boolean;
var
Tokenizer: ITreePatternLexer;
Parser: ITreePatternParser;
TreePattern: ITreePattern;
begin
Tokenizer := TTreePatternLexer.Create(Pattern);
Parser := TTreePatternParser.Create(Tokenizer, Self, TTreePatternTreeAdaptor.Create);
TreePattern := Parser.Pattern as ITreePattern;
Result := _Parse(T, TreePattern, Labels);
end;
procedure TTreeWizard.Visit(const T: IANTLRInterface; const Pattern: String;
const Visitor: IContextVisitor);
var
Tokenizer: ITreePatternLexer;
Parser: ITreePatternParser;
TreePattern: ITreePattern;
RootTokenType: Integer;
PatternVisitor: IContextVisitor;
begin
// Create a TreePattern from the pattern
Tokenizer := TTreePatternLexer.Create(Pattern);
Parser := TTreePatternParser.Create(Tokenizer, Self, TTreePatternTreeAdaptor.Create);
TreePattern := Parser.Pattern as ITreePattern;
if (TreePattern = nil) or (TreePattern.IsNil)
or Supports(TreePattern, IWildcardTreePattern)
then
Exit;
RootTokenType := TreePattern.TokenType;
PatternVisitor := TInvokeVisitorOnPatternMatchContextVisitor.Create(Self, TreePattern, Visitor);
Visit(T, RootTokenType, PatternVisitor);
end;
class function TTreeWizard._Equals(const T1, T2: IANTLRInterface;
const Adaptor: ITreeAdaptor): Boolean;
var
I, N1, N2: Integer;
Child1, Child2: IANTLRInterface;
begin
// make sure both are non-null
if (T1 = nil) or (T2 = nil) then
Exit(False);
// check roots
if (Adaptor.GetNodeType(T1) <> Adaptor.GetNodeType(T2)) then
Exit(False);
if (Adaptor.GetNodeText(T1) <> Adaptor.GetNodeText(T2)) then
Exit(False);
// check children
N1 := Adaptor.GetChildCount(T1);
N2 := Adaptor.GetChildCount(T2);
if (N1 <> N2) then
Exit(False);
for I := 0 to N1 - 1 do
begin
Child1 := Adaptor.GetChild(T1, I);
Child2 := Adaptor.GetChild(T2, I);
if (not _Equals(Child1, Child2, Adaptor)) then
Exit(False);
end;
Result := True;
end;
procedure TTreeWizard._Index(const T: IANTLRInterface;
const M: IDictionary<Integer, IList<IANTLRInterface>>);
var
I, N, TType: Integer;
Elements: IList<IANTLRInterface>;
begin
if (T = nil) then
Exit;
TType := FAdaptor.GetNodeType(T);
if (not M.TryGetValue(TType, Elements)) then
Elements := nil;
if (Elements = nil) then
begin
Elements := TList<IANTLRInterface>.Create;
M.Add(TType, Elements);
end;
Elements.Add(T);
N := FAdaptor.GetChildCount(T);
for I := 0 to N - 1 do
_Index(FAdaptor.GetChild(T, I), M);
end;
function TTreeWizard._Parse(const T1: IANTLRInterface; const T2: ITreePattern;
const Labels: IDictionary<String, IANTLRInterface>): Boolean;
var
I, N1, N2: Integer;
Child1: IANTLRInterface;
Child2: ITreePattern;
begin
// make sure both are non-null
if (T1 = nil) or (T2 = nil) then
Exit(False);
// check roots (wildcard matches anything)
if (not Supports(T2, IWildcardTreePattern)) then
begin
if (FAdaptor.GetNodeType(T1) <> T2.TokenType) then
Exit(False);
if (T2.HasTextArg) and (FAdaptor.GetNodeText(T1) <> T2.Text) then
Exit(False);
end;
if (T2.TokenLabel <> '') and Assigned(Labels) then
// map label in pattern to node in t1
Labels.AddOrSetValue(T2.TokenLabel, T1);
// check children
N1 := FAdaptor.GetChildCount(T1);
N2 := T2.ChildCount;
if (N1 <> N2) then
Exit(False);
for I := 0 to N1 - 1 do
begin
Child1 := FAdaptor.GetChild(T1, I);
Child2 := T2.GetChild(I) as ITreePattern;
if (not _Parse(Child1, Child2, Labels)) then
Exit(False);
end;
Result := True;
end;
procedure TTreeWizard._Visit(const T, Parent: IANTLRInterface; const ChildIndex,
TokenType: Integer; const Visitor: IContextVisitor);
var
I, N: Integer;
begin
if (T = nil) then
Exit;
if (FAdaptor.GetNodeType(T) = TokenType) then
Visitor.Visit(T, Parent, ChildIndex, nil);
N := FAdaptor.GetChildCount(T);
for I := 0 to N - 1 do
_Visit(FAdaptor.GetChild(T, I), T, I, TokenType, Visitor);
end;
procedure TTreeWizard.Visit(const T: IANTLRInterface; const TokenType: Integer;
const Visitor: IContextVisitor);
begin
_Visit(T, nil, 0, TokenType, Visitor);
end;
constructor TTreeWizard.Create(const TokenNames: TStringArray);
begin
Create(nil, TokenNames);
end;
{ TTreePatternParser }
constructor TTreePatternParser.Create(const ATokenizer: ITreePatternLexer;
const AWizard: ITreeWizard; const AAdaptor: ITreeAdaptor);
begin
inherited Create;
FTokenizer := ATokenizer;
FWizard := AWizard;
FAdaptor := AAdaptor;
FTokenType := FTokenizer.NextToken; // kickstart
end;
function TTreePatternParser.ParseNode: IANTLRInterface;
var
Lbl, TokenName, Text, Arg: String;
WildcardPayload: IToken;
Node: TTreeWizard.ITreePattern;
TreeNodeType: Integer;
begin
// "%label:" prefix
Lbl := '';
if (FTokenType = TTreePatternLexer.PERCENT) then
begin
FTokenType := FTokenizer.NextToken;
if (FTokenType <> TTreePatternLexer.ID) then
Exit(nil);
Lbl := FTokenizer.SVal;
FTokenType := FTokenizer.NextToken;
if (FTokenType <> TTreePatternLexer.COLON) then
Exit(nil);
FTokenType := FTokenizer.NextToken; // move to ID following colon
end;
// Wildcard?
if (FTokenType = TTreePatternLexer.DOT) then
begin
FTokenType := FTokenizer.NextToken;
WildcardPayload := TCommonToken.Create(0, '.');
Node := TTreeWizard.TWildcardTreePattern.Create(WildcardPayload);
if (Lbl <> '') then
Node.TokenLabel := Lbl;
Exit(Node);
end;
// "ID" or "ID[arg]"
if (FTokenType <> TTreePatternLexer.ID) then
Exit(nil);
TokenName := FTokenizer.SVal;
FTokenType := FTokenizer.NextToken;
if (TokenName = 'nil') then
Exit(FAdaptor.GetNilNode);
Text := TokenName;
// check for arg
Arg := '';
if (FTokenType = TTreePatternLexer.ARG) then
begin
Arg := FTokenizer.SVal;
Text := Arg;
FTokenType := FTokenizer.NextToken;
end;
// create node
TreeNodeType := FWizard.GetTokenType(TokenName);
if (TreeNodeType = TToken.INVALID_TOKEN_TYPE) then
Exit(nil);
Result := FAdaptor.CreateNode(TreeNodeType, Text);
if (Lbl <> '') and Supports(Result, TTreeWizard.ITreePattern, Node) then
Node.TokenLabel := Lbl;
if (Arg <> '') and Supports(Result, TTreeWizard.ITreePattern, Node) then
Node.HasTextArg := True;
end;
function TTreePatternParser.ParseTree: IANTLRInterface;
var
Subtree, Child: IANTLRInterface;
begin
if (FTokenType <> TTreePatternLexer.START) then
begin
WriteLn('no BEGIN');
Exit(nil);
end;
FTokenType := FTokenizer.NextToken;
Result := ParseNode;
if (Result = nil) then
Exit;
while (FTokenType in [TTreePatternLexer.START, TTreePatternLexer.ID,
TTreePatternLexer.PERCENT, TTreePatternLexer.DOT]) do
begin
if (FTokenType = TTreePatternLexer.START) then
begin
Subtree := ParseTree;
FAdaptor.AddChild(Result, Subtree);
end
else
begin
Child := ParseNode;
if (Child = nil) then
Exit(nil);
FAdaptor.AddChild(Result, Child);
end;
end;
if (FTokenType <> TTreePatternLexer.STOP) then
begin
WriteLn('no END');
Exit(nil);
end;
FTokenType := FTokenizer.NextToken;
end;
function TTreePatternParser.Pattern: IANTLRInterface;
var
Node: IANTLRInterface;
begin
if (FTokenType = TTreePatternLexer.START) then
Exit(ParseTree);
if (FTokenType = TTreePatternLexer.ID) then
begin
Node := ParseNode;
if (FTokenType = TTreePatternLexer.EOF) then
Result := Node
else
Result := nil; // extra junk on end
end
else
Result := nil;
end;
{ TTreeWizard.TVisitor }
procedure TTreeWizard.TVisitor.Visit(const T, Parent: IANTLRInterface;
const ChildIndex: Integer;
const Labels: IDictionary<String, IANTLRInterface>);
begin
Visit(T);
end;
{ TTreeWizard.TRecordAllElementsVisitor }
constructor TTreeWizard.TRecordAllElementsVisitor.Create(
const AList: IList<IANTLRInterface>);
begin
inherited Create;
FList := AList;
end;
procedure TTreeWizard.TRecordAllElementsVisitor.Visit(const T: IANTLRInterface);
begin
FList.Add(T);
end;
{ TTreeWizard.TPatternMatchingContextVisitor }
constructor TTreeWizard.TPatternMatchingContextVisitor.Create(
const AOwner: TTreeWizard; const APattern: ITreePattern;
const AList: IList<IANTLRInterface>);
begin
inherited Create;
FOwner := AOwner;
FPattern := APattern;
FList := AList;
end;
procedure TTreeWizard.TPatternMatchingContextVisitor.Visit(const T,
Parent: IANTLRInterface; const ChildIndex: Integer;
const Labels: IDictionary<String, IANTLRInterface>);
begin
if (FOwner._Parse(T, FPattern, nil)) then
FList.Add(T);
end;
{ TTreeWizard.TInvokeVisitorOnPatternMatchContextVisitor }
constructor TTreeWizard.TInvokeVisitorOnPatternMatchContextVisitor.Create(
const AOwner: TTreeWizard; const APattern: ITreePattern;
const AVisitor: IContextVisitor);
begin
inherited Create;
FOwner := AOwner;
FPattern := APattern;
FVisitor := AVisitor;
FLabels := TDictionary<String, IANTLRInterface>.Create;
end;
procedure TTreeWizard.TInvokeVisitorOnPatternMatchContextVisitor.Visit(const T,
Parent: IANTLRInterface; const ChildIndex: Integer;
const UnusedLabels: IDictionary<String, IANTLRInterface>);
begin
// the unusedlabels arg is null as visit on token type doesn't set.
FLabels.Clear;
if (FOwner._Parse(T, FPattern, FLabels)) then
FVisitor.Visit(T, Parent, ChildIndex, FLabels);
end;
{ TTreeWizard.TTreePattern }
function TTreeWizard.TTreePattern.GetHasTextArg: Boolean;
begin
Result := FHasTextArg;
end;
function TTreeWizard.TTreePattern.GetTokenLabel: String;
begin
Result := FLabel;
end;
procedure TTreeWizard.TTreePattern.SetHasTextArg(const Value: Boolean);
begin
FHasTextArg := Value;
end;
procedure TTreeWizard.TTreePattern.SetTokenLabel(const Value: String);
begin
FLabel := Value;
end;
function TTreeWizard.TTreePattern.ToString: String;
begin
if (FLabel <> '') then
Result := '%' + FLabel + ':' + inherited ToString
else
Result := inherited ToString;
end;
{ TTreeWizard.TTreePatternTreeAdaptor }
function TTreeWizard.TTreePatternTreeAdaptor.CreateNode(
const Payload: IToken): IANTLRInterface;
begin
Result := TTreePattern.Create(Payload);
end;
{ TTreeRuleReturnScope }
function TTreeRuleReturnScope.GetStart: IANTLRInterface;
begin
Result := FStart;
end;
procedure TTreeRuleReturnScope.SetStart(const Value: IANTLRInterface);
begin
FStart := Value;
end;
{ TUnBufferedTreeNodeStream }
procedure TUnBufferedTreeNodeStream.AddLookahead(const Node: IANTLRInterface);
var
Bigger: TANTLRInterfaceArray;
I, RemainderHeadToEnd: Integer;
begin
FLookahead[FTail] := Node;
FTail := (FTail + 1) mod Length(FLookahead);
if (FTail = FHead) then
begin
// buffer overflow: tail caught up with head
// allocate a buffer 2x as big
SetLength(Bigger,2 * Length(FLookahead));
// copy head to end of buffer to beginning of bigger buffer
RemainderHeadToEnd := Length(FLookahead) - FHead;
for I := 0 to RemainderHeadToEnd - 1 do
Bigger[I] := FLookahead[FHead + I];
// copy 0..tail to after that
for I := 0 to FTail - 1 do
Bigger[RemainderHeadToEnd + I] := FLookahead[I];
FLookahead := Bigger; // reset to bigger buffer
FHead := 0;
Inc(FTail,RemainderHeadToEnd);
end;
end;
procedure TUnBufferedTreeNodeStream.AddNavigationNode(const TokenType: Integer);
var
NavNode: IANTLRInterface;
begin
if (TokenType = TToken.DOWN) then
begin
if (GetHasUniqueNavigationNodes) then
NavNode := FAdaptor.CreateNode(TToken.DOWN,'DOWN')
else
NavNode := FDown;
end
else
begin
if (GetHasUniqueNavigationNodes) then
NavNode := FAdaptor.CreateNode(TToken.UP,'UP')
else
NavNode := FUp;
end;
AddLookahead(NavNode);
end;
procedure TUnBufferedTreeNodeStream.Consume;
begin
// make sure there is something in lookahead buf, which might call next()
Fill(1);
Inc(FAbsoluteNodeIndex);
FPreviousNode := FLookahead[FHead]; // track previous node before moving on
FHead := (FHead + 1) mod Length(FLookahead);
end;
constructor TUnBufferedTreeNodeStream.Create;
begin
inherited;
SetLength(FLookAhead,INITIAL_LOOKAHEAD_BUFFER_SIZE);
FNodeStack := TStackList<IANTLRInterface>.Create;
FIndexStack := TStackList<Integer>.Create;
end;
constructor TUnBufferedTreeNodeStream.Create(const ATree: IANTLRInterface);
begin
Create(TCommonTreeAdaptor.Create, ATree);
end;
constructor TUnBufferedTreeNodeStream.Create(const AAdaptor: ITreeAdaptor;
const ATree: IANTLRInterface);
begin
Create;
FRoot := ATree;
FAdaptor := AAdaptor;
Reset;
FDown := FAdaptor.CreateNode(TToken.DOWN, 'DOWN');
FUp := FAdaptor.CreateNode(TToken.UP, 'UP');
FEof := FAdaptor.CreateNode(TToken.EOF, 'EOF');
end;
procedure TUnBufferedTreeNodeStream.Fill(const K: Integer);
var
I, N: Integer;
begin
N := LookaheadSize;
for I := 1 to K - N do
MoveNext; // get at least k-depth lookahead nodes
end;
function TUnBufferedTreeNodeStream.Get(const I: Integer): IANTLRInterface;
begin
raise EInvalidOperation.Create('stream is unbuffered');
end;
function TUnBufferedTreeNodeStream.GetCurrent: IANTLRInterface;
begin
Result := FCurrentEnumerationNode;
end;
function TUnBufferedTreeNodeStream.GetHasUniqueNavigationNodes: Boolean;
begin
Result := FUniqueNavigationNodes;
end;
function TUnBufferedTreeNodeStream.GetSourceName: String;
begin
Result := GetTokenStream.SourceName;
end;
function TUnBufferedTreeNodeStream.GetTokenStream: ITokenStream;
begin
Result := FTokens;
end;
function TUnBufferedTreeNodeStream.GetTreeAdaptor: ITreeAdaptor;
begin
Result := FAdaptor;
end;
function TUnBufferedTreeNodeStream.GetTreeSource: IANTLRInterface;
begin
Result := FRoot;
end;
function TUnBufferedTreeNodeStream.HandleRootNode: IANTLRInterface;
begin
Result := FCurrentNode;
// point to first child in prep for subsequent next()
FCurrentChildIndex := 0;
if (FAdaptor.IsNil(Result)) then
// don't count this root nil node
Result := VisitChild(FCurrentChildIndex)
else
begin
AddLookahead(Result);
if (FAdaptor.GetChildCount(FCurrentNode) = 0) then
// single node case
Result := nil; // say we're done
end;
end;
function TUnBufferedTreeNodeStream.Index: Integer;
begin
Result := FAbsoluteNodeIndex + 1;
end;
function TUnBufferedTreeNodeStream.LA(I: Integer): Integer;
var
T: IANTLRInterface;
begin
T := LT(I);
if (T = nil) then
Result := TToken.INVALID_TOKEN_TYPE
else
Result := FAdaptor.GetNodeType(T);
end;
function TUnBufferedTreeNodeStream.LAChar(I: Integer): Char;
begin
Result := Char(LA(I));
end;
function TUnBufferedTreeNodeStream.LookaheadSize: Integer;
begin
if (FTail < FHead) then
Result := Length(FLookahead) - FHead + FTail
else
Result := FTail - FHead;
end;
function TUnBufferedTreeNodeStream.LT(const K: Integer): IANTLRInterface;
begin
if (K = -1) then
Exit(FPreviousNode);
if (K < 0) then
raise EArgumentException.Create('tree node streams cannot look backwards more than 1 node');
if (K = 0) then
Exit(TTree.INVALID_NODE);
Fill(K);
Result := FLookahead[(FHead + K - 1) mod Length(FLookahead)];
end;
function TUnBufferedTreeNodeStream.Mark: Integer;
var
State: ITreeWalkState;
I, N, K: Integer;
LA: TANTLRInterfaceArray;
begin
if (FMarkers = nil) then
begin
FMarkers := TList<ITreeWalkState>.Create;
FMarkers.Add(nil); // depth 0 means no backtracking, leave blank
end;
Inc(FMarkDepth);
State := nil;
if (FMarkDepth >= FMarkers.Count) then
begin
State := TTreeWalkState.Create;
FMarkers.Add(State);
end
else
State := FMarkers[FMarkDepth];
State.AbsoluteNodeIndex := FAbsoluteNodeIndex;
State.CurrentChildIndex := FCurrentChildIndex;
State.CurrentNode := FCurrentNode;
State.PreviousNode := FPreviousNode;
State.NodeStackSize := FNodeStack.Count;
State.IndexStackSize := FIndexStack.Count;
// take snapshot of lookahead buffer
N := LookaheadSize;
I := 0;
SetLength(LA,N);
for K := 1 to N do
begin
LA[I] := LT(K);
Inc(I);
end;
State.LookAhead := LA;
FLastMarker := FMarkDepth;
Result := FMarkDepth;
end;
function TUnBufferedTreeNodeStream.MoveNext: Boolean;
begin
// already walked entire tree; nothing to return
if (FCurrentNode = nil) then
begin
AddLookahead(FEof);
FCurrentEnumerationNode := nil;
// this is infinite stream returning EOF at end forever
// so don't throw NoSuchElementException
Exit(False);
end;
// initial condition (first time method is called)
if (FCurrentChildIndex = -1) then
begin
FCurrentEnumerationNode := HandleRootNode as ITree;
Exit(True);
end;
// index is in the child list?
if (FCurrentChildIndex < FAdaptor.GetChildCount(FCurrentNode)) then
begin
FCurrentEnumerationNode := VisitChild(FCurrentChildIndex) as ITree;
Exit(True);
end;
// hit end of child list, return to parent node or its parent ...
WalkBackToMostRecentNodeWithUnvisitedChildren;
if (FCurrentNode <> nil) then
begin
FCurrentEnumerationNode := VisitChild(FCurrentChildIndex) as ITree;
Result := True;
end
else
Result := False;
end;
procedure TUnBufferedTreeNodeStream.Release(const Marker: Integer);
begin
// unwind any other markers made after marker and release marker
FMarkDepth := Marker;
// release this marker
Dec(FMarkDepth);
end;
procedure TUnBufferedTreeNodeStream.ReplaceChildren(
const Parent: IANTLRInterface; const StartChildIndex, StopChildIndex: Integer;
const T: IANTLRInterface);
begin
raise EInvalidOperation.Create('can''t do stream rewrites yet');
end;
procedure TUnBufferedTreeNodeStream.Reset;
begin
FCurrentNode := FRoot;
FPreviousNode := nil;
FCurrentChildIndex := -1;
FAbsoluteNodeIndex := -1;
FHead := 0;
FTail := 0;
end;
procedure TUnBufferedTreeNodeStream.Rewind(const Marker: Integer);
var
State: ITreeWalkState;
begin
if (FMarkers = nil) then
Exit;
State := FMarkers[Marker];
FAbsoluteNodeIndex := State.AbsoluteNodeIndex;
FCurrentChildIndex := State.CurrentChildIndex;
FCurrentNode := State.CurrentNode;
FPreviousNode := State.PreviousNode;
// drop node and index stacks back to old size
FNodeStack.Capacity := State.NodeStackSize;
FIndexStack.Capacity := State.IndexStackSize;
FHead := 0; // wack lookahead buffer and then refill
FTail := 0;
while (FTail < Length(State.LookAhead)) do
begin
FLookahead[FTail] := State.LookAhead[FTail];
Inc(FTail);
end;
Release(Marker);
end;
procedure TUnBufferedTreeNodeStream.Rewind;
begin
Rewind(FLastMarker);
end;
procedure TUnBufferedTreeNodeStream.Seek(const Index: Integer);
begin
if (Index < Self.Index) then
raise EArgumentOutOfRangeException.Create('can''t seek backwards in node stream');
// seek forward, consume until we hit index
while (Self.Index < Index) do
Consume;
end;
procedure TUnBufferedTreeNodeStream.SetHasUniqueNavigationNodes(
const Value: Boolean);
begin
FUniqueNavigationNodes := Value;
end;
procedure TUnBufferedTreeNodeStream.SetTokenStream(const Value: ITokenStream);
begin
FTokens := Value;
end;
function TUnBufferedTreeNodeStream.Size: Integer;
var
S: ICommonTreeNodeStream;
begin
S := TCommonTreeNodeStream.Create(FRoot);
Result := S.Size;
end;
function TUnBufferedTreeNodeStream.ToString: String;
begin
Result := ToString(FRoot, nil);
end;
procedure TUnBufferedTreeNodeStream.ToStringWork(const P, Stop: IANTLRInterface;
const Buf: TStringBuilder);
var
Text: String;
C, N: Integer;
begin
if (not FAdaptor.IsNil(P)) then
begin
Text := FAdaptor.GetNodeText(P);
if (Text = '') then
Text := ' ' + IntToStr(FAdaptor.GetNodeType(P));
Buf.Append(Text); // ask the node to go to string
end;
if SameObj(P, Stop) then
Exit;
N := FAdaptor.GetChildCount(P);
if (N > 0) and (not FAdaptor.IsNil(P)) then
begin
Buf.Append(' ');
Buf.Append(TToken.DOWN);
end;
for C := 0 to N - 1 do
ToStringWork(FAdaptor.GetChild(P, C), Stop, Buf);
if (N > 0) and (not FAdaptor.IsNil(P)) then
begin
Buf.Append(' ');
Buf.Append(TToken.UP);
end;
end;
function TUnBufferedTreeNodeStream.VisitChild(
const Child: Integer): IANTLRInterface;
begin
Result := nil;
// save state
FNodeStack.Push(FCurrentNode);
FIndexStack.Push(Child);
if (Child = 0) and (not FAdaptor.IsNil(FCurrentNode)) then
AddNavigationNode(TToken.DOWN);
// visit child
FCurrentNode := FAdaptor.GetChild(FCurrentNode, Child);
FCurrentChildIndex := 0;
Result := FCurrentNode;
AddLookahead(Result);
WalkBackToMostRecentNodeWithUnvisitedChildren;
end;
procedure TUnBufferedTreeNodeStream.WalkBackToMostRecentNodeWithUnvisitedChildren;
begin
while (FCurrentNode <> nil) and (FCurrentChildIndex >= FAdaptor.GetChildCount(FCurrentNode)) do
begin
FCurrentNode := FNodeStack.Pop;
if (FCurrentNode = nil) then
// hit the root?
Exit;
FCurrentChildIndex := FIndexStack.Pop;
Inc(FCurrentChildIndex); // move to next child
if (FCurrentChildIndex >= FAdaptor.GetChildCount(FCurrentNode)) then
begin
if (not FAdaptor.IsNil(FCurrentNode)) then
AddNavigationNode(TToken.UP);
if SameObj(FCurrentNode, FRoot) then
// we done yet?
FCurrentNode := nil;
end;
end;
end;
function TUnBufferedTreeNodeStream.ToString(const Start,
Stop: IANTLRInterface): String;
var
BeginTokenIndex, EndTokenIndex: Integer;
Buf: TStringBuilder;
begin
if (Start = nil) then
Exit('');
// if we have the token stream, use that to dump text in order
if (FTokens <> nil) then
begin
// don't trust stop node as it's often an UP node etc...
// walk backwards until you find a non-UP, non-DOWN node
// and ask for it's token index.
BeginTokenIndex := FAdaptor.GetTokenStartIndex(Start);
if (Stop <> nil) and (FAdaptor.GetNodeType(Stop) = TToken.UP) then
EndTokenIndex := FAdaptor.GetTokenStopIndex(Start)
else
EndTokenIndex := Size - 1;
Exit(FTokens.ToString(BeginTokenIndex, EndTokenIndex));
end;
Buf := TStringBuilder.Create;
try
ToStringWork(Start, Stop, Buf);
Result := Buf.ToString;
finally
Buf.Free;
end;
end;
{ TUnBufferedTreeNodeStream.TTreeWalkState }
function TUnBufferedTreeNodeStream.TTreeWalkState.GetAbsoluteNodeIndex: Integer;
begin
Result := FAbsoluteNodeIndex;
end;
function TUnBufferedTreeNodeStream.TTreeWalkState.GetCurrentChildIndex: Integer;
begin
Result := FCurrentChildIndex;
end;
function TUnBufferedTreeNodeStream.TTreeWalkState.GetCurrentNode: IANTLRInterface;
begin
Result := FCurrentNode;
end;
function TUnBufferedTreeNodeStream.TTreeWalkState.GetIndexStackSize: integer;
begin
Result := FIndexStackSize;
end;
function TUnBufferedTreeNodeStream.TTreeWalkState.GetLookAhead: TANTLRInterfaceArray;
begin
Result := FLookAhead;
end;
function TUnBufferedTreeNodeStream.TTreeWalkState.GetNodeStackSize: Integer;
begin
Result := FNodeStackSize;
end;
function TUnBufferedTreeNodeStream.TTreeWalkState.GetPreviousNode: IANTLRInterface;
begin
Result := FPreviousNode;
end;
procedure TUnBufferedTreeNodeStream.TTreeWalkState.SetAbsoluteNodeIndex(
const Value: Integer);
begin
FAbsoluteNodeIndex := Value;
end;
procedure TUnBufferedTreeNodeStream.TTreeWalkState.SetCurrentChildIndex(
const Value: Integer);
begin
FCurrentChildIndex := Value;
end;
procedure TUnBufferedTreeNodeStream.TTreeWalkState.SetCurrentNode(
const Value: IANTLRInterface);
begin
FCurrentNode := Value;
end;
procedure TUnBufferedTreeNodeStream.TTreeWalkState.SetIndexStackSize(
const Value: integer);
begin
FIndexStackSize := Value;
end;
procedure TUnBufferedTreeNodeStream.TTreeWalkState.SetLookAhead(
const Value: TANTLRInterfaceArray);
begin
FLookAhead := Value;
end;
procedure TUnBufferedTreeNodeStream.TTreeWalkState.SetNodeStackSize(
const Value: Integer);
begin
FNodeStackSize := Value;
end;
procedure TUnBufferedTreeNodeStream.TTreeWalkState.SetPreviousNode(
const Value: IANTLRInterface);
begin
FPreviousNode := Value;
end;
{ Utilities }
var
EmptyCommonTree: ICommonTree = nil;
function Def(const X: ICommonTree): ICommonTree; overload;
begin
if Assigned(X) then
Result := X
else
begin
if (EmptyCommonTree = nil) then
EmptyCommonTree := TCommonTree.Create;
Result := EmptyCommonTree;
end;
end;
initialization
TTree.Initialize;
end.
Reference in New Issue View Git Blame Copy Permalink