Difference for common/loader.c from version 1.49 to 1.49.2.1

version 1.49 version 1.49.2.1
Line 1
 
Line 1
   
 #line 3 "loader.c"  
   
 #define  YY_INT_ALIGNED short int  
   
 /* A lexical scanner generated by flex */  /* A lexical scanner generated by flex */
   
   /* Scanner skeleton version:
    * $Header: /cvsroot/crossfire/crossfire/common/loader.c,v 1.49.2.1 2003/10/02 06:40:52 mwedel Exp $
    */
   
 #define FLEX_SCANNER  #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2  #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5  #define YY_FLEX_MINOR_VERSION 5
 #define YY_FLEX_SUBMINOR_VERSION 31  
 #if YY_FLEX_SUBMINOR_VERSION > 0  
 #define FLEX_BETA  
 #endif  
   
 /* First, we deal with  platform-specific or compiler-specific issues. */  
   
 /* begin standard C headers. */  
 #include <stdio.h>  #include <stdio.h>
 #include <string.h>  #include <unistd.h>
 #include <errno.h>  
 #include <stdlib.h>  
 #include <stdint.h> /* May break IA64 test-noansi-r */  
   
 /* end standard C headers. */  
   
 /* flex integer type definitions */  
   
 #ifndef FLEXINT_H  
 #define FLEXINT_H  
   
 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */  
   
 #if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L  
 #include <inttypes.h>  
 typedef int8_t flex_int8_t;  
 typedef uint8_t flex_uint8_t;  
 typedef int16_t flex_int16_t;  
 typedef uint16_t flex_uint16_t;  
 typedef int32_t flex_int32_t;  
 typedef uint32_t flex_uint32_t;  
 #else  
 typedef signed char flex_int8_t;  
 typedef short int flex_int16_t;  
 typedef int flex_int32_t;  
 typedef unsigned char flex_uint8_t;   
 typedef unsigned short int flex_uint16_t;  
 typedef unsigned int flex_uint32_t;  
 #endif /* ! C99 */  
   
 /* Limits of integral types. */  /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
 #ifndef INT8_MIN  #ifdef c_plusplus
 #define INT8_MIN               (-128)  #ifndef __cplusplus
 #endif  #define __cplusplus
 #ifndef INT16_MIN  
 #define INT16_MIN              (-32767-1)  
 #endif  
 #ifndef INT32_MIN  
 #define INT32_MIN              (-2147483647-1)  
 #endif  
 #ifndef INT8_MAX  
 #define INT8_MAX               (127)  
 #endif  
 #ifndef INT16_MAX  
 #define INT16_MAX              (32767)  
 #endif  
 #ifndef INT32_MAX  
 #define INT32_MAX              (2147483647)  
 #endif  
 #ifndef UINT8_MAX  
 #define UINT8_MAX              (255U)  
 #endif  
 #ifndef UINT16_MAX  
 #define UINT16_MAX             (65535U)  
 #endif  #endif
 #ifndef UINT32_MAX  
 #define UINT32_MAX             (4294967295U)  
 #endif  #endif
   
 #endif /* ! FLEXINT_H */  
   
 #ifdef __cplusplus  #ifdef __cplusplus
   
   #include <stdlib.h>
   
   /* Use prototypes in function declarations. */
   #define YY_USE_PROTOS
   
 /* The "const" storage-class-modifier is valid. */  /* The "const" storage-class-modifier is valid. */
 #define YY_USE_CONST  #define YY_USE_CONST
   
Line 88
 
Line 34
   
 #if __STDC__  #if __STDC__
   
   #define YY_USE_PROTOS
 #define YY_USE_CONST  #define YY_USE_CONST
   
 #endif /* __STDC__ */  #endif /* __STDC__ */
 #endif /* ! __cplusplus */  #endif /* ! __cplusplus */
   
   #ifdef __TURBOC__
    #pragma warn -rch
    #pragma warn -use
   #include <io.h>
   #include <stdlib.h>
   #define YY_USE_CONST
   #define YY_USE_PROTOS
   #endif
   
 #ifdef YY_USE_CONST  #ifdef YY_USE_CONST
 #define yyconst const  #define yyconst const
 #else  #else
 #define yyconst  #define yyconst
 #endif  #endif
   
   
   #ifdef YY_USE_PROTOS
   #define YY_PROTO(proto) proto
   #else
   #define YY_PROTO(proto) ()
   #endif
   
 /* Returned upon end-of-file. */  /* Returned upon end-of-file. */
 #define YY_NULL 0  #define YY_NULL 0
   
Line 113
 
Line 76
  * but we do it the disgusting crufty way forced on us by the ()-less   * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.   * definition of BEGIN.
  */   */
 #define BEGIN (yy_start) = 1 + 2 *  #define BEGIN yy_start = 1 + 2 *
   
 /* Translate the current start state into a value that can be later handed  /* 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   * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.   * compatibility.
  */   */
 #define YY_START (((yy_start) - 1) / 2)  #define YY_START ((yy_start - 1) / 2)
 #define YYSTATE YY_START  #define YYSTATE YY_START
   
 /* Action number for EOF rule of a given start state. */  /* Action number for EOF rule of a given start state. */
Line 131
 
