ruby-x/rubyx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

transformations according to todays post

Browse Source
This commit is contained in:
Torsten Ruger 2014-06-14 00:19:12 +03:00
parent 12a92e4db0
commit 2c26415de7
12 changed files with 138 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/boot/boot_space.rb
View File

@ -2,7 +2,7 @@ require "vm/context"
require "boot/boot_class"
require "vm/call_site"
require "arm/arm_machine"
require "core/kernel"
require "kernel/all"
require "boot/object"
require "boot/string"
@ -69,7 +69,7 @@ module Boot
end
[:utoa, :putstring,:putint,:fibo,:exit].each do |f|
puts "Boot Kernel::#{f}"
obj.add_function Core::Kernel.send(f , @context)
obj.add_function Crystal::Kernel.send(f , @context)
end
obj = get_or_create_class :String
[:get , :set].each do |f|

7
lib/core/integer.rb
View File

@ -1,7 +0,0 @@
module Core
class Integer
module ClassMethods
end
extend ClassMethods
end
end

107
lib/core/kernel.rb
View File

@ -1,107 +0,0 @@
module Core
class Kernel
#there are no Kernel instances, only class methods.
# We use this module syntax to avoid the (ugly) self (also eases searching).
module ClassMethods
def exit context
function = Vm::Function.new(:exit , Vm::Integer , [] )
ret = Vm::RegisterMachine.instance.exit(function)
function.set_return ret
function
end
def putstring context
function = Vm::Function.new(:putstring , Vm::Integer , [] )
ret = Vm::RegisterMachine.instance.write_stdout(function)
function.set_return ret
function
end
def putint context
putint_function = Vm::Function.new(:putint , Vm::Integer , [] , Vm::Integer )
buffer = Vm::StringConstant.new(" ") # create a buffer
context.object_space.add_object buffer # and save it (function local variable: a no no)
int = putint_function.receiver
moved_int = putint_function.new_local
utoa = context.object_space.get_or_create_class(:Object).resolve_function(:utoa)
putint_function.instance_eval do
mov( moved_int , int ) # move arg up
add( int , buffer ,nil ) # string to write to (add string address to pc)
add( int , int , buffer.length - 3) # 3 for good measure , ahem.
call( utoa )
after = new_block("after_call")
insert_at after
# And now we "just" have to print it, using the write_stdout
add( int , buffer , nil ) # string to write to
mov( moved_int , buffer.length )
end
Vm::RegisterMachine.instance.write_stdout(putint_function)
putint_function
end
# The conversion to base10 is quite a bit more complicated than i thought. The bulk of it is in div10
# We set up variables, do the devision and write the result to the string
# then check if were done and recurse if neccessary
# As we write before we recurse (save a push) we write the number backwards
# arguments: string address , integer
def utoa context
utoa_function = Vm::Function.new(:utoa , Vm::Integer , [ Vm::Integer ] , Vm::Integer )
str_addr = utoa_function.receiver
number = utoa_function.args.first
remainder = utoa_function.new_local
Vm::RegisterMachine.instance.div10( utoa_function , number , remainder )
# make char out of digit (by using ascii encoding) 48 == "0"
utoa_function.instance_eval do
add( remainder , remainder , 48)
strb( remainder, str_addr )
sub( str_addr, str_addr , 1 )
cmp( number , 0 )
callne( utoa_function )
end
return utoa_function
end
# testing method, hand coded fibo, expects arg in receiver_register
# result comes in return_register
# a hand coded version of the fibonachi numbers
# not my hand off course, found in the net http://www.peter-cockerell.net/aalp/html/ch-5.html
def fibo context
fibo_function = Vm::Function.new(:fibo , Vm::Integer , [] , Vm::Integer )
result = fibo_function.return_type
int = fibo_function.receiver
last = fibo_function.new_block("return")
f1 = fibo_function.new_local
f2 = fibo_function.new_local
fibo_function.instance_eval do
cmp int , 1
mov( result, int , condition_code: :le)
ble( last ) #branch to return, rather than return (as the original)
mov f1 , 1 #set up initial values
mov f2 , 0
end
loop = fibo_function.new_block("loop")
fibo_function.insert_at loop
fibo_function.instance_eval do #loop through
add f1 , f1 , f2 # f1 = f1 + f2
sub f2 , f1 , f2 # f2 = f1 -f2
sub int , int , 1 # todo: set.. should do below cmp, but doesn't , set_update_status: 1
cmp int , 1
bne( loop )
mov( result , f1 )
end
fibo_function
end
end
extend ClassMethods
end
end

10
lib/core/system.rb
View File

@ -1,10 +0,0 @@
module Core
module System
module ClassMethods
def puts io , c-string , length
end
end
extend ClassMethods
end
end

2
lib/crystal.rb
View File

@ -12,4 +12,4 @@ require "vm/function"
require "boot/boot_class"
require "boot/boot_space"
require "stream_reader"
require "core/kernel"
require "kernel/all"

19
lib/kernel/README.md Normal file
View File

