/[svn]/hopm/branches/1.1.x/src/config-lexer.c
ViewVC logotype

Diff of /hopm/branches/1.1.x/src/config-lexer.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 7827 by michael, Sat Oct 1 20:59:15 2016 UTC revision 7828 by michael, Wed Nov 2 17:17:39 2016 UTC
# Line 1  Line 1 
1    
2  #line 3 "config-lexer.c"  #line 2 "config-lexer.c"
3    
4  #define  YY_INT_ALIGNED short int  #define  YY_INT_ALIGNED short int
5    
# Line 8  Line 8 
8  #define FLEX_SCANNER  #define FLEX_SCANNER
9  #define YY_FLEX_MAJOR_VERSION 2  #define YY_FLEX_MAJOR_VERSION 2
10  #define YY_FLEX_MINOR_VERSION 6  #define YY_FLEX_MINOR_VERSION 6
11  #define YY_FLEX_SUBMINOR_VERSION 1  #define YY_FLEX_SUBMINOR_VERSION 2
12  #if YY_FLEX_SUBMINOR_VERSION > 0  #if YY_FLEX_SUBMINOR_VERSION > 0
13  #define FLEX_BETA  #define FLEX_BETA
14  #endif  #endif
# Line 99  typedef unsigned int flex_uint32_t; Line 99  typedef unsigned int flex_uint32_t;
99  /* Returned upon end-of-file. */  /* Returned upon end-of-file. */
100  #define YY_NULL 0  #define YY_NULL 0
101    
102  /* Promotes a possibly negative, possibly signed char to an unsigned  /* Promotes a possibly negative, possibly signed char to an
103   * integer for use as an array index.  If the signed char is negative,   *   integer in range [0..255] for use as an array index.
  * we want to instead treat it as an 8-bit unsigned char, hence the  
  * double cast.  
104   */   */
105  #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)  #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
106    
107  /* Enter a start condition.  This macro really ought to take a parameter,  /* Enter a start condition.  This macro really ought to take a parameter,
108   * 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
109   * definition of BEGIN.   * definition of BEGIN.
110   */   */
111  #define BEGIN (yy_start) = 1 + 2 *  #define BEGIN (yy_start) = 1 + 2 *
   
112  /* 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
113   * 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
114   * compatibility.   * compatibility.
115   */   */
116  #define YY_START (((yy_start) - 1) / 2)  #define YY_START (((yy_start) - 1) / 2)
117  #define YYSTATE YY_START  #define YYSTATE YY_START
   
118  /* Action number for EOF rule of a given start state. */  /* Action number for EOF rule of a given start state. */
119  #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)  #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
   
120  /* Special action meaning "start processing a new file". */  /* Special action meaning "start processing a new file". */
121  #define YY_NEW_FILE yyrestart(yyin  )  #define YY_NEW_FILE yyrestart(yyin  )
   
122  #define YY_END_OF_BUFFER_CHAR 0  #define YY_END_OF_BUFFER_CHAR 0
123    
124  /* Size of default input buffer. */  /* Size of default input buffer. */
# Line 161  extern FILE *yyin, *yyout; Line 155  extern FILE *yyin, *yyout;
155  #define EOB_ACT_CONTINUE_SCAN 0  #define EOB_ACT_CONTINUE_SCAN 0
156  #define EOB_ACT_END_OF_FILE 1  #define EOB_ACT_END_OF_FILE 1
157  #define EOB_ACT_LAST_MATCH 2  #define EOB_ACT_LAST_MATCH 2
158        
159      #define YY_LESS_LINENO(n)      #define YY_LESS_LINENO(n)
160      #define YY_LINENO_REWIND_TO(ptr)      #define YY_LINENO_REWIND_TO(ptr)
161            
# Line 178  extern FILE *yyin, *yyout; Line 172  extern FILE *yyin, *yyout;
172                  YY_DO_BEFORE_ACTION; /* set up yytext again */ \                  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
173                  } \                  } \
174          while ( 0 )          while ( 0 )
   
175  #define unput(c) yyunput( c, (yytext_ptr)  )  #define unput(c) yyunput( c, (yytext_ptr)  )
176    
177  #ifndef YY_STRUCT_YY_BUFFER_STATE  #ifndef YY_STRUCT_YY_BUFFER_STATE
# Line 260  static YY_BUFFER_STATE * yy_buffer_stack Line 253  static YY_BUFFER_STATE * yy_buffer_stack
253  #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \  #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
254                            ? (yy_buffer_stack)[(yy_buffer_stack_top)] \                            ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
255                            : NULL)                            : NULL)
   
