Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Messages - Xeda112358

Pages: [1] 2 3 ... 296
1
Holy hell, that is awesome!

2
ASM / Re: Interrupt question
« on: April 06, 2018, 04:03:39 pm »
I don't know crystals timers well, sorry. I do however remember a comment from about six years ago by thepenguin77, I think, involving this same premise. I couldn't find the post though :(

3
The Axe Parser Project / Re: Lag Problems with Collisions
« on: March 22, 2018, 09:20:50 am »
Could you post the code you are currently using?
In assembly, I would draw to a "collision buffer" and test with that, but I don't think that is efficient in Axe code.

4
Other Programming Languages / How To Add Two Sprites
« on: March 14, 2018, 01:39:13 pm »
For a few years now, I've been playing on-and-off with various ideas related to parsing and evaluating expressions. Today as I was working out the code for adding two values, I came across the case of adding a 'sprite' variable to some other variable.

If you had a programming language where you had two sprite variables, what would you want or expect 'sprite1+sprite2' to do, if anything? For that matter, how about adding an integer or float to it? How about multiplication or division?

I know, for example, that I would want 'sprite1 or sprite2' to return a sprite with it's contents bit-wise ORed together.

5
Axe / Re: More dynamic variables?
« on: March 14, 2018, 11:44:28 am »
Yeah, that would actually work. It's still less efficient for the reason that it is taking up unnecessary memory, though.

6
Axe / Re: More dynamic variables?
« on: March 13, 2018, 02:30:31 pm »
A lot of people use the areas pointed to by L1~L6 to store additional data. If even those don't suffice (that's a lot of RAM) you could make a buffer/array stored in your program and store the data there, or for a really complicated method, create a temporary OS variable of whatever size you need  and store the data there.

7
ASM / Re: Simple ASM tasks
« on: March 01, 2018, 06:30:11 pm »
What do you mean by "manipulate a variable?" A bunch of those codes you may have found take input and then output a value by manipulating a variable.


