No cache version.

Caching disabled. Default setting for this page:enabled (code LNG204)
If the display is too slow, you can disable the user mode to view the cached version.

console.c

Contents

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

English translation

You have asked to visit this site in English. For now, only the interface is translated, but not all the content yet.

If you want to help me in translations, your contribution is welcome. All you need to do is register on the site, and send me a message asking me to add you to the group of translators, which will give you the opportunity to translate the pages you want. A link at the bottom of each translated page indicates that you are the translator, and has a link to your profile.

Thank you in advance.

Document created the 05/10/2009, last modified the 28/10/2018
Source of the printed document:https://www.gaudry.be/en/sniplet-rf-lsd010/project/source/console.c.html

The infobrol is a personal site whose content is my sole responsibility. The text is available under CreativeCommons license (BY-NC-SA). More info on the terms of use and the author.