@ -0,0 +1,19 @@
### Kernel module
As of writing Kernel is an "old style" module, aka a bunch of functions.
These functions return their code, ie a Vm::Function object, which can then be called by ruby code as if it were a "normal"
function.
A normal ruby function is one that is parsed and transformed to code. But not all functionality can be written in ruby,
one of those chicken and egg things. C uses Assembler in this situation, we use Kernel function.
Slightly more here : http://ruby-in-ruby.github.io/2014/06/10/more-clarity.html
The Kernal module is scattered into several files, but that is just so the file doesn't get too long.
PS: Old style also means the acual receiver is not used. Kernel function are more like global functions.
PPS: New style is what rails pioneered and has now called Concerns. I call them Aspects, and they not only serve to split
a big file up, but use the receiver and also super, ie the fact that a module gets inserted into the method lookup
sequence in just the same way as an superclass. This solves the old c++ and Java multiple inheritance dilemma.

3
lib/kernel/all.rb Normal file
View File

@ -0,0 +1,3 @@
require_relative "integer"
require_relative "string"
require_relative "system"

86
lib/kernel/integer.rb Normal file
View File

@ -0,0 +1,86 @@
#integer related kernel functions
module Crystal
module Kernel
# The conversion to base10 is quite a bit more complicated than i thought. The bulk of it is in div10
# We set up variables, do the devision and write the result to the string
# then check if were done and recurse if neccessary
# As we write before we recurse (save a push) we write the number backwards
# arguments: string address , integer
def self.utoa context
utoa_function = Vm::Function.new(:utoa , Vm::Integer , [ Vm::Integer ] , Vm::Integer )
str_addr = utoa_function.receiver
number = utoa_function.args.first
remainder = utoa_function.new_local
Vm::RegisterMachine.instance.div10( utoa_function , number , remainder )
# make char out of digit (by using ascii encoding) 48 == "0"
utoa_function.instance_eval do
add( remainder , remainder , 48)
strb( remainder, str_addr )
sub( str_addr, str_addr , 1 )
cmp( number , 0 )
callne( utoa_function )
end
return utoa_function
end
def self.putint context
putint_function = Vm::Function.new(:putint , Vm::Integer , [] , Vm::Integer )
buffer = Vm::StringConstant.new(" ") # create a buffer
context.object_space.add_object buffer # and save it (function local variable: a no no)
int = putint_function.receiver
moved_int = putint_function.new_local
utoa = context.object_space.get_or_create_class(:Object).resolve_function(:utoa)
putint_function.instance_eval do
mov( moved_int , int ) # move arg up
add( int , buffer ,nil ) # string to write to (add string address to pc)
add( int , int , buffer.length - 3) # 3 for good measure , ahem.
call( utoa )
after = new_block("after_call")
insert_at after
# And now we "just" have to print it, using the write_stdout
add( int , buffer , nil ) # string to write to
mov( moved_int , buffer.length )
end
Vm::RegisterMachine.instance.write_stdout(putint_function)
putint_function
end
# testing method, hand coded fibo, expects arg in receiver_register
# result comes in return_register
# a hand coded version of the fibonachi numbers
# not my hand off course, found in the net http://www.peter-cockerell.net/aalp/html/ch-5.html
def self.fibo context
fibo_function = Vm::Function.new(:fibo , Vm::Integer , [] , Vm::Integer )
result = fibo_function.return_type
int = fibo_function.receiver
last = fibo_function.new_block("return")
f1 = fibo_function.new_local
f2 = fibo_function.new_local
fibo_function.instance_eval do
cmp int , 1
mov( result, int , condition_code: :le)
ble( last ) #branch to return, rather than return (as the original)
mov f1 , 1 #set up initial values
mov f2 , 0
end
loop = fibo_function.new_block("loop")
fibo_function.insert_at loop
fibo_function.instance_eval do #loop through
add f1 , f1 , f2 # f1 = f1 + f2
sub f2 , f1 , f2 # f2 = f1 -f2
sub int , int , 1 # todo: set.. should do below cmp, but doesn't , set_update_status: 1
cmp int , 1
bne( loop )
mov( result , f1 )
end
fibo_function
end
end
end

10
lib/kernel/string.rb Normal file
View File

@ -0,0 +1,10 @@
module Crystal
module Kernel
def self.putstring context
function = Vm::Function.new(:putstring , Vm::Integer , [] )
ret = Vm::RegisterMachine.instance.write_stdout(function)
function.set_return ret
function
end
end
end

10
lib/kernel/system.rb Normal file
View File

@ -0,0 +1,10 @@
module Crystal
module Kernel
def self.exit context
function = Vm::Function.new(:exit , Vm::Integer , [] )
ret = Vm::RegisterMachine.instance.exit(function)
function.set_return ret
function
end
end
end

7
lib/parfait/README.md Normal file
View File

@ -0,0 +1,7 @@
### A thin layer
Here we have a placeholder for things i am currently developing.
Basically Parfait is the smallest amount of code needed to make a ruby-like OO system work.
A work in progress that started from here : http://ruby-in-ruby.github.io/2014/06/10/more-clarity.html

0
lib/core/array.rb → lib/parfait/array.rb
View File