1#!/usr/bin/ruby
2# encoding: utf-8
3
4require 'antlr3/test/functional'
5
6class TestImportedGrammars < ANTLR3::Test::Functional
7  
8  def load( grammar )
9    grammar.compile
10    $:.unshift( grammar.output_directory ) unless $:.include?( grammar.output_directory )
11    for file in grammar.target_files( false )
12      require File.basename( file, '.rb' )
13    end
14  end
15  
16  example 'delegator invokes delegate rule' do
17    inline_grammar( <<-'END' )
18      parser grammar DIDRSlave;
19      options { language=Ruby; }
20      @members {
21        def capture(t)
22          @didr_master.capture(t)
23        end
24      }
25      a : B { capture("S.a") } ;
26    END
27    load inline_grammar( <<-'END' )
28      grammar DIDRMaster;
29      options { language=Ruby; }
30      import DIDRSlave;
31      
32      @members { include ANTLR3::Test::CaptureOutput }
33      
34      s : a ;
35      B : 'b' ;
36      WS : (' '|'\n') { skip() } ;
37    END
38    
39    lexer = DIDRMaster::Lexer.new( 'b' )
40    tokens = ANTLR3::CommonTokenStream.new( lexer )
41    parser = DIDRMaster::Parser.new( tokens )
42    parser.s
43    parser.output.should == 'S.a'
44  end
45  
46  example 'delegator invokes delegate rule with args' do
47    inline_grammar( <<-'END' )
48      parser grammar Slave2;
49      options {
50          language=Ruby;
51      }
52      @members {
53        def capture(t)
54          @master_2.capture(t)
55        end
56      }
57      a[x] returns [y] : B {capture("S.a"); $y="1000";} ;
58    END
59    load inline_grammar( <<-'END' )
60      grammar Master2;
61      options {language=Ruby;}
62      import Slave2;
63      
64      @members { include ANTLR3::Test::CaptureOutput }
65      
66      s : label=a[3] {capture($label.y)} ;
67      B : 'b' ;
68      WS : (' '|'\n') {skip} ;
69    END
70    lexer = Master2::Lexer.new( 'b' )
71    tokens = ANTLR3::CommonTokenStream.new( lexer )
72    parser = Master2::Parser.new( tokens )
73    parser.s
74    parser.output.should == 'S.a1000'
75  end
76  
77  example "delegator accesses delegate members" do
78    inline_grammar( <<-'END' )
79      parser grammar Slave3;
80      options {
81          language=Ruby;
82      }
83      @members {
84        def capture(t)
85          @master_3.capture(t)
86        end
87        
88        def whatevs
89          capture("whatevs")
90        end
91      }
92      a : B ;
93    END
94    load inline_grammar( <<-'END' )
95      grammar Master3;
96      options {
97        language=Ruby;
98      }
99      import Slave3;
100      @members { include ANTLR3::Test::CaptureOutput }
101      
102      s : 'b' {@slave_3.whatevs} ;
103      WS : (' '|'\n') {skip()} ;
104    END
105    
106    parser = Master3::Parser.new( Master3::Lexer.new( 'b' ) )
107    parser.s
108    parser.output.should == 'whatevs'
109  end
110  
111  example "delegator invokes first version of delegate rule" do
112    inline_grammar( <<-'END' )
113      parser grammar Slave4A;
114      options {
115          language=Ruby;
116      }
117      @members {
118        def capture(t)
119          @master_4.capture(t)
120        end
121      }
122      a : b {capture("S.a")} ;
123      b : B ;
124    END
125    inline_grammar( <<-'END' )
126      parser grammar Slave4B;
127      options {
128        language=Ruby;
129      }
130      @members {
131        def capture(t)
132          @master_4.capture(t)
133        end
134      }
135      a : B {capture("T.a")} ;
136    END
137    load inline_grammar( <<-'END' )
138      grammar Master4;
139      options {
140        language=Ruby;
141      }
142      import Slave4A, Slave4B;
143      @members { include ANTLR3::Test::CaptureOutput }
144      s : a ;
145      B : 'b' ;
146      WS : (' '|'\n') {skip} ;
147    END
148    
149    parser = Master4::Parser.new( Master4::Lexer.new( 'b' ) )
150    parser.s
151    parser.output.should == 'S.a'
152  end
153  
154  example "delegates see same token type" do
155    inline_grammar( <<-'END' )
156      parser grammar Slave5A; // A, B, C token type order
157      options {
158        language=Ruby;
159      }
160      tokens { A; B; C; }
161      @members {
162        def capture(t)
163          @master_5.capture(t)
164        end
165      }
166      x : A {capture("S.x ")} ;
167    END
168    inline_grammar( <<-'END' )
169      parser grammar Slave5B;
170      options {
171        language=Ruby;
172      }
173      tokens { C; B; A; } /// reverse order
174      @members {
175        def capture(t)
176          @master_5.capture(t)
177        end
178      }
179      y : A {capture("T.y")} ;
180    END
181    load inline_grammar( <<-'END' )
182      grammar Master5;
183      options {
184          language=Ruby;
185      }
186      import Slave5A, Slave5B;
187      @members { include ANTLR3::Test::CaptureOutput }
188      s : x y ; // matches AA, which should be "aa"
189      B : 'b' ; // another order: B, A, C
190      A : 'a' ;
191      C : 'c' ;
192      WS : (' '|'\n') {skip} ;
193    END
194    
195    lexer = Master5::Lexer.new( 'aa' )
196    tokens = ANTLR3::CommonTokenStream.new( lexer )
197    parser = Master5::Parser.new( tokens )
198    parser.s
199    parser.output.should == 'S.x T.y'
200  end
201  
202  example "delegator rule overrides delegate" do
203    inline_grammar( <<-'END' )
204      parser grammar Slave6;
205      options {
206          language=Ruby;
207      }
208      @members {
209        def capture(t)
210          @master_6.capture(t)
211        end
212      }
213      a : b {capture("S.a")} ;
214      b : B ;
215    END
216    load inline_grammar( <<-'END' )
217      grammar Master6;
218      options { language=Ruby; }
219      import Slave6;
220      @members { include ANTLR3::Test::CaptureOutput }
221      b : 'b'|'c' ;
222      WS : (' '|'\n') {skip} ;
223    END
224    
225    parser = Master6::Parser.new( Master6::Lexer.new( 'c' ) )
226    parser.a
227    parser.output.should == 'S.a'
228  end
229  
230  example "lexer delegator invokes delegate rule" do
231    inline_grammar( <<-'END' )
232      lexer grammar Slave7;
233      options {
234        language=Ruby;
235      }                                                                       
236      @members {
237        def capture(t)
238          @master_7.capture(t)
239        end
240      }
241      A : 'a' {capture("S.A ")} ;
242      C : 'c' ;
243    END
244    load inline_grammar( <<-'END' )
245      lexer grammar Master7;
246      options {
247        language=Ruby;
248      }
249      import Slave7;
250      @members { include ANTLR3::Test::CaptureOutput }
251      B : 'b' ;
252      WS : (' '|'\n') {skip} ;
253    END
254    
255    lexer = Master7::Lexer.new( 'abc' )
256    lexer.map { |tk| lexer.capture( tk.text ) }
257    lexer.output.should == 'S.A abc'
258  end
259  
260  example "lexer delegator rule overrides delegate" do
261    inline_grammar( <<-'END' )
262      lexer grammar Slave8;
263      options {language=Ruby;}
264      @members {
265        def capture(t)
266          @master_8.capture(t)
267        end
268      }
269      A : 'a' {capture("S.A")} ;
270    END
271    load inline_grammar( <<-'END' )
272      lexer grammar Master8;
273      options {language=Ruby;}
274      import Slave8;
275      @members { include ANTLR3::Test::CaptureOutput }
276      A : 'a' {capture("M.A ")} ;
277      WS : (' '|'\n') {skip} ;
278    END
279    
280    lexer = Master8::Lexer.new( 'a' )
281    lexer.map { |tk| lexer.capture( tk.text ) }
282    lexer.output.should == 'M.A a'
283  end
284
285  example "delegator rule with syntactic predicates" do
286    inline_grammar( <<-'END' )
287      parser grammar Slave9;
288      options { language=Ruby; }
289      @members {
290        def capture(t)
291          @master_9.capture(t)
292        end
293      }
294      a : b c;
295      c : ('c' 'b')=> 'c' 'b' { capture("(cb)") }
296        | ('c' 'c')=> 'c'
297        ;
298    END
299    load inline_grammar( <<-'END' )
300      grammar Master9;
301      options { language=Ruby; }
302      import Slave9;
303      @members { include ANTLR3::Test::CaptureOutput }
304      b : ('b' 'b')=> 'b' 'b'
305        | ('b' 'c')=> 'b' {capture("(bc)")}
306        ;
307      WS : (' '|'\n') {skip} ;
308    END
309    
310    parser = Master9::Parser.new( Master9::Lexer.new( 'bcb' ) )
311    parser.a
312    parser.output.should == '(bc)(cb)'
313  end
314  
315  example "lots of imported lexers" do
316    inline_grammar( <<-'END' )
317      lexer grammar SlaveOfSlaves;
318      options { language=Ruby; }
319      
320      INTEGER: ('+'|'-')? DIGITS;
321      FLOAT: INTEGER '.' DIGITS (('e'|'E') INTEGER)?;
322      fragment DIGITS: ('0'..'9')+;
323    END
324    inline_grammar( <<-'END' )
325      lexer grammar FirstSlave;
326      options { language=Ruby; }
327      
328      import SlaveOfSlaves;
329      
330      ID: ('A'..'Z')+;
331      OPS: '+' | '-' | '*' | '/';
332    END
333    inline_grammar( <<-'END' )
334      lexer grammar SecondSlave;
335      options { language=Ruby; }
336      
337      INT: ('0'..'9')+;
338      ID: ('a'..'z'|'A'..'Z'|'_')+;
339    END
340    load inline_grammar( <<-'END' )
341      lexer grammar MasterOfAll;
342      options { language=Ruby; }
343      
344      import FirstSlave, SecondSlave;
345      
346      ID: ('a'..'z'|'A'..'Z'|'_')+;
347      WS: ' '+ { $channel=HIDDEN };
348    END
349    
350    MasterOfAll::Lexer.master_grammars.should == []
351    MasterOfAll::Lexer.imported_grammars.should == Set[ :FirstSlave, :SecondSlave ]
352    MasterOfAll::Lexer.master.should be_nil
353    
354    MasterOfAll::FirstSlave.master_grammars.should == [ :MasterOfAll ]
355    MasterOfAll::FirstSlave.imported_grammars.should == Set[ :SlaveOfSlaves ]
356    MasterOfAll::FirstSlave.master.should == :MasterOfAll
357    
358    MasterOfAll::SecondSlave.master_grammars.should == [ :MasterOfAll ]
359    MasterOfAll::SecondSlave.imported_grammars.should == Set[ ]
360    MasterOfAll::SecondSlave.master.should == :MasterOfAll
361    
362    MasterOfAll::FirstSlave::SlaveOfSlaves.master_grammars.should == [ :MasterOfAll, :FirstSlave ]
363    MasterOfAll::FirstSlave::SlaveOfSlaves.imported_grammars.should == Set[ ]
364    MasterOfAll::FirstSlave::SlaveOfSlaves.master.should == :FirstSlave
365    
366    master = MasterOfAll::Lexer.new( 'blah de blah' )
367    master.should respond_to :first_slave
368    master.should respond_to :second_slave
369    master.first_slave.should respond_to :slave_of_slaves
370    master.first_slave.should respond_to :master_of_all
371    master.first_slave.slave_of_slaves.should respond_to :first_slave
372    master.first_slave.slave_of_slaves.should respond_to :master_of_all
373    dels = master.each_delegate.map { |d| d }
374    dels.should have( 2 ).things
375    dels.should include master.first_slave
376    dels.should include master.second_slave
377  end
378  
379end
380