Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Typedefs | Functions | Variables
crlgen_lex.c File Reference
#include <stdio.h>
#include <unistd.h>
#include "crlgen.h"
#include "prlock.h"

Go to the source code of this file.

Classes

struct  yy_buffer_state

Defines

#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION   2
#define YY_FLEX_MINOR_VERSION   5
#define yyconst
#define YY_PROTO(proto)   ()
#define YY_NULL   0
#define YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
#define BEGIN   yy_start = 1 + 2 *
#define YY_START   ((yy_start - 1) / 2)
#define YYSTATE   YY_START
#define YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
#define YY_NEW_FILE   yyrestart( yyin )
#define YY_END_OF_BUFFER_CHAR   0
#define YY_BUF_SIZE   16384
#define EOB_ACT_CONTINUE_SCAN   0
#define EOB_ACT_END_OF_FILE   1
#define EOB_ACT_LAST_MATCH   2
#define yyless(n)
#define unput(c)   yyunput( c, yytext_ptr )
#define YY_BUFFER_NEW   0
#define YY_BUFFER_NORMAL   1
#define YY_BUFFER_EOF_PENDING   2
#define YY_CURRENT_BUFFER   yy_current_buffer
#define YY_FLUSH_BUFFER   yy_flush_buffer( yy_current_buffer )
#define yy_new_buffer   yy_create_buffer
#define yy_set_interactive(is_interactive)
#define yy_set_bol(at_bol)
#define YY_AT_BOL()   (yy_current_buffer->yy_at_bol)
#define yytext_ptr   yytext
#define YY_DO_BEFORE_ACTION
#define YY_NUM_RULES   17
#define YY_END_OF_BUFFER   18
#define REJECT   reject_used_but_not_detected
#define yymore()   (yy_more_flag = 1)
#define YY_MORE_ADJ   yy_more_len
#define YY_RESTORE_YY_MORE_OFFSET
#define INITIAL   0
#define YY_INPUT(buf, result, max_size)
#define YY_NO_PUSH_STATE   1
#define YY_NO_POP_STATE   1
#define YY_NO_TOP_STATE   1
#define YY_READ_BUF_SIZE   8192
#define ECHO   (void) fwrite( yytext, yyleng, 1, yyout )
#define yyterminate()   return YY_NULL
#define YY_START_STACK_INCR   25
#define YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
#define YY_DECL   int yylex YY_PROTO(( void ))
#define YY_USER_ACTION
#define YY_BREAK   break;
#define YY_RULE_SETUP
#define YY_EXIT_FAILURE   2
#define yyless(n)

Typedefs

typedef struct yy_buffer_stateYY_BUFFER_STATE
typedef unsigned int yy_size_t
typedef unsigned char YY_CHAR
typedef int yy_state_type

Functions

void yyrestart YY_PROTO ((FILE *input_file))
void yy_switch_to_buffer YY_PROTO ((YY_BUFFER_STATE new_buffer))
void yy_load_buffer_state YY_PROTO ((void))
YY_BUFFER_STATE yy_create_buffer YY_PROTO ((FILE *file, int size))
void yy_delete_buffer YY_PROTO ((YY_BUFFER_STATE b))
void yy_init_buffer YY_PROTO ((YY_BUFFER_STATE b, FILE *file))
YY_BUFFER_STATE yy_scan_buffer YY_PROTO ((char *base, yy_size_t size))
YY_BUFFER_STATE yy_scan_string YY_PROTO ((yyconst char *yy_str))
YY_BUFFER_STATE yy_scan_bytes YY_PROTO ((yyconst char *bytes, int len))
static void *yy_flex_alloc YY_PROTO ((yy_size_t))
static void *yy_flex_realloc YY_PROTO ((void *, yy_size_t))
static void yy_flex_free YY_PROTO ((void *))
static yy_state_type
yy_try_NUL_trans 
YY_PROTO ((yy_state_type current_state))
static void yy_fatal_error YY_PROTO ((yyconst char msg[]))
static void yyunput YY_PROTO ((int c, char *buf_ptr))
 if (yy_init)
 while (1)
static int yy_get_next_buffer ()
static yy_state_type yy_get_previous_state ()
static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state)
static void yyunput (int c, char *yy_bp)
static int input ()
void yyrestart (FILE *input_file)
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)
void yy_load_buffer_state ()
YY_BUFFER_STATE yy_create_buffer (FILE *file, int size)
void yy_delete_buffer (YY_BUFFER_STATE b)
void yy_init_buffer (YY_BUFFER_STATE b, FILE *file)
void yy_flush_buffer (YY_BUFFER_STATE b)
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_bytes (yyconst char *bytes, int len)
static void yy_fatal_error (msg)
static voidyy_flex_alloc (yy_size_t size)
static voidyy_flex_realloc (void *ptr, yy_size_t size)
static void yy_flex_free (void *ptr)
void CRLGEN_InitCrlGenParserLock ()
void CRLGEN_DestroyCrlGenParserLock ()
SECStatus CRLGEN_StartCrlGen (CRLGENGeneratorData *parserCtlData)
int yywrap ()

Variables

int yyleng
FILEyyin = (FILE *) 0
FILEyyout = (FILE *) 0
static YY_BUFFER_STATE yy_current_buffer = 0
static char yy_hold_char
static int yy_n_chars
static char * yy_c_buf_p = (char *) 0
static int yy_init = 1
static int yy_start = 0
static int yy_did_buffer_switch_on_eof
char * yytext
static yyconst short int yy_accept [67]
static yyconst int yy_ec [256]
static yyconst int yy_meta [30]
static yyconst short int yy_base [72]
static yyconst short int yy_def [72]
static yyconst short int yy_nxt [235]
static yyconst short int yy_chk [235]
static yy_state_type yy_last_accepting_state
static char * yy_last_accepting_cpos
static int yy_more_flag = 0
static int yy_more_len = 0
static SECStatus parserStatus = SECSuccess
static CRLGENGeneratorData * parserData
static PRFileDescsrc
YY_DECL register yy_state_type yy_current_state
register char * yy_cp = NULL
register char * yy_bp = NULL
register int yy_act
static PRLockparserInvocationLock

