rubylexer 0.7.0 → 0.7.1

data/test/data/s.rb

@@ -1,6 +1,68 @@
 #string content tokens move around in this file; its not really a problem
 
 if false 
+p %w[\ .]
+p %w[\\ .]
+p %W[\ .]
+p %W[\\ .]
+
+p %W[\  
+] #ruby interprets this one as a single (totally unescaped) newline,
+  #but i suspect that might be a bug.
+
+p "\
+"
+
+p '\
+'
+
+p /\
+/
+
+p `\
+`
+
+p %w[\
+]
+
+p %[\
+]
+
+p "
+
+"
+
+p %{
+
+}
+
+  p %W(\s .)
+
+  p %W(\ .)
+  p %W(\\ .)
+  p %w(\ .)
+  p %w(\\ .)
+  p %w(\\
+.)
+
+  p %W(\s .)
+  p  %r/ \d/
+  p %w[\ ]
+  p %W[\ ]
+
+PROTOCOLS=%w[http ftp]
+EXTENSIONS=%w[tar zip rb tgz tbz2 tbz]
+EXTRA_EXTENSIONS=%w[gz bz2]
+TARBALL=%r<
+  \A(?:#{PROTOCOLS.join('|')})://
+  (?:[^/]+/)+
+  (.*)
+  [_-](.*)
+  \.(?:#{EXTENSIONS.join('|')})
+  (?:\.(?:#{EXTRA_EXTENSIONS.join'|'}))\Z
+>ix
+
+
       t=0
       t ?'t':0
       "#{t ?'t':0}"
@@ -141,19 +203,42 @@ FOO
 p "\
 #{foo}"
 
+p "#{foo}#{bar}"
+
+p "
+#{compile_body}\
+#{outvar}
+"
+
+p "
+#{a}\
+#{b}\
+#{c}\
+#{d}\
+#{e}\
+#{f}\
+#{g}\
+#{h}\
+"
+
 p <<end
 #{compile_body}\
 #{outvar}
 end
 
+p <<end
+#{a}\
+#{b}\
+#{c}\
+#{d}\
+#{e}\
+#{f}\
+#{g}\
+#{h}
+end
 
 
 
-p "#{<<foobar3}"
-bim
-baz
-bof
-foobar3
 
 p "#{<<foobar2
 bim
@@ -163,22 +248,6 @@ foobar2
 }"
 
 
-p <<one ; p "#{<<two}"
-1111111111111111
-fdsgdfgdsfffff
-one
-2222222222222222
-sdfasdfasdfads
-two
-
-p "#{<<foobar1.each('|'){|s| '\nthort: '+s}
-jbvd|g4543ghb|!@G$dfsd|fafr|e
-|s4e5rrwware|BBBBB|*&^(*&^>"PMK:njs;d|
-
-foobar1
-}"
-
-
 p <<""
 foo
 

data/test/data/simple.rb

@@ -0,0 +1 @@
+p simple

data/test/data/simple_dos.rb

@@ -0,0 +1 @@
+p simple

data/test/data/stanzas.rb

@@ -0,0 +1,1194 @@
+def x; yield end #this must be first!!!!
+#the purpose of x{...} is to prevent the enclosed code from
+#modifying the list of known local variables. it may be omitted
+#in cases where it is known that no local vars are defined.
+
+module SR
+def SelfReferencing
+#old name alias
+end
+def SelfReferencing #old name alias
+end
+def SelfReferencing#old name alias
+end
+def SelfReferencing;end#old name alias
+end
+
+p <<Class
+  zzzz
+Class
+
+p(String <<Class)
+sgsdfgf
+  Class
+Class
+
+def foo; end
+undef
+foo
+
+module Defined_p_syntax_tests
+  def self.defined?(foo) :baz end  #should be methname
+  def defined?(foo) :bar end  #should be methname
+  def ameth
+    p(defined? 44)  #should be keyword
+    p(self.defined? 44) #should be methname
+  end
+end
+
+proc{
+p /$/  #regexp
+p /=$/ #operator
+p /$/  #operator
+}
+
+proc{
+p %=b=
+2
+p %(1)
+}
+
+proc{
+p *=5
+p %(1)
+}
+
+proc{
+p &nil
+p &=1
+p %(1)
+}
+
+
+
+=begin
+=end
+
+p <<p
+\
+p
+p
+
+p <<'p'
+\
+p
+p
+
+p <<p
+\n\t\r\v\\
+p
+
+p <<'p'
+\n\t\r\v\\
+p
+
+p <<'p'
+\n\t\r\v\
+p
+p
+
+p <<p
+\
+sdfgd
+p
+
+
+p <<END
+dfgdfg
+END
+
+p <<'END'
+hgjfg
+END
+
+x{
+  a,b,c,(d,e)=1,2,3,[4,5]
+  p a %(4)
+  p c %(4)
+  p d %(4)
+  p e %(4)
+}
+
+def printem___1 a
+   a
+end
+
+class F0000; end
+def F0000; end
+
+x{
+  f0000=1
+  def f0000; end
+}
+
+def printem__1 a
+   p(a +77)
+end
+
+def printem_1 a,b
+   p(a +77)
+   p(b +77)
+end
+
+def printem1 a,b,c
+   p(a +77)
+   p(b +77)
+   p(c +77)
+end
+
+def printem10 a,b,c,d,e,f
+   p(a +77)
+   p(b +77)
+   p(c +77)
+   p(d +77)
+   p(e +77)
+   p(f +77)
+end
+
+def printem100 a,b,c,d,e,f,*g,&h
+   p(a +77)
+   p(b +77)
+   p(c +77)
+   p(d +77)
+   p(e +77)
+   p(f +77)
+   p(g +77)
+   p(h +77)
+end
+
+ddd="ddd"
+
+#@@ddd=@ddd=$ddd=nil
+def DDD;end
+def ddd2; "asdAds" end
+def (DDD()).foofarendle;end
+def Integer.foofarendle;end
+def @@ddd.foofarendle;  33;end
+def @ddd.foofarendle;  33;end
+def $ddd.foofarendle;  33;end
+def ddd.foofarendle;  33;end
+def ddd2.foofarendle;  33;end
+def (ddd).foofarendle2; end
+def (ddd()).foofarendle2; end
+def (ddd2).foofarendle;end
+def ddd2.foofarendle;end
+
+p(<<-jjj \
+ dsfgdf
+ jjj
+ )
+
+p(<<-jjj \
+ dsfgdf
+ jjj
+ +"dfsdfs"
+ )
+
+p(<<-jjj
+ dsfgdf
+ jjj
+ )
+
+p(<<-jjj +
+ dsfgdf
+ jjj
+ "dfsdfs"
+ )
+
+case 1
+when *[2]: p 1
+else p 2
+end
+
+x{
+  foo bar=>baz
+  bar %(1)
+}
+
+def foo1
+  p (1..10).method(:each)    #implicit parens around the whole thing
+end
+
+def foo2()
+  p((1..10).method(:each))  #explicitly parenthesized... no implicit parens needed
+end
+
+def foo3()
+  p (1..10).method(:each)   #implicit parens around the whole thing
+end
+
+p proc{|
+a,b,(c,d,),e|
+        p a %(1)
+        p b %(2)
+        p c %(3)
+        p d %(4)
+        p e %(5)
+[ a,b,c,d,e]}.call(1,2,[3,4],5)
+
+def ggg(x=nil) p x;9 end
+ (ggg / 1)
+
+
+module Y19  #limit lvar scope
+  a,b,c,(d,e)=1,2,3,[4,5]
+  p a %(4)
+  p c %(4)
+  p d %(4)
+  p e %(4)
+  a=[1,2,3,4,5]
+  def self.g(x=nil); 3 end
+  def a.g=(x) p x end
+  g = 5
+  self.g = 55
+  class<<a
+    def bb=(x) p :bb=, x end
+  end
+  A=a
+  class<<self
+  def aa; :aa end
+  def bb(arg=nil); p :bb; A end
+  alias bbb bb
+  def m; self end
+  def n; self end
+  def +(other) self end
+  def kk; nil end
+  def kk=(foo); nil end
+  end
+  proc{|a[4]|}.call 6
+  proc{|a[b]|}.call 7
+  proc{|a.bb| bb %(9) }.call 9
+  proc{|a[f]| f %(9)  }.call 8
+  proc{|bb(aa).bb| aa %(10) }.call 10
+  proc{|bbb(aa).bb| bbb %(11) }.call 11
+  proc{|t,u,(v,w,x),(y,),z|
+    t %(12)
+    u %(12)
+    v %(12)
+    w %(12)
+    x %(12)
+    y %(12)
+    z %(12)
+  }.call(1,2,[3,4,5],[6],7)
+  proc{|(m).kk,(m+n).kk|
+    m %(13)
+    n %(13)
+    kk %(13)
+  }.call(13,14)
+  proc{|a.g| g %(9)}
+  p a
+end
+
+x {
+  class<<self
+   alias q p
+   alias r p
+   alias s p
+  end
+  p(q,r,s)
+  q %(1)
+  r %(1)
+  s %(1)
+  p (q,r,s)
+  q %(1)
+  r %(1)
+  s %(1)
+}
+
+p true ?
+  1 : 2
+
+class String
+class Class
+end
+end
+
+p(String<<Class)
+p(String<< Class)
+p(String <<Class)
+sgsdfgf
+  Class
+Class
+p(String << Class)
+
+p(String<<-Class)
+p(String<< -Class)
+p(String <<-Class)
+sgsdfgf
+  Class
+Class
+p(String <<-Class)
+sgsdfgf
+Class
+  Class
+Class
+p(String << -Class)
+
+p(String<<- Class)
+p(String<< - Class)
+p(String <<- Class)
+  Class
+Class
+p(String <<- Class)
+Class
+  Class
+Class
+p(String << - Class)
+
+
+
+p <<p
+sdfsfdf^^^^@@@
+p
+
+module M33
+  p="var:"
+  Q="func:"
+  def Q.method_missing(name,*args)
+    self+name.to_s+(args.join' ')
+  end
+  def p.method_missing(name,*args)
+    self+name.to_s+(args.join' ')
+  end
+  def self.p(*a); super; Q end
+  @a=1
+  $a=2
+  p(p~6)
+  p(p ~6)
+  p(p~ 6)
+  p(p ~ 6)
+  p(p*11)
+  p(p *11)
+  p(p* 11)
+  p(p * 11)
+  p(p&proc{})
+  p(p &proc{})
+  p(p& proc{})
+  p(p & proc{})
+  p(p !1)
+#  p(p ?1) #compile error, when p is var
+  p(p ! 1)
+  p(p ? 1 : 6)
+  p(p@a)
+  p(p @a)
+#  p(p@ a)  #wont
+#  p(p @ a) #work
+  p(p#a
+)
+  p(p #a
+)
+  p(p# a
+)
+  p(p # a
+)
+  p(p$a)
+  p(p $a)
+#  p(p$ a)  #wont
+#  p(p $ a) #work
+  p(p%Q{:foo})
+  p(p %Q{:foo})
+  p(p% Q{:foo})
+  p(p % Q{:foo})
+  p(p^6)
+  p(p ^6)
+  p(p^ 6)
+  p(p ^ 6)
+  p(p&7)
+  p(p &proc{7})
+  p(p& 7)
+  p(p & 7)
+  p(p(2))
+  p(p (2))
+  p(p( 2))
+  p(p ( 2))
+  p(p(p))
+  p(p())
+  p(p (p))
+  p(p ())
+  p(p ( p))
+  p(p ( ))
+  p(p( p))
+  p(p( ))
+  p(p)
+  p((p))
+  p(p )
+  p((p ))
+  p((p p))
+  p((p p,p))
+  p((p p))
+  p((p p,p))
+  p(p-0)
+  p(p -0)
+  p(p- 0)
+  p(p - 0)
+  p(p+9)
+  p(p +9)
+  p(p+ 9)
+  p(p + 9)
+  p(p[1])
+  p(p [1])
+  p(p[ 1])
+  p(p [ 1])
+  p(p{1})
+  p(p {1})
+  p(p{ 1})
+  p(p { 1})
+  p(p/1)
+  p(p /22)
+  p(p/ 1)
+  p(p / 22)
+  p(p._)
+  p(p ._)
+  p(p. _)
+  p(p . _)
+  p(false ? p:f)
+  p(false ? p :f)
+  p(false ? p: f)
+  p(false ? p : f)
+  p((p;1))
+  p((p ;1))
+  p((p; 1))
+  p((p ; 1))
+  p(p<1)
+  p(p <1)
+  p(p< 1)
+  p(p < 1)
+  p(p<<1)
+  p(p <<1)
+  p(p<< 1)
+  p(p << 1)
+  p(p'j')
+  p(p 'j')
+  p(p' j')
+  p(p ' j')
+  p(p"k")
+  p(p "k")
+  p(p" k")
+  p(p " k")
+  p(p|4)
+  p(p |4)
+  p(p| 4)
+  p(p | 4)
+  p(p>2)
+  p(p >2)
+  p(p> 2)
+  p(p > 2)
+end
+
+module M34
+  p(p~6)
+  p(p ~6)
+  p(p~ 6)
+  p(p ~ 6)
+  p(p*[1])
+  p(p *[1])
+  p(p* [1])
+  p(p * [1])
+  p(p&proc{})
+  p(p &proc{})
+  p(p& proc{})
+  p(p & proc{})
+  p(p !1)
+  p(p ?1)
+  p(p ! 1)
+  p(p ? 1 : 6)
+  p(p@a)
+  p(p @a)
+#  p(p@ a)  #wont
+#  p(p @ a) #work
+  p(p#a
+)
+  p(p #a
+)
+  p(p# a
+)
+  p(p # a
+)
+  p(p$a)
+  p(p $a)
+#  p(p$ a)  #wont
+#  p(p $ a) #work
+  p(p%Q{:foo})
+  p(p %Q{:foo})
+  p(p% Q{:foo})
+  p(p % Q{:foo})
+  p(p^6)
+  p(p ^6)
+  p(p^ 6)
+  p(p ^ 6)
+  p(p&7)
+  p(p &proc{7})
+  p(p& 7)
+  p(p & 7)
+  p(p(2))
+  p(p (2))
+  p(p( 2))
+  p(p ( 2))
+  p(p(p))
+  p(p())
+  p(p (p))
+  p(p ())
+  p(p ( p))
+  p(p ( ))
+  p(p( p))
+  p(p( ))
+  p(p)
+  p((p))
+  p(p )
+  p((p ))
+  p((p p))
+  p((p p,p))
+  p((p p))
+  p((p p,p))
+  p(p-0)
+  p(p -1)
+  p(p- 0)
+  p(p - 0)
+  p(p+9)
+  p(p +9)
+  p(p+ 9)
+  p(p + 9)
+  p(p[1])
+  p(p [1])
+  p(p[ 1])
+  p(p [ 1])
+  p(p{1})
+  p(p {1})
+  p(p{ 1})
+  p(p { 1})
+  p(p/1)
+  p(p /22/)
+  p(p/ 1)
+  p(p / 22)
+  p(p._)
+  p(p ._)
+  p(p. _)
+  p(p . _)
+  p(p:f)
+  p(p :f)
+  p(false ? p: f)
+  p(false ? p : f)
+  p((p;1))
+  p((p ;1))
+  p((p; 1))
+  p((p ; 1))
+  p(p<1)
+  p(p <1)
+  p(p< 1)
+  p(p < 1)
+  p(p<<1)
+  p(p <<1)
+foobar
+1
+  p(p<< 1)
+  p(p << 1)
+  p(p'j')
+  p(p 'j')
+  p(p' j')
+  p(p ' j')
+  p(p"k")
+  p(p "k")
+  p(p" k")
+  p(p " k")
+  p(p|4)
+  p(p |4)
+  p(p| 4)
+  p(p | 4)
+  p(p>2)
+  p(p >2)
+  p(p> 2)
+  p(p > 2)
+end
+
+x{
+  def bob(x) x end
+  p(bob %(22))
+  for bob in [100] do p(bob %(22)) end
+  p(bob %(22))
+}
+
+x{
+  def %(n) to_s+"%#{n}" end
+  def bill(x) x end
+  p(bill %(22))
+  begin sdjkfsjkdfsd; rescue Object => bill; p(bill %(22)) end  
+  p(bill %(22))
+  undef %
+}
+
+class Fixnum
+  public :`
+  def `(s)
+    print "bq: #{s}\n"
+  end
+end
+69.`('what a world')
+79::`('what a word')
+
+x{
+  a=5
+  p p +5
+  p a +5
+}
+
+class Foou
+ public
+ def [] x=-100,&y; p x; 100 end
+end
+
+p Foou.new.[] <<9    #value
+foobar
+9
+
+x{
+  a0=9
+  p Foou.new.[]a0      #value
+  p Foou.new.[] a0     #value
+}
+
+x{
+  a=b=c=0
+  a ? b:c
+  a ?b:c
+  p(a ? b:c)
+  p(a ?b:c)
+}
+
+x{
+  h={}
+  h.default=:foo
+  p def h.default= v; p @v=v;v end
+  p def (h).default= v; p @v=v;v end
+  p def (h="foobar").default= v; p @v=v;v end
+  p h
+  p h.default=:b
+}
+
+x do
+x, (*y) = [:x, :y, :z]
+p x
+p y
+x, *y = [:x, :y, :z]
+p x
+p y
+x, * = [:x, :y, :z]
+p x
+end
+
+class Foop
+  def Foop.bar a,b
+    p a,b
+  end
+end
+Foop.bar 1,2
+Foop::bar 3,4
+
+
+class Foop
+  def Foop::baz a,b
+    p :baz,a,b
+  end
+end
+Foop.baz 5,6
+Foop::baz 7,8
+
+x{
+      without_creating=widgetname=nil
+      if without_creating && !widgetname #foo
+        fail ArgumentError,
+             "if set 'without_creating' to true, need to define 'widgetname'"
+      end
+}
+
+x{
+#class, module, and def should temporarily hide local variables
+def mopsdfjskdf arg; arg*2 end
+mopsdfjskdf=5
+ class C
+ p mopsdfjskdf %(3)    #calls method
+ end
+module M
+ p mopsdfjskdf %(4)    #calls method
+end
+ def d
+ p mopsdfjskdf %(5)    #calls method
+ end
+p d
+p mopsdfjskdf %(6)     #reads variable
+p proc{mopsdfjskdf %(7)}[] #reads variable
+}
+
+#multiple assignment test
+x {
+  a,b,c,d,e,f,g,h,i,j,k=1,2,3,4,5,6,7,8,9,10,11
+  p(b %(c))
+  p(a %(c))
+  p(k %(c))
+  p(p %(c))
+}
+
+=begin not supported yet
+p "#{<<kekerz}#{"foob"
+zimpler
+kekerz
+}"
+=end
+
+=begin not supported yet
+aaa=<<whatnot; p "#{'uh,yeah'
+gonna take it down, to the nitty-grit
+gonna tell you mother-fuckers why you ain't shit
+cause suckers like you just make me strong
+you been pumpin' that bullshit all day long
+whatnot
+}"
+p aaa
+=end
+
+#test variable creation in string inclusion
+#currently broken because string inclusions
+#are lexed by a separate lexer!
+proc {
+  p "jentawz: #{baz=200}"
+  p( baz %(9))
+}.call
+
+#scope of local variables always includes the here document
+#body if it includes the head
+p %w[well, whaddaya know].map{|j| <<-END }
+#{j #previous j should be local var, not method
+}45634543
+END
+
+=begin not supported yet
+p "#{<<foobar3}"
+bim
+baz
+bof
+foobar3
+=end
+
+x do
+  a,b,* = [1,2,3,4,5,6,7,8]
+  p a,b
+  a,b, = [1,2,3,4,5,6,7,8]
+  p a,b
+  a,b = [1,2,3,4,5,6,7,8]
+  p a,b
+  a,*b = [1,2,3,4,5,6,7,8]
+  p a,b
+  a,b,*c=[1,2,3,4,5,6,7,8]
+  a,b,* c=[1,2,3,4,5,6,7,8]
+end
+
+x {
+  h={:a=>(foo=100)}
+  p( foo %(5))
+}
+
+def foo(a=<<a,b=<<b,c=<<c)
+jfksdkjf
+dkljjkf
+a
+kdljfjkdg
+dfglkdfkgjdf
+dkf
+b
+lkdffdjksadhf
+sdflkdjgsfdkjgsdg
+dsfg;lkdflisgffd
+g
+c
+   a+b+c
+end
+
+
+class AA; class BB; class CC
+FFOO=1
+end end end
+p AA::BB::CC::FFOO
+
+x do
+ method_src = c.compile(template, (HtmlCompiler::AnyData.new)).join("\n") +
+    "\n# generated by PartsTemplate::compile_partstemplate at #{Time.new}\n"
+ rescu -1
+end
+
+  p('rb_out', 'args', <<-'EOL')
+    regsub -all {!} $args {\\!} args
+    regsub -all "{" $args "\\{" args
+    if {[set st [catch {ruby [format "TkCore.callback %%Q!%s!" $args]} ret]] != 0} {
+        return -code $st $ret
+    } {
+        return $ret
+    }
+  EOL
+
+
+def add(*args)
+   self.<<(*args)
+end
+
+
+x{
+  val=%[13,17,22,"hike", ?\s]
+    if val.include? ?\s
+      p val.split.collect{|v| (v)}
+    end
+}
+
+class Hosts
+end
+class DNS < Hosts
+end
+
+
+def ssssss &block
+end
+
+def params_quoted(field_name, default)
+  if block_given? then yield field_name else default end
+end
+
+x{
+  def yy;yield end
+  block=proc{p "blah  blah"}
+  yy &block
+}
+
+p(proc do
+   p=123
+end.call)
+
+p proc {
+   p=123
+}.call
+
+p def pppp
+   p=123
+end
+
+p module Ppp
+   p=123
+end
+
+p class Pppp < String
+   p=123
+end
+
+    def _make_regex(str) /([#{Regexp.escape(str)}])/n end
+    p _make_regex("8smdf,34rh\#@\#$%$gfm/[]dD")
+
+p "#$a #@b #@@c
+d e f
+#$a #@b #@@c
+"
+
+x do
+a='a'
+class <<a
+  def foobar
+     self*101
+  end
+  alias    eql?    ==
+end
+p a.foobar
+end
+
+p %w[a b c
+     d e f]
+
+p %w[a b c\n
+     d e f]
+
+     formatter.format_element(element) do
+       amrita_expand_and_format1(element, context, formatter)
+     end
+
+ ret = <<-END
+ @@parts_template = #{template.to_ruby}
+ def parts_template
+   @@parts_template
+ end
+ #{c.const_def_src.join("\n")}
+ def amrita_expand_and_format(element, context, formatter)
+   if element.tagname_symbol == :span and element.attrs.size == 0
+     amrita_expand_and_format1(element, context, formatter)
+   else
+     formatter.format_element(element) do
+       amrita_expand_and_format1(element, context, formatter)
+     end
+   end
+ end
+ def amrita_expand_and_format1(element, context, formatter)
+   #{method_src}
+ end
+ END
+
+p '
+'
+
+p "
+"
+
+p %w/
+/
+
+p %W/
+/
+
+p(/
+/)
+
+  p `
+  `
+
+p <<stuff+'foobar'.tr('j-l','d-f')
+"more stuff"
+12345678
+the quick brown fox jumped over the lazy dog
+stuff
+
+p <<stuff+'foobar'.tr('j-l','d-f')
+"more stuff"
+12345678
+the quick brown fox jumped over the lazy dog
+stuff
+
+p <<stuff+'foobar'.tr('j-l','d-f')\
++"more stuff"
+12345678
+the quick brown fox jumped over the lazy dog
+stuff
+
+p <<stuff+'foobar'\
++"more stuff"
+12345678
+the quick brown fox jumped over the lazy dog
+stuff
+
+
+p <<-BEGIN + <<-END
+          def element_downcase(attributes = {})
+        BEGIN
+          end
+        END
+
+p <<ggg; def
+kleegarts() p 'kkkkkkk' end
+dfgdgfdf
+ggg
+koomblatz!() p 'jdkfsk' end
+koomblatz!
+
+p( <<end )
+nine time nine men have stood untold.
+end
+
+=begin
+=end
+
+p <<"..end .."
+cbkvjb
+vb;lkxcvkbxc
+vxlc;kblxckvb
+xcvblcvb
+..end ..
+
+p <<a
+dkflg
+flk
+a
+
+label='label';tab=[1,2,3]
+      p <<S
+#{label} = arr = Array.new(#{tab.size}, nil)
+str = a = i = nil
+idx = 0
+clist.each do |str|
+  str.split(',', -1).each do |i|
+    arr[idx] = i.to_i unless i.empty?
+    idx += 1
+  end
+end
+S
+
+
+def printem1 a,b,c
+   p(a +77)
+   p(b +77)
+   p(c +77)
+end
+
+def foobar() end
+def foobar2
+end
+
+def printem0(a)
+   p(a +77)
+end
+
+def printem a,b,c
+   p a;p b;p c
+   p(a +77)
+   p(b %(0.123))
+end
+printem 1,2,3
+
+x do
+  a=1
+  p(a +77)
+  def hhh(a=(1+2)) a end
+end
+
+END {
+  p "bye-bye"
+}
+
+
+p <<here
+where?
+here
+
+p <<-what
+     ? that's
+  what
+
+x{
+for i in if false
+foob12345; else [44,55,66,77,88] end do p i**Math.sqrt(i) end
+}
+
+x{
+for i in \
+[44,55,66,77,88] do p i**Math.sqrt(i) end
+}
+
+x{
+for i in if
+false then foob12345; else [44,55,66,77,88] end do p i**Math.sqrt(i) end
+}
+
+x{
+for i in if false then
+foob12345; else [44,55,66,77,88] end do p i**Math.sqrt(i) end
+}
+
+x{
+c=j=0
+until while j<10 do j+=1 end.nil? do p 'pppppppppp' end
+}
+
+x{
+for i in if false then foob12345;
+else [44,55,66,77,88] end do p i**Math.sqrt(i) end
+}
+
+x{
+for i in if false then foob12345; else
+[44,55,66,77,88] end do p i**Math.sqrt(i) end
+}
+
+x{
+for i in (c;
+[44,55,66,77,88]) do p i**Math.sqrt(i) end
+}
+
+x{
+for i in (begin
+[44,55,66,77,88] end) do p i**Math.sqrt(i) end
+}
+
+x{
+for i in if false then foob12345; else
+[44,55,66,77,88] end do p i**Math.sqrt(i) end
+}
+
+x{
+for i in (
+[44,55,66,77,88]) do p i**Math.sqrt(i) end
+}
+
+x{
+for i in (
+[44,55,66,77,88]) do p i**Math.sqrt(i) end
+}
+
+
+
+<<SRC+<<SRC
+#{headers}
+SRC
+#{headers}
+SRC
+
+
+A::
+B
+
+A::
+b
+
+a::
+B
+
+a::
+b
+
+        assert_equal 403291461126605635584000000, 26._!
+        assert_equal 1, 0._!
+        assert_equal 1, 1._!
+        assert_equal 24, 4._!
+
+
+<<here
+#{<<there
+over there, over there, when its over over there.
+there
+}
+here
+
+
+[a \
+,b]
+
+<<a+<<b
+#{c}
+345234
+a
+#{d}
+234523452
+b
+
+<<a+<<b+\
+#{c}
+345234
+a
+#{d}
+234523452
+b
+"sdfsdf"
+
+<<a+<<b+
+#{c}
+345234
+a
+#{d}
+234523452
+b
+"sdfsdf"
+
+
+defined? <<A
+sdsdfsdfs
+A
+
+
+
+
+
+\
+__END__
+
+
+__END__