parser: remove a memory leak on /* block comments */ 46/21146/3
Clément DAVID [Wed, 4 Dec 2019 09:59:41 +0000 (10:59 +0100)]
Change-Id: I9e9870eabfd92a295d8576b22337471ff778f17d

scilab/modules/ast/includes/exps/location.hxx
scilab/modules/ast/src/cpp/parse/flex/scanscilab.ll
scilab/modules/ast/src/cpp/parse/scanscilab.cpp

index 93ac47c..fa367ab 100644 (file)
@@ -43,10 +43,6 @@ public:
     {
     }
 
-    Location(const Location & l) : first_line(l.first_line), first_column(l.first_column), last_line(l.last_line), last_column(l.last_column)
-    {
-    }
-
     Location* clone()
     {
         Location* ret = new Location();
index fddd8e1..ea0f23e 100644 (file)
@@ -1124,6 +1124,7 @@ assign                    "="
     if (comment_level == 0) {
       ParserSingleInstance::popControlStatus();
       yy_pop_state();
+      delete yylval.comment;
       //return scan_throw(BLOCKCOMMENT);
     }
   }
index 53566df..27d5420 100644 (file)
@@ -6,7 +6,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 6
-#define YY_FLEX_SUBMINOR_VERSION 1
+#define YY_FLEX_SUBMINOR_VERSION 4
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -81,10 +81,16 @@ typedef unsigned int flex_uint32_t;
 #define UINT32_MAX             (4294967295U)
 #endif
 
+#ifndef SIZE_MAX
+#define SIZE_MAX               (~(size_t)0)
+#endif
+
 #endif /* ! C99 */
 
 #endif /* ! FLEXINT_H */
 
+/* begin standard C++ headers. */
+
 /* TODO: this is always defined, so inline it */
 #define yyconst const
 
@@ -97,32 +103,26 @@ typedef unsigned int flex_uint32_t;
 /* Returned upon end-of-file. */
 #define YY_NULL 0
 
-/* Promotes a possibly negative, possibly signed char to an unsigned
- * integer for use as an array index.  If the signed char is negative,
- * we want to instead treat it as an 8-bit unsigned char, hence the
- * double cast.
+/* Promotes a possibly negative, possibly signed char to an
+ *   integer in range [0..255] for use as an array index.
  */
-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
 
 /* Enter a start condition.  This macro really ought to take a parameter,
  * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.
  */
 #define BEGIN (yy_start) = 1 + 2 *
-
 /* Translate the current start state into a value that can be later handed
  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.
  */
 #define YY_START (((yy_start) - 1) / 2)
 #define YYSTATE YY_START
-
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
-
 /* Special action meaning "start processing a new file". */
-#define YY_NEW_FILE yyrestart(yyin  )
-
+#define YY_NEW_FILE yyrestart( yyin  )
 #define YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */
@@ -159,7 +159,7 @@ extern FILE *yyin, *yyout;
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
-
+    
     #define YY_LESS_LINENO(n)
     #define YY_LINENO_REWIND_TO(ptr)
     
@@ -168,7 +168,7 @@ extern FILE *yyin, *yyout;
        do \
                { \
                /* Undo effects of setting up yytext. */ \
-        yy_size_t yyless_macro_arg = (n); \
+        int yyless_macro_arg = (n); \
         YY_LESS_LINENO(yyless_macro_arg);\
                *yy_cp = (yy_hold_char); \
                YY_RESTORE_YY_MORE_OFFSET \
@@ -176,7 +176,6 @@ extern FILE *yyin, *yyout;
                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
                } \
        while ( 0 )
-
 #define unput(c) yyunput( c, (yytext_ptr)  )
 
 #ifndef YY_STRUCT_YY_BUFFER_STATE
@@ -219,7 +218,7 @@ struct yy_buffer_state
 
     int yy_bs_lineno; /**< The line count. */
     int yy_bs_column; /**< The column count. */