Class Documentation

struct yy_buffer_state

Definition at line 238 of file icalsslexer.c.

Collaboration diagram for yy_buffer_state:
Class Members
int yy_at_bol
char * yy_buf_pos
yy_size_t yy_buf_size
int yy_buffer_status
char * yy_ch_buf
int yy_fill_buffer
FILE * yy_input_file
int yy_is_interactive
int yy_is_our_buffer
int yy_n_chars

Define Documentation

#define BEGIN   yy_start = 1 + 2 *

Definition at line 81 of file crlgen_lex.c.

Definition at line 534 of file crlgen_lex.c.

Definition at line 106 of file crlgen_lex.c.

Definition at line 107 of file crlgen_lex.c.

Definition at line 108 of file crlgen_lex.c.

Definition at line 7 of file crlgen_lex.c.

#define INITIAL   0

Definition at line 438 of file crlgen_lex.c.

#define REJECT   reject_used_but_not_detected

Definition at line 430 of file crlgen_lex.c.

#define unput (   c)    yyunput( c, yytext_ptr )

Definition at line 137 of file crlgen_lex.c.

#define YY_AT_BOL ( )    (yy_current_buffer->yy_at_bol)

Definition at line 264 of file crlgen_lex.c.

Definition at line 593 of file crlgen_lex.c.

#define YY_BUF_SIZE   16384

Definition at line 99 of file crlgen_lex.c.

Definition at line 200 of file crlgen_lex.c.

Definition at line 188 of file crlgen_lex.c.

Definition at line 189 of file crlgen_lex.c.

Definition at line 209 of file crlgen_lex.c.

Definition at line 581 of file crlgen_lex.c.

Value:
yytext_ptr = yy_bp; \
       yytext_ptr -= yy_more_len; \
       yyleng = (int) (yy_cp - yytext_ptr); \
       yy_hold_char = *yy_cp; \
       *yy_cp = '\0'; \
       yy_c_buf_p = yy_cp;

Definition at line 280 of file crlgen_lex.c.

Definition at line 289 of file crlgen_lex.c.

Definition at line 96 of file crlgen_lex.c.

Definition at line 1637 of file crlgen_lex.c.

Definition at line 574 of file crlgen_lex.c.

Definition at line 8 of file crlgen_lex.c.

Definition at line 9 of file crlgen_lex.c.

Definition at line 238 of file crlgen_lex.c.

#define YY_INPUT (   buf,
  result,
  max_size 
)
Value:
if ( parserStatus != SECFailure) { \
        if (((result = PR_Read(src, buf, max_size)) == 0) && \
            ferror( yyin )) \
          return SECFailure; \
    } else  { return SECFailure; }

Definition at line 447 of file crlgen_lex.c.

Definition at line 434 of file crlgen_lex.c.

Definition at line 248 of file crlgen_lex.c.

Definition at line 94 of file crlgen_lex.c.

Definition at line 504 of file crlgen_lex.c.

Definition at line 503 of file crlgen_lex.c.

Definition at line 505 of file crlgen_lex.c.

#define YY_NULL   0

Definition at line 68 of file crlgen_lex.c.

#define YY_NUM_RULES   17

Definition at line 288 of file crlgen_lex.c.

#define YY_PROTO (   proto)    ()

Definition at line 64 of file crlgen_lex.c.

Definition at line 525 of file crlgen_lex.c.

Definition at line 435 of file crlgen_lex.c.

Value:
if ( yyleng > 0 ) \
              yy_current_buffer->yy_at_bol = \
                            (yytext[yyleng - 1] == '\n'); \
       YY_USER_ACTION

Definition at line 596 of file crlgen_lex.c.

#define YY_SC_TO_UI (   c)    ((unsigned int) (unsigned char) c)

Definition at line 75 of file crlgen_lex.c.

#define yy_set_bol (   at_bol)
Value:
{ \
       if ( ! yy_current_buffer ) \
              yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
       yy_current_buffer->yy_at_bol = at_bol; \
       }

Definition at line 257 of file crlgen_lex.c.

#define yy_set_interactive (   is_interactive)
Value:
{ \
       if ( ! yy_current_buffer ) \
              yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
       yy_current_buffer->yy_is_interactive = is_interactive; \
       }

Definition at line 250 of file crlgen_lex.c.

#define YY_START   ((yy_start - 1) / 2)

Definition at line 87 of file crlgen_lex.c.

Definition at line 569 of file crlgen_lex.c.

Definition at line 91 of file crlgen_lex.c.

Definition at line 588 of file crlgen_lex.c.

Definition at line 57 of file crlgen_lex.c.

#define yyless (   n)
Value:
do \
              { \
              /* Undo effects of setting up yytext. */ \
              *yy_cp = yy_hold_char; \
              YY_RESTORE_YY_MORE_OFFSET \
              yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
              YY_DO_BEFORE_ACTION; /* set up yytext again */ \
              } \
       while ( 0 )

Definition at line 1656 of file crlgen_lex.c.

#define yyless (   n)
Value:
do \
              { \
              /* Undo effects of setting up yytext. */ \
              yytext[yyleng] = yy_hold_char; \
              yy_c_buf_p = yytext + n; \
              yy_hold_char = *yy_c_buf_p; \
              *yy_c_buf_p = '\0'; \
              yyleng = n; \
              } \
       while ( 0 )

Definition at line 1656 of file crlgen_lex.c.

#define yymore ( )    (yy_more_flag = 1)

Definition at line 433 of file crlgen_lex.c.

Definition at line 88 of file crlgen_lex.c.

