Difference for common/loader.c from version 1.66 to 1.67

version 1.66 version 1.67
Line 1
 
Line 1
 #line 2 "loader.c"  
 /* A lexical scanner generated by flex */  
   
 /* Scanner skeleton version:  #line 3 "loader.c"
  * $Header: /cvsroot/crossfire/crossfire/common/loader.c,v 1.66 2005/03/13 15:48:17 ryo_saeba Exp $  
  */  #define  YY_INT_ALIGNED short int
   
   /* A lexical scanner generated by flex */
   
 #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 <errno.h>
   #include <stdlib.h>
   
   /* end standard C headers. */
   
 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */  /* flex integer type definitions */
 #ifdef c_plusplus  
 #ifndef __cplusplus  #ifndef FLEXINT_H
 #define __cplusplus  #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. */
   #ifndef INT8_MIN
   #define INT8_MIN               (-128)
   #endif
   #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>  
 #include <unistd.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 35
 
Line 87
   
 #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 77
 
Line 112
  * 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 95
 
Line 130
 #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
   
 /* The funky do-while in the following #define is used to turn the definition      #define YY_LESS_LINENO(n)
  * 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. */ \
  *yy_cp = yy_hold_char; \          int yyless_macro_arg = (n); \
           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 + n - YY_MORE_ADJ; \   (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - 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).
  */   */
 typedef unsigned int yy_size_t;  
   
   #ifndef YY_TYPEDEF_YY_SIZE_T
   #define YY_TYPEDEF_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 178
 
Line 213
  */   */
  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 197
 
Line 236
  * 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 */
   
 static YY_BUFFER_STATE yy_current_buffer = 0;  /* Stack of input buffers. */
   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_current_buffer  #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
                             ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                             : NULL)
   
   /* Same as previous macro, but useful when we know that the buffer stack is not
    * NULL or when we need an lvalue. For internal use only.
    */
   #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 226
 
