401 lines
7.5 KiB
Text
401 lines
7.5 KiB
Text
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
|
|
}
|
|
native subprocess
|
|
"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 ^
|
|
|
|
native fcall
|
|
native deffunc
|
|
native defmethod
|
|
native deffield
|
|
|
|
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_FUNCTION "func" mktype =TYPE_FUNCTION
|
|
def TYPE_ARRAY "array" mktype =TYPE_ARRAY
|
|
def TYPE_STRING "string" mktype =TYPE_STRING
|
|
|
|
def TYPE_JIO "jio" mktype =TYPE_JIO
|
|
"class" {
|
|
pop
|
|
native jio.class
|
|
jio.class
|
|
} TYPE_JIO defmethod
|
|
"getclass" {
|
|
pop
|
|
native jio.getclass
|
|
jio.getclass
|
|
} TYPE_JIO defmethod
|
|
def JIO 0 TYPE_JIO settype =JIO
|
|
|
|
func _string {
|
|
def object =object
|
|
|
|
object ischar if {
|
|
1 anew =object
|
|
object TYPE_STRING settype
|
|
}
|
|
object isbyte if {
|
|
object itos =object
|
|
}
|
|
object isint if {
|
|
object itos =object
|
|
}
|
|
object isfloat if {
|
|
object ftoi =object
|
|
}
|
|
object islong if {
|
|
object ltoi =object
|
|
}
|
|
object isdouble if {
|
|
object 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 stoi {
|
|
stol _int
|
|
}
|
|
|
|
func stof {
|
|
stod _float
|
|
}
|
|
|
|
func itos {
|
|
_long ltos
|
|
}
|
|
|
|
func ftos {
|
|
_double dtos
|
|
}
|
|
|
|
func dtos {
|
|
"NotImplemented" "dtos is not implemented" throw
|
|
}
|
|
|
|
func stod {
|
|
"NotImplemented" "stod 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" #
|
|
}
|
|
|
|
n ( ne 2 * 1 - neg ) _long *
|
|
}
|
|
|
|
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 strlowercase {
|
|
def s _array =s "bind string" #
|
|
def i 0 =i
|
|
while { i s alen lt } {
|
|
def chr s i aget =chr
|
|
chr "A" char lt not chr "Z" char gt not and if {
|
|
s i chr "a" char "A" char - + aput
|
|
}
|
|
i inc
|
|
}
|
|
s _string
|
|
}
|
|
|
|
func struppercase {
|
|
def s _array =s "bind string" #
|
|
def i 0 =i
|
|
while { i s alen lt } {
|
|
def chr s i aget =chr
|
|
chr "a" char lt not chr "z" char gt not and if {
|
|
s i chr "a" char "A" char - - aput
|
|
}
|
|
i inc
|
|
}
|
|
s _string
|
|
}
|
|
|
|
func main {
|
|
pop 0
|
|
}
|