Line 94
 #define YY_END_OF_BUFFER_CHAR 0  #define YY_END_OF_BUFFER_CHAR 0
   
 /* Size of default input buffer. */  /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE  
 #define YY_BUF_SIZE 16384  #define YY_BUF_SIZE 16384
 #endif  
   
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE  
 #define YY_TYPEDEF_YY_BUFFER_STATE  
 typedef struct yy_buffer_state *YY_BUFFER_STATE;  typedef struct yy_buffer_state *YY_BUFFER_STATE;
 #endif  
   
 extern int yyleng;  extern int yyleng;
   
 extern FILE *yyin, *yyout;  extern FILE *yyin, *yyout;
   
 #define EOB_ACT_CONTINUE_SCAN 0  #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1  #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2  #define EOB_ACT_LAST_MATCH 2
   
     #define YY_LESS_LINENO(n)  /* The funky do-while in the following #define is used to turn the definition
    * int a single C statement (which needs a semi-colon terminator).  This
    * avoids problems with code like:
    *
    * if ( condition_holds )
    * yyless( 5 );
    * else
    * do_something_else();
    *
    * Prior to using the do-while the compiler would get upset at the
    * "else" because it interpreted the "if" statement as being all
    * done when it reached the ';' after the yyless() call.
    */
   
   /* Return all but the first 'n' matched characters back to the input stream. */
          
 /* Return all but the first "n" matched characters back to the input stream. */  
 #define yyless(n) \  #define yyless(n) \
  do \   do \
  { \   { \
  /* Undo effects of setting up yytext. */ \   /* Undo effects of setting up yytext. */ \
         int yyless_macro_arg = (n); \   *yy_cp = yy_hold_char; \
         YY_LESS_LINENO(yyless_macro_arg);\  
  *yy_cp = (yy_hold_char); \  
  YY_RESTORE_YY_MORE_OFFSET \   YY_RESTORE_YY_MORE_OFFSET \
  (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \   yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  YY_DO_BEFORE_ACTION; /* set up yytext again */ \   YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  } \   } \
  while ( 0 )   while ( 0 )
   
 #define unput(c) yyunput( c, (yytext_ptr)  )  #define unput(c) yyunput( c, yytext_ptr )
   
 /* The following is because we cannot portably get our hands on size_t  /* The following is because we cannot portably get our hands on size_t
  * (without autoconf's help, which isn't available because we want   * (without autoconf's help, which isn't available because we want
  * flex-generated scanners to compile on their own).   * flex-generated scanners to compile on their own).
  */   */
   
 #ifndef YY_TYPEDEF_YY_SIZE_T  
 #define YY_TYPEDEF_YY_SIZE_T  
 typedef unsigned int yy_size_t;  typedef unsigned int yy_size_t;
 #endif  
   
 #ifndef YY_STRUCT_YY_BUFFER_STATE  
 #define YY_STRUCT_YY_BUFFER_STATE  
 struct yy_buffer_state  struct yy_buffer_state
  {   {
  FILE *yy_input_file;   FILE *yy_input_file;
Line 214
 
Line 177
  */   */
  int yy_at_bol;   int yy_at_bol;
   
     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   /* Whether to try to fill the input buffer when we reach the
  * end of it.   * end of it.
  */   */
  int yy_fill_buffer;   int yy_fill_buffer;
   
  int yy_buffer_status;   int yy_buffer_status;
   
 #define YY_BUFFER_NEW 0  #define YY_BUFFER_NEW 0
 #define YY_BUFFER_NORMAL 1  #define YY_BUFFER_NORMAL 1
  /* When an EOF's been seen but there's still some text to process   /* When an EOF's been seen but there's still some text to process
Line 237
 
Line 196
  * just pointing yyin at a new input file.   * just pointing yyin at a new input file.
  */   */
 #define YY_BUFFER_EOF_PENDING 2  #define YY_BUFFER_EOF_PENDING 2
   
  };   };
 #endif /* !YY_STRUCT_YY_BUFFER_STATE */  
   
 /* Stack of input buffers. */  static YY_BUFFER_STATE yy_current_buffer = 0;
 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */  
 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */  
 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */  
   
 /* We provide macros for accessing buffer states in case in the  /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general   * future we want to put the buffer states in a more general
  * "scanner state".   * "scanner state".
  *  
  * Returns the top of the stack, or NULL.  
  */   */
 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \  #define YY_CURRENT_BUFFER yy_current_buffer
                           ? (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.  
  */  
 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]  
   
 /* yy_hold_char holds the character lost when yytext is formed. */  /* yy_hold_char holds the character lost when yytext is formed. */
 static char yy_hold_char;  static 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 */
   
   
 int yyleng;  int yyleng;
   
 /* Points to current character in buffer. */  /* Points to current character in buffer. */
Line 276
 
Line 225
  */   */
 static int yy_did_buffer_switch_on_eof;  static int yy_did_buffer_switch_on_eof;
   
 void yyrestart (FILE *input_file  );  void yyrestart YY_PROTO(( 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_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 void yy_delete_buffer (YY_BUFFER_STATE b  );  void yy_load_buffer_state YY_PROTO(( void ));
 void yy_flush_buffer (YY_BUFFER_STATE b  );  YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );  void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 void yypop_buffer_state (void );  void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
   void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 static void yyensure_buffer_stack (void );  #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 static void yy_load_buffer_state (void );  
 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );  YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
   YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )  YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
   
 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );  static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );  static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );  static void yy_flex_free YY_PROTO(( void * ));
   
 void *yyalloc (yy_size_t  );  
 void *yyrealloc (void *,yy_size_t  );  
 void yyfree (void *  );  
   
 #define yy_new_buffer yy_create_buffer  #define yy_new_buffer yy_create_buffer
   
 #define yy_set_interactive(is_interactive) \  #define yy_set_interactive(is_interactive) \
  { \   { \
  if ( ! YY_CURRENT_BUFFER ){ \   if ( ! yy_current_buffer ) \
         yyensure_buffer_stack (); \   yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  YY_CURRENT_BUFFER_LVALUE =    \   yy_current_buffer->yy_is_interactive = is_interactive; \
             yy_create_buffer(yyin,YY_BUF_SIZE ); \  
  } \  
  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \  
  }   }
   
 #define yy_set_bol(at_bol) \  #define yy_set_bol(at_bol) \
  { \   { \
  if ( ! YY_CURRENT_BUFFER ){\   if ( ! yy_current_buffer ) \
         yyensure_buffer_stack (); \   yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  YY_CURRENT_BUFFER_LVALUE =    \   yy_current_buffer->yy_at_bol = at_bol; \
             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)  #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
   
 /* Begin user sect3 */  
   
 #define yywrap(n) 1  #define yywrap() 1
 #define YY_SKIP_YYWRAP  #define YY_SKIP_YYWRAP
   
 typedef unsigned char YY_CHAR;  typedef unsigned char YY_CHAR;
   
 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;  FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
   
 typedef int yy_state_type;  typedef int yy_state_type;
   
 extern int yylineno;  
   
 int yylineno = 1;  
   
 extern char *yytext;  extern char *yytext;
 #define yytext_ptr yytext  #define yytext_ptr yytext
   
 static yy_state_type yy_get_previous_state (void );  static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );  static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 static int yy_get_next_buffer (void );  static int yy_get_next_buffer YY_PROTO(( void ));
 static void yy_fatal_error (yyconst char msg[]  );  static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
   
 /* Done after the current pattern has been matched and before the  /* Done after the current pattern has been matched and before the
  * corresponding action - sets up yytext.   * corresponding action - sets up yytext.
  */   */
 #define YY_DO_BEFORE_ACTION \  #define YY_DO_BEFORE_ACTION \
  (yytext_ptr) = yy_bp; \   yytext_ptr = yy_bp; \
  yyleng = (size_t) (yy_cp - yy_bp); \   yyleng = (int) (yy_cp - yy_bp); \
  (yy_hold_char) = *yy_cp; \   yy_hold_char = *yy_cp; \
  *yy_cp = '\0'; \   *yy_cp = '\0'; \
  (yy_c_buf_p) = yy_cp;   yy_c_buf_p = yy_cp;
   
 #define YY_NUM_RULES 262  #define YY_NUM_RULES 262
 #define YY_END_OF_BUFFER 263  #define YY_END_OF_BUFFER 263
 /* This struct is not used in this scanner,  static yyconst short int yy_accept[2341] =
    but its presence is necessary. */  
 struct yy_trans_info  
  {  
  flex_int32_t yy_verify;  
  flex_int32_t yy_nxt;  
  };  
 static yyconst flex_int16_t yy_accept[2341] =  
     {   0,      {   0,
       261,  261,    3,    3,    6,    6,    0,    0,  263,  261,        261,  261,    3,    3,    6,    6,    0,    0,  263,  261,
       259,  261,  261,  261,  261,  261,  261,  261,  261,  261,        259,  261,  261,  261,  261,  261,  261,  261,  261,  261,
Line 625
 
Line 548
       236,  236,  261,  250,  250,  258,  258,  251,  251,    0        236,  236,  261,  250,  250,  258,  258,  251,  251,    0
     } ;      } ;
   
 static yyconst flex_int32_t yy_ec[256] =  static yyconst int yy_ec[256] =
     {   0,      {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,          1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,          1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
Line 657
 
Line 580
         1,    1,    1,    1,    1          1,    1,    1,    1,    1
     } ;      } ;
   
 static yyconst flex_int32_t yy_meta[34] =  static yyconst int yy_meta[34] =
     {   0,      {   0,
         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,          1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,          1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
Line 665
 
Line 588
         1,    1,    1          1,    1,    1
     } ;      } ;
   
 static yyconst flex_int16_t yy_base[2603] =  static yyconst short int yy_base[2603] =
     {   0,      {   0,
         0,    6,   37,   38,   39,   43,   45,   50, 2631,    0,          0,    6,   37,   38,   39,   43,   45,   50, 2631,    0,
      2632, 2627,    0,   47,   40,   68,   53,   86,   59,   35,       2632, 2627,    0,   47,   40,   68,   53,   86,   59,   35,
Line 956
 
Line 879
      2130, 2131       2130, 2131
     } ;      } ;
   
 static yyconst flex_int16_t yy_def[2603] =  static yyconst short int yy_def[2603] =
     {   0,      {   0,
      2341, 2340, 2342, 2342, 2343, 2343, 2344, 2344, 2340, 2345,       2341, 2340, 2342, 2342, 2343, 2343, 2344, 2344, 2340, 2345,
      2340, 2346, 2345, 2345, 2345, 2345, 2345, 2345, 2345, 2345,       2340, 2346, 2345, 2345, 2345, 2345, 2345, 2345, 2345, 2345,
Line 1247
 
Line 1170
      2340, 2340       2340, 2340
     } ;      } ;
   
 static yyconst flex_int16_t yy_nxt[2666] =  static yyconst short int yy_nxt[2666] =
     {   0,      {   0,
      2340,   48,   11,   12,   49,   13,   10,   10,   11,   12,       2340,   48,   11,   12,   49,   13,   10,   10,   11,   12,
        10,   13,   10,   14,   15,   16,   17,   18,   19,   20,         10,   13,   10,   14,   15,   16,   17,   18,   19,   20,
Line 1544
 
Line 1467
      2340, 2340, 2340, 2340, 2340       2340, 2340, 2340, 2340, 2340
     } ;      } ;
   
 static yyconst flex_int16_t yy_chk[2666] =  static yyconst short int yy_chk[2666] =
     {   0,      {   0,
         0,   13,    1,    1,   13,    1,    2,    2,    2,    2,          0,   13,    1,    1,   13,    1,    2,    2,    2,    2,
         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,          2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
Line 1844
 
Line 1767
 static yy_state_type yy_last_accepting_state;  static yy_state_type yy_last_accepting_state;
 static char *yy_last_accepting_cpos;  static char *yy_last_accepting_cpos;
   
 extern int yy_flex_debug;  
 int yy_flex_debug = 0;  
   
 /* The intent behind this definition is that it'll catch  /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.   * any uses of REJECT which flex missed.
  */   */
Line 1856
 
Line 1776
 #define YY_RESTORE_YY_MORE_OFFSET  #define YY_RESTORE_YY_MORE_OFFSET
 char *yytext;  char *yytext;
 #line 1 "loader.l"  #line 1 "loader.l"
   #define INITIAL 0
 #line 2 "loader.l"  #line 2 "loader.l"
 /*  /*
  * static char *rcsid_object_c =   * static char *rcsid_object_c =
  *   "$Id: loader.c,v 1.49 2003/09/03 13:42:17 tchize Exp $";   *   "$Id: loader.c,v 1.49.2.1 2003/10/02 06:40:52 mwedel Exp $";
  */   */
   
 /*  /*
Line 2067
 
Line 1988
 }  }
   
   
   #define MESSAGE 1
   
   #define LORE 2
   
   #define SCRIPT 3
   
 /* Don't have to link with -lfl with this */  /* Don't have to link with -lfl with this */
 /* need yy_push_state, yy_pop_state */  /* need yy_push_state, yy_pop_state */
 #line 2076 "loader.c"  #define YY_STACK_USED 1
   #line 2001 "loader.c"
 #define INITIAL 0  
 #define MESSAGE 1  
 #define LORE 2  
 #define SCRIPT 3  
   
 #ifndef YY_NO_UNISTD_H  
 /* Special case for "unistd.h", since it is non-ANSI. We include it way  
  * down here because we want the user's section 1 to have been scanned first.  
  * The user has a chance to override it with an option.  
  */  
 #include <unistd.h>  
 #endif  
   
 #ifndef YY_EXTRA_TYPE  
 #define YY_EXTRA_TYPE void *  
 #endif  
   
 /* Macros after this point can all be overridden by user definitions in  /* Macros after this point can all be overridden by user definitions in
  * section 1.   * section 1.
Line 2097
 
Line 2005
   
 #ifndef YY_SKIP_YYWRAP  #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus  #ifdef __cplusplus
 extern "C" int yywrap (void );  extern "C" int yywrap YY_PROTO(( void ));
 #else  #else
 extern int yywrap (void );  extern int yywrap YY_PROTO(( void ));
 #endif  #endif
 #endif  #endif
   
     static void yyunput (int c,char *buf_ptr  );  #ifndef YY_NO_UNPUT
   static void yyunput YY_PROTO(( int c, char *buf_ptr ));
   #endif
          
 #ifndef yytext_ptr  #ifndef yytext_ptr
 static void yy_flex_strncpy (char *,yyconst char *,int );  static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 #endif  #endif
   
 #ifdef YY_NEED_STRLEN  #ifdef YY_NEED_STRLEN
 static int yy_flex_strlen (yyconst char * );  static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 #endif  #endif
   
 #ifndef YY_NO_INPUT  #ifndef YY_NO_INPUT
   
 #ifdef __cplusplus  #ifdef __cplusplus
 static int yyinput (void );  static int yyinput YY_PROTO(( void ));
 #else  #else
 static int input (void );  static int input YY_PROTO(( void ));
 #endif  #endif
   
 #endif  #endif
   
   #if YY_STACK_USED
         static int yy_start_stack_ptr = 0;          static int yy_start_stack_ptr = 0;
         static int yy_start_stack_depth = 0;          static int yy_start_stack_depth = 0;
         static int *yy_start_stack = 0;          static int *yy_start_stack = 0;
   #ifndef YY_NO_PUSH_STATE
   static void yy_push_state YY_PROTO(( int new_state ));
   #endif
   #ifndef YY_NO_POP_STATE
   static void yy_pop_state YY_PROTO(( void ));
   #endif
   #ifndef YY_NO_TOP_STATE
   static int yy_top_state YY_PROTO(( void ));
   #endif
          
     static void yy_push_state (int new_state );  #else
       #define YY_NO_PUSH_STATE 1
     static void yy_pop_state (void );  #define YY_NO_POP_STATE 1
   #define YY_NO_TOP_STATE 1
   #endif
          
     static int yy_top_state (void );  #ifdef YY_MALLOC_DECL
   YY_MALLOC_DECL
   #else
   #if __STDC__
   #ifndef __cplusplus
   #include <stdlib.h>
   #endif
   #else
   /* Just try to get by without declaring the routines.  This will fail
    * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
    * or sizeof(void*) != sizeof(int).
    */
   #endif
   #endif
          
 /* Amount of stuff to slurp up with each read. */  /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE  #ifndef YY_READ_BUF_SIZE
Line 2139
 
Line 2072
 #endif  #endif
   
 /* Copy whatever the last rule matched to the standard output. */  /* Copy whatever the last rule matched to the standard output. */
   
 #ifndef ECHO  #ifndef ECHO
 /* This used to be an fputs(), but since the string might contain NUL's,  /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().   * we now use fwrite().
Line 2151
 
Line 2085
  */   */
 #ifndef YY_INPUT  #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \  #define YY_INPUT(buf,result,max_size) \
  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \   if ( yy_current_buffer->yy_is_interactive ) \
  { \   { \
  int c = '*'; \   int c = '*', n; \
  size_t n; \  
  for ( n = 0; n < max_size && \   for ( n = 0; n < max_size && \
       (c = getc( yyin )) != EOF && c != '\n'; ++n ) \        (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  buf[n] = (char) c; \   buf[n] = (char) c; \
Line 2164
 
Line 2097
  YY_FATAL_ERROR( "input in flex scanner failed" ); \   YY_FATAL_ERROR( "input in flex scanner failed" ); \
  result = n; \   result = n; \
  } \   } \
  else \   else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
  { \     && ferror( yyin ) ) \
  errno=0; \   YY_FATAL_ERROR( "input in flex scanner failed" );
  while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \  
  { \  
  if( errno != EINTR) \  
  { \  
  YY_FATAL_ERROR( "input in flex scanner failed" ); \  
  break; \  
  } \  
  errno=0; \  
  clearerr(yyin); \  
  } \  
  }\  
 \  
   
 #endif  #endif
   
 /* No semi-colon after return; correct usage is to write "yyterminate();" -  /* No semi-colon after return; correct usage is to write "yyterminate();" -
Line 2200
 
Line 2120
 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )  #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 #endif  #endif
   
 /* end tables serialization structures and prototypes */  
   
 /* Default declaration of generated scanner - a define so the user can  /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.   * easily add parameters.
  */   */
 #ifndef YY_DECL  #ifndef YY_DECL
 #define YY_DECL_IS_OURS 1  #define YY_DECL int yylex YY_PROTO(( void ))
   #endif
 extern int yylex (void);  
   
 #define YY_DECL int yylex (void)  
 #endif /* !YY_DECL */  
   
 /* Code executed at the beginning of each rule, after yytext and yyleng  /* Code executed at the beginning of each rule, after yytext and yyleng
  * have been set up.   * have been set up.
Line 2227
 
Line 2141
   
 #define YY_RULE_SETUP \  #define YY_RULE_SETUP \
  if ( yyleng > 0 ) \   if ( yyleng > 0 ) \
  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \   yy_current_buffer->yy_at_bol = \
  (yytext[yyleng - 1] == '\n'); \   (yytext[yyleng - 1] == '\n'); \
  YY_USER_ACTION   YY_USER_ACTION
   
 /** The main scanner function which does all the work.  
  */  
 YY_DECL  YY_DECL
 {  {
  register yy_state_type yy_current_state;   register yy_state_type yy_current_state;
  register char *yy_cp, *yy_bp;   register char *yy_cp = NULL, *yy_bp = NULL;
  register int yy_act;   register int yy_act;
          
 #line 230 "loader.l"  #line 230 "loader.l"
Line 2250
 
Line 2162
   
   
   
 #line 2254 "loader.c"  #line 2166 "loader.c"
   
  if ( (yy_init) )   if ( yy_init )
  {   {
  (yy_init) = 0;   yy_init = 0;
   
 #ifdef YY_USER_INIT  #ifdef YY_USER_INIT
  YY_USER_INIT;   YY_USER_INIT;
 #endif  #endif
   
  if ( ! (yy_start) )   if ( ! yy_start )
  (yy_start) = 1; /* first start state */   yy_start = 1; /* first start state */
   
  if ( ! yyin )   if ( ! yyin )
  yyin = stdin;   yyin = stdin;
Line 2269
 
Line 2181
  if ( ! yyout )   if ( ! yyout )
  yyout = stdout;   yyout = stdout;
   
  if ( ! YY_CURRENT_BUFFER ) {   if ( ! yy_current_buffer )
  yyensure_buffer_stack ();   yy_current_buffer =
  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( );
  }   }
   
  while ( 1 ) /* loops until end-of-file is reached */   while ( 1 ) /* loops until end-of-file is reached */
  {   {
  yy_cp = (yy_c_buf_p);   yy_cp = yy_c_buf_p;
   
  /* Support of yytext. */   /* Support of yytext. */
  *yy_cp = (yy_hold_char);   *yy_cp = yy_hold_char;
   
  /* yy_bp points to the position in yy_ch_buf of the start of   /* yy_bp points to the position in yy_ch_buf of the start of
  * the current run.   * the current run.
  */   */
  yy_bp = yy_cp;   yy_bp = yy_cp;
   
  yy_current_state = (yy_start);   yy_current_state = yy_start;
  yy_current_state += YY_AT_BOL();   yy_current_state += YY_AT_BOL();
 yy_match:  yy_match:
  do   do
Line 2298
 
Line 2208
  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];   register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  if ( yy_accept[yy_current_state] )   if ( yy_accept[yy_current_state] )
  {   {
  (yy_last_accepting_state) = yy_current_state;   yy_last_accepting_state = yy_current_state;
  (yy_last_accepting_cpos) = yy_cp;   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 )
  {   {
Line 2316
 
Line 2226
  yy_act = yy_accept[yy_current_state];   yy_act = yy_accept[yy_current_state];
  if ( yy_act == 0 )   if ( yy_act == 0 )
  { /* have to back up */   { /* have to back up */
  yy_cp = (yy_last_accepting_cpos);   yy_cp = yy_last_accepting_cpos;
  yy_current_state = (yy_last_accepting_state);   yy_current_state = yy_last_accepting_state;
  yy_act = yy_accept[yy_current_state];   yy_act = yy_accept[yy_current_state];
  }   }
   
  YY_DO_BEFORE_ACTION;   YY_DO_BEFORE_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 )   switch ( yy_act )
  { /* beginning of action switch */   { /* beginning of action switch */
  case 0: /* must back up */   case 0: /* must back up */
  /* undo the effects of YY_DO_BEFORE_ACTION */   /* undo the effects of YY_DO_BEFORE_ACTION */
  *yy_cp = (yy_hold_char);   *yy_cp = yy_hold_char;
  yy_cp = (yy_last_accepting_cpos);   yy_cp = yy_last_accepting_cpos;
  yy_current_state = (yy_last_accepting_state);   yy_current_state = yy_last_accepting_state;
  goto yy_find_action;   goto yy_find_action;
   
 case 1:  case 1:
 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */  *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 (yy_c_buf_p) = yy_cp -= 1;  yy_c_buf_p = yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */  YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 240 "loader.l"  #line 240 "loader.l"
 { BEGIN( MESSAGE ); msgbuf[0]='\0'; }  { BEGIN( MESSAGE ); msgbuf[0]='\0'; }
  YY_BREAK   YY_BREAK
 case 2:  case 2:
 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */  *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 (yy_c_buf_p) = yy_cp -= 1;  yy_c_buf_p = yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */  YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 241 "loader.l"  #line 241 "loader.l"
Line 2364
 
Line 2276
 {strcat(msgbuf, yytext); strcat(msgbuf,"\n"); }  {strcat(msgbuf, yytext); strcat(msgbuf,"\n"); }
  YY_BREAK   YY_BREAK
 case 4:  case 4:
 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */  *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 (yy_c_buf_p) = yy_cp -= 1;  yy_c_buf_p = yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */  YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 252 "loader.l"  #line 252 "loader.l"
 { BEGIN( LORE ); lorebuf[0]='\0'; }  { BEGIN( LORE ); lorebuf[0]='\0'; }
  YY_BREAK   YY_BREAK
 case 5:  case 5:
 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */  *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 (yy_c_buf_p) = yy_cp -= 1;  yy_c_buf_p = yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */  YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 253 "loader.l"  #line 253 "loader.l"
Line 2447
 
Line 2359
 FREE_AND_COPY(op->slaying, yval());  FREE_AND_COPY(op->slaying, yval());
  YY_BREAK   YY_BREAK
 case 13:  case 13:
 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */  *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 (yy_c_buf_p) = yy_cp -= 1;  yy_c_buf_p = yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */  YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 295 "loader.l"  #line 295 "loader.l"
Line 2499
 
Line 2411
      }       }
  YY_BREAK   YY_BREAK
 case 17:  case 17:
 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */  *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 (yy_c_buf_p) = yy_cp -= 1;  yy_c_buf_p = yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */  YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 332 "loader.l"  #line 332 "loader.l"
Line 2511
 
Line 2423
      }       }
  YY_BREAK   YY_BREAK
 case 18:  case 18:
 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */  *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
 (yy_c_buf_p) = yy_cp -= 1;  yy_c_buf_p = yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */  YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 338 "loader.l"  #line 338 "loader.l"
Line 3989
 
Line 3901
      }       }
  YY_BREAK   YY_BREAK
 case 259:  case 259:
 /* rule 259 can match eol */  
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 885 "loader.l"  #line 885 "loader.l"
 {/* ignore empty lines, newlines we don't do above */}  {/* ignore empty lines, newlines we don't do above */}
  YY_BREAK   YY_BREAK
 case 260:  case 260:
 /* rule 260 can match eol */  
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 886 "loader.l"  #line 886 "loader.l"
 {}  {}
Line 4018
 
Line 3928
 #line 891 "loader.l"  #line 891 "loader.l"
 ECHO;  ECHO;
  YY_BREAK   YY_BREAK
 #line 4022 "loader.c"  #line 3932 "loader.c"
   
  case YY_END_OF_BUFFER:   case YY_END_OF_BUFFER:
  {   {
  /* Amount of text matched not including the EOB char. */   /* Amount of text matched not including the EOB char. */
  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;   int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
   
  /* Undo the effects of YY_DO_BEFORE_ACTION. */   /* Undo the effects of YY_DO_BEFORE_ACTION. */
  *yy_cp = (yy_hold_char);   *yy_cp = yy_hold_char;
  YY_RESTORE_YY_MORE_OFFSET   YY_RESTORE_YY_MORE_OFFSET
   
  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )   if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  {   {
  /* We're scanning a new file or input source.  It's   /* We're scanning a new file or input source.  It's
  * possible that this happened because the user   * possible that this happened because the user
  * just pointed yyin at a new source and called   * just pointed yyin at a new source and called
  * yylex().  If so, then we have to assure   * yylex().  If so, then we have to assure
  * consistency between YY_CURRENT_BUFFER and our   * consistency between yy_current_buffer and our
  * globals.  Here is the right place to do so, because   * globals.  Here is the right place to do so, because
  * this is the first action (other than possibly a   * this is the first action (other than possibly a
  * back-up) that will match for the new input source.   * back-up) that will match for the new input source.
  */   */
  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;   yy_n_chars = yy_current_buffer->yy_n_chars;
  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;   yy_current_buffer->yy_input_file = yyin;
  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;   yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  }   }
   
  /* Note that here we test for yy_c_buf_p "<=" to the position   /* Note that here we test for yy_c_buf_p "<=" to the position
Line 4052
 
Line 3962
  * end-of-buffer state).  Contrast this with the test   * end-of-buffer state).  Contrast this with the test
  * in input().   * in input().
  */   */
  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )   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_state_type yy_next_state;   yy_state_type yy_next_state;
   
  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;   yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
   
  yy_current_state = yy_get_previous_state(  );   yy_current_state = yy_get_previous_state(  );
   
Line 4071
 
Line 3981
   
  yy_next_state = yy_try_NUL_trans( yy_current_state );   yy_next_state = yy_try_NUL_trans( yy_current_state );
   
  yy_bp = (yytext_ptr) + YY_MORE_ADJ;   yy_bp = yytext_ptr + YY_MORE_ADJ;
   
  if ( yy_next_state )   if ( yy_next_state )
  {   {
  /* Consume the NUL. */   /* Consume the NUL. */
  yy_cp = ++(yy_c_buf_p);   yy_cp = ++yy_c_buf_p;
  yy_current_state = yy_next_state;   yy_current_state = yy_next_state;
  goto yy_match;   goto yy_match;
  }   }
   
  else   else
  {   {
  yy_cp = (yy_c_buf_p);   yy_cp = yy_c_buf_p;
  goto yy_find_action;   goto yy_find_action;
  }   }
  }   }
Line 4092
 
Line 4002
  {   {
  case EOB_ACT_END_OF_FILE:   case EOB_ACT_END_OF_FILE:
  {   {
  (yy_did_buffer_switch_on_eof) = 0;   yy_did_buffer_switch_on_eof = 0;
   
  if ( yywrap( ) )   if ( yywrap( ) )
  {   {
Line 4105
 
Line 4015
  * YY_NULL, it'll still work - another   * YY_NULL, it'll still work - another
  * YY_NULL will get returned.   * YY_NULL will get returned.
  */   */
  (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;   yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
   
  yy_act = YY_STATE_EOF(YY_START);   yy_act = YY_STATE_EOF(YY_START);
  goto do_action;   goto do_action;
Line 4113
 
Line 4023
   
  else   else
  {   {
  if ( ! (yy_did_buffer_switch_on_eof) )   if ( ! yy_did_buffer_switch_on_eof )
  YY_NEW_FILE;   YY_NEW_FILE;
  }   }
  break;   break;
  }   }
   
  case EOB_ACT_CONTINUE_SCAN:   case EOB_ACT_CONTINUE_SCAN:
  (yy_c_buf_p) =   yy_c_buf_p =
  (yytext_ptr) + yy_amount_of_matched_text;   yytext_ptr + yy_amount_of_matched_text;
   
  yy_current_state = yy_get_previous_state(  );   yy_current_state = yy_get_previous_state(  );
   
  yy_cp = (yy_c_buf_p);   yy_cp = yy_c_buf_p;
  yy_bp = (yytext_ptr) + YY_MORE_ADJ;   yy_bp = yytext_ptr + YY_MORE_ADJ;
  goto yy_match;   goto yy_match;
   
  case EOB_ACT_LAST_MATCH:   case EOB_ACT_LAST_MATCH:
  (yy_c_buf_p) =   yy_c_buf_p =
  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];   &yy_current_buffer->yy_ch_buf[yy_n_chars];
   
  yy_current_state = yy_get_previous_state(  );   yy_current_state = yy_get_previous_state(  );
   
  yy_cp = (yy_c_buf_p);   yy_cp = yy_c_buf_p;
  yy_bp = (yytext_ptr) + YY_MORE_ADJ;   yy_bp = yytext_ptr + YY_MORE_ADJ;
  goto yy_find_action;   goto yy_find_action;
  }   }
  break;   break;
Line 4149
 
Line 4059
  } /* end of scanning one token */   } /* end of scanning one token */
 } /* end of yylex */  } /* end of yylex */
   
   
 /* yy_get_next_buffer - try to read in a new buffer  /* yy_get_next_buffer - try to read in a new buffer
  *   *
  * Returns a code representing an action:   * Returns a code representing an action:
Line 4156
 
Line 4067
  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position   * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  * EOB_ACT_END_OF_FILE - end of file   * EOB_ACT_END_OF_FILE - end of file
  */   */
 static int yy_get_next_buffer (void)  
   static int yy_get_next_buffer()
 {  {
     register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;   register char *dest = yy_current_buffer->yy_ch_buf;
  register char *source = (yytext_ptr);   register char *source = yytext_ptr;
  register int number_to_move, i;   register int number_to_move, i;
  int ret_val;   int ret_val;
   
  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )   if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  YY_FATAL_ERROR(   YY_FATAL_ERROR(
  "fatal flex scanner internal error--end of buffer missed" );   "fatal flex scanner internal error--end of buffer missed" );
   
  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )   if ( yy_current_buffer->yy_fill_buffer == 0 )
  { /* Don't try to fill the buffer, so this is an EOF. */   { /* Don't try to fill the buffer, so this is an EOF. */
  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )   if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  {   {
  /* We matched a single character, the EOB, so   /* We matched a single character, the EOB, so
  * treat this as a final EOF.   * treat this as a final EOF.
Line 4189
 
Line 4101
  /* Try to read more data. */   /* Try to read more data. */
   
  /* First move last chars to start of buffer. */   /* First move last chars to start of buffer. */
  number_to_move = (int) ((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 )   for ( i = 0; i < number_to_move; ++i )
  *(dest++) = *(source++);   *(dest++) = *(source++);
   
  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )   if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  /* don't do the read, it's not guaranteed to return an EOF,   /* don't do the read, it's not guaranteed to return an EOF,
  * just force an EOF   * just force an EOF
  */   */
  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;   yy_current_buffer->yy_n_chars = yy_n_chars = 0;
   
  else   else
  {   {
  size_t num_to_read =   int num_to_read =
  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;   yy_current_buffer->yy_buf_size - number_to_move - 1;
   
  while ( num_to_read <= 0 )   while ( num_to_read <= 0 )
  { /* Not enough room in the buffer - grow it. */   { /* Not enough room in the buffer - grow it. */
   #ifdef YY_USES_REJECT
    YY_FATAL_ERROR(
   "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
   #else
   
  /* just a shorter name for the current buffer */   /* just a shorter name for the current buffer */
  YY_BUFFER_STATE b = YY_CURRENT_BUFFER;   YY_BUFFER_STATE b = yy_current_buffer;
   
  int yy_c_buf_p_offset =   int yy_c_buf_p_offset =
  (int) ((yy_c_buf_p) - b->yy_ch_buf);   (int) (yy_c_buf_p - b->yy_ch_buf);
   
  if ( b->yy_is_our_buffer )   if ( b->yy_is_our_buffer )
  {   {
Line 4225
 
Line 4141
   
  b->yy_ch_buf = (char *)   b->yy_ch_buf = (char *)
  /* Include room in for 2 EOB chars. */   /* Include room in for 2 EOB chars. */
  yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );   yy_flex_realloc( (void *) b->yy_ch_buf,
    b->yy_buf_size + 2 );
  }   }
  else   else
  /* Can't grow it, we don't own it. */   /* Can't grow it, we don't own it. */
Line 4235
 
Line 4152
  YY_FATAL_ERROR(   YY_FATAL_ERROR(
  "fatal error - scanner input buffer overflow" );   "fatal error - scanner input buffer overflow" );
   
  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];   yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
   
  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -   num_to_read = yy_current_buffer->yy_buf_size -
  number_to_move - 1;   number_to_move - 1;
   #endif
  }   }
   
  if ( num_to_read > YY_READ_BUF_SIZE )   if ( num_to_read > YY_READ_BUF_SIZE )
  num_to_read = YY_READ_BUF_SIZE;   num_to_read = YY_READ_BUF_SIZE;
   
  /* Read in more data. */   /* Read in more data. */
  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),   YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  (yy_n_chars), num_to_read );   yy_n_chars, num_to_read );
   
  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);   yy_current_buffer->yy_n_chars = yy_n_chars;
  }   }
   
  if ( (yy_n_chars) == 0 )   if ( yy_n_chars == 0 )
  {   {
  if ( number_to_move == YY_MORE_ADJ )   if ( number_to_move == YY_MORE_ADJ )
  {   {
Line 4263
 
Line 4180
  else   else
  {   {
  ret_val = EOB_ACT_LAST_MATCH;   ret_val = EOB_ACT_LAST_MATCH;
  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =   yy_current_buffer->yy_buffer_status =
  YY_BUFFER_EOF_PENDING;   YY_BUFFER_EOF_PENDING;
  }   }
  }   }
Line 4271
 
Line 4188
  else   else
  ret_val = EOB_ACT_CONTINUE_SCAN;   ret_val = EOB_ACT_CONTINUE_SCAN;
   
  (yy_n_chars) += number_to_move;   yy_n_chars += number_to_move;
  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;   yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;   yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
   
  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];   yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
   
  return ret_val;   return ret_val;
 }  }
   
   
 /* yy_get_previous_state - get the state just before the EOB char was reached */  /* yy_get_previous_state - get the state just before the EOB char was reached */
   
     static yy_state_type yy_get_previous_state (void)  static yy_state_type yy_get_previous_state()
 {  {
  register yy_state_type yy_current_state;   register yy_state_type yy_current_state;
  register char *yy_cp;   register char *yy_cp;
          
  yy_current_state = (yy_start);   yy_current_state = yy_start;
  yy_current_state += YY_AT_BOL();   yy_current_state += YY_AT_BOL();
   
  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )   for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  {   {
  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);   register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  if ( yy_accept[yy_current_state] )   if ( yy_accept[yy_current_state] )
  {   {
  (yy_last_accepting_state) = yy_current_state;   yy_last_accepting_state = yy_current_state;
  (yy_last_accepting_cpos) = yy_cp;   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 )
  {   {
Line 4310
 
Line 4228
  return yy_current_state;   return yy_current_state;
 }  }
   
   
 /* yy_try_NUL_trans - try to make a transition on the NUL character  /* yy_try_NUL_trans - try to make a transition on the NUL character
  *   *
  * synopsis   * synopsis
  * next_state = yy_try_NUL_trans( current_state );   * next_state = yy_try_NUL_trans( current_state );
  */   */
   
   #ifdef YY_USE_PROTOS
     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )      static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
   #else
   static yy_state_type yy_try_NUL_trans( yy_current_state )
   yy_state_type yy_current_state;
   #endif
 {  {
  register int yy_is_jam;   register int yy_is_jam;
     register char *yy_cp = (yy_c_buf_p);   register char *yy_cp = yy_c_buf_p;
   
  register YY_CHAR yy_c = 1;   register YY_CHAR yy_c = 1;
  if ( yy_accept[yy_current_state] )   if ( yy_accept[yy_current_state] )
  {   {
  (yy_last_accepting_state) = yy_current_state;   yy_last_accepting_state = yy_current_state;
  (yy_last_accepting_cpos) = yy_cp;   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 )
  {   {
Line 4338
 
Line 4263
  return yy_is_jam ? 0 : yy_current_state;   return yy_is_jam ? 0 : yy_current_state;
 }  }
   
   
   #ifndef YY_NO_UNPUT
   #ifdef YY_USE_PROTOS
     static void yyunput (int c, register char * yy_bp )      static void yyunput (int c, register char * yy_bp )
   #else
   static void yyunput( c, yy_bp )
   int c;
   register char *yy_bp;
   #endif
 {  {
  register char *yy_cp;   register char *yy_cp = yy_c_buf_p;
       
     yy_cp = (yy_c_buf_p);  
   
  /* undo effects of setting up yytext */   /* undo effects of setting up yytext */
  *yy_cp = (yy_hold_char);   *yy_cp = yy_hold_char;
   
  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )   if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  { /* need to shift things up to make room */   { /* need to shift things up to make room */
  /* +2 for EOB chars. */   /* +2 for EOB chars. */
  register int number_to_move = (yy_n_chars) + 2;   register int number_to_move = yy_n_chars + 2;
  register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[   register char *dest = &yy_current_buffer->yy_ch_buf[
  YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];   yy_current_buffer->yy_buf_size + 2];
  register char *source =   register char *source =
  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];   &yy_current_buffer->yy_ch_buf[number_to_move];
   
  while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )   while ( source > yy_current_buffer->yy_ch_buf )
  *--dest = *--source;   *--dest = *--source;
   
  yy_cp += (int) (dest - source);   yy_cp += (int) (dest - source);
  yy_bp += (int) (dest - source);   yy_bp += (int) (dest - source);
  YY_CURRENT_BUFFER_LVALUE->yy_n_chars =   yy_current_buffer->yy_n_chars =
  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;   yy_n_chars = yy_current_buffer->yy_buf_size;
   
  if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )   if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  YY_FATAL_ERROR( "flex scanner push-back overflow" );   YY_FATAL_ERROR( "flex scanner push-back overflow" );
  }   }
   
  *--yy_cp = (char) c;   *--yy_cp = (char) c;
   
  (yytext_ptr) = yy_bp;  
  (yy_hold_char) = *yy_cp;   yytext_ptr = yy_bp;
  (yy_c_buf_p) = yy_cp;   yy_hold_char = *yy_cp;
    yy_c_buf_p = yy_cp;
 }  }
   #endif /* ifndef YY_NO_UNPUT */
   
   
 #ifndef YY_NO_INPUT  #ifndef YY_NO_INPUT
 #ifdef __cplusplus  #ifdef __cplusplus
     static int yyinput (void)  static int yyinput()
 #else  #else
     static int input  (void)  static int input()
 #endif  #endif
   
 {  {
  int c;   int c;
          
  *(yy_c_buf_p) = (yy_hold_char);   *yy_c_buf_p = yy_hold_char;
   
  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )   if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  {   {
  /* yy_c_buf_p now points to the character we want to return.   /* yy_c_buf_p now points to the character we want to return.
  * If this occurs *before* the EOB characters, then it's a   * If this occurs *before* the EOB characters, then it's a
  * valid NUL; if not, then we've hit the end of the buffer.   * valid NUL; if not, then we've hit the end of the buffer.
  */   */
  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )   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   else
  { /* need more input */   { /* need more input */
  int offset = (yy_c_buf_p) - (yytext_ptr);   int offset = yy_c_buf_p - yytext_ptr;
  ++(yy_c_buf_p);   ++yy_c_buf_p;
   
  switch ( yy_get_next_buffer(  ) )   switch ( yy_get_next_buffer(  ) )
  {   {
Line 4418
 
Line 4351
  /* Reset buffer status. */   /* Reset buffer status. */
  yyrestart(yyin );   yyrestart(yyin );
   
  /*FALLTHROUGH*/   /* fall through */
   
  case EOB_ACT_END_OF_FILE:   case EOB_ACT_END_OF_FILE:
  {   {
  if ( yywrap( ) )   if ( yywrap( ) )
  return EOF;   return EOF;
   
  if ( ! (yy_did_buffer_switch_on_eof) )   if ( ! yy_did_buffer_switch_on_eof )
  YY_NEW_FILE;   YY_NEW_FILE;
 #ifdef __cplusplus  #ifdef __cplusplus
  return yyinput();   return yyinput();
Line 4435
 
Line 4368
  }   }
   
  case EOB_ACT_CONTINUE_SCAN:   case EOB_ACT_CONTINUE_SCAN:
  (yy_c_buf_p) = (yytext_ptr) + offset;   yy_c_buf_p = yytext_ptr + offset;
  break;   break;
  }   }
  }   }
  }   }
   
  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */   c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
  *(yy_c_buf_p) = '\0'; /* preserve yytext */   *yy_c_buf_p = '\0'; /* preserve yytext */
  (yy_hold_char) = *++(yy_c_buf_p);   yy_hold_char = *++yy_c_buf_p;
   
  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');   yy_current_buffer->yy_at_bol = (c == '\n');
   
  return c;   return c;
 }  }
 #endif /* ifndef YY_NO_INPUT */  #endif /* YY_NO_INPUT */
   
 /** Immediately switch to a different input stream.  #ifdef YY_USE_PROTOS
  * @param input_file A readable stream.  
  *   
  * @note This function does not reset the start condition to @c INITIAL .  
  */  
     void yyrestart  (FILE * input_file )      void yyrestart  (FILE * input_file )
   #else
   void yyrestart( input_file )
   FILE *input_file;
   #endif
 {  {
    if ( ! yy_current_buffer )
    yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
          
  if ( ! YY_CURRENT_BUFFER ){   yy_init_buffer( yy_current_buffer, input_file );
         yyensure_buffer_stack ();  
  YY_CURRENT_BUFFER_LVALUE =  
             yy_create_buffer(yyin,YY_BUF_SIZE );  
  }  
   
  yy_init_buffer(YY_CURRENT_BUFFER,input_file );  
  yy_load_buffer_state( );   yy_load_buffer_state( );
 }  }
   
 /** Switch to a different input buffer.  
  * @param new_buffer The new input buffer.  #ifdef YY_USE_PROTOS
  *   
  */  
     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )      void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
   #else
   void yy_switch_to_buffer( new_buffer )
   YY_BUFFER_STATE new_buffer;
   #endif
 {  {
        if ( yy_current_buffer == new_buffer )
  /* TODO. We should be able to replace this entire function body  
  * with  
  * yypop_buffer_state();  
  * yypush_buffer_state(new_buffer);  
      */  
  yyensure_buffer_stack ();  
  if ( YY_CURRENT_BUFFER == new_buffer )  
  return;   return;
   
  if ( YY_CURRENT_BUFFER )   if ( yy_current_buffer )
  {   {
  /* Flush out information for old buffer. */   /* Flush out information for old buffer. */
  *(yy_c_buf_p) = (yy_hold_char);   *yy_c_buf_p = yy_hold_char;
  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);   yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);   yy_current_buffer->yy_n_chars = yy_n_chars;
  }   }
   
  YY_CURRENT_BUFFER_LVALUE = new_buffer;   yy_current_buffer = new_buffer;
  yy_load_buffer_state( );   yy_load_buffer_state( );
   
  /* We don't actually know whether we did this switch during   /* We don't actually know whether we did this switch during
Line 4501
 
Line 4425
  * is looked at is after yywrap() is called, so it's safe   * is looked at is after yywrap() is called, so it's safe
  * to go ahead and always set it.   * to go ahead and always set it.
  */   */
  (yy_did_buffer_switch_on_eof) = 1;   yy_did_buffer_switch_on_eof = 1;
 }  }
   
 static void yy_load_buffer_state  (void)  
   #ifdef YY_USE_PROTOS
   void yy_load_buffer_state( void )
   #else
   void yy_load_buffer_state()
   #endif
 {  {
     (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;   yy_n_chars = yy_current_buffer->yy_n_chars;
  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;   yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;   yyin = yy_current_buffer->yy_input_file;
  (yy_hold_char) = *(yy_c_buf_p);   yy_hold_char = *yy_c_buf_p;
 }  }
   
 /** Allocate and initialize an input buffer state.  
  * @param file A readable stream.  #ifdef YY_USE_PROTOS
  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.  
  *   
  * @return the allocated buffer state.  
  */  
     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )      YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
   #else
   YY_BUFFER_STATE yy_create_buffer( file, size )
   FILE *file;
   int size;
   #endif
 {  {
  YY_BUFFER_STATE b;   YY_BUFFER_STATE b;
          
  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );   b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  if ( ! b )   if ( ! b )
  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );   YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
   