Line 275
  */   */
 static int yy_did_buffer_switch_on_eof;  static int yy_did_buffer_switch_on_eof;
   
 void yyrestart YY_PROTO(( FILE *input_file ));  void yyrestart (FILE *input_file  );
   void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));  YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
 void yy_load_buffer_state YY_PROTO(( void ));  void yy_delete_buffer (YY_BUFFER_STATE b  );
 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));  void yy_flush_buffer (YY_BUFFER_STATE b  );
 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));  void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));  void yypop_buffer_state (void );
 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));  
 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )  static void yyensure_buffer_stack (void );
   static void yy_load_buffer_state (void );
 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));  static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));  
 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));  #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
   
 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));  YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));  YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
 static void yy_flex_free YY_PROTO(( void * ));  YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
   
   void *yyalloc (yy_size_t  );
   void *yyrealloc (void *,yy_size_t  );
   void yyfree (void *  );
   
 #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 ){ \
  yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \          yyensure_buffer_stack (); \
  yy_current_buffer->yy_is_interactive = is_interactive; \   YY_CURRENT_BUFFER_LVALUE =    \
               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 ){\
  yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \          yyensure_buffer_stack (); \
  yy_current_buffer->yy_at_bol = at_bol; \   YY_CURRENT_BUFFER_LVALUE =    \
               yy_create_buffer(yyin,YY_BUF_SIZE ); \
    } \
    YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
  }   }
   
 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)  #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
   
   /* Begin user sect3 */
   
 #define yywrap() 1  #define yywrap(n) 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 YY_PROTO(( void ));  static yy_state_type yy_get_previous_state (void );
 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));  static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
 static int yy_get_next_buffer YY_PROTO(( void ));  static int yy_get_next_buffer (void );
 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));  static void yy_fatal_error (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 = (int) (yy_cp - yy_bp); \   yyleng = (size_t) (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 271  #define YY_NUM_RULES 271
 #define YY_END_OF_BUFFER 272  #define YY_END_OF_BUFFER 272
 static yyconst short int yy_accept[2437] =  /* This struct is not used in this scanner,
      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[2437] =
     {   0,      {   0,
       270,  270,    3,    3,    6,    6,    0,    0,  272,  270,        270,  270,    3,    3,    6,    6,    0,    0,  272,  270,
       268,  270,  270,  270,  270,  270,  270,  270,  270,  270,        268,  270,  270,  270,  270,  270,  270,  270,  270,  270,
Line 560
 
Line 635
       171,  267,  267,  260,  260,    0        171,  267,  267,  260,  260,    0
     } ;      } ;
   
 static yyconst int yy_ec[256] =  static yyconst flex_int32_t 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 592
 
Line 667
         1,    1,    1,    1,    1          1,    1,    1,    1,    1
     } ;      } ;
   
 static yyconst int yy_meta[34] =  static yyconst flex_int32_t 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 600
 
Line 675
         1,    1,    1          1,    1,    1
     } ;      } ;
   
 static yyconst short int yy_base[2712] =  static yyconst flex_int16_t yy_base[2712] =
     {   0,      {   0,
         0,    6,   37,   38,   39,   43,   45,   50, 2740,    0,          0,    6,   37,   38,   39,   43,   45,   50, 2740,    0,
      2741, 2736,    0,   47,   40,   68,   53,   86,   63,   35,       2741, 2736,    0,   47,   40,   68,   53,   86,   63,   35,
Line 903
 
Line 978
      2240       2240
     } ;      } ;
   
 static yyconst short int yy_def[2712] =  static yyconst flex_int16_t yy_def[2712] =
     {   0,      {   0,
      2437, 2436, 2438, 2438, 2439, 2439, 2440, 2440, 2436, 2441,       2437, 2436, 2438, 2438, 2439, 2439, 2440, 2440, 2436, 2441,
      2436, 2442, 2441, 2441, 2441, 2441, 2441, 2441, 2441, 2441,       2436, 2442, 2441, 2441, 2441, 2441, 2441, 2441, 2441, 2441,
Line 1206
 
Line 1281
      2436       2436
     } ;      } ;
   
 static yyconst short int yy_nxt[2775] =  static yyconst flex_int16_t yy_nxt[2775] =
     {   0,      {   0,
      2436,   48,   11,   12,   49,   13,   10,   10,   11,   12,       2436,   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 1515
 
Line 1590
      2436, 2436, 2436, 2436       2436, 2436, 2436, 2436
     } ;      } ;
   
 static yyconst short int yy_chk[2775] =  static yyconst flex_int16_t yy_chk[2775] =
     {   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 1827
 
Line 1902
 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 1836
 
Line 1914
 #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.66 2005/03/13 15:48:17 ryo_saeba Exp $";   *   "$Id: loader.c,v 1.67 2005/07/15 17:25:00 gros Exp $";
  */   */
   
 /*  /*
Line 2307
 
Line 2384
 }  }
   
   
 #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 */
 #define YY_STACK_USED 1  #line 2393 "loader.c"
 #line 2320 "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 2324
 
Line 2414
   
 #ifndef YY_SKIP_YYWRAP  #ifndef YY_SKIP_YYWRAP
 #ifdef __cplusplus  #ifdef __cplusplus
 extern "C" int yywrap YY_PROTO(( void ));  extern "C" int yywrap (void );
 #else  #else
 extern int yywrap YY_PROTO(( void ));  extern int yywrap (void );
 #endif  #endif
 #endif  #endif
   
 #ifndef YY_NO_UNPUT      static void yyunput (int c,char *buf_ptr  );
 static void yyunput YY_PROTO(( int c, char *buf_ptr ));  
 #endif  
   
 #ifndef yytext_ptr  #ifndef yytext_ptr
 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));  static void yy_flex_strncpy (char *,yyconst char *,int );
 #endif  #endif
   
 #ifdef YY_NEED_STRLEN  #ifdef YY_NEED_STRLEN
 static int yy_flex_strlen YY_PROTO(( yyconst char * ));  static int yy_flex_strlen (yyconst char * );
 #endif  #endif
   
 #ifndef YY_NO_INPUT  #ifndef YY_NO_INPUT
   
 #ifdef __cplusplus  #ifdef __cplusplus
 static int yyinput YY_PROTO(( void ));  static int yyinput (void );
 #else  #else
 static int input YY_PROTO(( void ));  static int input (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  
   
 #else      static void yy_push_state (int new_state );
 #define YY_NO_PUSH_STATE 1  
 #define YY_NO_POP_STATE 1  
 #define YY_NO_TOP_STATE 1  
 #endif  
   
 #ifdef YY_MALLOC_DECL      static void yy_pop_state (void );
 YY_MALLOC_DECL     
 #else      static int yy_top_state (void );
 #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 2391
 
Line 2456
 #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 2404
 
Line 2468
  */   */
 #ifndef YY_INPUT  #ifndef YY_INPUT
 #define YY_INPUT(buf,result,max_size) \  #define YY_INPUT(buf,result,max_size) \
  if ( yy_current_buffer->yy_is_interactive ) \   if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
  { \   { \
  int c = '*', n; \   int c = '*'; \
    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 2416
 
Line 2481
  YY_FATAL_ERROR( "input in flex scanner failed" ); \   YY_FATAL_ERROR( "input in flex scanner failed" ); \
  result = n; \   result = n; \
  } \   } \
  else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \   else \
    && ferror( yyin ) ) \   { \
  YY_FATAL_ERROR( "input in flex scanner failed" );   errno=0; \
    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 2439
 
Line 2517
 #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 int yylex YY_PROTO(( void ))  #define YY_DECL_IS_OURS 1
 #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 2460
 
Line 2544
   
 #define YY_RULE_SETUP \  #define YY_RULE_SETUP \
  if ( yyleng > 0 ) \   if ( yyleng > 0 ) \
  yy_current_buffer->yy_at_bol = \   YY_CURRENT_BUFFER_LVALUE->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;
Line 2481
 
Line 2567
   
   
   
 #line 2485 "loader.c"  #line 2571 "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 2500
 
Line 2586
  if ( ! yyout )   if ( ! yyout )
  yyout = stdout;   yyout = stdout;
   
  if ( ! yy_current_buffer )   if ( ! YY_CURRENT_BUFFER ) {
  yy_current_buffer =   yyensure_buffer_stack ();
    YY_CURRENT_BUFFER_LVALUE =
  yy_create_buffer( yyin, YY_BUF_SIZE );   yy_create_buffer( yyin, YY_BUF_SIZE );
    }
   
  yy_load_buffer_state();   yy_load_buffer_state();
  }   }
   
  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 2527
 
