[BACK]Return to token.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ipsec-tools / src / setkey

Diff for /embedaddon/ipsec-tools/src/setkey/token.c between versions 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2012/02/21 22:39:10 version 1.1.1.2, 2014/06/15 16:37:11
Line 8 Line 8
 #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 35#define YY_FLEX_SUBMINOR_VERSION 37
 #if YY_FLEX_SUBMINOR_VERSION > 0  #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA  #define FLEX_BETA
 #endif  #endif
Line 141  typedef unsigned int flex_uint32_t; Line 141  typedef unsigned int flex_uint32_t;
   
 /* Size of default input buffer. */  /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE  #ifndef YY_BUF_SIZE
 #ifdef __ia64__  
 /* On IA-64, the buffer size is 16k, not 8k.  
  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.  
  * Ditto for the __ia64__ case accordingly.  
  */  
 #define YY_BUF_SIZE 32768  
 #else  
 #define YY_BUF_SIZE 16384  #define YY_BUF_SIZE 16384
 #endif /* __ia64__ */  
 #endif  #endif
   
 /* The state buf must be large enough to hold one state per character in the main buffer.  /* The state buf must be large enough to hold one state per character in the main buffer.
Line 161  typedef unsigned int flex_uint32_t; Line 153  typedef unsigned int flex_uint32_t;
 typedef struct yy_buffer_state *YY_BUFFER_STATE;  typedef struct yy_buffer_state *YY_BUFFER_STATE;
 #endif  #endif
   
extern int yyleng;#ifndef YY_TYPEDEF_YY_SIZE_T
 #define YY_TYPEDEF_YY_SIZE_T
 typedef size_t yy_size_t;
 #endif
   
   extern yy_size_t yyleng;
   
 extern FILE *yyin, *yyout;  extern FILE *yyin, *yyout;
   
 #define EOB_ACT_CONTINUE_SCAN 0  #define EOB_ACT_CONTINUE_SCAN 0
Line 187  extern FILE *yyin, *yyout; Line 184  extern FILE *yyin, *yyout;
   
 #define unput(c) yyunput( c, (yytext_ptr)  )  #define unput(c) yyunput( c, (yytext_ptr)  )
   
 #ifndef YY_TYPEDEF_YY_SIZE_T  
 #define YY_TYPEDEF_YY_SIZE_T  
 typedef size_t yy_size_t;  
 #endif  
   
 #ifndef YY_STRUCT_YY_BUFFER_STATE  #ifndef YY_STRUCT_YY_BUFFER_STATE
 #define YY_STRUCT_YY_BUFFER_STATE  #define YY_STRUCT_YY_BUFFER_STATE
 struct yy_buffer_state  struct yy_buffer_state
Line 209  struct yy_buffer_state Line 201  struct yy_buffer_state
         /* Number of characters read into yy_ch_buf, not including EOB          /* Number of characters read into yy_ch_buf, not including EOB
          * characters.           * characters.
          */           */
        int yy_n_chars;        yy_size_t yy_n_chars;
   
         /* Whether we "own" the buffer - i.e., we know we created it,          /* Whether we "own" the buffer - i.e., we know we created it,
          * and can realloc() it to grow it, and should free() it to           * and can realloc() it to grow it, and should free() it to
Line 279  static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Sta Line 271  static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Sta
   
 /* 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 yy_size_t yy_n_chars;           /* number of characters read into yy_ch_buf */
int yyleng;yy_size_t yyleng;
   
 /* Points to current character in buffer. */  /* Points to current character in buffer. */
 static char *yy_c_buf_p = (char *) 0;  static char *yy_c_buf_p = (char *) 0;
Line 308  static void yy_init_buffer (YY_BUFFER_STATE b,FILE *fi Line 300  static void yy_init_buffer (YY_BUFFER_STATE b,FILE *fi
   
 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );  YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );  YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len  );
   
 void *yyalloc (yy_size_t  );  void *yyalloc (yy_size_t  );
 void *yyrealloc (void *,yy_size_t  );  void *yyrealloc (void *,yy_size_t  );
Line 1087  char *yytext; Line 1079  char *yytext;
 /* common section */  /* common section */
   
 #define YY_NO_INPUT 1  #define YY_NO_INPUT 1
#line 1091 "token.c"#line 1083 "token.c"
   
 #define INITIAL 0  #define INITIAL 0
 #define S_PL 1  #define S_PL 1
Line 1129  FILE *yyget_out (void ); Line 1121  FILE *yyget_out (void );
   
 void yyset_out  (FILE * out_str  );  void yyset_out  (FILE * out_str  );
   