-    
+
        /* Whether to try to fill the input buffer when we reach the
         * end of it.
         */
@@ -258,7 +257,6 @@ static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                           : NULL)
-
 /* Same as previous macro, but useful when we know that the buffer stack is not
  * NULL or when we need an lvalue. For internal use only.
  */
@@ -279,65 +277,59 @@ static int yy_start = 0;  /* start state number */
  */
 static int yy_did_buffer_switch_on_eof;
 
-void yyrestart (FILE *input_file  );
-void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
-YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
-void yy_delete_buffer (YY_BUFFER_STATE b  );
-void yy_flush_buffer (YY_BUFFER_STATE b  );
-void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
-void yypop_buffer_state (void );
+void yyrestart ( FILE *input_file  );
+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size  );
+void yy_delete_buffer ( YY_BUFFER_STATE b  );
+void yy_flush_buffer ( YY_BUFFER_STATE b  );
+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer  );
+void yypop_buffer_state ( void );
 
-static void yyensure_buffer_stack (void );
-static void yy_load_buffer_state (void );
-static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
+static void yyensure_buffer_stack ( void );
+static void yy_load_buffer_state ( void );
+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file  );
+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
 
-#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size  );
+YY_BUFFER_STATE yy_scan_string ( const char *yy_str  );
+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len  );
 
-YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
-YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
-YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
-
-void *yyalloc (yy_size_t  );
-void *yyrealloc (void *,yy_size_t  );
-void yyfree (void *  );
+void *yyalloc ( yy_size_t  );
+void *yyrealloc ( void *, yy_size_t  );
+void yyfree ( void *  );
 
 #define yy_new_buffer yy_create_buffer
-
 #define yy_set_interactive(is_interactive) \
        { \
        if ( ! YY_CURRENT_BUFFER ){ \
         yyensure_buffer_stack (); \
                YY_CURRENT_BUFFER_LVALUE =    \
-            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+            yy_create_buffer( yyin, YY_BUF_SIZE ); \
        } \
        YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
        }
-
 #define yy_set_bol(at_bol) \
        { \
        if ( ! YY_CURRENT_BUFFER ){\
         yyensure_buffer_stack (); \
                YY_CURRENT_BUFFER_LVALUE =    \
-            yy_create_buffer(yyin,YY_BUF_SIZE ); \
+            yy_create_buffer( yyin, YY_BUF_SIZE ); \
        } \
        YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
        }
-
 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 
 /* Begin user sect3 */
 
 #define yywrap() (/*CONSTCOND*/1)
 #define YY_SKIP_YYWRAP
-
-typedef unsigned char YY_CHAR;
+typedef flex_uint8_t YY_CHAR;
 
 FILE *yyin = NULL, *yyout = NULL;
 
 typedef int yy_state_type;
 
 extern int yylineno;
-
 int yylineno = 1;
 
 extern char *yytext;
@@ -346,10 +338,10 @@ extern char *yytext;
 #endif
 #define yytext_ptr yytext
 
-static yy_state_type yy_get_previous_state (void );
-static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
-static int yy_get_next_buffer (void );
-static void yynoreturn yy_fatal_error (yyconst char* msg  );
+static yy_state_type yy_get_previous_state ( void );
+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  );
+static int yy_get_next_buffer ( void );
+static void yynoreturn yy_fatal_error ( const char* msg  );
 
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up yytext.
@@ -360,7 +352,6 @@ static void yynoreturn yy_fatal_error (yyconst char* msg  );
        (yy_hold_char) = *yy_cp; \
        *yy_cp = '\0'; \
        (yy_c_buf_p) = yy_cp;
-
 #define YY_NUM_RULES 145
 #define YY_END_OF_BUFFER 146
 /* This struct is not used in this scanner,
@@ -370,7 +361,7 @@ struct yy_trans_info
        flex_int32_t yy_verify;
        flex_int32_t yy_nxt;
        };
-static yyconst flex_int16_t yy_acclist[959] =
+static const flex_int16_t yy_acclist[959] =
     {   0,
     16408,  124,  124,  133,  133,  115,  115,  111,  111,  146,
        85,  145,   81,   85,  145,   82,  145,   82,   85,  145,
@@ -479,7 +470,7 @@ static yyconst flex_int16_t yy_acclist[959] =
        75,   25,   14,   75,   14,   75,   14,   25
     } ;
 
-static yyconst flex_int16_t yy_accept[917] =
+static const flex_int16_t yy_accept[917] =
     {   0,
         1,    1,    2,    3,    4,    5,    6,    7,    8,    9,
        10,   10,   10,   10,   10,   10,   10,   10,   10,   11,
@@ -584,7 +575,7 @@ static yyconst flex_int16_t yy_accept[917] =
       952,  953,  955,  957,  959,  959
     } ;
 
-static yyconst YY_CHAR yy_ec[256] =
+static const YY_CHAR yy_ec[256] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         2,    2,    4,    1,    1,    1,    1,    1,    1,    1,
@@ -616,7 +607,7 @@ static yyconst YY_CHAR yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst YY_CHAR yy_meta[71] =
+static const YY_CHAR yy_meta[71] =
     {   0,
         1,    2,    3,    4,    5,    6,    5,    7,    1,    6,
         8,    1,    9,    1,   10,    1,   11,    9,   12,    1,
@@ -627,7 +618,7 @@ static yyconst YY_CHAR yy_meta[71] =
         1,    5,    5,    5,    5,    5,    5,    5,    5,    5
     } ;
 
-static yyconst flex_uint16_t yy_base[948] =
+static const flex_int16_t yy_base[948] =
     {   0,
         0,   70,  138,  143,  148,  153,  158,  164,  169,  171,
       176,  181,  199,    0,  268,  323,  379,    0, 1223, 4715,
@@ -735,7 +726,7 @@ static yyconst flex_uint16_t yy_base[948] =
      4643, 4651, 4659, 4671, 4683, 4691, 4702
     } ;
 
-static yyconst flex_int16_t yy_def[948] =
+static const flex_int16_t yy_def[948] =
     {   0,
       915,  915,  916,  916,  917,  917,  918,  918,  919,  919,
       920,  920,  915,   13,  921,  921,  915,   17,  915,  915,
@@ -843,7 +834,7 @@ static yyconst flex_int16_t yy_def[948] =
       915,  915,  915,  915,  915,  915,  915
     } ;
 
-static yyconst flex_uint16_t yy_nxt[4786] =
+static const flex_int16_t yy_nxt[4786] =
     {   0,
        20,   21,   22,   23,   24,   25,   26,   27,   28,   29,
        30,   31,   32,   33,   34,   35,   36,   37,   38,   39,
@@ -1373,7 +1364,7 @@ static yyconst flex_uint16_t yy_nxt[4786] =
       915,  915,  915,  915,  915
     } ;
 
-static yyconst flex_int16_t yy_chk[4786] =
+static const flex_int16_t yy_chk[4786] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -2006,36 +1997,36 @@ std::string token_to_string(int);
 #define YY_EXTRA_TYPE void *
 #endif
 
-static int yy_init_globals (void );
+static int yy_init_globals ( void );
 
 /* Accessor methods to globals.
    These are made visible to non-reentrant scanners for convenience. */
 
-int yylex_destroy (void );
+int yylex_destroy ( void );
 
-int yyget_debug (void );
+int yyget_debug ( void );
 
-void yyset_debug (int debug_flag  );
+void yyset_debug ( int debug_flag  );
 
-YY_EXTRA_TYPE yyget_extra (void );
+YY_EXTRA_TYPE yyget_extra ( void );
 
-void yyset_extra (YY_EXTRA_TYPE user_defined  );
+void yyset_extra ( YY_EXTRA_TYPE user_defined  );
 
-FILE *yyget_in (void );
+FILE *yyget_in ( void );
 
-void yyset_in  (FILE * _in_str  );
+void yyset_in  ( FILE * _in_str  );
 
-FILE *yyget_out (void );
+FILE *yyget_out ( void );
 
-void yyset_out  (FILE * _out_str  );
+void yyset_out  ( FILE * _out_str  );
 
-                       int yyget_leng (void );
+                       int yyget_leng ( void );
 
-char *yyget_text (void );
+char *yyget_text ( void );
 
-int yyget_lineno (void );
+int yyget_lineno ( void );
 
-void yyset_lineno (int _line_number  );
+void yyset_lineno ( int _line_number  );
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -2043,32 +2034,31 @@ void yyset_lineno (int _line_number  );
 
 #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus
-extern "C" int yywrap (void );
+extern "C" int yywrap ( void );
 #else
-extern int yywrap (void );
+extern int yywrap ( void );
 #endif
 #endif
 
 #ifndef YY_NO_UNPUT
     
-    static void yyunput (int c,char *buf_ptr  );
+    static void yyunput ( int c, char *buf_ptr  );
     
 #endif
 
 #ifndef yytext_ptr
-static void yy_flex_strncpy (char *,yyconst char *,int );
+static void yy_flex_strncpy ( char *, const char *, int );
 #endif
 
 #ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * );
+static int yy_flex_strlen ( const char * );
 #endif
 
 #ifndef YY_NO_INPUT
-
 #ifdef __cplusplus
-static int yyinput (void );
+static int yyinput ( void );
 #else
-static int input (void );
+static int input ( void );
 #endif
 
 #endif
@@ -2077,11 +2067,11 @@ static int input (void );
         static int yy_start_stack_depth = 0;
         static int *yy_start_stack = NULL;
     
-    static void yy_push_state (int _new_state );
+    static void yy_push_state ( int _new_state );
     
-    static void yy_pop_state (void );
+    static void yy_pop_state ( void );
     
-    static int yy_top_state (void );
+    static int yy_top_state ( void );
     
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
@@ -2220,10 +2210,10 @@ YY_DECL
                if ( ! YY_CURRENT_BUFFER ) {
                        yyensure_buffer_stack ();
                        YY_CURRENT_BUFFER_LVALUE =
-                               yy_create_buffer(yyin,YY_BUF_SIZE );
+                               yy_create_buffer( yyin, YY_BUF_SIZE );
                }
 
-               yy_load_buffer_state( );
+               yy_load_buffer_state(  );
                }
 
        {
@@ -2254,9 +2244,9 @@ yy_match:
                                {
                                yy_current_state = (int) yy_def[yy_current_state];
                                if ( yy_current_state >= 916 )
-                                       yy_c = yy_meta[(unsigned int) yy_c];
+                                       yy_c = yy_meta[yy_c];
                                }
-                       yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
+                       yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
                        *(yy_state_ptr)++ = yy_current_state;
                        ++yy_cp;
                        }
@@ -3489,6 +3479,7 @@ YY_RULE_SETUP
     if (comment_level == 0) {
       ParserSingleInstance::popControlStatus();
       yy_pop_state();
+      delete yylval.comment;
       //return scan_throw(BLOCKCOMMENT);
     }
   }
@@ -3918,7 +3909,7 @@ ECHO;
                                {
                                (yy_did_buffer_switch_on_eof) = 0;
 
-                               if ( yywrap( ) )
+                               if ( yywrap(  ) )
                                        {
                                        /* Note: because we've taken care in
                                         * yy_get_next_buffer() to have set up
@@ -3985,7 +3976,7 @@ static int yy_get_next_buffer (void)
 {
        char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
        char *source = (yytext_ptr);
-       yy_size_t number_to_move, i;
+       int number_to_move, i;
        int ret_val;
 
        if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
@@ -4014,7 +4005,7 @@ static int yy_get_next_buffer (void)
        /* Try to read more data. */
 
        /* First move last chars to start of buffer. */
-       number_to_move = (yy_size_t) ((yy_c_buf_p) - (yytext_ptr)) - 1;
+       number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
 
        for ( i = 0; i < number_to_move; ++i )
                *(dest++) = *(source++);
@@ -4053,7 +4044,7 @@ static int yy_get_next_buffer (void)
                if ( number_to_move == YY_MORE_ADJ )
                        {
                        ret_val = EOB_ACT_END_OF_FILE;
-                       yyrestart(yyin  );
+                       yyrestart( yyin  );
                        }
 
                else
@@ -4067,12 +4058,15 @@ static int yy_get_next_buffer (void)
        else
                ret_val = EOB_ACT_CONTINUE_SCAN;
 
-       if ((int) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+       if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
                /* Extend the array by 50%, plus the number we really need. */
                int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
-               YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size  );
+               YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
+                       (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size  );
                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+               /* "- 2" to take care of EOB's */
+               YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
        }
 
        (yy_n_chars) += number_to_move;
@@ -4104,9 +4098,9 @@ static int yy_get_next_buffer (void)
                        {
                        yy_current_state = (int) yy_def[yy_current_state];
                        if ( yy_current_state >= 916 )
-                               yy_c = yy_meta[(unsigned int) yy_c];
+                               yy_c = yy_meta[yy_c];
                        }
-               yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
+               yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
                *(yy_state_ptr)++ = yy_current_state;
                }
 
@@ -4127,9 +4121,9 @@ static int yy_get_next_buffer (void)
                {
                yy_current_state = (int) yy_def[yy_current_state];
                if ( yy_current_state >= 916 )
-                       yy_c = yy_meta[(unsigned int) yy_c];
+                       yy_c = yy_meta[yy_c];
                }
-       yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
+       yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
        yy_is_jam = (yy_current_state == 915);
        if ( ! yy_is_jam )
                *(yy_state_ptr)++ = yy_current_state;
@@ -4202,7 +4196,7 @@ static int yy_get_next_buffer (void)
 
                else
                        { /* need more input */
-                       int offset = (yy_c_buf_p) - (yytext_ptr);
+                       int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
                        ++(yy_c_buf_p);
 
                        switch ( yy_get_next_buffer(  ) )
@@ -4219,13 +4213,13 @@ static int yy_get_next_buffer (void)
                                         */
 
                                        /* Reset buffer status. */
-                                       yyrestart(yyin );
+                                       yyrestart( yyin );
 
                                        /*FALLTHROUGH*/
 
                                case EOB_ACT_END_OF_FILE:
                                        {
-                                       if ( yywrap( ) )
+                                       if ( yywrap(  ) )
                                                return 0;
 
                                        if ( ! (yy_did_buffer_switch_on_eof) )
@@ -4265,11 +4259,11 @@ static int yy_get_next_buffer (void)
        if ( ! YY_CURRENT_BUFFER ){
         yyensure_buffer_stack ();
                YY_CURRENT_BUFFER_LVALUE =
-            yy_create_buffer(yyin,YY_BUF_SIZE );
+            yy_create_buffer( yyin, YY_BUF_SIZE );
        }
 
-       yy_init_buffer(YY_CURRENT_BUFFER,input_file );
-       yy_load_buffer_state( );
+       yy_init_buffer( YY_CURRENT_BUFFER, input_file );
+       yy_load_buffer_state(  );
 }
 
 /** Switch to a different input buffer.
@@ -4297,7 +4291,7 @@ static int yy_get_next_buffer (void)
                }
 
        YY_CURRENT_BUFFER_LVALUE = new_buffer;
-       yy_load_buffer_state( );
+       yy_load_buffer_state(  );
 
        /* We don't actually know whether we did this switch during
         * EOF (yywrap()) processing, but the only time this flag
@@ -4325,7 +4319,7 @@ static void yy_load_buffer_state  (void)
 {
        YY_BUFFER_STATE b;
     
-       b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
+       b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
@@ -4334,13 +4328,13 @@ static void yy_load_buffer_state  (void)
        /* yy_ch_buf has to be 2 characters longer than the size given because
         * we need to put in 2 end-of-buffer characters.
         */
-       b->yy_ch_buf = (char *) yyalloc((yy_size_t) (b->yy_buf_size + 2)  );
+       b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
        if ( ! b->yy_ch_buf )
                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
 
        b->yy_is_our_buffer = 1;
 
-       yy_init_buffer(b,file );
+       yy_init_buffer( b, file );
 
        return b;
 }
@@ -4359,9 +4353,9 @@ static void yy_load_buffer_state  (void)
                YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
 
        if ( b->yy_is_our_buffer )
-               yyfree((void *) b->yy_ch_buf  );
+               yyfree( (void *) b->yy_ch_buf  );
 
-       yyfree((void *) b  );
+       yyfree( (void *) b  );
 }
 
 /* Initializes or reinitializes a buffer.
@@ -4373,7 +4367,7 @@ static void yy_load_buffer_state  (void)
 {
        int oerrno = errno;
     
-       yy_flush_buffer(b );
+       yy_flush_buffer( b );
 
        b->yy_input_file = file;
        b->yy_fill_buffer = 1;
@@ -4416,7 +4410,7 @@ static void yy_load_buffer_state  (void)
        b->yy_buffer_status = YY_BUFFER_NEW;
 
        if ( b == YY_CURRENT_BUFFER )
-               yy_load_buffer_state( );
+               yy_load_buffer_state(  );
 }
 
 /** Pushes the new state onto the stack. The new state becomes
@@ -4447,7 +4441,7 @@ void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
        YY_CURRENT_BUFFER_LVALUE = new_buffer;
 
        /* copied from yy_switch_to_buffer. */
-       yy_load_buffer_state( );
+       yy_load_buffer_state(  );
        (yy_did_buffer_switch_on_eof) = 1;
 }
 
@@ -4466,7 +4460,7 @@ void yypop_buffer_state (void)
                --(yy_buffer_stack_top);
 
        if (YY_CURRENT_BUFFER) {
-               yy_load_buffer_state( );
+               yy_load_buffer_state(  );
                (yy_did_buffer_switch_on_eof) = 1;
        }
 }
