Keine Cache-Version

Caching deaktiviert Standardeinstellung für diese Seite:aktiviert (code LNG204)
Wenn die Anzeige zu langsam ist, können Sie den Benutzermodus deaktivieren, um die zwischengespeicherte Version anzuzeigen.

console.c

Inhaltsverzeichnis

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

Deutsche Übersetzung

Sie haben gebeten, diese Seite auf Deutsch zu besuchen. Momentan ist nur die Oberfläche übersetzt, aber noch nicht der gesamte Inhalt.

Wenn Sie mir bei Übersetzungen helfen wollen, ist Ihr Beitrag willkommen. Alles, was Sie tun müssen, ist, sich auf der Website zu registrieren und mir eine Nachricht zu schicken, in der Sie gebeten werden, Sie der Gruppe der Übersetzer hinzuzufügen, die Ihnen die Möglichkeit gibt, die gewünschten Seiten zu übersetzen. Ein Link am Ende jeder übersetzten Seite zeigt an, dass Sie der Übersetzer sind und einen Link zu Ihrem Profil haben.

Vielen Dank im Voraus.

Dokument erstellt 05/10/2009, zuletzt geändert 28/10/2018
Quelle des gedruckten Dokuments:https://www.gaudry.be/de/sniplet-rf-lsd010/project/source/console.c.html

Die Infobro ist eine persönliche Seite, deren Inhalt in meiner alleinigen Verantwortung liegt. Der Text ist unter der CreativeCommons-Lizenz (BY-NC-SA) verfügbar. Weitere Informationen auf die Nutzungsbedingungen und dem Autor.