native func alen
native func aget
native func aput
native func anew
native func _array
func __array {
    "NotImplemented" "Not implemented" throw
}

native func _char
native func _int
native func _file
native func _float
native func _long
native func _double

func __char {
    _char
}
func __int {
    _int
}
func __file {
    _file
}
native func __float
func __long {
    _long
}
native func __double

native func ischar
native func isint
native func isfloat
native func islong
native func isdouble

native func stop
native func include
native func putchar
native func read
native func flength
native func write
native func type
native func mktype
# "call a dynamically computed function" pop
# "Please keep in mind that this will throw a native error if" pop
# "called incorrectly - this means wrong layer parameter will" pop
# "instantly crash the program." pop
native func _layer_call
func call {
    0 _layer_call
}
native func typename
native func istype
native func settype
native func throw
# try and catch are keywords, not functions
# storelength
native func stlen

native func eq
native func gt
native func lt
native func not
native func or
native func and
native func +
native func -
native func /
native func *
native func **
native func %
native func ^

native func dup
native func pop
native func swap

"char" mktype =TYPE_CHAR
"int" mktype =TYPE_INT
"file" mktype =TYPE_FILE
"float" mktype =TYPE_FLOAT
"long" mktype =TYPE_LONG
"double" mktype =TYPE_DOUBLE
"array" mktype =TYPE_ARRAY

"string" mktype =TYPE_STRING
func _string {
    =object

    object ischar if {
        0 _char 1 anew =object
    }
    object isint if {
        itos =object
    }
    object isfloat if {
        ftoi =object
    }
    object islong if {
        ltoi =object
    }
    object isdouble if {
        dtoi =object
    }
    
    object
}
func __string {
    _string
}
func isstring {
    isarray
}

func itos {
    ntos
}

func ltos {
    ntos
}

func ftos {
    ntos
}

func dtos {
    ntos
}

# Number to string
func ntos {
    "" =s
    =n

    n 0 lt dup if { n neg =n 1 =negative } =negative
    n type =thetype

    while n 1 lt not {
        n (n 10 % dup =x) - =n
        s (n '0' + _char) strconcat =s
    }
    1 =steps
    while n 0 eq not {
        n (n (1 (steps dup 10 * =steps) /) % dup =x) - =n
        s (x '0' + _char) strconcat =s
    }

    negative if { "-" s strconcat =s }

    s
}

# Copy array
func acopy {
    # bind args
    =len
    =idx2
    =idx1
    =arr2
    =arr1

    1 neg =i
    while (i 1 + =i) (i len lt) {
        arr2 i idx2 + (arr1 i idx1 + aget) aput
    }
}

func strconcat {
    # bind args
    _string =str2
    _string =str1
    
    0 _char str1 alen str2 alen + anew =str
    
    str1 str 0 0         str1 alen acopy
    str2 str 0 str1 alen str2 alen acopy

    str
}

func strsplit {
    # bind args
    _string =splitter
    _string =str

    1 neg =i
    "" 0 anew =sequences
    "" =sequence
    while (i 1 + =i) (i str alen lt) {
        str i aget =chr
        splitter 0 aget =spl
        sequence chr strconcat =sequence
        1 neg =j
        while (j 1 + =j) (chr spl eq) {
            j splitter alen eq if {
                sequences =oldsq
                "" (sequences alen dup =seq 1 +) anew =sequences
                oldsq sequences 0 0 oldsq alen acopy
                sequences seq sequence aput
                "" =sequence
                2 stop
            }
            str i j + aget dup =chr
            splitter j aget dup =spl
        }
    }

    sequences
}

func strjoin {
    # bind args
    _string =joiner
    _array =arr

    1 neg =i
    "" =s
    while (i 1 + =i) (i arr alen lt) {
        s arr i aget joiner strconcat strconcat =s
    }

    s
}

func strsub {
    # bind args
    _int =pos2
    _int =pos1
    _string =string

    pos2 pos1 - =length

    (o _char length anew dup) string swap pos1 0 length acopy
}

func puts {
    _string =str
    1 neg =i
    while (i 1 + =i) (i str alen lt) {
        str i aget putchar
    }
}

func anewput {
    def size =size
    def arr size anew =arr
    
    def i 0 =i
    while i size lt {
        arr swap i swap aput
        i 1 + =i
    }

    arr areverse
}

func areverse {
    def arr =arr
    def new arr alen anew =new

    def i arr alen 1 - =i
    def j 0 =j
    while i 0 lt not {
        new j arr i aget aput
        j 1 + =j
        i 1 - =i
    }

    new
}

func inc {
    def varname =varname
    ( varname 1 _layer_call ) # "Get var" pop
        1 + # "Increment" pop
        ( "=" varname strconcat 1 _layer_call ) # "Store var" pop
}

func dec {
    def varname =varname
    ( varname 1 _layer_call ) # "Get var" pop
        1 - # "Decrement" pop
        ( "=" varname strconcat 1 _layer_call ) # "Store var" pop
}