00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042 import re
00043
00044 from antlr3.constants import UP, DOWN, EOF, INVALID_TOKEN_TYPE
00045 from antlr3.recognizers import BaseRecognizer, RuleReturnScope
00046 from antlr3.streams import IntStream
00047 from antlr3.tokens import CommonToken, Token, INVALID_TOKEN
00048 from antlr3.exceptions import MismatchedTreeNodeException, \
00049 MissingTokenException, UnwantedTokenException, MismatchedTokenException, \
00050 NoViableAltException
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067 class RewriteCardinalityException(RuntimeError):
00068
00069 def __init__(self, elementDescription):
00070 RuntimeError.__init__(self, elementDescription)
00071
00072 self.elementDescription = elementDescription
00073
00074
00075 def getMessage(self):
00076 return self.elementDescription
00077
00078
00079
00080
00081 class RewriteEarlyExitException(RewriteCardinalityException):
00082
00083 def __init__(self, elementDescription=None):
00084 RewriteCardinalityException.__init__(self, elementDescription)
00085
00086
00087
00088
00089
00090
00091 class RewriteEmptyStreamException(RewriteCardinalityException):
00092
00093 pass
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116 class Tree(object):
00117
00118
00119 def getChild(self, i):
00120 raise NotImplementedError
00121
00122
00123 def getChildCount(self):
00124 raise NotImplementedError
00125
00126
00127
00128
00129 def getParent(self):
00130
00131 raise NotImplementedError
00132
00133
00134
00135 def setParent(self, t):
00136
00137 raise NotImplementedError
00138
00139
00140
00141
00142 def hasAncestor(self, ttype):
00143
00144 raise NotImplementedError
00145
00146
00147
00148 def getAncestor(self, ttype):
00149
00150 raise NotImplementedError
00151
00152
00153
00154
00155
00156
00157
00158 def getAncestors(self):
00159
00160 raise NotImplementedError
00161
00162
00163
00164
00165 def getChildIndex(self):
00166
00167 raise NotImplementedError
00168
00169
00170
00171 def setChildIndex(self, index):
00172
00173 raise NotImplementedError
00174
00175
00176
00177
00178 def freshenParentAndChildIndexes(self):
00179
00180 raise NotImplementedError
00181
00182
00183
00184
00185
00186
00187
00188 def addChild(self, t):
00189
00190 raise NotImplementedError
00191
00192
00193
00194
00195 def setChild(self, i, t):
00196
00197 raise NotImplementedError
00198
00199
00200 def deleteChild(self, i):
00201 raise NotImplementedError
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211 def replaceChildren(self, startChildIndex, stopChildIndex, t):
00212
00213 raise NotImplementedError
00214
00215
00216
00217
00218
00219
00220
00221 def isNil(self):
00222
00223 raise NotImplementedError
00224
00225
00226
00227
00228
00229
00230
00231 def getTokenStartIndex(self):
00232
00233 raise NotImplementedError
00234
00235
00236 def setTokenStartIndex(self, index):
00237 raise NotImplementedError
00238
00239
00240
00241
00242
00243
00244
00245 def getTokenStopIndex(self):
00246
00247 raise NotImplementedError
00248
00249
00250 def setTokenStopIndex(self, index):
00251 raise NotImplementedError
00252
00253
00254 def dupNode(self):
00255 raise NotImplementedError
00256
00257
00258
00259
00260 def getType(self):
00261
00262 raise NotImplementedError
00263
00264
00265 def getText(self):
00266 raise NotImplementedError
00267
00268
00269
00270
00271
00272
00273 def getLine(self):
00274
00275 raise NotImplementedError
00276
00277
00278 def getCharPositionInLine(self):
00279 raise NotImplementedError
00280
00281
00282 def toStringTree(self):
00283 raise NotImplementedError
00284
00285
00286 def toString(self):
00287 raise NotImplementedError
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304 class TreeAdaptor(object):
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316 def createWithPayload(self, payload):
00317
00318 raise NotImplementedError
00319
00320
00321
00322
00323
00324
00325 def dupNode(self, treeNode):
00326
00327 raise NotImplementedError
00328
00329
00330
00331
00332 def dupTree(self, tree):
00333
00334 raise NotImplementedError
00335
00336
00337
00338
00339
00340
00341
00342
00343 def nil(self):
00344
00345 raise NotImplementedError
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364 def errorNode(self, input, start, stop, exc):
00365
00366 raise NotImplementedError
00367
00368
00369
00370
00371 def isNil(self, tree):
00372
00373 raise NotImplementedError
00374
00375
00376
00377
00378
00379
00380
00381
00382
00383
00384
00385 def addChild(self, t, child):
00386
00387 raise NotImplementedError
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418 def becomeRoot(self, newRoot, oldRoot):
00419
00420 raise NotImplementedError
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438 def rulePostProcessing(self, root):
00439
00440 raise NotImplementedError
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450 def getUniqueID(self, node):
00451
00452 raise NotImplementedError
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467 def createFromToken(self, tokenType, fromToken, text=None):
00468
00469 raise NotImplementedError
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480 def createFromType(self, tokenType, text):
00481
00482 raise NotImplementedError
00483
00484
00485
00486
00487
00488
00489 def getType(self, t):
00490
00491 raise NotImplementedError
00492
00493
00494
00495
00496 def setType(self, t, type):
00497
00498 raise NotImplementedError
00499
00500
00501 def getText(self, t):
00502 raise NotImplementedError
00503
00504
00505
00506 def setText(self, t, text):
00507
00508 raise NotImplementedError
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522 def getToken(self, t):
00523
00524 raise NotImplementedError
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535 def setTokenBoundaries(self, t, startToken, stopToken):
00536
00537 raise NotImplementedError
00538
00539
00540
00541
00542
00543
00544 def getTokenStartIndex(self, t):
00545
00546 raise NotImplementedError
00547
00548
00549
00550
00551
00552
00553 def getTokenStopIndex(self, t):
00554
00555 raise NotImplementedError
00556
00557
00558
00559
00560
00561
00562 def getChild(self, t, i):
00563
00564 raise NotImplementedError
00565
00566
00567
00568
00569 def setChild(self, t, i, child):
00570
00571 raise NotImplementedError
00572
00573
00574
00575
00576 def deleteChild(self, t, i):
00577
00578 raise NotImplementedError
00579
00580
00581
00582
00583 def getChildCount(self, t):
00584
00585 raise NotImplementedError
00586
00587
00588
00589
00590
00591
00592
00593
00594 def getParent(self, t):
00595
00596 raise NotImplementedError
00597
00598
00599
00600
00601
00602
00603
00604
00605 def setParent(self, t, parent):
00606
00607 raise NotImplementedError
00608
00609
00610
00611
00612
00613
00614
00615
00616 def getChildIndex(self, t):
00617
00618 raise NotImplementedError
00619
00620
00621
00622
00623
00624
00625
00626
00627 def setChildIndex(self, t, index):
00628
00629 raise NotImplementedError
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641 def replaceChildren(self, parent, startChildIndex, stopChildIndex, t):
00642
00643 raise NotImplementedError
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655 def create(self, *args):
00656
00657 if len(args) == 1 and isinstance(args[0], Token):
00658
00659
00660
00661
00662
00663
00664 return self.createWithPayload(args[0])
00665
00666 if (len(args) == 2
00667 and isinstance(args[0], (int, long))
00668 and isinstance(args[1], Token)
00669 ):
00670
00671
00672
00673
00674
00675
00676 return self.createFromToken(args[0], args[1])
00677
00678 if (len(args) == 3
00679 and isinstance(args[0], (int, long))
00680 and isinstance(args[1], Token)
00681 and isinstance(args[2], basestring)
00682 ):
00683
00684
00685
00686
00687
00688
00689 return self.createFromToken(args[0], args[1], args[2])
00690
00691 if (len(args) == 2
00692 and isinstance(args[0], (int, long))
00693 and isinstance(args[1], basestring)
00694 ):
00695
00696
00697
00698
00699
00700
00701 return self.createFromType(args[0], args[1])
00702
00703 raise TypeError(
00704 "No create method with this signature found: %s"
00705 % (', '.join(type(v).__name__ for v in args))
00706 )
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732 class BaseTree(Tree):
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744 def __init__(self, node=None):
00745
00746 Tree.__init__(self)
00747 self.children = []
00748 self.parent = None
00749 self.childIndex = 0
00750
00751
00752 def getChild(self, i):
00753 try:
00754 return self.children[i]
00755 except IndexError:
00756 return None
00757
00758
00759
00760
00761
00762
00763
00764
00765 def getChildren(self):
00766
00767
00768 return self.children
00769
00770
00771 def getFirstChildWithType(self, treeType):
00772 for child in self.children:
00773 if child.getType() == treeType:
00774 return child
00775
00776 return None
00777
00778
00779 def getChildCount(self):
00780 return len(self.children)
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790 def addChild(self, childTree):
00791
00792
00793
00794
00795 if childTree is None:
00796 return
00797
00798 if childTree.isNil():
00799
00800
00801 if self.children is childTree.children:
00802 raise ValueError("attempt to add child list to itself")
00803
00804
00805 for idx, child in enumerate(childTree.children):
00806 child.parent = self
00807 child.childIndex = len(self.children) + idx
00808
00809 self.children += childTree.children
00810
00811 else:
00812
00813 self.children.append(childTree)
00814 childTree.parent = self
00815 childTree.childIndex = len(self.children) - 1
00816
00817
00818
00819
00820 def addChildren(self, children):
00821
00822 self.children += children
00823
00824
00825 def setChild(self, i, t):
00826 if t is None:
00827 return
00828
00829 if t.isNil():
00830 raise ValueError("Can't set single child to a list")
00831
00832 self.children[i] = t
00833 t.parent = self
00834 t.childIndex = i
00835
00836
00837 def deleteChild(self, i):
00838 killed = self.children[i]
00839
00840 del self.children[i]
00841
00842
00843 for idx, child in enumerate(self.children[i:]):
00844 child.childIndex = i + idx
00845
00846 return killed
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856 def replaceChildren(self, startChildIndex, stopChildIndex, newTree):
00857
00858 if (startChildIndex >= len(self.children)
00859 or stopChildIndex >= len(self.children)
00860 ):
00861 raise IndexError("indexes invalid")
00862
00863 replacingHowMany = stopChildIndex - startChildIndex + 1
00864
00865
00866 if newTree.isNil():
00867 newChildren = newTree.children
00868
00869 else:
00870 newChildren = [newTree]
00871
00872 replacingWithHowMany = len(newChildren)
00873 delta = replacingHowMany - replacingWithHowMany
00874
00875
00876 if delta == 0:
00877
00878 for idx, child in enumerate(newChildren):
00879 self.children[idx + startChildIndex] = child
00880 child.parent = self
00881 child.childIndex = idx + startChildIndex
00882
00883 else:
00884
00885
00886
00887 del self.children[startChildIndex:stopChildIndex+1]
00888
00889
00890 self.children[startChildIndex:startChildIndex] = newChildren
00891
00892
00893 self.freshenParentAndChildIndexes(startChildIndex)
00894
00895
00896 def isNil(self):
00897 return False
00898
00899
00900 def freshenParentAndChildIndexes(self, offset=0):
00901 for idx, child in enumerate(self.children[offset:]):
00902 child.childIndex = idx + offset
00903 child.parent = self
00904
00905
00906 def sanityCheckParentAndChildIndexes(self, parent=None, i=-1):
00907 if parent != self.parent:
00908 raise ValueError(
00909 "parents don't match; expected %r found %r"
00910 % (parent, self.parent)
00911 )
00912
00913 if i != self.childIndex:
00914 raise ValueError(
00915 "child indexes don't match; expected %d found %d"
00916 % (i, self.childIndex)
00917 )
00918
00919 for idx, child in enumerate(self.children):
00920 child.sanityCheckParentAndChildIndexes(self, idx)
00921
00922
00923
00924
00925 def getChildIndex(self):
00926
00927 return 0
00928
00929
00930
00931
00932 def setChildIndex(self, index):
00933
00934 pass
00935
00936
00937
00938
00939 def getParent(self):
00940
00941 return None
00942
00943
00944
00945 def setParent(self, t):
00946
00947 pass
00948
00949
00950
00951
00952 def hasAncestor(self, ttype):
00953 return self.getAncestor(ttype) is not None
00954
00955
00956
00957 def getAncestor(self, ttype):
00958 t = self.getParent()
00959 while t is not None:
00960 if t.getType() == ttype:
00961 return t
00962 t = t.getParent()
00963
00964 return None
00965
00966
00967
00968
00969
00970
00971
00972 def getAncestors(self):
00973 if selfgetParent() is None:
00974 return None
00975
00976 ancestors = []
00977 t = self.getParent()
00978 while t is not None:
00979 ancestors.insert(0, t)
00980 t = t.getParent()
00981
00982 return ancestors
00983
00984
00985
00986
00987 def toStringTree(self):
00988
00989 if len(self.children) == 0:
00990 return self.toString()
00991
00992 buf = []
00993 if not self.isNil():
00994 buf.append('(')
00995 buf.append(self.toString())
00996 buf.append(' ')
00997
00998 for i, child in enumerate(self.children):
00999 if i > 0:
01000 buf.append(' ')
01001 buf.append(child.toStringTree())
01002
01003 if not self.isNil():
01004 buf.append(')')
01005
01006 return ''.join(buf)
01007
01008
01009 def getLine(self):
01010 return 0
01011
01012
01013 def getCharPositionInLine(self):
01014 return 0
01015
01016
01017
01018
01019 def toString(self):
01020
01021 raise NotImplementedError
01022
01023
01024
01025
01026
01027
01028
01029 class BaseTreeAdaptor(TreeAdaptor):
01030
01031
01032
01033
01034
01035 def nil(self):
01036 return self.createWithPayload(None)
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047
01048
01049
01050
01051
01052 def errorNode(self, input, start, stop, exc):
01053
01054 return CommonErrorNode(input, start, stop, exc)
01055
01056
01057 def isNil(self, tree):
01058 return tree.isNil()
01059
01060
01061
01062
01063
01064
01065
01066
01067 def dupTree(self, t, parent=None):
01068
01069 if t is None:
01070 return None
01071
01072 newTree = self.dupNode(t)
01073
01074
01075
01076
01077 self.setChildIndex(newTree, self.getChildIndex(t))
01078
01079 self.setParent(newTree, parent)
01080
01081 for i in range(self.getChildCount(t)):
01082 child = self.getChild(t, i)
01083 newSubTree = self.dupTree(child, t)
01084 self.addChild(newTree, newSubTree)
01085
01086 return newTree
01087
01088
01089
01090
01091
01092
01093
01094
01095
01096
01097
01098 def addChild(self, tree, child):
01099
01100
01101
01102
01103 if tree is not None and child is not None:
01104 tree.addChild(child)
01105
01106
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135 def becomeRoot(self, newRoot, oldRoot):
01136
01137 if isinstance(newRoot, Token):
01138 newRoot = self.create(newRoot)
01139
01140 if oldRoot is None:
01141 return newRoot
01142
01143 if not isinstance(newRoot, CommonTree):
01144 newRoot = self.createWithPayload(newRoot)
01145
01146
01147 if newRoot.isNil():
01148 nc = newRoot.getChildCount()
01149 if nc == 1:
01150 newRoot = newRoot.getChild(0)
01151
01152 elif nc > 1:
01153
01154 raise RuntimeError("more than one node as root")
01155
01156
01157
01158
01159 newRoot.addChild(oldRoot)
01160 return newRoot
01161
01162
01163
01164
01165 def rulePostProcessing(self, root):
01166
01167 if root is not None and root.isNil():
01168 if root.getChildCount() == 0:
01169 root = None
01170
01171 elif root.getChildCount() == 1:
01172 root = root.getChild(0)
01173
01174 root.setParent(None)
01175 root.setChildIndex(-1)
01176
01177 return root
01178
01179
01180 def createFromToken(self, tokenType, fromToken, text=None):
01181 assert isinstance(tokenType, (int, long)), type(tokenType).__name__
01182 assert isinstance(fromToken, Token), type(fromToken).__name__
01183 assert text is None or isinstance(text, basestring), type(text).__name__
01184
01185 fromToken = self.createToken(fromToken)
01186 fromToken.type = tokenType
01187 if text is not None:
01188 fromToken.text = text
01189 t = self.createWithPayload(fromToken)
01190 return t
01191
01192
01193 def createFromType(self, tokenType, text):
01194 assert isinstance(tokenType, (int, long)), type(tokenType).__name__
01195 assert isinstance(text, basestring) or text is None, type(text).__name__
01196
01197 fromToken = self.createToken(tokenType=tokenType, text=text)
01198 t = self.createWithPayload(fromToken)
01199 return t
01200
01201
01202 def getType(self, t):
01203 return t.getType()
01204
01205
01206 def setType(self, t, type):
01207 raise RuntimeError("don't know enough about Tree node")
01208
01209
01210 def getText(self, t):
01211 return t.getText()
01212
01213
01214 def setText(self, t, text):
01215 raise RuntimeError("don't know enough about Tree node")
01216
01217
01218 def getChild(self, t, i):
01219 return t.getChild(i)
01220
01221
01222 def setChild(self, t, i, child):
01223 t.setChild(i, child)
01224
01225
01226 def deleteChild(self, t, i):
01227 return t.deleteChild(i)
01228
01229
01230 def getChildCount(self, t):
01231 return t.getChildCount()
01232
01233
01234 def getUniqueID(self, node):
01235 return hash(node)
01236
01237
01238
01239
01240
01241
01242
01243
01244
01245
01246
01247
01248 def createToken(self, fromToken=None, tokenType=None, text=None):
01249
01250 raise NotImplementedError
01251
01252
01253
01254
01255
01256
01257
01258
01259
01260
01261
01262
01263
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279 class CommonTree(BaseTree):
01280
01281 def __init__(self, payload):
01282 BaseTree.__init__(self)
01283
01284
01285
01286 self.startIndex = -1
01287 self.stopIndex = -1
01288
01289
01290 self.parent = None
01291
01292
01293 self.childIndex = -1
01294
01295
01296 if payload is None:
01297 self.token = None
01298
01299 elif isinstance(payload, CommonTree):
01300 self.token = payload.token
01301 self.startIndex = payload.startIndex
01302 self.stopIndex = payload.stopIndex
01303
01304 elif payload is None or isinstance(payload, Token):
01305 self.token = payload
01306
01307 else:
01308 raise TypeError(type(payload).__name__)
01309
01310
01311
01312 def getToken(self):
01313 return self.token
01314
01315
01316 def dupNode(self):
01317 return CommonTree(self)
01318
01319
01320 def isNil(self):
01321 return self.token is None
01322
01323
01324 def getType(self):
01325 if self.token is None:
01326 return INVALID_TOKEN_TYPE
01327
01328 return self.token.getType()
01329
01330 type = property(getType)
01331
01332
01333 def getText(self):
01334 if self.token is None:
01335 return None
01336
01337 return self.token.text
01338
01339 text = property(getText)
01340
01341
01342 def getLine(self):
01343 if self.token is None or self.token.getLine() == 0:
01344 if self.getChildCount():
01345 return self.getChild(0).getLine()
01346 else:
01347 return 0
01348
01349 return self.token.getLine()
01350
01351 line = property(getLine)
01352
01353
01354 def getCharPositionInLine(self):
01355 if self.token is None or self.token.getCharPositionInLine() == -1:
01356 if self.getChildCount():
01357 return self.getChild(0).getCharPositionInLine()
01358 else:
01359 return 0
01360
01361 else:
01362 return self.token.getCharPositionInLine()
01363
01364 charPositionInLine = property(getCharPositionInLine)
01365
01366
01367 def getTokenStartIndex(self):
01368 if self.startIndex == -1 and self.token is not None:
01369 return self.token.getTokenIndex()
01370
01371 return self.startIndex
01372
01373 def setTokenStartIndex(self, index):
01374 self.startIndex = index
01375
01376 tokenStartIndex = property(getTokenStartIndex, setTokenStartIndex)
01377
01378
01379 def getTokenStopIndex(self):
01380 if self.stopIndex == -1 and self.token is not None:
01381 return self.token.getTokenIndex()
01382
01383 return self.stopIndex
01384
01385 def setTokenStopIndex(self, index):
01386 self.stopIndex = index
01387
01388 tokenStopIndex = property(getTokenStopIndex, setTokenStopIndex)
01389
01390
01391
01392
01393
01394
01395
01396 def setUnknownTokenBoundaries(self):
01397
01398 if self.children is None:
01399 if self.startIndex < 0 or self.stopIndex < 0:
01400 self.startIndex = self.stopIndex = self.token.getTokenIndex()
01401
01402 return
01403
01404 for child in self.children:
01405 child.setUnknownTokenBoundaries()
01406
01407 if self.startIndex >= 0 and self.stopIndex >= 0:
01408
01409 return
01410
01411 if self.children:
01412 firstChild = self.children[0]
01413 lastChild = self.children[-1]
01414 self.startIndex = firstChild.getTokenStartIndex()
01415 self.stopIndex = lastChild.getTokenStopIndex()
01416
01417
01418 def getChildIndex(self):
01419
01420 return self.childIndex
01421
01422
01423 def setChildIndex(self, idx):
01424
01425 self.childIndex = idx
01426
01427
01428 def getParent(self):
01429
01430 return self.parent
01431
01432
01433 def setParent(self, t):
01434
01435 self.parent = t
01436
01437
01438 def toString(self):
01439 if self.isNil():
01440 return "nil"
01441
01442 if self.getType() == INVALID_TOKEN_TYPE:
01443 return "<errornode>"
01444
01445 return self.token.text
01446
01447 __str__ = toString
01448
01449
01450
01451 def toStringTree(self):
01452 if not self.children:
01453 return self.toString()
01454
01455 ret = ''
01456 if not self.isNil():
01457 ret += '(%s ' % (self.toString())
01458
01459 ret += ' '.join([child.toStringTree() for child in self.children])
01460
01461 if not self.isNil():
01462 ret += ')'
01463
01464 return ret
01465
01466
01467 INVALID_NODE = CommonTree(INVALID_TOKEN)
01468
01469
01470
01471
01472 class CommonErrorNode(CommonTree):
01473
01474 def __init__(self, input, start, stop, exc):
01475 CommonTree.__init__(self, None)
01476
01477 if (stop is None or
01478 (stop.getTokenIndex() < start.getTokenIndex() and
01479 stop.getType() != EOF
01480 )
01481 ):
01482
01483
01484
01485
01486 stop = start
01487
01488 self.input = input
01489 self.start = start
01490 self.stop = stop
01491 self.trappedException = exc
01492
01493
01494 def isNil(self):
01495 return False
01496
01497
01498 def getType(self):
01499 return INVALID_TOKEN_TYPE
01500
01501
01502 def getText(self):
01503 if isinstance(self.start, Token):
01504 i = self.start.getTokenIndex()
01505 j = self.stop.getTokenIndex()
01506 if self.stop.getType() == EOF:
01507 j = self.input.size()
01508
01509 badText = self.input.toString(i, j)
01510
01511 elif isinstance(self.start, Tree):
01512 badText = self.input.toString(self.start, self.stop)
01513
01514 else:
01515
01516
01517 badText = "<unknown>"
01518
01519 return badText
01520
01521
01522 def toString(self):
01523 if isinstance(self.trappedException, MissingTokenException):
01524 return ("<missing type: "
01525 + str(self.trappedException.getMissingType())
01526 + ">")
01527
01528 elif isinstance(self.trappedException, UnwantedTokenException):
01529 return ("<extraneous: "
01530 + str(self.trappedException.getUnexpectedToken())
01531 + ", resync=" + self.getText() + ">")
01532
01533 elif isinstance(self.trappedException, MismatchedTokenException):
01534 return ("<mismatched token: "
01535 + str(self.trappedException.token)
01536 + ", resync=" + self.getText() + ">")
01537
01538 elif isinstance(self.trappedException, NoViableAltException):
01539 return ("<unexpected: "
01540 + str(self.trappedException.token)
01541 + ", resync=" + self.getText() + ">")
01542
01543 return "<error: "+self.getText()+">"
01544
01545
01546
01547
01548
01549
01550
01551
01552
01553
01554
01555
01556
01557
01558
01559
01560 class CommonTreeAdaptor(BaseTreeAdaptor):
01561
01562
01563
01564
01565
01566
01567
01568
01569
01570 def dupNode(self, treeNode):
01571
01572 if treeNode is None:
01573 return None
01574
01575 return treeNode.dupNode()
01576
01577
01578 def createWithPayload(self, payload):
01579 return CommonTree(payload)
01580
01581
01582
01583
01584
01585
01586
01587
01588
01589
01590
01591
01592 def createToken(self, fromToken=None, tokenType=None, text=None):
01593
01594 if fromToken is not None:
01595 return CommonToken(oldToken=fromToken)
01596
01597 return CommonToken(type=tokenType, text=text)
01598
01599
01600
01601
01602
01603
01604
01605
01606
01607 def setTokenBoundaries(self, t, startToken, stopToken):
01608
01609 if t is None:
01610 return
01611
01612 start = 0
01613 stop = 0
01614
01615 if startToken is not None:
01616 start = startToken.index
01617
01618 if stopToken is not None:
01619 stop = stopToken.index
01620
01621 t.setTokenStartIndex(start)
01622 t.setTokenStopIndex(stop)
01623
01624
01625 def getTokenStartIndex(self, t):
01626 if t is None:
01627 return -1
01628 return t.getTokenStartIndex()
01629
01630
01631 def getTokenStopIndex(self, t):
01632 if t is None:
01633 return -1
01634 return t.getTokenStopIndex()
01635
01636
01637 def getText(self, t):
01638 if t is None:
01639 return None
01640 return t.getText()
01641
01642
01643 def getType(self, t):
01644 if t is None:
01645 return INVALID_TOKEN_TYPE
01646
01647 return t.getType()
01648
01649
01650
01651
01652
01653
01654
01655
01656 def getToken(self, t):
01657
01658 if isinstance(t, CommonTree):
01659 return t.getToken()
01660
01661 return None
01662
01663
01664 def getChild(self, t, i):
01665 if t is None:
01666 return None
01667 return t.getChild(i)
01668
01669
01670 def getChildCount(self, t):
01671 if t is None:
01672 return 0
01673 return t.getChildCount()
01674
01675
01676 def getParent(self, t):
01677 return t.getParent()
01678
01679
01680 def setParent(self, t, parent):
01681 t.setParent(parent)
01682
01683
01684 def getChildIndex(self, t):
01685 if t is None:
01686 return 0
01687 return t.getChildIndex()
01688
01689
01690 def setChildIndex(self, t, index):
01691 t.setChildIndex(index)
01692
01693
01694 def replaceChildren(self, parent, startChildIndex, stopChildIndex, t):
01695 if parent is not None:
01696 parent.replaceChildren(startChildIndex, stopChildIndex, t)
01697
01698
01699
01700
01701
01702
01703
01704
01705
01706
01707
01708
01709
01710
01711
01712
01713
01714
01715
01716
01717
01718
01719
01720 class TreeNodeStream(IntStream):
01721
01722
01723
01724
01725
01726
01727
01728
01729
01730
01731 def get(self, i):
01732
01733 raise NotImplementedError
01734
01735
01736
01737
01738
01739
01740
01741
01742
01743
01744
01745
01746
01747
01748
01749 def LT(self, k):
01750
01751 raise NotImplementedError
01752
01753
01754
01755
01756
01757
01758
01759 def getTreeSource(self):
01760
01761 raise NotImplementedError
01762
01763
01764
01765
01766
01767
01768
01769
01770
01771 def getTokenStream(self):
01772
01773 raise NotImplementedError
01774
01775
01776
01777
01778
01779
01780
01781 def getTreeAdaptor(self):
01782
01783 raise NotImplementedError
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794 def setUniqueNavigationNodes(self, uniqueNavigationNodes):
01795
01796 raise NotImplementedError
01797
01798
01799
01800
01801
01802
01803
01804
01805
01806
01807 def toString(self, start, stop):
01808
01809 raise NotImplementedError
01810
01811
01812
01813
01814
01815
01816
01817
01818
01819
01820
01821
01822
01823
01824
01825 def replaceChildren(self, parent, startChildIndex, stopChildIndex, t):
01826
01827 raise NotImplementedError
01828
01829
01830
01831
01832
01833
01834
01835
01836
01837
01838
01839
01840
01841
01842
01843
01844
01845
01846
01847
01848
01849 class CommonTreeNodeStream(TreeNodeStream):
01850
01851 def __init__(self, *args):
01852 TreeNodeStream.__init__(self)
01853
01854 if len(args) == 1:
01855 adaptor = CommonTreeAdaptor()
01856 tree = args[0]
01857
01858 nodes = None
01859 down = None
01860 up = None
01861 eof = None
01862
01863 elif len(args) == 2:
01864 adaptor = args[0]
01865 tree = args[1]
01866
01867 nodes = None
01868 down = None
01869 up = None
01870 eof = None
01871
01872 elif len(args) == 3:
01873 parent = args[0]
01874 start = args[1]
01875 stop = args[2]
01876
01877 adaptor = parent.adaptor
01878 tree = parent.root
01879
01880 nodes = parent.nodes[start:stop]
01881 down = parent.down
01882 up = parent.up
01883 eof = parent.eof
01884
01885 else:
01886 raise TypeError("Invalid arguments")
01887
01888
01889
01890 if down is not None:
01891 self.down = down
01892 else:
01893 self.down = adaptor.createFromType(DOWN, "DOWN")
01894
01895 if up is not None:
01896 self.up = up
01897 else:
01898 self.up = adaptor.createFromType(UP, "UP")
01899
01900 if eof is not None:
01901 self.eof = eof
01902 else:
01903 self.eof = adaptor.createFromType(EOF, "EOF")
01904
01905
01906
01907
01908
01909
01910
01911
01912
01913 if nodes is not None:
01914 self.nodes = nodes
01915 else:
01916 self.nodes = []
01917
01918
01919 self.root = tree
01920
01921
01922 self.tokens = None
01923
01924
01925 self.adaptor = adaptor
01926
01927
01928 self.uniqueNavigationNodes = False
01929
01930
01931
01932 self.p = -1
01933
01934
01935 self.lastMarker = None
01936
01937
01938 self.calls = []
01939
01940
01941
01942
01943
01944
01945 def fillBuffer(self):
01946
01947 self._fillBuffer(self.root)
01948 self.p = 0
01949
01950
01951 def _fillBuffer(self, t):
01952 nil = self.adaptor.isNil(t)
01953
01954 if not nil:
01955 self.nodes.append(t)
01956
01957
01958 n = self.adaptor.getChildCount(t)
01959 if not nil and n > 0:
01960 self.addNavigationNode(DOWN)
01961
01962
01963 for c in range(n):
01964 self._fillBuffer(self.adaptor.getChild(t, c))
01965
01966
01967 if not nil and n > 0:
01968 self.addNavigationNode(UP)
01969
01970
01971
01972
01973
01974
01975 def getNodeIndex(self, node):
01976
01977 if self.p == -1:
01978 self.fillBuffer()
01979
01980 for i, t in enumerate(self.nodes):
01981 if t == node:
01982 return i
01983
01984 return -1
01985
01986
01987
01988
01989
01990
01991
01992
01993 def addNavigationNode(self, ttype):
01994
01995 navNode = None
01996
01997 if ttype == DOWN:
01998 if self.hasUniqueNavigationNodes():
01999 navNode = self.adaptor.createFromType(DOWN, "DOWN")
02000
02001 else:
02002 navNode = self.down
02003
02004 else:
02005 if self.hasUniqueNavigationNodes():
02006 navNode = self.adaptor.createFromType(UP, "UP")
02007
02008 else:
02009 navNode = self.up
02010
02011 self.nodes.append(navNode)
02012
02013
02014 def get(self, i):
02015 if self.p == -1:
02016 self.fillBuffer()
02017
02018 return self.nodes[i]
02019
02020
02021 def LT(self, k):
02022 if self.p == -1:
02023 self.fillBuffer()
02024
02025 if k == 0:
02026 return None
02027
02028 if k < 0:
02029 return self.LB(-k)
02030
02031 if self.p + k - 1 >= len(self.nodes):
02032 return self.eof
02033
02034 return self.nodes[self.p + k - 1]
02035
02036
02037 def getCurrentSymbol(self):
02038 return self.LT(1)
02039
02040
02041
02042
02043 def LB(self, k):
02044
02045 if k == 0:
02046 return None
02047
02048 if self.p - k < 0:
02049 return None
02050
02051 return self.nodes[self.p - k]
02052
02053
02054 def getTreeSource(self):
02055 return self.root
02056
02057
02058 def getSourceName(self):
02059 return self.getTokenStream().getSourceName()
02060
02061
02062 def getTokenStream(self):
02063 return self.tokens
02064
02065
02066 def setTokenStream(self, tokens):
02067 self.tokens = tokens
02068
02069
02070 def getTreeAdaptor(self):
02071 return self.adaptor
02072
02073
02074 def hasUniqueNavigationNodes(self):
02075 return self.uniqueNavigationNodes
02076
02077
02078 def setUniqueNavigationNodes(self, uniqueNavigationNodes):
02079 self.uniqueNavigationNodes = uniqueNavigationNodes
02080
02081
02082 def consume(self):
02083 if self.p == -1:
02084 self.fillBuffer()
02085
02086 self.p += 1
02087
02088
02089 def LA(self, i):
02090 return self.adaptor.getType(self.LT(i))
02091
02092
02093 def mark(self):
02094 if self.p == -1:
02095 self.fillBuffer()
02096
02097
02098 self.lastMarker = self.index()
02099 return self.lastMarker
02100
02101
02102 def release(self, marker=None):
02103
02104
02105 pass
02106
02107
02108 def index(self):
02109 return self.p
02110
02111
02112 def rewind(self, marker=None):
02113 if marker is None:
02114 marker = self.lastMarker
02115
02116 self.seek(marker)
02117
02118
02119 def seek(self, index):
02120 if self.p == -1:
02121 self.fillBuffer()
02122
02123 self.p = index
02124
02125
02126
02127
02128
02129
02130
02131 def push(self, index):
02132
02133 self.calls.append(self.p)
02134 self.seek(index)
02135
02136
02137
02138
02139
02140
02141
02142 def pop(self):
02143
02144 ret = self.calls.pop(-1)
02145 self.seek(ret)
02146 return ret
02147
02148
02149 def reset(self):
02150 self.p = 0
02151 self.lastMarker = 0
02152 self.calls = []
02153
02154
02155 def size(self):
02156 if self.p == -1:
02157 self.fillBuffer()
02158
02159 return len(self.nodes)
02160
02161
02162
02163
02164 def replaceChildren(self, parent, startChildIndex, stopChildIndex, t):
02165 if parent is not None:
02166 self.adaptor.replaceChildren(
02167 parent, startChildIndex, stopChildIndex, t
02168 )
02169
02170
02171
02172
02173 def __str__(self):
02174
02175 if self.p == -1:
02176 self.fillBuffer()
02177
02178 return ' '.join([str(self.adaptor.getType(node))
02179 for node in self.nodes
02180 ])
02181
02182
02183 def toString(self, start, stop):
02184 if start is None or stop is None:
02185 return None
02186
02187 if self.p == -1:
02188 self.fillBuffer()
02189
02190
02191
02192
02193
02194
02195
02196
02197
02198
02199
02200
02201 if self.tokens is not None:
02202 beginTokenIndex = self.adaptor.getTokenStartIndex(start)
02203 endTokenIndex = self.adaptor.getTokenStopIndex(stop)
02204
02205
02206
02207 if self.adaptor.getType(stop) == UP:
02208 endTokenIndex = self.adaptor.getTokenStopIndex(start)
02209
02210 elif self.adaptor.getType(stop) == EOF:
02211 endTokenIndex = self.size() -2
02212
02213 return self.tokens.toString(beginTokenIndex, endTokenIndex)
02214
02215
02216 i, t = 0, None
02217 for i, t in enumerate(self.nodes):
02218 if t == start:
02219 break
02220
02221
02222 buf = []
02223 t = self.nodes[i]
02224 while t != stop:
02225 text = self.adaptor.getText(t)
02226 if text is None:
02227 text = " " + self.adaptor.getType(t)
02228
02229 buf.append(text)
02230 i += 1
02231 t = self.nodes[i]
02232
02233
02234 text = self.adaptor.getText(stop)
02235 if text is None:
02236 text = " " +self.adaptor.getType(stop)
02237
02238 buf.append(text)
02239
02240 return ''.join(buf)
02241
02242
02243
02244 def __iter__(self):
02245 if self.p == -1:
02246 self.fillBuffer()
02247
02248 for node in self.nodes:
02249 yield node
02250
02251
02252
02253
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264
02265 class TreeParser(BaseRecognizer):
02266
02267 def __init__(self, input, state=None):
02268 BaseRecognizer.__init__(self, state)
02269
02270 self.input = None
02271 self.setTreeNodeStream(input)
02272
02273
02274 def reset(self):
02275 BaseRecognizer.reset(self)
02276 if self.input is not None:
02277 self.input.seek(0)
02278
02279
02280
02281
02282 def setTreeNodeStream(self, input):
02283
02284 self.input = input
02285
02286
02287 def getTreeNodeStream(self):
02288 return self.input
02289
02290
02291 def getSourceName(self):
02292 return self.input.getSourceName()
02293
02294
02295 def getCurrentInputSymbol(self, input):
02296 return input.LT(1)
02297
02298
02299 def getMissingSymbol(self, input, e, expectedTokenType, follow):
02300 tokenText = "<missing " + self.tokenNames[expectedTokenType] + ">"
02301 return CommonTree(CommonToken(type=expectedTokenType, text=tokenText))
02302
02303
02304
02305 dotdot = ".*[^.]\\.\\.[^.].*"
02306 doubleEtc = ".*\\.\\.\\.\\s+\\.\\.\\..*"
02307 dotdotPattern = re.compile(dotdot)
02308 doubleEtcPattern = re.compile(doubleEtc)
02309
02310
02311
02312
02313
02314
02315
02316
02317
02318
02319
02320
02321
02322
02323 def inContext(self, context, adaptor=None, tokenName=None, t=None):
02324
02325 return _inContext(
02326 self.input.getTreeAdaptor(), self.getTokenNames(),
02327 self.input.LT(1), context)
02328
02329 @classmethod
02330
02331
02332
02333
02334
02335 def _inContext(cls, adaptor, tokenNames, t, context):
02336
02337 if cls.dotdotPattern.match(context):
02338
02339 raise ValueError("invalid syntax: ..")
02340
02341 if cls.doubleEtcPattern.match(context):
02342
02343 raise ValueError("invalid syntax: ... ...")
02344
02345
02346 context = context.replace("...", " ... ")
02347 context = context.strip()
02348 nodes = context.split()
02349
02350 ni = len(nodes) - 1
02351 t = adaptor.getParent(t)
02352 while ni >= 0 and t is not None:
02353 if nodes[ni] == "...":
02354
02355 if ni == 0:
02356
02357 return True
02358 goal = nodes[ni-1]
02359 ancestor = cls._getAncestor(adaptor, tokenNames, t, goal)
02360 if ancestor is None:
02361 return False
02362 t = ancestor
02363 ni -= 1
02364
02365 name = tokenNames[adaptor.getType(t)]
02366 if name != nodes[ni]:
02367 return False
02368
02369
02370 ni -= 1
02371 t = adaptor.getParent(t)
02372
02373
02374 if t is None and ni >= 0:
02375 return False
02376
02377 return True
02378
02379 @staticmethod
02380
02381
02382 def _getAncestor(adaptor, tokenNames, t, goal):
02383 while t is not None:
02384 name = tokenNames[adaptor.getType(t)]
02385 if name == goal:
02386 return t
02387 t = adaptor.getParent(t)
02388
02389 return None
02390
02391
02392
02393
02394
02395
02396
02397
02398 def matchAny(self, ignore):
02399
02400 self._state.errorRecovery = False
02401
02402 look = self.input.LT(1)
02403 if self.input.getTreeAdaptor().getChildCount(look) == 0:
02404 self.input.consume()
02405 return
02406
02407
02408
02409 level = 0
02410 tokenType = self.input.getTreeAdaptor().getType(look)
02411 while tokenType != EOF and not (tokenType == UP and level==0):
02412 self.input.consume()
02413 look = self.input.LT(1)
02414 tokenType = self.input.getTreeAdaptor().getType(look)
02415 if tokenType == DOWN:
02416 level += 1
02417
02418 elif tokenType == UP:
02419 level -= 1
02420
02421 self.input.consume()
02422
02423
02424
02425
02426
02427
02428
02429
02430 def mismatch(self, input, ttype, follow):
02431
02432 raise MismatchedTreeNodeException(ttype, input)
02433
02434
02435
02436
02437
02438
02439
02440
02441 def getErrorHeader(self, e):
02442
02443 return (self.getGrammarFileName() +
02444 ": node from %sline %s:%s"
02445 % (['', "after "][e.approximateLineInfo],
02446 e.line,
02447 e.charPositionInLine
02448 )
02449 )
02450
02451
02452
02453
02454
02455
02456 def getErrorMessage(self, e, tokenNames):
02457
02458 if isinstance(self, TreeParser):
02459 adaptor = e.input.getTreeAdaptor()
02460 e.token = adaptor.getToken(e.node)
02461 if e.token is not None:
02462 e.token = CommonToken(
02463 type=adaptor.getType(e.node),
02464 text=adaptor.getText(e.node)
02465 )
02466
02467 return BaseRecognizer.getErrorMessage(self, e, tokenNames)
02468
02469
02470 def traceIn(self, ruleName, ruleIndex):
02471 BaseRecognizer.traceIn(self, ruleName, ruleIndex, self.input.LT(1))
02472
02473
02474 def traceOut(self, ruleName, ruleIndex):
02475 BaseRecognizer.traceOut(self, ruleName, ruleIndex, self.input.LT(1))
02476
02477
02478
02479
02480
02481
02482
02483
02484
02485
02486
02487
02488 class TreeVisitor(object):
02489
02490 def __init__(self, adaptor=None):
02491 if adaptor is not None:
02492 self.adaptor = adaptor
02493 else:
02494 self.adaptor = CommonTreeAdaptor()
02495
02496
02497
02498
02499
02500
02501
02502
02503
02504
02505
02506
02507
02508
02509
02510 def visit(self, t, pre_action=None, post_action=None):
02511
02512 isNil = self.adaptor.isNil(t)
02513 if pre_action is not None and not isNil:
02514
02515 t = pre_action(t)
02516
02517 for idx in xrange(self.adaptor.getChildCount(t)):
02518 child = self.adaptor.getChild(t, idx)
02519 self.visit(child, pre_action, post_action)
02520
02521 if post_action is not None and not isNil:
02522 t = post_action(t)
02523
02524 return t
02525
02526
02527
02528
02529
02530
02531
02532
02533
02534
02535
02536
02537
02538
02539
02540
02541
02542
02543
02544
02545
02546
02547
02548
02549
02550 class RewriteRuleElementStream(object):
02551
02552 def __init__(self, adaptor, elementDescription, elements=None):
02553
02554
02555 self.cursor = 0
02556
02557
02558 self.singleElement = None
02559
02560
02561 self.elements = None
02562
02563
02564
02565
02566
02567 self.dirty = False
02568
02569
02570
02571
02572 self.elementDescription = elementDescription
02573
02574 self.adaptor = adaptor
02575
02576 if isinstance(elements, (list, tuple)):
02577
02578 self.singleElement = None
02579 self.elements = elements
02580
02581 else:
02582
02583 self.add(elements)
02584
02585
02586
02587
02588
02589
02590
02591
02592
02593 def reset(self):
02594
02595 self.cursor = 0
02596 self.dirty = True
02597
02598
02599 def add(self, el):
02600 if el is None:
02601 return
02602
02603 if self.elements is not None:
02604 self.elements.append(el)
02605 return
02606
02607 if self.singleElement is None:
02608 self.singleElement = el
02609 return
02610
02611
02612 self.elements = []
02613 self.elements.append(self.singleElement)
02614 self.singleElement = None
02615 self.elements.append(el)
02616
02617
02618
02619
02620
02621
02622
02623
02624
02625
02626 def nextTree(self):
02627
02628 if (self.dirty
02629 or (self.cursor >= len(self) and len(self) == 1)
02630 ):
02631
02632 el = self._next()
02633 return self.dup(el)
02634
02635
02636 el = self._next()
02637 return el
02638
02639
02640
02641
02642
02643
02644
02645
02646
02647
02648 def _next(self):
02649
02650 if len(self) == 0:
02651 raise RewriteEmptyStreamException(self.elementDescription)
02652
02653 if self.cursor >= len(self):
02654 if len(self) == 1:
02655 return self.toTree(self.singleElement)
02656
02657
02658 raise RewriteCardinalityException(self.elementDescription)
02659
02660
02661 if self.singleElement is not None:
02662 self.cursor += 1
02663 return self.toTree(self.singleElement)
02664
02665
02666 o = self.toTree(self.elements[self.cursor])
02667 self.cursor += 1
02668 return o
02669
02670
02671
02672
02673
02674
02675
02676
02677
02678 def dup(self, el):
02679
02680 raise NotImplementedError
02681
02682
02683
02684
02685
02686
02687
02688 def toTree(self, el):
02689
02690 return el
02691
02692
02693 def hasNext(self):
02694 return ( (self.singleElement is not None and self.cursor < 1)
02695 or (self.elements is not None
02696 and self.cursor < len(self.elements)
02697 )
02698 )
02699
02700
02701 def size(self):
02702 if self.singleElement is not None:
02703 return 1
02704
02705 if self.elements is not None:
02706 return len(self.elements)
02707
02708 return 0
02709
02710 __len__ = size
02711
02712
02713
02714
02715 def getDescription(self):
02716
02717 return self.elementDescription
02718
02719
02720
02721
02722 class RewriteRuleTokenStream(RewriteRuleElementStream):
02723
02724 def toTree(self, el):
02725
02726
02727 return el
02728
02729
02730 def nextNode(self):
02731 t = self._next()
02732 return self.adaptor.createWithPayload(t)
02733
02734
02735 def nextToken(self):
02736 return self._next()
02737
02738
02739 def dup(self, el):
02740 raise TypeError("dup can't be called for a token stream.")
02741
02742
02743
02744
02745 class RewriteRuleSubtreeStream(RewriteRuleElementStream):
02746
02747
02748
02749
02750
02751
02752
02753
02754
02755
02756
02757
02758
02759
02760
02761
02762 def nextNode(self):
02763
02764 if (self.dirty
02765 or (self.cursor >= len(self) and len(self) == 1)
02766 ):
02767
02768
02769 el = self._next()
02770 return self.adaptor.dupNode(el)
02771
02772
02773 el = self._next()
02774 return el
02775
02776
02777 def dup(self, el):
02778 return self.adaptor.dupTree(el)
02779
02780
02781
02782
02783
02784
02785
02786
02787 class RewriteRuleNodeStream(RewriteRuleElementStream):
02788
02789 def nextNode(self):
02790 return self._next()
02791
02792
02793 def toTree(self, el):
02794 return self.adaptor.dupNode(el)
02795
02796
02797 def dup(self, el):
02798
02799
02800 raise TypeError("dup can't be called for a node stream.")
02801
02802
02803
02804
02805
02806
02807
02808
02809
02810 class TreeRuleReturnScope(RuleReturnScope):
02811
02812 def __init__(self):
02813 self.start = None
02814 self.tree = None
02815
02816
02817 def getStart(self):
02818 return self.start
02819
02820
02821 def getTree(self):
02822 return self.tree
02823
02824
02825