256  /* Same as previous macro, but useful when we know that the buffer stack is not  /* Same as previous macro, but useful when we know that the buffer stack is not
257   * NULL or when we need an lvalue. For internal use only.   * NULL or when we need an lvalue. For internal use only.
258   */   */
# Line 281  static int yy_start = 0;       /* start state Line 273  static int yy_start = 0;       /* start state
273   */   */
274  static int yy_did_buffer_switch_on_eof;  static int yy_did_buffer_switch_on_eof;
275    
276  void yyrestart (FILE *input_file  );  void yyrestart ( FILE *input_file  );
277  void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );  void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer  );
278  YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );  YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size  );
279  void yy_delete_buffer (YY_BUFFER_STATE b  );  void yy_delete_buffer ( YY_BUFFER_STATE b  );
280  void yy_flush_buffer (YY_BUFFER_STATE b  );  void yy_flush_buffer ( YY_BUFFER_STATE b  );
281  void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );  void yypush_buffer_state ( YY_BUFFER_STATE new_buffer  );
282  void yypop_buffer_state (void );  void yypop_buffer_state ( void );
283    
284  static void yyensure_buffer_stack (void );  static void yyensure_buffer_stack ( void );
285  static void yy_load_buffer_state (void );  static void yy_load_buffer_state ( void );
286  static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );  static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file  );
   
287  #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )  #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
288    
289  YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );  YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size  );
290  YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );  YY_BUFFER_STATE yy_scan_string ( const char *yy_str  );
291  YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );  YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len  );
292    
293  void *yyalloc (yy_size_t  );  void *yyalloc ( yy_size_t  );
294  void *yyrealloc (void *,yy_size_t  );  void *yyrealloc ( void *, yy_size_t  );
295  void yyfree (void *  );  void yyfree ( void *  );
296    
297  #define yy_new_buffer yy_create_buffer  #define yy_new_buffer yy_create_buffer
   
298  #define yy_set_interactive(is_interactive) \  #define yy_set_interactive(is_interactive) \
299          { \          { \
300          if ( ! YY_CURRENT_BUFFER ){ \          if ( ! YY_CURRENT_BUFFER ){ \
# Line 314  void yyfree (void *  ); Line 304  void yyfree (void *  );
304          } \          } \
305          YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \          YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
306          }          }
   
307  #define yy_set_bol(at_bol) \  #define yy_set_bol(at_bol) \
308          { \          { \
309          if ( ! YY_CURRENT_BUFFER ){\          if ( ! YY_CURRENT_BUFFER ){\
# Line 324  void yyfree (void *  ); Line 313  void yyfree (void *  );
313          } \          } \
314          YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \          YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
315          }          }
   
316  #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)  #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
317    
318  /* Begin user sect3 */  /* Begin user sect3 */
319    
320  #define yywrap() (/*CONSTCOND*/1)  #define yywrap() (/*CONSTCOND*/1)
321  #define YY_SKIP_YYWRAP  #define YY_SKIP_YYWRAP
322    typedef flex_uint8_t YY_CHAR;
 typedef unsigned char YY_CHAR;  
323    
324  FILE *yyin = NULL, *yyout = NULL;  FILE *yyin = NULL, *yyout = NULL;
325    
326  typedef int yy_state_type;  typedef int yy_state_type;
327    
328  extern int yylineno;  extern int yylineno;
   