Line 2615
  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 2545
 
Line 2633
  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 499 "loader.l"  #line 499 "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 500 "loader.l"  #line 500 "loader.l"
Line 2595
 
Line 2681
 {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 511 "loader.l"  #line 511 "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 512 "loader.l"  #line 512 "loader.l"
Line 2683
 
Line 2769
 FREE_AND_COPY(op->slaying, yval());  FREE_AND_COPY(op->slaying, yval());
  YY_BREAK   YY_BREAK
 case 14:  case 14:
 *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 555 "loader.l"  #line 555 "loader.l"
Line 2754
 
Line 2840
      }       }
  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 611 "loader.l"  #line 611 "loader.l"
Line 2766
 
Line 2852
      }       }
  YY_BREAK   YY_BREAK
 case 19:  case 19:
 *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 617 "loader.l"  #line 617 "loader.l"
Line 4284
 
Line 4370
      }       }
  YY_BREAK   YY_BREAK
 case 268:  case 268:
   /* rule 268 can match eol */
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 1172 "loader.l"  #line 1172 "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 269:  case 269:
   /* rule 269 can match eol */
 YY_RULE_SETUP  YY_RULE_SETUP
 #line 1173 "loader.l"  #line 1173 "loader.l"
 {}  {}
Line 4311
 
