Question

我正在制作8051汇编程序。

在一切都是读取下一个令牌的标记器之前，设置错误标志，识别EOF等然后是编译器的主循环，它读取下一个标记并检查有效的助记符：

mnemonic= NextToken();
if (mnemonic.Error)
{
    //throw some error
}
else if (mnemonic.Text == "ADD")
{
    ...
}
else if (mnemonic.Text == "ADDC")
{
    ...
}

还有几例。更糟糕的是每个案例中的代码，它检查有效参数然后将其转换为编译代码。现在它看起来像这样：

if (mnemonic.Text == "MOV")
{
    arg1 = NextToken();
    if (arg1.Error) { /* throw error */ break; }
    arg2 = NextToken();
    if (arg2.Error) { /* throw error */ break; }

    if (arg1.Text == "A")
    {
        if (arg2.Text == "B")
            output << 0x1234; //Example compiled code
        else if (arg2.Text == "@B")
            output << 0x5678; //Example compiled code
        else
            /* throw "Invalid parameters" */
    }
    else if (arg1.Text == "B")
    {
        if (arg2.Text == "A")
            output << 0x9ABC; //Example compiled code
        else if (arg2.Text == "@A")
            output << 0x0DEF; //Example compiled code
        else
            /* throw "Invalid parameters" */
    }
}

对于每个助记符，我必须检查有效参数，然后创建正确的编译代码。用于检查每种情况下每个助记符重复的有效参数的代码非常相似。

是否有改进此代码的设计模式？
或者只是一种更简单的方法来实现它？

编辑：我接受了基座的回答，谢谢他。如果你有这方面的想法，我将很乐意学习它们。谢谢大家。

Answer 1

多年来我编写了许多汇编程序进行手工解析，坦率地说，使用语法语言和解析器生成器可能会更好。

这就是原因 - 典型的装配线可能看起来像这样：

[label:] [instruction|directive][newline]

并且指令将是：

plain-mnemonic|mnemonic-withargs

并且指令将是：

plain-directive|directive-withargs

等

使用像Gold这样的解析器生成器，您应该能够在几个小时内删除8051的语法。这种过度解析的优点是，您可以在汇编代码中使用足够复杂的表达式，如：

.define kMagicNumber 0xdeadbeef
CMPA #(2 * kMagicNumber + 1)

这可能是一个真正的熊手工做。

如果您想手动完成，请列出所有助记符，其中还包括它们支持的各种允许寻址模式以及每种寻址模式，每个变量将采用的字节数以及操作码的操作码它。像这样：

enum {
    Implied = 1, Direct = 2, Extended = 4, Indexed = 8 // etc
} AddressingMode; 

/* for a 4 char mnemonic, this struct will be 5 bytes.  A typical small processor
 * has on the order of 100 instructions, making this table come in at ~500 bytes when all
 * is said and done.
 * The time to binary search that will be, worst case 8 compares on the mnemonic.
 * I claim that I/O will take way more time than look up.
 * You will also need a table and/or a routine that given a mnemonic and addressing mode
 * will give you the actual opcode.
 */

struct InstructionInfo {
    char Mnemonic[4];
    char AddessingMode;
}

/* order them by mnemonic */
static InstructionInfo instrs[] = {
    { {'A', 'D', 'D', '\0'}, Direct|Extended|Indexed },
    { {'A', 'D', 'D', 'A'}, Direct|Extended|Indexed },
    { {'S', 'U', 'B', '\0'}, Direct|Extended|Indexed },
    { {'S', 'U', 'B', 'A'}, Direct|Extended|Indexed }
}; /* etc */

static int nInstrs = sizeof(instrs)/sizeof(InstrcutionInfo);

InstructionInfo *GetInstruction(char *mnemonic) {
   /* binary search for mnemonic */
}

int InstructionSize(AddressingMode mode)
{
    switch (mode) {
    case Inplied: return 1;
    / * etc */
    }
 }

然后你将得到每个指令的列表，而这些指令又包含所有寻址模式的列表。

所以你的解析器会变成这样：

char *line = ReadLine();
int nextStart = 0;
int labelLen;
char *label = GetLabel(line, &labelLen, nextStart, &nextStart); // may be empty
int mnemonicLen;
char *mnemonic = GetMnemonic(line, &mnemonicLen, nextStart, &nextStart); // may be empty
if (IsOpcode(mnemonic, mnemonicLen)) {
    AddressingModeInfo info = GetAddressingModeInfo(line, nextStart, &nextStart);
    if (IsValidInstruction(mnemonic, info)) {
        GenerateCode(mnemonic, info);
    }
    else throw new BadInstructionException(mnemonic, info);
}
else if (IsDirective()) { /* etc. */ }

Answer 2

是。大多数汇编程序使用描述指令的数据表：助记符，操作码，操作数表等。

我建议查看as的源代码。 ~~我找不到它。~~看here。（感谢Hossein。）

Answer 3

我认为你应该研究访客模式。它可能不会使您的代码更简单，但会减少耦合并提高可重用性。 SableCC是一个java框架，用于构建广泛使用它的编译器。

Answer 4

您是否看过“Command Dispatcher”模式？

http://en.wikipedia.org/wiki/Command_pattern

一般的想法是创建一个处理每个指令（命令）的对象，并创建一个将每个指令映射到处理程序类的查找表。每个命令类都有一个公共接口（例如Command.Execute（* args）），这肯定会给你一个比你当前庞大的switch语句更清晰/更灵活的设计。

Answer 5

当我使用Microcode模拟器工具时，我将所有内容转换为Instruction类的后代。来自Instruction的是类别类，例如Arithmetic_Instruction和Branch_Instruction。我使用 factory 模式来创建实例。

您最好的选择是获得汇编语言语法规范。写一个 lexer 来转换为令牌（**请不要使用if-elseif-else梯子）。然后基于语义，发出代码。

很久以前，汇编程序至少有两次传递：第一次解析常量并形成骨架代码（包括符号表）。第二步是产生更具体或绝对的价值。

你最近读过龙书吗？

制作汇编程序的设计模式

5 个答案: