console.c

Table des matières

Description du code

Fonctions d'affichage Compilateur LSD010

Code source ou contenu du fichier

  1. /*
  2.  * console.c : output (terminal and files) helper file
  3.  * Part of the compiler project for LSD10 language
  4.  * Gaudry Stéphane
  5.  * More information on http://www.gaudry.be/langages-lex-yacc-intro.html
  6.  */
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #if(VERBOSE_LEVEL<=DEB_E)
  11. 	#include <errno.h>
  12. #endif
  13. #if(VERBOSE_LEVEL<=DEB_I)
  14. 	#include <time.h>
  15. #endif
  16.  
  17. //includes for the var args
  18. #include <stdarg.h>
  19. //end of var args includes
  20. #include "common.h"
  21. #include "graphVizHelper.h"
  22. #include "symbolsTableDataRepresentation.h"
  23.  
  24.  
  25. extern int lexLinesCount;
  26. extern char* yytext;
  27. extern int *yylineno;
  28. extern FILE *yyin;
  29. extern AstNode *rootNode;
  30. extern DebugInfo *debugInfo;
  31.  
  32. void printHTMLTree(FILE *htmlFile, AstNode *node, int depth);
  33. void printHTMLNode(FILE *htmlFile, AstNode *node, int depth);
  34. void printXMLTree(FILE *htmlFile, AstNode *node, int depth);
  35. void printXMLNode(FILE *htmlFile, AstNode *node, int depth);
  36. /**************************************************************/
  37. /**
  38.  * Generates Yacc error with custom message
  39.  * todo: 2 function; this is used only to call the yyerror function and producing a exit(EXIT_SUCCESS),
  40.  * and another to print KO with an exit(EXIT_FAILURE) on compiler inexpected bug (like allocation error)
  41.  * Exposed method
  42.  */
  43. void onError(char* errorMsg, char* compilerFile, int compilerLine, AstNode *node)
  44. {
  45. 	if(node!=NULL)
  46. 	{
  47. 		lexLinesCount=node->debug->line;
  48. 		//lexCharsCountBeforeToken=node->debug->line; todo : yylloc.first_line??
  49. 		debugInfo=node->debug;
  50. 	}
  51. 	yytext=NULL;
  52. 	#if(VERBOSE_LEVEL<=DEB_EXEC)
  53. 		printMsg(DEB_W, errorMsg, compilerFile, compilerLine);
  54. 	#endif
  55. 	yyerror(errorMsg);
  56. }
  57. void onNotForwardDeclarationError(AstNode *current, AstNode *found)
  58. {
  59. 	char errorStr[1024];//todo: minimize length
  60. 	char *str = errorStr;
  61. 	if(current!=found)
  62. 	{
  63. 		sprintf(
  64. 			str,
  65. 			"Backward declaration failure for %s %s line %d char %d, possible forward declaration on %s %s line %d col %d",
  66. 			typeToString(current->type),
  67. 			current->info->name,
  68. 			current->debug->line,
  69. 			current->debug->linePsn,
  70.  
  71. 			typeToString(found->type),
  72. 			found->info->name,
  73. 			found->debug->line,
  74. 			found->debug->linePsn
  75. 			);
  76. 	}
  77. 	else
  78. 	{
  79. 		sprintf(
  80. 			str,
  81. 			"Backward declaration failure for %s %s line %d col %d",
  82. 			typeToString(current->type),
  83. 			current->info->name,
  84. 			current->debug->line,
  85. 			current->debug->linePsn
  86. 			);
  87. 	}
  88. 	onError(str, __FILE__, __LINE__, current);
  89. }
  90. void onNotIntegerNotBooleanTypeError(AstNode *node, char *file, int line)
  91. {
  92. 	char errorStr[1024];//todo: minimize length
  93. 	char *str = errorStr;
  94. 	sprintf(
  95. 			str,
  96. 			"Type check failure : %s or %s expected, but %s found for '%s' line %d col %d (compiler %s, line %d)",
  97. 			typeToString(AST_INTEGER_VAR_TYPE),
  98. 			typeToString(AST_BOOLEAN_VAR_TYPE),
  99. 			typeToString(node->info->computedType),
  100. 			node->info->name,
  101. 			node->debug->line,
  102. 			node->debug->linePsn,
  103. 			file,
  104. 			line
  105. 			);
  106. 	lexLinesCount=node->debug->line;
  107. 	yytext=NULL;
  108. 	yyerror(str);
  109. 	//failure for the parsed code, but success for the compiler (it must stop here)
  110. 	exit(EXIT_SUCCESS);
  111. }
  112. /**
  113.  * Generates Yacc error if a type is not recognized
  114.  * Exposed method
  115.  */
  116. void onUnrecognizedTypeError(int type, char* file, int line)
  117. {
  118. 	char errorStr[1024];//todo: minimize length
  119. 	sprintf(errorStr, "Unrecognized type=%s (%d) on %s line %d", typeToString(type), type, file, line);
  120. 	onError(errorStr, file, line, NULL);
  121. }
  122. /**
  123.  * Print custom message on stdout, depending on the Debug level
  124.  * Exposed method
  125.  */
  126. void printMsg(int msgType, char *msg, char *file, int line)
  127. {
  128. 	/*if(VERBOSE_LEVEL>msgType)return;*/
  129. 	switch(msgType)
  130. 	{
  131. 		case DEB_W :
  132. 			printf(";\n;\tWarning : '%s' On %s, Line %d\n;\t-------------------------------------------------------------\n", msg, file, line);
  133. 			break;
  134. 		case DEB_E :
  135. 			printf(";\n;\tError : '%s' On %s, Line %d\n;\t-------------------------------------------------------------\n", msg, file, line);
  136. 			break;
  137. 		case DEB_EXEC :
  138. 			printf("\n;  %s\n",msg);
  139. 			break;
  140. 		default :
  141. 			printf("\n;\tMessage : '%s' On %s, Line %d\n", msg, file, line);
  142. 			break;
  143. 	}
  144. 	return;
  145. }
  146. /******************************************************************************/
  147.  
  148. void printDebugTree(char *htmlFileName, char *xmlFileName)
  149. {
  150.  
  151. 	FILE * htmlFile;
  152. 	time_t genTime = time(NULL);
  153. 	if(htmlFileName==NULL)htmlFileName=AST_HTML_FILE;
  154. 	if(xmlFileName==NULL)xmlFileName=AST_XML_FILE;
  155. 	htmlFile = fopen(htmlFileName, "w");
  156. 	if(htmlFile!=NULL)
  157. 	{
  158. 		printf("\n;\tPrinting AST into %s file ... (%s, col %d)", htmlFileName, __FILE__, __LINE__);
  159. 		fprintf(htmlFile, "<html><head><title>AST</title></head><body>\n");
  160. 		fprintf(htmlFile, "<h1>LSD010 AST</h1>\n");
  161. 		fprintf(htmlFile, "<p>Document généré le %s par le compilateur LSD0<sup>10</sup></p>", asctime(localtime(&genTime)));
  162. 		printHTMLTree(htmlFile, rootNode, 0);
  163. 		fprintf(htmlFile, "</body></html>\n");
  164. 		fclose(htmlFile);
  165.  
  166. 		#if(VERBOSE_LEVEL<=DEB_EXEC)
  167. 			printMsg(DEB_EXEC,"\t...OK HTML printed", __FILE__, __LINE__);
  168. 		#endif
  169. 	}
  170. 	else
  171. 	{
  172. 		#if(VERBOSE_LEVEL<=DEB_EXEC)
  173. 			printMsg(DEB_EXEC,"Printing AST into HTML file ... Can't open file", __FILE__, __LINE__);
  174. 			printMsg(DEB_E, (char *)strerror(errno), __FILE__, __LINE__);
  175. 		#endif
  176. 	}
  177. 	htmlFile = fopen(xmlFileName==NULL?AST_XML_FILE:xmlFileName, "w");
  178. 	if(htmlFile!=NULL)
  179. 	{
  180. 		printf("\n;\tPrinting AST into %s file ... (%s, col %d)", xmlFileName, __FILE__, __LINE__);
  181. 		fprintf(htmlFile, "<lsd010>\n");
  182. 		fprintf(htmlFile, "<![CDATA[\nDocument généré le %s par le compilateur LSD010\n]]>\n", asctime(localtime(&genTime)));
  183. 		printXMLTree(htmlFile, rootNode, 0);
  184. 		fprintf(htmlFile, "</lsd010>\n");
  185. 		fclose(htmlFile);
  186.  
  187. 		#if(VERBOSE_LEVEL<=DEB_EXEC)
  188. 			printMsg(DEB_EXEC,"\t...OK XML printed", __FILE__, __LINE__);
  189. 		#endif
  190. 	}
  191. 	else
  192. 	{
  193. 		#if(VERBOSE_LEVEL<=DEB_EXEC)
  194. 			printMsg(DEB_EXEC,"Printing AST into XML file ... Can't open file", __FILE__, __LINE__);
  195. 			printMsg(DEB_E, (char *)strerror(errno), __FILE__, __LINE__);
  196. 		#endif
  197. 	}
  198. }
  199. /**
  200.  * Generates an HTML file and an XML file with AST nodes.
  201.  * These files are generated on the current directory.
  202.  * An error message is displayed if a problem occurs on opening files
  203.  * Exposed method
  204.  */
  205. void printTree()
  206. {
  207. 	printDebugTree(NULL, NULL);
  208. }
  209.  
  210. //alternate row
  211. int altRowSTI=0;
  212. void printScopeStack(ScopeStack *scopeStack, FILE * htmlFile, int topItem)
  213. {
  214. 	if(scopeStack!=NULL)
  215. 	{
  216. 		int altRow=0;
  217. 		altRowSTI=0;
  218. 		if(topItem!=0)
  219. 		{
  220. 			fprintf(
  221. 					htmlFile,
  222. 					//"<table width=\"100%%\">",
  223. 					"<table width=\"100%%\" border=\"1\" cellpadding=\"2\" cellspacing=\"1\" class=\"table\">"
  224. 					);
  225. 			fprintf(
  226. 					htmlFile,
  227. 					"<thead><tr><td colspan=\"5\">Pile du symbole : %s</td></tr>",
  228. 					scopeStack->declarationNode->info->name
  229. 					);
  230. 			fprintf(htmlFile, "<tr><th>Profondeur</th><th>Portée</th><th>Type</th><th>Ligne</th><th>Col</th></tr>");
  231. 			fprintf(htmlFile, "</thead><tbody>");
  232. 		}
  233. 		fprintf(
  234. 				htmlFile,
  235. 				(++altRow%2==0)? "<tr class=\"td\">": "<tr class=\"td2\">"
  236. 				);
  237. 		fprintf(
  238. 				htmlFile,
  239. 				"<td>%d</td><td>%d</td><td>%s</td><td>%d</td><td>%d</td></tr>",
  240. 				scopeStack->declarationNode->info->scopeDepth,
  241. 				scopeStack->declarationNode->info->scopeId,
  242. 				typeToString(scopeStack->declarationNode->info->type),
  243. 				scopeStack->declarationNode->debug->line,
  244. 				scopeStack->declarationNode->debug->linePsn
  245. 				);
  246. 		printScopeStack(scopeStack->parentPtr, htmlFile, 0);
  247. 		if(topItem!=0)
  248. 		{
  249. 			fprintf(htmlFile, "</tbody></table>");
  250. 		}
  251. 	}
  252. }
  253. int printSymbolsTableHeader()
  254. {
  255. 	FILE * htmlFile;
  256. 	time_t genTime = time(NULL);
  257. 	char *htmlFileName=SYMBOLSTABLE_HTML_FILE;
  258. 	htmlFile = fopen(htmlFileName, "w");
  259. 	if(htmlFile==NULL)
  260. 	{
  261. 		return EXIT_FAILURE;
  262. 	}
  263. 	fprintf(htmlFile, "<html><head><title>Table des symboles</title></head><body>\n");
  264. 	fprintf(htmlFile, "<h1>Etats de la table des symboles LSD010</h1>\n");
  265. 	fprintf(htmlFile, "<p>Document généré le %s par le compilateur LSD0<sup>10</sup></p>", asctime(localtime(&genTime)));
  266.  
  267. 	fclose(htmlFile);
  268. 	return EXIT_SUCCESS;
  269. }
  270. int printSymbolsTableFooter()
  271. {
  272. 	//printSymbolsTableItem();
  273. 	FILE * htmlFile;
  274. 	//time_t genTime = time(NULL);
  275. 	char *htmlFileName=SYMBOLSTABLE_HTML_FILE;
  276. 	htmlFile = fopen(htmlFileName, "a+");
  277. 	if(htmlFile==NULL)
  278. 	{
  279. 		return EXIT_FAILURE;
  280. 	}
  281. 	fprintf(htmlFile, "\n</body></html>\n");
  282.  
  283. 	fclose(htmlFile);
  284. 	return EXIT_SUCCESS;
  285. }
  286. // first null index
  287. int startNull = INITIAL_INT;
  288. // @todo: define a astnodedebug as parameter to show where
  289. // this scope enter/exit was found
  290.  
  291. int printSymbolsTableItem(char *title)
  292. {
  293. 	if(declarations!=NULL)
  294. 	{
  295. 		FILE * htmlFile;
  296. 		//time_t genTime = time(NULL);
  297. 		char *htmlFileName=SYMBOLSTABLE_HTML_FILE;
  298. 		htmlFile = fopen(htmlFileName, "a+");
  299. 		if(htmlFile!=NULL)
  300. 		{
  301. 			fprintf(htmlFile, "<?php \n?><h2>%s (portée actuelle : %d)</h2>", title, scopeHelperGetCurrentScope());
  302. 			//fprintf(htmlFile, "<table width=\"100%%\" border=\"1\"><thead>");
  303. 			fprintf(htmlFile, "<?php \n?><table width=\"100%%\" border=\"1\" cellpadding=\"2\" cellspacing=\"1\" class=\"table\"><thead>");
  304. 			fprintf(htmlFile, "<tr><td>Index</td><td>Liste cha&icirc;née de <pre>SymTableEntry</pre></td></tr>");
  305. 			fprintf(htmlFile, "</thead><tbody>");
  306. 			int i;
  307. 			for(i=0;i<TABLES_SIZE;i++)
  308. 			{
  309. 				if(declarations[i]==NULL)
  310. 				{
  311. 					if(startNull==INITIAL_INT)
  312. 					{
  313. 						startNull=i;
  314. 					}
  315. 				}
  316. 				else
  317. 				{
  318. 					if(startNull!=-INITIAL_INT)
  319. 					{
  320. 						fprintf(htmlFile, ++altRowSTI%2==0?"<tr class=\"td\">":"<tr class=\"td2\">");
  321. 						if(startNull<-i-1)
  322. 						{
  323. 							fprintf(htmlFile, "<td>%d...%d</td><td>NULL</td></tr>", startNull, i-1);
  324. 						}
  325. 						else
  326. 						{
  327. 							fprintf(htmlFile, "<td>%d</td><td>NULL</td></tr>", i-1);
  328. 						}
  329. 						startNull = INITIAL_INT;
  330. 					}
  331. 					fprintf(htmlFile, ++altRowSTI%2==0?"<tr class=\"td\">":"<tr class=\"td2\">");
  332. 					fprintf(htmlFile, "<td>%d</td><td>",i);
  333. 					SymTableEntry *entry = declarations[i];
  334. 					while(entry!=NULL)
  335. 					{
  336. 						printScopeStack(entry->scopeStack, htmlFile, 1);
  337. 						entry = entry->next;
  338. 					}
  339. 					fprintf(htmlFile, "</td></tr>");
  340. 				}
  341. 			}
  342. 			if(startNull!=INITIAL_INT)
  343. 			{
  344. 				fprintf(htmlFile, ++altRowSTI%2==0?"<tr class=\"td\">":"<tr class=\"td2\">");
  345. 				if(startNull<i-1)
  346. 				{
  347. 					fprintf(htmlFile, "<td>%d...%d</td><td>NULL</td></tr>", startNull, i-1);
  348. 				}
  349. 				else
  350. 				{
  351. 					fprintf(htmlFile, "<td>%d</td><td>NULL</td></tr>", i-1);
  352. 				}
  353. 				startNull = INITIAL_INT;
  354. 			}
  355. 			fprintf(htmlFile, "</tbody></table>");
  356. 			fclose(htmlFile);
  357. 			return EXIT_SUCCESS;
  358. 		}
  359. 	}
  360. 	else
  361. 	{
  362. 		printMsg(DEB_EXEC,"-------------------------Symbols table is null", __FILE__, __LINE__);
  363. 	}
  364. 	return EXIT_FAILURE;
  365. }
  366. char *variableUsageToString(VariableUsage usage)
  367. {
  368. 	switch(usage)
  369. 	{
  370. 		case VAR_USAGE_NEVER:
  371. 			return "n'est jamais utilisée";
  372. 			break;
  373. 		case VAR_USAGE_SOMETIMES:
  374. 			return "est parfois utilisée";
  375. 			break;
  376. 		case VAR_USAGE_ALWAYS:
  377. 			return "est toujours utilisée";
  378. 			break;
  379. 		default:
  380. 			return "[Erreur (valeur hors norme)]";
  381. 	}
  382. }
  383. void printScopeUsage(ScopeStack *scopeStack)
  384. {
  385. 	if(scopeStack!=NULL)
  386. 	{
  387. 		printf(
  388. 			"; %s(...) : la %s '%s' %s\n",
  389. 			scopeStack->functionNode==NULL?"Program":scopeStack->functionNode->info->name,
  390. 			scopeStack->declarationNode->type==NODE_TYPE_FUNCTION?"fonction":"variable",
  391. 			scopeStack->declarationNode->info->name,
  392. 			variableUsageToString(scopeStack->usage)
  393. 		);
  394. 		printScopeUsage(scopeStack->parentPtr);
  395. 	}
  396. }
  397. int printSymbolsUsage()
  398. {
  399. 	printf("\n;\n;Symbols usage\n");
  400. 	if(declarations!=NULL)
  401. 	{
  402. 		int i;
  403. 		for(i=0;i<TABLES_SIZE;i++)
  404. 		{
  405. 			if(declarations[i]!=NULL)
  406. 			{
  407. 				SymTableEntry *entry = declarations[i];
  408. 				while(entry!=NULL)
  409. 				{
  410. 					printScopeUsage(entry->scopeStack);
  411. 					entry = entry->next;
  412. 				}
  413. 			}
  414. 		}
  415. 		return EXIT_SUCCESS;
  416. 	}
  417. 	else
  418. 	{
  419. 		printMsg(DEB_EXEC,"Can't print it: Symbols table is null", __FILE__, __LINE__);
  420. 	}
  421. 	return EXIT_FAILURE;
  422. }
  423. void printScopeDebug(ScopeStack *scopeStack, int tableId, int stackId)
  424. {
  425. 	if(scopeStack!=NULL)
  426. 	{
  427. 		printf(
  428. 			"\n; Table[%3d][%2d]= %7s %10s line %3d, col %3d; scope %d; %s function, ",
  429. 			tableId,
  430. 			stackId,
  431. 			typeToString(scopeStack->declarationNode->info->type),
  432. 			scopeStack->declarationNode->info->name,
  433. 			scopeStack->declarationNode->debug->line,
  434. 			scopeStack->declarationNode->debug->linePsn,
  435. 			scopeStack->declarationNode->info->scopeId,
  436. 			scopeStack->functionNode==NULL?"No ":scopeStack->functionNode->info->name
  437. 		);
  438. 		printScopeDebug(scopeStack->parentPtr, tableId, ++stackId);
  439. 	}
  440. }
  441. int printSymbolsTableDebug(char*file, int line)
  442. {
  443. 	printMsg(DEB_EXEC,"-------------------------Symbols table state", file, line);
  444. 	if(declarations!=NULL)
  445. 	{
  446. 		int i;
  447. 		for(i=0;i<TABLES_SIZE;i++)
  448. 		{
  449. 			if(declarations[i]!=NULL)
  450. 			{
  451. 				SymTableEntry *entry = declarations[i];
  452. 				while(entry!=NULL)
  453. 				{
  454. 					printScopeDebug(entry->scopeStack, i, 0);
  455. 					entry = entry->next;
  456. 				}
  457. 			}
  458. 		}
  459. 		return EXIT_SUCCESS;
  460. 	}
  461. 	else
  462. 	{
  463. 		printMsg(DEB_EXEC,"-------------------------Symbols table is null", __FILE__, __LINE__);
  464. 	}
  465. 	return EXIT_FAILURE;
  466. }
  467. /******************************************************************************/
  468. /**
  469.  * Prints an AST node into the html file
  470.  * Internal business
  471.  */
  472. void printHTMLNode(FILE *file, AstNode *node, int depth)
  473. {
  474. 	if(node!=NULL)
  475. 	{
  476. 		fprintf(file, "<li><b>Noeud :</b> %s (%d)\n", typeToString(node->type), node->type);
  477. 		if(node->info!=NULL)
  478. 		{
  479. 			fprintf(
  480. 			file,
  481. 			"<br /><b>Type :</b> %s <br /><b>Nom :</b> %s<br /><b>Valeur :</b> %d\n",
  482. 			typeToString(node->info->type),
  483. 			node->info->name,
  484. 			node->info->value
  485. 			);
  486. 		}else fprintf(file, "<li>Info null (%d)\n",depth);
  487. 		fprintf(file, "</li>\n");/*char *name, int type, int value
  488. 	while(node->rightBrother!=NULL)
  489. 	{
  490. 		printNode(file, node->rightBrother, depth);
  491. 	}*/
  492. 	}else fprintf(file, "<li>Noeud null (%d)</li>\n",depth);
  493. }
  494. /**
  495.  * Prints the AST into the html file
  496.  * Internal business
  497.  */
  498. void printHTMLTree(FILE *file, AstNode *node, int depth)
  499. {
  500. 	if(node!=NULL)
  501. 	{
  502. 		fprintf(file, "<ul>\n");
  503. 		printHTMLNode(file, node, depth);
  504. 		printHTMLTree(file, node->left, depth+1);
  505. 		printHTMLTree(file, node->right, depth+1);
  506. 		fprintf(file, "</ul>\n");
  507. 	}else fprintf(file, "<ul><li>Noeud null (%d)</li></ul>\n",depth);
  508.  
  509. }/**
  510.  * Prints an AST node into the xml file
  511.  * Internal business
  512.  */
  513. void printXMLNode(FILE *file, AstNode *node, int depth)
  514. {
  515. 	if(node!=NULL)
  516. 	{
  517. 		fprintf(file, "%s<depth>%d</depth>", typeToString(node->type), depth);
  518. 		fprintf(file, "<memaddress>%p</memaddress>", node);
  519. 		if(node->parent!=NULL)
  520. 		{
  521. 			fprintf(file, "<parent><type>%s</type><pmemaddress>%p</pmemaddress></parent>", typeToString(node->parent->type), node->parent);
  522. 		}else
  523. 		{
  524. 			fprintf(file, "<parent>NULL</parent>");
  525. 		}
  526. 		if(node->info!=NULL)
  527. 		{
  528. 			fprintf(
  529. 			file,
  530. 			"<info><rightmemaddress>%p</rightmemaddress><leftmemaddress>%p</leftmemaddress><infotype>%s</infotype><infoname>%s</infoname><infoval>%d</infoval></info>\n",
  531. 			node->right,
  532. 			node->left,
  533. 			typeToString(node->info->type),
  534. 			node->info->name,
  535. 			node->info->value,
  536. 			depth
  537. 			);
  538. 		}
  539. 	}
  540. 	else fprintf(file, "null");
  541. }/**
  542.  * Prints the AST into the xml file
  543.  * Internal business
  544.  */
  545. void printXMLTree(FILE *file, AstNode *node, int depth)
  546. {
  547. 	fprintf(file, "<node%d>\n", depth);
  548. 	printXMLNode(file, node, depth);
  549. 	if(node!=NULL)
  550. 	{
  551. 		printXMLTree(file, node->left, depth+1);
  552. 		printXMLTree(file, node->right, depth+1);
  553. 	}
  554. 	fprintf(file, "</node%d>\n", depth);
  555.  
  556. }
  557. /******************************************************************************/
  558. /**
  559.  * Returns a human readable string from a given type constant value
  560.  * Expected : one of the DEB_xxx constants
  561.  * Exposed method
  562.  */
  563. char* debugLevelToString(int type)
  564. {
  565. 	char *str = NULL;
  566. 	switch(type)
  567. 	{
  568. 		case DEB_L:
  569. 			str = "Lex tokens";
  570. 			break;
  571. 		case DEB_Y:
  572. 			str = "Yacc parsing";
  573. 			break;
  574. 		case DEB_O:
  575. 			str = "Misc files";
  576. 			break;
  577. 		case DEB_I:
  578. 			str = "Information messages";
  579. 			break;
  580. 		case DEB_P:
  581. 			str = "P-code generation";
  582. 			break;
  583. 		case DEB_W:
  584. 			str = "Warning messages";
  585. 			break;
  586. 		case DEB_EXEC:
  587. 			str = "Minimum excution messages";
  588. 			break;
  589. 		case DEB_E:
  590. 			str = "Error messages";
  591. 			break;
  592. 		case DEB_NONE:
  593. 			str = "Silent (no other output than p-code, and OK or KO)";
  594. 			break;
  595. 		default:
  596. 			str = "undefined";
  597. 			#if(VERBOSE_LEVEL<=DEB_W)
  598. 				char str[1024];//todo: minimize length
  599. 				sprintf(str, "Undefined constant value '%d'",  type);
  600. 				printMsg(DEB_W, str, __FILE__, __LINE__);
  601. 			#endif
  602. 			break;
  603. 	}
  604. 	return str;
  605. }
  606. /******************************************************************************/
  607. /**
  608.  * Generates p-code output on stdout,
  609.  * and (if GENERATE_PCODE_FILE is set to 1) write it into a file
  610.  * source http://www.pps.jussieu.fr/~rifflet/enseignements/LC4/vararg.html
  611.  * Only one digit format allowed (examples %s, %d, %f, %l)
  612.  */
  613. void printPCode(FILE* pcodeFile, char *format, ...)
  614. {
  615. 	if(PCODE_GENERATION_BYPASS)
  616. 	{
  617. 		return;
  618. 	}
  619. 	va_list p_list;
  620. 	int i;
  621. 	long l;
  622. 	double f;
  623. 	char *s;
  624. 	int validFormat;
  625. 	validFormat=0;
  626.  
  627. 	va_start(p_list, format);
  628.  
  629. 	#if(VERBOSE_LEVEL==DEB_NONE)
  630. 	if(*format!=';')
  631. 	{
  632. 	#endif
  633.  
  634. 	while (*format != 0) {
  635. 		switch(*format){
  636. 			case '%' :
  637. 				validFormat=1;
  638. 				break;
  639. 			case 'd': /* type int */
  640. 				if(validFormat==1)
  641. 				{
  642. 					i = va_arg(p_list, int);
  643. 					if(pcodeFile!=NULL){
  644. 						fprintf(pcodeFile, "%d", i);
  645. 					}
  646. 					printf("%d", i);
  647. 				}
  648. 				break;
  649. 			case 'l': /* type long */
  650. 				if(validFormat==1)
  651. 				{
  652. 					l = va_arg(p_list, long);
  653. 					if(pcodeFile!=NULL){
  654. 						fprintf(pcodeFile, "%ld", l);
  655. 					}
  656. 					printf("%ld", l);
  657. 				}
  658. 				break;
  659. 			case 'f' : /* type double */
  660. 				if(validFormat==1)
  661. 				{
  662. 					f = va_arg(p_list, double);
  663. 					if(pcodeFile!=NULL){
  664. 						fprintf(pcodeFile, "%lf", f);
  665. 					}
  666. 					printf("%lf", f);
  667. 				}
  668. 				break;
  669. 			case 's' : /* type char[] */
  670. 				if(validFormat==1)
  671. 				{
  672. 					s = va_arg(p_list, char *);
  673. 					if(pcodeFile!=NULL){
  674. 						fprintf(pcodeFile, "%s", s);
  675. 					}
  676. 					printf("%s", s);
  677. 				}
  678. 				break;
  679. //			case 'c' : /* type char * */
  680. //				if(validFormat==1)
  681. //				{
  682. //					s = va_arg(p_list, char *);
  683. //					if(pcodeFile!=NULL){
  684. //						fprintf(pcodeFile, "%s", s);
  685. //					}
  686. //					printf("%s", s);
  687. //				}
  688. //				break;
  689. 			default : /* type char[] */
  690. 				validFormat=0;
  691. 				break;
  692. 		}
  693. 		if(validFormat==0)
  694. 		{
  695. 			printf("%c",format[0]);
  696. 			if(pcodeFile!=NULL){
  697. 				fprintf(pcodeFile, "%c",format[0]);
  698. 			}
  699. 		}
  700. 		format++;
  701. 	}
  702. 	#if(VERBOSE_LEVEL==DEB_NONE)
  703. 	}
  704. 	#endif
  705. 	va_end(p_list);
  706. }

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/console.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.