Definition at line 564 of file crlgen_lex.c.

Definition at line 270 of file crlgen_lex.c.


Typedef Documentation

Definition at line 101 of file crlgen_lex.c.

typedef unsigned char YY_CHAR

Definition at line 266 of file crlgen_lex.c.

typedef unsigned int yy_size_t

Definition at line 143 of file crlgen_lex.c.

typedef int yy_state_type

Definition at line 268 of file crlgen_lex.c.


Function Documentation

Definition at line 1760 of file crlgen_lex.c.

Definition at line 1755 of file crlgen_lex.c.

SECStatus CRLGEN_StartCrlGen ( CRLGENGeneratorData *  parserCtlData)

Definition at line 1766 of file crlgen_lex.c.

{
    SECStatus rv;

    PR_Lock(parserInvocationLock);

    parserStatus = SECSuccess;
    parserData = parserCtlData;
    src = parserCtlData->src;

    rv = yylex();

    PR_Unlock(parserInvocationLock);

    return rv;
}
if ( yy_init  )

Definition at line 612 of file crlgen_lex.c.

              {
              yy_init = 0;

#ifdef YY_USER_INIT
              YY_USER_INIT;
#endif

              if ( ! yy_start )
                     yy_start = 1; /* first start state */

              if ( ! yyin )
                     yyin = stdin;

              if ( ! yyout )
                     yyout = stdout;

              if ( ! yy_current_buffer )
                     yy_current_buffer =
                            yy_create_buffer( yyin, YY_BUF_SIZE );

              yy_load_buffer_state();
              }

Here is the call graph for this function:

static int input ( ) [static]

Definition at line 1252 of file crlgen_lex.c.

       {
       int c;

       *yy_c_buf_p = yy_hold_char;

       if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
              {
              /* yy_c_buf_p now points to the character we want to return.
               * If this occurs *before* the EOB characters, then it's a
               * 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] )
                     /* This was really a NUL. */
                     *yy_c_buf_p = '\0';

              else
                     { /* need more input */
                     int offset = yy_c_buf_p - yytext_ptr;
                     ++yy_c_buf_p;

                     switch ( yy_get_next_buffer() )
                            {
                            case EOB_ACT_LAST_MATCH:
                                   /* This happens because yy_g_n_b()
                                    * sees that we've accumulated a
                                    * token and flags that we need to
                                    * try matching the token before
                                    * proceeding.  But for input(),
                                    * there's no matching to consider.
                                    * So convert the EOB_ACT_LAST_MATCH
                                    * to EOB_ACT_END_OF_FILE.
                                    */

                                   /* Reset buffer status. */
                                   yyrestart( yyin );

                                   /* fall through */

                            case EOB_ACT_END_OF_FILE:
                                   {
                                   if ( yywrap() )
                                          return EOF;

                                   if ( ! yy_did_buffer_switch_on_eof )
                                          YY_NEW_FILE;
#ifdef __cplusplus
                                   return yyinput();
#else
                                   return input();
#endif
                                   }

                            case EOB_ACT_CONTINUE_SCAN:
                                   yy_c_buf_p = yytext_ptr + offset;
                                   break;
                            }
                     }
              }

       c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
       *yy_c_buf_p = '\0';  /* preserve yytext */
       yy_hold_char = *++yy_c_buf_p;

       yy_current_buffer->yy_at_bol = (c == '\n');

       return c;
       }

Here is the call graph for this function:

while ( )

