Mercurial > repos > rhope
view kernel.rhope @ 91:bcdc326b3d6e
Added basic support for list literals in compiler. Updated todo list.
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Sat, 31 Jul 2010 17:17:23 -0400 |
parents | 27bb051d631c |
children | e73a93fb5de1 |
line wrap: on
line source
Import string.rhope Import list.rhope Import functional.rhope Import file.rhope Import dict.rhope Val[in:out] { out <- in } Blueprint Boolean { Val(Int32,Naked) } /* Blueprint Blueprint { Val(Blueprint,Naked) }*/ Blueprint Int64 { Num(Int64,Naked) } If@Int64[num:yes,no] { yes,no <- If[[num]!=[0i64]] } Blueprint Int32 { Num(Int32,Naked) } If@Int32[num:yes,no] { yes,no <- If[[num]!=[0i32]] } Foreign C:libc { write[filedes(Int32,Naked),buf(Array,Raw Pointer),nbyte(Int64,Naked):written(Int32,Naked)] read[filedes(Int32,Naked),buf(Array,Raw Pointer,Mutable),nbyte(Int64,Naked):read(Int64,Naked),buf] } _Print Int32[n,buf:out] { If[[n] < [10i32]] { byte <- [[n]Trunc Int8] + [48i8] out <- [buf]Append[byte] }{ next <- [n]/[10i32] byte <- [[[n]-[[next]*[10i32]]]Trunc Int8] + [48i8] out <- [_Print Int32[next, buf]]Append[byte] } } Print@Int32[n:out] { If[[n] < [0i32]] { val <- [0i32]-[n] buf <- [Array[]]Append[45i8] }{ val <- Val[n] buf <- Array[] } fbuf <- [_Print Int32[val, buf]]Append[10i8] out <- write[1i32, fbuf, Int64[[fbuf]Length >>]] } Blueprint Int16 { Num(Int16,Naked) } If@Int16[num:yes,no] { yes,no <- If[[num]!=[0i16]] } Blueprint Int8 { Num(Int8,Naked) } If@Int8[num:yes,no] { yes,no <- If[[num]!=[0i8]] } Blueprint UInt64 { Num(UInt64,Naked) } If@UInt64[num:yes,no] { yes,no <- If[[num]!=[0u64]] } Blueprint UInt32 { Num(UInt32,Naked) } If@UInt32[num:yes,no] { yes,no <- If[[num]!=[0u32]] } Blueprint UInt16 { Num(UInt16,Naked) } If@UInt16[num:yes,no] { yes,no <- If[[num]!=[0u16]] } Blueprint UInt8 { Num(UInt8,Naked) } If@UInt8[num:yes,no] { yes,no <- If[[num]!=[0u8]] } Blueprint Array { Eltype(Blueprint) Length(Int32,Naked) Storage(Int32,Naked) } Foreign C:runtime { _internal_array_copyout[array(Array), index(Int32,Naked), dest(Any Type,Boxed,Mutable):dest] _internal_array_copyin[array(Array,Boxed,Mutable), index(Int32,Naked), val:array] _internal_array_getboxed[array(Array), index(Int32,Naked):out] _internal_array_setboxed[array(Array,Boxed,Mutable), index(Int32,Naked), val:array] _internal_array_allocboxed[size(Int32,Naked):out(Array)] _internal_array_allocnaked[size(Int32,Naked),type(Blueprint):out(Array)] _internal_blueprint_eq[left(Blueprint),right(Blueprint):out(Int32,Naked)] _internal_worker_alloc[size(Int16,Naked):out(Worker)] _internal_worker_setinput[worker(Worker,Boxed,Mutable),num(Int16,Naked),val:worker] _internal_worker_getinput[worker(Worker),num(Int16,Naked):out] _internal_worker_hasinput[worker(Worker),num(Int16,Naked):out(Int32,Naked)] } Blueprint Worker { Index(Int32,Naked) Size(Int16,Naked) Count(Int16,Naked) } Get Input@Worker[worker(Worker),bindex(Int32):val,not populated] { index <- [bindex]Trunc Int16 ,not populated <- If[_internal_worker_hasinput[worker,index]] { val <- _internal_worker_getinput[worker,index] } } _Copy Params[source(Worker),dest(Worker),cur(Int16):out(Worker)] { If[[cur]<[[source]Size >>]] { [source]Get Input[cur] { next <- _internal_worker_setinput[dest, cur, ~] }{ next <- Val[dest] } out <- _Copy Params[source, next, [cur]+[1i16]] }{ out <- dest } } Set Input@Worker[worker(Worker),bindex(Int32),val:out(Worker)] { index <- [bindex]Trunc Int16 If[[index] < [[worker]Size >>]] { set <- _internal_worker_setinput[worker, index, val] }{ set <- _internal_worker_setinput[ _Copy Params[worker, [ _internal_worker_alloc[[index]+[1i16]] ]Index <<[[worker]Index >>] , 0i16] , index, val] } out <- [set]Count <<[ [[set]Count >>]+[1i16] ] } =@Blueprint[left,right:out] { out <- [_internal_blueprint_eq[left,right]]!=[0] } Array[:out(Array)] { out <- [[_internal_array_allocboxed[0] ]Length <<[0] ]Storage <<[0] } First@Array[array:out(Int32),empty] { ,empty <- If[[array]Length >>] { out <- 0 } } Next@Array[array,current:out(Int32),empty] { next <- [current]+[1] ,empty <- If[[next] < [[array]Length >>]] { out <- Val[next] } } Last@Array[array:out(Int32),empty] { ,empty <- If[[array]Length >>] { out <- [[array]Length >>] - [1] } } Append@Array[array,newval:out(Array)] { out <- [array]Set[[array]Length >>, newval] } Index@Array[array,index(Int32):out,notfound] { ,notfound <- If[[index] >= [0]] { ,notfound <- If[[index] < [[array]Length >>]] { eltype <- [array]Eltype >> If[[eltype] = [Any Type()]] { out <- _internal_array_getboxed[array, index] }{ out <- _internal_array_copyout[array, index, Build[eltype]] } } } } _Copy to Boxed[source,dest,current:out] { ndest <- _internal_array_setboxed[dest, current, [source]Index[current]] [source]Next[current] { out <- _Copy to Boxed[source, ndest, ~] }{ out <- Val[ndest] } } _Copy Naked[source,dest,current:out] { ndest <- _internal_array_copyin[dest, current, [source]Index[current]] [source]Next[current] { out <- _Copy Naked[source, ndest, ~] }{ out <- Val[ndest] } } Set@Array[array,index(Int32),val:out(Array)] { If[[index] < [[array]Storage >>]] { If[[index] > [[array]Length >>]] { farray <- [[array]Set[[index]-[1], val]]Length <<[ [index]+[1] ] }{ If[[index] = [[array]Length >>]] { farray <- [array]Length <<[ [index]+[1] ] }{ farray <- Val[array] } } eltype <- [array]Eltype >> If[[eltype] = [Any Type()]] { out <- _internal_array_setboxed[farray, index, val] }{ If[[Blueprint Of[val]] = [eltype]] { out <- _internal_array_copyin[farray, index, val] }{ boxed <- _internal_array_allocboxed[[farray]Storage >>] [array]First { copied <- _Copy to Boxed[farray, boxed, ~] }{ //I don't think this case should happen normally copied <- Val[boxed] } out <- _internal_array_setboxed[copied, index, val] } } }{ If[[array]Length >>] { If[[index] < [4]] { new storage <- [index]+[index] }{ new storage <- [index]+[[index]RShift[1]] } do boxed <- If[[[array]Eltype >>] = [Any Type()]] { copied <- _Copy to Boxed[array, _internal_array_allocboxed[new storage], 0] }{ bp <- Blueprint Of[val] If[[[array]Eltype >>] = [bp]] { copied <- _Copy Naked[array, _internal_array_allocnaked[new storage, bp], 0] }{ copied <- _Copy to Boxed[array, _internal_array_allocboxed[new storage], 0] } } out <- [[copied]Length <<[[array]Length >>]]Set[index,val] }{ len <- [index]+[1] out <- [_internal_array_allocnaked[len, Blueprint Of[val]] ]Set[index,val] } } } Length@Array[arr:out] { out <- [arr]Length >> } Call@Array[arr(Array),index(Int32):out] { out <- [arr]Index[index] } _Copy Part Naked[source,dest,srcindex,destindex:out] { ndest <- _internal_array_copyin[dest, destindex, [source]Index[srcindex]] [source]Next[srcindex] { out <- _Copy Part Naked[source, ndest, ~, [destindex]+[1]] }{ out <- Val[ndest] } } _Copy Part Boxed[source,dest,srcindex,destindex:out] { ndest <- _internal_array_setboxed[dest, destindex, [source]Index[srcindex]] [source]Next[srcindex] { out <- _Copy Part Boxed[source, ndest, ~, [destindex]+[1]] }{ out <- Val[ndest] } } Slice@Array[arr,slicepoint(Int32):left,right] { If[[slicepoint]<[[arr]Length]] { If[[slicepoint]>[0i32]] { eltype <- [arr]Eltype >> If[[eltype] = [Any Type()]] { _Copy Part Boxed[arr, _internal_array_allocboxed[[[arr]Length]-[slicepoint]], slicepoint, 0] }{ _Copy Part Naked[arr, _internal_array_allocnaked[[[arr]Length]-[slicepoint], eltype], slicepoint, 0] } left <- [arr]Length <<[slicepoint] }{ right <- arr left <- Array[] } }{ left <- arr right <- Array[] } } And[left,right:out] { ,out <- If[left] { out,out <- If[right] } } Or[left,right:out] { out <- If[left] {} { out <- right } } Min[a,b:out] { If[[a]<[b]] { out <- a }{ out <- b } } Max[a,b:out] { If[[a]>[b]] { out <- a }{ out <- b } }