VC warning fixes.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@34610 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/contrib/src/deprecated/doslex.c b/contrib/src/deprecated/doslex.c
index d63b9b2590f76d0d2bcfe197f8b008f7b08dc51d..1198926aab82b10278d33d1f36a1439eb131ad2e 100644 (file)
--- a/contrib/src/deprecated/doslex.c
+++ b/contrib/src/deprecated/doslex.c
@@ -2,11 +2,17 @@
 
 /* scanner skeleton version:
  * $Header$
 
 /* scanner skeleton version:
  * $Header$

-       Last change:  JS   13 Jul 97    6:17 pm
+  Last change:  JS   13 Jul 97    6:17 pm

  */
 /* Copyright: (c) Julian Smart */
 /* Licence:   wxWindows Licence */
 
  */
 /* Copyright: (c) Julian Smart */
 /* Licence:   wxWindows Licence */
 

+#ifdef __VISUALC__
+    #pragma warning(push)
+    #pragma warning(disable:4127) /* warning C4127: conditional expression is constant [about while ( 0 | 1 )] */
+    #pragma warning(disable:4244) /* warning C4244: '=' : conversion from 'A' to 'B', possible loss of data    */
+#endif
+

 #define FLEX_SCANNER
 
 #include <stdio.h>
 #define FLEX_SCANNER
 
 #include <stdio.h>


@@ -47,7 +53,7 @@
   /* the "const" storage-class-modifier is valid */
   #define YY_USE_CONST
 
   /* the "const" storage-class-modifier is valid */
   #define YY_USE_CONST
 

-#else  /* ! __cplusplus */
+#else /* ! __cplusplus */

 
   #ifdef __STDC__
 
 
   #ifdef __STDC__
 


@@ -62,6 +68,10 @@
 
   #endif  /* __STDC__ */
 
 
   #endif  /* __STDC__ */
 

+  #ifdef __VISUALC__
+    #define YY_USE_PROTOS
+  #endif
+

   #ifdef __BORLANDC__
     #include <io.h>
     #define YY_USE_PROTOS
   #ifdef __BORLANDC__
     #include <io.h>
     #define YY_USE_PROTOS


@@ -72,7 +82,7 @@
     #include <io.h>
   #endif
 
     #include <io.h>
   #endif
 

-#endif /* ! __cplusplus */
+#endif /* ! __cplusplus */

 
 
 #ifdef __TURBOC__
 
 
 #ifdef __TURBOC__


@@ -123,8 +133,8 @@
  * is returned in "result".
  */
 #define YY_INPUT(buf,result,max_size) \
  * is returned in "result".
  */
 #define YY_INPUT(buf,result,max_size) \

-       if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
-           YY_FATAL_ERROR( "read() in flex scanner failed" );
+    if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
+        YY_FATAL_ERROR( "read() in flex scanner failed" );

 #define YY_NULL 0
 
 
 #define YY_NULL 0
 
 


@@ -141,10 +151,10 @@
  * a single C statement (which needs a semi-colon terminator).
  * This avoids problems with code like:
  *
  * a single C statement (which needs a semi-colon terminator).
  * This avoids problems with code like:
  *

- *     if ( something_happens )
- *             YY_FATAL_ERROR( "oops, the something happened" );
- *     else
- *             everything_okay();
+ *   if ( something_happens )
+ *       YY_FATAL_ERROR( "oops, the something happened" );
+ *   else
+ *       everything_okay();

  *
  * Prior to using the do-while the compiler would get upset at the
  * "else" because it interpreted the "if" statement as being all
  *
  * Prior to using the do-while the compiler would get upset at the
  * "else" because it interpreted the "if" statement as being all


@@ -152,25 +162,25 @@
  */
 
 #if !defined(__VISAGECPP__)
  */
 
 #if !defined(__VISAGECPP__)

-  #define YY_FATAL_ERROR(msg) \
-       do \
-               { \
-               (void) fputs( msg, stderr ); \
-               (void) putc( '\n', stderr ); \
-               exit( 1 ); \
-               } \
-       while ( 0 )
+    #define YY_FATAL_ERROR(msg)             \
+        do                                  \
+        {                                   \
+            (void) fputs( msg, stderr );    \
+            (void) putc( '\n', stderr );    \
+            exit( 1 );                      \
+        }                                   \
+        while ( 0 )

 #else
 #else

-  /* suppress expression always false warning */
-  int os2var = 0;
-  #define YY_FATAL_ERROR(msg) \
-       do \
-               { \
-               (void) fputs( msg, stderr ); \
-               (void) putc( '\n', stderr ); \
-               exit( 1 ); \
-               } \
-       while ( os2var == 0 )
+    /* suppress expression always false warning */
+    int os2var = 0;
+    #define YY_FATAL_ERROR(msg)             \
+        do                                  \
+        {                                   \
+            (void) fputs( msg, stderr );    \
+            (void) putc( '\n', stderr );    \
+            exit( 1 );                      \
+        }                                   \
+        while ( os2var == 0 )

 #endif
 
 
 #endif
 
 


@@ -189,21 +199,21 @@ int yywrap(void) { return 1; }
 
 /* special action meaning "start processing a new file" */
 #if !defined(__VISAGECPP__)
 
 /* special action meaning "start processing a new file" */
 #if !defined(__VISAGECPP__)

-  #define YY_NEW_FILE \
-       do \
-               { \
-               yy_init_buffer( yy_current_buffer, yyin ); \
-               yy_load_buffer_state(); \
-               } \
-       while ( 0 )
+    #define YY_NEW_FILE                                \
+        do                                             \
+        {                                              \
+            yy_init_buffer( yy_current_buffer, yyin ); \
+            yy_load_buffer_state();                    \
+        }                                              \
+        while ( 0 )

 #else
 #else

