generics.cairo

%lang starknet

from starkware.cairo.common.alloc import alloc
from starkware.cairo.common.invoke import invoke
from starkware.cairo.common.registers import get_ap, get_label_location

from structs import Class

func invoke_func(size: felt, func_ptr : codeoffset, args_len : felt, args : felt*) -> (loc_ptr : felt*):
    let (func_pc) = get_label_location(func_ptr)
    invoke(func_pc, args_len, args)

    let (ap_val) = get_ap()
    let loc_ptr = ap_val - size
    return (loc_ptr)
end

func new_(class : Class, args_len : felt, args : felt*) -> (obj_ptr : felt*):
    let (new_obj) = invoke_func(class.size, class.ctor, args_len, args)
    return (new_obj)
end

func typeof(obj_ptr : felt*) -> (c : Class):
    let c = cast(obj_ptr, Class*)[0]
    return (c=c)
end

func sizeof(obj_ptr : felt*) -> (size : felt):
    let c = cast(obj_ptr, Class*)[0]
    return (size=c.size)
end

oop.cairo

# Use the output builtin.
%builtins output

from starkware.cairo.common.serialize import serialize_word

from starkware.cairo.common.alloc import alloc
from starkware.cairo.common.registers import get_ap, get_label_location
from starkware.cairo.common.invoke import invoke

func invoke_func(func_ptr : codeoffset, args_len : felt, args : felt*) -> (loc_ptr : felt*):
    let (func_pc) = get_label_location(func_ptr)
    invoke(func_pc, args_len, args)

    let (ap_val) = get_ap()
    # let result_arr : felt* = cast([ap_val - Location.SIZE - 1], felt*)
    # let loc_size = Location.SIZE
    let loc_ptr = ap_val - Location.SIZE
    # let result_arr_len = [ap_val - 2]
    # return (result_arr)
    return (loc_ptr)
end

struct Class:
    member size : felt
    member ctor : codeoffset  # constructor
    member clone : codeoffset
    member differ: codeoffset
end

struct Location:
    member class : Class
    member x : felt
    member y : felt
end

func new_location(x, y) -> (l : Location):
    let c = Class(size=3, ctor=new_location, clone=clone, differ=differ)
    let l = Location(class=c, x=x, y=y)
    return (l=l)
end

func clone(l : Location) -> (loc : Location):
    let (loc) = new_location(l.x, l.y)
    return (loc)
end

func differ(l1: Location, l2: Location) -> (is_diff: felt):
    if l1.x == l2.x:
        if l1.y == l2.y:
            return (1)
        end
    end
    return (0)
end

func typeof(obj_ptr: felt*) -> (c: Class):
    let c = cast(obj_ptr, Class*)[0]
    return (c=c)
end

func main{output_ptr : felt*}():
    let (l1) = new_location(1, 2)
    let (args) = alloc()
    assert args[0] = 1
    assert args[1] = 2

    let (loc_ptr) = invoke_func(l1.class.ctor, 2, args)
    let loc: Location = cast(loc_ptr, Location*)[0]
    let (class) = typeof(loc_ptr)

    serialize_word(class.size)
    serialize_word(loc.x)
    serialize_word(loc.y)
    
    return ()
end