Line 4531
 
Line 4461
  /* yy_ch_buf has to be 2 characters longer than the size given because   /* yy_ch_buf has to be 2 characters longer than the size given because
  * we need to put in 2 end-of-buffer characters.   * we need to put in 2 end-of-buffer characters.
  */   */
  b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );   b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  if ( ! b->yy_ch_buf )   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()" );
   
Line 4542
 
Line 4472
  return b;   return b;
 }  }
   
 /** Destroy the buffer.  
  * @param b a buffer created with yy_create_buffer()  #ifdef YY_USE_PROTOS
  *   
  */  
     void yy_delete_buffer (YY_BUFFER_STATE  b )      void yy_delete_buffer (YY_BUFFER_STATE  b )
   #else
   void yy_delete_buffer( b )
   YY_BUFFER_STATE b;
   #endif
 {  {
       
  if ( ! b )   if ( ! b )
  return;   return;
   
  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */   if ( b == yy_current_buffer )
  YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;   yy_current_buffer = (YY_BUFFER_STATE) 0;
   
  if ( b->yy_is_our_buffer )   if ( b->yy_is_our_buffer )
  yyfree((void *) b->yy_ch_buf  );   yy_flex_free( (void *) b->yy_ch_buf );
   
  yyfree((void *) b  );   yy_flex_free( (void *) b );
 }  }
   
 #ifndef __cplusplus  
 extern int isatty (int );  
 #endif /* __cplusplus */  
          
 /* Initializes or reinitializes a buffer.  
  * This function is sometimes called more than once on the same buffer,  
  * such as during a yyrestart() or at EOF.  
  */  
     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )  
   
 {  #ifdef YY_USE_PROTOS
  int oerrno = errno;  void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
   #else
   void yy_init_buffer( b, file )
   YY_BUFFER_STATE b;
   FILE *file;
   #endif
   
          
    {
  yy_flush_buffer(b );   yy_flush_buffer(b );
   
  b->yy_input_file = file;   b->yy_input_file = file;
  b->yy_fill_buffer = 1;   b->yy_fill_buffer = 1;
   
     /* If b is the current buffer, then yy_init_buffer was _probably_  #if YY_ALWAYS_INTERACTIVE
      * called from yyrestart() or through yy_get_next_buffer.   b->yy_is_interactive = 1;
      * In that case, we don't want to reset the lineno or column.  #else
      */  #if YY_NEVER_INTERACTIVE
     if (b != YY_CURRENT_BUFFER){   b->yy_is_interactive = 0;
         b->yy_bs_lineno = 1;  #else
         b->yy_bs_column = 0;  
     }  
   
         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;          b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
       #endif
  errno = oerrno;  #endif
 }  }
   
 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.  
  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.  #ifdef YY_USE_PROTOS
  *   
  */  
     void yy_flush_buffer (YY_BUFFER_STATE  b )      void yy_flush_buffer (YY_BUFFER_STATE  b )
   #else
   void yy_flush_buffer( b )
   YY_BUFFER_STATE b;
   #endif
   
 {  {
     if ( ! b )      if ( ! b )
  return;   return;
Line 4616
 
Line 4546
  b->yy_at_bol = 1;   b->yy_at_bol = 1;
  b->yy_buffer_status = YY_BUFFER_NEW;   b->yy_buffer_status = YY_BUFFER_NEW;
   
  if ( b == YY_CURRENT_BUFFER )   if ( b == yy_current_buffer )
  yy_load_buffer_state( );  
 }  
   
 /** Pushes the new state onto the stack. The new state becomes  
  *  the current state. This function will allocate the stack  
  *  if necessary.  
  *  @param new_buffer The new state.  
  *    
  */  
 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )  
 {  
     if (new_buffer == NULL)  
  return;  
   
  yyensure_buffer_stack();  
   
  /* This block is copied from yy_switch_to_buffer. */  
  if ( YY_CURRENT_BUFFER )  
  {  
  /* Flush out information for old buffer. */  
  *(yy_c_buf_p) = (yy_hold_char);  
  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);  
  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);  
  }  
   
  /* Only push if top exists. Otherwise, replace top. */  
  if (YY_CURRENT_BUFFER)  
  (yy_buffer_stack_top)++;  
  YY_CURRENT_BUFFER_LVALUE = new_buffer;  
   
  /* copied from yy_switch_to_buffer. */  
  yy_load_buffer_state( );  
  (yy_did_buffer_switch_on_eof) = 1;  
 }  
   
 /** Removes and deletes the top of the stack, if present.  
  *  The next element becomes the new top.  
  *    
  */  
 void yypop_buffer_state (void)  
 {  
     if (!YY_CURRENT_BUFFER)  
  return;  
   
  yy_delete_buffer(YY_CURRENT_BUFFER );  
  YY_CURRENT_BUFFER_LVALUE = NULL;  
  if ((yy_buffer_stack_top) > 0)  
  --(yy_buffer_stack_top);  
   
  if (YY_CURRENT_BUFFER) {  
  yy_load_buffer_state( );   yy_load_buffer_state( );
  (yy_did_buffer_switch_on_eof) = 1;  
  }  
 }  
   
 /* Allocates the stack if it does not exist.  
  *  Guarantees space for at least one push.  
  */  
 static void yyensure_buffer_stack (void)  
 {  
  int num_to_alloc;  
       
  if (!(yy_buffer_stack)) {  
   
  /* First allocation is just for 2 elements, since we don't know if this  
  * scanner will even need a stack. We use 2 instead of 1 to avoid an  
  * immediate realloc on the next call.  
          */  
  num_to_alloc = 1;  
  (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc  
  (num_to_alloc * sizeof(struct yy_buffer_state*)  
  );  
    
  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;  
  }   }
   
  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){  
   
  /* Increase the buffer to prepare for a possible push. */  #ifndef YY_NO_SCAN_BUFFER
  int grow_size = 8 /* arbitrary grow size */;  #ifdef YY_USE_PROTOS
   
  num_to_alloc = (yy_buffer_stack_max) + grow_size;  
  (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc  
  ((yy_buffer_stack),  
  num_to_alloc * sizeof(struct yy_buffer_state*)  
  );  
   
  /* zero only the new slots.*/  
  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));  
  (yy_buffer_stack_max) = num_to_alloc;  
  }  
 }  
   
 /** Setup the input buffer state to scan directly from a user-specified character buffer.  
  * @param base the character buffer  
  * @param size the size in bytes of the character buffer  
  *   
  * @return the newly allocated buffer state object.   
  */  
 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )  YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
   #else
   YY_BUFFER_STATE yy_scan_buffer( base, size )
   char *base;
   yy_size_t size;
   #endif
 {  {
  YY_BUFFER_STATE b;   YY_BUFFER_STATE b;
          
Line 4730
 
Line 4568
  /* They forgot to leave room for the EOB's. */   /* They forgot to leave room for the EOB's. */
  return 0;   return 0;
   
  b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );   b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  if ( ! b )   if ( ! b )
  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );   YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
   
Line 4748
 
Line 4586
   
  return b;   return b;
 }  }
   #endif
   
 /** Setup the input buffer state to scan a string. The next call to yylex() will  
  * scan from a @e copy of @a str.  #ifndef YY_NO_SCAN_STRING
  * @param str a NUL-terminated string to scan  #ifdef YY_USE_PROTOS
  *   
  * @return the newly allocated buffer state object.  
  * @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 * yy_str )  YY_BUFFER_STATE yy_scan_string (yyconst char * yy_str )
   #else
   YY_BUFFER_STATE yy_scan_string( yy_str )
   yyconst char *yy_str;
   #endif
 {  {
    int len;
    for ( len = 0; yy_str[len]; ++len )
    ;
          
  return yy_scan_bytes(yy_str,strlen(yy_str) );   return yy_scan_bytes( yy_str, len );
 }  }
   #endif
   
 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will  
  * scan from a @e copy of @a bytes.  #ifndef YY_NO_SCAN_BYTES
  * @param bytes the byte buffer to scan  #ifdef YY_USE_PROTOS
  * @param len the number of bytes in the buffer pointed to by @a bytes.  
  *   
  * @return the newly allocated buffer state object.  
  */  
 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * bytes, int  len )  YY_BUFFER_STATE yy_scan_bytes  (yyconst char * bytes, int  len )
   #else
   YY_BUFFER_STATE yy_scan_bytes( bytes, len )
   yyconst char *bytes;
   int len;
   #endif
 {  {
  YY_BUFFER_STATE b;   YY_BUFFER_STATE b;
  char *buf;   char *buf;
Line 4779
 
Line 4622
          
  /* Get memory for full buffer, including space for trailing EOB's. */   /* Get memory for full buffer, including space for trailing EOB's. */
  n = len + 2;   n = len + 2;
  buf = (char *) yyalloc(n  );   buf = (char *) yy_flex_alloc( n );
  if ( ! buf )   if ( ! buf )
  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );   YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
   
Line 4799
 
Line 4642
   
  return b;   return b;
 }  }
   #endif
   
   
   #ifndef YY_NO_PUSH_STATE
   #ifdef YY_USE_PROTOS
     static void yy_push_state (int  new_state )      static void yy_push_state (int  new_state )
   #else
   static void yy_push_state( new_state )
   int new_state;
   #endif
 {  {
     if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )   if ( yy_start_stack_ptr >= yy_start_stack_depth )
  {   {
  yy_size_t new_size;   yy_size_t new_size;
   
  (yy_start_stack_depth) += YY_START_STACK_INCR;   yy_start_stack_depth += YY_START_STACK_INCR;
  new_size = (yy_start_stack_depth) * sizeof( int );   new_size = yy_start_stack_depth * sizeof( int );
   
  if ( ! (yy_start_stack) )   if ( ! yy_start_stack )
  (yy_start_stack) = (int *) yyalloc(new_size  );   yy_start_stack = (int *) yy_flex_alloc( new_size );
   
  else   else
  (yy_start_stack) = (int *) yyrealloc((void *) (yy_start_stack),new_size  );   yy_start_stack = (int *) yy_flex_realloc(
    (void *) yy_start_stack, new_size );
   
  if ( ! (yy_start_stack) )   if ( ! yy_start_stack )
  YY_FATAL_ERROR(   YY_FATAL_ERROR(
  "out of memory expanding start-condition stack" );   "out of memory expanding start-condition stack" );
  }   }
   
  (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;   yy_start_stack[yy_start_stack_ptr++] = YY_START;
   
  BEGIN(new_state);   BEGIN(new_state);
 }  }
   #endif
   
   
     static void yy_pop_state  (void)  #ifndef YY_NO_POP_STATE
   static void yy_pop_state()
 {  {
     if ( --(yy_start_stack_ptr) < 0 )   if ( --yy_start_stack_ptr < 0 )
  YY_FATAL_ERROR( "start-condition stack underflow" );   YY_FATAL_ERROR( "start-condition stack underflow" );
   
  BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);   BEGIN(yy_start_stack[yy_start_stack_ptr]);
 }  }
   #endif
   
     static int yy_top_state  (void)  
   #ifndef YY_NO_TOP_STATE
   static int yy_top_state()
 {  {
     return (yy_start_stack)[(yy_start_stack_ptr) - 1];   return yy_start_stack[yy_start_stack_ptr - 1];
 }  }
   #endif
   
 #ifndef YY_EXIT_FAILURE  #ifndef YY_EXIT_FAILURE
 #define YY_EXIT_FAILURE 2  #define YY_EXIT_FAILURE 2
 #endif  #endif
   
 static void yy_fatal_error (yyconst char* msg )  #ifdef YY_USE_PROTOS
   static void yy_fatal_error( yyconst char msg[] )
   #else
   static void yy_fatal_error( msg )
   char msg[];
   #endif
 {  {
     (void) fprintf( stderr, "%s\n", msg );      (void) fprintf( stderr, "%s\n", msg );
  exit( YY_EXIT_FAILURE );   exit( YY_EXIT_FAILURE );
 }  }
   
   
   
 /* Redefine yyless() so it works in section 3 code. */  /* Redefine yyless() so it works in section 3 code. */
   
 #undef yyless  #undef yyless
Line 4855
 
Line 4721
  do \   do \
  { \   { \
  /* Undo effects of setting up yytext. */ \   /* Undo effects of setting up yytext. */ \
         int yyless_macro_arg = (n); \   yytext[yyleng] = yy_hold_char; \
         YY_LESS_LINENO(yyless_macro_arg);\   yy_c_buf_p = yytext + n; \
  yytext[yyleng] = (yy_hold_char); \   yy_hold_char = *yy_c_buf_p; \
  (yy_c_buf_p) = yytext + yyless_macro_arg; \   *yy_c_buf_p = '\0'; \
  (yy_hold_char) = *(yy_c_buf_p); \   yyleng = n; \
  *(yy_c_buf_p) = '\0'; \  
  yyleng = yyless_macro_arg; \  
  } \   } \
  while ( 0 )   while ( 0 )
   
 /* Accessor  methods (get/set functions) to struct members. */  
   
 /** Get the current line number.  
  *   
  */  
 int yyget_lineno  (void)  
 {  
           
     return yylineno;  
 }  
   
 /** Get the input stream.  
  *   
  */  
 FILE *yyget_in  (void)  
 {  
         return yyin;  
 }  
   
 /** Get the output stream.  
  *   
  */  
 FILE *yyget_out  (void)  
 {  
         return yyout;  
 }  
   
 /** Get the length of the current token.  
  *   
  */  
 int yyget_leng  (void)  
 {  
         return yyleng;  
 }  
   
 /** Get the current token.  /* Internal utility routines. */
  *   
  */  
   
 char *yyget_text  (void)  
 {  
         return yytext;  
 }  
   
 /** Set the current line number.  
  * @param line_number  
  *   
  */  
 void yyset_lineno (int  line_number )  
 {  
       
     yylineno = line_number;  
 }  
   
 /** Set the input stream. This does not discard the current  
  * input buffer.  
  * @param in_str A readable stream.  
  *   
  * @see yy_switch_to_buffer  
  */  
 void yyset_in (FILE *  in_str )  
 {  
         yyin = in_str ;  
 }  
   
 void yyset_out (FILE *  out_str )  
 {  
         yyout = out_str ;  
 }  
   
 int yyget_debug  (void)  
 {  
         return yy_flex_debug;  
 }  
   
 void yyset_debug (int  bdebug )  
 {  
         yy_flex_debug = bdebug ;  
 }  
   
 /* yylex_destroy is for both reentrant and non-reentrant scanners. */  
 int yylex_destroy  (void)  
 {  
       
     /* Pop the buffer stack, destroying each element. */  
  while(YY_CURRENT_BUFFER){  
  yy_delete_buffer(YY_CURRENT_BUFFER  );  
  YY_CURRENT_BUFFER_LVALUE = NULL;  
  yypop_buffer_state();  
  }  
   
  /* Destroy the stack itself. */  
  yyfree((yy_buffer_stack) );  
  (yy_buffer_stack) = NULL;  
   
     /* Destroy the start condition stack. */  
         yyfree((yy_start_stack)  );  
         (yy_start_stack) = NULL;  
   
     return 0;  
 }  
   
 /*  
  * Internal utility routines.  
  */  
   
 #ifndef yytext_ptr  #ifndef yytext_ptr
   #ifdef YY_USE_PROTOS
 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )  static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
   #else
   static void yy_flex_strncpy( s1, s2, n )
   char *s1;
   yyconst char *s2;
   int n;
   #endif
 {  {
  register int i;   register int i;
     for ( i = 0; i < n; ++i )      for ( i = 0; i < n; ++i )
Line 4981
 
Line 4749
 #endif  #endif
   
 #ifdef YY_NEED_STRLEN  #ifdef YY_NEED_STRLEN
   #ifdef YY_USE_PROTOS
 static int yy_flex_strlen (yyconst char * s )  static int yy_flex_strlen (yyconst char * s )
   #else
   static int yy_flex_strlen( s )
   yyconst char *s;
   #endif
 {  {
  register int n;   register int n;
     for ( n = 0; s[n]; ++n )      for ( n = 0; s[n]; ++n )
Line 4991
 
Line 4764
 }  }
 #endif  #endif
   
 void *yyalloc (yy_size_t  size )  
   #ifdef YY_USE_PROTOS
   static void *yy_flex_alloc( yy_size_t size )
   #else
   static void *yy_flex_alloc( size )
   yy_size_t size;
   #endif
 {  {
  return (void *) malloc( size );   return (void *) malloc( size );
 }  }
   
 void *yyrealloc  (void * ptr, yy_size_t  size )  #ifdef YY_USE_PROTOS
   static void *yy_flex_realloc( void *ptr, yy_size_t size )
   #else
   static void *yy_flex_realloc( ptr, size )
   void *ptr;
   yy_size_t size;
   #endif
 {  {
  /* The cast to (char *) in the following accommodates both   /* The cast to (char *) in the following accommodates both
  * implementations that use char* generic pointers, and those   * implementations that use char* generic pointers, and those
Line 5008
 
Line 4793
  return (void *) realloc( (char *) ptr, size );   return (void *) realloc( (char *) ptr, size );
 }  }
   
 void yyfree (void * ptr )  #ifdef YY_USE_PROTOS
   static void yy_flex_free( void *ptr )
   #else
   static void yy_flex_free( ptr )
   void *ptr;
   #endif
 {  {
  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */   free( ptr );
 }  }
   
 #define YYTABLES_NAME "yytables"  #if YY_MAIN
   int main()
 #undef YY_NEW_FILE   {
 #undef YY_FLUSH_BUFFER   yylex();
 #undef yy_set_bol   return 0;
 #undef yy_new_buffer   }
 #undef yy_set_interactive  
 #undef yytext_ptr  
 #undef YY_DO_BEFORE_ACTION  
   
 #ifdef YY_DECL_IS_OURS  
 #undef YY_DECL_IS_OURS  
 #undef YY_DECL  
 #endif  #endif
 #line 891 "loader.l"  #line 891 "loader.l"
   
   
   
   
 int yyerror(char *s)  int yyerror(char *s)
 {  {
   LOG(llevError, "%s: %s\n", s, yytext);    LOG(llevError, "%s: %s\n", s, yytext);
Line 5409
 
Line 5191
     FAST_SAVE_LONG(fastbuf,"grace ",op->stats.grace,6);      FAST_SAVE_LONG(fastbuf,"grace ",op->stats.grace,6);
   if(op->stats.maxgrace!=op2->stats.maxgrace)    if(op->stats.maxgrace!=op2->stats.maxgrace)
     FAST_SAVE_LONG(fastbuf,"maxgrace ",op->stats.maxgrace,9);      FAST_SAVE_LONG(fastbuf,"maxgrace ",op->stats.maxgrace,9);
   if(op->stats.exp!=op2->stats.exp)    if(op->stats.exp!=op2->stats.exp) {
     FAST_SAVE_LONG(fastbuf,"exp ",op->stats.exp,4);      sprintf(buf2,"%lld\n", op->stats.exp);
       ADD_STRINGLINE_ENTRY(fastbuf,"exp ", buf2, 4);
     }
   
   if(op->expmul!=op2->expmul)    if(op->expmul!=op2->expmul)
     FAST_SAVE_DOUBLE(fastbuf,"expmul ",op->expmul,7);      FAST_SAVE_DOUBLE(fastbuf,"expmul ",op->expmul,7);
   if(op->stats.food!=op2->stats.food)    if(op->stats.food!=op2->stats.food)
Line 5681
 
Line 5466
   
   
   
   

Legend:
line(s) removed in v.1.49 
line(s) changed
 line(s) added in v.1.49.2.1
File made using version 1.98 of cvs2html by leaf at 2011-07-21 17:11