matiec: comparison stage1_2/iec

equal deleted inserted replaced

-:89eb85bab58f
+:c61b2e370181
 #define YY_INPUT(buf,result,max_size)  {\
 result = GetNextChar(buf, max_size);\
 if (  result <= 0  )\
 result = YY_NULL;\
 }
-/* A counter to track the order by which each token is processed.
-* NOTE: This counter is not exactly linear (i.e., it does not get incremented by 1 for each token).
-*       i.e.. it may get incremented by more than one between two consecutive tokens.
-*       This is due to the fact that the counter gets incremented every 'user action' in flex,
-*       however not every user action will result in a token being passed to bison.
-*       Nevertheless this is still OK, as we are only interested in the relative
-*       ordering of tokens...
-*/
-static long int current_order = 0;
 /* Macro that is executed for every action.
 * We use it to pass the location of the token
 * back to the bison parser...
 	yylloc.last_file = current_filename;					\
 	yylloc.last_order = current_order;					\
 	current_tracking->currentTokenStart = current_tracking->currentChar;	\
 	current_order++;							\
 	}
 /* Since this lexical parser we defined only works in ASCII based
 * systems, we might as well make sure it is being compiled on
 * one...
 * Lets check a few random characters...
 file_include_pragma_end		\"{st_whitespace}"}"
 file_include_pragma			{file_include_pragma_beg}{file_include_pragma_filename}{file_include_pragma_end}
 %{
-#define MAX_INCLUDE_DEPTH 16
+/* A counter to track the order by which each token is processed.
+* NOTE: This counter is not exactly linear (i.e., it does not get incremented by 1 for each token).
+*       i.e.. it may get incremented by more than one between two consecutive tokens.
+*       This is due to the fact that the counter gets incremented every 'user action' in flex,
+*       however not every user action will result in a token being passed to bison.
+*       Nevertheless this is still OK, as we are only interested in the relative
+*       ordering of tokens...
+*/
+static long int current_order = 0;
 typedef struct {
 int eof;
 int lineNumber;
 int currentChar;
 int lineLength;
 int currentTokenStart;
 char *buffer;
 FILE *in_file;
 } tracking_t;
+/* A forward declaration of a function defined at the end of this file. */
+void FreeTracking(tracking_t *tracking);
+#define MAX_INCLUDE_DEPTH 16
 typedef struct {
 	  YY_BUFFER_STATE buffer_state;
 	  tracking_t *env;
 	  const char *filename;
 			       *       As a corollory, flex can never safely close the main input file, and we must ask
 			       *       bison to close it!
 			       */
 			  if (include_stack_ptr == 0) {
 			      // fclose(yyin);           // Must not do this!!
-			      // free(current_tracking); // Must not do this!!
+			      // FreeTracking(current_tracking); // Must not do this!!
 			      /* yyterminate() terminates the scanner and returns a 0 to the
 			       * scanner's  caller, indicating "all done".
 			       *
 			       * Our syntax parser (written with bison) has the token
 			       * END_OF_INPUT associated to the value 0, so even though
 			       * calling yyterminate() is equivalent to doing that.
 			       */
 			    yyterminate();
 			  } else {
 			    fclose(yyin);
-			    free(current_tracking);
+			    FreeTracking(current_tracking);
 			    --include_stack_ptr;
 			    yy_delete_buffer(YY_CURRENT_BUFFER);
 			    yy_switch_to_buffer((include_stack[include_stack_ptr]).buffer_state);
 			    current_tracking = include_stack[include_stack_ptr].env;
 			      /* removing constness of char *. This is safe actually,
 /*************************/
 /* Tracking Functions... */
 /*************************/
-#define MAX_BUFFER_LENGTH 1000
+#define MAX_LINE_LENGTH 1000
 tracking_t *GetNewTracking(FILE* in_file) {
 tracking_t* new_env = new tracking_t;
 new_env->eof = 0;
 new_env->lineNumber = 0;
 new_env->currentChar = 0;
 new_env->lineLength = 0;
 new_env->currentTokenStart = 0;
-new_env->buffer = (char*)malloc(MAX_BUFFER_LENGTH);
+new_env->buffer = (char*)malloc(MAX_LINE_LENGTH);
 new_env->in_file = in_file;
 return new_env;
+}
+void FreeTracking(tracking_t *tracking) {
+free(tracking->buffer);
+delete tracking;
 }
 /* GetNextChar: reads a character from input */
 int GetNextChar(char *b, int maxBuffer) {
 while (  current_tracking->currentChar >= current_tracking->lineLength  ) {
 current_tracking->currentChar = 0;
 current_tracking->currentTokenStart = 1;
 current_tracking->eof = false;
-p = fgets(current_tracking->buffer, MAX_BUFFER_LENGTH, current_tracking->in_file);
+p = fgets(current_tracking->buffer, MAX_LINE_LENGTH, current_tracking->in_file);
 if (  p == NULL  ) {
 if (  ferror(current_tracking->in_file)  )
 return 0;
 current_tracking->eof = true;
 return 0;
 * if we return newlines back to the input stream. These newlines will be re-counted
 * a second time when they are processed again by flex.
 * We therefore determine how many newlines are in the text we are returning,
 * and decrement the line counter acordingly...
 */
-/*unsigned int i;
+/*
+unsigned int i;
 for (i = n; i < strlen(yytext); i++)
 if (yytext[i] == '\n')
-current_tracking->lineNumber--;*/
+current_tracking->lineNumber--;
+*/
 /* now return all the text back to the input stream... */
 yyless(n);
 }

changeset 879	c61b2e370181
parent 876	e2c4f6f4abe2
child 880	599e88d12f9a