Line 4399
 #line 1178 "loader.l"  #line 1178 "loader.l"
 ECHO;  ECHO;
  YY_BREAK   YY_BREAK
 #line 4315 "loader.c"  #line 4403 "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->yy_buffer_status == YY_BUFFER_NEW )   if ( YY_CURRENT_BUFFER_LVALUE->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->yy_n_chars;   (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
  yy_current_buffer->yy_input_file = yyin;   YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
  yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;   YY_CURRENT_BUFFER_LVALUE->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 4345
 
Line 4433
  * 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->yy_ch_buf[yy_n_chars] )   if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->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 4364
 
Line 4452
   
  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 4385
 
Line 4473
  {   {
  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 4398
 
Line 4486
  * 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 4406
 
Line 4494
   
  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->yy_ch_buf[yy_n_chars];   &YY_CURRENT_BUFFER_LVALUE->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 4442
 
Line 4530
  } /* 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 4450
 
Line 4537
  * 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->yy_ch_buf;      register char *dest = YY_CURRENT_BUFFER_LVALUE->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->yy_ch_buf[yy_n_chars + 1] )   if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->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->yy_fill_buffer == 0 )   if ( YY_CURRENT_BUFFER_LVALUE->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 4484
 
Line 4570
  /* 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->yy_buffer_status == YY_BUFFER_EOF_PENDING )   if ( YY_CURRENT_BUFFER_LVALUE->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->yy_n_chars = yy_n_chars = 0;   YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
   
  else   else
  {   {
  int num_to_read =   size_t num_to_read =
  yy_current_buffer->yy_buf_size - number_to_move - 1;   YY_CURRENT_BUFFER_LVALUE->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 4524
 
Line 4606
   
  b->yy_ch_buf = (char *)   b->yy_ch_buf = (char *)
  /* Include room in for 2 EOB chars. */   /* Include room in for 2 EOB chars. */
  yy_flex_realloc( (void *) b->yy_ch_buf,   yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
  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 4535
 
Line 4616
  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->yy_buf_size -   num_to_read = YY_CURRENT_BUFFER_LVALUE->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->yy_ch_buf[number_to_move]),   YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
  yy_n_chars, num_to_read );   (yy_n_chars), num_to_read );
   
  yy_current_buffer->yy_n_chars = yy_n_chars;   YY_CURRENT_BUFFER_LVALUE->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 4563
 
Line 4644
  else   else
  {   {
  ret_val = EOB_ACT_LAST_MATCH;   ret_val = EOB_ACT_LAST_MATCH;
  yy_current_buffer->yy_buffer_status =   YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
  YY_BUFFER_EOF_PENDING;   YY_BUFFER_EOF_PENDING;
  }   }
  }   }
Line 4571
 