-  #define YY_NEW_FILE \
-       do \
-               { \
-               yy_init_buffer( yy_current_buffer, yyin ); \
-               yy_load_buffer_state(); \
-               } \
-       while ( os2var == 0 )
+    #define YY_NEW_FILE                                \
+        do                                             \
+        {                                              \
+            yy_init_buffer( yy_current_buffer, yyin ); \
+            yy_load_buffer_state();                    \
+        }                                              \
+        while ( os2var == 0 )

 #endif
 
 
 #endif
 
 


@@ -222,9 +232,9 @@ int yywrap(void) { return 1; }
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 
 #define YY_CHAR unsigned char
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 
 #define YY_CHAR unsigned char

-// # line 1 "lexer.l"
+/* # line 1 "lexer.l" */

 #define INITIAL 0
 #define INITIAL 0

-// # line 9 "lexer.l"
+/* # line 9 "lexer.l" */

 /*
  * File:         lexer.l
  * Description:  Lexical analyser for PROLOGIO; can be used with
 /*
  * File:         lexer.l
  * Description:  Lexical analyser for PROLOGIO; can be used with


@@ -262,15 +272,15 @@ static int my_input(void);
 
 #ifdef FLEX_SCANNER
     #undef YY_INPUT
 
 #ifdef FLEX_SCANNER
     #undef YY_INPUT

-    #define YY_INPUT(buf,result,max_size) \
-   if (lex_read_from_string) \
-        { \
-            int c = my_input(); \
-            result = (c == 0) ? YY_NULL : ((buf)[0]=(c), 1); \
-        } \
-   else \
-       if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
-           YY_FATAL_ERROR( "read() in flex scanner failed" );
+    #define YY_INPUT(buf,result,max_size)                                  \
+    if (lex_read_from_string)                                              \
+    {                                                                      \
+        int c = my_input();                                                \
+        result = (c == 0) ? YY_NULL : ((buf)[0]=(c), 1);                   \
+    }                                                                      \
+    else                                                                   \
+        if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
+            YY_FATAL_ERROR( "read() in flex scanner failed" );

 #else
     #ifndef unput
         #undef unput
 #else
     #ifndef unput
         #undef unput


@@ -278,18 +288,18 @@ static int my_input(void);
     #define unput(_c) my_unput(_c)
 #endif
 
     #define unput(_c) my_unput(_c)
 #endif
 

-// # line 58 "lexer.l"
+/* # line 58 "lexer.l" */

 
 /* done after the current pattern has been matched and before the
  * corresponding action - sets up yytext
  */
 
 #define YY_DO_BEFORE_ACTION \
 
 /* done after the current pattern has been matched and before the
  * corresponding action - sets up yytext
  */
 
 #define YY_DO_BEFORE_ACTION \

-       yytext = yy_bp; \
-       yyleng = yy_cp - yy_bp; \
-       yy_hold_char = *yy_cp; \
-       *yy_cp = '\0'; \
-       yy_c_buf_p = yy_cp;
+    yytext = yy_bp;         \
+    yyleng = yy_cp - yy_bp; \
+    yy_hold_char = *yy_cp;  \
+    *yy_cp = '\0';          \
+    yy_c_buf_p = yy_cp;

 
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1


@@ -297,25 +307,25 @@ static int my_input(void);
 
 /* return all but the first 'n' matched characters back to the input stream */
 #if !defined(__VISAGECPP__)
 
 /* return all but the first 'n' matched characters back to the input stream */
 #if !defined(__VISAGECPP__)

-    #define yyless(n) \
-       do \
-               { \
-               /* undo effects of setting up yytext */ \
-               *yy_cp = yy_hold_char; \
-               yy_c_buf_p = yy_cp = yy_bp + n; \
-               YY_DO_BEFORE_ACTION; /* set up yytext again */ \
-               } \
-       while ( 0 )
+    #define yyless(n)                                      \
+        do                                                 \
+        {                                                  \
+            /* undo effects of setting up yytext */        \
+            *yy_cp = yy_hold_char;                         \
+            yy_c_buf_p = yy_cp = yy_bp + n;                \
+            YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+        }                                                  \
+        while ( 0 )

 #else
 #else

-    #define yyless(n) \
-       do \
-               { \
-               /* undo effects of setting up yytext */ \
-               *yy_cp = yy_hold_char; \
-               yy_c_buf_p = yy_cp = yy_bp + n; \
-               YY_DO_BEFORE_ACTION; /* set up yytext again */ \
-               } \
-       while ( os2var == 0 )
+    #define yyless(n)                                      \
+        do                                                 \
+        {                                                  \
+            /* undo effects of setting up yytext */        \
+            *yy_cp = yy_hold_char;                         \
+            yy_c_buf_p = yy_cp = yy_bp + n;                \
+            YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+        }                                                  \
+        while ( os2var == 0 )

 #endif
 
 #undef unput
 #endif
 
 #undef unput


@@ -325,16 +335,16 @@ struct yy_buffer_state
 {
     FILE *yy_input_file;
 
 {
     FILE *yy_input_file;
 

-    YY_CHAR *yy_ch_buf;                /* input buffer */
-    YY_CHAR *yy_buf_pos;       /* current position in input buffer */
+    YY_CHAR *yy_ch_buf;     /* input buffer */
+    YY_CHAR *yy_buf_pos;    /* current position in input buffer */

 
     /* size of input buffer in bytes, not including room for EOB characters*/
 
     /* size of input buffer in bytes, not including room for EOB characters*/

-    int yy_buf_size;   
+    int yy_buf_size;

 
     /* number of characters read into yy_ch_buf, not including EOB characters */
     int yy_n_chars;
 
 
     /* number of characters read into yy_ch_buf, not including EOB characters */
     int yy_n_chars;
 

-    int yy_eof_status;         /* whether we've seen an EOF on this buffer */
+    int yy_eof_status;      /* whether we've seen an EOF on this buffer */

 
 #define EOF_NOT_SEEN 0
 
 
 #define EOF_NOT_SEEN 0
 


@@ -358,7 +368,7 @@ static YY_BUFFER_STATE yy_current_buffer;
 /* yy_hold_char holds the character lost when yytext is formed */
 static YY_CHAR yy_hold_char;
 
 /* yy_hold_char holds the character lost when yytext is formed */
 static YY_CHAR yy_hold_char;
 

-static int yy_n_chars;         /* number of characters read into yy_ch_buf */
+static int yy_n_chars;      /* number of characters read into yy_ch_buf */

 
 
 
 
 
 


@@ -482,8 +492,8 @@ static YY_CHAR *yy_last_accepting_cpos;
  */
 /* points to current character in buffer */
 static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;
  */
 /* points to current character in buffer */
 static YY_CHAR *yy_c_buf_p = (YY_CHAR *) 0;

-static int yy_init = 1;                /* whether we need to initialize */
-static int yy_start = 0;       /* start state number */
+static int yy_init = 1;     /* whether we need to initialize */
+static int yy_start = 0;    /* start state number */

 
 /* flag which is used to allow yywrap()'s to do buffer switches
  * instead of setting up a fresh yyin.  A bit of a hack ...
 
 /* flag which is used to allow yywrap()'s to do buffer switches
  * instead of setting up a fresh yyin.  A bit of a hack ...


@@ -519,315 +529,315 @@ YY_DECL
 
 
     if ( yy_init )
 
 
     if ( yy_init )

-       {
-       YY_USER_INIT;
+    {
+        YY_USER_INIT;

 
 

-       if ( ! yy_start )
-           yy_start = 1;       /* first start state */
+        if ( ! yy_start )
+            yy_start = 1; /* first start state */

 
 

-       if ( ! yyin )
-           yyin = stdin;
+        if ( ! yyin )
+            yyin = stdin;

 
 

-       if ( ! yyout )
-           yyout = stdout;
+        if ( ! yyout )
+            yyout = stdout;

 
 

-       if ( yy_current_buffer )
-           yy_init_buffer( yy_current_buffer, yyin );
-       else
-           yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+        if ( yy_current_buffer )
+            yy_init_buffer( yy_current_buffer, yyin );
+        else
+            yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );

 
 

-       yy_load_buffer_state();
+        yy_load_buffer_state();

 
 

-       yy_init = 0;
-       }
+        yy_init = 0;
+    }

 
 #if !defined(__VISAGECPP__)
 
 #if !defined(__VISAGECPP__)

-    while ( 1 )                /* loops until end-of-file is reached */
+    while ( 1 ) /* loops until end-of-file is reached */

 #else
     os2var = 1;
     if (os2var == 0) return 0;
 #else
     os2var = 1;
     if (os2var == 0) return 0;

-    while ( os2var == 1 )              /* loops until end-of-file is reached */
+    while ( os2var == 1 )   /* loops until end-of-file is reached */

 #endif
 #endif

-       {
-       yy_cp = yy_c_buf_p;
+    {
+        yy_cp = yy_c_buf_p;

 
 

-       /* support of yytext */
-       *yy_cp = yy_hold_char;
+        /* support of yytext */
+        *yy_cp = yy_hold_char;

 
 

-       /* yy_bp points to the position in yy_ch_buf of the start of the
-        * current run.
-        */
-       yy_bp = yy_cp;
+        /* yy_bp points to the position in yy_ch_buf of the start of the
+         * current run.
+         */
+        yy_bp = yy_cp;

 
 

-       yy_current_state = yy_start;
+        yy_current_state = yy_start;

 yy_match:
 yy_match:

-       do
-           {
-           register YY_CHAR yy_c = yy_ec[*yy_cp];
-           if ( yy_accept[yy_current_state] )
-               {
-               yy_last_accepting_state = yy_current_state;
-               yy_last_accepting_cpos = yy_cp;
-               }
-           while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-               {
-               yy_current_state = yy_def[yy_current_state];
-               if ( yy_current_state >= 34 )
-                   yy_c = yy_meta[yy_c];
-               }
-           yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-           ++yy_cp;
-           }
-       while ( yy_current_state != 33 );
-       yy_cp = yy_last_accepting_cpos;
-       yy_current_state = yy_last_accepting_state;
+        do
+        {
+            register YY_CHAR yy_c = yy_ec[*yy_cp];
+            if ( yy_accept[yy_current_state] )
+            {
+                yy_last_accepting_state = yy_current_state;
+                yy_last_accepting_cpos = yy_cp;
+            }
+            while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+            {
+                yy_current_state = yy_def[yy_current_state];
+                if ( yy_current_state >= 34 )
+                    yy_c = yy_meta[yy_c];
+            }
+            yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+            ++yy_cp;
+        }
+        while ( yy_current_state != 33 );
+        yy_cp = yy_last_accepting_cpos;
+        yy_current_state = yy_last_accepting_state;

 
 yy_find_action:
 
 yy_find_action:

-       yy_act = yy_accept[yy_current_state];
+        yy_act = yy_accept[yy_current_state];

 
 

-       YY_DO_BEFORE_ACTION;
-       YY_USER_ACTION;
+        YY_DO_BEFORE_ACTION;
+        YY_USER_ACTION;

 
 

-do_action:     /* this label is used only to access EOF actions */
+do_action: /* this label is used only to access EOF actions */

 
 
 
 

-       switch ( yy_act )
-           {
-           case 0: /* must backtrack */
+        switch ( yy_act )

         {
         {

-           /* undo the effects of YY_DO_BEFORE_ACTION */
-           *yy_cp = yy_hold_char;
-           yy_cp = yy_last_accepting_cpos;
-           yy_current_state = yy_last_accepting_state;
-           goto yy_find_action;
-        }
+            case 0: /* must backtrack */
+            {
+                /* undo the effects of YY_DO_BEFORE_ACTION */
+                *yy_cp = yy_hold_char;
+                yy_cp = yy_last_accepting_cpos;
+                yy_current_state = yy_last_accepting_state;
+                goto yy_find_action;
+            }
+
+            case 1:
+            {
+                yylval.s = strdup((const char*) yytext);
+                return INTEGER;
+            }

 
 

-        case 1:
-        {
-            yylval.s = strdup((const char*) yytext);
-            return INTEGER;
-        }
+            case 2:
+            {
+                return EXP;
+            }

 
 

-        case 2:
-        {
-            return EXP;
-        }
+            case 3:
+            {
+                yylval.s = strdup((const char*) yytext);
+                return WORD;
+            }

 
 

-        case 3:
-        {
-            yylval.s = strdup((const char*) yytext);
-            return WORD;
-        }
+            case 4:
+            {
+                int len = strlen((const char*) yytext);
+                yytext[len-1] = 0;
+                yylval.s = strdup((const char*) (yytext+1));
+                return WORD;
+            }

 
 

-        case 4:
-        {
-            int len = strlen((const char*) yytext);
-                                   yytext[len-1] = 0;
-                                   yylval.s = strdup((const char*) (yytext+1));
-            return WORD;
-        }
+            case 5:
+            {
+                yylval.s = strdup((const char*) yytext);
+                return STRING;
+            }

 
 

-        case 5:
-        {
-            yylval.s = strdup((const char*) yytext);
-            return STRING;
-        }
+            case 6:
+            {
+                return OPEN;
+            }

 
 

-        case 6:
-        {
-            return OPEN;
-        }
+            case 7:
+            {
+                return CLOSE;
+            }

 
 

-        case 7:
-        {
-            return CLOSE;
-        }
+            case 8:
+            {
+                return COMMA;
+            }

 
 

-        case 8:
-        {
-            return COMMA;
-        }
+            case 9:
+            {
+                return OPEN_SQUARE;
+            }

 
 

-        case 9:
-        {
-            return OPEN_SQUARE;
-        }
+            case 10:
+            {
+                return CLOSE_SQUARE;
+            }

 
 

-        case 10:
-        {
-            return CLOSE_SQUARE;
-        }
+            case 11:
+            {
+                return EQUALS;
+            }

 
 

-        case 11:
-        {
-            return EQUALS;
-        }
+            case 12:
+            {
+                return PERIOD;
+            }

 
 

-        case 12:
-        {
-            return PERIOD;
-        }
+            case 13:
+            {
+                break;
+            }

 
 

-        case 13:
-        {
-            break;
-        }
+            case 14:
+            {
+                break;
+            }

 
 

-        case 14:
-        {
-            break;
-        }
+            case 15:
+            {
+            loop:
+#ifdef __cplusplus
+                while (yyinput() != '*') ;
+                switch (yyinput())
+#else
+                while (input() != '*') ;
+                switch (input())
+#endif
+                {
+                    case '/':
+                        break;
+                    case '*':
+                        unput('*');
+                    default:
+                        goto loop;
+                }
+                break;
+            }
+
+            case 16:
+            {
+                return ERROR;
+            }

 
 

-        case 15:
-        {
-          loop:
-            #ifdef __cplusplus
-                          while (yyinput() != '*') ;
-                          switch (yyinput())
-            #else
-                          while (input() != '*') ;
-                          switch (input())
-            #endif
-              {
-                  case '/':
-                      break;
-                  case '*':
-                      unput('*');
-                  default:
-                      goto loop;
-              }
-            break;
-        }
+            case 17:
+            {
+                ECHO;
+                break;
+            }

 
 

-        case 16:
-                                  {
-            return ERROR;
-                                  }
+            case YY_STATE_EOF(INITIAL):
+            {
+                yyterminate();
+            }

 
 

-        case 17:
-        {
-            ECHO;
+            case YY_END_OF_BUFFER:
+            {
+                /* amount of text matched not including the EOB char */
+                int yy_amount_of_matched_text = yy_cp - yytext - 1;
+
+                /* undo the effects of YY_DO_BEFORE_ACTION */
+                *yy_cp = yy_hold_char;
+
+                /* note that here we test for yy_c_buf_p "<=" to the position
+                 * of the first EOB in the buffer, since yy_c_buf_p will
+                 * already have been incremented past the NUL character
+                 * (since all states make transitions on EOB to the end-
+                 * of-buffer state).  Contrast this with the test in yyinput().
+                 */
+                if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+                /* this was really a NUL */
+                {
+                    yy_state_type yy_next_state;
+
+                    yy_c_buf_p = yytext + yy_amount_of_matched_text;
+
+                    yy_current_state = yy_get_previous_state();
+
+                    /* okay, we're now positioned to make the
+                     * NUL transition.  We couldn't have
+                     * yy_get_previous_state() go ahead and do it
+                     * for us because it doesn't know how to deal
+                     * with the possibility of jamming (and we
+                     * don't want to build jamming into it because
+                     * then it will run more slowly)
+                     */
+
+                    yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+                    yy_bp = yytext + YY_MORE_ADJ;
+
+                    if ( yy_next_state )
+                    {
+                        /* consume the NUL */
+                        yy_cp = ++yy_c_buf_p;
+                        yy_current_state = yy_next_state;
+                        goto yy_match;
+                    }
+                    else
+                    {
+                        yy_cp = yy_last_accepting_cpos;
+                        yy_current_state = yy_last_accepting_state;
+                        goto yy_find_action;
+                    }
+                }
+                else switch ( yy_get_next_buffer() )
+                {
+                    case EOB_ACT_END_OF_FILE:
+                    {
+                        yy_did_buffer_switch_on_eof = 0;
+
+                        if ( yywrap() )
+                        {
+                            /* note: because we've taken care in
+                             * yy_get_next_buffer() to have set up yytext,
+                             * we can now set up yy_c_buf_p so that if some
+                             * total hoser (like flex itself) wants
+                             * to call the scanner after we return the
+                             * YY_NULL, it'll still work - another YY_NULL
+                             * will get returned.
+                             */
+                            yy_c_buf_p = yytext + YY_MORE_ADJ;
+
+                            yy_act = YY_STATE_EOF((yy_start - 1) / 2);
+                            goto do_action;
+                        }
+                        else
+                        {
+                            if ( ! yy_did_buffer_switch_on_eof )
+                                YY_NEW_FILE;
+                        }
+                    }
+                    break;
+
+                    case EOB_ACT_CONTINUE_SCAN:
+                        yy_c_buf_p = yytext + yy_amount_of_matched_text;
+
+                        yy_current_state = yy_get_previous_state();
+
+                        yy_cp = yy_c_buf_p;
+                        yy_bp = yytext + YY_MORE_ADJ;
+                        goto yy_match;
+
+                    case EOB_ACT_LAST_MATCH:
+                        yy_c_buf_p = &yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+                        yy_current_state = yy_get_previous_state();
+
+                        yy_cp = yy_c_buf_p;
+                        yy_bp = yytext + YY_MORE_ADJ;
+                        goto yy_find_action;
+                }
+            }

             break;
             break;

-                          }
-
-        case YY_STATE_EOF(INITIAL):
-        {
-    yyterminate();
-        }

 
 

-           case YY_END_OF_BUFFER:
-               {
-               /* amount of text matched not including the EOB char */
-               int yy_amount_of_matched_text = yy_cp - yytext - 1;
-
-               /* undo the effects of YY_DO_BEFORE_ACTION */
-               *yy_cp = yy_hold_char;
-
-               /* note that here we test for yy_c_buf_p "<=" to the position
-                * of the first EOB in the buffer, since yy_c_buf_p will
-                * already have been incremented past the NUL character
-                * (since all states make transitions on EOB to the end-
-                * of-buffer state).  Contrast this with the test in yyinput().
-                */
-               if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
-                   /* this was really a NUL */
-                   {
-                   yy_state_type yy_next_state;
-
-                   yy_c_buf_p = yytext + yy_amount_of_matched_text;
-
-                   yy_current_state = yy_get_previous_state();
-
-                   /* okay, we're now positioned to make the
-                    * NUL transition.  We couldn't have
-                    * yy_get_previous_state() go ahead and do it
-                    * for us because it doesn't know how to deal
-                    * with the possibility of jamming (and we
-                    * don't want to build jamming into it because
-                    * then it will run more slowly)
-                    */
-
-                   yy_next_state = yy_try_NUL_trans( yy_current_state );
-
-                   yy_bp = yytext + YY_MORE_ADJ;
-
-                   if ( yy_next_state )
-                       {
-                       /* consume the NUL */
-                       yy_cp = ++yy_c_buf_p;
-                       yy_current_state = yy_next_state;
-                       goto yy_match;
-                       }
-                   else
-                       {
-                           yy_cp = yy_last_accepting_cpos;
-                           yy_current_state = yy_last_accepting_state;
-                       goto yy_find_action;
-                       }
-                   }
-               else switch ( yy_get_next_buffer() )
-                   {
-                   case EOB_ACT_END_OF_FILE:
-                       {
-                       yy_did_buffer_switch_on_eof = 0;
-
-                       if ( yywrap() )
-                           {
-                           /* note: because we've taken care in
-                            * yy_get_next_buffer() to have set up yytext,
-                            * we can now set up yy_c_buf_p so that if some
-                            * total hoser (like flex itself) wants
-                            * to call the scanner after we return the
-                            * YY_NULL, it'll still work - another YY_NULL
-                            * will get returned.
-                            */
-                           yy_c_buf_p = yytext + YY_MORE_ADJ;
-
-                           yy_act = YY_STATE_EOF((yy_start - 1) / 2);
-                           goto do_action;
-                           }
-                       else
-                           {
-                           if ( ! yy_did_buffer_switch_on_eof )
-                               YY_NEW_FILE;
-                           }
-                       }
-                       break;
-
-                   case EOB_ACT_CONTINUE_SCAN:
-                       yy_c_buf_p = yytext + yy_amount_of_matched_text;
-
-                       yy_current_state = yy_get_previous_state();
-
-                       yy_cp = yy_c_buf_p;
-                       yy_bp = yytext + YY_MORE_ADJ;
-                       goto yy_match;
-
-                   case EOB_ACT_LAST_MATCH:
-                    yy_c_buf_p = &yy_current_buffer->yy_ch_buf[yy_n_chars];
-
-                       yy_current_state = yy_get_previous_state();
-
-                       yy_cp = yy_c_buf_p;
-                       yy_bp = yytext + YY_MORE_ADJ;
-                       goto yy_find_action;
-                   }
-               break;
-               }
-
-           default:
+            default:

 #ifdef FLEX_DEBUG
 #ifdef FLEX_DEBUG

-               printf( "action # %d\n", yy_act );
+                printf( "action # %d\n", yy_act );

 #endif
 #endif

-            YY_FATAL_ERROR("fatal flex scanner internal error--no action found" );
-           }
-       }
+                YY_FATAL_ERROR("fatal flex scanner internal error--no action found" );
+        }
+    }

 
 #if defined(__VISAGECPP__)
 
 #if defined(__VISAGECPP__)

-/* VA complains about proc maybe not returning a value so return one */
-return 0;
+    /* VA complains about proc maybe not returning a value so return one */
+    return 0;

 #endif
 #endif

-    }
+}

 
 
 /* yy_get_next_buffer - try to read in a new buffer
 
 
 /* yy_get_next_buffer - try to read in a new buffer


@@ -849,8 +859,7 @@ static int yy_get_next_buffer()
     int ret_val;
 
     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
     int ret_val;
 
     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )

-       YY_FATAL_ERROR(
-               "fatal flex scanner internal error--end of buffer missed" );
+        YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" );

 
     /* try to read more data */
 
 
     /* try to read more data */
 


@@ -858,46 +867,46 @@ static int yy_get_next_buffer()
     number_to_move = yy_c_buf_p - yytext;
 
     for ( i = 0; i < number_to_move; ++i )
     number_to_move = yy_c_buf_p - yytext;
 
     for ( i = 0; i < number_to_move; ++i )

-       *(dest++) = *(source++);
+        *(dest++) = *(source++);

 
     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
 
     if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )

-       /* don't do the read, it's not guaranteed to return an EOF,
-        * just force an EOF
-        */
-       yy_n_chars = 0;
+        /* don't do the read, it's not guaranteed to return an EOF,
+         * just force an EOF
+         */
+        yy_n_chars = 0;

 
     else
 
     else

-       {
-       int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;
+    {
+        int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;

 
 

-       if ( num_to_read > YY_READ_BUF_SIZE )
-           num_to_read = YY_READ_BUF_SIZE;
+        if ( num_to_read > YY_READ_BUF_SIZE )
+            num_to_read = YY_READ_BUF_SIZE;

 
 

-       else if ( num_to_read <= 0 )
-           YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
+        else if ( num_to_read <= 0 )
+            YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );

 
 

-       /* read in more data */
-       YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
-                 yy_n_chars, num_to_read );
-       }
+        /* read in more data */
+        YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+            yy_n_chars, num_to_read );
+    }

 
     if ( yy_n_chars == 0 )
 
     if ( yy_n_chars == 0 )

-       {
-       if ( number_to_move == 1 )
-           {
-           ret_val = EOB_ACT_END_OF_FILE;
-           yy_current_buffer->yy_eof_status = EOF_DONE;
-           }
-
-       else
-           {
-           ret_val = EOB_ACT_LAST_MATCH;
-           yy_current_buffer->yy_eof_status = EOF_PENDING;
-           }
-       }
+    {
+        if ( number_to_move == 1 )
+        {
+            ret_val = EOB_ACT_END_OF_FILE;
+            yy_current_buffer->yy_eof_status = EOF_DONE;
+        }
+
+        else
+        {
+            ret_val = EOB_ACT_LAST_MATCH;
+            yy_current_buffer->yy_eof_status = EOF_PENDING;
+        }
+    }

 
     else
 
     else

-       ret_val = EOB_ACT_CONTINUE_SCAN;
+        ret_val = EOB_ACT_CONTINUE_SCAN;

 
     yy_n_chars += number_to_move;
     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
 
     yy_n_chars += number_to_move;
     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;


@@ -929,21 +938,21 @@ static yy_state_type yy_get_previous_state()
     yy_current_state = yy_start;
 
     for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
     yy_current_state = yy_start;
 
     for ( yy_cp = yytext + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )

-       {
-       register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
-       if ( yy_accept[yy_current_state] )
-           {
-           yy_last_accepting_state = yy_current_state;
-           yy_last_accepting_cpos = yy_cp;
-           }
-       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
-           {
-           yy_current_state = yy_def[yy_current_state];
-           if ( yy_current_state >= 34 )
-               yy_c = yy_meta[yy_c];
-           }
-       yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
-       }
+    {
+        register YY_CHAR yy_c = (*yy_cp ? yy_ec[*yy_cp] : 1);
+        if ( yy_accept[yy_current_state] )
+        {
+            yy_last_accepting_state = yy_current_state;
+            yy_last_accepting_cpos = yy_cp;
+        }
+        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+        {
+            yy_current_state = yy_def[yy_current_state];
+            if ( yy_current_state >= 34 )
+                yy_c = yy_meta[yy_c];
+        }
+        yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
+    }

 
     return ( yy_current_state );
 }
 
     return ( yy_current_state );
 }


@@ -967,16 +976,16 @@ register yy_state_type yy_current_state;
 
     register YY_CHAR yy_c = 1;
     if ( yy_accept[yy_current_state] )
 
     register YY_CHAR yy_c = 1;
     if ( yy_accept[yy_current_state] )

-       {
-       yy_last_accepting_state = yy_current_state;
-       yy_last_accepting_cpos = yy_cp;
-       }
+    {
+        yy_last_accepting_state = yy_current_state;
+        yy_last_accepting_cpos = yy_cp;
+    }

     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )

-       {
-       yy_current_state = yy_def[yy_current_state];
-       if ( yy_current_state >= 34 )
-           yy_c = yy_meta[yy_c];
-       }
+    {
+        yy_current_state = yy_def[yy_current_state];
+        if ( yy_current_state >= 34 )
+            yy_c = yy_meta[yy_c];
+    }

     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
     yy_is_jam = (yy_current_state == 33);
 
     yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
     yy_is_jam = (yy_current_state == 33);
 


@@ -998,26 +1007,26 @@ register YY_CHAR *yy_bp;
     *yy_cp = yy_hold_char;
 
     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
     *yy_cp = yy_hold_char;
 
     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )

-       { /* need to shift things up to make room */
-       register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
-       register YY_CHAR *dest =
-           &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
-       register YY_CHAR *source =
-           &yy_current_buffer->yy_ch_buf[number_to_move];
-
-       while ( source > yy_current_buffer->yy_ch_buf )
-           *--dest = *--source;
-
-       yy_cp += dest - source;
-       yy_bp += dest - source;
-       yy_n_chars = yy_current_buffer->yy_buf_size;
-
-       if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
-           YY_FATAL_ERROR( "flex scanner push-back overflow" );
-       }
+    { /* need to shift things up to make room */
+        register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars */
+        register YY_CHAR *dest =
+            &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];
+        register YY_CHAR *source =
+            &yy_current_buffer->yy_ch_buf[number_to_move];
+
+        while ( source > yy_current_buffer->yy_ch_buf )
+            *--dest = *--source;
+
+        yy_cp += dest - source;
+        yy_bp += dest - source;
+        yy_n_chars = yy_current_buffer->yy_buf_size;
+
+        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+            YY_FATAL_ERROR( "flex scanner push-back overflow" );
+    }

 
     if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
 
     if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )

-       yy_cp[-2] = '\n';
+        yy_cp[-2] = '\n';

 
     *--yy_cp = c;
 
 
     *--yy_cp = c;
 


@@ -1040,51 +1049,51 @@ static int input()
     *yy_cp = yy_hold_char;
 
     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
     *yy_cp = yy_hold_char;
 
     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )

-       {
-       /* yy_c_buf_p now points to the character we want to return.
-        * If this occurs *before* the EOB characters, then it's a
-        * valid NUL; if not, then we've hit the end of the buffer.
-        */
-       if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+    {
+        /* yy_c_buf_p now points to the character we want to return.
+         * If this occurs *before* the EOB characters, then it's a
+         * valid NUL; if not, then we've hit the end of the buffer.
+         */
+        if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )

         { /* this was really a NUL */
         { /* this was really a NUL */

-           *yy_c_buf_p = '\0';
+           *yy_c_buf_p = '\0';

         }
         }

-       else
-           { /* need more input */
-           yytext = yy_c_buf_p;
-           ++yy_c_buf_p;
-
-           switch ( yy_get_next_buffer() )
-               {
-               case EOB_ACT_END_OF_FILE:
-                   {
-                   if ( yywrap() )
-                       {
-                       yy_c_buf_p = yytext + YY_MORE_ADJ;
-                       return ( EOF );
-                       }
-                   YY_NEW_FILE;
-
-                    #ifdef __cplusplus
-                   return ( yyinput() );
-                    #else
-                   return ( input() );
-                    #endif
-                   }
-
-               case EOB_ACT_CONTINUE_SCAN:
-                   yy_c_buf_p = yytext + YY_MORE_ADJ;
-                   break;
-
-               case EOB_ACT_LAST_MATCH:
-                    #ifdef __cplusplus
-                   YY_FATAL_ERROR( "unexpected last match in yyinput()" );
-                    #else
-                   YY_FATAL_ERROR( "unexpected last match in input()" );
-                    #endif
-               }
-           }
-       }
+        else
+        { /* need more input */
+            yytext = yy_c_buf_p;
+            ++yy_c_buf_p;
+
+            switch ( yy_get_next_buffer() )
+            {
+                case EOB_ACT_END_OF_FILE:
+                {
+                    if ( yywrap() )
+                    {
+                        yy_c_buf_p = yytext + YY_MORE_ADJ;
+                        return ( EOF );
+                    }
+                    YY_NEW_FILE;
+
+#ifdef __cplusplus
+                    return ( yyinput() );
+#else
+                    return ( input() );
+#endif
+                }
+
+                case EOB_ACT_CONTINUE_SCAN:
+                    yy_c_buf_p = yytext + YY_MORE_ADJ;
+                    break;
+
+                case EOB_ACT_LAST_MATCH:
+#ifdef __cplusplus
+                    YY_FATAL_ERROR( "unexpected last match in yyinput()" );
+#else
+                    YY_FATAL_ERROR( "unexpected last match in input()" );
+#endif
+            }
+        }
+    }

 
     c = *yy_c_buf_p;
     yy_hold_char = *++yy_c_buf_p;
 
     c = *yy_c_buf_p;
     yy_hold_char = *++yy_c_buf_p;


@@ -1113,15 +1122,15 @@ YY_BUFFER_STATE new_buffer;
 #endif
 {
     if ( yy_current_buffer == new_buffer )
 #endif
 {
     if ( yy_current_buffer == new_buffer )

-       return;
+        return;

 
     if ( yy_current_buffer )
 
     if ( yy_current_buffer )

-       {
-       /* flush out information for old buffer */
-       *yy_c_buf_p = yy_hold_char;
-       yy_current_buffer->yy_buf_pos = yy_c_buf_p;
-       yy_current_buffer->yy_n_chars = yy_n_chars;
-       }
+    {
+        /* flush out information for old buffer */
+        *yy_c_buf_p = yy_hold_char;
+        yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+        yy_current_buffer->yy_n_chars = yy_n_chars;
+    }

 
     yy_current_buffer = new_buffer;
     yy_load_buffer_state();
 
     yy_current_buffer = new_buffer;
     yy_load_buffer_state();


@@ -1161,7 +1170,7 @@ int size;
     b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
 
     if ( ! b )
     b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
 
     if ( ! b )

-       YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

 
     b->yy_buf_size = size;
 
 
     b->yy_buf_size = size;
 


@@ -1171,7 +1180,7 @@ int size;
     b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
 
     if ( ! b->yy_ch_buf )
     b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );
 
     if ( ! b->yy_ch_buf )

-       YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

 
     yy_init_buffer( b, file );
 
 
     yy_init_buffer( b, file );
 


@@ -1187,7 +1196,7 @@ YY_BUFFER_STATE b;
 #endif
 {
     if ( b == yy_current_buffer )
 #endif
 {
     if ( b == yy_current_buffer )

-       yy_current_buffer = (YY_BUFFER_STATE) 0;
+        yy_current_buffer = (YY_BUFFER_STATE) 0;

 
     free( (char *) b->yy_ch_buf );
     free( (char *) b );
 
     free( (char *) b->yy_ch_buf );
     free( (char *) b );


@@ -1222,7 +1231,7 @@ FILE *file;
 
     b->yy_eof_status = EOF_NOT_SEEN;
 }
 
     b->yy_eof_status = EOF_NOT_SEEN;
 }

-// # line 108 "lexer.l"
+/* # line 108 "lexer.l" */

 
 
 
 
 
 


@@ -1231,7 +1240,7 @@ FILE *file;
     {
   return input();
     }
     {
   return input();
     }

-#else  /* BSD/AT&T lex */
+#else /* BSD/AT&T lex */

     #ifndef input
         #error "Sorry, but need either flex or AT&T lex"
     #endif
     #ifndef input
         #error "Sorry, but need either flex or AT&T lex"
     #endif


@@ -1297,28 +1306,31 @@ static int my_input( void )
 {
     if (lex_read_from_string)
     {
 {
     if (lex_read_from_string)
     {

-    if (lex_string_ptr == lex_buffer_length)
+        if (lex_string_ptr == lex_buffer_length)

         {
         {

-      return 0;
+            return 0;

         }
         else
         {
         }
         else
         {

-      char c = lex_buffer[lex_string_ptr++];
+            char c = lex_buffer[lex_string_ptr++];

 #ifndef FLEX_SCANNER
 #ifndef FLEX_SCANNER

-      if (c == '\n') yylineno++;
+            if (c == '\n') yylineno++;

 #endif
 #endif

-      return c;
-    }
+                return c;
+        }

     }
     else
     {
     }
     else
     {

-    return lex_input();
-  }
+        return lex_input();
+    }

 }
 
 void wxExprCleanUp()
 {
 }
 
 void wxExprCleanUp()
 {

-       if (yy_current_buffer)
-               yy_delete_buffer(yy_current_buffer);
+    if (yy_current_buffer)
+        yy_delete_buffer(yy_current_buffer);

 }
 
 }
 

+#ifdef __VISUALC__
+    #pragma warning(pop)
+#endif

diff --git a/contrib/src/deprecated/dosyacc.c b/contrib/src/deprecated/dosyacc.c
index e7a33d4a3eab81c14d1e7397dd76f6bb0ac164a4..6b03b4159d42a452c76b387d8bca4c4ea7668462 100644 (file)
--- a/contrib/src/deprecated/dosyacc.c
+++ b/contrib/src/deprecated/dosyacc.c
@@ -1,12 +1,18 @@
 /* Copyright: (c) Julian Smart */
 /* Licence:   wxWindows Licence */
 /* include platform.h first to get __WIN32__ definition */
 /* Copyright: (c) Julian Smart */
 /* Licence:   wxWindows Licence */
 /* include platform.h first to get __WIN32__ definition */

+

 #include "wx/platform.h"
 #include "wx/setup.h"
 #include "wx/deprecated/setup.h"
 
 #if !defined(wxUSE_PROLOGIO) || wxUSE_PROLOGIO
 
 #include "wx/platform.h"
 #include "wx/setup.h"
 #include "wx/deprecated/setup.h"
 
 #if !defined(wxUSE_PROLOGIO) || wxUSE_PROLOGIO
 

+#ifdef __VISUALC__
+    #pragma warning(push)
+    #pragma warning(disable:4244) /* warning C4244: '=' : conversion from 'A' to 'B', possible loss of data */
+#endif
+

 #if !defined(lint) && 0
 static char yysccsid[] = "@(#)yaccpar     1.7 (Berkeley) 09/09/90";
 #endif
 #if !defined(lint) && 0
 static char yysccsid[] = "@(#)yaccpar     1.7 (Berkeley) 09/09/90";
 #endif


@@ -260,7 +266,7 @@ void yyerror(char *s)
 #endif
 #endif
 #endif
 #endif
 #endif
 #endif

-   
+

 // #line 247 "y_tab.c"
 #define YYABORT goto yyabort
 #define YYACCEPT goto yyaccept
 // #line 247 "y_tab.c"
 #define YYABORT goto yyabort
 #define YYACCEPT goto yyaccept


@@ -539,4 +545,8 @@ yyaccept:
     return (0);
 }
 
     return (0);
 }
 

+#ifdef __VISUALC__
+    #pragma warning(pop)
+#endif
+

 #endif /* wxUSE_PROLOGIO */
 #endif /* wxUSE_PROLOGIO */

diff --git a/contrib/src/mmedia/g72x.cpp b/contrib/src/mmedia/g72x.cpp
index 2202cf8235c3282df201879e1f6cfc7848a5da65..97d3322c23bd3569065bc26f7d39ed641ceb615e 100644 (file)
--- a/contrib/src/mmedia/g72x.cpp
+++ b/contrib/src/mmedia/g72x.cpp
@@ -464,8 +464,10 @@ update(
     } else if (sr > -32768) {
         mag = -sr;
         state_ptr->sr[0] = base2(mag) - 0x400;
     } else if (sr > -32768) {
         mag = -sr;
         state_ptr->sr[0] = base2(mag) - 0x400;

-    } else
-        state_ptr->sr[0] = short (0xFC20);
+    } else {
+        const unsigned short c = 0xFC20;
+        state_ptr->sr[0] = short(c);
+    }

 
     /* DELAY A */
     state_ptr->pk[1] = state_ptr->pk[0];
 
     /* DELAY A */
     state_ptr->pk[1] = state_ptr->pk[0];