1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// [The "BSD licence"]
// Copyright (c) 2006-2007 Kay Roepke 2010 Alan Condit
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. The name of the author may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#import "ANTLRToken.h"
#import "ANTLRBaseTree.h"
#import "ANTLRTokenStream.h"
#pragma warning tree/node diction is broken.
@protocol ANTLRTreeAdaptor <NSObject, NSCopying>
#pragma mark Construction
+ (id<ANTLRTree>) newEmptyTree;
- (id<ANTLRTree>) createTree:(id<ANTLRToken>)payload;
#pragma mark ANTLRTreeAdaptor implementation
- (id<ANTLRTree>)dupNode:(id<ANTLRTree>)aNode; // copies just the node
- (id<ANTLRTree>)dupTree:(id<ANTLRTree>)aTree; // copies the entire subtree, recursively
/** 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);"
*/
- (id) emptyNode;
/** 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.
*
* 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.
*
* This only makes sense during token parsing, not tree parsing.
* Tree parsing should happen only when parsing and tree construction
* succeed.
*/
- (id) errorNode:(id<ANTLRTokenStream>)anInput
From:(id<ANTLRToken>)aStartToken
To:(id<ANTLRToken>)aStopToken
Exception:(NSException *) e;
/** Is tree considered a nil node used to make lists of child nodes? */
- (BOOL) isNil:(id<ANTLRTree>)aTree;
- (void) addChild:(id<ANTLRTree>)child toTree:(id<ANTLRTree>)aTree;
/** 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.
*
* 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.
*/
- (id) becomeRoot:(id<ANTLRTree>)newRoot old:(id<ANTLRTree>)oldRoot;
- (id) rulePostProcessing:(id<ANTLRTree>)root;
#pragma mark Rewrite Rules
- (NSUInteger) getUniqueID:(id<ANTLRTree>)aNode;
- (id<ANTLRTree>) createTree:(NSInteger)tokenType FromToken:(id<ANTLRToken>)fromToken;
- (id<ANTLRTree>) createTree:(NSInteger)tokenType FromToken:(id<ANTLRToken>)fromToken Text:(NSString *)text;
- (id<ANTLRTree>) createTree:(NSInteger)tokenType Text:(NSString *)text;
#pragma mark Content
- (id<ANTLRTree>)dupNode:(id<ANTLRTree>)aNode;
- (id<ANTLRTree>)dupTree:(id<ANTLRTree>)aTree;
- (NSInteger) getType:(id<ANTLRTree>)aNode;
- (void) setType:(id<ANTLRTree>)aNode Type:(NSInteger)tokenType;
- (NSString *) getText:(id<ANTLRTree>)aNode;
- (void) setText:(id<ANTLRTree>)aNode Text:(NSString *)tokenText;
- (id<ANTLRToken>) getToken:(id<ANTLRTree>)t;
- (void) setTokenBoundaries:(id<ANTLRTree>)aTree From:(id<ANTLRToken>)startToken To:(id<ANTLRToken>)stopToken;
- (NSInteger) getTokenStartIndex:(id<ANTLRTree>)aTree;
- (NSInteger) getTokenStopIndex:(id<ANTLRTree>)aTree;
#pragma mark Navigation / Tree Parsing
/** Get a child 0..n-1 node */
- (id<ANTLRTree>) getChild:(id<ANTLRTree>)aNode At:(NSInteger) i;
/** Set ith child (0..n-1) to t; t must be non-null and non-nil node */
- (void) setChild:(id<ANTLRTree>)aTree At:(NSInteger)index Child:(id<ANTLRTree>)child;
/** Remove ith child and shift children down from right. */
- (id<ANTLRTree>) deleteChild:(id<ANTLRTree>)t Index:(NSInteger)index;
/** How many children? If 0, then this is a leaf node */
- (NSInteger) getChildCount:(id<ANTLRTree>) aTree;
/** Who is the parent node of this node; if null, implies node is root.
* If your node type doesn't handle this, it's ok but the tree rewrites
* in tree parsers need this functionality.
*/
- (id<ANTLRTree>)getParent:(id<ANTLRTree>)t;
- (void) setParent:(id<ANTLRTree>)t With:(id<ANTLRTree>)parent;
/** What index is this node in the child list? Range: 0..n-1
* If your node type doesn't handle this, it's ok but the tree rewrites
* in tree parsers need this functionality.
*/
- (NSInteger) getChildIndex:(id<ANTLRTree>)t;
- (void) setChildIndex:(id<ANTLRTree>)t With:(NSInteger)index;
- (void) replaceChildren:(id<ANTLRTree>)parent From:(NSInteger)startChildIndex To:(NSInteger)stopChildIndex With:(id<ANTLRTree>)t;
@end
|
