pcode.c

Table des matières

Description du code

Génération de p-code Compilateur LSD010

Code source ou contenu du fichier

  1. /*
  2.  * pcode.c : generation of p-code
  3.  * Part of the compiler project for LSD10 language
  4.  * Gaudry Stéphane
  5.  * More information on http://www.gaudry.be/langages-pcode.html
  6.  */
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #if(VERBOSE_LEVEL<=DEB_E)
  10. 	#include <errno.h>
  11. #endif
  12.  
  13. #include "common.h"
  14. #include "y.tab.h"
  15.  
  16. /*
  17.  * **********************************************************
  18.  * Internal business implementations
  19.  * **********************************************************
  20.  */
  21.  
  22. extern int num_lines;
  23. extern char* yytext;
  24. extern int *yylineno;
  25.  
  26. extern AstNode *rootNode;
  27.  
  28. FILE* pcodeFile;
  29. #define RESERVED_MEM 5
  30. int pcodeGenValue(AstNode *node);
  31. /**
  32.  * Wrapper function to get location
  33.  * This calls table of symbols method, and compute shift for reserved memory
  34.  * Internal business
  35.  */
  36. int getShiftedMemoryLocation(AstNode *node)
  37. {
  38. 	if (node == NULL || !isSymbolsTableAvailable())
  39. 	{
  40. 		onError("AST node and Table of Symbols must not be NULL", __FILE__, __LINE__, node);
  41. 		//Failure of the compiler behavior, independent of the parsed code
  42. 		exit(EXIT_FAILURE);
  43. 	}
  44.  
  45. 	int location=INITIAL_INT;
  46. 	switch(node->type)
  47. 	{
  48. 		case LEXICAL_RETURN_STMT:
  49. 			location=RESERVED_MEM;
  50. 			break;
  51. 		case NODE_TYPE_FUNCTION_CALL:
  52. 		 	location = getDeclarationMemoryLocation(node)+RESERVED_MEM;
  53. 		 	location += node->info->scopeDepth>1?RESERVED_MEM:1;
  54. 			break;
  55. 		default:
  56. 			location = getDeclarationMemoryLocation(node);
  57. 			if(location<0)location=0;
  58. 		 	//if( node->info->scopeDepth>=1)location += RESERVED_MEM;
  59. 			break;
  60. 	}
  61. 	return location;
  62. }
  63. /**
  64.  * Returns the depth difference between the call node and the declaration node
  65.  * @see IHDCB332 séance 1.pdf "Laboratoire LSD010" slide 40
  66.  */
  67. int getDepthDiff(AstNode *node)
  68. {
  69. 	AstNode *declaration = getDeclaration(node);
  70. //	printPCode(
  71. //		pcodeFile,
  72. //		";\t%s depth %d, declaration depth=%d\n",
  73. //		node->info->name,
  74. //		node->info->scopeDepth,
  75. //		declaration->info->scopeDepth
  76. //		);
  77. 	int locationDiff = (node->info->scopeDepth - declaration->info->scopeDepth)-1;
  78.  
  79. 	return locationDiff<0?0:locationDiff;
  80. }
  81. void printLoad(int type, int depthDiff, int location)
  82. {
  83. 	switch(type)
  84. 	{
  85. 		case AST_INTEGER_VAR_TYPE:
  86. 			printPCode(pcodeFile, "lda i %d %d\n", depthDiff, location);
  87. 			break;
  88. 		case AST_BOOLEAN_VAR_TYPE:
  89. 			printPCode(pcodeFile, "lda b %d %d\n", depthDiff, location);
  90. 			break;
  91. 		case AST_INSTACK_VAR_TYPE:
  92. 			//@todo: by val, by address
  93. 			//printPCode(pcodeFile, "lda a %d %d\n", getDepthDiff(node), location+RESERVED_MEM);
  94. 			break;
  95. 	}
  96. }
  97. int pcodeGenAddress(AstNode *node)
  98. {
  99.  
  100. 	if (node == NULL)
  101. 	{
  102. 		return 0;
  103. 	}
  104. 	if(!isSymbolsTableAvailable())
  105. 	{
  106. 		onError("Table of Symbols must not be NULL", __FILE__, __LINE__, node);
  107. 		//Failure of the compiler behavior, independent of the parsed code
  108. 		exit(EXIT_FAILURE);
  109. 	}
  110.  
  111. //	printPCode(pcodeFile, ";\tGenerate address for node %s\n", node->info->name);
  112.  
  113. 	int location;
  114. 	int depthDiff = 0;
  115. 	switch (node->type)
  116. 	{
  117. 		case NODE_TYPE_ID:
  118. 			location = getShiftedMemoryLocation(node);
  119. 			depthDiff=getDepthDiff(node);
  120. 			printPCode(pcodeFile, ";\tGenerate address for %s variable\n",node->info->name);
  121. 			printLoad(node->info->computedType, depthDiff, location+RESERVED_MEM);
  122. 			break;
  123. //		case LEXICAL_RETURN_STMT:
  124. //			printPCode(pcodeFile, ";\tStart generate address for return statement\n");
  125. //			location = getShiftedMemoryLocation(node);
  126. //			printLoad(node->info->computedType, depthDiff, location);
  127. //			switch(node->info->computedType)
  128. //			{
  129. //				case AST_INTEGER_VAR_TYPE:
  130. //					printPCode(pcodeFile, "ind i\n");
  131. //					printPCode(pcodeFile, "sto i\n");
  132. //					break;
  133. //				case AST_BOOLEAN_VAR_TYPE:
  134. //					printPCode(pcodeFile, "ind b\n");
  135. //					printPCode(pcodeFile, "sto b\n");
  136. //					break;
  137. //			}
  138. //			printPCode(pcodeFile, ";\tEnd generate address for return statement\n");
  139. //			break;
  140. 	}
  141.  
  142. 	return 0;
  143. }
  144. /**
  145.  *
  146.  */
  147. void pcodeGenParam(AstNode *node)
  148. {
  149. //	printPCode(
  150. //		pcodeFile,
  151. //		";\tGenerate %s Parameter (compiler %s, %d)\n",
  152. //		node->info->name,
  153. //		__FILE__,
  154. //		__LINE__
  155. //		);
  156. 	switch(node->subtype)
  157. 	{
  158. 		case LEXICAL_VAR://NODE_DECL_PADR:
  159. 			pcodeGenAddress(node);
  160. 		break;
  161. 		default://case NODE_DECL_PVAL:
  162. 			pcodeGenValue(node);
  163. 		break;
  164. 		/*
  165. 		 * case stack by val :
  166. 		 * pcodeGenValue(node);
  167. 		 * printPCode(pcodeFile, "ind a");
  168. 		 */
  169. 	}
  170. }
  171. /**
  172.  * Recursive method to produce p-code from AST
  173.  */
  174. int pcodeGenValue(AstNode *node)
  175. {
  176. 	int location = INITIAL_INT;
  177. 	static int staticLabel = 0;
  178. 	int label = staticLabel;
  179. 	int rightLabel = INITIAL_INT;
  180. 	int leftLabel = INITIAL_INT;
  181.  
  182. 	staticLabel++;
  183.  
  184. 	if (node == NULL){
  185. 		return EXIT_SUCCESS;
  186. 	}
  187. 	if(!isSymbolsTableAvailable())
  188. 	{
  189. 		onError("Table of Symbols must not be NULL", __FILE__, __LINE__, NULL);
  190. 		//Failure of the compiler behavior, independent of the parsed code
  191. 		exit(EXIT_FAILURE);
  192. 	}
  193. 	char str[1024];//todo: minimize length
  194. 	#if(VERBOSE_LEVEL<=DEB_P)
  195. 		sprintf(
  196. 			str,
  197. 			"pcodeGenValue %s (%d) (%s, line %d)",
  198. 			typeToString(node->type),
  199. 			node->type,
  200. 			node->debug->file,
  201. 			node->debug->line
  202. 		);
  203. 		printMsg(DEB_P, str, __FILE__, __LINE__);
  204. 	#endif
  205. //	printPCode(pcodeFile, ";\tGenerate value for node %s\n", node->info->name);
  206.  
  207. //	printf(
  208. //		";\n;\tp-code : %s (%s, %s) line %d col %d (compiler %s, %d)\n",
  209. //		node->info->name,
  210. //		typeToString(node->type),
  211. //		typeToString(node->subtype),
  212. //		node->debug->line,
  213. //		node->debug->linePsn,
  214. //		__FILE__,
  215. //		__LINE__
  216. //		);
  217. 	switch (node->type)
  218. 	{
  219. 		case NUMBER:
  220. 			printPCode(pcodeFile, ";\t---Generate value for %d integer constant\n",node->info->value);
  221. 			printPCode(pcodeFile, "ldc i %d\n", node->info->value);
  222. 			break;
  223. 		case LEXICAL_TRUE_VAL:
  224. 			printPCode(pcodeFile, ";\t---Generate value for true boolean constant\n");
  225. 			printPCode(pcodeFile, "ldc b 1\n");
  226. 			break;
  227. 		case LEXICAL_FALSE_VAL:
  228. 			printPCode(pcodeFile, ";\t---Generate value for false boolean constant\n",node->info->value);
  229. 			printPCode(pcodeFile, "ldc b 0\n");
  230. 			break;
  231. 		case NODE_TYPE_FUNCTIONS:
  232. 			//function
  233. 			 pcodeGenValue(node->right);
  234. 			//functions
  235. 			 pcodeGenValue(node->left);
  236. 			 break;
  237.  
  238. 		case NODE_TYPE_FUNCTION:
  239. 			printPCode(pcodeFile, ";\tStart of %s function\n",node->info->name);
  240. 			location = getShiftedMemoryLocation(node);
  241.  
  242. 			printPCode(pcodeFile, "define @fct_%s_%d\n",node->info->name,location);
  243.  
  244. 			//int varsCount=getDeclarationsMemoryUpperBound();
  245. 			AstNode *arg = node->left;
  246. 			int varsCount=0;
  247. 			//get params count
  248. 			while(arg!=NULL)
  249. 			{
  250. 				switch(arg->type)
  251. 				{
  252. 					case NODE_TYPE_PARAM_LIST:
  253. 						varsCount++;
  254. 						arg=arg->right;
  255. 						break;
  256. 					case NODE_TYPE_PARAM:
  257. 						varsCount++;
  258. 						arg=NULL;
  259. 						break;
  260. 					default:
  261. 						arg=NULL;
  262. 				}
  263. 			}
  264. 			arg=node->right;
  265. 			//get declarations count
  266. 			while(arg!=NULL)
  267. 			{
  268. 				switch(arg->type)
  269. 				{
  270. 					case NODE_TYPE_CONTAINER:
  271. 						if(
  272. 								arg->left!=NULL &&
  273. 								(arg->left->type==NODE_TYPE_DECLARATIONS||arg->left->type==NODE_TYPE_VAR_DECL)
  274. 							)
  275. 						{
  276. 							arg=arg->left;
  277. 						}
  278. 						else
  279. 						{
  280. 							arg=NULL;
  281. 						}
  282. 						break;
  283. 					case NODE_TYPE_DECLARATIONS:
  284. 						if(arg->left!=NULL && arg->left->type==NODE_TYPE_VAR_DECL)
  285. 						{
  286. 							varsCount++;
  287. 						}
  288. 						arg=arg->right;
  289. 						break;
  290. 					case NODE_TYPE_VAR_DECL:
  291. 						varsCount++;
  292. 						arg=NULL;
  293. 						break;
  294. 					default:
  295. 						arg=NULL;
  296. 				}
  297. 			}
  298. 			printPCode(pcodeFile, "ssp %d\n",varsCount+RESERVED_MEM);
  299.  
  300. 			printPCode(pcodeFile, "ujp @fct_body_%s_%d\n",node->info->name, location);
  301. 			pcodeGenValue(node->left);
  302. 			printPCode(pcodeFile, "define @fct_body_%s_%d\n",node->info->name,location);
  303. 			printPCode(pcodeFile, "lda i %d %d\n", 0, 0);//args= {diff, rel addr} ??
  304. 			pcodeGenValue(node->right);
  305. 			if(node->info->returnStatement!=NULL)
  306. 			{
  307. 				printPCode(pcodeFile, ";\tReturn\n");
  308. //				pcodeGenAddress(node->info->returnStatement);
  309. 				switch (node->info->returnStatement->info->computedType)
  310. 				{
  311. 					case AST_INTEGER_VAR_TYPE: 	printPCode(pcodeFile, "sto i\n");		break;
  312. 					case AST_BOOLEAN_VAR_TYPE: 	printPCode(pcodeFile, "sto b\n");		break;
  313. 					case AST_INSTACK_VAR_TYPE: 	printPCode(pcodeFile, "sto a\n");		break;
  314. 					default: 					onNotIntegerNotBooleanTypeError(node, __FILE__, __LINE__);	break;
  315. 				}
  316. 				printPCode(pcodeFile, "retf\n");
  317. 			}
  318. 			printPCode(pcodeFile, "retf\n");
  319. 			printPCode(pcodeFile, ";\tEnd of %s function\n",node->info->name);
  320. 			break;
  321.  
  322. 		case NODE_TYPE_FUNCTION_CALL:
  323. 		{
  324. 			printPCode(pcodeFile, ";\t---%s function call\n",node->info->name);
  325. 			printPCode(pcodeFile, "mst %d\n", getDepthDiff(node));
  326.  
  327. 			AstNode *arg = node->left;
  328. 			int paramsCount=0;
  329. 			while(arg!=NULL)
  330. 			{
  331. 				switch(arg->type)
  332. 				{
  333. 					case NODE_TYPE_PARAM_LIST:
  334. 						pcodeGenParam(arg->left);
  335. 						paramsCount++;
  336. 						arg=arg->right;
  337. 						break;
  338. 					case NODE_TYPE_PARAM:
  339. 						pcodeGenParam(arg);
  340. 						paramsCount++;
  341. 						arg=NULL;
  342. 						break;
  343. 					default:
  344. 						// These types are the only allowed types for parameters
  345. 						// Must trigger an error here?
  346. 						arg=NULL;
  347. 				}
  348. 			}
  349. //
  350. 			printPCode(
  351. 				pcodeFile,
  352. 				"cup %d @fct_%s_%d\n",
  353. 				paramsCount,
  354. 				node->info->name,
  355. 				getShiftedMemoryLocation(node->info->declarationNode)
  356. 				);
  357. 		}
  358. 					break;
  359. 		case NODE_TYPE_REXP:
  360. //			printf(
  361. //				";\n;\t*************tp-code %s =>%s=> %sline %d col %d (compiler %s, %d)\n",
  362. //				node->left==NULL?"NULL":node->left->info->name,
  363. //				typeToString(node->subtype),
  364. //				node->right==NULL?"NULL":node->right->info->name,
  365. //				node->debug->line,
  366. //				node->debug->linePsn,
  367. //				__FILE__,
  368. //				__LINE__
  369. //				);
  370. 			switch(node->subtype)
  371. 			{
  372. 			//Integer operations
  373. 				case LEXICAL_PLUS:
  374. 					printPCode(pcodeFile, ";\t---Start + operation\n");
  375. 					pcodeGenValue(node->left);
  376. 					pcodeGenValue(node->right);
  377. 					printPCode(pcodeFile, "add i\n");
  378. 					printPCode(pcodeFile, ";\t---Start + operation\n");
  379. 					break;
  380. 				case LEXICAL_MINUS:
  381. 					printPCode(pcodeFile, ";\t---Start - operation\n");
  382. 					pcodeGenValue(node->left);
  383. 					pcodeGenValue(node->right);
  384. 					printPCode(pcodeFile, "sub i\n");
  385. 					printPCode(pcodeFile, ";\t---Start - operation\n");
  386. 					break;
  387. 				case LEXICAL_MULT:
  388. 					printPCode(pcodeFile, ";\t---Start * operation\n");
  389. 					pcodeGenValue(node->left);
  390. 					pcodeGenValue(node->right);
  391. 					printPCode(pcodeFile, "mul i\n");
  392. 					printPCode(pcodeFile, ";\t---Start * operation\n");
  393. 					break;
  394. 				case LEXICAL_DIV:
  395. 					printPCode(pcodeFile, ";\t---Start DIV operation\n");
  396. 					pcodeGenValue(node->left);
  397. 					pcodeGenValue(node->right);
  398. 					printPCode(pcodeFile, "ldc i 0\n");
  399. 					printPCode(pcodeFile, "equ i\n");
  400. 					printPCode(pcodeFile, "fjp @div_%d\n", label);
  401. 					/* here left == 0 */
  402. 					printPCode(pcodeFile, ";\tdiv division by 0 !!\n");
  403. 					printPCode(pcodeFile, "stp\n");
  404. 					/* else left != 0 */
  405. 					printPCode(pcodeFile, ";\tbegin of div\n");
  406. 					printPCode(pcodeFile, "define @div_%d\n",label);
  407. 					label++;
  408. 					pcodeGenValue(node->right);
  409. 					printPCode(pcodeFile, "div i\n");
  410. 					printPCode(pcodeFile, ";\t---Start DIV operation\n");
  411. 					break;
  412. 				case LEXICAL_MOD:
  413. 					{
  414. 					printPCode(pcodeFile, ";\t---Start mod operation (b mod a)\n");
  415. 					int modLeft=5;
  416. 					int modRight=6;
  417.  
  418. 					printPCode(pcodeFile, "lda i 0 %d\n",modLeft);
  419. 					pcodeGenValue(node->right);
  420. 					printPCode(pcodeFile, "sto i\n");
  421. 					printPCode(pcodeFile, "lda i 0 %d\n",modRight);
  422. 					pcodeGenValue(node->left);
  423. 					printPCode(pcodeFile, "sto i\n");
  424.  
  425. 					printPCode(pcodeFile, ";\tchecks if b == 0\n");
  426. 					printPCode(pcodeFile, "lda i 0 %d\n",modLeft);
  427. 					printPCode(pcodeFile, "ind i\n");
  428. 					printPCode(pcodeFile, "ldc i 0\n");
  429. 					printPCode(pcodeFile, "equ i\n");
  430. 					printPCode(pcodeFile, "fjp @mod_%d\n", label);
  431. 					/* here left == 0 */
  432. 					printPCode(pcodeFile, ";\tmod division by 0 !!\n");
  433. 					printPCode(pcodeFile, "stp\n");
  434. 					/* else left != 0 */
  435. 					printPCode(pcodeFile, "define @mod_%d\n",label);
  436. 					label++;
  437.  
  438. 					//load left
  439. 					printPCode(pcodeFile, "lda i 0 %d\n",modRight);
  440. 					printPCode(pcodeFile, "ind i\n");
  441.  
  442. 					printPCode(pcodeFile, "lda i 0 %d\n",modRight);
  443. 					printPCode(pcodeFile, "ind i\n");
  444.  
  445. 					printPCode(pcodeFile, "lda i 0 %d\n",modLeft);
  446. 					printPCode(pcodeFile, "ind i\n");
  447. 					printPCode(pcodeFile, "div i\n");
  448.  
  449. 					printPCode(pcodeFile, "lda i 0 %d\n",modLeft);
  450. 					printPCode(pcodeFile, "ind i\n");
  451. 					printPCode(pcodeFile, "mul i\n");
  452. 					printPCode(pcodeFile, "sub i\n");
  453. 					printPCode(pcodeFile, ";\t---Start MOD operation\n");
  454. 					}
  455. 					break;
  456. 			//Boolean operations
  457. 				case LEXICAL_EQUALS:
  458. 					printPCode(pcodeFile, ";\t---Start == operation\n");
  459. 					pcodeGenValue(node->left);
  460. 					pcodeGenValue(node->right);
  461. 					printPCode(pcodeFile, "equ b\n");
  462. 					printPCode(pcodeFile, ";\t---Start == operation\n");
  463. 					break;
  464. 				case LEXICAL_LESS_EQUALS:
  465. 					printPCode(pcodeFile, ";\t---Start <= operation\n");
  466. 					pcodeGenValue(node->left);
  467. 					pcodeGenValue(node->right);
  468. 					printPCode(pcodeFile, "leq b\n");
  469. 					printPCode(pcodeFile, ";\t---Start <= operation\n");
  470. 					break;
  471. 				case LEXICAL_LESS:
  472. 					printPCode(pcodeFile, ";\t---Start < operation\n");
  473. 					pcodeGenValue(node->left);
  474. 					pcodeGenValue(node->right);
  475. 					printPCode(pcodeFile, "les b\n");
  476. 					printPCode(pcodeFile, ";\t---Start < operation\n");
  477. 					break;
  478. 				case LEXICAL_ANDLAZY:
  479. 					printPCode(pcodeFile, ";\t---Start & operation\n");
  480. 					leftLabel = staticLabel++;
  481. 					rightLabel = staticLabel++;
  482.  
  483. 					pcodeGenValue(node->left);
  484.  
  485. 					//set condition for the false jump(exp_1)
  486. 					pcodeGenValue(node->left);
  487.  
  488. 					char andLazy[7+1] = "andLazy";
  489.  
  490. 					printPCode(pcodeFile, "fjp @%s%d\n", andLazy, leftLabel);
  491. 					pcodeGenValue(node->right);
  492. 					printPCode(pcodeFile, "and b\n");
  493.  
  494. 					printPCode(pcodeFile, "define @%s%d\n", andLazy, leftLabel);
  495. 					printPCode(pcodeFile, ";\t---Start & operation\n");
  496. 					break;
  497. 				case LEXICAL_AND:
  498. 					printPCode(pcodeFile, ";\t---Start && operation\n");
  499. 					pcodeGenValue(node->right);
  500. 					pcodeGenValue(node->left);
  501. 					printPCode(pcodeFile, "and b\n");
  502. 					printPCode(pcodeFile, ";\t---Start && operation\n");
  503. 					break;
  504. 				case LEXICAL_ORLAZY:
  505. 					printPCode(pcodeFile, ";\t---Start | operation\n");
  506. 					leftLabel = staticLabel++;
  507. 					rightLabel = staticLabel++;
  508.  
  509. 					pcodeGenValue(node->left);
  510.  
  511. 					//set condition for the false jump(exp_1)
  512. 					pcodeGenValue(node->left);
  513. 					printPCode(pcodeFile, "not b\n");
  514.  
  515. 					char orLazy[6+1] = "orLazy";
  516.  
  517. 					printPCode(pcodeFile, "fjp @%s%d\n", orLazy, leftLabel);
  518. 					pcodeGenValue(node->right);
  519. 					printPCode(pcodeFile, "or b\n");
  520.  
  521. 					printPCode(pcodeFile, "define @%s%d\n", orLazy, leftLabel);
  522. 					printPCode(pcodeFile, ";\t---Start | operation\n");
  523. 					break;
  524. 				case LEXICAL_OR:
  525. 					printPCode(pcodeFile, ";\t---Start || operation\n");
  526. 					pcodeGenValue(node->right);
  527. 					pcodeGenValue(node->left);
  528. 					printPCode(pcodeFile, "or b\n");
  529. 					printPCode(pcodeFile, ";\t---Start || operation\n");
  530. 					break;
  531. 				case LEXICAL_NOT:
  532. 					printPCode(pcodeFile, ";\t---NOT operation\n");
  533. 					pcodeGenValue(node->right);
  534. 					printPCode(pcodeFile, "not b\n");
  535. 					break;
  536. 				case LEXICAL_ISEMPTY_OPS :
  537. 					printPCode(pcodeFile, "ldc b 1\n");
  538. 					break;
  539. 				default:
  540. 					pcodeGenValue(node->right);
  541. 					pcodeGenValue(node->left);
  542. 					break;
  543. 			}
  544. 			break;
  545. 		case NODE_TYPE_PARAM_DECL:
  546. 			{
  547. 				printPCode(pcodeFile, ";\t---Start %s param declaration\n",node->info->name);
  548. 				char nodeArgType[1+1];//because I have some problems with %c on printPCode
  549. 				char *pnodeArgType = nodeArgType;
  550. 				switch(node->info->computedType)
  551. 				{
  552. 					case AST_INTEGER_VAR_TYPE:
  553. 						pnodeArgType="i";
  554. 						break;
  555. 					case AST_BOOLEAN_VAR_TYPE:
  556. 						pnodeArgType="b";
  557. 						break;
  558. 					case AST_INSTACK_VAR_TYPE:
  559. 						pnodeArgType="a";
  560. 						break;
  561. 					default:
  562. 						onNotIntegerNotBooleanTypeError(node, __FILE__, __LINE__);
  563. 						break;
  564. 				}
  565. 				char varInst[3+1];
  566. 				char *varInstp=varInst;
  567. 				if( node->subtype==LEXICAL_VAR)
  568. 				{
  569. 					varInstp="lda";
  570. 				}
  571. 				else if( node->subtype==ID)
  572. 				{
  573. 					varInstp="lod";
  574. 					pnodeArgType="a";
  575. 				}
  576. 				else
  577. 				{
  578. 					sprintf(
  579. 						str,
  580. 						"Unsupported subtype %s (%d) for %s, only %s or %s are allowed (%s, line %d)",
  581. 						typeToString(node->subtype),
  582. 						node->type,
  583. 						node->info->name,
  584. 						typeToString(LEXICAL_VAR),
  585. 						typeToString(ID),
  586. 						node->debug->file,
  587. 						node->debug->line
  588. 						);
  589. 					onError(str, __FILE__, __LINE__, node);
  590. 					//Failure of the compiler behavior, independent of the parsed code
  591. 					exit(EXIT_FAILURE);
  592. 				}
  593. 				printPCode(pcodeFile, "%s %s %d %d\n", varInstp, pnodeArgType, getDepthDiff(node), getShiftedMemoryLocation(node));
  594. 				printPCode(pcodeFile, "ind %s\n", pnodeArgType);
  595. 				printPCode(pcodeFile, ";\t---End of %s param declaration\n",node->info->name);
  596. 			}
  597. 			break;
  598. 		case NODE_TYPE_ID:
  599. 			printPCode(pcodeFile, ";\t---%s id\n",node->info->name);
  600.  
  601. 			pcodeGenAddress(node);
  602. 			switch (node->info->computedType)
  603. 			{
  604. 				case AST_INTEGER_VAR_TYPE: 	printPCode(pcodeFile, "ind i\n");		break;
  605. 				case AST_BOOLEAN_VAR_TYPE: 	printPCode(pcodeFile, "ind b\n");		break;
  606. 				case AST_INSTACK_VAR_TYPE: 	printPCode(pcodeFile, "ind a\n");		break;
  607. 				default: 					onNotIntegerNotBooleanTypeError(node, __FILE__, __LINE__);	break;
  608. 			}
  609. 			break;
  610. //		case LEXICAL_RETURN_STMT:
  611. //			break;
  612. 		case NODE_TYPE_STATEMENT:
  613. 			switch(node->subtype)
  614. 			{
  615. 				case LEXICAL_AFFECTATION:
  616. 					printPCode(pcodeFile, ";\t---Start affectation\n");
  617. 					pcodeGenAddress(node->left);
  618.  
  619. 					//printPCode(pcodeFile, ";\tAFFECT right %d--%d\n",node->right->type,node->right->subtype);
  620. 					pcodeGenValue(node->right);
  621.  
  622. 					switch (node->right->info->computedType)
  623. 					{
  624. 						case AST_INTEGER_VAR_TYPE: 	printPCode(pcodeFile, "sto i\n");		break;
  625. 						case AST_BOOLEAN_VAR_TYPE: 	printPCode(pcodeFile, "sto b\n");		break;
  626. 						case AST_INSTACK_VAR_TYPE: 	printPCode(pcodeFile, "sto a\n");		break;
  627. 						default: 					onNotIntegerNotBooleanTypeError(node, __FILE__, __LINE__);	break;
  628. 					}
  629.  
  630. 					printPCode(pcodeFile, ";\tEnd of affectation\n");
  631. 					break;
  632. 			//Flow control operations
  633. 				case LEXICAL_IF_STMT:
  634. 					printPCode(pcodeFile, ";\t---Start if statement\n");
  635. 					leftLabel = staticLabel++;
  636. 					rightLabel = staticLabel++;
  637.  
  638. 					//set condition for the false jump
  639. 					pcodeGenValue(node->left);
  640. 					printPCode(pcodeFile, "fjp @endif_%d\n", leftLabel);
  641.  
  642. 					pcodeGenValue(node->right);
  643. 					printPCode(pcodeFile, "define @endif_%d\n", leftLabel);
  644. 					printPCode(pcodeFile, ";\t---End of if statement\n");
  645. 					break;
  646. 				case AST_IF_ELSE_STMT:
  647. 					printPCode(pcodeFile, ";\t---Start if...else... statement\n");
  648. 					leftLabel = staticLabel++;
  649. 					rightLabel = staticLabel++;
  650.  
  651. 					//set condition for the false jump
  652. 					pcodeGenValue(node->left);
  653. 					printPCode(pcodeFile, "fjp @then_%d\n", leftLabel);
  654.  
  655. 					pcodeGenValue(node->right->left);
  656. 					printPCode(pcodeFile, "ujp @endif_%d\n", rightLabel);
  657.  
  658. 					printPCode(pcodeFile, "define @then_%d\n", leftLabel);
  659. 					pcodeGenValue(node->right->right);
  660. 					printPCode(pcodeFile, "define @endif_%d\n", rightLabel);
  661. 					printPCode(pcodeFile, ";\t---End of if...else... statement\n");
  662. 					break;
  663. 				case LEXICAL_FOR_STMT:
  664. 					printPCode(pcodeFile, ";\t---Start for statement\n");
  665. 					// for(pre_instructions:condition:post_instructions_loop){instructions_loop}
  666. 					// is translated into
  667. 					// pre_instructions; while(condition){instructions_loop;post_instructions_loop}
  668.  
  669. 					leftLabel = staticLabel++;
  670. 					rightLabel = staticLabel++;
  671.  
  672. 					// pre_instructions
  673. 					if(node->right!=NULL && node->right->left!=NULL)
  674. 					{
  675. 						//printf("\n; FLEXICAL_OR statement pre_instructions (compiler %s, %d)",__FILE__,__LINE__);
  676. 						pcodeGenValue(node->right->left->left);
  677. 					}
  678.  
  679. 					// while
  680. 					printPCode(pcodeFile, "define @for_%d\n", leftLabel);
  681.  
  682. 					//set condition for the false jump
  683. 					pcodeGenValue(node->left);
  684. 					printPCode(pcodeFile, "fjp @endfor_%d\n", rightLabel);
  685.  
  686. 					// instructions_loop
  687. 					if(node->right!=NULL)
  688. 					{
  689. 						//printf("\n; FLEXICAL_OR statement instructions_loop (compiler %s, %d)",__FILE__,__LINE__);
  690. 						pcodeGenValue(node->right->right);
  691. 					}
  692. 					// post_instructions_loop
  693. 					if(node->right!=NULL && node->right->left!=NULL)
  694. 					{
  695. 						//printf("\n; FLEXICAL_OR statement post_instructions_loop (compiler %s, %d)",__FILE__,__LINE__);
  696. 						pcodeGenValue(node->right->left->right);
  697. 					}
  698. 					printPCode(pcodeFile, "ujp @for_%d\n", leftLabel);
  699. 					printPCode(pcodeFile, "define @endfor_%d\n", rightLabel);
  700. 					printPCode(pcodeFile, ";\t---End of for statement\n");
  701. 					break;
  702. 				case LEXICAL_WHILE_STMT:
  703. 					printPCode(pcodeFile, ";\t---Start while statement\n");
  704. 					leftLabel = staticLabel++;
  705. 					rightLabel = staticLabel++;
  706.  
  707. 					printPCode(pcodeFile, "define @while_%d\n", leftLabel);
  708.  
  709. 					//set condition for the false jump
  710. 					pcodeGenValue(node->left);
  711. 					printPCode(pcodeFile, "fjp @endwhile_%d\n", rightLabel);
  712.  
  713. 					pcodeGenValue(node->right);
  714. 					printPCode(pcodeFile, "ujp @while_%d\n", leftLabel);
  715. 					printPCode(pcodeFile, "define @endwhile_%d\n", rightLabel);
  716. 					printPCode(pcodeFile, ";\t---End of while statement\n");
  717. 					break;
  718. 				default:
  719. 					pcodeGenValue(node->right);
  720. 					pcodeGenValue(node->left);
  721. 					break;
  722. 			}
  723. 			break;
  724. 		case LEXICAL_READ_OPS:
  725. 			printPCode(pcodeFile, ";\t---Start read operation\n");
  726. 			pcodeGenAddress(node->right);
  727. 			printPCode(pcodeFile, "read\n");
  728. 			//Only integer argument allowed for read (Spec. 6.2)
  729. 			printPCode(pcodeFile, "sto i\n");
  730. 			printPCode(pcodeFile, ";\t---End of read operation\n");
  731. 			break;
  732. 		case LEXICAL_WRITE_OPS:
  733. 			printPCode(pcodeFile, ";\t---Start write operation\n");
  734. 			pcodeGenValue(node->right);
  735. 			printPCode(pcodeFile, "prin\n");
  736. 			printPCode(pcodeFile, ";\t---End of write operation\n");
  737. 			break;
  738.  
  739. //		case NODE_TYPE_CONTAINER:
  740. //		case NODE_TYPE_FUNCTION_BODY:
  741. //		case NODE_TYPE_DECLARATIONS:
  742. //			pcodeGenValue(node->left);
  743. //			pcodeGenValue(node->right);
  744. //			break;
  745. 		default:
  746. 			pcodeGenValue(node->left);
  747. 			pcodeGenValue(node->right);
  748. 			//onUnrecognizedTypeError(node->type, __FILE__, __LINE__);
  749. 			break;
  750. 	}
  751.  
  752. 	return EXIT_SUCCESS;
  753. }
  754.  
  755. /*
  756.  * **********************************************************
  757.  * Implementation of the header exposed items
  758.  * See pcode.h for these functions comments
  759.  * **********************************************************
  760.  */
  761.  
  762. int generatePCode()
  763. {
  764. 	if(rootNode==NULL)
  765. 	{
  766. 		//To check : Meaning of a null node, is it an error or only a warning?
  767. 		onError("Root node may not be null", __FILE__, __LINE__, NULL);
  768. 		return EXIT_FAILURE;
  769. 	}
  770. 	if(!isSymbolsTableAvailable())
  771. 	{
  772. 		onError("Table of Symbols must not be NULL", __FILE__, __LINE__, NULL);
  773. 		//Failure of the compiler behavior, independent of the parsed code
  774. 		exit(EXIT_FAILURE);
  775. 	}
  776.  
  777.  
  778. 	#if(PCODE_FILE_REQUESTED)
  779. 		if(!(pcodeFile = fopen(PCODE_FILE, "w")))
  780. 		{
  781. 			#if(VERBOSE_LEVEL<=DEB_EXEC)
  782. 				printMsg(DEB_EXEC,"Open p-code file...ERRLEXICAL_OR", __FILE__, __LINE__);
  783. 				printMsg(DEB_E, (char *)strerror(errno), __FILE__, __LINE__);
  784. 			#endif
  785. 		}else
  786. 		{
  787. 			#if(VERBOSE_LEVEL<=DEB_EXEC)
  788. 				printf(
  789. 					"\n;  Open %s p-code file...OK\n",
  790. 					PCODE_FILE,
  791. 					__FILE__,
  792. 					__LINE__
  793. 					);
  794. 			#endif
  795. 		}
  796.  
  797. 	#endif
  798.  
  799. 	printPCode(pcodeFile, ";\tStart program\n");
  800. //	int maxMem = getDeclarationsMemoryUpperBound();
  801. //	printPCode(pcodeFile, "ssp %d\n", (maxMem<= 0) ? 0 : maxMem );
  802. 	printPCode(pcodeFile, "ssp 0\n");
  803.  
  804. 	printPCode(pcodeFile, "mst 0\n");
  805.  
  806. 	int mainMemLoc = getShiftedMemoryLocation(getMain());
  807. 	printPCode(pcodeFile, "cup 0 @fct_%s_%d\n", getMain()->info->name, mainMemLoc);
  808. 	printPCode(pcodeFile, "ujp @program_end\n");
  809. 	int ret = pcodeGenValue(rootNode);
  810.  
  811. 	printPCode(pcodeFile, "define @program_end\n");
  812. 	printPCode(pcodeFile, "stp\n");
  813. 	printPCode(pcodeFile, ";\tEnd of program\n");
  814.  
  815. 	if(PCODE_FILE_REQUESTED && pcodeFile!=NULL)
  816. 	{
  817. 		fclose(pcodeFile);
  818. 	}
  819. 	#if(VERBOSE_LEVEL<=DEB_P)
  820. 		printSymbolsTableDebug(__FILE__,__LINE__);
  821. 	#endif
  822. 	return ret;
  823. }

