devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言实现简易LC-3汇编器_lc3汇编语言string指令

作者：神奇cpp | 2024-08-17 09:50:07

赞

踩

lc3汇编语言string指令

        这是笔者的计算系统概论这门课的实验之一，实验内容是实现简易的LC-3汇编器，将汇编码转换为机器码，原理较为简单，即利用两次遍历，第一次获取标签信息，第二次实现转换。但具体用代码实现极其繁琐，特别是不止18个指令要一个一个写，所以把写好的代码放在下面供大家参考，注释也写了，如果有看不懂的或有什么问题可以直接问我。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <math.h>
  5.  
  6. #define MAX_LINE_LENGTH 100
  7.  
  8. //标签链表结构体，用于储存标签名以及标签位置
  9. typedef struct Lable{
  10. 	char * name;
  11. 	int pos;
  12. 	struct Lable *next;
  13. }Lable;
  14.  
  15. // Function prototypes
  16. void read_asm_file(const char *filename, char lines[][MAX_LINE_LENGTH], int *num_lines);
  17. void write_output_file(const char *filename, const char *output[], int num_lines);
  18. void assemble(char lines[][MAX_LINE_LENGTH], int num_lines, char *output[]);
  19. char * translate_instruction(char *instruction,int line,Lable *head);
  20. char *bin_transfer(char *str,int bit);
  21. char *reg_num(char *str);
  22. Lable *get_lable_pos(char lines[][MAX_LINE_LENGTH],int line_index);
  23. char *word_ascii(char word);
  24. char **my_strtok(const char *source, char flag);
  25. int getIndexOfSigns(char ch);
  26. long hexToDec(char *source);
  27. void reverse(char* left, char* right);
  28. char* to_binary(int n, int m);
  29.  
  30. // TODO: Define any additional functions you need to implement the assembler, e.g. the symbol table.
  31.  
  32.  
  33.  
  34. int main(int argc, char *argv[])
  35. //int main()
  36. {
  37.     // Command-line argument parsing
  38.     if (argc != 3)
  39.     {
  40.         fprintf(stderr, "Usage: %s <input_file.asm> <output_file.txt>\n", argv[0]);
  41.         return 1;
  42.     }
  43.  
  44.     char input_filename[100];
  45.     char output_filename[100];
  46.     strcpy(input_filename, argv[1]);
  47.     strcpy(output_filename, argv[2]);
  48.  
  49. //	printf("input input_filename:\n");
  50. //	scanf("%s",&input_filename);
  51. //	printf("input output_filename:\n");
  52. //	scanf("%s",&output_filename);
  53.  
  54. 	
  55.     char lines[100][MAX_LINE_LENGTH]; // Assuming a maximum of 100 lines
  56.     int num_lines = 0;
  57.     read_asm_file(input_filename, lines, &num_lines);
  58.  
  59.     char *output[100]; // Output array of strings
  60.     for (int i = 0; i < 100; i++)
  61.     {
  62.         output[i] = (char *)malloc(MAX_LINE_LENGTH * sizeof(char));
  63.     }
  64.  
  65.     assemble(lines, num_lines, output);
  66.     write_output_file(output_filename, (const char **)output, num_lines);
  67.  
  68.     // Free allocated memory
  69.     for (int i = 0; i < 100; i++)
  70.     {
  71.         free(output[i]);
  72.     }
  73.  
  74.     return 0;
  75. }
  76.  
  77. void read_asm_file(const char *filename, char lines[][MAX_LINE_LENGTH], int *num_lines)
  78. {
  79.     FILE *file = fopen(filename, "r");
  80.     if (file == NULL)
  81.     {
  82.         fprintf(stderr, "Unable to open file: %s\n", filename);
  83.         exit(1);
  84.     }
  85.  
  86.     char line[MAX_LINE_LENGTH];
  87.     while (fgets(line, MAX_LINE_LENGTH, file))
  88.     {
  89.         strcpy(lines[*num_lines], line);
  90.         printf("%s",lines[*num_lines]);
  91.         (*num_lines)++;
  92.     }
  93.  
  94.     fclose(file);
  95. }
  96.  
  97. void write_output_file(const char *filename, const char *output[], int num_lines)
  98. {
  99.     FILE *file = fopen(filename, "w");
  100.     if (file == NULL)
  101.     {
  102.         fprintf(stderr, "Unable to open file: %s\n", filename);
  103.         exit(1);
  104.     }
  105.  
  106.     for (int i = 0; i < num_lines; i++)
  107.     {
  108.         fprintf(file, "%s\n", output[i]);
  109.     }
  110.  
  111.     fclose(file);
  112. }
  113. int trans_line = 1;
  114. void assemble(char lines[][MAX_LINE_LENGTH], int num_lines, char *output[])
  115. {
  116.     // TODO: Implement the assembly process
  117.     // Implement the 2-pass process described in textbook.
  118.     Lable *lable;
  119.     lable = get_lable_pos(lines,num_lines);//第一次遍历创建标签链表
  120.     char *tem_output;
  121.     for (int i = 0; i < num_lines; i++)
  122.     {   	
  123.         tem_output = translate_instruction(lines[i],i+trans_line,lable);//临时指针存转码结果
  124.         strcpy(output[i],tem_output);
  125.         printf("\n%s",output[i]);//打印结果
  126.     }
  127. }
  128.  
  129. char * translate_instruction(char *instruction,int line,Lable *head)
  130. {
  131. 	char *machine_code;//要返回的机器码
  132. 	machine_code = (char *)malloc(MAX_LINE_LENGTH * sizeof(char));//分配空间
  133. 	char *condition_code;//条件码
  134. 	//下面是用到的29个指令
  135.     char str1[] = ".ORIG";
  136.     char str2[] = "ADD";
  137.     char str3[] = "AND";
  138.     char str4[] = "BR";
  139.     	char str4_1[] = "BRN";
  140.     	char str4_2[] = "BRZ";
  141.     	char str4_3[] = "BRP";
  142.     	char str4_4[] = "BRNZ";
  143.     	char str4_5[] = "BRNP";
  144.     	char str4_6[] = "BRZP";
  145.     	char str4_7[] = "BRNZP";//BR子指令
  146.     char str5[] = "JMP";
  147.     char str6[] = "RET";
  148.     char str7[] = "JSR";
  149.     char str8[] = "JSRR";
  150.     char str9[] = "LD";
  151.     char str10[] = "LDI";
  152.     char str11[] = "LDR";
  153.     char str12[] = "LEA";
  154. 	char str13[] = "NOT";
  155. 	char str14[] = "RTI";
  156. 	char str15[] = "ST";
  157. 	char str16[] = "STI";
  158. 	char str17[] = "STR";
  159. 	char str18[] = "TRAP";
  160. 	char str19[] = ".BLKW";
  161. 	char str20[] = ".STRINGZ";
  162. 	char str21[] = ".FILL";
  163. 	char str22[] = ".END";
  164. 	 
  165.     char ** single ;//用来存分割后的字符串
  166.     char space = ' ';//按空格分割
  167.     char enter = '\n';//按换行分割，因为字符串最后有\n
  168.     char *reg_number = "000";
  169.     char *imm_number = "1";//一些机器码中用到的码
  170.     single = my_strtok(instruction,enter);
  171.     single = my_strtok(single[0],space);//第一次分割，得到各个子字符串
  172.     int bin_num;
  173.     int count;//计数，表示是分割后的第几个字符串
  174. 	for(count = 0;;count++)
  175. 	{
  176. 		if(strcmp(single[count],str1) == 0 || strcmp(single[count],str21) == 0)//.ORIG or .FILL
  177. 		{
  178. 			single = my_strtok(single[count+1],enter);//去换行操作
  179. 			machine_code= bin_transfer(single[0],16);//将语句后面带的数直接转为16位二进制编码
  180. 			break;			
  181. 		}
  182. 		if(strcmp(single[count],str2) == 0 || strcmp(single[count],str3) == 0)//ADD or AND
  183. 		{
  184. 			if(strcmp(single[count],str2) == 0)
  185. 			{
  186. 				condition_code = "0001";				
  187. 			}
  188. 			else
  189. 			{
  190. 				condition_code = "0101";//先存入指令码，后面类似
  191. 			}
  192. 			strcpy(machine_code,condition_code);
  193. 			count ++;
  194. 			if(single[count][0] != '#' && single[count][0] != 'x')//这句并没有多大用处，因为ADD或AND后面两个都是寄存器
  195. 			{
  196. 				char *ad_binary_1 = reg_num(single[count++]);//判断寄存器
  197. 				strcat(machine_code,ad_binary_1);
  198. 			}
  199. 			if(single[count][0] != '#' && single[count][0] != 'x')
  200. 			{
  201. 				char *ad_binary_2 = reg_num(single[count++]);
  202. 				strcat(machine_code,ad_binary_2);
  203. 			}
  204. 			single = my_strtok(single[count],enter);
  205. 			if(single[0][0] != '#' && single[0][0] != 'x')//检测是立即数还是寄存器
  206. 			{
  207. 				strcat(machine_code,reg_number);
  208. 				char *ad_binary_3 = reg_num(single[0]);
  209. 				strcat(machine_code,ad_binary_3);
  210. 			}
  211. 			else
  212. 			{
  213. 				strcat(machine_code,imm_number);
  214. 				char *ad_bin;
  215. 				ad_bin = bin_transfer(single[0],5);
  216. 				strcat(machine_code,ad_bin);
  217. 			}
  218. 			break;
  219. 		}
  220. 		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)
  221. 		{
  222. 			if(strcmp(single[count],str4) == 0 || strcmp(single[count],str4_7) == 0)//BR or BRNZP
  223. 			{
  224. 				condition_code = "0000111";						
  225. 			}
  226. 			if(strcmp(single[count],str4_1) == 0)//BRN
  227. 			{
  228. 				condition_code = "0000100";
  229. 			}
  230. 			if(strcmp(single[count],str4_2) == 0)//BRZ
  231. 			{
  232. 				condition_code = "0000010";
  233. 			}
  234. 			if(strcmp(single[count],str4_3) == 0)//BRP
  235. 			{
  236. 				condition_code = "0000001";
  237. 			}
  238. 			if(strcmp(single[count],str4_4) == 0)//BRNZ
  239. 			{
  240. 				condition_code = "0000110";
  241. 			}
  242. 			if(strcmp(single[count],str4_5) == 0)//BRNP
  243. 			{
  244. 				condition_code = "0000101";
  245. 			}
  246. 			if(strcmp(single[count],str4_6) == 0)//BRZP
  247. 			{
  248. 				condition_code = "0000011";
  249. 			}
  250. 			strcpy(machine_code,condition_code);
  251. 			count++;
  252. 			single = my_strtok(single[count],enter);
  253. 			if(single[0][0] == '#' || single[0][0] == 'x')//检测是立即数还是标签
  254. 			{
  255. 				char *br_bin = bin_transfer(single[0],9);
  256. 				strcat(machine_code,br_bin);
  257. 			}
  258. 			else
  259. 			{
  260. 				Lable *p = head;
  261. 				char *br_bin_2;
  262. 				char *imm_0 = "000000000";
  263. 				while(p!= NULL)//遍历标签链表找到对应标签所在位置（行数）
  264. 				{
  265. 					if(strcmp(single[0],p->name) == 0)
  266. 					{
  267. 						int sub = p->pos - 1 - line;//标签行数减PC增量减当前行数
  268. 						if(sub == 0)
  269. 						{
  270. 							strcat(machine_code,imm_0);
  271. 							break;
  272. 						}
  273. 						else
  274. 						{
  275. 							br_bin_2 = to_binary(sub,9);	//得到差值并转为9位二进制编码
  276. 							strcat(machine_code,br_bin_2);				
  277. 							break;
  278. 						}
  279. 					}
  280. 					p = p->next;
  281. 				}				
  282. 			}
  283. 			break;
  284. 		}
  285. 		char *jmp_bin_2 = "000000";
  286. 		if(strcmp(single[count],str5) == 0 || strcmp(single[count],str6) == 0)//JMP or RET
  287. 		{
  288. 			if(strcmp(single[count],str5) == 0)
  289. 			{
  290. 				condition_code = "1100000";
  291. 				strcpy(machine_code,condition_code);
  292. 				count ++ ;
  293. 				single = my_strtok(single[count],enter);
  294. 				char *jmp_bin = reg_num(single[0]);	
  295. 				strcat(machine_code,jmp_bin);			
  296. 				strcat(machine_code,jmp_bin_2);				
  297. 			}
  298. 			else
  299. 			{
  300. 				condition_code = "1100000111000000";
  301. 				strcpy(machine_code,condition_code);
  302. 			}
  303. 			break;
  304. 		}
  305. 		if(strcmp(single[count],str7) == 0 || strcmp(single[count],str8) == 0)//JSR or JSRR
  306. 		{
  307. 			if(strcmp(single[count],str7) == 0)
  308. 			{
  309. 				condition_code = "01001";
  310. 				strcpy(machine_code,condition_code);
  311. 				count ++ ;
  312. 				single = my_strtok(single[count],enter);
  313. 				if(single[0][0] == '#' || single[0][0] == 'x')
  314. 				{
  315. 					char *jsr_num_bin  = bin_transfer(single[0],11);
  316. 					strcat(machine_code,jsr_num_bin);
  317. 				}
  318. 				else
  319. 				{
  320. 					Lable *jsr_p = head;//同样的检测标签并返回，只不过变为了11位
  321. 					jsr_p->name = (char *)malloc(100 *sizeof(char));
  322. 					char *jsr_bin_2;
  323. 					while(jsr_p != NULL)
  324. 					{
  325. 						if(strcmp(single[0],jsr_p->name) == 0)
  326. 						{
  327. 							int jsr_sub = jsr_p->pos - 1 - line ;
  328. 							jsr_bin_2 = to_binary(jsr_sub,11);	
  329. 							break;					
  330. 						}
  331. 						jsr_p = jsr_p->next;
  332. 					}
  333. 					strcat(machine_code,jsr_bin_2);				
  334. 				}
  335. 			}
  336. 			else
  337. 			{
  338. 				condition_code = "0100000";
  339. 				strcpy(machine_code,condition_code);
  340. 				count++;
  341. 				single = my_strtok(single[count],enter);
  342. 				char *jsrr_bin = reg_num(single[0]);
  343. 				strcat(machine_code,jsrr_bin);
  344. 				strcat(machine_code,jmp_bin_2);
  345. 			}
  346. 			break;
  347. 		}
  348. 		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
  349. 		{
  350. 			if(strcmp(single[count],str9) == 0)
  351. 			{
  352. 				condition_code = "0010";				
  353. 			}
  354. 			else if(strcmp(single[count],str10) == 0)
  355. 			{
  356. 				condition_code = "1010";
  357. 			}
  358. 			else if(strcmp(single[count],str15) == 0)
  359. 			{
  360. 				condition_code = "0011";
  361. 			}
  362. 			else
  363. 			{
  364. 				condition_code = "1011";
  365. 			}
  366. 			strcpy(machine_code,condition_code);
  367. 			count ++ ;
  368. 			char *ld_bin = reg_num(single[count]);
  369. 			strcat(machine_code,ld_bin);
  370. 			count ++ ;
  371. 			single = my_strtok(single[count],enter);
  372. 			if(single[0][0] == '#' || single[0][0] == 'x')
  373. 			{
  374. 				char *ld_num_bin  = bin_transfer(single[0],9);
  375. 				strcat(machine_code,ld_num_bin);
  376. 			}		
  377. 			else
  378. 			{
  379. 				Lable *ld_p = head;
  380. 				ld_p->name = (char *)malloc(100 *sizeof(char));
  381. 				char *ld_bin_2;
  382. 				while(ld_p != NULL)
  383. 				{
  384. 					if(strcmp(single[0],ld_p->name) == 0)
  385. 					{
  386. 						int ld_sub = ld_p->pos - 1 - line;
  387. 						ld_bin_2 = to_binary(ld_sub,9);
  388. 						break;						
  389. 					}
  390. 					ld_p = ld_p->next;
  391. 				}
  392. 				strcat(machine_code,ld_bin_2);				
  393. 			}	
  394.  
  395. 			break;			
  396. 		}
  397. 		if(strcmp(single[count],str11) == 0 || strcmp(single[count],str17) == 0)//LDR or STR
  398. 		{
  399. 			if(strcmp(single[count],str11) == 0)
  400. 			{
  401. 				condition_code = "0110";
  402. 			}
  403. 			else
  404. 			{
  405. 				condition_code = "0111";
  406. 			}
  407. 			strcpy(machine_code,condition_code);
  408. 			count ++ ;
  409. 			char *ldr_bin_1 = reg_num(single[count]);
  410. 			strcat(machine_code,ldr_bin_1);
  411. 			count ++ ;
  412. 			char *ldr_bin_2 = reg_num(single[count]);
  413. 			strcat(machine_code,ldr_bin_2);
  414. 			count ++ ;
  415. 			single = my_strtok(single[count],enter);
  416. 			char *ldr_bin_3 = bin_transfer(single[0],6);
  417. 			strcat(machine_code,ldr_bin_3);
  418. 			break;
  419. 		}
  420. 		if(strcmp(single[count],str12) == 0)//LEA
  421. 		{
  422. 			condition_code = "1110";
  423. 			strcpy(machine_code,condition_code);
  424. 			count ++;
  425. 			char *lea_bin_1 = reg_num(single[count]);
  426. 			
  427. 			strcat(machine_code,lea_bin_1);
  428. 			count++;
  429. 			single = my_strtok(single[count],enter);
  430. 			if(single[0][0] == '#' || single[0][0] == 'x')
  431. 			{
  432. 				char *lea_num_bin  = bin_transfer(single[0],9);
  433. 				strcat(machine_code,lea_num_bin);
  434. 			}
  435. 			else
  436. 			{
  437. 				Lable *lea_p = head;
  438. 				lea_p->name = (char *)malloc(100 *sizeof(char));
  439. 				char *lea_bin_2;
  440. 				while(lea_p!= NULL)
  441. 				{
  442. 					if(strcmp(single[0],lea_p->name) == 0)
  443. 					{
  444. 						int lea_sub = lea_p->pos - 1 - line;
  445. 						lea_bin_2 = to_binary(lea_sub,9);
  446. 						break;						
  447. 					}
  448. 					lea_p = lea_p->next;
  449. 				}
  450. 				strcat(machine_code,lea_bin_2);					
  451. 			}	
  452. 			break;		
  453. 		}
  454. 		if(strcmp(single[count],str13) == 0)//NOT
  455. 		{
  456. 			condition_code = "1001";
  457. 			strcpy(machine_code,condition_code);
  458. 			count ++ ;
  459. 			char *not_bin_1 = reg_num(single[count]);
  460. 			strcat(machine_code,not_bin_1);
  461. 			count ++ ;
  462. 			single = my_strtok(single[count],enter);
  463. 			char *not_bin_2 = reg_num(single[0]);
  464. 			strcat(machine_code,not_bin_2);	
  465. 			char *not_bin_3 = "111111";
  466. 			strcat(machine_code,not_bin_3);	
  467. 			break;				
  468. 		}
  469. 		if(strcmp(single[count],str14) == 0)//RTI
  470. 		{
  471. 			condition_code= "1000000000000000";
  472. 			strcpy(machine_code,condition_code);
  473. 			break;
  474. 		}
  475. 		if(strcmp(single[count],str18) == 0)//.TRAP
  476. 		{
  477. 			condition_code = "11110000";
  478. 			strcpy(machine_code,condition_code);
  479. 			count++;
  480. 			single = my_strtok(single[count],enter);
  481. 			char *trap_bin = bin_transfer(single[0],8);
  482. 			strcat(machine_code,trap_bin);
  483. 			break;
  484. 		}
  485. 		if(strcmp(single[count],str19) == 0)//.BLKW
  486. 		{
  487. 			count++;
  488. 			int blkw_dec;
  489. 			if(single[count][0] == 'x')
  490. 			{
  491. 				char blkw_tem1 = 'x';
  492. 				single = my_strtok(single[count],blkw_tem1);
  493. 				blkw_dec = hexToDec(single[0]);
  494. 			}
  495. 			if(single[count][0] == '#')
  496. 			{
  497. 				char blkw_tem2 = '#';
  498. 				single = my_strtok(single[count],blkw_tem2);
  499. 				blkw_dec = strtol(single[0],NULL,10);
  500. 			}
  501. 			trans_line += blkw_dec - 1;
  502. 			char *blkw_bin_1 = "0000000000000000";
  503. 			char *blkw_bin_2 = "0000000000000000\n";
  504. 			if(blkw_dec == 1)
  505. 			{
  506. 				machine_code = "0000000000000000";
  507. 			}
  508. 			else
  509. 			{
  510. 				for(int bi = 0;bi<blkw_dec - 1;bi++)//表示存入多少行的16位的0
  511. 				{
  512. 					if(bi == 0)
  513. 					{
  514. 						condition_code = "0000000000000000\n"	;
  515. 						strcpy(machine_code,condition_code);
  516. 					}
  517. 					else
  518. 					{
  519. 						strcat(machine_code,blkw_bin_2);
  520. 					}
  521. 				}
  522. 				strcat(machine_code,blkw_bin_1);
  523. 			}
  524. 			break;			
  525. 		}
  526. 		if(strcmp(single[count],str20) == 0)//.STRINGZ
  527. 		{
  528. 			char ascii_bin[100] = {0};
  529. 			count++;
  530. 			char *space_1 = " ";
  531. 			while(single[count]!=NULL)
  532. 			{
  533. 				strcat(ascii_bin,single[count]);
  534. 				strcat(ascii_bin,space_1);
  535. 				count ++;
  536. 			}
  537. 			int trans_pos = strlen(ascii_bin) - 3;
  538. 			trans_line += trans_pos;//全局变量控制当前语句行数，只有BLKW和STRINGZ会改变
  539. 			single = my_strtok(ascii_bin,enter);
  540. 			int si = 1;
  541. 			char *enter_1 = "\n";//换行
  542. 			while(single[0][si]!='"' && single[0][si+1]!='\0')//把双引号内的字符串一个一个转换为ascii值对应的二进制数并存入
  543. 			{
  544. 				if(si == 1)
  545. 				{
  546. 					condition_code = word_ascii(single[0][si]);
  547. 					strcpy(machine_code,condition_code);
  548. 					strcat(machine_code,enter_1);
  549. 				}
  550. 				else if(single[0][si+1]!='"')
  551. 				{
  552. 					char *str_bin = word_ascii(single[0][si]);
  553. 					strcat(machine_code,str_bin);
  554. 					strcat(machine_code,enter_1);
  555. 				}
  556. 				else
  557. 				{
  558. 					char *str_bin_2 = word_ascii(single[0][si]);
  559. 					strcat(machine_code,str_bin_2);	
  560. 					char *zero = "0000000000000000";
  561. 					strcat(machine_code,enter_1);
  562. 					strcat(machine_code,zero);				
  563. 				}
  564. 				si++;
  565. 			}
  566. 			break;
  567. 		}
  568. 		if(strcmp(single[count],str22) == 0)//.END
  569. 		{
  570. 			machine_code = "\0";
  571. 			break;
  572. 		}		
  573. 	}
  574. 	return machine_code;
  575. }
  576.  
  577. char *word_ascii(char word)//字母转换为ascii值并转换为16位二进制编码
  578. {
  579. 	int ascii = (int)word;
  580. 	char *ascii_bin = to_binary(ascii,16);
  581. 	return ascii_bin;
  582. }
  583.  
  584. Lable *get_lable_pos(char lines[][MAX_LINE_LENGTH],int line_index)
  585. {
  586. 	    char *str[] = {".ORIG","ADD","AND","BR","BRN",
  587. 						"BRZ","BRP","BRNZ","BRNP","BRZP",
  588. 						"BRNZP","JMP","RET","JSR","JSRR",
  589. 						"LD","LDI","LDR","LEA","NOT","RTI",
  590. 						"ST","STI","STR","TRAP",".BLKW",
  591.  						".STRINGZ",".FILL",".END"};
  592.  	char **act_str;
  593.  	Lable  *lable_head = (Lable*)malloc(sizeof(Lable)); //标签链表头结点
  594.  	int j = 0;
  595.  	int temp = 0;
  596.  	int str_pos = 0;
  597. 	for(int k = 0 ;k<line_index;k++)
  598. 	{
  599. 		char *instroction = lines[k];
  600.  		char space_lable = ' ';
  601.  		char enter_lable = '\n';
  602.  		char **act_str_son;
  603.  		act_str = my_strtok(instroction,space_lable);
  604.  		act_str_son = my_strtok(act_str[0],enter_lable);
  605. 		temp = 0;
  606. 		for(int j = 0;j<29;j++)
  607. 		{
  608. 			if(strcmp(act_str_son[0],str[j])!=0)
  609. 			{
  610. 				temp++;
  611. 			}
  612. 		}
  613. 		if(temp == 29)//当不是这29个指令时，记为标签，头插法创建标签链表
  614. 		{
  615. 			Lable *p = (Lable*)malloc(sizeof(Lable)); 
  616. 			p->name = (char*)malloc(100 * sizeof(char));
  617. 			strcpy(p->name,act_str_son[0]);
  618. 			p->pos = k + str_pos + 1;//记录标签位置
  619. 			p->next = lable_head ->next;
  620. 			lable_head->next = p;
  621. 			if(strcmp(act_str[1],str[26]) == 0)//STRINGZ进行更改
  622. 			{
  623. 				char str_len[100] = {0};
  624. 				char *space_2 = " ";
  625. 				int m = 2;
  626. 				while(act_str[m]!=NULL)
  627. 				{
  628. 					strcat(str_len,act_str[m]);
  629. 					strcat(str_len,space_2);
  630. 					m ++;
  631. 				}
  632. 				str_pos += strlen(str_len) - 4;//减4是两个双引号，多加的空格和最后的换行
  633. 			}
  634. 			if(strcmp(act_str[1],str[25]) == 0)//BLKW进行更改
  635. 			{
  636. 				char lable_tem = '#';
  637. 				act_str = my_strtok(act_str_son[2],lable_tem);
  638. 				int lable_dec = strtol(act_str[0],NULL,10);
  639. 				str_pos += lable_dec;
  640. 			}			
  641. 		}			
  642. 	}
  643. 	return lable_head;
  644. }
  645.  
  646. char *reg_num(char *str)//检测寄存器模块，输出为寄存器对应二进制编码
  647. {
  648. 		char reg1[] = "R0";
  649. 		char reg2[] = "R1";
  650. 		char reg3[] = "R2";
  651. 		char reg4[] = "R3";
  652. 		char reg5[] = "R4";
  653. 		char reg6[] = "R5";
  654. 		char reg7[] = "R6";
  655. 		char reg8[] = "R7";
  656. 		
  657. 		char tem = ',';
  658. 	char **reg_str;	
  659. 	reg_str = my_strtok(str,tem);//去逗号	
  660. 	char *bin = (char *)malloc(sizeof(char) * 3);
  661. 	if(strcmp(reg_str[0],reg1) == 0)
  662. 	{
  663. 		bin = "000";
  664. 	}
  665. 	if(strcmp(reg_str[0],reg2) == 0)
  666. 	{
  667. 		bin = "001";
  668. 	}
  669. 	if(strcmp(reg_str[0],reg3) == 0)
  670. 	{
  671. 		bin = "010";
  672. 	}
  673. 	if(strcmp(reg_str[0],reg4) == 0)
  674. 	{
  675. 		bin = "011";
  676. 	}
  677. 	if(strcmp(reg_str[0],reg5) == 0)
  678. 	{
  679. 		bin = "100";
  680. 	}
  681. 	if(strcmp(reg_str[0],reg6) == 0)
  682. 	{
  683. 		bin = "101";
  684. 	}
  685. 	if(strcmp(reg_str[0],reg7) == 0)
  686. 	{
  687. 		bin = "110";
  688. 	}
  689. 	if(strcmp(reg_str[0],reg8) == 0)
  690. 	{
  691. 		bin = "111";
  692. 	}
  693. 	return bin;
  694. }
  695.  
  696. char **my_strtok(const char *source, char flag)
  697. {
  698.     char **pt;
  699.     int j, n = 0;
  700.     int count = 1;
  701.     int len = strlen(source);
  702.     // 动态分配一个 *tmp，静态的话，变量len无法用于下标
  703.     char *tmp = (char*)malloc((len + 1) * sizeof(char));
  704.     tmp[0] = '\0';
  705.  
  706.     for (int i = 0; i < len; ++i)
  707.     {
  708.         if (source[i] == flag && source[i+1] == '\0')
  709.             continue;
  710.         else if (source[i] == flag && source[i+1] != flag)
  711.             count++;
  712.     }
  713.     // 多分配一个char*，是为了设置结束标志
  714.     pt = (char**)malloc((count+1) * sizeof(char*));
  715.  
  716.     count = 0;
  717.     for (int i = 0; i < len; ++i)
  718.     {
  719.         if (i == len - 1 && source[i] != flag)
  720.         {
  721.             tmp[n++] = source[i];
  722.             tmp[n] = '\0';  // 字符串末尾添加空字符
  723.             j = strlen(tmp) + 1;
  724.             pt[count] = (char*)malloc(j * sizeof(char));
  725.             strcpy(pt[count++], tmp);
  726.         }
  727.         else if (source[i] == flag)
  728.         {
  729.             j = strlen(tmp);
  730.             if (j != 0)
  731.             {
  732.                 tmp[n] = '\0';  // 字符串末尾添加空字符
  733.                 pt[count] = (char*)malloc((j+1) * sizeof(char));
  734.                 strcpy(pt[count++], tmp);
  735.                 // 重置tmp
  736.                 n = 0;
  737.                 tmp[0] = '\0';
  738.             }
  739.         }
  740.         else
  741.             tmp[n++] = source[i];
  742.     }
  743. 	free(tmp);	
  744.     // 设置结束标志
  745.     pt[count] = NULL;
  746.     return pt;
  747. }
  748.  
  749. void reverse(char* left, char* right) //翻转数组
  750. {
  751. 	while (left < right) {
  752. 		char tmp = *right;
  753. 		*right = *left;
  754. 		*left = tmp;
  755. 		left++;
  756. 		right--;
  757. 	}
  758. }
  759. char* to_binary(int n, int m)//假设要求m位二进制数
  760. {
  761. 	char a[10000] = { '\0' };
  762. 	int i = 0;
  763. 	int n_2 = 0;
  764. 	if(n<0)//若是负数
  765. 	{
  766. 		n = abs(n);
  767. 		n_2 = pow(2,m-1);
  768. 		n = n_2 - n;//2的n-1次方减去绝对值得补码
  769. 		while (n != 0)
  770. 		{
  771. 			a[i++] = '0' + n % 2;
  772. 			n = n / 2;
  773. 		}
  774. 		reverse(a, a + strlen(a) - 1);
  775. 		char b[10000] = {'1'};
  776. 		for (int i = 1; i < m - strlen(a); i++)
  777. 		{
  778. 			b[i] = '0';
  779. 		}
  780. 		return strcat(b,a);
  781. 	}
  782. 	else
  783. 	{
  784. 		while (n != 0)
  785. 		{
  786. 			a[i++] = '0' + n % 2;
  787. 			n = n / 2;
  788. 		}
  789. 		reverse(a, a + strlen(a) - 1);			
  790. 		char b[10000] = {'\0'};		
  791. 		for (int i = 0; i < m - strlen(a); i++)
  792. 		{
  793. 			b[i] = '0';
  794. 		}
  795. 		return strcat(b,a);
  796. 	}
  797. }
  798.  
  799. long hexToDec(char *source)//十六进制转十进制
  800. {
  801.     long sum = 0;
  802.     long t = 1;
  803.     int i, len;
  804.  
  805.     len = strlen(source);
  806.     for(i=len-1; i>=0; i--)
  807.     {
  808.         sum += t * getIndexOfSigns(*(source + i));
  809.         t *= 16;
  810.     }  
  811.  
  812.     return sum;
  813. }
  814.  
  815. int getIndexOfSigns(char ch)
  816. {
  817.     if(ch >= '0' && ch <= '9')
  818.     {
  819.         return ch - '0';
  820.     }
  821.     if(ch >= 'A' && ch <='F') 
  822.     {
  823.         return ch - 'A' + 10;
  824.     }
  825.     if(ch >= 'a' && ch <= 'f')
  826.     {
  827.         return ch - 'a' + 10;
  828.     }
  829.     return -1;
  830. }
  831.  
  832. char *bin_transfer(char *str,int bit)//"xn" or "#n"转换为二进制编码字符串
  833. {
  834. 	int dec;
  835. 	char *bin = (char *)malloc(sizeof(char) * 16);
  836. 	int index = 0;
  837. 	char **bin_str;
  838. 	if(str[0] == 'x')
  839. 	{
  840. 		char tem = 'x';
  841. 		bin_str = my_strtok(str,tem);
  842. 		dec = hexToDec(bin_str[0]);
  843.  
  844. 	}
  845. 	if(str[0] == '#')
  846. 	{
  847. 		char tem = '#';
  848. 		bin_str = my_strtok(str,tem);
  849. 		dec = strtol(bin_str[0],NULL,10);
  850. 	}
  851. 	char *binary = to_binary(dec,bit);
  852. 	return binary;
  853. }