int yyget_leng (void );yy_size_t yyget_leng (void );
   
 char *yyget_text (void );  char *yyget_text (void );
   
Line 1169  static int input (void ); Line 1161  static int input (void );
   
 /* 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
 #ifdef __ia64__  
 /* On IA-64, the buffer size is 16k, not 8k */  
 #define YY_READ_BUF_SIZE 16384  
 #else  
 #define YY_READ_BUF_SIZE 8192  #define YY_READ_BUF_SIZE 8192
 #endif /* __ia64__ */  
 #endif  #endif
   
 /* Copy whatever the last rule matched to the standard output. */  /* Copy whatever the last rule matched to the standard output. */
Line 1279  YY_DECL Line 1266  YY_DECL
   
   
   
#line 1283 "token.c"#line 1270 "token.c"
   
         if ( !(yy_init) )          if ( !(yy_init) )
                 {                  {
Line 1912  YY_RULE_SETUP Line 1899  YY_RULE_SETUP
 #line 314 "token.l"  #line 314 "token.l"
 ECHO;  ECHO;
         YY_BREAK          YY_BREAK
#line 1916 "token.c"#line 1903 "token.c"
 case YY_STATE_EOF(INITIAL):  case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(S_PL):  case YY_STATE_EOF(S_PL):
 case YY_STATE_EOF(S_AUTHALG):  case YY_STATE_EOF(S_AUTHALG):
Line 2101  static int yy_get_next_buffer (void) Line 2088  static int yy_get_next_buffer (void)
   
         else          else
                 {                  {
                        int num_to_read =                        yy_size_t num_to_read =
                         YY_CURRENT_BUFFER_LVALUE->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. */
   
                         /* 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_LVALUE;
   
                         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 )
                                 {                                  {
                                int new_size = b->yy_buf_size * 2;                                yy_size_t new_size = b->yy_buf_size * 2;
   
                                 if ( new_size <= 0 )                                  if ( new_size <= 0 )
                                         b->yy_buf_size += b->yy_buf_size / 8;                                          b->yy_buf_size += b->yy_buf_size / 8;
Line 2146  static int yy_get_next_buffer (void) Line 2133  static int yy_get_next_buffer (void)
   
                 /* Read in more data. */                  /* Read in more data. */
                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),                  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
                        (yy_n_chars), (size_t) num_to_read );                        (yy_n_chars), num_to_read );
   
                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);                  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
                 }                  }
Line 2241  static int yy_get_next_buffer (void) Line 2228  static int yy_get_next_buffer (void)
         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];          yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
         yy_is_jam = (yy_current_state == 563);          yy_is_jam = (yy_current_state == 563);
   
        return yy_is_jam ? 0 : yy_current_state;                return yy_is_jam ? 0 : yy_current_state;
 }  }
   
 #ifndef YY_NO_INPUT  #ifndef YY_NO_INPUT
Line 2268  static int yy_get_next_buffer (void) Line 2255  static int yy_get_next_buffer (void)
   
                 else                  else
                         { /* need more input */                          { /* need more input */
                        int offset = (yy_c_buf_p) - (yytext_ptr);                        yy_size_t 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 2428  static void yy_load_buffer_state  (void) Line 2415  static void yy_load_buffer_state  (void)
         yyfree((void *) b  );          yyfree((void *) b  );
 }  }
   
 #ifndef __cplusplus  
 extern int isatty (int );  
 #endif /* __cplusplus */  
       
 /* Initializes or reinitializes a buffer.  /* Initializes or reinitializes a buffer.
  * This function is sometimes called more than once on the same buffer,   * This function is sometimes called more than once on the same buffer,
  * such as during a yyrestart() or at EOF.   * such as during a yyrestart() or at EOF.
Line 2544  void yypop_buffer_state (void) Line 2527  void yypop_buffer_state (void)
  */   */
 static void yyensure_buffer_stack (void)  static void yyensure_buffer_stack (void)
 {  {
        int num_to_alloc;        yy_size_t num_to_alloc;
           
         if (!(yy_buffer_stack)) {          if (!(yy_buffer_stack)) {
   
Line 2641  YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) Line 2624  YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
  *    * 
  * @return the newly allocated buffer state object.   * @return the newly allocated buffer state object.
  */   */
YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
 {  {
         YY_BUFFER_STATE b;          YY_BUFFER_STATE b;
         char *buf;          char *buf;
Line 2728  FILE *yyget_out  (void) Line 2711  FILE *yyget_out  (void)
 /** Get the length of the current token.  /** Get the length of the current token.
  *    * 
  */   */
int yyget_leng  (void)yy_size_t yyget_leng  (void)
 {  {
         return yyleng;          return yyleng;
 }  }
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>