Support for other variables is just  find and replace. You would probably do that when you parse the numbers to convert them into whatever format you plan on using, just replace the variable with the value it holds.

Step 2 and 4 will use  the same code to parse, since there won't be any parentheses to evaluate in step 2 (you've found the innermost parenthesis), so you should just need one last call to the parse routine (that handles the multiplication, division, etc.). I think step 3 is unnecessary.

EDIT: Also, there are more possible errors than just the parentheses, for example you need to make sure there is a number/expression before and after every operator (2+3* is invalid, as is +2+3*4) and ideally you'd have something in between the parentheses (not "2+3*( )" ), but i would set that aside for now. I wrote a little parsing routine last night just to see how difficult this project would be, currently it just converts the numbers into a 2-byte number (that fits inside hl/de/bc/etc.) and finds the first parenthesis.

I'm just saying that once you're at step 3, you should have a simplified equation, so all you need to do is pass that last equation back to your routine for evaluating expressions once more. You can just overwrite the space you're working with (it should be smaller anyway), there's no need to copy it someplace else, evaluate that, then copy it back. Just evaluate what you have there the same as you did for all the parenthesis pairs, just like treating it as if there were one final set of parentheses around the equation: ( 2+4*(3/(7+1))+3 ).

Also, when Axe command lists say a command takes EXPR as an argument, what does that mean exactly? What's the difference between EXPR and an Axe list, or an array of bytes?

In the command list, EXP signifies any expression that returns a numerical result.

Deep Thought gave me another way to do it, which I'll modify slightly.

Create a stack, with number (or var), operator, and precedence,

where precedence is  OpPrec + ( 2 * N).
OpPrec = 0 for addition or subtraction, 1 for multiplication and division
N = nesting level; every time we hit a (, we add 1 to N. Every time we hit a ), we minus 1 from N

Imagine the following:  7x + 3x^2 - (x^2 + (2x - 1))
7 is pushed as the the number
implicit multiplication, so * pushed
precedence = 1 + (2*0)
x is pushed as number
+ pushed
precedence 0
... and so on until...
hit the first (. Add 1 to N. N=1
x^2 is the value
operator is +
precedence is 0 + (2*1) = 2
hit next (. Add 1 to N. N=2
2 is the value
implicit multiplication.
precedence is 1 + (2 * 2) = 5
... and so on

Then, you take that stack, and process it in order of descending precedence.

clrhome.org. He owns. Im one of the admins. I have ways to get a hold of him lol.

That sounds pretty much like what we were talking about before, only the other way didn't require a special stack as it's processed on the fly. That sounds like a fine method to me, personally i would start working on converting something like "3+2(4-1)" into "3 + 2*4 + 2*-1". Once you get to that point, adding X shouldn't be too difficult.