native dup
native pop
native swap

func # { pop }

native alen
native aget
native aput
native anew
native _array

native _char
native _byte
native _int
native _float
native _long
native _double

native ischar
native isbyte
native isint
native isfloat
native islong
native isdouble
native isarray

"call a dynamically computed function" #
"Please keep in mind that this will throw a native error if" #
"called incorrectly - this means wrong layer parameter will" #
"instantly crash the program." #
native _layer_call
func call {
    1 _layer_call
}
"This returns the last word as a string, from an index." #
"index has to be <16, index 0 is this call" #
native _last_word
native include
native putchar
native mktype
native getos
native typename
native gettype
native settype
"try and do are keywords, not functions" #
native throw
native exit

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

func ++ { 1 + }
func -- { 1 - }

"this looks so wrong" #
func ( { }
func ) { }
func ; { }

"int must be registered first." #
def TYPE_INT "int" mktype =TYPE_INT
def TYPE_CHAR "char" mktype =TYPE_CHAR
def TYPE_BYTE "byte" mktype =TYPE_BYTE
def TYPE_FLOAT "float" mktype =TYPE_FLOAT
def TYPE_LONG "long" mktype =TYPE_LONG
def TYPE_DOUBLE "double" mktype =TYPE_DOUBLE
def TYPE_ARRAY "array" mktype =TYPE_ARRAY

def TYPE_STRING "string" mktype =TYPE_STRING
func _string {
    def object =object

    object ischar if {
        1 anew =object
        object TYPE_STRING settype
    }
    object isbyte if {
        itos =object
    }
    object isint if {
        itos =object
    }
    object isfloat if {
        ftoi =object
    }
    object islong if {
        ltoi =object
    }
    object isdouble if {
        dtoi =object
    }

    object isarray if {
        object TYPE_STRING settype =object
    }
    object isstring not if {
        "IncompatibleTypes" "Incompatible types: " object gettype typename " - string" strconcat strconcat throw
    }
    
    object
}
func isstring {
    gettype typename "string" eq
}

func itos {
    _long ltos
}

func ftos {
    _double dtos
}

func dtos {
    "NotImplemented" "dtos is not implemented" throw
}

"Number to string" #
func ltos {
    def n =n "bind number" #
    def s 0 anew =s "make array" #
    
    def ne n 0 lt dup if { n neg =n } =ne
    
    func rem { 10 _long / }

    def c0 "0" char =c0

    n 0 gt not if {
        "0" =s
    }
    while { n 0 gt } {
        ( ( ( n 10 _long % _char ) c0 + ) _char 1 anewput _string ) s strconcat =s
        n rem =n "divide by ten to remove last digit" #
    }

    ne if { "-" s strconcat =s }

    s _string
}

func stol {
    def s _array =s "bind string" #
    def n 0 _long =n "the number to return" #
    
    def ne s 0 aget "-" char eq =ne
    def len s alen =len
    ne if { s ( len 1 - dup =len anew ) 1 0 len acopy =s }

    func rem { dup ( ( def len alen 1 - =len ) len anew ) 1 0 len acopy }
    
    def c0 "0" char =c0

    while { s alen 0 eq not } {
        def chr s char =chr "extract first char" #
        n 10 _long * =n
        n ( chr c0 - _long ) + =n
        s rem =s "remove first digit" #
    }

    ne if { n neg =n }
    n
}

func char { _array 0 aget }

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

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

    arr2
}

func strconcat {
    "bind args" #
    def str2 _string _array =str2
    def str1 _string _array =str1

    def str str1 alen str2 alen + anew =str

    str1  str  0  0          str1 alen  acopy pop
    str2  str  0  str1 alen  str2 alen  acopy pop

    str _string
}

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

    1 neg =i
    def sequences "" 0 anew =sequences
    def sequence "" =sequence
    while { ( i 1 + =i ) ( i str alen lt ) } {
        def chr str i aget =chr
        def spl splitter 0 aget =spl
        sequence chr strconcat =sequence
        1 neg =j
        while { ( j 1 + =j ) ( chr spl eq ) } {
            j splitter alen eq if {
                def oldsq 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" #
    def joiner _string =joiner
    def arr _array =arr

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

    s
}

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

    pos2 pos1 - =length

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

func puts {
    def str _array =str
    def i 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
    def tmp
    while { i size lt } {
        =tmp arr i tmp aput
        i inc
    }

    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 strcontains {
    def check =check "bind check" #
    def s =s "bind string" #

    def found 0 =found
    def counter 0 =counter
    def i 0 =i
    def j 0 =j
    while { i s alen lt } {
        s i aget check j aget eq dup if {
            counter inc
        }
        not if {
            0 =counter
        }
        counter check alen eq if {
            3 stop
        }
        i inc
    }
    counter check alen eq
}

"These functions are magic, they use natives to get recent words and modify the" #
"variables, do not touch them unless you know exactly what you're doing!" #
func inc {
    def varname 4 _last_word =varname
    pop
    ( varname 1 _layer_call ) "Get var" #
        1 + "Increment" #
        ( "=" varname strconcat 1 _layer_call ) "Store var" #
}
func dec {
    def varname 4 _last_word =varname
    pop
    ( varname 1 _layer_call ) "Get var" #
        1 - "Decrement" #
        ( "=" varname strconcat 1 _layer_call ) "Store var" #
}

func random {
    "file.isbpl" include
    getos strlowercase dup ( "linux" strcontains ) swap ( "macos" strcontains ) or dup if {
        "/dev/urandom" _file 0 1 read
    }
    not if {
        "__windows_radom" call
    }
}

func strlowercase {
    def s =s "bind string" #
    def i 0 =i
    while { i s alen lt } {
        def char s i aget =char
        char 64 gt char 91 lt and if {
            s i char 32 + aput
        }
        i inc
    }
    s
}

func struppercase {
    def s =s "bind string" #
    def i 0 =i
    while { i s alen lt } {
        def char s i aget =char
        char 89 gt char 123 lt and if {
            s i char 32 - aput
        }
        i inc
    }
    s
}