...

typedef struct {
WhatKind kind;
double num;
char op;
} TOKEN;

aah... i still don't get it... what are "lexemes"?

ok

Given the lack of code tags, I would have to agree with that statement.

relay01,

I don't know if your question was answered or not.

I believe your professor means that TOKEN should be one of the math functions.
A * B - C / (D + E)

Each of the MULTIPLY, DIVIDE, ADD, SUBTRACT are the "TOKENS" to which your professor is referring.

You should probably have two strings: infixString and postfixString.

Basically:

1) You are given an INFIX problem (like above)
2) Parse the INFIX expression, and print out the resulting POSTFIX expression
- i) For each character that is read in from the infixString, perform the following:
- ii) If the input character is a letter, append that letter to the end of postfixString
- iii) If the input character is a TOKEN, put that TOKEN onto a stack which you will retrieve later
- iv) If the next input character is another letter, get (read: POP) the TOP element from your stack and insert it onto the end of your postfixString.
- v) You have to make sure to check the preference of the TOKENS when you remove them: *, / and % have higher precedence than + or -, so be sure to remove the correct one.
3) Output, at the very end, the POSTFIX string

The only exception to the above is if your professor's code includes parentheses (like in my example INFIX expression). If he does, once you encounter a ), you have to loop though all the items in your stack until you find the ( and push everything you find into your postfixString.

This way, the above will do this:
A * B - C / (D + E)

infixString          postfixString                  myStack
-----------          -------------                  -------
A                    A                              (empty)
*                                                   *
B                    AB*                            (empty) -- (because we removed the "*")
-                    AB*                            -
C                    AB*C                           - (not removed because the NEXT character is higher-precedence: "/")
/                    AB*C                           -/
(                    AB*C                           -/(
D                    AB*CD                          -/(
+                    AB*CD                          -/(+
E                    AB*CDE+                        -/( (removed the "+")
)                    AB*CDE+                        -/ (removed the "(")
                     AB*CDE+/                       - (still inside the FOR..LOOP for the ")" TOKEN)
                     AB*CDE+/-                      (empty)

I hope that helps somewhat with your assignment.

Not if he also had to actually compile to machine code Knowing the assembler would go a long way to understanding the workings of the chip/system, and what to compile the code to

Um, compiling code isn't compiler theory? Whod'a thunk it!

I think you need to read what I said again

That last message I was pulling your chain

Maybe hes just old? IIRC his day job involves a lot of COBOL. (at least I think its him..)

I think hes saying writing it IN assembler isn't so much compiler theory, and may get in the way of teaching pure compiler theory.

Yes, that's what I'm saying Thomas. I haven't said that writing an assembler isn't a compiler theory thing, at least I don't think so? I've said that learning assembler isn't a compiler theory thing and that you would probably want to use a high level language if you want to create a compiler. As you will get more stuff done and have a greater freedom to experiment.

I couldn't stand the thought of having to do that for my two VM projects, so I ended up writing some nice assemblers for both of them first one was two pass, so you could actually reference labels that are declared after you use them