Thread: Building an assembler in C O_o

Read a line. Parse its contents. Basically, chop each line into its words. The number of words per line will likely be determined by what the first word actually is. So in this case, you look at add, and after figuring out that it says "add", you know that it has X number of parts after it. Those parts are then added, or whatever it is the command is supposed to do.


Quzah.

How different are those instructions? In my experience, assembler instructions come in groups that have similar features, e.g. there's math/binary operations such as
add, sub, mul, div, and, or, xor, shifts (e.g. lsr, lsl), rotates (ror, rol).
move/load/store instructions to read/write memory.
conditional jumps
unconditional jump and call instruction
return instruction
and there's usually a couple of "odd" instructions that don't resemble any others.

For each of thos groups (except the last one), you can share code to decode and validate the parameters/arguments/operands (whatever you want to call them).

You obviously need to split the line BEFORE that, at least enough to find out which instruction it is.

--
Mats

Originally Posted by Evenstevens

Therein lies the problem though. There's like...30 different "types" of instruction. So I have no idea at what angle to come at this from.

How about with a list of say ... 30 elements?

Quzah.

Parse a line

Means tokenize everything. Is it a mnemonic? Is it whitespace? Is it an expression? You need to compare the input against valid symbols. Then check if the symbols are valid against a grammar.

Declare an enum or array of all possible symbols (all mnemonics, keywords, etc.). Now run through the line and check for your symbols. If a valid symbol is found, you want to save the symbol to check against the grammar.

Grammar might look like this on paper:

<line> := <mnemonic> <op> [, <op>]*
<mnemonic> := <term_ops> | <expr_ops> | <mem_ops> | ......
<op> := <register> | <immediate> | <address>
etc...

The grammar could get complicated, but it all depends on what your assembler needs to support. If it's fairly simple then you could probably get away with a few checks (check that there's a mnemonic and that it has necessary number of operands).

Yes. Make something to reflect every operation. Hell just to get something rolling, I'd probably make a structure for each one, and fill out a table of them as well:

Code:

struct ops oplist[] =
{
    { "nop", 0, 0, NULL },
    { "syscall", 1, 0, func_syscall },
    ...
};

Fit your structure to have whatever fields you need. Like for example, the number of ops, or the actual op code, and possibly a function pointer of what function they should be performing.


Quzah.