这是笔者的计算系统概论这门课的实验之一，实验内容是实现简易的LC-3汇编器，将汇编码转换为机器码，原理较为简单，即利用两次遍历，第一次获取标签信息，第二次实现转换。但具体用代码实现极其繁琐，特别是不止18个指令要一个一个写，所以把写好的代码放在下面供大家参考，注释也写了，如果有看不懂的或有什么问题可以直接问我。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define MAX_LINE_LENGTH 100
//标签链表结构体，用于储存标签名以及标签位置
typedef struct Lable{
char * name;
int pos;
struct Lable *next;
}Lable;
// Function prototypes
void read_asm_file(const char *filename, char lines[][MAX_LINE_LENGTH], int *num_lines);
void write_output_file(const char *filename, const char *output[], int num_lines);
void assemble(char lines[][MAX_LINE_LENGTH], int num_lines, char *output[]);
char * translate_instruction(char *instruction,int line,Lable *head);
char *bin_transfer(char *str,int bit);
char *reg_num(char *str);
Lable *get_lable_pos(char lines[][MAX_LINE_LENGTH],int line_index);
char *word_ascii(char word);
char **my_strtok(const char *source, char flag);
int getIndexOfSigns(char ch);
long hexToDec(char *source);
void reverse(char* left, char* right);
char* to_binary(int n, int m);
// TODO: Define any additional functions you need to implement the assembler, e.g. the symbol table.
int main(int argc, char *argv[])
//int main()
{
// Command-line argument parsing
if (argc != 3)
{
fprintf(stderr, "Usage: %s <input_file.asm> <output_file.txt>
", argv[0]);
return 1;
}
char input_filename[100];
char output_filename[100];
strcpy(input_filename, argv[1]);
strcpy(output_filename, argv[2]);
// printf("input input_filename:
");
// scanf("%s",&input_filename);
// printf("input output_filename:
");
// scanf("%s",&output_filename);
char lines[100][MAX_LINE_LENGTH]; // Assuming a maximum of 100 lines
int num_lines = 0;
read_asm_file(input_filename, lines, &num_lines);
char *output[100]; // Output array of strings
for (int i = 0; i < 100; i++)
{
output[i] = (char *)malloc(MAX_LINE_LENGTH * sizeof(char));
}
assemble(lines, num_lines, output);
write_output_file(output_filename, (const char **)output, num_lines);
// Free allocated memory
for (int i = 0; i < 100; i++)
{
free(output[i]);
}
return 0;
}
void read_asm_file(const char *filename, char lines[][MAX_LINE_LENGTH], int *num_lines)
{
FILE *file = fopen(filename, "r");
if (file == NULL)
{
fprintf(stderr, "Unable to open file: %s
", filename);
exit(1);
}
char line[MAX_LINE_LENGTH];
while (fgets(line, MAX_LINE_LENGTH, file))
{
strcpy(lines[*num_lines], line);
printf("%s",lines[*num_lines]);
(*num_lines)++;
}
fclose(file);
}
void write_output_file(const char *filename, const char *output[], int num_lines)
{
FILE *file = fopen(filename, "w");
if (file == NULL)
{
fprintf(stderr, "Unable to open file: %s
", filename);
exit(1);
}
for (int i = 0; i < num_lines; i++)
{
fprintf(file, "%s
", output[i]);
}
fclose(file);
}
int trans_line = 1;
void assemble(char lines[][MAX_LINE_LENGTH], int num_lines, char *output[])
{
// TODO: Implement the assembly process
// Implement the 2-pass process described in textbook.
Lable *lable;
lable = get_lable_pos(lines,num_lines);//第一次遍历创建标签链表
char *tem_output;
for (int i = 0; i < num_lines; i++)
{
tem_output = translate_instruction(lines[i],i+trans_line,lable);//临时指针存转码结果
strcpy(output[i],tem_output);
printf("
%s",output[i]);//打印结果
}
}
char * translate_instruction(char *instruction,int line,Lable *head)
{
char *machine_code;//要返回的机器码
machine_code = (char *)malloc(MAX_LINE_LENGTH * sizeof(char));//分配空间
char *condition_code;//条件码
//下面是用到的29个指令
char str1[] = ".ORIG";
char str2[] = "ADD";
char str3[] = "AND";
char str4[] = "BR";
char str4_1[] = "BRN";
char str4_2[] = "BRZ";
char str4_3[] = "BRP";
char str4_4[] = "BRNZ";
char str4_5[] = "BRNP";
char str4_6[] = "BRZP";
char str4_7[] = "BRNZP";//BR子指令
char str5[] = "JMP";
char str6[] = "RET";
char str7[] = "JSR";
char str8[] = "JSRR";
char str9[] = "LD";
char str10[] = "LDI";
char str11[] = "LDR";
char str12[] = "LEA";
char str13[] = "NOT";
char str14[] = "RTI";
char str15[] = "ST";
char str16[] = "STI";
char str17[] = "STR";
char str18[] = "TRAP";
char str19[] = ".BLKW";
char str20[] = ".STRINGZ";
char str21[] = ".FILL";
char str22[] = ".END";
char ** single ;//用来存分割后的字符串
char space = ' ';//按空格分割
char enter = '
';//按换行分割，因为字符串最后有
char *reg_number = "000";
char *imm_number = "1";//一些机器码中用到的码
single = my_strtok(instruction,enter);
single = my_strtok(single[0],space);//第一次分割，得到各个子字符串
int bin_num;
int count;//计数，表示是分割后的第几个字符串
for(count = 0;;count++)
{
if(strcmp(single[count],str1) == 0 || strcmp(single[count],str21) == 0)//.ORIG or .FILL
{
single = my_strtok(single[count+1],enter);//去换行操作
machine_code= bin_transfer(single[0],16);//将语句后面带的数直接转为16位二进制编码
break;
}
if(strcmp(single[count],str2) == 0 || strcmp(single[count],str3) == 0)//ADD or AND
{
if(strcmp(single[count],str2) == 0)
{
condition_code = "0001";
}
else
{
condition_code = "0101";//先存入指令码，后面类似
}
strcpy(machine_code,condition_code);
count ++;
if(single[count][0] != '#' && single[count][0] != 'x')//这句并没有多大用处，因为ADD或AND后面两个都是寄存器
{
char *ad_binary_1 = reg_num(single[count++]);//判断寄存器
strcat(machine_code,ad_binary_1);
}
if(single[count][0] != '#' && single[count][0] != 'x')
{
char *ad_binary_2 = reg_num(single[count++]);
strcat(machine_code,ad_binary_2);
}
single = my_strtok(single[count],enter);
if(single[0][0] != '#' && single[0][0] != 'x')//检测是立即数还是寄存器
{
strcat(machine_code,reg_number);
char *ad_binary_3 = reg_num(single[0]);
strcat(machine_code,ad_binary_3);
}
else
{
strcat(machine_code,imm_number);
char *ad_bin;
ad_bin = bin_transfer(single[0],5);
strcat(machine_code,ad_bin);
}
break;
}
if(strcmp(single[count],str4) == 0 || strcmp(single[count],str4_1) == 0 || strcmp(single[count],str4_2) == 0 || strcmp(single[count],str4_3) == 0 || strcmp(single[count],str4_4) == 0 || strcmp(single[count],str4_5) == 0 || strcmp(single[count],str4_6) == 0 || strcmp(single[count],str4_7) == 0)
{
if(strcmp(single[count],str4) == 0 || strcmp(single[count],str4_7) == 0)//BR or BRNZP
{
condition_code = "0000111";
}
if(strcmp(single[count],str4_1) == 0)//BRN
{
condition_code = "0000100";
}
if(strcmp(single[count],str4_2) == 0)//BRZ
{
condition_code = "0000010";
}
if(strcmp(single[count],str4_3) == 0)//BRP
{
condition_code = "0000001";
}
if(strcmp(single[count],str4_4) == 0)//BRNZ
{
condition_code = "0000110";
}
if(strcmp(single[count],str4_5) == 0)//BRNP
{
condition_code = "0000101";
}
if(strcmp(single[count],str4_6) == 0)//BRZP
{
condition_code = "0000011";
}
strcpy(machine_code,condition_code);
count++;
single = my_strtok(single[count],enter);
if(single[0][0] == '#' || single[0][0] == 'x')//检测是立即数还是标签
{
char *br_bin = bin_transfer(single[0],9);
strcat(machine_code,br_bin);
}
else
{
Lable *p = head;
char *br_bin_2;
char *imm_0 = "000000000";
while(p!= NULL)//遍历标签链表找到对应标签所在位置（行数）
{
if(strcmp(single[0],p->name) == 0)
{
int sub = p->pos - 1 - line;//标签行数减PC增量减当前行数
if(sub == 0)
{
strcat(machine_code,imm_0);
break;
}
else
{
br_bin_2 = to_binary(sub,9); //得到差值并转为9位二进制编码
strcat(machine_code,br_bin_2);
break;
}
}
p = p->next;
}
}
break;
}
char *jmp_bin_2 = "000000";
if(strcmp(single[count],str5) == 0 || strcmp(single[count],str6) == 0)//JMP or RET
{
if(strcmp(single[count],str5) == 0)
{
condition_code = "1100000";
strcpy(machine_code,condition_code);
count ++ ;
single = my_strtok(single[count],enter);
char *jmp_bin = reg_num(single[0]);
strcat(machine_code,jmp_bin);
strcat(machine_code,jmp_bin_2);
}
else
{
condition_code = "1100000111000000";
strcpy(machine_code,condition_code);
}
break;
}
if(strcmp(single[count],str7) == 0 || strcmp(single[count],str8) == 0)//JSR or JSRR
{
if(strcmp(single[count],str7) == 0)
{
condition_code = "01001";
strcpy(machine_code,condition_code);
count ++ ;
single = my_strtok(single[count],enter);
if(single[0][0] == '#' || single[0][0] == 'x')
{
char *jsr_num_bin = bin_transfer(single[0],11);
strcat(machine_code,jsr_num_bin);
}
else
{
Lable *jsr_p = head;//同样的检测标签并返回，只不过变为了11位
jsr_p->name = (char *)malloc(100 *sizeof(char));
char *jsr_bin_2;
while(jsr_p != NULL)
{
if(strcmp(single[0],jsr_p->name) == 0)
{
int jsr_sub = jsr_p->pos - 1 - line ;
jsr_bin_2 = to_binary(jsr_sub,11);
break;
}
jsr_p = jsr_p->next;
}
strcat(machine_code,jsr_bin_2);
}
}
else
{
condition_code = "0100000";
strcpy(machine_code,condition_code);
count++;
single = my_strtok(single[count],enter);
char *jsrr_bin = reg_num(single[0]);
strcat(machine_code,jsrr_bin);
strcat(machine_code,jmp_bin_2);
}
break;
}
if(strcmp(single[count],str9) == 0 || strcmp(single[count],str10) == 0 || strcmp(single[count],str15) == 0 ||strcmp(single[count],str16) == 0)//LD or LDI or ST or STI
{
if(strcmp(single[count],str9) == 0)
{
condition_code = "0010";
}
else if(strcmp(single[count],str10) == 0)
{
condition_code = "1010";
}
else if(strcmp(single[count],str15) == 0)
{
condition_code = "0011";
}
else
{
condition_code = "1011";
}
strcpy(machine_code,condition_code);
count ++ ;
char *ld_bin = reg_num(single[count]);
strcat(machine_code,ld_bin);
count ++ ;
single = my_strtok(single[count],enter);
if(single[0][0] == '#' || single[0][0] == 'x')
{
char *ld_num_bin = bin_transfer(single[0],9);
strcat(machine_code,ld_num_bin);
}
else
{
Lable *ld_p = head;
ld_p->name = (char *)malloc(100 *sizeof(char));
char *ld_bin_2;
while(ld_p != NULL)
{
if(strcmp(single[0],ld_p->name) == 0)
{
int ld_sub = ld_p->pos - 1 - line;
ld_bin_2 = to_binary(ld_sub,9);
break;
}
ld_p = ld_p->next;
}
strcat(machine_code,ld_bin_2);
}
break;
}
if(strcmp(single[count],str11) == 0 || strcmp(single[count],str17) == 0)//LDR or STR
{
if(strcmp(single[count],str11) == 0)
{
condition_code = "0110";
}
else
{
condition_code = "0111";
}
strcpy(machine_code,condition_code);
count ++ ;
char *ldr_bin_1 = reg_num(single[count]);
strcat(machine_code,ldr_bin_1);
count ++ ;
char *ldr_bin_2 = reg_num(single[count]);
strcat(machine_code,ldr_bin_2);
count ++ ;
single = my_strtok(single[count],enter);
char *ldr_bin_3 = bin_transfer(single[0],6);
strcat(machine_code,ldr_bin_3);
break;
}
if(strcmp(single[count],str12) == 0)//LEA
{
condition_code = "1110";
strcpy(machine_code,condition_code);
count ++;
char *lea_bin_1 = reg_num(single[count]);
strcat(machine_code,lea_bin_1);
count++;
single = my_strtok(single[count],enter);
if(single[0][0] == '#' || single[0][0] == 'x')
{
char *lea_num_bin = bin_transfer(single[0],9);
strcat(machine_code,lea_num_bin);
}
else
{
Lable *lea_p = head;
lea_p->name = (char *)malloc(100 *sizeof(char));
char *lea_bin_2;
while(lea_p!= NULL)
{
if(strcmp(single[0],lea_p->name) == 0)
{
int lea_sub = lea_p->pos - 1 - line;
lea_bin_2 = to_binary(lea_sub,9);
break;
}
lea_p = lea_p->next;
}
strcat(machine_code,lea_bin_2);
}
break;
}
if(strcmp(single[count],str13) == 0)//NOT
{
condition_code = "1001";
strcpy(machine_code,condition_code);
count ++ ;
char *not_bin_1 = reg_num(single[count]);
strcat(machine_code,not_bin_1);
count ++ ;
single = my_strtok(single[count],enter);
char *not_bin_2 = reg_num(single[0]);
strcat(machine_code,not_bin_2);
char *not_bin_3 = "111111";
strcat(machine_code,not_bin_3);
break;
}
if(strcmp(single[count],str14) == 0)//RTI
{
condition_code= "1000000000000000";
strcpy(machine_code,condition_code);
break;
}
if(strcmp(single[count],str18) == 0)//.TRAP
{
condition_code = "11110000";
strcpy(machine_code,condition_code);
count++;
single = my_strtok(single[count],enter);
char *trap_bin = bin_transfer(single[0],8);
strcat(machine_code,trap_bin);
break;
}
if(strcmp(single[count],str19) == 0)//.BLKW
{
count++;
int blkw_dec;
if(single[count][0] == 'x')
{
char blkw_tem1 = 'x';
single = my_strtok(single[count],blkw_tem1);
blkw_dec = hexToDec(single[0]);
}
if(single[count][0] == '#')
{
char blkw_tem2 = '#';
single = my_strtok(single[count],blkw_tem2);
blkw_dec = strtol(single[0],NULL,10);
}
trans_line += blkw_dec - 1;
char *blkw_bin_1 = "0000000000000000";
char *blkw_bin_2 = "0000000000000000
";
if(blkw_dec == 1)
{
machine_code = "0000000000000000";
}
else
{
for(int bi = 0;bi<blkw_dec - 1;bi++)//表示存入多少行的16位的0
{
if(bi == 0)
{
condition_code = "0000000000000000
" ;
strcpy(machine_code,condition_code);
}
else
{
strcat(machine_code,blkw_bin_2);
}
}
strcat(machine_code,blkw_bin_1);
}
break;
}
if(strcmp(single[count],str20) == 0)//.STRINGZ
{
char ascii_bin[100] = {0};
count++;
char *space_1 = " ";
while(single[count]!=NULL)
{
strcat(ascii_bin,single[count]);
strcat(ascii_bin,space_1);
count ++;
}
int trans_pos = strlen(ascii_bin) - 3;
trans_line += trans_pos;//全局变量控制当前语句行数，只有BLKW和STRINGZ会改变
single = my_strtok(ascii_bin,enter);
int si = 1;
char *enter_1 = "
";//换行
while(single[0][si]!='"' && single[0][si+1]!=' ')//把双引号内的字符串一个一个转换为ascii值对应的二进制数并存入
{
if(si == 1)
{
condition_code = word_ascii(single[0][si]);
strcpy(machine_code,condition_code);
strcat(machine_code,enter_1);
}
else if(single[0][si+1]!='"')
{
char *str_bin = word_ascii(single[0][si]);
strcat(machine_code,str_bin);
strcat(machine_code,enter_1);
}
else
{
char *str_bin_2 = word_ascii(single[0][si]);
strcat(machine_code,str_bin_2);
char *zero = "0000000000000000";
strcat(machine_code,enter_1);
strcat(machine_code,zero);
}
si++;
}
break;
}
if(strcmp(single[count],str22) == 0)//.END
{
machine_code = " ";
break;
}
}
return machine_code;
}
char *word_ascii(char word)//字母转换为ascii值并转换为16位二进制编码
{
int ascii = (int)word;
char *ascii_bin = to_binary(ascii,16);
return ascii_bin;
}
Lable *get_lable_pos(char lines[][MAX_LINE_LENGTH],int line_index)
{
char *str[] = {".ORIG","ADD","AND","BR","BRN",
"BRZ","BRP","BRNZ","BRNP","BRZP",
"BRNZP","JMP","RET","JSR","JSRR",
"LD","LDI","LDR","LEA","NOT","RTI",
"ST","STI","STR","TRAP",".BLKW",
".STRINGZ",".FILL",".END"};
char **act_str;
Lable *lable_head = (Lable*)malloc(sizeof(Lable)); //标签链表头结点
int j = 0;
int temp = 0;
int str_pos = 0;
for(int k = 0 ;k<line_index;k++)
{
char *instroction = lines[k];
char space_lable = ' ';
char enter_lable = '
';
char **act_str_son;
act_str = my_strtok(instroction,space_lable);
act_str_son = my_strtok(act_str[0],enter_lable);
temp = 0;
for(int j = 0;j<29;j++)
{
if(strcmp(act_str_son[0],str[j])!=0)
{
temp++;
}
}
if(temp == 29)//当不是这29个指令时，记为标签，头插法创建标签链表
{
Lable *p = (Lable*)malloc(sizeof(Lable));
p->name = (char*)malloc(100 * sizeof(char));
strcpy(p->name,act_str_son[0]);
p->pos = k + str_pos + 1;//记录标签位置
p->next = lable_head ->next;
lable_head->next = p;
if(strcmp(act_str[1],str[26]) == 0)//STRINGZ进行更改
{
char str_len[100] = {0};
char *space_2 = " ";
int m = 2;
while(act_str[m]!=NULL)
{
strcat(str_len,act_str[m]);
strcat(str_len,space_2);
m ++;
}
str_pos += strlen(str_len) - 4;//减4是两个双引号，多加的空格和最后的换行
}
if(strcmp(act_str[1],str[25]) == 0)//BLKW进行更改
{
char lable_tem = '#';
act_str = my_strtok(act_str_son[2],lable_tem);
int lable_dec = strtol(act_str[0],NULL,10);
str_pos += lable_dec;
}
}
}
return lable_head;
}
char *reg_num(char *str)//检测寄存器模块，输出为寄存器对应二进制编码
{
char reg1[] = "R0";
char reg2[] = "R1";
char reg3[] = "R2";
char reg4[] = "R3";
char reg5[] = "R4";
char reg6[] = "R5";
char reg7[] = "R6";
char reg8[] = "R7";
char tem = ',';
char **reg_str;
reg_str = my_strtok(str,tem);//去逗号
char *bin = (char *)malloc(sizeof(char) * 3);
if(strcmp(reg_str[0],reg1) == 0)
{
bin = "000";
}
if(strcmp(reg_str[0],reg2) == 0)
{
bin = "001";
}
if(strcmp(reg_str[0],reg3) == 0)
{
bin = "010";
}
if(strcmp(reg_str[0],reg4) == 0)
{
bin = "011";
}
if(strcmp(reg_str[0],reg5) == 0)
{
bin = "100";
}
if(strcmp(reg_str[0],reg6) == 0)
{
bin = "101";
}
if(strcmp(reg_str[0],reg7) == 0)
{
bin = "110";
}
if(strcmp(reg_str[0],reg8) == 0)
{
bin = "111";
}
return bin;
}
char **my_strtok(const char *source, char flag)
{
char **pt;
int j, n = 0;
int count = 1;
int len = strlen(source);
// 动态分配一个 *tmp，静态的话，变量len无法用于下标
char *tmp = (char*)malloc((len + 1) * sizeof(char));
tmp[0] = ' ';
for (int i = 0; i < len; ++i)
{
if (source[i] == flag && source[i+1] == ' ')
continue;
else if (source[i] == flag && source[i+1] != flag)
count++;
}
// 多分配一个char*，是为了设置结束标志
pt = (char**)malloc((count+1) * sizeof(char*));
count = 0;
for (int i = 0; i < len; ++i)
{
if (i == len - 1 && source[i] != flag)
{
tmp[n++] = source[i];
tmp[n] = ' '; // 字符串末尾添加空字符
j = strlen(tmp) + 1;
pt[count] = (char*)malloc(j * sizeof(char));
strcpy(pt[count++], tmp);
}
else if (source[i] == flag)
{
j = strlen(tmp);
if (j != 0)
{
tmp[n] = ' '; // 字符串末尾添加空字符
pt[count] = (char*)malloc((j+1) * sizeof(char));
strcpy(pt[count++], tmp);
// 重置tmp
n = 0;
tmp[0] = ' ';
}
}
else
tmp[n++] = source[i];
}
free(tmp);
// 设置结束标志
pt[count] = NULL;
return pt;
}
void reverse(char* left, char* right) //翻转数组
{
while (left < right) {
char tmp = *right;
*right = *left;
*left = tmp;
left++;
right--;
}
}
char* to_binary(int n, int m)//假设要求m位二进制数
{
char a[10000] = { ' ' };
int i = 0;
int n_2 = 0;
if(n<0)//若是负数
{
n = abs(n);
n_2 = pow(2,m-1);
n = n_2 - n;//2的n-1次方减去绝对值得补码
while (n != 0)
{
a[i++] = '0' + n % 2;
n = n / 2;
}
reverse(a, a + strlen(a) - 1);
char b[10000] = {'1'};
for (int i = 1; i < m - strlen(a); i++)
{
b[i] = '0';
}
return strcat(b,a);
}
else
{
while (n != 0)
{
a[i++] = '0' + n % 2;
n = n / 2;
}
reverse(a, a + strlen(a) - 1);
char b[10000] = {' '};
for (int i = 0; i < m - strlen(a); i++)
{
b[i] = '0';
}
return strcat(b,a);
}
}
long hexToDec(char *source)//十六进制转十进制
{
long sum = 0;
long t = 1;
int i, len;
len = strlen(source);
for(i=len-1; i>=0; i--)
{
sum += t * getIndexOfSigns(*(source + i));
t *= 16;
}
return sum;
}
int getIndexOfSigns(char ch)
{
if(ch >= '0' && ch <= '9')
{
return ch - '0';
}
if(ch >= 'A' && ch <='F')
{
return ch - 'A' + 10;
}
if(ch >= 'a' && ch <= 'f')
{
return ch - 'a' + 10;
}
return -1;
}
char *bin_transfer(char *str,int bit)//"xn" or "#n"转换为二进制编码字符串
{
int dec;
char *bin = (char *)malloc(sizeof(char) * 16);
int index = 0;
char **bin_str;
if(str[0] == 'x')
{
char tem = 'x';
bin_str = my_strtok(str,tem);
dec = hexToDec(bin_str[0]);
}
if(str[0] == '#')
{
char tem = '#';
bin_str = my_strtok(str,tem);
dec = strtol(bin_str[0],NULL,10);
}
char *binary = to_binary(dec,bit);
return binary;
}