Definition at line 636 of file crlgen_lex.c.

              {
              yy_more_len = 0;
              if ( yy_more_flag )
                     {
                     yy_more_len = yy_c_buf_p - yytext_ptr;
                     yy_more_flag = 0;
                     }
              yy_cp = yy_c_buf_p;

              /* Support of yytext. */
              *yy_cp = yy_hold_char;

              /* yy_bp points to the position in yy_ch_buf of the start of
               * the current run.
               */
              yy_bp = yy_cp;

              yy_current_state = yy_start;
              yy_current_state += YY_AT_BOL();
yy_match:
              do
                     {
                     register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
                     if ( yy_accept[yy_current_state] )
                            {
                            yy_last_accepting_state = yy_current_state;
                            yy_last_accepting_cpos = yy_cp;
                            }
                     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                            {
                            yy_current_state = (int) yy_def[yy_current_state];
                            if ( yy_current_state >= 67 )
                                   yy_c = yy_meta[(unsigned int) yy_c];
                            }
                     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                     ++yy_cp;
                     }
              while ( yy_base[yy_current_state] != 205 );

yy_find_action:
              yy_act = yy_accept[yy_current_state];
              if ( yy_act == 0 )
                     { /* have to back up */
                     yy_cp = yy_last_accepting_cpos;
                     yy_current_state = yy_last_accepting_state;
                     yy_act = yy_accept[yy_current_state];
                     }

              YY_DO_BEFORE_ACTION;


do_action:    /* This label is used only to access EOF actions. */


              switch ( yy_act )
       { /* beginning of action switch */
                     case 0: /* must back up */
                     /* undo the effects of YY_DO_BEFORE_ACTION */
                     *yy_cp = yy_hold_char;
                     yy_cp = yy_last_accepting_cpos;
                     yy_current_state = yy_last_accepting_state;
                     goto yy_find_action;

case 1:
YY_RULE_SETUP
#line 30 "crlgen_lex_orig.l"
{
parserStatus = crlgen_setNextData(parserData, yytext, CRLGEN_TYPE_ZDATE);
if (parserStatus != SECSuccess)
    return parserStatus;
}
       YY_BREAK
case 2:
YY_RULE_SETUP
#line 36 "crlgen_lex_orig.l"
{
parserStatus = crlgen_setNextData(parserData, yytext, CRLGEN_TYPE_DIGIT);
if (parserStatus != SECSuccess)
    return parserStatus;
}
       YY_BREAK
case 3:
YY_RULE_SETUP
#line 42 "crlgen_lex_orig.l"
{
parserStatus = crlgen_setNextData(parserData, yytext, CRLGEN_TYPE_DIGIT_RANGE);
if (parserStatus != SECSuccess)
    return parserStatus;
}
       YY_BREAK
case 4:
YY_RULE_SETUP
#line 48 "crlgen_lex_orig.l"
{
parserStatus = crlgen_setNextData(parserData, yytext, CRLGEN_TYPE_OID);
if (parserStatus != SECSuccess)
    return parserStatus;
}
       YY_BREAK
case 5:
YY_RULE_SETUP
#line 54 "crlgen_lex_orig.l"
{
parserStatus = crlgen_createNewLangStruct(parserData, CRLGEN_ISSUER_CONTEXT);
if (parserStatus != SECSuccess)
    return parserStatus;
}
       YY_BREAK
case 6:
YY_RULE_SETUP
#line 60 "crlgen_lex_orig.l"
{
parserStatus = crlgen_createNewLangStruct(parserData, CRLGEN_UPDATE_CONTEXT);
if (parserStatus != SECSuccess)
    return parserStatus;
}
       YY_BREAK
case 7:
YY_RULE_SETUP
#line 65 "crlgen_lex_orig.l"
{
parserStatus = crlgen_createNewLangStruct(parserData, CRLGEN_NEXT_UPDATE_CONTEXT);
if (parserStatus != SECSuccess)
    return parserStatus;
}
       YY_BREAK
case 8:
YY_RULE_SETUP
#line 71 "crlgen_lex_orig.l"
{
parserStatus = crlgen_createNewLangStruct(parserData, CRLGEN_CHANGE_RANGE_CONTEXT);
if (parserStatus != SECSuccess)
    return parserStatus;
}
       YY_BREAK
case 9:
YY_RULE_SETUP
#line 77 "crlgen_lex_orig.l"
{
if (strcmp(yytext, "addcert") == 0) {
    parserStatus = crlgen_createNewLangStruct(parserData,
                                    CRLGEN_ADD_CERT_CONTEXT);
    if (parserStatus != SECSuccess)
        return parserStatus;
} else if (strcmp(yytext, "rmcert") == 0) {
    parserStatus = crlgen_createNewLangStruct(parserData,
                                    CRLGEN_RM_CERT_CONTEXT);
    if (parserStatus != SECSuccess)
        return parserStatus;
} else if (strcmp(yytext, "addext") == 0) {
    parserStatus = crlgen_createNewLangStruct(parserData,
                                    CRLGEN_ADD_EXTENSION_CONTEXT);
    if (parserStatus != SECSuccess)
        return parserStatus;
} else {
    parserStatus = crlgen_setNextData(parserData, yytext, CRLGEN_TYPE_ID);
    if (parserStatus != SECSuccess)
        return parserStatus;
}
}
       YY_BREAK
case 10:
YY_RULE_SETUP
#line 100 "crlgen_lex_orig.l"

       YY_BREAK
case 11:
YY_RULE_SETUP
#line 102 "crlgen_lex_orig.l"
{
if (yytext[yyleng-1] == '\\') {
    yymore();
} else {
    register int c;
    c = input();
    if (c != '\"') {
        printf( "Error: Line ending \" is missing:  %c\n", c);
        unput(c);
    } else {
        parserStatus = crlgen_setNextData(parserData, yytext + 1,
                                          CRLGEN_TYPE_STRING);
        if (parserStatus != SECSuccess)
            return parserStatus;
    }
}
}
       YY_BREAK
case 12:
YY_RULE_SETUP
#line 120 "crlgen_lex_orig.l"
{
parserStatus = crlgen_setNextData(parserData, yytext, CRLGEN_TYPE_STRING);
if (parserStatus != SECSuccess)
    return parserStatus;
}
       YY_BREAK
case 13:
YY_RULE_SETUP
#line 128 "crlgen_lex_orig.l"
/* eat up one-line comments */ {}
       YY_BREAK
case 14:
YY_RULE_SETUP
#line 130 "crlgen_lex_orig.l"
{}
       YY_BREAK
case 15:
YY_RULE_SETUP
#line 132 "crlgen_lex_orig.l"
{
parserStatus = crlgen_updateCrl(parserData);
if (parserStatus != SECSuccess)
    return parserStatus;
}
       YY_BREAK
case 16:
YY_RULE_SETUP
#line 138 "crlgen_lex_orig.l"
{
    fprintf(stderr, "Syntax error at line %d: unknown token %s\n",
            parserData->parsedLineNum, yytext);
    return SECFailure;
}
       YY_BREAK
case 17:
YY_RULE_SETUP
#line 144 "crlgen_lex_orig.l"
ECHO;
       YY_BREAK
case YY_STATE_EOF(INITIAL):
       yyterminate();

       case YY_END_OF_BUFFER:
              {
              /* Amount of text matched not including the EOB char. */
              int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;

              /* Undo the effects of YY_DO_BEFORE_ACTION. */
              *yy_cp = yy_hold_char;
              YY_RESTORE_YY_MORE_OFFSET

              if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
                     {
                     /* We're scanning a new file or input source.  It's
                      * possible that this happened because the user
                      * just pointed yyin at a new source and called
                      * yylex().  If so, then we have to assure
                      * consistency between yy_current_buffer and our
                      * globals.  Here is the right place to do so, because
                      * this is the first action (other than possibly a
                      * back-up) that will match for the new input source.
                      */
                     yy_n_chars = yy_current_buffer->yy_n_chars;
                     yy_current_buffer->yy_input_file = yyin;
                     yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
                     }

              /* Note that here we test for yy_c_buf_p "<=" to the position
               * of the first EOB in the buffer, since yy_c_buf_p will
               * already have been incremented past the NUL character
               * (since all states make transitions on EOB to the
               * end-of-buffer state).  Contrast this with the test
               * in input().
               */
              if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
                     { /* This was really a NUL. */
                     yy_state_type yy_next_state;

                     yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;

                     yy_current_state = yy_get_previous_state();

                     /* Okay, we're now positioned to make the NUL
                      * transition.  We couldn't have
                      * yy_get_previous_state() go ahead and do it
                      * for us because it doesn't know how to deal
                      * with the possibility of jamming (and we don't
                      * want to build jamming into it because then it
                      * will run more slowly).
                      */

                     yy_next_state = yy_try_NUL_trans( yy_current_state );

                     yy_bp = yytext_ptr + YY_MORE_ADJ;

                     if ( yy_next_state )
                            {
                            /* Consume the NUL. */
                            yy_cp = ++yy_c_buf_p;
                            yy_current_state = yy_next_state;
                            goto yy_match;
                            }

                     else
                            {
                            yy_cp = yy_c_buf_p;
                            goto yy_find_action;
                            }
                     }

              else switch ( yy_get_next_buffer() )
                     {
                     case EOB_ACT_END_OF_FILE:
                            {
                            yy_did_buffer_switch_on_eof = 0;

                            if ( yywrap() )
                                   {
                                   /* Note: because we've taken care in
                                    * yy_get_next_buffer() to have set up
                                    * yytext, we can now set up
                                    * yy_c_buf_p so that if some total
                                    * hoser (like flex itself) wants to
                                    * call the scanner after we return the
                                    * YY_NULL, it'll still work - another
                                    * YY_NULL will get returned.
                                    */
                                   yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;

                                   yy_act = YY_STATE_EOF(YY_START);
                                   goto do_action;
                                   }

                            else
                                   {
                                   if ( ! yy_did_buffer_switch_on_eof )
                                          YY_NEW_FILE;
                                   }
                            break;
                            }

                     case EOB_ACT_CONTINUE_SCAN:
                            yy_c_buf_p =
                                   yytext_ptr + yy_amount_of_matched_text;

                            yy_current_state = yy_get_previous_state();

                            yy_cp = yy_c_buf_p;
                            yy_bp = yytext_ptr + YY_MORE_ADJ;
                            goto yy_match;

                     case EOB_ACT_LAST_MATCH:
                            yy_c_buf_p =
                            &yy_current_buffer->yy_ch_buf[yy_n_chars];

                            yy_current_state = yy_get_previous_state();

                            yy_cp = yy_c_buf_p;
                            yy_bp = yytext_ptr + YY_MORE_ADJ;
                            goto yy_find_action;
                     }
              break;
              }

       default:
              YY_FATAL_ERROR(
                     "fatal flex scanner internal error--no action found" );
       } /* end of action switch */
              } /* end of scanning one token */

Here is the call graph for this function:

YY_BUFFER_STATE yy_create_buffer ( FILE file,
int  size 
)

Definition at line 1384 of file crlgen_lex.c.

       {
       YY_BUFFER_STATE b;

       b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
       if ( ! b )
              YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

       b->yy_buf_size = size;

       /* yy_ch_buf has to be 2 characters longer than the size given because
        * we need to put in 2 end-of-buffer characters.
        */
       b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
       if ( ! b->yy_ch_buf )
              YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

       b->yy_is_our_buffer = 1;

       yy_init_buffer( b, file );

       return b;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1415 of file crlgen_lex.c.

       {
       if ( ! b )
              return;

       if ( b == yy_current_buffer )
              yy_current_buffer = (YY_BUFFER_STATE) 0;

       if ( b->yy_is_our_buffer )
              yy_flex_free( (void *) b->yy_ch_buf );

       yy_flex_free( (void *) b );
       }

Here is the call graph for this function:

static void yy_fatal_error ( msg  ) [static]

Definition at line 1643 of file crlgen_lex.c.

       {
       (void) fprintf( stderr, "%s\n", msg );
       exit( YY_EXIT_FAILURE );
       }

Here is the call graph for this function:

static void* yy_flex_alloc ( yy_size_t  size) [static]

Definition at line 1707 of file crlgen_lex.c.

       {
       return (void *) malloc( size );
       }

Here is the caller graph for this function:

static void yy_flex_free ( void ptr) [static]

Definition at line 1735 of file crlgen_lex.c.

       {
       free( ptr );
       }

Here is the caller graph for this function:

static void* yy_flex_realloc ( void ptr,
yy_size_t  size 
) [static]

Definition at line 1717 of file crlgen_lex.c.

       {
       /* The cast to (char *) in the following accommodates both
        * implementations that use char* generic pointers, and those
        * that use void* generic pointers.  It works with the latter
        * because both ANSI C and C++ allow castless assignment from
        * any pointer type to void*, and deal with argument conversions
        * as though doing an assignment.
        */
       return (void *) realloc( (char *) ptr, size );
       }

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1463 of file crlgen_lex.c.

       {
       if ( ! b )
              return;

       b->yy_n_chars = 0;

       /* We always need two end-of-buffer characters.  The first causes
        * a transition to the end-of-buffer state.  The second causes
        * a jam in that state.
        */
       b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
       b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

       b->yy_buf_pos = &b->yy_ch_buf[0];

       b->yy_at_bol = 1;
       b->yy_buffer_status = YY_BUFFER_NEW;

       if ( b == yy_current_buffer )
              yy_load_buffer_state();
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static int yy_get_next_buffer ( ) [static]

Definition at line 1007 of file crlgen_lex.c.

       {
       register char *dest = yy_current_buffer->yy_ch_buf;
       register char *source = yytext_ptr;
       register int number_to_move, i;
       int ret_val;

       if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
              YY_FATAL_ERROR(
              "fatal flex scanner internal error--end of buffer missed" );

       if ( yy_current_buffer->yy_fill_buffer == 0 )
              { /* Don't try to fill the buffer, so this is an EOF. */
              if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
                     {
                     /* We matched a single character, the EOB, so
                      * treat this as a final EOF.
                      */
                     return EOB_ACT_END_OF_FILE;
                     }

              else
                     {
                     /* We matched some text prior to the EOB, first
                      * process it.
                      */
                     return EOB_ACT_LAST_MATCH;
                     }
              }

       /* Try to read more data. */

       /* First move last chars to start of buffer. */
       number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;

       for ( i = 0; i < number_to_move; ++i )
              *(dest++) = *(source++);

       if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
              /* don't do the read, it's not guaranteed to return an EOF,
               * just force an EOF
               */
              yy_current_buffer->yy_n_chars = yy_n_chars = 0;

       else
              {
              int num_to_read =
                     yy_current_buffer->yy_buf_size - number_to_move - 1;

              while ( num_to_read <= 0 )
                     { /* 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 */
                     YY_BUFFER_STATE b = yy_current_buffer;

                     int yy_c_buf_p_offset =
                            (int) (yy_c_buf_p - b->yy_ch_buf);

                     if ( b->yy_is_our_buffer )
                            {
                            int new_size = b->yy_buf_size * 2;

                            if ( new_size <= 0 )
                                   b->yy_buf_size += b->yy_buf_size / 8;
                            else
                                   b->yy_buf_size *= 2;

                            b->yy_ch_buf = (char *)
                                   /* Include room in for 2 EOB chars. */
                                   yy_flex_realloc( (void *) b->yy_ch_buf,
                                                  b->yy_buf_size + 2 );
                            }
                     else
                            /* Can't grow it, we don't own it. */
                            b->yy_ch_buf = 0;

                     if ( ! b->yy_ch_buf )
                            YY_FATAL_ERROR(
                            "fatal error - scanner input buffer overflow" );

                     yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

                     num_to_read = yy_current_buffer->yy_buf_size -
                                          number_to_move - 1;
#endif
                     }

              if ( num_to_read > YY_READ_BUF_SIZE )
                     num_to_read = YY_READ_BUF_SIZE;

              /* Read in more data. */
              YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
                     yy_n_chars, num_to_read );

              yy_current_buffer->yy_n_chars = yy_n_chars;
              }

       if ( yy_n_chars == 0 )
              {
              if ( number_to_move == YY_MORE_ADJ )
                     {
                     ret_val = EOB_ACT_END_OF_FILE;
                     yyrestart( yyin );
                     }

              else
                     {
                     ret_val = EOB_ACT_LAST_MATCH;
                     yy_current_buffer->yy_buffer_status =
                            YY_BUFFER_EOF_PENDING;
                     }
              }

       else
              ret_val = EOB_ACT_CONTINUE_SCAN;

       yy_n_chars += number_to_move;
       yy_current_buffer->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;

       yytext_ptr = &yy_current_buffer->yy_ch_buf[0];

       return ret_val;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static yy_state_type yy_get_previous_state ( ) [static]

Definition at line 1139 of file crlgen_lex.c.

       {
       register yy_state_type yy_current_state;
       register char *yy_cp;

       yy_current_state = yy_start;
       yy_current_state += YY_AT_BOL();

       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);
              if ( yy_accept[yy_current_state] )
                     {
                     yy_last_accepting_state = yy_current_state;
                     yy_last_accepting_cpos = yy_cp;
                     }
              while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                     {
                     yy_current_state = (int) yy_def[yy_current_state];
                     if ( yy_current_state >= 67 )
                            yy_c = yy_meta[(unsigned int) yy_c];
                     }
              yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
              }

       return yy_current_state;
       }

Here is the caller graph for this function:

void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE file 
)

Definition at line 1436 of file crlgen_lex.c.

       {
       yy_flush_buffer( b );

       b->yy_input_file = file;
       b->yy_fill_buffer = 1;

#if YY_ALWAYS_INTERACTIVE
       b->yy_is_interactive = 1;
#else
#if YY_NEVER_INTERACTIVE
       b->yy_is_interactive = 0;
#else
       b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
#endif
#endif
       }

Here is the call graph for this function:

Definition at line 1371 of file crlgen_lex.c.

Here is the caller graph for this function:

void yyrestart YY_PROTO ( (FILE *input_file)  )
static int input YY_PROTO ( (void )
static void* yy_flex_alloc YY_PROTO ( (yy_size_t ) [static]
static void* yy_flex_realloc YY_PROTO ( (void *, yy_size_t ) [static]
static void yy_flex_free YY_PROTO ( (void *)  ) [static]
static yy_state_type yy_try_NUL_trans YY_PROTO ( (yy_state_type current_state)  ) [static]
static void yy_fatal_error YY_PROTO ( (yyconst char msg[])  ) [static]
static void yyunput YY_PROTO ( (int c, char *buf_ptr)  ) [static]
YY_BUFFER_STATE yy_scan_buffer ( char *  base,
yy_size_t  size 
)

Definition at line 1494 of file crlgen_lex.c.

       {
       YY_BUFFER_STATE b;

       if ( size < 2 ||
            base[size-2] != YY_END_OF_BUFFER_CHAR ||
            base[size-1] != YY_END_OF_BUFFER_CHAR )
              /* They forgot to leave room for the EOB's. */
              return 0;

       b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
       if ( ! b )
              YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

       b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
       b->yy_buf_pos = b->yy_ch_buf = base;
       b->yy_is_our_buffer = 0;
       b->yy_input_file = 0;
       b->yy_n_chars = b->yy_buf_size;
       b->yy_is_interactive = 0;
       b->yy_at_bol = 1;
       b->yy_fill_buffer = 0;
       b->yy_buffer_status = YY_BUFFER_NEW;

       yy_switch_to_buffer( b );

       return b;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

YY_BUFFER_STATE yy_scan_bytes ( yyconst char *  bytes,
int  len 
)

Definition at line 1549 of file crlgen_lex.c.

       {
       YY_BUFFER_STATE b;
       char *buf;
       yy_size_t n;
       int i;

       /* Get memory for full buffer, including space for trailing EOB's. */
       n = len + 2;
       buf = (char *) yy_flex_alloc( n );
       if ( ! buf )
              YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

       for ( i = 0; i < len; ++i )
              buf[i] = bytes[i];

       buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;

       b = yy_scan_buffer( buf, n );
       if ( ! b )
              YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

       /* It's okay to grow etc. this buffer, and we should throw it
        * away when we're done.
        */
       b->yy_is_our_buffer = 1;

       return b;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1532 of file crlgen_lex.c.

       {
       int len;
       for ( len = 0; yy_str[len]; ++len )
              ;

       return yy_scan_bytes( yy_str, len );
       }

Here is the call graph for this function:

Definition at line 1341 of file crlgen_lex.c.

       {
       if ( yy_current_buffer == new_buffer )
              return;

       if ( yy_current_buffer )
              {
              /* Flush out information for old buffer. */
              *yy_c_buf_p = yy_hold_char;
              yy_current_buffer->yy_buf_pos = yy_c_buf_p;
              yy_current_buffer->yy_n_chars = yy_n_chars;
              }

       yy_current_buffer = new_buffer;
       yy_load_buffer_state();

       /* We don't actually know whether we did this switch during
        * EOF (yywrap()) processing, but the only time this flag
        * is looked at is after yywrap() is called, so it's safe
        * to go ahead and always set it.
        */
       yy_did_buffer_switch_on_eof = 1;
       }

Here is the call graph for this function:

Here is the caller graph for this function:

static yy_state_type yy_try_NUL_trans ( yy_state_type  yy_current_state) [static]

Definition at line 1177 of file crlgen_lex.c.

       {
       register int yy_is_jam;
       register char *yy_cp = yy_c_buf_p;

       register YY_CHAR yy_c = 1;
       if ( yy_accept[yy_current_state] )
              {
              yy_last_accepting_state = yy_current_state;
              yy_last_accepting_cpos = yy_cp;
              }
       while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
              {
              yy_current_state = (int) yy_def[yy_current_state];
              if ( yy_current_state >= 67 )
                     yy_c = yy_meta[(unsigned int) yy_c];
              }
       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
       yy_is_jam = (yy_current_state == 66);

       return yy_is_jam ? 0 : yy_current_state;
       }

Here is the caller graph for this function:

void yyrestart ( FILE input_file)

Definition at line 1326 of file crlgen_lex.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static void yyunput ( int  c,
char *  yy_bp 
) [static]

Definition at line 1207 of file crlgen_lex.c.

       {
       register char *yy_cp = yy_c_buf_p;

       /* undo effects of setting up yytext */
       *yy_cp = yy_hold_char;

       if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
              { /* need to shift things up to make room */
              /* +2 for EOB chars. */
              register int number_to_move = yy_n_chars + 2;
              register char *dest = &yy_current_buffer->yy_ch_buf[
                                   yy_current_buffer->yy_buf_size + 2];
              register char *source =
                            &yy_current_buffer->yy_ch_buf[number_to_move];

              while ( source > yy_current_buffer->yy_ch_buf )
                     *--dest = *--source;

              yy_cp += (int) (dest - source);
              yy_bp += (int) (dest - source);
              yy_current_buffer->yy_n_chars =
                     yy_n_chars = yy_current_buffer->yy_buf_size;

              if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
                     YY_FATAL_ERROR( "flex scanner push-back overflow" );
              }

       *--yy_cp = (char) c;


       yytext_ptr = yy_bp;
       yy_hold_char = *yy_cp;
       yy_c_buf_p = yy_cp;
       }
int yywrap ( )

Definition at line 1783 of file crlgen_lex.c.

{return 1;}

Variable Documentation

CRLGENGeneratorData* parserData [static]

Definition at line 444 of file crlgen_lex.c.

Definition at line 1753 of file crlgen_lex.c.

Definition at line 443 of file crlgen_lex.c.

PRFileDesc* src [static]

Definition at line 445 of file crlgen_lex.c.

yyconst short int yy_accept[67] [static]
Initial value:
    {   0,
        0,    0,   18,   16,   14,   15,   16,   11,   12,    2,
       10,    9,    9,    9,    9,    9,   13,   14,   15,   11,
       12,    0,   12,    2,    9,    9,    9,    9,    9,   13,
        3,    4,    2,    9,    9,    9,    9,    2,    9,    9,
        9,    9,    2,    2,    9,    9,    8,    9,    2,    5,
        9,    6,    2,    9,    2,    9,    2,    9,    2,    7,
        2,    2,    2,    2,    1,    0
    }

Definition at line 290 of file crlgen_lex.c.

register int yy_act

Definition at line 606 of file crlgen_lex.c.

yyconst short int yy_base[72] [static]
Initial value:
    {   0,
        0,  149,  154,  205,  138,  205,  103,    0,    0,   23,
      205,   29,   30,   31,   32,   33,    0,   99,  205,    0,
        0,    0,   50,   55,   34,   61,   41,   63,   64,    0,
        0,    0,   79,   65,   68,   86,   66,   99,  105,   88,
      106,   90,  118,   76,  107,  110,   89,  125,   43,   91,
      127,  128,  138,  144,  113,  129,  154,  160,  160,  130,
      172,  166,  177,  144,    0,  205,  190,  192,  194,  199,
       76
    }

Definition at line 340 of file crlgen_lex.c.

register char * yy_bp = NULL

Definition at line 605 of file crlgen_lex.c.

char* yy_c_buf_p = (char *) 0 [static]

Definition at line 221 of file crlgen_lex.c.

yyconst short int yy_chk[235] [static]
Initial value:
    {   0,
        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,    1,    1,   10,
       10,   10,   10,   10,   10,   10,   12,   13,   14,   15,
       16,   25,   12,   13,   14,   15,   16,   25,   27,   15,
       14,   49,   49,   49,   27,   13,   16,   23,   23,   23,
       23,   23,   23,   24,   24,   24,   24,   24,   26,   27,
       28,   29,   34,   37,   26,   35,   28,   29,   34,   37,
       71,   35,   29,   37,   44,   28,   26,   33,   33,   33,
       33,   33,   34,   36,   35,   40,   47,   42,   50,   36,

       18,   40,   47,   42,   50,    7,   36,   38,   38,   38,
       38,   38,   39,   41,   45,   40,   42,   46,   39,   41,
       45,   55,   55,   46,   39,   41,   43,   43,   43,   43,
       43,   45,   48,   46,   51,   52,   56,   60,   48,    5,
       51,   52,   56,   60,   48,   51,   53,   53,   53,   53,
       53,   54,   64,    3,    2,   56,    0,   54,    0,    0,
       64,   54,   57,   57,   57,   57,   57,   58,   59,   59,
       59,   59,    0,   58,   62,   62,   62,   62,    0,   58,
       61,   61,   61,   61,   61,   63,   63,   63,   63,   63,
       67,   67,    0,   67,   67,   68,   68,   69,   69,   70,

        0,   70,   70,   70,   66,   66,   66,   66,   66,   66,
       66,   66,   66,   66,   66,   66,   66,   66,   66,   66,
       66,   66,   66,   66,   66,   66,   66,   66,   66,   66,
       66,   66,   66,   66
    }

Definition at line 394 of file crlgen_lex.c.

register char* yy_cp = NULL

Definition at line 605 of file crlgen_lex.c.

Definition at line 203 of file crlgen_lex.c.

Definition at line 604 of file crlgen_lex.c.

yyconst short int yy_def[72] [static]
Initial value:
    {   0,
       66,    1,   66,   66,   66,   66,   66,   67,   68,   68,
       66,   69,   69,   69,   69,   69,   70,   66,   66,   67,
       68,   71,   68,   10,   69,   69,   69,   69,   69,   70,
       71,   23,   10,   69,   69,   69,   69,   10,   69,   69,
       69,   69,   10,   38,   69,   69,   69,   69,   38,   69,
       69,   69,   38,   69,   38,   69,   38,   69,   38,   69,
       38,   38,   38,   38,   68,    0,   66,   66,   66,   66,
       66
    }

Definition at line 352 of file crlgen_lex.c.

Definition at line 228 of file crlgen_lex.c.

yyconst int yy_ec[256] [static]

Definition at line 301 of file crlgen_lex.c.

char yy_hold_char [static]

Definition at line 213 of file crlgen_lex.c.

int yy_init = 1 [static]

Definition at line 222 of file crlgen_lex.c.

char* yy_last_accepting_cpos [static]

Definition at line 425 of file crlgen_lex.c.

Definition at line 424 of file crlgen_lex.c.

yyconst int yy_meta[30] [static]
Initial value:
    {   0,
        1,    1,    2,    1,    3,    1,    1,    4,    5,    5,
        5,    5,    5,    4,    1,    4,    4,    4,    4,    4,
        4,    4,    4,    4,    4,    4,    4,    4,    4
    }

Definition at line 333 of file crlgen_lex.c.

int yy_more_flag = 0 [static]

Definition at line 431 of file crlgen_lex.c.

int yy_more_len = 0 [static]

Definition at line 432 of file crlgen_lex.c.

int yy_n_chars [static]

Definition at line 215 of file crlgen_lex.c.

yyconst short int yy_nxt[235] [static]
Initial value:
    {   0,
        4,    5,    6,    7,    8,    4,    4,    9,   10,   10,
       10,   10,   10,    9,   11,   12,   12,   12,   12,   12,
       12,   13,   14,   12,   15,   12,   12,   16,   12,   22,
       23,   24,   24,   24,   24,   24,   21,   21,   21,   21,
       21,   21,   21,   21,   21,   21,   21,   21,   21,   28,
       27,   53,   53,   53,   21,   26,   29,   32,   32,   32,
       32,   32,   32,   33,   33,   33,   33,   33,   21,   35,
       21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
       31,   21,   37,   42,   44,   36,   34,   38,   38,   38,
       38,   38,   39,   21,   40,   21,   21,   21,   21,   21,

       18,   21,   21,   21,   21,   19,   41,   43,   44,   44,
       44,   44,   21,   21,   21,   46,   48,   21,   21,   21,
       21,   57,   57,   21,   45,   47,   49,   49,   49,   49,
       49,   50,   21,   51,   21,   21,   21,   21,   21,   18,
       21,   21,   21,   21,   52,   54,   55,   55,   55,   55,
       55,   21,   44,   66,   17,   58,   66,   21,   66,   66,
       65,   56,   59,   59,   59,   59,   59,   21,   61,   61,
       61,   61,   66,   21,   63,   63,   63,   63,   66,   60,
       62,   62,   62,   62,   62,   64,   64,   64,   64,   64,
       20,   20,   66,   20,   20,   21,   21,   25,   25,   30,

       66,   30,   30,   30,    3,   66,   66,   66,   66,   66,
       66,   66,   66,   66,   66,   66,   66,   66,   66,   66,
       66,   66,   66,   66,   66,   66,   66,   66,   66,   66,
       66,   66,   66,   66
    }

Definition at line 364 of file crlgen_lex.c.

int yy_start = 0 [static]

Definition at line 223 of file crlgen_lex.c.

FILE* yyin = (FILE *) 0

Definition at line 267 of file crlgen_lex.c.

Definition at line 218 of file crlgen_lex.c.

FILE * yyout = (FILE *) 0

Definition at line 267 of file crlgen_lex.c.

char* yytext

Definition at line 436 of file crlgen_lex.c.