I recommend you create it with a computer programming language (like lua or python) first so that you can have the concept done and then "port" it to axe because it would be somewhat more difficult to do it initially in axe because axe doesn't come with dynamic arrays (I am not implying that it should though, I like axe how it is.)

I recommend you create it with a computer programming language (like lua or python) first so that you can have the concept done and then "port" it to axe because it would be somewhat more difficult to do it initially in axe because axe doesn't come with dynamic arrays (I am not implying that it should though, I like axe how it is.)

It would be even more difficult to have to port it from a "high level" language into Axe, so I'd say that coding in Axe direcly is a better idea.

Ok I came up with a partial algorithm, but I may need some assistance coding it. Order of operations goes PEMDAS, so parentheses are first. So, my idea is to loop:



input->A
A->W
While inData(')',A)
   ;; in the example 3x + (7x + 4x + (3x) - (2x-1))
   ;; while we have a ), this will keep looping
   While inData('(',W)<inData(')',A)
       If inData('(',W) < inData(')',A)
           inData('(',W) -> Z
           End
       inData('(',W) + 1 -> W
   ;; while the next ( we find is in front of the ), we loop.
   ;; When it moves behind it, we are in a new nested parentheses, so we stop looping.
   ;;  Z is saved, so we can recall correct location.
   End
 ;; Once we are out of the second while loop, we can copy the innermost parentheses...
 ;; contents to another location in RAM, and zero terminate it, or length pre-pend it.
 ;; then we delete the contents of that paren from the source string. doing so eliminates that...
 ;; ), so that the first while loop returns the position of the next ) in its test, so we loop until parens...
 ;; are all gone.
End   

Ok I came up with a partial algorithm, but I may need some assistance coding it. Order of operations goes PEMDAS, so parentheses are first. So, my idea is to loop:

Code: [Select]

input->A
A->W
While inData(')',A)
   ;; in the example 3x + (7x + 4x + (3x) - (2x-1))
   ;; while we have a ), this will keep looping
   While inData('(',W)<inData(')',A)
       If inData('(',W) < inData(')',A)
           inData('(',W) -> Z
           End
       inData('(',W) + 1 -> W
   ;; while the next ( we find is in front of the ), we loop.
   ;; When it moves behind it, we are in a new nested parentheses, so we stop looping.
   ;;  Z is saved, so we can recall correct location.
   End
 ;; Once we are out of the second while loop, we can copy the innermost parentheses...
 ;; contents to another location in RAM, and zero terminate it, or length pre-pend it.
 ;; then we delete the contents of that paren from the source string. doing so eliminates that...
 ;; ), so that the first while loop returns the position of the next ) in its test, so we loop until parens...
 ;; are all gone.
End   

bump on that.

When i talk to people about order of operations...they say "make a tree". but my question is...how the heck do you make a "tree" in assembly? you just have arrays of bytes...

Ok, that helps a bit. So as a follow up to that... is Axe advanced enough now to take arbitrary Label names? Like you said sub(evaluate, [arg]). Can I do LBL EVALUATE? Or must I use the 2-character label names?

Nice! Didn't know that. Haven't been up to date on Axe's features before now. :p Is that the same for variable names now? Anything else it can do? lol

Thats pretty awesome. So it seems to me like Axe is being designed to at least *feel* like using a C-style language for the computer. Am I right?

As for functions, how about direct ROM call injection? Like using b_call(_MD5Init) or something, that require certain registers as input? Or if its not implemented, maybe a variation on sub(, where argument one is the ROM call name, and the other arguments are like loads into registers, in {PTR}->[register] format?


Edit: So here would be an all-text algorithm..


Lbl Evaluate


1. if number of ( > number of ); then error one or more paren not closed
2. if number of ( < number of ); then error, too many )
3. find innermost (...), dump expression into scrap RAM
4. repeat 3 for each wrapping (...), until there are no parentheses left to evaluate. Each iteration of this becomes an "entry" in scrap RAM. When we have no more parentheses, we dump the rest of the expression into scrap RAM.
5. For each entry in scrap RAM, break apart entry into expressions, by the operator, and perform * and / before + and -.


Would that work?