From 20b6c9b47646733861798c0d42b4525b6c4caddb Mon Sep 17 00:00:00 2001 From: Torsten Ruger Date: Sun, 20 Sep 2015 15:51:08 +0300 Subject: [PATCH] fix class functions some extra tests in the process --- lib/parser/transform.rb | 13 +- test/cases/class_def/big_class.tst | 160 ++++++++++++++++++ test/cases/class_def/class_function.tst | 6 +- .../function_definition/class_function.tst | 5 +- 4 files changed, 174 insertions(+), 10 deletions(-) create mode 100644 test/cases/class_def/big_class.tst diff --git a/lib/parser/transform.rb b/lib/parser/transform.rb index ec4cfab..fb81eca 100644 --- a/lib/parser/transform.rb +++ b/lib/parser/transform.rb @@ -74,12 +74,13 @@ module Parser s(:expressions , *expressions)) end - rule(:type => simple(:type) , :receiver=> simple(:receiver), + rule(:type => simple(:type) , + :receiver=> simple(:receiver), :function_name => simple(:function_name), - :parameter_list => simple(:parameter_list), + :parameter_list => sequence(:parameter_list), :expressions => sequence(:expressions) , :end => simple(:e)) do s(:function, type.to_sym , function_name, s(:parameters , *parameter_list ), - s(:expressions , *expressions) , receiver) + s(:expressions , *expressions) , s(:receiver , *receiver)) end rule(l: simple(:l), o: simple(:o) , r: simple(:r)) do @@ -92,13 +93,13 @@ module Parser end #modules and classes are understandibly quite similar Class < Module - rule( :module_name => simple(:module_name) , :module_expressions => sequence(:module_expressions) , :end=>"end") do - s(:module , module_name.to_s.to_sym , *module_expressions) - end rule( :module_name => simple(:module_name) , :derived_name => simple(:derived_name) , :class_expressions => sequence(:class_expressions) , :end=>"end") do s(:class , module_name.to_s.to_sym , s(:derives, derived_name ? derived_name.to_a.first.to_sym : nil) , *class_expressions) end + rule( :module_name => simple(:module_name) , :module_expressions => sequence(:module_expressions) , :end=>"end") do + s(:module , module_name.to_s.to_sym , *module_expressions) + end rule(:expression_list => sequence(:expression_list)) { s(:expressions , *expression_list) diff --git a/test/cases/class_def/big_class.tst b/test/cases/class_def/big_class.tst new file mode 100644 index 0000000..43a7375 --- /dev/null +++ b/test/cases/class_def/big_class.tst @@ -0,0 +1,160 @@ +class String + + ref self.new_string(int len ) + len = len << 2 + return super.new_object( len) + end + + int length() + return self.length + end + + int plus(ref str) + my_length = self.length + str_len = str.length() + my_length = str_len + my_length + new_string = self.new_string(my_length ) + i = 0 + while( i < my_length) + char = get(i) + new_string.set(i , char) + i = i + 1 + end + i = 0 + while( i < str_len) + char = str.get(i) + len = i + my_length + new_string.set( len , char) + i = i + 1 + end + return new_string + end + +end +-- -- -- +s(:expressions, + s(:class, :String, + s(:derives, nil), + s(:function, :ref, + s(:name, :new_string), + s(:parameters, + s(:parameter, :int, :len)), + s(:expressions, + s(:assign, + s(:name, :len), + s(:operator, "<<", + s(:name, :len), + s(:int, 2))), + s(:return, + s(:call, + s(:name, :new_object), + s(:arguments, + s(:name, :len)), + s(:receiver, + s(:name, :super))))), + s(:receiver, :self)), + s(:function, :int, + s(:name, :length), + s(:parameters), + s(:expressions, + s(:return, + s(:field_access, + s(:receiver, + s(:name, :self)), + s(:field, + s(:name, :length)))))), + s(:function, :int, + s(:name, :plus), + s(:parameters, + s(:parameter, :ref, :str)), + s(:expressions, + s(:assign, + s(:name, :my_length), + s(:field_access, + s(:receiver, + s(:name, :self)), + s(:field, + s(:name, :length)))), + s(:assign, + s(:name, :str_len), + s(:call, + s(:name, :length), + s(:arguments), + s(:receiver, + s(:name, :str)))), + s(:assign, + s(:name, :my_length), + s(:operator, "+", + s(:name, :str_len), + s(:name, :my_length))), + s(:assign, + s(:name, :new_string), + s(:call, + s(:name, :new_string), + s(:arguments, + s(:name, :my_length)), + s(:receiver, + s(:name, :self)))), + s(:assign, + s(:name, :i), + s(:int, 0)), + s(:while, + s(:condition, + s(:operator, "<", + s(:name, :i), + s(:name, :my_length))), + s(:expressions, + s(:assign, + s(:name, :char), + s(:call, + s(:name, :get), + s(:arguments, + s(:name, :i)))), + s(:call, + s(:name, :set), + s(:arguments, + s(:name, :i), + s(:name, :char)), + s(:receiver, + s(:name, :new_string))), + s(:assign, + s(:name, :i), + s(:operator, "+", + s(:name, :i), + s(:int, 1))))), + s(:assign, + s(:name, :i), + s(:int, 0)), + s(:while, + s(:condition, + s(:operator, "<", + s(:name, :i), + s(:name, :str_len))), + s(:expressions, + s(:assign, + s(:name, :char), + s(:call, + s(:name, :get), + s(:arguments, + s(:name, :i)), + s(:receiver, + s(:name, :str)))), + s(:assign, + s(:name, :len), + s(:operator, "+", + s(:name, :i), + s(:name, :my_length))), + s(:call, + s(:name, :set), + s(:arguments, + s(:name, :len), + s(:name, :char)), + s(:receiver, + s(:name, :new_string))), + s(:assign, + s(:name, :i), + s(:operator, "+", + s(:name, :i), + s(:int, 1))))), + s(:return, + s(:name, :new_string)))))) diff --git a/test/cases/class_def/class_function.tst b/test/cases/class_def/class_function.tst index e6aa448..54d8dd9 100644 --- a/test/cases/class_def/class_function.tst +++ b/test/cases/class_def/class_function.tst @@ -1,6 +1,7 @@ class Pifi ofthen(3 , var) - int ofthen(int n , ref m) + + int self.ofthen(int n , ref m) n = n + m.index return n end @@ -30,4 +31,5 @@ s(:expressions, s(:field, s(:name, :index))))), s(:return, - s(:name, :n)))))) + s(:name, :n))), + s(:receiver, :self)))) diff --git a/test/cases/function_definition/class_function.tst b/test/cases/function_definition/class_function.tst index 3d1ac0b..ddaf24a 100644 --- a/test/cases/function_definition/class_function.tst +++ b/test/cases/function_definition/class_function.tst @@ -1,4 +1,4 @@ -int length( ref x ) +int self.length( ref x ) length end -- -- -- @@ -8,4 +8,5 @@ s(:expressions, s(:parameters, s(:parameter, :ref, :x)), s(:expressions, - s(:name, :length)))) + s(:name, :length)), + s(:receiver, :self)))