If you decide to try assembly, look into how variables are stored and look into bcalls like the following:
_RclAns
_StoAns
_ChkFindSym
rFindSym (don't use the bcall, use the rst)
_SetXXOP1
_SetXXOP2
_SetXXXXOP2
_OP2ToOP1


8
Reuben Quest / Re: Reuben Quest: Lost Between Times [Color Remake]
« on: February 28, 2018, 09:29:58 am »
That is so freaking cool! How can I get or make a gamebuino?

9
Other Calculators / Re: Why RPN?
« on: February 24, 2018, 10:31:47 am »
Being older and wiser than I was in my last response, I maintain that RPN is the clear winner for performance, especially in an interpreted programming language, but infix is better for organization for humans.

Also @martinot, please edit your post instead of double posting.

10
This looks pretty cool, I'd like to see how it turns out!

11
TI Z80 / Re: ICE Compiler
« on: December 03, 2017, 11:33:12 am »
Same here, it seems like it's on it's way to Axe-tier popularity, good job PT_!

12
TI Z80 / Re: Shunting-Yard Algorithm
« on: November 30, 2017, 02:11:34 am »
Today I wrote a Python version of the "compiler." Currently it only recognizes a handful of binary operations, and the function 'sin(', but it does recognize signed and unsigned integers of sizes 8,16,32, and 64, as well as single precision floats. The variable type 'single' gets mapped to 'float' and 'char' gets mapped to 'uint8' and 'int' is mapped to 'int32'.

I've got it doing some complicated stuff like basic math optimizations (ex. 3*3 is just changed to 9) and variable mapping, neither of which the Z80 version do. As well, the Python version actually handles multiple lines of source code. In the example, 'code.txt' we have the three-line code:
Code: [Select]
var float x0=0
var uint8 y0=0
sin(3.14159*2*x0+y0)^9
This compiles to 44 bytes if you include the metadata about variable names, and 35 bytes for the code+header+static variables.

The source for the Python program is included in the attached file, but for those who don't want to go through the trouble of downloading, here is the current source for 'compyler.py'. It's ugly, for now.
Code: [Select]
from math import sin
t_plus      = 0xD1
t_minus     = 0xD2
t_mul       = 0xD3
t_div       = 0xD4
t_pow       = 0xD5
t_and       = 0xD6
t_xor       = 0xD7
t_or        = 0xD8
t_eq        = 0xD9
t_neq       = 0xDA
t_gt        = 0xDB
t_lt        = 0xDC
t_ge        = 0xDD
t_le        = 0xDE
t_sto       = 0xDF
binops=[
        ["~",0x01,t_sto],
        ["=",0x50,t_eq],
        ["|",0x60,t_or],
        ["&",0x70,t_and],
        ["-",0x81,t_minus],
        ["+",0x80,t_plus],
        ["/",0x83,t_div],
        ["*",0x82,t_mul],
        ["^",0x85,t_pow],
        ["",0x00,0]
       ]
varlist=[]
def getbinopsinfo(s):
    n=0
    m=len(binops)-1
    while (n<m) and s!=binops[n][0]:
        n+=1
    return binops[n]
def isvar(s):
    for i in varlist:
        if s==i[0]:
            return True
    return False
def shuntingyard(inp):
    size = len(inp)
    opstack=""
    out=""
    k=0
    inp+=" "
    while k<size:
        n=k
        while ("0"<inp[k]<="9"):
            out+=inp[k]
            k+=1
        if inp[k]==".":
            out+=inp[k]
            k+=1
            while ("0"<inp[k]<="9"):
                out+=inp[k]
                k+=1
            if inp[k]==".":
                return "Err: Too Many Decimals."
        if n!=k:
            out+=","
        else:
#Check Variables
            while ("a"<=inp[k]<="z") or ("A"<=inp[k]<="Z") or ("0"<=inp[k]<="9") or inp[k]=="_":
                k+=1
            if n==k or inp[k]=="(":
                k=n
            else:
                if isvar(inp[n:k])==True:
                    out+=inp[n:k]+","
                else:
                    return "Err: Var Not Found  :  "+inp[n:k]
        if inp[k]=="(":
            opstack="(,"+opstack
            k+=1
        if inp[k]==")":
            m=len(opstack)           
            if m==0:
                return "Err: Unmatched ')'."
            n=0
            opstack+=" "
            while opstack[n]!="(" and n<m:
                n+=1
            if n==m:
                return "Err: Unmatched ')'."
            out+=opstack[0:n+2]
            opstack=opstack[n+2:-1]
            k+=1
        n=getbinopsinfo(inp[k])
        if n[0]!="":
            p=n[1]
            m=0
            j=len(opstack)
            opstack+=" "
            while (p<=getbinopsinfo(opstack[m])[1]) and m<j:
                m+=1
                if m<j:
                    if opstack[m]==',':
                        m+=1
                if m<j:
                    if getbinopsinfo(opstack[m])[0]=='':
                        j=m
            out+=opstack[0:m]
            opstack=n[0]+","+opstack[m:-1]
            k+=1
        if ("A"<inp[k]<="Z") or ("a"<inp[k]<="z"):
            n=k
            while (("A"<inp[k]<="Z") or ("a"<inp[k]<="z") or ("0"<inp[k]<="1") or (inp[k]=="_")) and k<size:
                k+=1
            if inp[k]=="(":
                k+=1
                opstack=inp[n:k]+","+opstack
            else:
                k=n
    out+=opstack
    out=out.strip(",")
    return out.split(",")
def int2hex(n):
    n=int(n)
    if n==0:
        return "0"
    s=""
    hexstr="0123456789ABCDEF"
    while n!=0:
        s=hexstr[n%16]+s
        n>>=4
    return s
def littleendianify(s):
    out=""
    n=len(s)
    while n>0:
        out+=s[n-2:n]
        n-=2
    return out
def floatsingleify(s):
    x=eval(s)
    if x==0:
        return "00000000"
    s=0
    if x<0:
        s=1
        x=-x
    exp=128
    mant=x
    while x>=2:
        exp+=1
        x/=2
    while x<1:
        exp-=1
        x*=2
    x*=(1<<24)
    x=int(x)
    x+=(x&1)
    x>>=1
    if x>=(1<<24):
        exp+=1
        x>>=1
    if exp<0:
        return "00000000"
    if exp>255:
        return "00004000"
    if s==0:
        x-=(1<<23)
    s=int2hex(x)
    s="0"*(6-len(s))+s
    s=littleendianify(s)
    t=int2hex(exp)
    return s+"0"*(2-len(t))+t
def hextok(s):
    if ("0"<=s[0]<="9") or s[0]=="." or s[0]=="-":
        s=s.split(".")
        if len(s)==1:
            s=int(s[0])
            sign=0
            if s<0:
                sign=1
                if s>-(1<<7):
                    s+=256
                if s>-(1<<15):
                    s+=(1<<16)
                if s>-(1<<31):
                    s+=(1<<32)
                if s>-(1<<63):
                    s+=(1<<64)
            s=int2hex(s)
            if len(s)%2:
                s="0"+s
            s=littleendianify(s)
            if (len(s)==2) and sign==0:
                return "00"+s       #uint8, a.k.a 'char', default for 8-bit integer
            if (len(s)==2) and sign==1:
                return "01"+s       #int8
            if (len(s)==4) and sign==0:
                return "02"+s       #uint16, default for 16-bit integer
            if (len(s)==4) and sign==1:
                return "03"+s       #int16
            if len(s)<=8:
                s+="0"*(8-len(s))
                if "0"<s[6]<"8":
                    return "04"+s       #uint32 is the default if the int can't fit into a signed 32-bit int
                return "05"+s       #int32, default for 32-bit integer
            if len(s)==16:
                s+="0"*(16-len(s))
                if "0"<s[14]<"8":
                    return "06"+s       #uint64 is the default if the int can't fit into a signed 64-bit int
                return "07"+s       #int64, default for 64-bit integer
        else:
            s=floatsingleify(s[0]+"."+s[1])
            return "08"+s           #single prec. float, default float type.
    if isvar(s)==True:
        k=0
        while varlist[k][0]!=s:
            k+=1
        s=int2hex(k)
        s="0"*(4-len(s))+s
        return "1B"+littleendianify(s)
    if s=="sin(":
        return "63"
    if getbinopsinfo(s)[0]!="":
        s=int2hex(getbinopsinfo(s)[2])
        return "0"*(2-len(s))+s
    return s
def hextokenize(inp):
    n=len(inp)
    out=[]
    for i in range(n):
        if inp[i]!="(":
            out+=[hextok(inp[i])]   
    return out
def isnum(s):
    for i in s:
        if ((i<"0") or (i>"9")) and (i!=".") and (i!='-'):
            return False
    return True
def optimizer(exp):
    n=len(exp)
    k=0
    while k<n:
        f=False
        if isnum(exp[k-1])==True:
            if exp[k]=="sin(":
                f=True
                s=str(sin(eval(exp[k-1])))
            if f==True:
                f=False
                if k==1:
                    exp=[s]+exp[2:]
                else:
                    exp=exp[0:k-1]+[s]+exp[k+1:]
                k-=1
                n-=1
            if isnum(exp[k-2])==True:
                if exp[k]=="+":
                    f=True
                    s=str(eval(exp[k-2])+eval(exp[k-1]))
                if exp[k]=="-":
                    f=True
                    s=str(eval(exp[k-2])-eval(exp[k-1]))
                if exp[k]=="*":
                    f=True
                    s=str(eval(exp[k-2])*eval(exp[k-1]))
                if exp[k]=="/":
                    f=True
                    s=str(eval(exp[k-2])/eval(exp[k-1]))
                if exp[k]=="^":
                    f=True
                    s=str(eval(exp[k-2])**eval(exp[k-1]))
                if f==True:
                    if k==2:
                        exp=[s]+exp[3:]
                    else:
                        exp=exp[0:k-2]+[s]+exp[k+1:]
                    k-=2
                    n-=2
        k+=1
    return exp
def compileline(exp, varlist=varlist,opt=True):
    if exp=="":
        return exp
    if exp[0:4]=="var ":
        exp=exp[4:].split(" ")
        if len(exp)!=2:
            return "Err: Syntax"
        i=exp[1].split("=")
        s=exp[0]
        if s=="int":
            s="int32"
        if s=="char":
            s="uint8"
        if s=="single":
            s="float"
        if s=="floatext" or s=="float" or s=="int8" or s=="int16" or s=="int32" or s=="int64" or s=="uint8" or s=="uint16" or s=="uint32" or s=="uint64":
            if len(i)==1:
                i+=["0"]
            if len(i)>2:
                return "Err: Syntax"
            varlist+=[[i[0],s,i[1]]]
            return ""


    exp=shuntingyard(exp)
    if exp[0:4] == "Err:":
        return exp
    if opt==True:
        exp=optimizer(exp)
        if exp[0:4] == "Err:":
            return exp
    exp=hextokenize(exp)
    s=""
    for i in exp:
        s+=i
    return s
def tokifyvar(s,x):
    if s=="uint8":
        x=int(x)%256
        s=int2hex(x)
        return "00"+"0"*(2-len(s))+s
    if s=="int8":
        x=int(x)%256
        s=int2hex(x)
        return "01"+"0"*(2-len(s))+s
    if s=="uint16":
        x=int(x)%(1<<16)
        s=int2hex(x)
        return "02"+littleendianify("0"*(4-len(s))+s)
    if s=="int16":
        x=int(x)%(1<<16)
        s=int2hex(x)
        return "03"+littleendianify("0"*(4-len(s))+s)
    if s=="uint32":
        x=int(x)%(1<<32)
        s=int2hex(x)
        return "04"+littleendianify("0"*(8-len(s))+s)
    if s=="int32":
        x=int(x)%(1<<32)
        s=int2hex(x)
        return "05"+littleendianify("0"*(8-len(s))+s)
    if s=="uint64":
        x=int(x)%(1<<64)
        s=int2hex(x)
        return "06"+littleendianify("0"*(16-len(s))+s)
    if s=="int64":
        x=int(x)%(1<<64)
        s=int2hex(x)
        return "07"+littleendianify("0"*(16-len(s))+s)
    if s=="float":
        return "08"+floatsingleify(x)
    return "Err: Unknown Type"
def int2hexle(x,n=0):
    s=int2hex(x)
    if len(s)%2==1:
        s="0"+s
    s=littleendianify(s)
    if n==0:
        return s
    return s+("0"*(n-len(s)))
def compile(code,varlist=varlist,opt=True):
    code=code.split("\n")
    out=''
    k=0
    for i in code:
        k+=1
        s=compileline(i)
        if s[0:4]=="Err:":
            return "Line "+str(k)+"  "+s
        out+=s
#'out' is the code section
#now we need to create the var section, preloaded with default assignment
#then we need to create the var names LUT
    vars=[]
    names=[]
    for i in varlist:
        names+=[i[0]]
        vars+=[tokifyvar(i[1],i[2])]
        if vars[-1][0:4]=="Err:":
            return vars[-1][0:4]
    varslut=int2hexle(len(vars),2)
    offset=2*len(vars)
    for i in vars:
        varslut+=int2hexle(offset,4)
        offset+=int(len(i)/2)
    nameslut=int2hexle(len(names),2)
    offset=2*len(names)
    for i in names:
        nameslut+=int2hexle(offset,4)
        offset+=len(i)+1
    for i in names:
        for j in i:
            nameslut+=int2hexle(ord(j),2)
    for i in vars:
        varslut+=i
    s=int2hexle(int(len(out)/2),4)
    s+=int2hexle(int(len(varslut)/2),4)
    s+=int2hexle(int(len(nameslut)/2),4)
    return [s,out,varslut,nameslut]
f=open("code.txt","r+")
code=f.read()
f.close()
print(code)
cmpld=compile(code)
print(len(cmpld[0]+cmpld[1]+cmpld[2]+cmpld[3])>>1,"bytes :",cmpld)
print(varlist)
# varlist=[['x0'],['y0']]
# exp="sin(3.14159*2*x0+y0)^9"
# print(exp)
# exp=compileline(exp)
# print(int(len(exp)/2),"bytes : ",exp)

13
TI Z80 / Re: Shunting-Yard Algorithm
« on: November 27, 2017, 03:32:48 pm »
Now I have it 'tokenizing' as it is parsing the ASCII string! So numbers are converted to a machine-friendly format, function names are converted to one-byte 'tokens', and order of operations is preserved. I also made a routine that converts tokens to an ASCII string, in order to display the result of the shunting yard algorithm.

I whipped up an RPN parser to test some code, and it worked! Keep in mind that the RPN parser I made for this is not at all how I want to ideally implement it. Instead manually comparing the bytes, I need to look it up in the lookup table already available. I want it to be fast so I am going to have to modify the LUT to point directly to the code, but that is okay. Bleggh, this is tedious work :P

There is an example in the screenshots where I draw a sprite located at address 0x0000. I don't have the sprite type implemented yet, or even variables for that matter, so it's just a constant. In the attached files, I changed the example to have '06/3' to kind of show that the input won't always be able to be reconstructed from the output. During the tokenizing, '06' is converted to 0x0006, and during the token->ascii output, 0x0006 is converted to just '6'.

14
TI-Nspire / Re: Hiding the files
« on: November 06, 2017, 12:32:20 pm »
I don't know much about the nspire, but I personally never came across a method to do that. I would suggest backing up your programs and data onto a computer, and then resend afterwards.

15
TI Z80 / Re: Shunting-Yard Algorithm
« on: November 05, 2017, 09:15:04 pm »
I combined the shunting yard code with my latest function lookup code, and now it is recognizing named functions as well!

Here is the code that is run in the attached gif:
Code: [Select]
#include "grammer3.inc"
#ifndef scrap
#define scrap 8000h
#endif
 
#define bcall(x) rst 28h \ .dw x
saveSScreen = 86ECh
_PutS = 450Ah
_NewLine = 452Eh

sybuf           = saveSScreen
outhead         = scrap
stackhead       = scrap+2
input_save      = scrap+4
input_savesize  = scrap+6
hash            = scrap+8
spsave          = scrap+10

.db $BB,$6D
.org $9D95

;    ld hl,testinput
;    ld bc,testinput_end-testinput
;    call hashlookup     ;returns c if success

    ld hl,test
    bcall(_PutS)
    bcall(_NewLine)
    ld hl,s_RightArrow
    bcall(_PutS)
    bcall(_NewLine)
    ld hl,test
    ld bc,test_end-test
    ld (spsave),sp
    call shuntingyard
    call rpn
    ld hl,sybuf
    bcall(_PutS)
    bcall(_NewLine)
    ret
shuntingyard:
    ld de,sybuf
    ld (outhead),de
    ld d,(sybuf/256)+3
    ld (stackhead),de
_:
    ld a,(hl)
    call +_
    cpi
    jp pe,-_
    ld hl,sybuf+768
    ld de,(stackhead)
    or a
    sbc hl,de
    ld b,h
    ld c,l
    ld hl,(outhead)
    ex de,hl
    jr z,$+3
    ldir
    dec de
    xor a
    ld (de),a
    ret
_:
    cp '.'
    jp z,num_dec
    cp 30h
    jr c,+_
    cp 3Ah
    jp c,num
_:
    cp '('
    jp nz,+_
    ex de,hl
    ld hl,(stackhead)
    dec hl
    ld (hl),','
    dec hl
    ld (hl),a
    ld (stackhead),hl
    ex de,hl
    ret
_:
    cp ')'
    jp nz,checkunops
    push hl
    push bc
    ld hl,sybuf+768
    ld de,(stackhead)
    sbc hl,de
    jp z,ERR_Unmatched_lparens
    ld b,h
    ld c,l
    ex de,hl
    ld de,(outhead)
;BC is the size of the stack. Use this in case there is a missing ')' so we don't read garbage.
;basically search for the matching '(' while piping out the stack to the output.
_:
    ld a,(hl)
    cp '('
    jr z,+_
    ldi
    jp pe,-_
    jp ERR_Unmatched_lparens
_:
    dec de
    ld a,(de)
    inc de
    cp ','
    jr z,+_
    ld a,','
    ld (de),a
    inc de
_:
.echo "Potential bug here."     ;Should be fine unless an external routine randomly jumps partway into the shunting yard code :P
    inc hl
    inc hl
    ld (outhead),de
    ld (stackhead),hl
    pop bc
    pop hl
    ret
checkunops:
checkbinops:
;; if the token is an operator, then:
;;  while there is an operator at the top of the operator stack with
;;   greater than or equal to precedence and the operator is left associative:
;;    pop operators from the operator stack, onto the output queue.
;;  push the read operator onto the operator stack.
;;
;;
    push bc
    ex de,hl
    call getprecedence
    ld a,c
    pop bc
    ex de,hl
    jp c,search_function
    ;now C is the precedence, with lower bit = 1 if left-associative
    push bc
    push hl
    ld de,(stackhead)
    ld hl,sybuf+768
    sbc hl,de
    ld b,h
    ld c,l
    ld hl,(outhead)
    ex de,hl
    jr z,pushop
    ;a is the precedence against which to compare
_:
    push hl
    push bc
    push af
    ld a,(hl)
    call getprecedence
    jr c,+_
    pop hl
    ld a,h      ;incoming
    cp c
    jr nz,$+4
    rra \ nop

    pop bc
    pop hl
   
 ;======================================================
    jr nc,pushop
.echo "The following code only works until we have to add >1 byte tokens."
 ldi
 ldi
    jp pe,-_
    jp $+6
_:
    pop af
    pop bc
    pop hl
pushop:
    ld (outhead),de
    pop de
    dec hl
    ld (hl),','
    dec hl
    ld a,(de)
    ld (stackhead),hl
    ld (hl),a
    ex de,hl
    pop bc
    ret
search_function:
    push bc
    call hashlookup
    ld a,c
    pop bc
    jp nc,ERR_Func_Not_Found
    push hl
    ld de,(stackhead)
    dec de
    ex de,hl
    ld (hl),','
    ex de,hl
    inc a
    dec de
_:
    ldd
    dec a
    jr nz,-_
    pop hl
    inc de
    ld (stackhead),de
    inc bc
    ret
getprecedence:
    ld hl,binops
    ld b,(binops_end-binops)/2
_:
    cp (hl)
    inc hl
    ld c,(hl)
    ret z
    inc hl
    djnz -_
    scf
    ret
binops:
    .db 4,  $01
    .db '=',$50
    .db '|',$60
    .db '&',$70
    .db '-',$81     ;right associative is odd
    .db '+',$80     ;left associative is even
    .db '/',$83     ;right associative
    .db '*',$82     ;left associative
    .db '^',$85     ;right associative
binops_end:
num:
    ld de,(outhead)
_:
    ldi
    jp po,+_
    ld a,(hl)
    cp '.'
    jr z,num_dec+4
    cp 30h
    jr c,+_
    cp 3Ah
    jr c,-_
_:
    ld a,','
    ld (de),a
    inc de
    ld (outhead),de
    dec hl
    inc bc
    ret
num_dec:
    ld de,(outhead)
_:
    ldi
    jp po,+_
    ld a,(hl)
    cp 30h
    jr c,+_
    cp 3Ah
    jr c,-_
_:
    cp '.'
    jp z,ERR_Syntax_00
    ld a,','
    ld (de),a
    inc de
    ld (outhead),de
    dec hl
    inc bc
    ret



hashlookup:
;HL points to the input
;BC is the max size
;return nc if failed to match, c if success
    ld (input_save),hl
    ld (input_savesize),bc
    ld a,b
    or c
    jr z,match_null
    call computehash
    ld hl,(input_savesize)
    xor a
    sbc hl,bc
    jr z,match_fail
    ld b,h
    ld c,l
    ld d,a
    ex de,hl
    add hl,hl
    ld (hash),hl


    ld de,hashlut_builtin
    add hl,de
    ld e,(hl)
    inc hl
    ld d,(hl)

    ld hl,(input_save)
;BC is the input size
;HL points to the input string
;DE points to the comparison
    ld a,(de)
    cp c
    jr nz,match_fail
    inc de
    ld b,c

_:
    ld a,(de)
    inc de
    cp (hl)
    jr nz,match_fail
    inc hl
    djnz -_
    scf
    ret
match_null:
    ld de,t_null+1
match_fail:
    ld hl,(input_save)
    ld bc,(input_savesize)
    or a
    ret
computehash:
    ld e,0
_:
    ld a,(hl)
    sub 48
    ret c
    cp 10
    jr c,$+5
    sub 7
    ret c
    cp 68
    ret nc
    ld d,a
    add a,a
    add a,d
    xor e
    ld e,a
    cpi
    jp pe,-_
    ret
   
   
hashlut_builtin:
.dw t_null              ;00
.dw t_null              ;01
.dw t_null              ;02
.dw t_null              ;03
.dw t_null              ;04
.dw t_null              ;05
.dw t_null              ;06
.dw t_null              ;07
.dw t_null              ;08
.dw t_null              ;09
.dw t_null              ;0a
.dw t_cosh              ;0b
.dw t_null              ;0c
.dw t_null              ;0d
.dw t_null              ;0e
.dw t_null              ;0f
.dw t_null              ;10
.dw t_null              ;11
.dw t_atan              ;12
.dw t_null              ;13
.dw t_sinh              ;14
.dw t_null              ;15
.dw t_null              ;16
.dw t_null              ;17
.dw t_null              ;18
.dw t_null              ;19
.dw t_null              ;1a
.dw t_null              ;1b
.dw t_sqrt              ;1c
.dw t_null              ;1d
.dw t_null              ;1e
.dw t_max               ;1f
.dw t_null              ;20
.dw t_null              ;21
.dw t_ClrDraw           ;22
.dw t_null              ;23
.dw t_null              ;24
.dw t_null              ;25
.dw t_null              ;26
.dw t_null              ;27
.dw t_null              ;28
.dw t_Ellipse           ;29
.dw t_null              ;2a
.dw t_null              ;2b
.dw t_null              ;2c
.dw t_null              ;2d
.dw t_null              ;2e
.dw t_null              ;2f
.dw t_null              ;30
.dw t_null              ;31
.dw t_null              ;32
.dw t_null              ;33
.dw t_null              ;34
.dw t_null              ;35
.dw t_null              ;36
.dw t_null              ;37
.dw t_null              ;38
.dw t_null              ;39
.dw t_ln                ;3a
.dw t_null              ;3b
.dw t_null              ;3c
.dw t_pi                ;3d
.dw t_null              ;3e
.dw t_null              ;3f
.dw t_null              ;40
.dw t_null              ;41
.dw t_null              ;42
.dw t_null              ;43
.dw t_null              ;44
.dw t_null              ;45
.dw t_null              ;46
.dw t_null              ;47
.dw t_null              ;48
.dw t_null              ;49
.dw t_null              ;4a
.dw t_null              ;4b
.dw t_null              ;4c
.dw t_null              ;4d
.dw t_null              ;4e
.dw t_null              ;4f
.dw t_null              ;50
.dw t_null              ;51
.dw t_null              ;52
.dw t_null              ;53
.dw t_null              ;54
.dw t_null              ;55
.dw t_null              ;56
.dw t_null              ;57
.dw t_null              ;58
.dw t_null              ;59
.dw t_null              ;5a
.dw t_null              ;5b
.dw t_null              ;5c
.dw t_null              ;5d
.dw t_null              ;5e
.dw t_null              ;5f
.dw t_null              ;60
.dw t_null              ;61
.dw t_null              ;62
.dw t_null              ;63
.dw t_null              ;64
.dw t_null              ;65
.dw t_null              ;66
.dw t_null              ;67
.dw t_null              ;68
.dw t_randint           ;69
.dw t_asinh             ;6a
.dw t_null              ;6b
.dw t_tan               ;6c
.dw t_null              ;6d
.dw t_null              ;6e
.dw t_null              ;6f
.dw t_null              ;70
.dw t_null              ;71
.dw t_null              ;72
.dw t_null              ;73
.dw t_null              ;74
.dw t_acosh             ;75
.dw t_null              ;76
.dw t_null              ;77
.dw t_null              ;78
.dw t_null              ;79
.dw t_null              ;7a
.dw t_null              ;7b
.dw t_null              ;7c
.dw t_null              ;7d
.dw t_null              ;7e
.dw t_null              ;7f
.dw t_null              ;80
.dw t_atanh             ;81
.dw t_null              ;82
.dw t_null              ;83
.dw t_null              ;84
.dw t_null              ;85
.dw t_Line              ;86
.dw t_sin               ;87
.dw t_null              ;88
.dw t_null              ;89
.dw t_e                 ;8a
.dw t_null              ;8b
.dw t_null              ;8c
.dw t_mod               ;8d
.dw t_null              ;8e
.dw t_null              ;8f
.dw t_null              ;90
.dw t_min               ;91
.dw t_Circle            ;92
.dw t_gcd               ;93
.dw t_null              ;94
.dw t_null              ;95
.dw t_null              ;96
.dw t_null              ;97
.dw t_cos               ;98
.dw t_null              ;99
.dw t_null              ;9a
.dw t_null              ;9b
.dw t_null              ;9c
.dw t_null              ;9d
.dw t_null              ;9e
.dw t_null              ;9f
.dw t_null              ;a0
.dw t_log2              ;a1
.dw t_null              ;a2
.dw t_Tilemap           ;a3
.dw t_log10             ;a4
.dw t_null              ;a5
.dw t_null              ;a6
.dw t_null              ;a7
.dw t_null              ;a8
.dw t_Text              ;a9
.dw t_null              ;aa
.dw t_null              ;ab
.dw t_null              ;ac
.dw t_null              ;ad
.dw t_Disp              ;ae
.dw t_null              ;af
.dw t_null              ;b0
.dw t_null              ;b1
.dw t_null              ;b2
.dw t_null              ;b3
.dw t_null              ;b4
.dw t_null              ;b5
.dw t_null              ;b6
.dw t_null              ;b7
.dw t_DispBuf           ;b8
.dw t_lcm               ;b9
.dw t_setseed           ;ba
.dw t_null              ;bb
.dw t_null              ;bc
.dw t_null              ;bd
.dw t_null              ;be
.dw t_null              ;bf
.dw t_pow10             ;c0
.dw t_null              ;c1
.dw t_null              ;c2
.dw t_null              ;c3
.dw t_null              ;c4
.dw t_pow2              ;c5
.dw t_null              ;c6
.dw t_null              ;c7
.dw t_null              ;c8
.dw t_null              ;c9
.dw t_null              ;ca
.dw t_null              ;cb
.dw t_null              ;cc
.dw t_null              ;cd
.dw t_null              ;ce
.dw t_null              ;cf
.dw t_null              ;d0
.dw t_null              ;d1
.dw t_null              ;d2
.dw t_null              ;d3
.dw t_null              ;d4
.dw t_null              ;d5
.dw t_null              ;d6
.dw t_null              ;d7
.dw t_null              ;d8
.dw t_null              ;d9
.dw t_null              ;da
.dw t_null              ;db
.dw t_null              ;dc
.dw t_Shiftbuf          ;dd
.dw t_randseed          ;de
.dw t_null              ;df
.dw t_null              ;e0
.dw t_null              ;e1
.dw t_exp               ;e2
.dw t_Output            ;e3
.dw t_null              ;e4
.dw t_Sprite            ;e5
.dw t_acos              ;e6
.dw t_null              ;e7
.dw t_Rect              ;e8
.dw t_null              ;e9
.dw t_null              ;ea
.dw t_null              ;eb
.dw t_null              ;ec
.dw t_rand              ;ed
.dw t_null              ;ee
.dw t_null              ;ef
.dw t_null              ;f0
.dw t_null              ;f1
.dw t_null              ;f2
.dw t_null              ;f3
.dw t_null              ;f4
.dw t_null              ;f5
.dw t_null              ;f6
.dw t_null              ;f7
.dw t_null              ;f8
.dw t_asin              ;f9
.dw t_null              ;fa
.dw t_null              ;fb
.dw t_null              ;fc
.dw t_null              ;fd
.dw t_null              ;fe
.dw t_tanh              ;ff
t_null:
.db 0
t_cosh:
.db 4,"cosh"
#include "commands\cosh.z80"
t_atan:
.db 4,"atan"
#include "commands\atan.z80"
t_sinh:
.db 4,"sinh"
#include "commands\sinh.z80"
t_sqrt:
.db 4,"sqrt"
#include "commands\sqrt.z80"
t_max:
.db 3,"max"
#include "commands\max.z80"
t_ClrDraw:
.db 7,"ClrDraw"
#include "commands\ClrDraw.z80"
t_Ellipse:
.db 7,"Ellipse"
#include "commands\Ellipse.z80"
t_ln:
.db 2,"ln"
#include "commands\ln.z80"
t_pi:
.db 2,"pi"
#include "commands\pi.z80"
t_randint:
.db 7,"randint"
#include "commands\randint.z80"
t_asinh:
.db 5,"asinh"
#include "commands\asinh.z80"
t_tan:
.db 3,"tan"
#include "commands\tan.z80"
t_acosh:
.db 5,"acosh"
#include "commands\acosh.z80"
t_atanh:
.db 5,"atanh"
#include "commands\atanh.z80"
t_Line:
.db 4,"Line"
#include "commands\Line.z80"
t_sin:
.db 3,"sin"
#include "commands\sin.z80"
t_e:
.db 1,"e"
#include "commands\e.z80"
t_mod:
.db 3,"mod"
#include "commands\mod.z80"
t_min:
.db 3,"min"
#include "commands\min.z80"
t_Circle:
.db 6,"Circle"
#include "commands\Circle.z80"
t_gcd:
.db 3,"gcd"
#include "commands\gcd.z80"
t_cos:
.db 3,"cos"
#include "commands\cos.z80"
t_log2:
.db 4,"log2"
#include "commands\log2.z80"
t_Tilemap:
.db 7,"Tilemap"
#include "commands\Tilemap.z80"
t_log10:
.db 5,"log10"
#include "commands\log10.z80"
t_Text:
.db 4,"Text"
#include "commands\Text.z80"
t_Disp:
.db 4,"Disp"
#include "commands\Disp.z80"
t_DispBuf:
.db 7,"DispBuf"
#include "commands\DispBuf.z80"
t_lcm:
.db 3,"lcm"
#include "commands\lcm.z80"
t_setseed:
.db 7,"setseed"
#include "commands\setseed.z80"
t_pow10:
.db 5,"pow10"
#include "commands\pow10.z80"
t_pow2:
.db 4,"pow2"
#include "commands\pow2.z80"
t_Shiftbuf:
.db 8,"Shiftbuf"
#include "commands\Shiftbuf.z80"
t_randseed:
.db 8,"randseed"
#include "commands\randseed.z80"
t_exp:
.db 3,"exp"
#include "commands\exp.z80"
t_Output:
.db 6,"Output"
#include "commands\Output.z80"
t_Sprite:
.db 6,"Sprite"
#include "commands\Sprite.z80"
t_acos:
.db 4,"acos"
#include "commands\acos.z80"
t_Rect:
.db 4,"Rect"
#include "commands\Rect.z80"
t_rand:
.db 4,"rand"
#include "commands\rand.z80"
t_asin:
.db 4,"asin"
#include "commands\asin.z80"
t_tanh:
.db 4,"tanh"
#include "commands\tanh.z80"

poparg:
    ret
tostr:
    ret


ERR_Syntax_00:      ;Too many decimal points.
    ld hl,s_Syntax_00
    jr error
ERR_Func_Not_Found:
    ld hl,s_Func_Not_Found
    jr error
ERR_Unmatched_lparens:
    ld hl,s_Unmatched_lparens
error:
    ld sp,(spsave)
    push hl
    ld hl,s_Err
    bcall(_PutS)
    pop hl
    bcall(_PutS)
    bcall(_NewLine)
    ret
rpn:
    ret
s_Err:
    .db "Err:",0
s_Unmatched_lparens:
    .db "Missing '('",0
s_Syntax_00:
    .db "Too Many '.'",0
s_Func_Not_Found:
    .db "FuncNotFound",0
s_RightArrow:
    .db $3D,$3D,$05,0
test:
;    .db "(3.1415926535)"
.db "asinh(3.142+6/2-7)*3^(6*3)"
test_end: .db 0

.echo $-$9D95," bytes"

It includes error messages for a few typical errors. Unfortunately it is only converting plaintext to plaintext, so there is no compiling or 'tokenizing' or actual evaluation going on-- it's just converting from infix to postfix.

Pages: [1] 2 3 ... 296