1月25日更：

        注意，这个代码中的.STRINGZ实现的是把字符串存入后再把下一个内存空间置为x0000，即和标准功能一样，但如果最后一个.STRINGZ不需要这样做的话（即.END前面跟的是.STRINGZ，末尾没必要加x0000），需要修改代码，加一个全局变量来控制输出，如下所示：

  1. int end_flag = 0;
  2. void assemble(...)
  3. {
  4.     //...下面的内容放在for循环里
  5.     char check_space = ' ';
  6.     char check_enter = '\n';
  7.     if(i!=num_lines-1)
  8.     {
  9.         char **check = my_strtok(lines[i],check_space);
  10.         char **check_next = my_strtok(lines[i+1],check_enter);
  11.         int k = 0;
  12.         char check_str1[] = ".STRINGZ";
  13.         char check_str2[] = ".END";
  14.         while(check[k]!=NULL)
  15.         {
  16.             if(strcmp(check[k],check_str1) == 0)
  17.             {
  18.                 if(strcmp(check_next[0],check_str2) == 0)
  19.                 {
  20.                     end_flag = 1;
  21.                 }
  22.                 else
  23.                 {
  24.                 k++;
  25.                 }
  26.             }
  27.         }
  28.     }
  29. }
  30. //同时修改translate函数中的.STRINGZ分支，只需判断end_flag即可
  31. char * translate_instruction(...)
  32. {
  33.     //...
  34. 	else
  35. 	{
  36. 		char *str_bin_2 = word_ascii(single[0][si]);
  37. 		strcat(machine_code,str_bin_2);	
  38. 		char *zero = "0000000000000000";
  39. 		strcat(machine_code,enter_1);
  40.         if(end_flag == 0)
  41.         {        
  42. 			strcat(machine_code,zero);	
  43.         }			
  44. 	}

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号