Back to index

python-biopython  1.60
lex.yy.c
Go to the documentation of this file.
00001 /* A lexical scanner generated by flex */
00002 
00003 /* Scanner skeleton version:
00004  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
00005  */
00006 
00007 #define FLEX_SCANNER
00008 #define YY_FLEX_MAJOR_VERSION 2
00009 #define YY_FLEX_MINOR_VERSION 5
00010 
00011 #include <stdio.h>
00012 
00013 
00014 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
00015 #ifdef c_plusplus
00016 #ifndef __cplusplus
00017 #define __cplusplus
00018 #endif
00019 #endif
00020 
00021 
00022 #ifdef __cplusplus
00023 
00024 #include <stdlib.h>
00025 #include <unistd.h>
00026 
00027 /* Use prototypes in function declarations. */
00028 #define YY_USE_PROTOS
00029 
00030 /* The "const" storage-class-modifier is valid. */
00031 #define YY_USE_CONST
00032 
00033 #else  /* ! __cplusplus */
00034 
00035 #if __STDC__
00036 
00037 #define YY_USE_PROTOS
00038 #define YY_USE_CONST
00039 
00040 #endif /* __STDC__ */
00041 #endif /* ! __cplusplus */
00042 
00043 #ifdef __TURBOC__
00044  #pragma warn -rch
00045  #pragma warn -use
00046 #include <io.h>
00047 #include <stdlib.h>
00048 #define YY_USE_CONST
00049 #define YY_USE_PROTOS
00050 #endif
00051 
00052 #ifdef YY_USE_CONST
00053 #define yyconst const
00054 #else
00055 #define yyconst
00056 #endif
00057 
00058 
00059 #ifdef YY_USE_PROTOS
00060 #define YY_PROTO(proto) proto
00061 #else
00062 #define YY_PROTO(proto) ()
00063 #endif
00064 
00065 /* Returned upon end-of-file. */
00066 #define YY_NULL 0
00067 
00068 /* Promotes a possibly negative, possibly signed char to an unsigned
00069  * integer for use as an array index.  If the signed char is negative,
00070  * we want to instead treat it as an 8-bit unsigned char, hence the
00071  * double cast.
00072  */
00073 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00074 
00075 /* Enter a start condition.  This macro really ought to take a parameter,
00076  * but we do it the disgusting crufty way forced on us by the ()-less
00077  * definition of BEGIN.
00078  */
00079 #define BEGIN yy_start = 1 + 2 *
00080 
00081 /* Translate the current start state into a value that can be later handed
00082  * to BEGIN to return to the state.  The YYSTATE alias is for lex
00083  * compatibility.
00084  */
00085 #define YY_START ((yy_start - 1) / 2)
00086 #define YYSTATE YY_START
00087 
00088 /* Action number for EOF rule of a given start state. */
00089 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00090 
00091 /* Special action meaning "start processing a new file". */
00092 #define YY_NEW_FILE yyrestart( yyin )
00093 
00094 #define YY_END_OF_BUFFER_CHAR 0
00095 
00096 /* Size of default input buffer. */
00097 #define YY_BUF_SIZE 16384
00098 
00099 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00100 
00101 extern int yyleng;
00102 extern FILE *yyin, *yyout;
00103 
00104 #define EOB_ACT_CONTINUE_SCAN 0
00105 #define EOB_ACT_END_OF_FILE 1
00106 #define EOB_ACT_LAST_MATCH 2
00107 
00108 /* The funky do-while in the following #define is used to turn the definition
00109  * int a single C statement (which needs a semi-colon terminator).  This
00110  * avoids problems with code like:
00111  *
00112  *     if ( condition_holds )
00113  *            yyless( 5 );
00114  *     else
00115  *            do_something_else();
00116  *
00117  * Prior to using the do-while the compiler would get upset at the
00118  * "else" because it interpreted the "if" statement as being all
00119  * done when it reached the ';' after the yyless() call.
00120  */
00121 
00122 /* Return all but the first 'n' matched characters back to the input stream. */
00123 
00124 #define yyless(n) \
00125        do \
00126               { \
00127               /* Undo effects of setting up yytext. */ \
00128               *yy_cp = yy_hold_char; \
00129               YY_RESTORE_YY_MORE_OFFSET \
00130               yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
00131               YY_DO_BEFORE_ACTION; /* set up yytext again */ \
00132               } \
00133        while ( 0 )
00134 
00135 #define unput(c) yyunput( c, yytext_ptr )
00136 
00137 /* The following is because we cannot portably get our hands on size_t
00138  * (without autoconf's help, which isn't available because we want
00139  * flex-generated scanners to compile on their own).
00140  */
00141 typedef unsigned int yy_size_t;
00142 
00143 
00144 struct yy_buffer_state
00145        {
00146        FILE *yy_input_file;
00147 
00148        char *yy_ch_buf;            /* input buffer */
00149        char *yy_buf_pos;           /* current position in input buffer */
00150 
00151        /* Size of input buffer in bytes, not including room for EOB
00152         * characters.
00153         */
00154        yy_size_t yy_buf_size;
00155 
00156        /* Number of characters read into yy_ch_buf, not including EOB
00157         * characters.
00158         */
00159        int yy_n_chars;
00160 
00161        /* Whether we "own" the buffer - i.e., we know we created it,
00162         * and can realloc() it to grow it, and should free() it to
00163         * delete it.
00164         */
00165        int yy_is_our_buffer;
00166 
00167        /* Whether this is an "interactive" input source; if so, and
00168         * if we're using stdio for input, then we want to use getc()
00169         * instead of fread(), to make sure we stop fetching input after
00170         * each newline.
00171         */
00172        int yy_is_interactive;
00173 
00174        /* Whether we're considered to be at the beginning of a line.
00175         * If so, '^' rules will be active on the next match, otherwise
00176         * not.
00177         */
00178        int yy_at_bol;
00179 
00180        /* Whether to try to fill the input buffer when we reach the
00181         * end of it.
00182         */
00183        int yy_fill_buffer;
00184 
00185        int yy_buffer_status;
00186 #define YY_BUFFER_NEW 0
00187 #define YY_BUFFER_NORMAL 1
00188        /* When an EOF's been seen but there's still some text to process
00189         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
00190         * shouldn't try reading from the input source any more.  We might
00191         * still have a bunch of tokens to match, though, because of
00192         * possible backing-up.
00193         *
00194         * When we actually see the EOF, we change the status to "new"
00195         * (via yyrestart()), so that the user can continue scanning by
00196         * just pointing yyin at a new input file.
00197         */
00198 #define YY_BUFFER_EOF_PENDING 2
00199        };
00200 
00201 static YY_BUFFER_STATE yy_current_buffer = 0;
00202 
00203 /* We provide macros for accessing buffer states in case in the
00204  * future we want to put the buffer states in a more general
00205  * "scanner state".
00206  */
00207 #define YY_CURRENT_BUFFER yy_current_buffer
00208 
00209 
00210 /* yy_hold_char holds the character lost when yytext is formed. */
00211 static char yy_hold_char;
00212 
00213 static int yy_n_chars;             /* number of characters read into yy_ch_buf */
00214 
00215 
00216 int yyleng;
00217 
00218 /* Points to current character in buffer. */
00219 static char *yy_c_buf_p = (char *) 0;
00220 static int yy_init = 1;            /* whether we need to initialize */
00221 static int yy_start = 0;    /* start state number */
00222 
00223 /* Flag which is used to allow yywrap()'s to do buffer switches
00224  * instead of setting up a fresh yyin.  A bit of a hack ...
00225  */
00226 static int yy_did_buffer_switch_on_eof;
00227 
00228 void yyrestart YY_PROTO(( FILE *input_file ));
00229 
00230 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
00231 void yy_load_buffer_state YY_PROTO(( void ));
00232 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
00233 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
00234 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
00235 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
00236 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
00237 
00238 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
00239 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
00240 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
00241 
00242 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
00243 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
00244 static void yy_flex_free YY_PROTO(( void * ));
00245 
00246 #define yy_new_buffer yy_create_buffer
00247 
00248 #define yy_set_interactive(is_interactive) \
00249        { \
00250        if ( ! yy_current_buffer ) \
00251               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
00252        yy_current_buffer->yy_is_interactive = is_interactive; \
00253        }
00254 
00255 #define yy_set_bol(at_bol) \
00256        { \
00257        if ( ! yy_current_buffer ) \
00258               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
00259        yy_current_buffer->yy_at_bol = at_bol; \
00260        }
00261 
00262 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
00263 
00264 
00265 #define yywrap() 1
00266 #define YY_SKIP_YYWRAP
00267 typedef unsigned char YY_CHAR;
00268 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
00269 typedef int yy_state_type;
00270 extern char *yytext;
00271 #define yytext_ptr yytext
00272 
00273 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
00274 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
00275 static int yy_get_next_buffer YY_PROTO(( void ));
00276 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
00277 
00278 /* Done after the current pattern has been matched and before the
00279  * corresponding action - sets up yytext.
00280  */
00281 #define YY_DO_BEFORE_ACTION \
00282        yytext_ptr = yy_bp; \
00283        yyleng = (int) (yy_cp - yy_bp); \
00284        yy_hold_char = *yy_cp; \
00285        *yy_cp = '\0'; \
00286        yy_c_buf_p = yy_cp;
00287 
00288 #define YY_NUM_RULES 10
00289 #define YY_END_OF_BUFFER 11
00290 static yyconst short int yy_accept[42] =
00291     {   0,
00292         0,    0,   11,    8,    9,    8,    8,    8,    8,    8,
00293         8,    8,    8,    9,    8,    0,    6,    8,    0,    1,
00294         8,    0,    7,    8,    8,    2,    8,    0,    0,    6,
00295         7,    8,    8,    0,    5,    8,    8,    8,    3,    4,
00296         0
00297     } ;
00298 
00299 static yyconst int yy_ec[256] =
00300     {   0,
00301         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
00302         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00303         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00304         1,    2,    1,    4,    5,    1,    1,    1,    6,    1,
00305         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00306         1,    1,    1,    1,    1,    1,    1,    1,    7,    1,
00307         1,    1,    1,    1,    8,    1,    1,    9,    1,    1,
00308         1,    1,    1,    1,    1,   10,    1,    1,   11,   12,
00309         1,    1,    1,   13,    1,    1,    1,    1,    1,    1,
00310         1,    1,    1,    1,   14,    1,    8,    1,    1,    9,
00311 
00312         1,    1,    1,    1,    1,    1,    1,   10,    1,    1,
00313        11,   12,    1,    1,    1,   13,    1,    1,    1,    1,
00314         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00315         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00316         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00317         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00318         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00319         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00320         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00321         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00322 
00323         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00324         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00325         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00326         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00327         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00328         1,    1,    1,    1,    1
00329     } ;
00330 
00331 static yyconst int yy_meta[15] =
00332     {   0,
00333         1,    2,    3,    1,    1,    1,    1,    1,    1,    1,
00334         1,    1,    1,    1
00335     } ;
00336 
00337 static yyconst short int yy_base[54] =
00338     {   0,
00339         0,   69,   75,    0,   13,   15,   18,   16,   66,   62,
00340         0,   21,    0,   23,   25,   68,    0,   28,   68,   77,
00341        26,   64,    0,   56,   57,    0,   31,   64,   59,   77,
00342        77,   57,   52,   60,   77,   48,   47,    0,    0,    0,
00343        77,   59,   34,   36,   39,   58,   41,   44,   46,   49,
00344        51,   54,   57
00345     } ;
00346 
00347 static yyconst short int yy_def[54] =
00348     {   0,
00349        41,    1,   41,   42,   41,   43,   44,   45,   42,   42,
00350        46,   47,   42,   41,   43,   48,   42,   44,   49,   41,
00351        45,   50,   42,   42,   42,   46,   47,   51,   52,   41,
00352        41,   42,   42,   51,   41,   42,   42,   53,   42,   53,
00353         0,   41,   41,   41,   41,   41,   41,   41,   41,   41,
00354        41,   41,   41
00355     } ;
00356 
00357 static yyconst short int yy_nxt[92] =
00358     {   0,
00359         4,    5,    5,    6,    7,    8,    4,    4,    9,   10,
00360         4,    4,    4,   11,   14,   14,   16,   22,   17,   19,
00361        20,   23,   28,   29,   14,   14,   16,   22,   17,   19,
00362        20,   23,   28,   29,   15,   15,   18,   18,   18,   21,
00363        21,   27,   27,   27,   16,   16,   19,   19,   19,   22,
00364        22,   28,   28,   28,   34,   34,   34,   40,   26,   13,
00365        39,   38,   29,   37,   36,   35,   29,   33,   32,   31,
00366        20,   30,   25,   24,   41,   12,    3,   41,   41,   41,
00367        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
00368        41
00369 
00370     } ;
00371 
00372 static yyconst short int yy_chk[92] =
00373     {   0,
00374         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00375         1,    1,    1,    1,    5,    5,    6,    8,    6,    7,
00376         7,    8,   12,   12,   14,   14,   15,   21,   15,   18,
00377        18,   21,   27,   27,   43,   43,   44,   44,   44,   45,
00378        45,   47,   47,   47,   48,   48,   49,   49,   49,   50,
00379        50,   51,   51,   51,   52,   52,   52,   53,   46,   42,
00380        37,   36,   34,   33,   32,   29,   28,   25,   24,   22,
00381        19,   16,   10,    9,    3,    2,   41,   41,   41,   41,
00382        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
00383        41
00384 
00385     } ;
00386 
00387 static yy_state_type yy_last_accepting_state;
00388 static char *yy_last_accepting_cpos;
00389 
00390 /* The intent behind this definition is that it'll catch
00391  * any uses of REJECT which flex missed.
00392  */
00393 #define REJECT reject_used_but_not_detected
00394 #define yymore() yymore_used_but_not_detected
00395 #define YY_MORE_ADJ 0
00396 #define YY_RESTORE_YY_MORE_OFFSET
00397 char *yytext;
00398 #line 1 "mmcif.lex"
00399 #define INITIAL 0
00400 /* 
00401 Number code of the tokens is:
00402 
00403 NAME                 (eg. _entity.id)            1
00404 LOOP                 (loop_)                                   2
00405 DATA                 (eg. data_something) 3
00406 SEMICOLON            (eg. ;value\n;)                    4      
00407 DOUBLE QUOTE  (eg. "value")               5
00408 SINGLE QUOTE  (eg. 'value')               6
00409 FREE                 (eg. value )                7
00410 
00411 */
00412 #line 413 "lex.yy.c"
00413 
00414 /* Macros after this point can all be overridden by user definitions in
00415  * section 1.
00416  */
00417 
00418 #ifndef YY_SKIP_YYWRAP
00419 #ifdef __cplusplus
00420 extern "C" int yywrap YY_PROTO(( void ));
00421 #else
00422 extern int yywrap YY_PROTO(( void ));
00423 #endif
00424 #endif
00425 
00426 #ifndef YY_NO_UNPUT
00427 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
00428 #endif
00429 
00430 #ifndef yytext_ptr
00431 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
00432 #endif
00433 
00434 #ifdef YY_NEED_STRLEN
00435 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
00436 #endif
00437 
00438 #ifndef YY_NO_INPUT
00439 #ifdef __cplusplus
00440 static int yyinput YY_PROTO(( void ));
00441 #else
00442 static int input YY_PROTO(( void ));
00443 #endif
00444 #endif
00445 
00446 #if YY_STACK_USED
00447 static int yy_start_stack_ptr = 0;
00448 static int yy_start_stack_depth = 0;
00449 static int *yy_start_stack = 0;
00450 #ifndef YY_NO_PUSH_STATE
00451 static void yy_push_state YY_PROTO(( int new_state ));
00452 #endif
00453 #ifndef YY_NO_POP_STATE
00454 static void yy_pop_state YY_PROTO(( void ));
00455 #endif
00456 #ifndef YY_NO_TOP_STATE
00457 static int yy_top_state YY_PROTO(( void ));
00458 #endif
00459 
00460 #else
00461 #define YY_NO_PUSH_STATE 1
00462 #define YY_NO_POP_STATE 1
00463 #define YY_NO_TOP_STATE 1
00464 #endif
00465 
00466 #ifdef YY_MALLOC_DECL
00467 YY_MALLOC_DECL
00468 #else
00469 #if __STDC__
00470 #ifndef __cplusplus
00471 #include <stdlib.h>
00472 #endif
00473 #else
00474 /* Just try to get by without declaring the routines.  This will fail
00475  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
00476  * or sizeof(void*) != sizeof(int).
00477  */
00478 #endif
00479 #endif
00480 
00481 /* Amount of stuff to slurp up with each read. */
00482 #ifndef YY_READ_BUF_SIZE
00483 #define YY_READ_BUF_SIZE 8192
00484 #endif
00485 
00486 /* Copy whatever the last rule matched to the standard output. */
00487 
00488 #ifndef ECHO
00489 /* This used to be an fputs(), but since the string might contain NUL's,
00490  * we now use fwrite().
00491  */
00492 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
00493 #endif
00494 
00495 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
00496  * is returned in "result".
00497  */
00498 #ifndef YY_INPUT
00499 #define YY_INPUT(buf,result,max_size) \
00500        if ( yy_current_buffer->yy_is_interactive ) \
00501               { \
00502               int c = '*', n; \
00503               for ( n = 0; n < max_size && \
00504                           (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00505                      buf[n] = (char) c; \
00506               if ( c == '\n' ) \
00507                      buf[n++] = (char) c; \
00508               if ( c == EOF && ferror( yyin ) ) \
00509                      YY_FATAL_ERROR( "input in flex scanner failed" ); \
00510               result = n; \
00511               } \
00512        else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
00513                 && ferror( yyin ) ) \
00514               YY_FATAL_ERROR( "input in flex scanner failed" );
00515 #endif
00516 
00517 /* No semi-colon after return; correct usage is to write "yyterminate();" -
00518  * we don't want an extra ';' after the "return" because that will cause
00519  * some compilers to complain about unreachable statements.
00520  */
00521 #ifndef yyterminate
00522 #define yyterminate() return YY_NULL
00523 #endif
00524 
00525 /* Number of entries by which start-condition stack grows. */
00526 #ifndef YY_START_STACK_INCR
00527 #define YY_START_STACK_INCR 25
00528 #endif
00529 
00530 /* Report a fatal error. */
00531 #ifndef YY_FATAL_ERROR
00532 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
00533 #endif
00534 
00535 /* Default declaration of generated scanner - a define so the user can
00536  * easily add parameters.
00537  */
00538 #ifndef YY_DECL
00539 #define YY_DECL int yylex YY_PROTO(( void ))
00540 #endif
00541 
00542 /* Code executed at the beginning of each rule, after yytext and yyleng
00543  * have been set up.
00544  */
00545 #ifndef YY_USER_ACTION
00546 #define YY_USER_ACTION
00547 #endif
00548 
00549 /* Code executed at the end of each rule. */
00550 #ifndef YY_BREAK
00551 #define YY_BREAK break;
00552 #endif
00553 
00554 #define YY_RULE_SETUP \
00555        if ( yyleng > 0 ) \
00556               yy_current_buffer->yy_at_bol = \
00557                             (yytext[yyleng - 1] == '\n'); \
00558        YY_USER_ACTION
00559 
00560 YY_DECL
00561        {
00562        register yy_state_type yy_current_state;
00563        register char *yy_cp, *yy_bp;
00564        register int yy_act;
00565 
00566 #line 24 "mmcif.lex"
00567 
00568 
00569 #line 570 "lex.yy.c"
00570 
00571        if ( yy_init )
00572               {
00573               yy_init = 0;
00574 
00575 #ifdef YY_USER_INIT
00576               YY_USER_INIT;
00577 #endif
00578 
00579               if ( ! yy_start )
00580                      yy_start = 1; /* first start state */
00581 
00582               if ( ! yyin )
00583                      yyin = stdin;
00584 
00585               if ( ! yyout )
00586                      yyout = stdout;
00587 
00588               if ( ! yy_current_buffer )
00589                      yy_current_buffer =
00590                             yy_create_buffer( yyin, YY_BUF_SIZE );
00591 
00592               yy_load_buffer_state();
00593               }
00594 
00595        while ( 1 )          /* loops until end-of-file is reached */
00596               {
00597               yy_cp = yy_c_buf_p;
00598 
00599               /* Support of yytext. */
00600               *yy_cp = yy_hold_char;
00601 
00602               /* yy_bp points to the position in yy_ch_buf of the start of
00603                * the current run.
00604                */
00605               yy_bp = yy_cp;
00606 
00607               yy_current_state = yy_start;
00608               yy_current_state += YY_AT_BOL();
00609 yy_match:
00610               do
00611                      {
00612                      register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00613                      if ( yy_accept[yy_current_state] )
00614                             {
00615                             yy_last_accepting_state = yy_current_state;
00616                             yy_last_accepting_cpos = yy_cp;
00617                             }
00618                      while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00619                             {
00620                             yy_current_state = (int) yy_def[yy_current_state];
00621                             if ( yy_current_state >= 42 )
00622                                    yy_c = yy_meta[(unsigned int) yy_c];
00623                             }
00624                      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00625                      ++yy_cp;
00626                      }
00627               while ( yy_base[yy_current_state] != 77 );
00628 
00629 yy_find_action:
00630               yy_act = yy_accept[yy_current_state];
00631               if ( yy_act == 0 )
00632                      { /* have to back up */
00633                      yy_cp = yy_last_accepting_cpos;
00634                      yy_current_state = yy_last_accepting_state;
00635                      yy_act = yy_accept[yy_current_state];
00636                      }
00637 
00638               YY_DO_BEFORE_ACTION;
00639 
00640 
00641 do_action:    /* This label is used only to access EOF actions. */
00642 
00643 
00644               switch ( yy_act )
00645        { /* beginning of action switch */
00646                      case 0: /* must back up */
00647                      /* undo the effects of YY_DO_BEFORE_ACTION */
00648                      *yy_cp = yy_hold_char;
00649                      yy_cp = yy_last_accepting_cpos;
00650                      yy_current_state = yy_last_accepting_state;
00651                      goto yy_find_action;
00652 
00653 case 1:
00654 YY_RULE_SETUP
00655 #line 26 "mmcif.lex"
00656 /* ignore */                
00657        YY_BREAK
00658 case 2:
00659 YY_RULE_SETUP
00660 #line 28 "mmcif.lex"
00661 { return 1; } 
00662        YY_BREAK
00663 case 3:
00664 YY_RULE_SETUP
00665 #line 30 "mmcif.lex"
00666 { return 2; }                             
00667        YY_BREAK
00668 case 4:
00669 YY_RULE_SETUP
00670 #line 32 "mmcif.lex"
00671 { return 3;   }
00672        YY_BREAK
00673 case 5:
00674 YY_RULE_SETUP
00675 #line 34 "mmcif.lex"
00676 { return 4; } 
00677        YY_BREAK
00678 case 6:
00679 YY_RULE_SETUP
00680 #line 36 "mmcif.lex"
00681 { return 5; } 
00682        YY_BREAK
00683 case 7:
00684 YY_RULE_SETUP
00685 #line 38 "mmcif.lex"
00686 { return 6; } 
00687        YY_BREAK
00688 case 8:
00689 YY_RULE_SETUP
00690 #line 40 "mmcif.lex"
00691 { return 7; } 
00692        YY_BREAK
00693 case 9:
00694 YY_RULE_SETUP
00695 #line 42 "mmcif.lex"
00696 /* ignore */
00697        YY_BREAK
00698 case 10:
00699 YY_RULE_SETUP
00700 #line 44 "mmcif.lex"
00701 ECHO;
00702        YY_BREAK
00703 #line 704 "lex.yy.c"
00704 case YY_STATE_EOF(INITIAL):
00705        yyterminate();
00706 
00707        case YY_END_OF_BUFFER:
00708               {
00709               /* Amount of text matched not including the EOB char. */
00710               int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
00711 
00712               /* Undo the effects of YY_DO_BEFORE_ACTION. */
00713               *yy_cp = yy_hold_char;
00714               YY_RESTORE_YY_MORE_OFFSET
00715 
00716               if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
00717                      {
00718                      /* We're scanning a new file or input source.  It's
00719                       * possible that this happened because the user
00720                       * just pointed yyin at a new source and called
00721                       * yylex().  If so, then we have to assure
00722                       * consistency between yy_current_buffer and our
00723                       * globals.  Here is the right place to do so, because
00724                       * this is the first action (other than possibly a
00725                       * back-up) that will match for the new input source.
00726                       */
00727                      yy_n_chars = yy_current_buffer->yy_n_chars;
00728                      yy_current_buffer->yy_input_file = yyin;
00729                      yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
00730                      }
00731 
00732               /* Note that here we test for yy_c_buf_p "<=" to the position
00733                * of the first EOB in the buffer, since yy_c_buf_p will
00734                * already have been incremented past the NUL character
00735                * (since all states make transitions on EOB to the
00736                * end-of-buffer state).  Contrast this with the test
00737                * in input().
00738                */
00739               if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
00740                      { /* This was really a NUL. */
00741                      yy_state_type yy_next_state;
00742 
00743                      yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
00744 
00745                      yy_current_state = yy_get_previous_state();
00746 
00747                      /* Okay, we're now positioned to make the NUL
00748                       * transition.  We couldn't have
00749                       * yy_get_previous_state() go ahead and do it
00750                       * for us because it doesn't know how to deal
00751                       * with the possibility of jamming (and we don't
00752                       * want to build jamming into it because then it
00753                       * will run more slowly).
00754                       */
00755 
00756                      yy_next_state = yy_try_NUL_trans( yy_current_state );
00757 
00758                      yy_bp = yytext_ptr + YY_MORE_ADJ;
00759 
00760                      if ( yy_next_state )
00761                             {
00762                             /* Consume the NUL. */
00763                             yy_cp = ++yy_c_buf_p;
00764                             yy_current_state = yy_next_state;
00765                             goto yy_match;
00766                             }
00767 
00768                      else
00769                             {
00770                             yy_cp = yy_c_buf_p;
00771                             goto yy_find_action;
00772                             }
00773                      }
00774 
00775               else switch ( yy_get_next_buffer() )
00776                      {
00777                      case EOB_ACT_END_OF_FILE:
00778                             {
00779                             yy_did_buffer_switch_on_eof = 0;
00780 
00781                             if ( yywrap() )
00782                                    {
00783                                    /* Note: because we've taken care in
00784                                     * yy_get_next_buffer() to have set up
00785                                     * yytext, we can now set up
00786                                     * yy_c_buf_p so that if some total
00787                                     * hoser (like flex itself) wants to
00788                                     * call the scanner after we return the
00789                                     * YY_NULL, it'll still work - another
00790                                     * YY_NULL will get returned.
00791                                     */
00792                                    yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
00793 
00794                                    yy_act = YY_STATE_EOF(YY_START);
00795                                    goto do_action;
00796                                    }
00797 
00798                             else
00799                                    {
00800                                    if ( ! yy_did_buffer_switch_on_eof )
00801                                           YY_NEW_FILE;
00802                                    }
00803                             break;
00804                             }
00805 
00806                      case EOB_ACT_CONTINUE_SCAN:
00807                             yy_c_buf_p =
00808                                    yytext_ptr + yy_amount_of_matched_text;
00809 
00810                             yy_current_state = yy_get_previous_state();
00811 
00812                             yy_cp = yy_c_buf_p;
00813                             yy_bp = yytext_ptr + YY_MORE_ADJ;
00814                             goto yy_match;
00815 
00816                      case EOB_ACT_LAST_MATCH:
00817                             yy_c_buf_p =
00818                             &yy_current_buffer->yy_ch_buf[yy_n_chars];
00819 
00820                             yy_current_state = yy_get_previous_state();
00821 
00822                             yy_cp = yy_c_buf_p;
00823                             yy_bp = yytext_ptr + YY_MORE_ADJ;
00824                             goto yy_find_action;
00825                      }
00826               break;
00827               }
00828 
00829        default:
00830               YY_FATAL_ERROR(
00831                      "fatal flex scanner internal error--no action found" );
00832        } /* end of action switch */
00833               } /* end of scanning one token */
00834        } /* end of yylex */
00835 
00836 
00837 /* yy_get_next_buffer - try to read in a new buffer
00838  *
00839  * Returns a code representing an action:
00840  *     EOB_ACT_LAST_MATCH -
00841  *     EOB_ACT_CONTINUE_SCAN - continue scanning from current position
00842  *     EOB_ACT_END_OF_FILE - end of file
00843  */
00844 
00845 static int yy_get_next_buffer()
00846        {
00847        register char *dest = yy_current_buffer->yy_ch_buf;
00848        register char *source = yytext_ptr;
00849        register int number_to_move, i;
00850        int ret_val;
00851 
00852        if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
00853               YY_FATAL_ERROR(
00854               "fatal flex scanner internal error--end of buffer missed" );
00855 
00856        if ( yy_current_buffer->yy_fill_buffer == 0 )
00857               { /* Don't try to fill the buffer, so this is an EOF. */
00858               if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
00859                      {
00860                      /* We matched a single character, the EOB, so
00861                       * treat this as a final EOF.
00862                       */
00863                      return EOB_ACT_END_OF_FILE;
00864                      }
00865 
00866               else
00867                      {
00868                      /* We matched some text prior to the EOB, first
00869                       * process it.
00870                       */
00871                      return EOB_ACT_LAST_MATCH;
00872                      }
00873               }
00874 
00875        /* Try to read more data. */
00876 
00877        /* First move last chars to start of buffer. */
00878        number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
00879 
00880        for ( i = 0; i < number_to_move; ++i )
00881               *(dest++) = *(source++);
00882 
00883        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
00884               /* don't do the read, it's not guaranteed to return an EOF,
00885                * just force an EOF
00886                */
00887               yy_current_buffer->yy_n_chars = yy_n_chars = 0;
00888 
00889        else
00890               {
00891               int num_to_read =
00892                      yy_current_buffer->yy_buf_size - number_to_move - 1;
00893 
00894               while ( num_to_read <= 0 )
00895                      { /* Not enough room in the buffer - grow it. */
00896 #ifdef YY_USES_REJECT
00897                      YY_FATAL_ERROR(
00898 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
00899 #else
00900 
00901                      /* just a shorter name for the current buffer */
00902                      YY_BUFFER_STATE b = yy_current_buffer;
00903 
00904                      int yy_c_buf_p_offset =
00905                             (int) (yy_c_buf_p - b->yy_ch_buf);
00906 
00907                      if ( b->yy_is_our_buffer )
00908                             {
00909                             int new_size = b->yy_buf_size * 2;
00910 
00911                             if ( new_size <= 0 )
00912                                    b->yy_buf_size += b->yy_buf_size / 8;
00913                             else
00914                                    b->yy_buf_size *= 2;
00915 
00916                             b->yy_ch_buf = (char *)
00917                                    /* Include room in for 2 EOB chars. */
00918                                    yy_flex_realloc( (void *) b->yy_ch_buf,
00919                                                   b->yy_buf_size + 2 );
00920                             }
00921                      else
00922                             /* Can't grow it, we don't own it. */
00923                             b->yy_ch_buf = 0;
00924 
00925                      if ( ! b->yy_ch_buf )
00926                             YY_FATAL_ERROR(
00927                             "fatal error - scanner input buffer overflow" );
00928 
00929                      yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
00930 
00931                      num_to_read = yy_current_buffer->yy_buf_size -
00932                                           number_to_move - 1;
00933 #endif
00934                      }
00935 
00936               if ( num_to_read > YY_READ_BUF_SIZE )
00937                      num_to_read = YY_READ_BUF_SIZE;
00938 
00939               /* Read in more data. */
00940               YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
00941                      yy_n_chars, num_to_read );
00942 
00943               yy_current_buffer->yy_n_chars = yy_n_chars;
00944               }
00945 
00946        if ( yy_n_chars == 0 )
00947               {
00948               if ( number_to_move == YY_MORE_ADJ )
00949                      {
00950                      ret_val = EOB_ACT_END_OF_FILE;
00951                      yyrestart( yyin );
00952                      }
00953 
00954               else
00955                      {
00956                      ret_val = EOB_ACT_LAST_MATCH;
00957                      yy_current_buffer->yy_buffer_status =
00958                             YY_BUFFER_EOF_PENDING;
00959                      }
00960               }
00961 
00962        else
00963               ret_val = EOB_ACT_CONTINUE_SCAN;
00964 
00965        yy_n_chars += number_to_move;
00966        yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
00967        yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
00968 
00969        yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
00970 
00971        return ret_val;
00972        }
00973 
00974 
00975 /* yy_get_previous_state - get the state just before the EOB char was reached */
00976 
00977 static yy_state_type yy_get_previous_state()
00978        {
00979        register yy_state_type yy_current_state;
00980        register char *yy_cp;
00981 
00982        yy_current_state = yy_start;
00983        yy_current_state += YY_AT_BOL();
00984 
00985        for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
00986               {
00987               register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
00988               if ( yy_accept[yy_current_state] )
00989                      {
00990                      yy_last_accepting_state = yy_current_state;
00991                      yy_last_accepting_cpos = yy_cp;
00992                      }
00993               while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00994                      {
00995                      yy_current_state = (int) yy_def[yy_current_state];
00996                      if ( yy_current_state >= 42 )
00997                             yy_c = yy_meta[(unsigned int) yy_c];
00998                      }
00999               yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01000               }
01001 
01002        return yy_current_state;
01003        }
01004 
01005 
01006 /* yy_try_NUL_trans - try to make a transition on the NUL character
01007  *
01008  * synopsis
01009  *     next_state = yy_try_NUL_trans( current_state );
01010  */
01011 
01012 #ifdef YY_USE_PROTOS
01013 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
01014 #else
01015 static yy_state_type yy_try_NUL_trans( yy_current_state )
01016 yy_state_type yy_current_state;
01017 #endif
01018        {
01019        register int yy_is_jam;
01020        register char *yy_cp = yy_c_buf_p;
01021 
01022        register YY_CHAR yy_c = 1;
01023        if ( yy_accept[yy_current_state] )
01024               {
01025               yy_last_accepting_state = yy_current_state;
01026               yy_last_accepting_cpos = yy_cp;
01027               }
01028        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01029               {
01030               yy_current_state = (int) yy_def[yy_current_state];
01031               if ( yy_current_state >= 42 )
01032                      yy_c = yy_meta[(unsigned int) yy_c];
01033               }
01034        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01035        yy_is_jam = (yy_current_state == 41);
01036 
01037        return yy_is_jam ? 0 : yy_current_state;
01038        }
01039 
01040 
01041 #ifndef YY_NO_UNPUT
01042 #ifdef YY_USE_PROTOS
01043 static void yyunput( int c, register char *yy_bp )
01044 #else
01045 static void yyunput( c, yy_bp )
01046 int c;
01047 register char *yy_bp;
01048 #endif
01049        {
01050        register char *yy_cp = yy_c_buf_p;
01051 
01052        /* undo effects of setting up yytext */
01053        *yy_cp = yy_hold_char;
01054 
01055        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01056               { /* need to shift things up to make room */
01057               /* +2 for EOB chars. */
01058               register int number_to_move = yy_n_chars + 2;
01059               register char *dest = &yy_current_buffer->yy_ch_buf[
01060                                    yy_current_buffer->yy_buf_size + 2];
01061               register char *source =
01062                             &yy_current_buffer->yy_ch_buf[number_to_move];
01063 
01064               while ( source > yy_current_buffer->yy_ch_buf )
01065                      *--dest = *--source;
01066 
01067               yy_cp += (int) (dest - source);
01068               yy_bp += (int) (dest - source);
01069               yy_current_buffer->yy_n_chars =
01070                      yy_n_chars = yy_current_buffer->yy_buf_size;
01071 
01072               if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01073                      YY_FATAL_ERROR( "flex scanner push-back overflow" );
01074               }
01075 
01076        *--yy_cp = (char) c;
01077 
01078 
01079        yytext_ptr = yy_bp;
01080        yy_hold_char = *yy_cp;
01081        yy_c_buf_p = yy_cp;
01082        }
01083 #endif /* ifndef YY_NO_UNPUT */
01084 
01085 
01086 #ifdef __cplusplus
01087 static int yyinput()
01088 #else
01089 static int input()
01090 #endif
01091        {
01092        int c;
01093 
01094        *yy_c_buf_p = yy_hold_char;
01095 
01096        if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
01097               {
01098               /* yy_c_buf_p now points to the character we want to return.
01099                * If this occurs *before* the EOB characters, then it's a
01100                * valid NUL; if not, then we've hit the end of the buffer.
01101                */
01102               if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01103                      /* This was really a NUL. */
01104                      *yy_c_buf_p = '\0';
01105 
01106               else
01107                      { /* need more input */
01108                      int offset = yy_c_buf_p - yytext_ptr;
01109                      ++yy_c_buf_p;
01110 
01111                      switch ( yy_get_next_buffer() )
01112                             {
01113                             case EOB_ACT_LAST_MATCH:
01114                                    /* This happens because yy_g_n_b()
01115                                     * sees that we've accumulated a
01116                                     * token and flags that we need to
01117                                     * try matching the token before
01118                                     * proceeding.  But for input(),
01119                                     * there's no matching to consider.
01120                                     * So convert the EOB_ACT_LAST_MATCH
01121                                     * to EOB_ACT_END_OF_FILE.
01122                                     */
01123 
01124                                    /* Reset buffer status. */
01125                                    yyrestart( yyin );
01126 
01127                                    /* fall through */
01128 
01129                             case EOB_ACT_END_OF_FILE:
01130                                    {
01131                                    if ( yywrap() )
01132                                           return EOF;
01133 
01134                                    if ( ! yy_did_buffer_switch_on_eof )
01135                                           YY_NEW_FILE;
01136 #ifdef __cplusplus
01137                                    return yyinput();
01138 #else
01139                                    return input();
01140 #endif
01141                                    }
01142 
01143                             case EOB_ACT_CONTINUE_SCAN:
01144                                    yy_c_buf_p = yytext_ptr + offset;
01145                                    break;
01146                             }
01147                      }
01148               }
01149 
01150        c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
01151        *yy_c_buf_p = '\0';  /* preserve yytext */
01152        yy_hold_char = *++yy_c_buf_p;
01153 
01154        yy_current_buffer->yy_at_bol = (c == '\n');
01155 
01156        return c;
01157        }
01158 
01159 
01160 #ifdef YY_USE_PROTOS
01161 void yyrestart( FILE *input_file )
01162 #else
01163 void yyrestart( input_file )
01164 FILE *input_file;
01165 #endif
01166        {
01167        if ( ! yy_current_buffer )
01168               yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
01169 
01170        yy_init_buffer( yy_current_buffer, input_file );
01171        yy_load_buffer_state();
01172        }
01173 
01174 
01175 #ifdef YY_USE_PROTOS
01176 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
01177 #else
01178 void yy_switch_to_buffer( new_buffer )
01179 YY_BUFFER_STATE new_buffer;
01180 #endif
01181        {
01182        if ( yy_current_buffer == new_buffer )
01183               return;
01184 
01185        if ( yy_current_buffer )
01186               {
01187               /* Flush out information for old buffer. */
01188               *yy_c_buf_p = yy_hold_char;
01189               yy_current_buffer->yy_buf_pos = yy_c_buf_p;
01190               yy_current_buffer->yy_n_chars = yy_n_chars;
01191               }
01192 
01193        yy_current_buffer = new_buffer;
01194        yy_load_buffer_state();
01195 
01196        /* We don't actually know whether we did this switch during
01197         * EOF (yywrap()) processing, but the only time this flag
01198         * is looked at is after yywrap() is called, so it's safe
01199         * to go ahead and always set it.
01200         */
01201        yy_did_buffer_switch_on_eof = 1;
01202        }
01203 
01204 
01205 #ifdef YY_USE_PROTOS
01206 void yy_load_buffer_state( void )
01207 #else
01208 void yy_load_buffer_state()
01209 #endif
01210        {
01211        yy_n_chars = yy_current_buffer->yy_n_chars;
01212        yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
01213        yyin = yy_current_buffer->yy_input_file;
01214        yy_hold_char = *yy_c_buf_p;
01215        }
01216 
01217 
01218 #ifdef YY_USE_PROTOS
01219 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
01220 #else
01221 YY_BUFFER_STATE yy_create_buffer( file, size )
01222 FILE *file;
01223 int size;
01224 #endif
01225        {
01226        YY_BUFFER_STATE b;
01227 
01228        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
01229        if ( ! b )
01230               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01231 
01232        b->yy_buf_size = size;
01233 
01234        /* yy_ch_buf has to be 2 characters longer than the size given because
01235         * we need to put in 2 end-of-buffer characters.
01236         */
01237        b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
01238        if ( ! b->yy_ch_buf )
01239               YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01240 
01241        b->yy_is_our_buffer = 1;
01242 
01243        yy_init_buffer( b, file );
01244 
01245        return b;
01246        }
01247 
01248 
01249 #ifdef YY_USE_PROTOS
01250 void yy_delete_buffer( YY_BUFFER_STATE b )
01251 #else
01252 void yy_delete_buffer( b )
01253 YY_BUFFER_STATE b;
01254 #endif
01255        {
01256        if ( ! b )
01257               return;
01258 
01259        if ( b == yy_current_buffer )
01260               yy_current_buffer = (YY_BUFFER_STATE) 0;
01261 
01262        if ( b->yy_is_our_buffer )
01263               yy_flex_free( (void *) b->yy_ch_buf );
01264 
01265        yy_flex_free( (void *) b );
01266        }
01267 
01268 
01269 #ifndef YY_ALWAYS_INTERACTIVE
01270 #ifndef YY_NEVER_INTERACTIVE
01271 extern int isatty YY_PROTO(( int ));
01272 #endif
01273 #endif
01274 
01275 #ifdef YY_USE_PROTOS
01276 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
01277 #else
01278 void yy_init_buffer( b, file )
01279 YY_BUFFER_STATE b;
01280 FILE *file;
01281 #endif
01282 
01283 
01284        {
01285        yy_flush_buffer( b );
01286 
01287        b->yy_input_file = file;
01288        b->yy_fill_buffer = 1;
01289 
01290 #if YY_ALWAYS_INTERACTIVE
01291        b->yy_is_interactive = 1;
01292 #else
01293 #if YY_NEVER_INTERACTIVE
01294        b->yy_is_interactive = 0;
01295 #else
01296        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
01297 #endif
01298 #endif
01299        }
01300 
01301 
01302 #ifdef YY_USE_PROTOS
01303 void yy_flush_buffer( YY_BUFFER_STATE b )
01304 #else
01305 void yy_flush_buffer( b )
01306 YY_BUFFER_STATE b;
01307 #endif
01308 
01309        {
01310        if ( ! b )
01311               return;
01312 
01313        b->yy_n_chars = 0;
01314 
01315        /* We always need two end-of-buffer characters.  The first causes
01316         * a transition to the end-of-buffer state.  The second causes
01317         * a jam in that state.
01318         */
01319        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01320        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01321 
01322        b->yy_buf_pos = &b->yy_ch_buf[0];
01323 
01324        b->yy_at_bol = 1;
01325        b->yy_buffer_status = YY_BUFFER_NEW;
01326 
01327        if ( b == yy_current_buffer )
01328               yy_load_buffer_state();
01329        }
01330 
01331 
01332 #ifndef YY_NO_SCAN_BUFFER
01333 #ifdef YY_USE_PROTOS
01334 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
01335 #else
01336 YY_BUFFER_STATE yy_scan_buffer( base, size )
01337 char *base;
01338 yy_size_t size;
01339 #endif
01340        {
01341        YY_BUFFER_STATE b;
01342 
01343        if ( size < 2 ||
01344             base[size-2] != YY_END_OF_BUFFER_CHAR ||
01345             base[size-1] != YY_END_OF_BUFFER_CHAR )
01346               /* They forgot to leave room for the EOB's. */
01347               return 0;
01348 
01349        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
01350        if ( ! b )
01351               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
01352 
01353        b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
01354        b->yy_buf_pos = b->yy_ch_buf = base;
01355        b->yy_is_our_buffer = 0;
01356        b->yy_input_file = 0;
01357        b->yy_n_chars = b->yy_buf_size;
01358        b->yy_is_interactive = 0;
01359        b->yy_at_bol = 1;
01360        b->yy_fill_buffer = 0;
01361        b->yy_buffer_status = YY_BUFFER_NEW;
01362 
01363        yy_switch_to_buffer( b );
01364 
01365        return b;
01366        }
01367 #endif
01368 
01369 
01370 #ifndef YY_NO_SCAN_STRING
01371 #ifdef YY_USE_PROTOS
01372 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
01373 #else
01374 YY_BUFFER_STATE yy_scan_string( yy_str )
01375 yyconst char *yy_str;
01376 #endif
01377        {
01378        int len;
01379        for ( len = 0; yy_str[len]; ++len )
01380               ;
01381 
01382        return yy_scan_bytes( yy_str, len );
01383        }
01384 #endif
01385 
01386 
01387 #ifndef YY_NO_SCAN_BYTES
01388 #ifdef YY_USE_PROTOS
01389 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
01390 #else
01391 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
01392 yyconst char *bytes;
01393 int len;
01394 #endif
01395        {
01396        YY_BUFFER_STATE b;
01397        char *buf;
01398        yy_size_t n;
01399        int i;
01400 
01401        /* Get memory for full buffer, including space for trailing EOB's. */
01402        n = len + 2;
01403        buf = (char *) yy_flex_alloc( n );
01404        if ( ! buf )
01405               YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
01406 
01407        for ( i = 0; i < len; ++i )
01408               buf[i] = bytes[i];
01409 
01410        buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
01411 
01412        b = yy_scan_buffer( buf, n );
01413        if ( ! b )
01414               YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
01415 
01416        /* It's okay to grow etc. this buffer, and we should throw it
01417         * away when we're done.
01418         */
01419        b->yy_is_our_buffer = 1;
01420 
01421        return b;
01422        }
01423 #endif
01424 
01425 
01426 #ifndef YY_NO_PUSH_STATE
01427 #ifdef YY_USE_PROTOS
01428 static void yy_push_state( int new_state )
01429 #else
01430 static void yy_push_state( new_state )
01431 int new_state;
01432 #endif
01433        {
01434        if ( yy_start_stack_ptr >= yy_start_stack_depth )
01435               {
01436               yy_size_t new_size;
01437 
01438               yy_start_stack_depth += YY_START_STACK_INCR;
01439               new_size = yy_start_stack_depth * sizeof( int );
01440 
01441               if ( ! yy_start_stack )
01442                      yy_start_stack = (int *) yy_flex_alloc( new_size );
01443 
01444               else
01445                      yy_start_stack = (int *) yy_flex_realloc(
01446                                    (void *) yy_start_stack, new_size );
01447 
01448               if ( ! yy_start_stack )
01449                      YY_FATAL_ERROR(
01450                      "out of memory expanding start-condition stack" );
01451               }
01452 
01453        yy_start_stack[yy_start_stack_ptr++] = YY_START;
01454 
01455        BEGIN(new_state);
01456        }
01457 #endif
01458 
01459 
01460 #ifndef YY_NO_POP_STATE
01461 static void yy_pop_state()
01462        {
01463        if ( --yy_start_stack_ptr < 0 )
01464               YY_FATAL_ERROR( "start-condition stack underflow" );
01465 
01466        BEGIN(yy_start_stack[yy_start_stack_ptr]);
01467        }
01468 #endif
01469 
01470 
01471 #ifndef YY_NO_TOP_STATE
01472 static int yy_top_state()
01473        {
01474        return yy_start_stack[yy_start_stack_ptr - 1];
01475        }
01476 #endif
01477 
01478 #ifndef YY_EXIT_FAILURE
01479 #define YY_EXIT_FAILURE 2
01480 #endif
01481 
01482 #ifdef YY_USE_PROTOS
01483 static void yy_fatal_error( yyconst char msg[] )
01484 #else
01485 static void yy_fatal_error( msg )
01486 char msg[];
01487 #endif
01488        {
01489        (void) fprintf( stderr, "%s\n", msg );
01490        exit( YY_EXIT_FAILURE );
01491        }
01492 
01493 
01494 
01495 /* Redefine yyless() so it works in section 3 code. */
01496 
01497 #undef yyless
01498 #define yyless(n) \
01499        do \
01500               { \
01501               /* Undo effects of setting up yytext. */ \
01502               yytext[yyleng] = yy_hold_char; \
01503               yy_c_buf_p = yytext + n; \
01504               yy_hold_char = *yy_c_buf_p; \
01505               *yy_c_buf_p = '\0'; \
01506               yyleng = n; \
01507               } \
01508        while ( 0 )
01509 
01510 
01511 /* Internal utility routines. */
01512 
01513 #ifndef yytext_ptr
01514 #ifdef YY_USE_PROTOS
01515 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
01516 #else
01517 static void yy_flex_strncpy( s1, s2, n )
01518 char *s1;
01519 yyconst char *s2;
01520 int n;
01521 #endif
01522        {
01523        register int i;
01524        for ( i = 0; i < n; ++i )
01525               s1[i] = s2[i];
01526        }
01527 #endif
01528 
01529 #ifdef YY_NEED_STRLEN
01530 #ifdef YY_USE_PROTOS
01531 static int yy_flex_strlen( yyconst char *s )
01532 #else
01533 static int yy_flex_strlen( s )
01534 yyconst char *s;
01535 #endif
01536        {
01537        register int n;
01538        for ( n = 0; s[n]; ++n )
01539               ;
01540 
01541        return n;
01542        }
01543 #endif
01544 
01545 
01546 #ifdef YY_USE_PROTOS
01547 static void *yy_flex_alloc( yy_size_t size )
01548 #else
01549 static void *yy_flex_alloc( size )
01550 yy_size_t size;
01551 #endif
01552        {
01553        return (void *) malloc( size );
01554        }
01555 
01556 #ifdef YY_USE_PROTOS
01557 static void *yy_flex_realloc( void *ptr, yy_size_t size )
01558 #else
01559 static void *yy_flex_realloc( ptr, size )
01560 void *ptr;
01561 yy_size_t size;
01562 #endif
01563        {
01564        /* The cast to (char *) in the following accommodates both
01565         * implementations that use char* generic pointers, and those
01566         * that use void* generic pointers.  It works with the latter
01567         * because both ANSI C and C++ allow castless assignment from
01568         * any pointer type to void*, and deal with argument conversions
01569         * as though doing an assignment.
01570         */
01571        return (void *) realloc( (char *) ptr, size );
01572        }
01573 
01574 #ifdef YY_USE_PROTOS
01575 static void yy_flex_free( void *ptr )
01576 #else
01577 static void yy_flex_free( ptr )
01578 void *ptr;
01579 #endif
01580        {
01581        free( ptr );
01582        }
01583 
01584 #if YY_MAIN
01585 int main()
01586        {
01587        yylex();
01588        return 0;
01589        }
01590 #endif
01591 #line 44 "mmcif.lex"
01592 
01593 
01594 
01595 void mmcif_set_file(FILE *fp)
01596 {
01597        yyin=fp;
01598 }      
01599 
01600 int mmcif_get_token(void)
01601 {
01602        extern int yylex(void);
01603        return yylex();
01604 }
01605 
01606 char *mmcif_get_string(void)
01607 {
01608        return yytext;
01609 }      
01610