/[svn]/ircd-hybrid/trunk/src/conf_lexer.c
ViewVC logotype

Diff of /ircd-hybrid/trunk/src/conf_lexer.c

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

revision 8244 by michael, Sat Mar 18 18:09:01 2017 UTC revision 8245 by michael, Mon May 15 17:09:05 2017 UTC
# 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 2  #define YY_FLEX_SUBMINOR_VERSION 4
12  #if YY_FLEX_SUBMINOR_VERSION > 0  #if YY_FLEX_SUBMINOR_VERSION > 0
13  #define FLEX_BETA  #define FLEX_BETA
14  #endif  #endif
# Line 83  typedef unsigned int flex_uint32_t; Line 83  typedef unsigned int flex_uint32_t;
83  #define UINT32_MAX             (4294967295U)  #define UINT32_MAX             (4294967295U)
84  #endif  #endif
85    
86    #ifndef SIZE_MAX
87    #define SIZE_MAX               (~(size_t)0)
88    #endif
89    
90  #endif /* ! C99 */  #endif /* ! C99 */
91    
92  #endif /* ! FLEXINT_H */  #endif /* ! FLEXINT_H */
93    
94    /* begin standard C++ headers. */
95    
96  /* TODO: this is always defined, so inline it */  /* TODO: this is always defined, so inline it */
97  #define yyconst const  #define yyconst const
98    
# Line 118  typedef unsigned int flex_uint32_t; Line 124  typedef unsigned int flex_uint32_t;
124  /* Action number for EOF rule of a given start state. */  /* Action number for EOF rule of a given start state. */
125  #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)  #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
126  /* Special action meaning "start processing a new file". */  /* Special action meaning "start processing a new file". */
127  #define YY_NEW_FILE yyrestart(yyin  )  #define YY_NEW_FILE yyrestart( yyin  )
128  #define YY_END_OF_BUFFER_CHAR 0  #define YY_END_OF_BUFFER_CHAR 0
129    
130  /* Size of default input buffer. */  /* Size of default input buffer. */
# Line 214  struct yy_buffer_state Line 220  struct yy_buffer_state
220    
221      int yy_bs_lineno; /**< The line count. */      int yy_bs_lineno; /**< The line count. */
222      int yy_bs_column; /**< The column count. */      int yy_bs_column; /**< The column count. */
223        
224          /* Whether to try to fill the input buffer when we reach the          /* Whether to try to fill the input buffer when we reach the
225           * end of it.           * end of it.
226           */           */
# Line 284  void yypop_buffer_state ( void ); Line 290  void yypop_buffer_state ( void );
290  static void yyensure_buffer_stack ( void );  static void yyensure_buffer_stack ( void );
291  static void yy_load_buffer_state ( void );  static void yy_load_buffer_state ( void );
292  static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file  );  static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file  );
293  #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )  #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
294    
295  YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size  );  YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size  );
296  YY_BUFFER_STATE yy_scan_string ( const char *yy_str  );  YY_BUFFER_STATE yy_scan_string ( const char *yy_str  );
# Line 300  void yyfree ( void *  ); Line 306  void yyfree ( void *  );
306          if ( ! YY_CURRENT_BUFFER ){ \          if ( ! YY_CURRENT_BUFFER ){ \
307          yyensure_buffer_stack (); \          yyensure_buffer_stack (); \
308                  YY_CURRENT_BUFFER_LVALUE =    \                  YY_CURRENT_BUFFER_LVALUE =    \
309              yy_create_buffer(yyin,YY_BUF_SIZE ); \              yy_create_buffer( yyin, YY_BUF_SIZE ); \
310          } \          } \
311          YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \          YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
312          }          }
# Line 309  void yyfree ( void *  ); Line 315  void yyfree ( void *  );
315          if ( ! YY_CURRENT_BUFFER ){\          if ( ! YY_CURRENT_BUFFER ){\
316          yyensure_buffer_stack (); \          yyensure_buffer_stack (); \
317                  YY_CURRENT_BUFFER_LVALUE =    \                  YY_CURRENT_BUFFER_LVALUE =    \
318              yy_create_buffer(yyin,YY_BUF_SIZE ); \              yy_create_buffer( yyin, YY_BUF_SIZE ); \
319          } \          } \
320          YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \          YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
321          }          }
# Line 1817  conf_yy_fatal_error(const char *msg) Line 1823  conf_yy_fatal_error(const char *msg)
1823    return 0;    return 0;
1824  }  }
1825    
1826  #line 1820 "conf_lexer.c"  #line 1826 "conf_lexer.c"
1827  #line 1821 "conf_lexer.c"  #line 1827 "conf_lexer.c"
1828    
1829  #define INITIAL 0  #define INITIAL 0
1830    
# Line 2026  YY_DECL Line 2032  YY_DECL
2032                  if ( ! YY_CURRENT_BUFFER ) {                  if ( ! YY_CURRENT_BUFFER ) {
2033                          yyensure_buffer_stack ();                          yyensure_buffer_stack ();
2034                          YY_CURRENT_BUFFER_LVALUE =                          YY_CURRENT_BUFFER_LVALUE =
2035                                  yy_create_buffer(yyin,YY_BUF_SIZE );                                  yy_create_buffer( yyin, YY_BUF_SIZE );
2036                  }                  }
2037    
2038                  yy_load_buffer_state( );                  yy_load_buffer_state(  );
2039                  }                  }
2040    
2041          {          {
2042  #line 85 "conf_lexer.l"  #line 85 "conf_lexer.l"
2043    
2044  #line 2038 "conf_lexer.c"  #line 2044 "conf_lexer.c"
2045    
2046          while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */          while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */
2047                  {                  {
# Line 3459  YY_RULE_SETUP Line 3465  YY_RULE_SETUP
3465  #line 395 "conf_lexer.l"  #line 395 "conf_lexer.l"
3466  ECHO;  ECHO;
3467          YY_BREAK          YY_BREAK
3468  #line 3462 "conf_lexer.c"  #line 3468 "conf_lexer.c"
3469    
3470          case YY_END_OF_BUFFER:          case YY_END_OF_BUFFER:
3471                  {                  {
# Line 3536  ECHO; Line 3542  ECHO;
3542                                  {                                  {
3543                                  (yy_did_buffer_switch_on_eof) = 0;                                  (yy_did_buffer_switch_on_eof) = 0;
3544    
3545                                  if ( yywrap( ) )                                  if ( yywrap(  ) )
3546                                          {                                          {
3547                                          /* Note: because we've taken care in                                          /* Note: because we've taken care in
3548                                           * yy_get_next_buffer() to have set up                                           * yy_get_next_buffer() to have set up
# Line 3668  static int yy_get_next_buffer (void) Line 3674  static int yy_get_next_buffer (void)
3674    
3675                                  b->yy_ch_buf = (char *)                                  b->yy_ch_buf = (char *)
3676                                          /* Include room in for 2 EOB chars. */                                          /* Include room in for 2 EOB chars. */
3677                                          yyrealloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size + 2)  );                                          yyrealloc( (void *) b->yy_ch_buf,
3678                                                             (yy_size_t) (b->yy_buf_size + 2)  );
3679                                  }                                  }
3680                          else                          else
3681                                  /* Can't grow it, we don't own it. */                                  /* Can't grow it, we don't own it. */
# Line 3700  static int yy_get_next_buffer (void) Line 3707  static int yy_get_next_buffer (void)
3707                  if ( number_to_move == YY_MORE_ADJ )                  if ( number_to_move == YY_MORE_ADJ )
3708                          {                          {
3709                          ret_val = EOB_ACT_END_OF_FILE;                          ret_val = EOB_ACT_END_OF_FILE;
3710                          yyrestart(yyin  );                          yyrestart( yyin  );
3711                          }                          }
3712    
3713                  else                  else
# Line 3717  static int yy_get_next_buffer (void) Line 3724  static int yy_get_next_buffer (void)
3724          if (((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) {
3725                  /* Extend the array by 50%, plus the number we really need. */                  /* Extend the array by 50%, plus the number we really need. */
3726                  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);
3727                  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size  );                  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
3728                            (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size  );
3729                  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )                  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
3730                          YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );                          YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
3731                    /* "- 2" to take care of EOB's */
3732                    YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
3733          }          }
3734    
3735          (yy_n_chars) += number_to_move;          (yy_n_chars) += number_to_move;
# Line 3833  static int yy_get_next_buffer (void) Line 3843  static int yy_get_next_buffer (void)
3843                                           */                                           */
3844    
3845                                          /* Reset buffer status. */                                          /* Reset buffer status. */
3846                                          yyrestart(yyin );                                          yyrestart( yyin );
3847    
3848                                          /*FALLTHROUGH*/                                          /*FALLTHROUGH*/
3849    
3850                                  case EOB_ACT_END_OF_FILE:                                  case EOB_ACT_END_OF_FILE:
3851                                          {                                          {
3852                                          if ( yywrap( ) )                                          if ( yywrap(  ) )
3853                                                  return 0;                                                  return 0;
3854    
3855                                          if ( ! (yy_did_buffer_switch_on_eof) )                                          if ( ! (yy_did_buffer_switch_on_eof) )
# Line 3877  static int yy_get_next_buffer (void) Line 3887  static int yy_get_next_buffer (void)
3887          if ( ! YY_CURRENT_BUFFER ){          if ( ! YY_CURRENT_BUFFER ){
3888          yyensure_buffer_stack ();          yyensure_buffer_stack ();
3889                  YY_CURRENT_BUFFER_LVALUE =                  YY_CURRENT_BUFFER_LVALUE =
3890              yy_create_buffer(yyin,YY_BUF_SIZE );              yy_create_buffer( yyin, YY_BUF_SIZE );
3891          }          }
3892    
3893          yy_init_buffer(YY_CURRENT_BUFFER,input_file );          yy_init_buffer( YY_CURRENT_BUFFER, input_file );
3894          yy_load_buffer_state( );          yy_load_buffer_state(  );
3895  }  }
3896    
3897  /** Switch to a different input buffer.  /** Switch to a different input buffer.
# Line 3909  static int yy_get_next_buffer (void) Line 3919  static int yy_get_next_buffer (void)
3919                  }                  }
3920    
3921          YY_CURRENT_BUFFER_LVALUE = new_buffer;          YY_CURRENT_BUFFER_LVALUE = new_buffer;
3922          yy_load_buffer_state( );          yy_load_buffer_state(  );
3923    
3924          /* We don't actually know whether we did this switch during          /* We don't actually know whether we did this switch during
3925           * EOF (yywrap()) processing, but the only time this flag           * EOF (yywrap()) processing, but the only time this flag
# Line 3937  static void yy_load_buffer_state  (void) Line 3947  static void yy_load_buffer_state  (void)
3947  {  {
3948          YY_BUFFER_STATE b;          YY_BUFFER_STATE b;
3949            
3950          b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );          b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
3951          if ( ! b )          if ( ! b )
3952                  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );                  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3953    
# Line 3946  static void yy_load_buffer_state  (void) Line 3956  static void yy_load_buffer_state  (void)
3956          /* 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
3957           * we need to put in 2 end-of-buffer characters.           * we need to put in 2 end-of-buffer characters.
3958           */           */
3959          b->yy_ch_buf = (char *) yyalloc((yy_size_t) (b->yy_buf_size + 2)  );          b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
3960          if ( ! b->yy_ch_buf )          if ( ! b->yy_ch_buf )
3961                  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );                  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
3962    
3963          b->yy_is_our_buffer = 1;          b->yy_is_our_buffer = 1;
3964    
3965          yy_init_buffer(b,file );          yy_init_buffer( b, file );
3966    
3967          return b;          return b;
3968  }  }
# Line 3971  static void yy_load_buffer_state  (void) Line 3981  static void yy_load_buffer_state  (void)
3981                  YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;                  YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
3982    
3983          if ( b->yy_is_our_buffer )          if ( b->yy_is_our_buffer )
3984                  yyfree((void *) b->yy_ch_buf  );                  yyfree( (void *) b->yy_ch_buf  );
3985    
3986          yyfree((void *) b  );          yyfree( (void *) b  );
3987  }  }
3988    
3989  /* Initializes or reinitializes a buffer.  /* Initializes or reinitializes a buffer.
# Line 3985  static void yy_load_buffer_state  (void) Line 3995  static void yy_load_buffer_state  (void)
3995  {  {
3996          int oerrno = errno;          int oerrno = errno;
3997            
3998          yy_flush_buffer(b );          yy_flush_buffer( b );
3999    
4000          b->yy_input_file = file;          b->yy_input_file = file;
4001          b->yy_fill_buffer = 1;          b->yy_fill_buffer = 1;
# Line 4028  static void yy_load_buffer_state  (void) Line 4038  static void yy_load_buffer_state  (void)
4038          b->yy_buffer_status = YY_BUFFER_NEW;          b->yy_buffer_status = YY_BUFFER_NEW;
4039    
4040          if ( b == YY_CURRENT_BUFFER )          if ( b == YY_CURRENT_BUFFER )
4041                  yy_load_buffer_state( );                  yy_load_buffer_state(  );
4042  }  }
4043    
4044  /** Pushes the new state onto the stack. The new state becomes  /** Pushes the new state onto the stack. The new state becomes
# Line 4059  void yypush_buffer_state (YY_BUFFER_STAT Line 4069  void yypush_buffer_state (YY_BUFFER_STAT
4069          YY_CURRENT_BUFFER_LVALUE = new_buffer;          YY_CURRENT_BUFFER_LVALUE = new_buffer;
4070    
4071          /* copied from yy_switch_to_buffer. */          /* copied from yy_switch_to_buffer. */
4072          yy_load_buffer_state( );          yy_load_buffer_state(  );
4073          (yy_did_buffer_switch_on_eof) = 1;          (yy_did_buffer_switch_on_eof) = 1;
4074  }  }
4075    
# Line 4078  void yypop_buffer_state (void) Line 4088  void yypop_buffer_state (void)
4088                  --(yy_buffer_stack_top);                  --(yy_buffer_stack_top);
4089    
4090          if (YY_CURRENT_BUFFER) {          if (YY_CURRENT_BUFFER) {
4091                  yy_load_buffer_state( );                  yy_load_buffer_state(  );
4092                  (yy_did_buffer_switch_on_eof) = 1;                  (yy_did_buffer_switch_on_eof) = 1;
4093          }          }
4094  }  }
# Line 4102  static void yyensure_buffer_stack (void) Line 4112  static void yyensure_buffer_stack (void)
4112                                                                  );                                                                  );
4113                  if ( ! (yy_buffer_stack) )                  if ( ! (yy_buffer_stack) )
4114                          YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );                          YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
4115                                                                      
4116                  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));                  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
4117                                    
4118                  (yy_buffer_stack_max) = num_to_alloc;                  (yy_buffer_stack_max) = num_to_alloc;
4119                  (yy_buffer_stack_top) = 0;                  (yy_buffer_stack_top) = 0;
4120                  return;                  return;
# Line 4133  static void yyensure_buffer_stack (void) Line 4143  static void yyensure_buffer_stack (void)
4143   * @param base the character buffer   * @param base the character buffer
4144   * @param size the size in bytes of the character buffer   * @param size the size in bytes of the character buffer
4145   *   *
4146   * @return the newly allocated buffer state object.   * @return the newly allocated buffer state object.
4147   */   */
4148  YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )  YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
4149  {  {
# Line 4145  YY_BUFFER_STATE yy_scan_buffer  (char * Line 4155  YY_BUFFER_STATE yy_scan_buffer  (char *
4155                  /* They forgot to leave room for the EOB's. */                  /* They forgot to leave room for the EOB's. */
4156                  return NULL;                  return NULL;
4157    
4158          b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );          b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
4159          if ( ! b )          if ( ! b )
4160                  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );                  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
4161    
# Line 4159  YY_BUFFER_STATE yy_scan_buffer  (char * Line 4169  YY_BUFFER_STATE yy_scan_buffer  (char *
4169          b->yy_fill_buffer = 0;          b->yy_fill_buffer = 0;
4170          b->yy_buffer_status = YY_BUFFER_NEW;          b->yy_buffer_status = YY_BUFFER_NEW;
4171    
4172          yy_switch_to_buffer(b  );          yy_switch_to_buffer( b  );
4173    
4174          return b;          return b;
4175  }  }
# Line 4175  YY_BUFFER_STATE yy_scan_buffer  (char * Line 4185  YY_BUFFER_STATE yy_scan_buffer  (char *
4185  YY_BUFFER_STATE yy_scan_string (const char * yystr )  YY_BUFFER_STATE yy_scan_string (const char * yystr )
4186  {  {
4187            
4188          return yy_scan_bytes(yystr,(int) strlen(yystr) );          return yy_scan_bytes( yystr, (int) strlen(yystr) );
4189  }  }
4190    
4191  /** Setup the input buffer state to scan the given bytes. The next call to yylex() will  /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
# Line 4194  YY_BUFFER_STATE yy_scan_bytes  (const ch Line 4204  YY_BUFFER_STATE yy_scan_bytes  (const ch
4204            
4205          /* Get memory for full buffer, including space for trailing EOB's. */          /* Get memory for full buffer, including space for trailing EOB's. */
4206          n = (yy_size_t) (_yybytes_len + 2);          n = (yy_size_t) (_yybytes_len + 2);
4207          buf = (char *) yyalloc(n  );          buf = (char *) yyalloc( n  );
4208          if ( ! buf )          if ( ! buf )
4209                  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );                  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
4210    
# Line 4203  YY_BUFFER_STATE yy_scan_bytes  (const ch Line 4213  YY_BUFFER_STATE yy_scan_bytes  (const ch
4213    
4214          buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;          buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
4215    
4216          b = yy_scan_buffer(buf,n );          b = yy_scan_buffer( buf, n );
4217          if ( ! b )          if ( ! b )
4218                  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );                  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
4219    
# Line 4221  YY_BUFFER_STATE yy_scan_bytes  (const ch Line 4231  YY_BUFFER_STATE yy_scan_bytes  (const ch
4231    
4232  static void yynoreturn yy_fatal_error (const char* msg )  static void yynoreturn yy_fatal_error (const char* msg )
4233  {  {
4234                          (void) fprintf( stderr, "%s\n", msg );                          fprintf( stderr, "%s\n", msg );
4235          exit( YY_EXIT_FAILURE );          exit( YY_EXIT_FAILURE );
4236  }  }
4237    
# Line 4249  static void yynoreturn yy_fatal_error (c Line 4259  static void yynoreturn yy_fatal_error (c
4259   */   */
4260  int yyget_lineno  (void)  int yyget_lineno  (void)
4261  {  {
4262                
4263      return yylineno;      return yylineno;
4264  }  }
4265    
# Line 4356  int yylex_destroy  (void) Line 4366  int yylex_destroy  (void)
4366            
4367      /* Pop the buffer stack, destroying each element. */      /* Pop the buffer stack, destroying each element. */
4368          while(YY_CURRENT_BUFFER){          while(YY_CURRENT_BUFFER){
4369                  yy_delete_buffer(YY_CURRENT_BUFFER  );                  yy_delete_buffer( YY_CURRENT_BUFFER  );
4370                  YY_CURRENT_BUFFER_LVALUE = NULL;                  YY_CURRENT_BUFFER_LVALUE = NULL;
4371                  yypop_buffer_state();                  yypop_buffer_state();
4372          }          }

Legend:
Removed from v.8244  
changed lines
  Added in v.8245

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