Line 4652
  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->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
  yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;   YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
   
  yytext_ptr = &yy_current_buffer->yy_ch_buf[0];   (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->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()      static yy_state_type yy_get_previous_state (void)
  {   {
  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 4611
 
Line 4691
  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 4646
 
Line 4719
  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 = yy_c_buf_p;   register char *yy_cp;
      
       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->yy_ch_buf + 2 )   if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->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->yy_ch_buf[   register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
  yy_current_buffer->yy_buf_size + 2];   YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
  register char *source =   register char *source =
  &yy_current_buffer->yy_ch_buf[number_to_move];   &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
   
  while ( source > yy_current_buffer->yy_ch_buf )   while ( source > YY_CURRENT_BUFFER_LVALUE->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->yy_n_chars =   YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
  yy_n_chars = yy_current_buffer->yy_buf_size;   (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
   
  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )   if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->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;
  yytext_ptr = yy_bp;   (yy_hold_char) = *yy_cp;
  yy_hold_char = *yy_cp;   (yy_c_buf_p) = yy_cp;
  yy_c_buf_p = yy_cp;  
  }   }
 #endif /* ifndef YY_NO_UNPUT */  
   
   
   #ifndef YY_NO_INPUT
 #ifdef __cplusplus  #ifdef __cplusplus
 static int yyinput()      static int yyinput (void)
 #else  #else
 static int input()      static int input  (void)
 #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->yy_ch_buf[yy_n_chars] )   if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->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 4733
 
Line 4799
  /* Reset buffer status. */   /* Reset buffer status. */
  yyrestart( yyin );   yyrestart( yyin );
   
  /* fall through */   /*FALLTHROUGH*/
   
  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 4750
 
Line 4816
  }   }
   
  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->yy_at_bol = (c == '\n');   YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
   
  return c;   return c;
  }   }
   #endif /* ifndef 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 );  
   
  yy_init_buffer( yy_current_buffer, input_file );   if ( ! YY_CURRENT_BUFFER ){
  yy_load_buffer_state();          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( );
   }
   
 #ifdef YY_USE_PROTOS  /** Switch to a different input buffer.
    * @param new_buffer The new input buffer.
    *
    */
 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->yy_buf_pos = yy_c_buf_p;   YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
  yy_current_buffer->yy_n_chars = yy_n_chars;   YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
  }   }
   
  yy_current_buffer = new_buffer;   YY_CURRENT_BUFFER_LVALUE = new_buffer;
  yy_load_buffer_state();   yy_load_buffer_state();
   
  /* We don't actually know whether we did this switch during   /* We don't actually know whether we did this switch during
Line 4807
 
Line 4882
  * 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->yy_n_chars;      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
  yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;   (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
  yyin = yy_current_buffer->yy_input_file;   yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
  yy_hold_char = *yy_c_buf_p;   (yy_hold_char) = *(yy_c_buf_p);
  }   }
   
   /** Allocate and initialize an input buffer state.
 #ifdef YY_USE_PROTOS   * @param file A readable stream.
    * @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) yy_flex_alloc( sizeof( struct yy_buffer_state ) );   b = (YY_BUFFER_STATE) yyalloc(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 4843
 
Line 4912
  /* 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 *) yy_flex_alloc( b->yy_buf_size + 2 );   b->yy_ch_buf = (char *) yyalloc(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 4854
 
Line 4923
  return b;   return b;
  }   }
   
   /** Destroy the buffer.
 #ifdef YY_USE_PROTOS   * @param b a buffer created with yy_create_buffer()
    *
    */
 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 )   if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
  yy_current_buffer = (YY_BUFFER_STATE) 0;   YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
   
  if ( b->yy_is_our_buffer )   if ( b->yy_is_our_buffer )
  yy_flex_free( (void *) b->yy_ch_buf );   yyfree((void *) b->yy_ch_buf  );
   
  yy_flex_free( (void *) b );   yyfree((void *) b  );
  }   }
   
   #ifndef __cplusplus
   extern int isatty (int );
   #endif /* __cplusplus */
   
 #ifndef YY_ALWAYS_INTERACTIVE  /* Initializes or reinitializes a buffer.
 #ifndef YY_NEVER_INTERACTIVE   * This function is sometimes called more than once on the same buffer,
 extern int isatty YY_PROTO(( int ));   * such as during a yyrestart() or at EOF.
 #endif   */
 #endif      static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
   
 #ifdef YY_USE_PROTOS  
 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )  
 #else  
 void yy_init_buffer( b, file )  
 YY_BUFFER_STATE b;  
 FILE *file;  
 #endif  
   
   
  {   {
    int oerrno = errno;
      
  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 YY_ALWAYS_INTERACTIVE      /* If b is the current buffer, then yy_init_buffer was _probably_
  b->yy_is_interactive = 1;       * called from yyrestart() or through yy_get_next_buffer.
 #else       * In that case, we don't want to reset the lineno or column.
 #if YY_NEVER_INTERACTIVE       */
  b->yy_is_interactive = 0;      if (b != YY_CURRENT_BUFFER){
 #else          b->yy_bs_lineno = 1;
  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;          b->yy_bs_column = 0;
 #endif  
 #endif  
  }   }
   
           b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
   
 #ifdef YY_USE_PROTOS   errno = oerrno;
 void yy_flush_buffer( YY_BUFFER_STATE b )  }
 #else  
 void yy_flush_buffer( b )  
 YY_BUFFER_STATE b;  
 #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.
    *
    */
       void yy_flush_buffer (YY_BUFFER_STATE  b )
  {   {
  if ( ! b )   if ( ! b )
  return;   return;
Line 4933
 
Line 4997
  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;
   
 #ifndef YY_NO_SCAN_BUFFER   if (!(yy_buffer_stack)) {
 #ifdef YY_USE_PROTOS  
    /* 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. */
    int grow_size = 8 /* arbitrary grow size */;
   
    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 4955
 
Line 5111
  /* 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) yy_flex_alloc( sizeof( struct yy_buffer_state ) );   b = (YY_BUFFER_STATE) yyalloc(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 4973
 
Line 5129
   
  return b;   return b;
  }   }
 #endif  
   
   /** Setup the input buffer state to scan a string. The next call to yylex() will
 #ifndef YY_NO_SCAN_STRING   * scan from a @e copy of @a str.
 #ifdef YY_USE_PROTOS   * @param str a NUL-terminated string to scan
    *
    * @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, len );   return yy_scan_bytes(yy_str,strlen(yy_str) );
  }   }
 #endif  
   
   
 #ifndef YY_NO_SCAN_BYTES  /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
 #ifdef YY_USE_PROTOS   * scan from a @e copy of @a bytes.
    * @param bytes the byte buffer to scan
    * @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 5009
 
Line 5160
   
  /* 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 *) yy_flex_alloc( n );   buf = (char *) yyalloc(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 5029
 
Line 5180
   
  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 *) yy_flex_alloc( new_size );   (yy_start_stack) = (int *) yyalloc(new_size  );
   
  else   else
  yy_start_stack = (int *) yy_flex_realloc(   (yy_start_stack) = (int *) yyrealloc((void *) (yy_start_stack),new_size  );
  (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  
   
   
 #ifndef YY_NO_POP_STATE      static void yy_pop_state  (void)
 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  
   
   
 #ifndef YY_NO_TOP_STATE      static int yy_top_state  (void)
 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
   
 #ifdef YY_USE_PROTOS  static void yy_fatal_error (yyconst char* msg )
 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 5108
 
Line 5236
  do \   do \
  { \   { \
  /* Undo effects of setting up yytext. */ \   /* Undo effects of setting up yytext. */ \
  yytext[yyleng] = yy_hold_char; \          int yyless_macro_arg = (n); \
  yy_c_buf_p = yytext + n; \          YY_LESS_LINENO(yyless_macro_arg);\
  yy_hold_char = *yy_c_buf_p; \   yytext[yyleng] = (yy_hold_char); \
  *yy_c_buf_p = '\0'; \   (yy_c_buf_p) = yytext + yyless_macro_arg; \
  yyleng = n; \   (yy_hold_char) = *(yy_c_buf_p); \
    *(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.
    *
    */
   
   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. */  /*
    * 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 5136
 
Line 5362
 #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 5151
 
Line 5372
  }   }
 #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 );
  }   }
   
 #ifdef YY_USE_PROTOS  void *yyrealloc  (void * ptr, yy_size_t  size )
 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 5180
 
Line 5389
  return (void *) realloc( (char *) ptr, size );   return (void *) realloc( (char *) ptr, size );
  }   }
   
 #ifdef YY_USE_PROTOS  void yyfree (void * ptr )
 static void yy_flex_free( void *ptr )  
 #else  
 static void yy_flex_free( ptr )  
 void *ptr;  
 #endif  
  {   {
  free( ptr );   free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
  }   }
   
 #if YY_MAIN  #define YYTABLES_NAME "yytables"
 int main()  
  {  #undef YY_NEW_FILE
  yylex();  #undef YY_FLUSH_BUFFER
  return 0;  #undef yy_set_bol
  }  #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 1178 "loader.l"  #line 1178 "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 5889
 
Line 6101
   
   
   
   

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