@@ -4476,7 +4470,7 @@ void yypop_buffer_state (void)
  */
 static void yyensure_buffer_stack (void)
 {
-       int num_to_alloc;
+       yy_size_t num_to_alloc;
     
        if (!(yy_buffer_stack)) {
 
@@ -4490,9 +4484,9 @@ static void yyensure_buffer_stack (void)
                                                                );
                if ( ! (yy_buffer_stack) )
                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
-                                                                 
+
                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
-                               
+
                (yy_buffer_stack_max) = num_to_alloc;
                (yy_buffer_stack_top) = 0;
                return;
@@ -4521,7 +4515,7 @@ static void yyensure_buffer_stack (void)
  * @param base the character buffer
  * @param size the size in bytes of the character buffer
  * 
- * @return the newly allocated buffer state object. 
+ * @return the newly allocated buffer state object.
  */
 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
 {
@@ -4533,7 +4527,7 @@ YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
                /* They forgot to leave room for the EOB's. */
                return NULL;
 
-       b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
+       b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
        if ( ! b )
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
 
@@ -4547,7 +4541,7 @@ YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
        b->yy_fill_buffer = 0;
        b->yy_buffer_status = YY_BUFFER_NEW;
 
-       yy_switch_to_buffer(b  );
+       yy_switch_to_buffer( b  );
 
        return b;
 }
@@ -4560,10 +4554,10 @@ YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
  * @note If you want to scan bytes that may contain NUL values, then use
  *       yy_scan_bytes() instead.
  */
-YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
+YY_BUFFER_STATE yy_scan_string (const char * yystr )
 {
     
-       return yy_scan_bytes(yystr,(int) strlen(yystr) );
+       return yy_scan_bytes( yystr, (int) strlen(yystr) );
 }
 
 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
@@ -4573,16 +4567,16 @@ YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
  * 
  * @return the newly allocated buffer state object.
  */
-YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
+YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
 {
        YY_BUFFER_STATE b;
        char *buf;
        yy_size_t n;
-       yy_size_t i;
+       int i;
     
        /* Get memory for full buffer, including space for trailing EOB's. */
-       n = (yy_size_t) _yybytes_len + 2;
-       buf = (char *) yyalloc(n  );
+       n = (yy_size_t) (_yybytes_len + 2);
+       buf = (char *) yyalloc( n  );
        if ( ! buf )
                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
 
@@ -4591,7 +4585,7 @@ YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
 
        buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
 
-       b = yy_scan_buffer(buf,n );
+       b = yy_scan_buffer( buf, n );
        if ( ! b )
                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
 
@@ -4613,10 +4607,11 @@ YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
                new_size = (yy_size_t) (yy_start_stack_depth) * sizeof( int );
 
                if ( ! (yy_start_stack) )
-                       (yy_start_stack) = (int *) yyalloc(new_size  );
+                       (yy_start_stack) = (int *) yyalloc( new_size  );
 
                else
-                       (yy_start_stack) = (int *) yyrealloc((void *) (yy_start_stack),new_size  );
+                       (yy_start_stack) = (int *) yyrealloc(
+                                       (void *) (yy_start_stack), new_size  );
 
                if ( ! (yy_start_stack) )
                        YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
@@ -4644,9 +4639,9 @@ YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
 #define YY_EXIT_FAILURE 2
 #endif
 
-static void yynoreturn yy_fatal_error (yyconst char* msg )
+static void yynoreturn yy_fatal_error (const char* msg )
 {
-                       (void) fprintf( stderr, "%s\n", msg );
+                       fprintf( stderr, "%s\n", msg );
        exit( YY_EXIT_FAILURE );
 }
 
@@ -4657,7 +4652,7 @@ static void yynoreturn yy_fatal_error (yyconst char* msg )
        do \
                { \
                /* Undo effects of setting up yytext. */ \
-        yy_size_t yyless_macro_arg = (n); \
+        int yyless_macro_arg = (n); \
         YY_LESS_LINENO(yyless_macro_arg);\
                yytext[yyleng] = (yy_hold_char); \
                (yy_c_buf_p) = yytext + yyless_macro_arg; \
@@ -4674,7 +4669,7 @@ static void yynoreturn yy_fatal_error (yyconst char* msg )
  */
 int yyget_lineno  (void)
 {
-        
+    
     return yylineno;
 }
 
@@ -4790,7 +4785,7 @@ int yylex_destroy  (void)
     
     /* Pop the buffer stack, destroying each element. */
        while(YY_CURRENT_BUFFER){
-               yy_delete_buffer(YY_CURRENT_BUFFER  );
+               yy_delete_buffer( YY_CURRENT_BUFFER  );
                YY_CURRENT_BUFFER_LVALUE = NULL;
                yypop_buffer_state();
        }
@@ -4800,7 +4795,7 @@ int yylex_destroy  (void)
        (yy_buffer_stack) = NULL;
 
     /* Destroy the start condition stack. */
-        yyfree((yy_start_stack)  );
+        yyfree( (yy_start_stack)  );
         (yy_start_stack) = NULL;
 
     yyfree ( (yy_state_buf) );
@@ -4818,7 +4813,7 @@ int yylex_destroy  (void)
  */
 
 #ifndef yytext_ptr
-static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
+static void yy_flex_strncpy (char* s1, const char * s2, int n )
 {
                
        int i;
@@ -4828,7 +4823,7 @@ static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
 #endif
 
 #ifdef YY_NEED_STRLEN
-static int yy_flex_strlen (yyconst char * s )
+static int yy_flex_strlen (const char * s )
 {
        int n;
        for ( n = 0; s[n]; ++n )