329  int yylineno = 1;  int yylineno = 1;
330    
331  extern char *yytext;  extern char *yytext;
# Line 348  extern char *yytext; Line 334  extern char *yytext;
334  #endif  #endif
335  #define yytext_ptr yytext  #define yytext_ptr yytext
336    
337  static yy_state_type yy_get_previous_state (void );  static yy_state_type yy_get_previous_state ( void );
338  static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );  static yy_state_type yy_try_NUL_trans ( yy_state_type current_state  );
339  static int yy_get_next_buffer (void );  static int yy_get_next_buffer ( void );
340  static void yynoreturn yy_fatal_error (yyconst char* msg  );  static void yynoreturn yy_fatal_error ( const char* msg  );
341    
342  /* Done after the current pattern has been matched and before the  /* Done after the current pattern has been matched and before the
343   * corresponding action - sets up yytext.   * corresponding action - sets up yytext.
# Line 363  static void yynoreturn yy_fatal_error (y Line 349  static void yynoreturn yy_fatal_error (y
349          (yy_hold_char) = *yy_cp; \          (yy_hold_char) = *yy_cp; \
350          *yy_cp = '\0'; \          *yy_cp = '\0'; \
351          (yy_c_buf_p) = yy_cp;          (yy_c_buf_p) = yy_cp;
   
352  #define YY_NUM_RULES 104  #define YY_NUM_RULES 104
353  #define YY_END_OF_BUFFER 105  #define YY_END_OF_BUFFER 105
354  /* This struct is not used in this scanner,  /* This struct is not used in this scanner,
# Line 373  struct yy_trans_info Line 358  struct yy_trans_info
358          flex_int32_t yy_verify;          flex_int32_t yy_verify;
359          flex_int32_t yy_nxt;          flex_int32_t yy_nxt;
360          };          };
361  static yyconst flex_int16_t yy_accept[450] =  static const flex_int16_t yy_accept[450] =
362      {   0,      {   0,
363          7,    7,    0,    0,  105,  103,    7,    6,  103,    8,          7,    7,    0,    0,  105,  103,    7,    6,  103,    8,
364        103,  103,    9,  103,  103,  103,  103,  103,  103,  103,        103,  103,    9,  103,  103,  103,  103,  103,  103,  103,
# Line 426  static yyconst flex_int16_t yy_accept[45 Line 411  static yyconst flex_int16_t yy_accept[45
411          0,   15,    0,   34,    0,    0,   48,   16,    0          0,   15,    0,   34,    0,    0,   48,   16,    0
412      } ;      } ;
413    
414  static yyconst YY_CHAR yy_ec[256] =  static const YY_CHAR yy_ec[256] =
415      {   0,      {   0,
416          1,    1,    1,    1,    1,    1,    1,    1,    2,    3,          1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
417          1,    1,    1,    1,    1,    1,    1,    1,    1,    1,          1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
# Line 458  static yyconst YY_CHAR yy_ec[256] = Line 443  static yyconst YY_CHAR yy_ec[256] =
443          1,    1,    1,    1,    1          1,    1,    1,    1,    1
444      } ;      } ;
445    
446  static yyconst YY_CHAR yy_meta[65] =  static const YY_CHAR yy_meta[65] =
447      {   0,      {   0,
448          1,    1,    2,    1,    1,    1,    1,    1,    1,    1,          1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
449          1,    1,    1,    1,    1,    1,    1,    1,    1,    1,          1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
# Line 469  static yyconst YY_CHAR yy_meta[65] = Line 454  static yyconst YY_CHAR yy_meta[65] =
454          1,    1,    1,    1          1,    1,    1,    1
455      } ;      } ;
456    
457  static yyconst flex_uint16_t yy_base[456] =  static const flex_int16_t yy_base[456] =
458      {   0,      {   0,
459          0,    0,   62,   63,  881,  888,  878,    0,   67,    0,          0,    0,   62,   63,  881,  888,  878,    0,   67,    0,
460         45,   66,   66,   38,   64,   58,   66,   45,   69,   55,         45,   66,   66,   38,   64,   58,   66,   45,   69,   55,
# Line 523  static yyconst flex_uint16_t yy_base[456 Line 508  static yyconst flex_uint16_t yy_base[456
508         97,  885,   94,   90,   83         97,  885,   94,   90,   83
509      } ;      } ;
510    
511  static yyconst flex_int16_t yy_def[456] =  static const flex_int16_t yy_def[456] =
512      {   0,      {   0,
513        449,    1,  450,  450,  449,  449,  449,  451,  452,  453,        449,    1,  450,  450,  449,  449,  449,  451,  452,  453,
514        449,  449,  449,  449,  449,  449,  449,  449,  449,  449,        449,  449,  449,  449,  449,  449,  449,  449,  449,  449,
# Line 577  static yyconst flex_int16_t yy_def[456] Line 562  static yyconst flex_int16_t yy_def[456]
562        449,  449,  449,  449,  449        449,  449,  449,  449,  449
563      } ;      } ;
564    
565  static yyconst flex_uint16_t yy_nxt[953] =  static const flex_int16_t yy_nxt[953] =
566      {   0,      {   0,
567          6,    7,    8,    9,   10,    6,   11,   12,   13,   13,          6,    7,    8,    9,   10,    6,   11,   12,   13,   13,
568         13,    6,    6,   14,   15,   16,   17,   18,   19,    6,         13,    6,    6,   14,   15,   16,   17,   18,   19,    6,
# Line 686  static yyconst flex_uint16_t yy_nxt[953] Line 671  static yyconst flex_uint16_t yy_nxt[953]
671        449,  449        449,  449
672      } ;      } ;
673    
674  static yyconst flex_int16_t yy_chk[953] =  static const flex_int16_t yy_chk[953] =
675      {   0,      {   0,
676          1,    1,    1,    1,    1,    1,    1,    1,    1,    1,          1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
677          1,    1,    1,    1,    1,    1,    1,    1,    1,    1,          1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
# Line 881  conf_yy_fatal_error(const char *msg) Line 866  conf_yy_fatal_error(const char *msg)
866  {  {
867    return 0;    return 0;
868  }  }
869  #line 885 "config-lexer.c"  #line 869 "config-lexer.c"
870    #line 870 "config-lexer.c"
871    
872  #define INITIAL 0  #define INITIAL 0
873  #define IN_COMMENT 1  #define IN_COMMENT 1
# Line 898  conf_yy_fatal_error(const char *msg) Line 884  conf_yy_fatal_error(const char *msg)
884  #define YY_EXTRA_TYPE void *  #define YY_EXTRA_TYPE void *
885  #endif  #endif
886    
887  static int yy_init_globals (void );  static int yy_init_globals ( void );
888    
889  /* Accessor methods to globals.  /* Accessor methods to globals.
890     These are made visible to non-reentrant scanners for convenience. */     These are made visible to non-reentrant scanners for convenience. */
891    
892  int yylex_destroy (void );  int yylex_destroy ( void );
893    
894  int yyget_debug (void );  int yyget_debug ( void );
895    
896  void yyset_debug (int debug_flag  );  void yyset_debug ( int debug_flag  );
897    
898  YY_EXTRA_TYPE yyget_extra (void );  YY_EXTRA_TYPE yyget_extra ( void );
899    
900  void yyset_extra (YY_EXTRA_TYPE user_defined  );  void yyset_extra ( YY_EXTRA_TYPE user_defined  );
901    
902  FILE *yyget_in (void );  FILE *yyget_in ( void );
903    
904  void yyset_in  (FILE * _in_str  );  void yyset_in  ( FILE * _in_str  );
905    
906  FILE *yyget_out (void );  FILE *yyget_out ( void );
907    
908  void yyset_out  (FILE * _out_str  );  void yyset_out  ( FILE * _out_str  );
909    
910                          int yyget_leng (void );                          int yyget_leng ( void );
911    
912  char *yyget_text (void );  char *yyget_text ( void );
913    
914  int yyget_lineno (void );  int yyget_lineno ( void );
915    
916  void yyset_lineno (int _line_number  );  void yyset_lineno ( int _line_number  );
917    
918  /* Macros after this point can all be overridden by user definitions in  /* Macros after this point can all be overridden by user definitions in
919   * section 1.   * section 1.
# Line 935  void yyset_lineno (int _line_number  ); Line 921  void yyset_lineno (int _line_number  );
921    
922  #ifndef YY_SKIP_YYWRAP  #ifndef YY_SKIP_YYWRAP
923  #ifdef __cplusplus  #ifdef __cplusplus
924  extern "C" int yywrap (void );  extern "C" int yywrap ( void );
925  #else  #else
926  extern int yywrap (void );  extern int yywrap ( void );
927  #endif  #endif
928  #endif  #endif
929    
# Line 946  extern int yywrap (void ); Line 932  extern int yywrap (void );
932  #endif  #endif
933    
934  #ifndef yytext_ptr  #ifndef yytext_ptr
935  static void yy_flex_strncpy (char *,yyconst char *,int );  static void yy_flex_strncpy ( char *, const char *, int );
936  #endif  #endif
937    
938  #ifdef YY_NEED_STRLEN  #ifdef YY_NEED_STRLEN
939  static int yy_flex_strlen (yyconst char * );  static int yy_flex_strlen ( const char * );
940  #endif  #endif
941    
942  #ifndef YY_NO_INPUT  #ifndef YY_NO_INPUT
   
943  #ifdef __cplusplus  #ifdef __cplusplus
944  static int yyinput (void );  static int yyinput ( void );
945  #else  #else
946  static int input (void );  static int input ( void );
947  #endif  #endif
948    
949  #endif  #endif
# Line 989  static int input (void ); Line 974  static int input (void );
974          if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \          if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
975                  { \                  { \
976                  int c = '*'; \                  int c = '*'; \
977                  size_t n; \                  int n; \
978                  for ( n = 0; n < max_size && \                  for ( n = 0; n < max_size && \
979                               (c = getc( yyin )) != EOF && c != '\n'; ++n ) \                               (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
980                          buf[n] = (char) c; \                          buf[n] = (char) c; \
# Line 1002  static int input (void ); Line 987  static int input (void );
987          else \          else \
988                  { \                  { \
989                  errno=0; \                  errno=0; \
990                  while ( (result = (int) fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \                  while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
991                          { \                          { \
992                          if( errno != EINTR) \                          if( errno != EINTR) \
993                                  { \                                  { \
# Line 1101  YY_DECL Line 1086  YY_DECL
1086  #line 85 "config-lexer.l"  #line 85 "config-lexer.l"
1087    
1088    
1089  #line 1105 "config-lexer.c"  #line 1089 "config-lexer.c"
1090    
1091          while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */          while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */
1092                  {                  {
1093                  (yy_more_len) = 0;                  (yy_more_len) = 0;
1094                  if ( (yy_more_flag) )                  if ( (yy_more_flag) )
1095                          {                          {
1096                          (yy_more_len) = (yy_c_buf_p) - (yytext_ptr);                          (yy_more_len) = (int) ((yy_c_buf_p) - (yytext_ptr));
1097                          (yy_more_flag) = 0;                          (yy_more_flag) = 0;
1098                          }                          }
1099                  yy_cp = (yy_c_buf_p);                  yy_cp = (yy_c_buf_p);
# Line 1135  yy_match: Line 1120  yy_match:
1120                                  {                                  {
1121                                  yy_current_state = (int) yy_def[yy_current_state];                                  yy_current_state = (int) yy_def[yy_current_state];
1122                                  if ( yy_current_state >= 450 )                                  if ( yy_current_state >= 450 )
1123                                          yy_c = yy_meta[(unsigned int) yy_c];                                          yy_c = yy_meta[yy_c];
1124                                  }                                  }
1125                          yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];                          yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1126                          ++yy_cp;                          ++yy_cp;
1127                          }                          }
1128                  while ( yy_current_state != 449 );                  while ( yy_current_state != 449 );
# Line 1775  YY_RULE_SETUP Line 1760  YY_RULE_SETUP
1760  #line 298 "config-lexer.l"  #line 298 "config-lexer.l"
1761  ECHO;  ECHO;
1762          YY_BREAK          YY_BREAK
1763  #line 1779 "config-lexer.c"  #line 1763 "config-lexer.c"
1764    
1765          case YY_END_OF_BUFFER:          case YY_END_OF_BUFFER:
1766                  {                  {
# Line 1919  static int yy_get_next_buffer (void) Line 1904  static int yy_get_next_buffer (void)
1904  {  {
1905          char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;          char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1906          char *source = (yytext_ptr);          char *source = (yytext_ptr);
1907          yy_size_t number_to_move, i;          int number_to_move, i;
1908          int ret_val;          int ret_val;
1909    
1910          if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )          if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
# Line 1948  static int yy_get_next_buffer (void) Line 1933  static int yy_get_next_buffer (void)
1933          /* Try to read more data. */          /* Try to read more data. */
1934    
1935          /* First move last chars to start of buffer. */          /* First move last chars to start of buffer. */
1936          number_to_move = (yy_size_t) ((yy_c_buf_p) - (yytext_ptr)) - 1;          number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1937    
1938          for ( i = 0; i < number_to_move; ++i )          for ( i = 0; i < number_to_move; ++i )
1939                  *(dest++) = *(source++);                  *(dest++) = *(source++);
# Line 1984  static int yy_get_next_buffer (void) Line 1969  static int yy_get_next_buffer (void)
1969    
1970                                  b->yy_ch_buf = (char *)                                  b->yy_ch_buf = (char *)
1971                                          /* Include room in for 2 EOB chars. */                                          /* Include room in for 2 EOB chars. */
1972                                          yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );                                          yyrealloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2)  );
1973                                  }                                  }
1974                          else                          else
1975                                  /* Can't grow it, we don't own it. */                                  /* Can't grow it, we don't own it. */
# Line 2030  static int yy_get_next_buffer (void) Line 2015  static int yy_get_next_buffer (void)
2015          else          else
2016                  ret_val = EOB_ACT_CONTINUE_SCAN;                  ret_val = EOB_ACT_CONTINUE_SCAN;
2017    
2018          if ((int) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {          if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
2019                  /* Extend the array by 50%, plus the number we really need. */                  /* Extend the array by 50%, plus the number we really need. */
2020                  int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);                  int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
2021                  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );                  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size  );
2022                  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )                  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2023                          YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );                          YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
2024          }          }
# Line 2068  static int yy_get_next_buffer (void) Line 2053  static int yy_get_next_buffer (void)
2053                          {                          {
2054                          yy_current_state = (int) yy_def[yy_current_state];                          yy_current_state = (int) yy_def[yy_current_state];
2055                          if ( yy_current_state >= 450 )                          if ( yy_current_state >= 450 )
2056                                  yy_c = yy_meta[(unsigned int) yy_c];                                  yy_c = yy_meta[yy_c];
2057                          }                          }
2058                  yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];                  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
2059                  }                  }
2060    
2061          return yy_current_state;          return yy_current_state;
# Line 2096  static int yy_get_next_buffer (void) Line 2081  static int yy_get_next_buffer (void)
2081                  {                  {
2082                  yy_current_state = (int) yy_def[yy_current_state];                  yy_current_state = (int) yy_def[yy_current_state];
2083                  if ( yy_current_state >= 450 )                  if ( yy_current_state >= 450 )
2084                          yy_c = yy_meta[(unsigned int) yy_c];                          yy_c = yy_meta[yy_c];
2085                  }                  }
2086          yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];          yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
2087          yy_is_jam = (yy_current_state == 449);          yy_is_jam = (yy_current_state == 449);
2088    
2089                  return yy_is_jam ? 0 : yy_current_state;                  return yy_is_jam ? 0 : yy_current_state;
# Line 2132  static int yy_get_next_buffer (void) Line 2117  static int yy_get_next_buffer (void)
2117    
2118                  else                  else
2119                          { /* need more input */                          { /* need more input */
2120                          int offset = (yy_c_buf_p) - (yytext_ptr);                          int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
2121                          ++(yy_c_buf_p);                          ++(yy_c_buf_p);
2122    
2123                          switch ( yy_get_next_buffer(  ) )                          switch ( yy_get_next_buffer(  ) )
# Line 2257  static void yy_load_buffer_state  (void) Line 2242  static void yy_load_buffer_state  (void)
2242          if ( ! b )          if ( ! b )
2243                  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );                  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2244    
2245          b->yy_buf_size = (yy_size_t)size;          b->yy_buf_size = size;
2246    
2247          /* 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
2248           * we need to put in 2 end-of-buffer characters.           * we need to put in 2 end-of-buffer characters.
2249           */           */
2250          b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );          b->yy_ch_buf = (char *) yyalloc((yy_size_t) (b->yy_buf_size + 2)  );
2251          if ( ! b->yy_ch_buf )          if ( ! b->yy_ch_buf )
2252                  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );                  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2253    
# Line 2404  void yypop_buffer_state (void) Line 2389  void yypop_buffer_state (void)
2389   */   */
2390  static void yyensure_buffer_stack (void)  static void yyensure_buffer_stack (void)
2391  {  {
2392          int num_to_alloc;          yy_size_t num_to_alloc;
2393            
2394          if (!(yy_buffer_stack)) {          if (!(yy_buffer_stack)) {
2395    
# Line 2465  YY_BUFFER_STATE yy_scan_buffer  (char * Line 2450  YY_BUFFER_STATE yy_scan_buffer  (char *
2450          if ( ! b )          if ( ! b )
2451                  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );                  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2452    
2453          b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */          b->yy_buf_size = (int) (size - 2);      /* "- 2" to take care of EOB's */
2454          b->yy_buf_pos = b->yy_ch_buf = base;          b->yy_buf_pos = b->yy_ch_buf = base;
2455          b->yy_is_our_buffer = 0;          b->yy_is_our_buffer = 0;
2456          b->yy_input_file = NULL;          b->yy_input_file = NULL;
# Line 2488  YY_BUFFER_STATE yy_scan_buffer  (char * Line 2473  YY_BUFFER_STATE yy_scan_buffer  (char *
2473   * @note If you want to scan bytes that may contain NUL values, then use   * @note If you want to scan bytes that may contain NUL values, then use
2474   *       yy_scan_bytes() instead.   *       yy_scan_bytes() instead.
2475   */   */
2476  YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )  YY_BUFFER_STATE yy_scan_string (const char * yystr )
2477  {  {
2478            
2479          return yy_scan_bytes(yystr,(int) strlen(yystr) );          return yy_scan_bytes(yystr,(int) strlen(yystr) );
# Line 2501  YY_BUFFER_STATE yy_scan_string (yyconst Line 2486  YY_BUFFER_STATE yy_scan_string (yyconst
2486   *   *
2487   * @return the newly allocated buffer state object.   * @return the newly allocated buffer state object.
2488   */   */
2489  YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )  YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
2490  {  {
2491          YY_BUFFER_STATE b;          YY_BUFFER_STATE b;
2492          char *buf;          char *buf;
2493          yy_size_t n;          yy_size_t n;
2494          yy_size_t i;          int i;
2495            
2496          /* Get memory for full buffer, including space for trailing EOB's. */          /* Get memory for full buffer, including space for trailing EOB's. */
2497          n = (yy_size_t) _yybytes_len + 2;          n = (yy_size_t) (_yybytes_len + 2);
2498          buf = (char *) yyalloc(n  );          buf = (char *) yyalloc(n  );
2499          if ( ! buf )          if ( ! buf )
2500                  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );                  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
# Line 2535  YY_BUFFER_STATE yy_scan_bytes  (yyconst Line 2520  YY_BUFFER_STATE yy_scan_bytes  (yyconst
2520  #define YY_EXIT_FAILURE 2  #define YY_EXIT_FAILURE 2
2521  #endif  #endif
2522    
2523  static void yynoreturn yy_fatal_error (yyconst char* msg )  static void yynoreturn yy_fatal_error (const char* msg )
2524  {  {
2525                          (void) fprintf( stderr, "%s\n", msg );                          (void) fprintf( stderr, "%s\n", msg );
2526          exit( YY_EXIT_FAILURE );          exit( YY_EXIT_FAILURE );
# Line 2693  int yylex_destroy  (void) Line 2678  int yylex_destroy  (void)
2678   */   */
2679    
2680  #ifndef yytext_ptr  #ifndef yytext_ptr
2681  static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )  static void yy_flex_strncpy (char* s1, const char * s2, int n )
2682  {  {
2683                                    
2684          int i;          int i;
# Line 2703  static void yy_flex_strncpy (char* s1, y Line 2688  static void yy_flex_strncpy (char* s1, y
2688  #endif  #endif
2689    
2690  #ifdef YY_NEED_STRLEN  #ifdef YY_NEED_STRLEN
2691  static int yy_flex_strlen (yyconst char * s )  static int yy_flex_strlen (const char * s )
2692  {  {
2693          int n;          int n;
2694          for ( n = 0; s[n]; ++n )          for ( n = 0; s[n]; ++n )
# Line 2741  void yyfree (void * ptr ) Line 2726  void yyfree (void * ptr )
2726  #line 298 "config-lexer.l"  #line 298 "config-lexer.l"
2727    
2728    
   
2729  static void  static void
2730  conf_include(void)  conf_include(void)
2731  {  {
# Line 2783  conf_include(void) Line 2767  conf_include(void)
2767    conf_file = tmp_fbfile_in;    conf_file = tmp_fbfile_in;
2768    strlcpy(conffilebuf, filenamebuf, sizeof(conffilebuf));    strlcpy(conffilebuf, filenamebuf, sizeof(conffilebuf));
2769    
2770    yy_switch_to_buffer(yy_create_buffer(NULL,YY_BUF_SIZE));    yy_switch_to_buffer(yy_create_buffer(NULL, YY_BUF_SIZE));
2771  }  }
2772    
2773  static int  static int

Legend:
Removed from v.7827  
changed lines
  Added in v.7828

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.28