Autres extraits de codes en c

  • DisquetteDispo Vérifier la disponibilité du lecteur de disquette
  • Suite de Fibonacci Exemple d'itération en C
  • Suite de Fibonacci Exemple de récursion en C
  • astDataRepresentation.h Représentation de données de l'arbre syntaxique abstrait Compilateur LSD010
  • ast.h Arbre syntaxique abstrait Compilateur LSD010
  • ast.c Arbre syntaxique abstrait Compilateur LSD010
  • symbolsTableDataRepresentation.h Représentation de données de la table des symboles Compilateur LSD010
  • symbolsTable.h Fonctions de gestion de la table des symboles Compilateur LSD010
  • symbolsTable.c Fonctions de gestion de la table des symboles Compilateur LSD010
  • hashCode.h Fonctions de hachage Compilateur LSD010
  • hashCode.c Fonctions de hachage Compilateur LSD010
  • scopeStack.h Fonctions de gestion d'une pile de portées Compilateur LSD010
  • scopeStack.c Fonctions de gestion d'une pile de portées Compilateur LSD010
  • scopeHelper.h Fonctions de gestion de la portée courante Compilateur LSD010
  • console.h Fonctions d'affichage Compilateur LSD010
  • console.c Fonctions d'affichage Compilateur LSD010
  • graphVizHelper.h Génération d'une image d'un arbre syntaxique abstrait.
    Classe d'intégration de l'outil GraphViz. Compilateur LSD010
  • graphVizHelper.c Génération d'une image d'un arbre syntaxique abstrait.
    Classe d'intégration de l'outil GraphViz. Compilateur LSD010
  • common.h Définition des constantes et variables communes Compilateur LSD010
  • pcode.c Génération de p-code Compilateur LSD010
  • pcode.h Génération de p-code Compilateur LSD010
  • Tous les extraits

Document créé le 05/10/2009, dernière modification le 28/10/2018
Source du document imprimé : https://www.gaudry.be/sniplet-rf-lsd010/project/source/pcode.c.html

L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.