1663 lines
47 KiB
Ruby
1663 lines
47 KiB
Ruby
#!/usr/bin/ruby
|
|
# encoding: utf-8
|
|
|
|
require 'antlr3/test/functional'
|
|
|
|
|
|
class TestASTRewritingTreeParsers < ANTLR3::Test::Functional
|
|
inline_grammar( <<-'END' )
|
|
grammar FlatList;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar FlatListWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=FlatList;
|
|
}
|
|
|
|
a : ID INT -> INT ID;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar SimpleTree;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar SimpleTreeWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=SimpleTree;
|
|
}
|
|
a : ^(ID INT) -> ^(INT ID);
|
|
END
|
|
|
|
inline_grammar( <<-END )
|
|
grammar CombinedRewriteAndAuto;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT) | INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-END )
|
|
tree grammar CombinedRewriteAndAutoTree;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=CombinedRewriteAndAuto;
|
|
}
|
|
a : ^(ID INT) -> ^(INT ID) | INT;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AvoidDup;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AvoidDupWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AvoidDup;
|
|
}
|
|
a : ID -> ^(ID ID);
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar Loop;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID+ INT+ -> (^(ID INT))+ ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar LoopWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=Loop;
|
|
}
|
|
a : (^(ID INT))+ -> INT+ ID+;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoDup;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoDupWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AutoDup;
|
|
}
|
|
a : ID;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoDupRule;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoDupRuleWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AutoDupRule;
|
|
}
|
|
a : b c ;
|
|
b : ID ;
|
|
c : INT ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoWildcard;
|
|
options {language=Ruby;output=AST;}
|
|
a : ID INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoWildcardWalker;
|
|
options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcard;}
|
|
a : ID .
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoWildcard2;
|
|
options {language=Ruby;output=AST;}
|
|
a : ID INT -> ^(ID INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoWildcard2Walker;
|
|
options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcard2;}
|
|
a : ^(ID .)
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoWildcardWithLabel;
|
|
options {language=Ruby;output=AST;}
|
|
a : ID INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoWildcardWithLabelWalker;
|
|
options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcardWithLabel;}
|
|
a : ID c=.
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoWildcardWithListLabel;
|
|
options {language=Ruby;output=AST;}
|
|
a : ID INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoWildcardWithListLabelWalker;
|
|
options {language=Ruby;output=AST; ASTLabelType=CommonTree; tokenVocab=AutoWildcardWithListLabel;}
|
|
a : ID c+=.
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoDupMultiple;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID ID INT;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoDupMultipleWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AutoDupMultiple;
|
|
}
|
|
a : ID ID INT
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoDupTree;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoDupTreeWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AutoDupTree;
|
|
}
|
|
a : ^(ID INT)
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoDupTreeWithLabels;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoDupTreeWithLabelsWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AutoDupTreeWithLabels;
|
|
}
|
|
a : ^(x=ID y=INT)
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoDupTreeWithListLabels;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoDupTreeWithListLabelsWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AutoDupTreeWithListLabels;
|
|
}
|
|
a : ^(x+=ID y+=INT)
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoDupTreeWithRuleRoot;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoDupTreeWithRuleRootWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AutoDupTreeWithRuleRoot;
|
|
}
|
|
a : ^(b INT) ;
|
|
b : ID ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoDupTreeWithRuleRootAndLabels;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoDupTreeWithRuleRootAndLabelsWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AutoDupTreeWithRuleRootAndLabels;
|
|
}
|
|
a : ^(x=b INT) ;
|
|
b : ID ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoDupTreeWithRuleRootAndListLabels;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoDupTreeWithRuleRootAndListLabelsWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AutoDupTreeWithRuleRootAndListLabels;
|
|
}
|
|
a : ^(x+=b y+=c) ;
|
|
b : ID ;
|
|
c : INT ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar AutoDupNestedTree;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : x=ID y=ID INT -> ^($x ^($y INT));
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar AutoDupNestedTreeWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=AutoDupNestedTree;
|
|
}
|
|
a : ^(ID ^(ID INT))
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar Delete;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar DeleteWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=Delete;
|
|
}
|
|
a : ID ->
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar SetMatchNoRewrite;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar SetMatchNoRewriteWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=SetMatchNoRewrite;
|
|
}
|
|
a : b INT;
|
|
b : ID | INT;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar SetOptionalMatchNoRewrite;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar SetOptionalMatchNoRewriteWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=SetOptionalMatchNoRewrite;
|
|
}
|
|
a : (ID|INT)? INT ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar SetMatchNoRewriteLevel2;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : x=ID INT -> ^($x INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar SetMatchNoRewriteLevel2Walker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=SetMatchNoRewriteLevel2;
|
|
}
|
|
a : ^(ID (ID | INT) ) ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar SetMatchNoRewriteLevel2Root;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : x=ID INT -> ^($x INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar SetMatchNoRewriteLevel2RootWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=SetMatchNoRewriteLevel2Root;
|
|
}
|
|
a : ^((ID | INT) INT) ;
|
|
END
|
|
|
|
inline_grammar( <<-END )
|
|
grammar RewriteModeCombinedRewriteAndAuto;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT) | INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-END )
|
|
tree grammar RewriteModeCombinedRewriteAndAutoTree;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=RewriteModeCombinedRewriteAndAuto;
|
|
rewrite=true;
|
|
}
|
|
a : ^(ID INT) -> ^(ID["ick"] INT)
|
|
| INT // leaves it alone, returning $a.start
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteModeFlatTree;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ID INT | INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteModeFlatTreeWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=RewriteModeFlatTree;
|
|
rewrite=true;
|
|
}
|
|
s : ID a ;
|
|
a : INT -> INT["1"]
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteModeChainRuleFlatTree;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT -> ID INT | INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteModeChainRuleFlatTreeWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleFlatTree; rewrite=true;}
|
|
s : a ;
|
|
a : b ;
|
|
b : ID INT -> INT ID
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteModeChainRuleTree;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT -> ^(ID INT) ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteModeChainRuleTreeWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree; rewrite=true;}
|
|
s : a ;
|
|
a : b ; // a.tree must become b.tree
|
|
b : ^(ID INT) -> INT
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteModeChainRuleTree2;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT -> ^(ID INT) ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteModeChainRuleTree2Walker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree2; rewrite=true;}
|
|
tokens { X; }
|
|
s : a* b ; // only b contributes to tree, but it's after a*; s.tree = b.tree
|
|
a : X ;
|
|
b : ^(ID INT) -> INT
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteModeChainRuleTree3;
|
|
options {language=Ruby; output=AST;}
|
|
a : 'boo' ID INT -> 'boo' ^(ID INT) ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteModeChainRuleTree3Walker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree3; rewrite=true;}
|
|
tokens { X; }
|
|
s : 'boo' a* b ; // don't reset s.tree to b.tree due to 'boo'
|
|
a : X ;
|
|
b : ^(ID INT) -> INT
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteModeChainRuleTree4;
|
|
options {language=Ruby; output=AST;}
|
|
a : 'boo' ID INT -> ^('boo' ^(ID INT)) ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteModeChainRuleTree4Walker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree4; rewrite=true;}
|
|
tokens { X; }
|
|
s : ^('boo' a* b) ; // don't reset s.tree to b.tree due to 'boo'
|
|
a : X ;
|
|
b : ^(ID INT) -> INT
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteModeChainRuleTree5;
|
|
options {language=Ruby; output=AST;}
|
|
a : 'boo' ID INT -> ^('boo' ^(ID INT)) ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteModeChainRuleTree5Walker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteModeChainRuleTree5; rewrite=true;}
|
|
tokens { X; }
|
|
s : ^(a b) ; // s.tree is a.tree
|
|
a : 'boo' ;
|
|
b : ^(ID INT) -> INT
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteOfRuleRef;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT -> ID INT | INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteOfRuleRefWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRef; rewrite=true;}
|
|
s : a -> a ;
|
|
a : ID INT -> ID INT ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteOfRuleRefRoot;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT INT -> ^(INT ^(ID INT));
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteOfRuleRefRootWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefRoot; rewrite=true;}
|
|
s : ^(a ^(ID INT)) -> a ;
|
|
a : INT ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteOfRuleRefRootLabeled;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT INT -> ^(INT ^(ID INT));
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteOfRuleRefRootLabeledWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefRootLabeled; rewrite=true;}
|
|
s : ^(label=a ^(ID INT)) -> a ;
|
|
a : INT ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteOfRuleRefRootListLabeled;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT INT -> ^(INT ^(ID INT));
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteOfRuleRefRootListLabeledWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefRootListLabeled; rewrite=true;}
|
|
s : ^(label+=a ^(ID INT)) -> a ;
|
|
a : INT ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteOfRuleRefChild;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT -> ^(ID ^(INT INT));
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteOfRuleRefChildWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefChild; rewrite=true;}
|
|
s : ^(ID a) -> a ;
|
|
a : ^(INT INT) ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteOfRuleRefLabel;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT -> ^(ID ^(INT INT));
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteOfRuleRefLabelWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefLabel; rewrite=true;}
|
|
s : ^(ID label=a) -> a ;
|
|
a : ^(INT INT) ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteOfRuleRefListLabel;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT -> ^(ID ^(INT INT));
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteOfRuleRefListLabelWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=RewriteOfRuleRefListLabel; rewrite=true;}
|
|
s : ^(ID label+=a) -> a ;
|
|
a : ^(INT INT) ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar RewriteModeWithPredicatedRewrites;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID["root"] ^(ID INT)) | INT -> ^(ID["root"] INT) ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar RewriteModeWithPredicatedRewritesWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=RewriteModeWithPredicatedRewrites;
|
|
rewrite=true;
|
|
}
|
|
s : ^(ID a) {
|
|
# self.buf += $s.start.inspect
|
|
};
|
|
a : ^(ID INT) -> {true}? ^(ID["ick"] INT)
|
|
-> INT
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar WildcardSingleNode;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID["root"] INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar WildcardSingleNodeWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=WildcardSingleNode;
|
|
}
|
|
s : ^(ID c=.) -> $c
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar WildcardUnlabeledSingleNode;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID INT -> ^(ID INT);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar WildcardUnlabeledSingleNodeWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardUnlabeledSingleNode;}
|
|
s : ^(ID .) -> ID
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar WildcardListLabel;
|
|
options {language=Ruby; output=AST;}
|
|
a : INT INT INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar WildcardListLabelWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardListLabel;}
|
|
s : (c+=.)+ -> $c+
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar WildcardListLabel2;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree;}
|
|
a : x=INT y=INT z=INT -> ^($x ^($y $z) ^($y $z));
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar WildcardListLabel2Walker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardListLabel2; rewrite=true;}
|
|
s : ^(INT (c+=.)+) -> $c+
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar WildcardGrabsSubtree;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID x=INT y=INT z=INT -> ^(ID[\"root\"] ^($x $y $z));
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar WildcardGrabsSubtreeWalker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardGrabsSubtree;}
|
|
s : ^(ID c=.) -> $c
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
grammar WildcardGrabsSubtree2;
|
|
options {language=Ruby; output=AST;}
|
|
a : ID x=INT y=INT z=INT -> ID ^($x $y $z);
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-'END' )
|
|
tree grammar WildcardGrabsSubtree2Walker;
|
|
options {language=Ruby; output=AST; ASTLabelType=CommonTree; tokenVocab=WildcardGrabsSubtree2;}
|
|
s : ID c=. -> $c
|
|
;
|
|
END
|
|
|
|
inline_grammar( <<-END )
|
|
grammar CombinedRewriteAndAuto;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT) | INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-END )
|
|
tree grammar CombinedRewriteAndAutoWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=CombinedRewriteAndAuto;
|
|
}
|
|
a : ^(ID INT) -> ^(INT ID) | INT;
|
|
END
|
|
|
|
inline_grammar( <<-END )
|
|
grammar RewriteModeCombinedRewriteAndAuto;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
}
|
|
a : ID INT -> ^(ID INT) | INT ;
|
|
ID : 'a'..'z'+ ;
|
|
INT : '0'..'9'+;
|
|
WS : (' '|'\\n') {$channel=HIDDEN;} ;
|
|
END
|
|
|
|
inline_grammar( <<-END )
|
|
tree grammar RewriteModeCombinedRewriteAndAutoWalker;
|
|
options {
|
|
language=Ruby;
|
|
output=AST;
|
|
ASTLabelType=CommonTree;
|
|
tokenVocab=RewriteModeCombinedRewriteAndAuto;
|
|
rewrite=true;
|
|
}
|
|
a : ^(ID INT) -> ^(ID["ick"] INT)
|
|
| INT // leaves it alone, returning $a.start
|
|
;
|
|
END
|
|
|
|
example "flat list" do
|
|
lexer = FlatList::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = FlatList::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = FlatListWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "34 abc"
|
|
end
|
|
|
|
example "simple tree" do
|
|
lexer = SimpleTree::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = SimpleTree::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = SimpleTreeWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(34 abc)"
|
|
end
|
|
|
|
example "combined rewrite and auto" do
|
|
lexer = CombinedRewriteAndAuto::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = CombinedRewriteAndAuto::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = CombinedRewriteAndAutoWalker::TreeParser.new( nodes )
|
|
result = walker.a.tree
|
|
result.inspect.should == '(34 abc)'
|
|
lexer = CombinedRewriteAndAuto::Lexer.new( "34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = CombinedRewriteAndAuto::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = CombinedRewriteAndAutoWalker::TreeParser.new( nodes )
|
|
result = walker.a.tree
|
|
result.inspect.should == '34'
|
|
end
|
|
|
|
example "avoid dup" do
|
|
lexer = AvoidDup::Lexer.new( "abc" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AvoidDup::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AvoidDupWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(abc abc)"
|
|
end
|
|
|
|
example "loop" do
|
|
lexer = Loop::Lexer.new( "a b c 3 4 5" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = Loop::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = LoopWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "3 4 5 a b c"
|
|
end
|
|
|
|
example "auto dup" do
|
|
lexer = AutoDup::Lexer.new( "abc" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoDup::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoDupWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "abc"
|
|
end
|
|
|
|
example "auto dup rule" do
|
|
lexer = AutoDupRule::Lexer.new( "a 1" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoDupRule::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoDupRuleWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "a 1"
|
|
end
|
|
|
|
example "auto wildcard" do
|
|
lexer = AutoWildcard::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoWildcard::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoWildcardWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "abc 34"
|
|
end
|
|
|
|
example "auto wildcard2" do
|
|
lexer = AutoWildcard2::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoWildcard2::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoWildcard2Walker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(abc 34)"
|
|
end
|
|
|
|
example "auto wildcard with label" do
|
|
lexer = AutoWildcardWithLabel::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoWildcardWithLabel::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoWildcardWithLabelWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "abc 34"
|
|
end
|
|
|
|
example "auto wildcard with list label" do
|
|
lexer = AutoWildcardWithListLabel::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoWildcardWithListLabel::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoWildcardWithListLabelWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "abc 34"
|
|
end
|
|
|
|
example "auto dup multiple" do
|
|
lexer = AutoDupMultiple::Lexer.new( "a b 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoDupMultiple::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoDupMultipleWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "a b 3"
|
|
end
|
|
|
|
example "auto dup tree" do
|
|
lexer = AutoDupTree::Lexer.new( "a 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoDupTree::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoDupTreeWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(a 3)"
|
|
end
|
|
|
|
example "auto dup tree with labels" do
|
|
lexer = AutoDupTreeWithLabels::Lexer.new( "a 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoDupTreeWithLabels::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoDupTreeWithLabelsWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(a 3)"
|
|
end
|
|
|
|
example "auto dup tree with list labels" do
|
|
lexer = AutoDupTreeWithListLabels::Lexer.new( "a 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoDupTreeWithListLabels::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoDupTreeWithListLabelsWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(a 3)"
|
|
end
|
|
|
|
example "auto dup tree with rule root" do
|
|
lexer = AutoDupTreeWithRuleRoot::Lexer.new( "a 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoDupTreeWithRuleRoot::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoDupTreeWithRuleRootWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(a 3)"
|
|
end
|
|
|
|
example "auto dup tree with rule root and labels" do
|
|
lexer = AutoDupTreeWithRuleRootAndLabels::Lexer.new( "a 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoDupTreeWithRuleRootAndLabels::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoDupTreeWithRuleRootAndLabelsWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(a 3)"
|
|
end
|
|
|
|
example "auto dup tree with rule root and list labels" do
|
|
lexer = AutoDupTreeWithRuleRootAndListLabels::Lexer.new( "a 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoDupTreeWithRuleRootAndListLabels::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoDupTreeWithRuleRootAndListLabelsWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(a 3)"
|
|
end
|
|
|
|
example "auto dup nested tree" do
|
|
lexer = AutoDupNestedTree::Lexer.new( "a b 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = AutoDupNestedTree::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = AutoDupNestedTreeWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(a (b 3))"
|
|
end
|
|
|
|
example "delete" do
|
|
lexer = Delete::Lexer.new( "abc" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = Delete::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = DeleteWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == ""
|
|
end
|
|
|
|
example "set match no rewrite" do
|
|
lexer = SetMatchNoRewrite::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = SetMatchNoRewrite::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = SetMatchNoRewriteWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "abc 34"
|
|
end
|
|
|
|
example "set optional match no rewrite" do
|
|
lexer = SetOptionalMatchNoRewrite::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = SetOptionalMatchNoRewrite::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = SetOptionalMatchNoRewriteWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "abc 34"
|
|
end
|
|
|
|
example "set match no rewrite level2" do
|
|
lexer = SetMatchNoRewriteLevel2::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = SetMatchNoRewriteLevel2::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = SetMatchNoRewriteLevel2Walker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(abc 34)"
|
|
end
|
|
|
|
example "set match no rewrite level2 root" do
|
|
lexer = SetMatchNoRewriteLevel2Root::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = SetMatchNoRewriteLevel2Root::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = SetMatchNoRewriteLevel2RootWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(abc 34)"
|
|
end
|
|
|
|
example "rewrite mode combined rewrite and auto" do
|
|
|
|
parser_test = proc do |input, expected_output|
|
|
lexer = RewriteModeCombinedRewriteAndAuto::Lexer.new( input )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteModeCombinedRewriteAndAuto::Parser.new( tokens )
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteModeCombinedRewriteAndAutoWalker::TreeParser.new( nodes )
|
|
result = walker.a
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == expected_output
|
|
end
|
|
|
|
parser_test[ 'abc 34', '(ick 34)' ]
|
|
parser_test[ '34', '34' ]
|
|
end
|
|
|
|
example "rewrite mode flat tree" do
|
|
lexer = RewriteModeFlatTree::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteModeFlatTree::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteModeFlatTreeWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "abc 1"
|
|
end
|
|
|
|
example "rewrite mode chain rule flat tree" do
|
|
lexer = RewriteModeChainRuleFlatTree::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteModeChainRuleFlatTree::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteModeChainRuleFlatTreeWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "34 abc"
|
|
end
|
|
|
|
example "rewrite mode chain rule tree" do
|
|
lexer = RewriteModeChainRuleTree::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteModeChainRuleTree::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteModeChainRuleTreeWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "34"
|
|
end
|
|
|
|
example "rewrite mode chain rule tree2" do
|
|
lexer = RewriteModeChainRuleTree2::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteModeChainRuleTree2::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteModeChainRuleTree2Walker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "34"
|
|
end
|
|
|
|
example "rewrite mode chain rule tree3" do
|
|
lexer = RewriteModeChainRuleTree3::Lexer.new( "boo abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteModeChainRuleTree3::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteModeChainRuleTree3Walker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "boo 34"
|
|
end
|
|
|
|
example "rewrite mode chain rule tree4" do
|
|
lexer = RewriteModeChainRuleTree4::Lexer.new( "boo abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteModeChainRuleTree4::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteModeChainRuleTree4Walker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(boo 34)"
|
|
end
|
|
|
|
example "rewrite mode chain rule tree5" do
|
|
lexer = RewriteModeChainRuleTree5::Lexer.new( "boo abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteModeChainRuleTree5::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteModeChainRuleTree5Walker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(boo 34)"
|
|
end
|
|
|
|
example "rewrite of rule ref" do
|
|
lexer = RewriteOfRuleRef::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteOfRuleRef::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteOfRuleRefWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "abc 34"
|
|
end
|
|
|
|
example "rewrite of rule ref root" do
|
|
lexer = RewriteOfRuleRefRoot::Lexer.new( "abc 12 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteOfRuleRefRoot::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteOfRuleRefRootWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(12 (abc 34))"
|
|
end
|
|
|
|
example "rewrite of rule ref root labeled" do
|
|
lexer = RewriteOfRuleRefRootLabeled::Lexer.new( "abc 12 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteOfRuleRefRootLabeled::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteOfRuleRefRootLabeledWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(12 (abc 34))"
|
|
end
|
|
|
|
example "rewrite of rule ref root list labeled" do
|
|
lexer = RewriteOfRuleRefRootListLabeled::Lexer.new( "abc 12 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteOfRuleRefRootListLabeled::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteOfRuleRefRootListLabeledWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(12 (abc 34))"
|
|
end
|
|
|
|
example "rewrite of rule ref child" do
|
|
lexer = RewriteOfRuleRefChild::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteOfRuleRefChild::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteOfRuleRefChildWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(34 34)"
|
|
end
|
|
|
|
example "rewrite of rule ref label" do
|
|
lexer = RewriteOfRuleRefLabel::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteOfRuleRefLabel::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteOfRuleRefLabelWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(34 34)"
|
|
end
|
|
|
|
example "rewrite of rule ref list label" do
|
|
lexer = RewriteOfRuleRefListLabel::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteOfRuleRefListLabel::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteOfRuleRefListLabelWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(34 34)"
|
|
end
|
|
|
|
example "rewrite mode with predicated rewrites" do
|
|
lexer = RewriteModeWithPredicatedRewrites::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = RewriteModeWithPredicatedRewrites::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = RewriteModeWithPredicatedRewritesWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(root (ick 34))"
|
|
end
|
|
|
|
example "wildcard single node" do
|
|
lexer = WildcardSingleNode::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = WildcardSingleNode::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = WildcardSingleNodeWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "34"
|
|
end
|
|
|
|
example "wildcard unlabeled single node" do
|
|
lexer = WildcardUnlabeledSingleNode::Lexer.new( "abc 34" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = WildcardUnlabeledSingleNode::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = WildcardUnlabeledSingleNodeWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "abc"
|
|
end
|
|
|
|
example "wildcard grabs subtree" do
|
|
lexer = WildcardGrabsSubtree::Lexer.new( "abc 1 2 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = WildcardGrabsSubtree::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = WildcardGrabsSubtreeWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(1 2 3)"
|
|
end
|
|
|
|
example "wildcard grabs subtree2" do
|
|
lexer = WildcardGrabsSubtree2::Lexer.new( "abc 1 2 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = WildcardGrabsSubtree2::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = WildcardGrabsSubtree2Walker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(1 2 3)"
|
|
end
|
|
|
|
example "wildcard list label" do
|
|
lexer = WildcardListLabel::Lexer.new( "1 2 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = WildcardListLabel::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = WildcardListLabelWalker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "1 2 3"
|
|
end
|
|
|
|
example "wildcard list label2" do
|
|
lexer = WildcardListLabel2::Lexer.new( "1 2 3" )
|
|
tokens = ANTLR3::CommonTokenStream.new( lexer )
|
|
parser = WildcardListLabel2::Parser.new( tokens )
|
|
|
|
result = parser.a
|
|
nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
|
|
nodes.token_stream = tokens
|
|
walker = WildcardListLabel2Walker::TreeParser.new( nodes )
|
|
result = walker.s
|
|
stree = result.tree.nil? ? '' : result.tree.inspect
|
|
stree.should == "(2 3) (2 3)"
|
|
end
|
|
|
|
end
|