Geen cache-versie.

Caching uitgeschakeld. Standaardinstelling voor deze pagina:ingeschakeld (code LNG204)
Als het scherm te langzaam is, kunt u de gebruikersmodus uitschakelen om de cacheversie te bekijken.

pcode.c

Inhoudsopgave

Description du code

pcode.c est un fichier du projet Compilateur LSD010.
Ce fichier est situé dans /var/www/bin/sniplets/lsd010/.

Projet Compilateur LSD010 :

Compilateur LSD010 développé dans le cadre du cours de syntaxe et sémantiqueref 1

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. }

Structure et Fichiers du projet

Afficher/masquer...


Répertoires contenus dans /var/www/bin/sniplets/lsd010/project/source/ 
IcôneNomTailleModification
Pas de sous-répertoires.
IcôneNomTailleModification
| _ Répertoire parent0 octets1714254332 27/04/2024 23:45:32
Fichiers contenus dans /var/www/bin/sniplets/lsd010/project/source/ 
IcôneNomTailleModificationAction
IcôneNomTailleModificationAction
Afficher le fichier .o|.ographVizHelper.o4.72 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .c|.cast.c27.73 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .h|.hconst.h4.01 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .c|.cy.tab.c84.53 Ko31/10/2018 18:32:39-refusé-
Afficher le fichier .y|.ylsd10.y22.88 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .o|.olex.yy.o18.88 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .c|.cscopeStack.c3.69 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .h|.hgraphVizHelper.h573 octets31/10/2018 18:32:37-refusé-
Afficher le fichier .h|.hsymbolsTableDataRepresentation.h1.31 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .o|.osymbolsTable.o5.2 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .h|.hcommon.h1.08 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .c|.cscopeHelper.c4.09 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .o|.ohashCode.o1.45 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .h|.hconsole.h2.21 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .o|.oconsole.o12.23 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .|lsd10lsd1075.26 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .h|.hhashCode.h1020 octets31/10/2018 18:32:37-refusé-
Afficher le fichier .h|.hsymbolsTable.h2.65 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .h|.hpcode.h417 octets31/10/2018 18:32:38-refusé-
Afficher le fichier .o|.oast.o11.45 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .h|.hscopeStack.h2.2 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .c|.cgraphVizHelper.c6.11 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .l|.llsd10.l6.46 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .h|.hy.tab.h4.69 Ko31/10/2018 18:32:39-refusé-
Afficher le fichier .output|.outputy.output81.69 Ko31/10/2018 18:32:39-refusé-
Afficher le fichier .o|.oy.tab.o24.45 Ko31/10/2018 18:32:39-refusé-
Afficher le fichier .c|.clex.yy.c57.93 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .h|.hast.h2.39 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .o|.oscopeStack.o1.34 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .o|.oscopeHelper.o2.59 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .h|.hastDataRepresentation.h1.87 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .c|.csymbolsTable.c14.91 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .c|.cpcode.c23.45 Ko31/10/2018 18:32:38-refusé-
Afficher le fichier .c|.chashCode.c3.94 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .c|.cconsole.c18.01 Ko31/10/2018 18:32:37-refusé-
Afficher le fichier .h|.hscopeHelper.h719 octets31/10/2018 18:32:38-refusé-

Waarschuwing

Ce code présente une manière possible d'implémenter un compilateur, et certains choix peuvent être discutés.
Cependant, il peut donner des pistes pour démarrer, ou approcher certains concepts, et je tenterais par la suite de mettre à jour le code.

Utilisation de l'explorateur de code

  • Navigation :
    • Un clic sur une icône de répertoire ouvre ce répertoire pour en afficher les fichiers.
    • Lorsque le répertoire en cours ne contient pas de sous-répertoires il est possible de remonter vers le répertoire parent.
    • La structure de répertoires en treetable (tableau en forme d'arborescence) n'est plus possibledans cette version.
    • Un clic sur une icône de fichier ouvre ce fichier pour en afficher le code avec la coloration syntaxique adaptée en fonction du langage principal utilisé dans le fichier.
  • Affichage :
    • Il est possible de trier les répertoires ou les fichiers selon certains critères (nom, taille, date).
  • Actions :
    • Les actions possible sur les fichiers dépendent de vos droits d'utilisateur sur le site. Veuillez activer le mode utilisateur pour activer les actions.

Nederlandse vertaling

U hebt gevraagd om deze site in het Nederlands te bezoeken. Voor nu wordt alleen de interface vertaald, maar nog niet alle inhoud.

Als je me wilt helpen met vertalingen, is je bijdrage welkom. Het enige dat u hoeft te doen, is u op de site registreren en mij een bericht sturen waarin u wordt gevraagd om u toe te voegen aan de groep vertalers, zodat u de gewenste pagina's kunt vertalen. Een link onderaan elke vertaalde pagina geeft aan dat u de vertaler bent en heeft een link naar uw profiel.

Bij voorbaat dank.

Document heeft de 07/03/2010 gemaakt, de laatste keer de 28/10/2018 gewijzigd
Bron van het afgedrukte document:https://www.gaudry.be/nl/langages-lsd10-source-rf-project/source//pcode.c.html

De infobrol is een persoonlijke site waarvan de inhoud uitsluitend mijn verantwoordelijkheid is. De tekst is beschikbaar onder CreativeCommons-licentie (BY-NC-SA). Meer info op de gebruiksvoorwaarden en de auteur.

Notes

  1. ↑a,b LSD010 : Langage Simple et Didactique Il existe une un certain nombre d'interprétations de l'acronyme LSD (Langage Symbolique Didactique, Langage Sans Difficulté, Langage Simple et Didactique). LSD010 est la version 2010 de la suite LSD80, LSD_02, LSD03, LSD04, LSD05, LSD06, LSD07, LSD08, et LSD09.

Inhoudsopgave Haut

Referenties

  1. boek Taal van het document:fr IHDCB332 - Théorie des langages : Syntaxe et sémantique : PY Schobbens, Syntaxe et sémantique (January 2010)

Deze verwijzingen en links verwijzen naar documenten die geraadpleegd zijn tijdens het schrijven van deze pagina, of die aanvullende informatie kunnen geven, maar de auteurs van deze bronnen kunnen niet verantwoordelijk worden gehouden voor de inhoud van deze pagina.
De auteur Deze site is als enige verantwoordelijk voor de manier waarop de verschillende concepten, en de vrijheden die met de referentiewerken worden genomen, hier worden gepresenteerd. Vergeet niet dat u meerdere broninformatie moet doorgeven om het risico op fouten te verkleinen.

Inhoudsopgave Haut