| # kdeprint Library API Documentation
Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# ppdscanner.cpp

    00001 #define yy_create_buffer kdeprint_ppd_create_buffer
    00002 #define yy_delete_buffer kdeprint_ppd_delete_buffer
    00003 #define yy_scan_buffer kdeprint_ppd_scan_buffer
    00004 #define yy_scan_string kdeprint_ppd_scan_string
    00005 #define yy_scan_bytes kdeprint_ppd_scan_bytes
    00006 #define yy_flex_debug kdeprint_ppd_flex_debug
    00007 #define yy_init_buffer kdeprint_ppd_init_buffer
    00008 #define yy_flush_buffer kdeprint_ppd_flush_buffer
    00009 #define yy_load_buffer_state kdeprint_ppd_load_buffer_state
    00010 #define yy_switch_to_buffer kdeprint_ppd_switch_to_buffer
    00011 #define yyin kdeprint_ppdin
    00012 #define yyleng kdeprint_ppdleng
    00013 #define yylex kdeprint_ppdlex
    00014 #define yyout kdeprint_ppdout
    00015 #define yyrestart kdeprint_ppdrestart
    00016 #define yytext kdeprint_ppdtext
    00017
    00018 #line 19 "./ppdscanner.cpp"
    00019 /* A lexical scanner generated by flex */
    00020
    00021 /* Scanner skeleton version:
    00022  * $Header$
    00023  */
    00024
    00025 #define FLEX_SCANNER
    00026 #define YY_FLEX_MAJOR_VERSION 2
    00027 #define YY_FLEX_MINOR_VERSION 5
    00028
    00029 #include <stdio.h>
    00030 #include <unistd.h>
    00031
    00032
    00033 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
    00034 #ifdef c_plusplus
    00035 #ifndef __cplusplus
    00036 #define __cplusplus
    00037 #endif
    00038 #endif
    00039
    00040
    00041 #ifdef __cplusplus
    00042
    00043 #include <stdlib.h>
    00044
    00045 /* Use prototypes in function declarations. */
    00046 #define YY_USE_PROTOS
    00047
    00048 /* The "const" storage-class-modifier is valid. */
    00049 #define YY_USE_CONST
    00050
    00051 #else   /* ! __cplusplus */
    00052
    00053 #if __STDC__
    00054
    00055 #define YY_USE_PROTOS
    00056 #define YY_USE_CONST
    00057
    00058 #endif  /* __STDC__ */
    00059 #endif  /* ! __cplusplus */
    00060
    00061 #ifdef __TURBOC__
    00062  #pragma warn -rch
    00063  #pragma warn -use
    00064 #include <io.h>
    00065 #include <stdlib.h>
    00066 #define YY_USE_CONST
    00067 #define YY_USE_PROTOS
    00068 #endif
    00069
    00070 #ifdef YY_USE_CONST
    00071 #define yyconst const
    00072 #else
    00073 #define yyconst
    00074 #endif
    00075
    00076
    00077 #ifdef YY_USE_PROTOS
    00078 #define YY_PROTO(proto) proto
    00079 #else
    00080 #define YY_PROTO(proto) ()
    00081 #endif
    00082
    00083 /* Returned upon end-of-file. */
    00084 #define YY_NULL 0
    00085
    00086 /* Promotes a possibly negative, possibly signed char to an unsigned
    00087  * integer for use as an array index.  If the signed char is negative,
    00088  * we want to instead treat it as an 8-bit unsigned char, hence the
    00089  * double cast.
    00090  */
    00091 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
    00092
    00093 /* Enter a start condition.  This macro really ought to take a parameter,
    00094  * but we do it the disgusting crufty way forced on us by the ()-less
    00095  * definition of BEGIN.
    00096  */
    00097 #define BEGIN yy_start = 1 + 2 *
    00098
    00099 /* Translate the current start state into a value that can be later handed
    00100  * to BEGIN to return to the state.  The YYSTATE alias is for lex
    00101  * compatibility.
    00102  */
    00103 #define YY_START ((yy_start - 1) / 2)
    00104 #define YYSTATE YY_START
    00105
    00106 /* Action number for EOF rule of a given start state. */
    00107 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
    00108
    00109 /* Special action meaning "start processing a new file". */
    00110 #define YY_NEW_FILE yyrestart( yyin )
    00111
    00112 #define YY_END_OF_BUFFER_CHAR 0
    00113
    00114 /* Size of default input buffer. */
    00115 #define YY_BUF_SIZE 16384
    00116
    00117 typedef struct yy_buffer_state *YY_BUFFER_STATE;
    00118
    00119 extern int yyleng;
    00120 extern FILE *yyin, *yyout;
    00121
    00122 #define EOB_ACT_CONTINUE_SCAN 0
    00123 #define EOB_ACT_END_OF_FILE 1
    00124 #define EOB_ACT_LAST_MATCH 2
    00125
    00126 /* The funky do-while in the following #define is used to turn the definition
    00127  * int a single C statement (which needs a semi-colon terminator).  This
    00128  * avoids problems with code like:
    00129  *
    00130  *  if ( condition_holds )
    00131  *      yyless( 5 );
    00132  *  else
    00133  *      do_something_else();
    00134  *
    00135  * Prior to using the do-while the compiler would get upset at the
    00136  * "else" because it interpreted the "if" statement as being all
    00137  * done when it reached the ';' after the yyless() call.
    00138  */
    00139
    00140 /* Return all but the first 'n' matched characters back to the input stream. */
    00141
    00142 #define yyless(n) \
    00143     do \
    00144         { \
    00145         /* Undo effects of setting up yytext. */ \
    00146         *yy_cp = yy_hold_char; \
    00147         YY_RESTORE_YY_MORE_OFFSET \
    00148         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
    00149         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
    00150         } \
    00151     while ( 0 )
    00152
    00153 #define unput(c) yyunput( c, yytext_ptr )
    00154
    00155 /* The following is because we cannot portably get our hands on size_t
    00156  * (without autoconf's help, which isn't available because we want
    00157  * flex-generated scanners to compile on their own).
    00158  */
    00159 typedef unsigned int yy_size_t;
    00160
    00161
    00162 struct yy_buffer_state
    00163     {
    00164     FILE *yy_input_file;
    00165
    00166     char *yy_ch_buf;        /* input buffer */
    00167     char *yy_buf_pos;       /* current position in input buffer */
    00168
    00169     /* Size of input buffer in bytes, not including room for EOB
    00170      * characters.
    00171      */
    00172     yy_size_t yy_buf_size;
    00173
    00174     /* Number of characters read into yy_ch_buf, not including EOB
    00175      * characters.
    00176      */
    00177     int yy_n_chars;
    00178
    00179     /* Whether we "own" the buffer - i.e., we know we created it,
    00180      * and can realloc() it to grow it, and should free() it to
    00181      * delete it.
    00182      */
    00183     int yy_is_our_buffer;
    00184
    00185     /* Whether this is an "interactive" input source; if so, and
    00186      * if we're using stdio for input, then we want to use getc()
    00187      * instead of fread(), to make sure we stop fetching input after
    00188      * each newline.
    00189      */
    00190     int yy_is_interactive;
    00191
    00192     /* Whether we're considered to be at the beginning of a line.
    00193      * If so, '^' rules will be active on the next match, otherwise
    00194      * not.
    00195      */
    00196     int yy_at_bol;
    00197
    00198     /* Whether to try to fill the input buffer when we reach the
    00199      * end of it.
    00200      */
    00201     int yy_fill_buffer;
    00202
    00203     int yy_buffer_status;
    00204 #define YY_BUFFER_NEW 0
    00205 #define YY_BUFFER_NORMAL 1
    00206     /* When an EOF's been seen but there's still some text to process
    00207      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
    00208      * shouldn't try reading from the input source any more.  We might
    00209      * still have a bunch of tokens to match, though, because of
    00210      * possible backing-up.
    00211      *
    00212      * When we actually see the EOF, we change the status to "new"
    00213      * (via yyrestart()), so that the user can continue scanning by
    00214      * just pointing yyin at a new input file.
    00215      */
    00216 #define YY_BUFFER_EOF_PENDING 2
    00217     };
    00218
    00219 static YY_BUFFER_STATE yy_current_buffer = 0;
    00220
    00221 /* We provide macros for accessing buffer states in case in the
    00222  * future we want to put the buffer states in a more general
    00223  * "scanner state".
    00224  */
    00225 #define YY_CURRENT_BUFFER yy_current_buffer
    00226
    00227
    00228 /* yy_hold_char holds the character lost when yytext is formed. */
    00229 static char yy_hold_char;
    00230
    00231 static int yy_n_chars;      /* number of characters read into yy_ch_buf */
    00232
    00233
    00234 int yyleng;
    00235
    00236 /* Points to current character in buffer. */
    00237 static char *yy_c_buf_p = (char *) 0;
    00238 static int yy_init = 1;     /* whether we need to initialize */
    00239 static int yy_start = 0;    /* start state number */
    00240
    00241 /* Flag which is used to allow yywrap()'s to do buffer switches
    00242  * instead of setting up a fresh yyin.  A bit of a hack ...
    00243  */
    00244 static int yy_did_buffer_switch_on_eof;
    00245
    00246 void yyrestart YY_PROTO(( FILE *input_file ));
    00247
    00248 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
    00249 void yy_load_buffer_state YY_PROTO(( void ));
    00250 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
    00251 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
    00252 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
    00253 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
    00254 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
    00255
    00256 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
    00257 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
    00258 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
    00259
    00260 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
    00261 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
    00262 static void yy_flex_free YY_PROTO(( void * ));
    00263
    00264 #define yy_new_buffer yy_create_buffer
    00265
    00266 #define yy_set_interactive(is_interactive) \
    00267     { \
    00268     if ( ! yy_current_buffer ) \
    00269         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
    00270     yy_current_buffer->yy_is_interactive = is_interactive; \
    00271     }
    00272
    00273 #define yy_set_bol(at_bol) \
    00274     { \
    00275     if ( ! yy_current_buffer ) \
    00276         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
    00277     yy_current_buffer->yy_at_bol = at_bol; \
    00278     }
    00279
    00280 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
    00281
    00282
    00283 #define yywrap() 1
    00284 #define YY_SKIP_YYWRAP
    00285 typedef unsigned char YY_CHAR;
    00286 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
    00287 typedef int yy_state_type;
    00288 extern char *yytext;
    00289 #define yytext_ptr yytext
    00290
    00291 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
    00292 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
    00293 static int yy_get_next_buffer YY_PROTO(( void ));
    00294 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
    00295
    00296 /* Done after the current pattern has been matched and before the
    00297  * corresponding action - sets up yytext.
    00298  */
    00299 #define YY_DO_BEFORE_ACTION \
    00300     yytext_ptr = yy_bp; \
    00301     yyleng = (int) (yy_cp - yy_bp); \
    00302     yy_hold_char = *yy_cp; \
    00303     *yy_cp = '\0'; \
    00304     yy_c_buf_p = yy_cp;
    00305
    00306 #define YY_NUM_RULES 37
    00307 #define YY_END_OF_BUFFER 38
    00308 static yyconst short int yy_accept[172] =
    00309     {   0,
    00310         0,    0,    0,    0,    0,    0,   21,   21,   29,   29,
    00311         0,    0,   38,   36,   35,   36,   19,   17,   20,   18,
    00312        27,   25,   25,   26,   28,   21,   23,   22,   29,   30,
    00313        34,   33,   36,   31,   16,   15,   16,   16,   16,   16,
    00314        16,   16,   16,   16,   16,   17,   25,    0,   25,   24,
    00315        21,   29,   33,   32,   15,   15,   15,   16,   16,   16,
    00316        16,   16,   16,   16,   16,   16,   24,   15,   16,   16,
    00317        13,   16,   16,   16,   16,   16,   16,   15,   16,   16,
    00318        16,   16,   16,   16,   16,   16,   16,   15,   16,   16,
    00319        16,   16,   16,   16,   16,   16,   16,   16,   15,   16,
    00320
    00321        16,   16,   16,   16,   16,   16,   16,    2,   16,   16,
    00322        15,   16,    4,   16,   16,   16,   16,   16,   16,    2,
    00323        16,   16,   15,   16,    4,    8,    8,   16,   16,   16,
    00324        16,   16,   16,   16,   15,   16,    7,   16,   16,    1,
    00325        16,    5,   16,   16,   15,    6,   16,    3,   16,   16,
    00326        16,   15,   16,   16,   16,   16,   15,   14,   16,   16,
    00327        16,   16,   12,   16,   16,    9,   16,   11,   16,   10,
    00328         0
    00329     } ;
    00330
    00331 static yyconst int yy_ec[256] =
    00332     {   0,
    00333         1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
    00334         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00335         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00336         1,    3,    4,    5,    6,    4,    7,    4,    4,    4,
    00337         4,    8,    4,    4,    4,    4,    9,   10,   10,   10,
    00338        10,   10,   10,   10,   10,   10,   10,   11,    4,    4,
    00339         4,    4,    4,    4,   12,   10,   13,   14,   15,   10,
    00340        16,   10,   17,   18,   10,   19,   20,   21,   22,   23,
    00341        10,   10,   10,   24,   25,   10,   10,   10,   10,   10,
    00342         4,    4,    4,    4,    4,    4,   26,   27,   10,   28,
    00343
    00344        29,   30,   31,   10,   32,   10,   10,   33,   34,   35,
    00345        36,   37,   10,   38,   39,   40,   41,   10,   10,   10,
    00346        10,   10,    4,    4,    4,    4,    1,    1,    1,    1,
    00347         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00348         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00349         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00350         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00351         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00352         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00353         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00354
    00355         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00356         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00357         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00358         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00359         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00360         1,    1,    1,    1,    1
    00361     } ;
    00362
    00363 static yyconst int yy_meta[42] =
    00364     {   0,
    00365         1,    2,    3,    4,    4,    4,    4,    5,    1,    4,
    00366         6,    4,    4,    4,    4,    4,    4,    4,    4,    4,
    00367         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
    00368         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
    00369         4
    00370     } ;
    00371
    00372 static yyconst short int yy_base[194] =
    00373     {   0,
    00374         0,    1,    3,   14,   17,   28,   25,   30,  300,  299,
    00375        41,   45,  300,  303,  303,   50,  303,    0,  303,  303,
    00376       303,    0,   75,  303,  303,    0,  303,  303,    0,  303,
    00377       303,    0,    0,  303,    0,   78,  266,  269,  262,  262,
    00378       282,  258,  256,  266,  274,    0,    0,  285,   89,    0,
    00379         0,    0,    0,    0,    0,  276,   92,  252,  257,  258,
    00380       259,  265,  248,  253,  244,  267,  303,  257,  239,  251,
    00381         0,  245,   38,  250,  239,  244,  236,  251,  241,  228,
    00382       239,  234,  229,  248,   45,  226,  228,  248,   58,  228,
    00383       234,  223,  229,  244,  218,  238,  240,  214,  240,  213,
    00384
    00385       233,  209,  221,  208,  211,  209,  208,  100,  211,  202,
    00386       217,  204,  105,  231,  205,  208,  211,  200,  193,  110,
    00387       199,  194,  219,  189,  115,    0,    0,  200,  203,  210,
    00388       187,  188,  195,  197,  219,  184,    0,  208,  202,    0,
    00389       178,    0,  182,  184,  191,    0,  147,    0,  141,  135,
    00390        67,   97,   68,   70,   56,   45,   80,  303,   43,   34,
    00391        26,   20,    0,   23,   20,    0,    5,    0,    1,    0,
    00392       303,  123,  129,  135,  141,  147,  153,  156,  159,  161,
    00393       166,  172,  177,    6,    3,  183,  189,  195,  198,  200,
    00394       202,  204,  209
    00395
    00396     } ;
    00397
    00398 static yyconst short int yy_def[194] =
    00399     {   0,
    00400       172,  172,  173,  173,  174,  174,  175,  175,  176,  176,
    00401       177,  177,  171,  171,  171,  178,  171,  179,  171,  171,
    00402       171,  180,  181,  171,  171,  182,  171,  171,  183,  171,
    00403       171,  184,  185,  171,  178,  186,  178,  178,  178,  178,
    00404       178,  178,  178,  178,  178,  179,  180,  187,  181,  180,
    00405       182,  183,  184,  185,  188,  188,  186,  178,  178,  178,
    00406       178,  178,  178,  178,  178,  178,  171,  188,  178,  178,
    00407       178,  178,  178,  178,  178,  178,  178,  188,  178,  178,
    00408       178,  178,  178,  178,  178,  178,  178,  188,  178,  178,
    00409       178,  178,  178,  178,  178,  178,  178,  178,  188,  178,
    00410
    00411       178,  178,  178,  178,  178,  178,  178,  189,  178,  178,
    00412       188,  178,  190,  191,  178,  178,  178,  178,  178,  189,
    00413       178,  178,  188,  178,  190,  191,  192,  178,  178,  178,
    00414       178,  178,  178,  178,  188,  178,  192,  178,  178,  178,
    00415       178,  178,  178,  178,  188,  178,  178,  178,  178,  178,
    00416       178,  193,  178,  178,  178,  178,  193,  171,  178,  178,
    00417       178,  178,  178,  178,  178,  178,  178,  178,  178,  178,
    00418         0,  171,  171,  171,  171,  171,  171,  171,  171,  171,
    00419       171,  171,  171,  171,  171,  171,  171,  171,  171,  171,
    00420       171,  171,  171
    00421
    00422     } ;
    00423
    00424 static yyconst short int yy_nxt[345] =
    00425     {   0,
    00426       171,   15,   15,   14,   17,   14,   54,   16,   16,   53,
    00427       171,   19,  171,   20,   14,   17,   14,   14,   21,   14,
    00428       171,   23,   19,  171,   20,   24,   27,   25,   14,   21,
    00429        14,   27,   23,  171,  171,   28,   24,  171,   25,  170,
    00430        28,   14,   31,   14,  169,   14,   31,   14,   33,   14,
    00431        82,   34,   33,   14,  168,   34,   36,  167,  166,   83,
    00432        95,  165,   37,   38,   39,  164,   40,   41,  163,   96,
    00433        42,   43,   44,  100,   45,   48,   48,   48,   55,   50,
    00434        56,  158,  101,   48,  162,   48,   55,  161,   55,   48,
    00435        48,   48,   55,   50,   55,  160,  159,   48,  158,   48,
    00436
    00437        55,  156,   55,   35,   35,   35,   35,   35,   35,   35,
    00438        35,   35,   35,   35,   35,   35,   35,   35,   35,   35,
    00439        35,   35,   35,   14,   14,   14,   14,   14,   14,   18,
    00440        18,   18,   18,   18,   18,   22,   22,   22,   22,   22,
    00441        22,   26,   26,   26,   26,   26,   26,   29,   29,   29,
    00442        29,   29,   29,   32,   32,   32,   32,   32,   32,   35,
    00443        35,   46,   46,   46,   47,   47,   49,   49,   49,   49,
    00444        49,   49,   51,  155,   51,   51,   51,   52,  154,   52,
    00445        52,   52,   52,   57,  153,   57,   57,   57,   57,   48,
    00446        48,   48,   48,   48,   48,   55,  152,   55,   55,   55,
    00447
    00448        55,  120,  120,  125,  125,  126,  126,  137,  137,  157,
    00449       157,  157,  157,  157,  157,  151,  150,  149,  148,  147,
    00450       146,  145,  144,  143,  142,  141,  140,  139,  138,  136,
    00451       135,  134,  133,  132,  131,  130,  129,  128,  127,  124,
    00452       123,  122,  121,  119,  118,  117,  116,  115,  114,  113,
    00453       112,  111,  110,  109,  108,  107,  106,  105,  104,  103,
    00454       102,   99,   98,   97,   94,   93,   92,   91,   90,   89,
    00455        88,   87,   86,   85,   84,   81,   80,   79,   78,   77,
    00456        76,   75,   74,   73,   72,   71,   70,   69,   68,   67,
    00457        66,   65,   64,   63,   62,   61,   60,   59,   58,  171,
    00458
    00459        30,   30,   13,  171,  171,  171,  171,  171,  171,  171,
    00460       171,  171,  171,  171,  171,  171,  171,  171,  171,  171,
    00461       171,  171,  171,  171,  171,  171,  171,  171,  171,  171,
    00462       171,  171,  171,  171,  171,  171,  171,  171,  171,  171,
    00463       171,  171,  171,  171
    00464     } ;
    00465
    00466 static yyconst short int yy_chk[345] =
    00467     {   0,
    00468         0,    1,    2,    3,    3,    3,  185,    1,    2,  184,
    00469         0,    3,    0,    3,    4,    4,    4,    5,    5,    5,
    00470         0,    5,    4,    0,    4,    5,    7,    5,    6,    6,
    00471         6,    8,    6,    0,    0,    7,    6,    0,    6,  169,
    00472         8,   11,   11,   11,  167,   12,   12,   12,   11,   11,
    00473        73,   11,   12,   12,  165,   12,   16,  164,  162,   73,
    00474        85,  161,   16,   16,   16,  160,   16,   16,  159,   85,
    00475        16,   16,   16,   89,   16,   23,   23,   23,   36,   23,
    00476        36,  157,   89,   23,  156,   23,   36,  155,   36,   49,
    00477        49,   49,   57,   49,   57,  154,  153,   49,  152,   49,
    00478
    00479        57,  151,   57,  108,  108,  108,  108,  108,  113,  113,
    00480       113,  113,  113,  120,  120,  120,  120,  120,  125,  125,
    00481       125,  125,  125,  172,  172,  172,  172,  172,  172,  173,
    00482       173,  173,  173,  173,  173,  174,  174,  174,  174,  174,
    00483       174,  175,  175,  175,  175,  175,  175,  176,  176,  176,
    00484       176,  176,  176,  177,  177,  177,  177,  177,  177,  178,
    00485       178,  179,  179,  179,  180,  180,  181,  181,  181,  181,
    00486       181,  181,  182,  150,  182,  182,  182,  183,  149,  183,
    00487       183,  183,  183,  186,  147,  186,  186,  186,  186,  187,
    00488       187,  187,  187,  187,  187,  188,  145,  188,  188,  188,
    00489
    00490       188,  189,  189,  190,  190,  191,  191,  192,  192,  193,
    00491       193,  193,  193,  193,  193,  144,  143,  141,  139,  138,
    00492       136,  135,  134,  133,  132,  131,  130,  129,  128,  124,
    00493       123,  122,  121,  119,  118,  117,  116,  115,  114,  112,
    00494       111,  110,  109,  107,  106,  105,  104,  103,  102,  101,
    00495       100,   99,   98,   97,   96,   95,   94,   93,   92,   91,
    00496        90,   88,   87,   86,   84,   83,   82,   81,   80,   79,
    00497        78,   77,   76,   75,   74,   72,   70,   69,   68,   66,
    00498        65,   64,   63,   62,   61,   60,   59,   58,   56,   48,
    00499        45,   44,   43,   42,   41,   40,   39,   38,   37,   13,
    00500
    00501        10,    9,  171,  171,  171,  171,  171,  171,  171,  171,
    00502       171,  171,  171,  171,  171,  171,  171,  171,  171,  171,
    00503       171,  171,  171,  171,  171,  171,  171,  171,  171,  171,
    00504       171,  171,  171,  171,  171,  171,  171,  171,  171,  171,
    00505       171,  171,  171,  171
    00506     } ;
    00507
    00508 static yy_state_type yy_last_accepting_state;
    00509 static char *yy_last_accepting_cpos;
    00510
    00511 /* The intent behind this definition is that it'll catch
    00512  * any uses of REJECT which flex missed.
    00513  */
    00514 #define REJECT reject_used_but_not_detected
    00515 #define yymore() yymore_used_but_not_detected
    00516 #define YY_MORE_ADJ 0
    00517 #define YY_RESTORE_YY_MORE_OFFSET
    00518 char *yytext;
    00519 #line 1 "./ppdscanner.l"
    00520 #define INITIAL 0
    00521 #line 2 "./ppdscanner.l"
    00522 /*
    00523  *  This file is part of the KDE libraries
    00524  *  Copyright (c) 2001-2003 Michael Goffioul <kdeprint@swing.be>
    00525  *
    00526  *  This library is free software; you can redistribute it and/or
    00527  *  modify it under the terms of the GNU Library General Public
    00528  *  License version 2 as published by the Free Software Foundation.
    00529  *
    00530  *  This library is distributed in the hope that it will be useful,
    00531  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    00532  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00533  *  Library General Public License for more details.
    00534  *
    00535  *  You should have received a copy of the GNU Library General Public License
    00536  *  along with this library; see the file COPYING.LIB.  If not, write to
    00537  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00538  *  Boston, MA 02111-1307, USA.
    00539  **/
    00540
    00541 #include <qstringlist.h>
    00542 #include <qiodevice.h>
    00543 #define YYSTYPE QStringList
    00544 #include "ppdparser.cpp.h"
    00545
    00546 #define yylval kdeprint_ppdlval
    00547
    00548 QIODevice *kdeprint_ppdscanner_device = NULL;
    00549 #define YY_INPUT(buf,result,max_size) \
    00550     { \
    00551         if (kdeprint_ppdscanner_device) \
    00552         { \
    00553             result = kdeprint_ppdscanner_device->readBlock(buf,max_size); \
    00554             if (result < 0) \
    00555                 result = 0; \
    00556         } \
    00557         else \
    00558             result = 0; \
    00559     }
    00560 int kdeprint_ppdscanner_lno = 0;
    00561
    00562 #if 0
    00563 #define QDEBUG0(s) qDebug(s)
    00564 #define QDEBUG1(s,a) qDebug(s,a)
    00565 #else
    00566 #define QDEBUG0(s)
    00567 #define QDEBUG1(s,a)
    00568 #endif
    00569 #define option 1
    00570 #define value 2
    00571 #define translation_1 3
    00572 #define translation_2 4
    00573 #define constr 5
    00574
    00575 #line 576 "./ppdscanner.cpp"
    00576
    00577 /* Macros after this point can all be overridden by user definitions in
    00578  * section 1.
    00579  */
    00580
    00581 #ifndef YY_SKIP_YYWRAP
    00582 #ifdef __cplusplus
    00583 extern "C" int yywrap YY_PROTO(( void ));
    00584 #else
    00585 extern int yywrap YY_PROTO(( void ));
    00586 #endif
    00587 #endif
    00588
    00589 #ifndef YY_NO_UNPUT
    00590 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
    00591 #endif
    00592
    00593 #ifndef yytext_ptr
    00594 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
    00595 #endif
    00596
    00597 #ifdef YY_NEED_STRLEN
    00598 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
    00599 #endif
    00600
    00601 #ifndef YY_NO_INPUT
    00602 #ifdef __cplusplus
    00603 static int yyinput YY_PROTO(( void ));
    00604 #else
    00605 static int input YY_PROTO(( void ));
    00606 #endif
    00607 #endif
    00608
    00609 #if YY_STACK_USED
    00610 static int yy_start_stack_ptr = 0;
    00611 static int yy_start_stack_depth = 0;
    00612 static int *yy_start_stack = 0;
    00613 #ifndef YY_NO_PUSH_STATE
    00614 static void yy_push_state YY_PROTO(( int new_state ));
    00615 #endif
    00616 #ifndef YY_NO_POP_STATE
    00617 static void yy_pop_state YY_PROTO(( void ));
    00618 #endif
    00619 #ifndef YY_NO_TOP_STATE
    00620 static int yy_top_state YY_PROTO(( void ));
    00621 #endif
    00622
    00623 #else
    00624 #define YY_NO_PUSH_STATE 1
    00625 #define YY_NO_POP_STATE 1
    00626 #define YY_NO_TOP_STATE 1
    00627 #endif
    00628
    00629 #ifdef YY_MALLOC_DECL
    00630 YY_MALLOC_DECL
    00631 #else
    00632 #if __STDC__
    00633 #ifndef __cplusplus
    00634 #include <stdlib.h>
    00635 #endif
    00636 #else
    00637 /* Just try to get by without declaring the routines.  This will fail
    00638  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
    00639  * or sizeof(void*) != sizeof(int).
    00640  */
    00641 #endif
    00642 #endif
    00643
    00644 /* Amount of stuff to slurp up with each read. */
    00645 #ifndef YY_READ_BUF_SIZE
    00646 #define YY_READ_BUF_SIZE 8192
    00647 #endif
    00648
    00649 /* Copy whatever the last rule matched to the standard output. */
    00650
    00651 #ifndef ECHO
    00652 /* This used to be an fputs(), but since the string might contain NUL's,
    00653  * we now use fwrite().
    00654  */
    00655 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
    00656 #endif
    00657
    00658 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
    00659  * is returned in "result".
    00660  */
    00661 #ifndef YY_INPUT
    00662 #define YY_INPUT(buf,result,max_size) \
    00663     if ( yy_current_buffer->yy_is_interactive ) \
    00664         { \
    00665         int c = '*', n; \
    00666         for ( n = 0; n < max_size && \
    00667                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
    00668             buf[n] = (char) c; \
    00669         if ( c == '\n' ) \
    00670             buf[n++] = (char) c; \
    00671         if ( c == EOF && ferror( yyin ) ) \
    00672             YY_FATAL_ERROR( "input in flex scanner failed" ); \
    00673         result = n; \
    00674         } \
    00675     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
    00676           && ferror( yyin ) ) \
    00677         YY_FATAL_ERROR( "input in flex scanner failed" );
    00678 #endif
    00679
    00680 /* No semi-colon after return; correct usage is to write "yyterminate();" -
    00681  * we don't want an extra ';' after the "return" because that will cause
    00682  * some compilers to complain about unreachable statements.
    00683  */
    00684 #ifndef yyterminate
    00685 #define yyterminate() return YY_NULL
    00686 #endif
    00687
    00688 /* Number of entries by which start-condition stack grows. */
    00689 #ifndef YY_START_STACK_INCR
    00690 #define YY_START_STACK_INCR 25
    00691 #endif
    00692
    00693 /* Report a fatal error. */
    00694 #ifndef YY_FATAL_ERROR
    00695 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
    00696 #endif
    00697
    00698 /* Default declaration of generated scanner - a define so the user can
    00699  * easily add parameters.
    00700  */
    00701 #ifndef YY_DECL
    00702 #define YY_DECL int yylex YY_PROTO(( void ))
    00703 #endif
    00704
    00705 /* Code executed at the beginning of each rule, after yytext and yyleng
    00706  * have been set up.
    00707  */
    00708 #ifndef YY_USER_ACTION
    00709 #define YY_USER_ACTION
    00710 #endif
    00711
    00712 /* Code executed at the end of each rule. */
    00713 #ifndef YY_BREAK
    00714 #define YY_BREAK break;
    00715 #endif
    00716
    00717 #define YY_RULE_SETUP \
    00718     YY_USER_ACTION
    00719
    00720 YY_DECL
    00721     {
    00722     register yy_state_type yy_current_state;
    00723     register char *yy_cp, *yy_bp;
    00724     register int yy_act;
    00725
    00726 #line 59 "./ppdscanner.l"
    00727
    00728
    00732 #line 733 "./ppdscanner.cpp"
    00733
    00734     if ( yy_init )
    00735         {
    00736         yy_init = 0;
    00737
    00738 #ifdef YY_USER_INIT
    00739         YY_USER_INIT;
    00740 #endif
    00741
    00742         if ( ! yy_start )
    00743             yy_start = 1;   /* first start state */
    00744
    00745         if ( ! yyin )
    00746             yyin = stdin;
    00747
    00748         if ( ! yyout )
    00749             yyout = stdout;
    00750
    00751         if ( ! yy_current_buffer )
    00752             yy_current_buffer =
    00753                 yy_create_buffer( yyin, YY_BUF_SIZE );
    00754
    00755         yy_load_buffer_state();
    00756         }
    00757
    00758     while ( 1 )     /* loops until end-of-file is reached */
    00759         {
    00760         yy_cp = yy_c_buf_p;
    00761
    00762         /* Support of yytext. */
    00763         *yy_cp = yy_hold_char;
    00764
    00765         /* yy_bp points to the position in yy_ch_buf of the start of
    00766          * the current run.
    00767          */
    00768         yy_bp = yy_cp;
    00769
    00770         yy_current_state = yy_start;
    00771 yy_match:
    00772         do
    00773             {
    00774             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
    00775             if ( yy_accept[yy_current_state] )
    00776                 {
    00777                 yy_last_accepting_state = yy_current_state;
    00778                 yy_last_accepting_cpos = yy_cp;
    00779                 }
    00780             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    00781                 {
    00782                 yy_current_state = (int) yy_def[yy_current_state];
    00783                 if ( yy_current_state >= 172 )
    00784                     yy_c = yy_meta[(unsigned int) yy_c];
    00785                 }
    00786             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    00787             ++yy_cp;
    00788             }
    00789         while ( yy_base[yy_current_state] != 303 );
    00790
    00791 yy_find_action:
    00792         yy_act = yy_accept[yy_current_state];
    00793         if ( yy_act == 0 )
    00794             { /* have to back up */
    00795             yy_cp = yy_last_accepting_cpos;
    00796             yy_current_state = yy_last_accepting_state;
    00797             yy_act = yy_accept[yy_current_state];
    00798             }
    00799
    00800         YY_DO_BEFORE_ACTION;
    00801
    00802
    00803 do_action:  /* This label is used only to access EOF actions. */
    00804
    00805
    00806         switch ( yy_act )
    00807     { /* beginning of action switch */
    00808             case 0: /* must back up */
    00809             /* undo the effects of YY_DO_BEFORE_ACTION */
    00810             *yy_cp = yy_hold_char;
    00811             yy_cp = yy_last_accepting_cpos;
    00812             yy_current_state = yy_last_accepting_state;
    00813             goto yy_find_action;
    00814
    00815 case 1:
    00816 #line 65 "./ppdscanner.l"
    00817 case 2:
    00818 YY_RULE_SETUP
    00819 #line 65 "./ppdscanner.l"
    00820 { QDEBUG0("Open UI"); BEGIN(option); return OPENUI; }
    00821     YY_BREAK
    00822 case 3:
    00823 #line 67 "./ppdscanner.l"
    00824 case 4:
    00825 YY_RULE_SETUP
    00826 #line 67 "./ppdscanner.l"
    00827 { QDEBUG0("Close UI"); BEGIN(value); return CLOSEUI; }
    00828     YY_BREAK
    00829 case 5:
    00830 YY_RULE_SETUP
    00831 #line 68 "./ppdscanner.l"
    00832 { QDEBUG0("Open group"); BEGIN(option); return OPENGROUP; }
    00833     YY_BREAK
    00834 case 6:
    00835 YY_RULE_SETUP
    00836 #line 69 "./ppdscanner.l"
    00837 { QDEBUG0("Close group"); BEGIN(option); return CLOSEGROUP; }
    00838     YY_BREAK
    00839 case 7:
    00840 YY_RULE_SETUP
    00841 #line 70 "./ppdscanner.l"
    00842 { yylval = yytext+9; BEGIN(option); return DEFAULT; }
    00843     YY_BREAK
    00844 case 8:
    00845 YY_RULE_SETUP
    00846 #line 71 "./ppdscanner.l"
    00847 { yylval = yytext+8; BEGIN(option); return DEFAULT; }
    00848     YY_BREAK
    00849 case 9:
    00850 #line 73 "./ppdscanner.l"
    00851 case 10:
    00852 YY_RULE_SETUP
    00853 #line 73 "./ppdscanner.l"
    00854 { BEGIN(constr); return CONSTRAINT; }
    00855     YY_BREAK
    00856 case 11:
    00857 YY_RULE_SETUP
    00858 #line 74 "./ppdscanner.l"
    00859 { BEGIN(option); return PAPERDIM; }
    00860     YY_BREAK
    00861 case 12:
    00862 YY_RULE_SETUP
    00863 #line 75 "./ppdscanner.l"
    00864 { BEGIN(option); return IMGAREA; }
    00865     YY_BREAK
    00866 case 13:
    00867 YY_RULE_SETUP
    00868 #line 76 "./ppdscanner.l"
    00869 { /* eat up */ }
    00870     YY_BREAK
    00871 case 14:
    00872 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
    00873 yy_c_buf_p = yy_cp -= 1;
    00874 YY_DO_BEFORE_ACTION; /* set up yytext again */
    00875 YY_RULE_SETUP
    00876 #line 78 "./ppdscanner.l"
    00877 { yylval = yytext+12; return FOODATA; }
    00878     YY_BREAK
    00879 case 15:
    00880 YY_RULE_SETUP
    00881 #line 79 "./ppdscanner.l"
    00882 { QDEBUG0("Comment"); return COMMENT; }
    00883     YY_BREAK
    00884 case 16:
    00885 YY_RULE_SETUP
    00886 #line 80 "./ppdscanner.l"
    00887 { yylval = yytext+1; QDEBUG1("Main keyword: %s",yytext+1); BEGIN(option); return KEYWORD; }
    00888     YY_BREAK
    00892 case 17:
    00893 YY_RULE_SETUP
    00894 #line 85 "./ppdscanner.l"
    00895 { yylval = yytext; QDEBUG1("Option: %s",yytext); return OPTION; }
    00896     YY_BREAK
    00897 case 18:
    00898 YY_RULE_SETUP
    00899 #line 86 "./ppdscanner.l"
    00900 { BEGIN(value); return ':'; }
    00901     YY_BREAK
    00902 case 19:
    00903 YY_RULE_SETUP
    00904 #line 87 "./ppdscanner.l"
    00905 { kdeprint_ppdscanner_lno++; BEGIN(INITIAL); }
    00906     YY_BREAK
    00907 case 20:
    00908 YY_RULE_SETUP
    00909 #line 88 "./ppdscanner.l"
    00910 { BEGIN(translation_1); return '/'; }
    00911     YY_BREAK
    00915 case 21:
    00916 YY_RULE_SETUP
    00917 #line 93 "./ppdscanner.l"
    00918 { yylval = yytext; QDEBUG1("Translation: %s",yytext); return TRANSLATION; }
    00919     YY_BREAK
    00920 case 22:
    00921 YY_RULE_SETUP
    00922 #line 94 "./ppdscanner.l"
    00923 { BEGIN(value); return ':'; }
    00924     YY_BREAK
    00925 case 23:
    00926 YY_RULE_SETUP
    00927 #line 95 "./ppdscanner.l"
    00928 { kdeprint_ppdscanner_lno++; BEGIN(INITIAL); }
    00929     YY_BREAK
    00933 case 24:
    00934 YY_RULE_SETUP
    00935 #line 100 "./ppdscanner.l"
    00936 { yylval = yytext; kdeprint_ppdscanner_lno += yylval[0].contains('\n'); QDEBUG1("Quoted value: %s",yytext); return QUOTED; }
    00937     YY_BREAK
    00938 case 25:
    00939 YY_RULE_SETUP
    00940 #line 101 "./ppdscanner.l"
    00941 { yylval = yytext; QDEBUG1("String part: %s",yytext); return STRINGPART; }
    00942     YY_BREAK
    00943 case 26:
    00944 YY_RULE_SETUP
    00945 #line 102 "./ppdscanner.l"
    00946 { BEGIN(translation_2); return '/'; }
    00947     YY_BREAK
    00948 case 27:
    00949 YY_RULE_SETUP
    00950 #line 103 "./ppdscanner.l"
    00951 { kdeprint_ppdscanner_lno++; BEGIN(INITIAL); }
    00952     YY_BREAK
    00953 case 28:
    00954 YY_RULE_SETUP
    00955 #line 104 "./ppdscanner.l"
    00956 { /* stay in the same state */ return ':'; }
    00957     YY_BREAK
    00961 case 29:
    00962 YY_RULE_SETUP
    00963 #line 109 "./ppdscanner.l"
    00964 { yylval = yytext; QDEBUG1("Translation: %s",yytext); return TRANSLATION; }
    00965     YY_BREAK
    00966 case 30:
    00967 YY_RULE_SETUP
    00968 #line 110 "./ppdscanner.l"
    00969 { kdeprint_ppdscanner_lno++; BEGIN(INITIAL); }
    00970     YY_BREAK
    00974 case 31:
    00975 YY_RULE_SETUP
    00976 #line 115 "./ppdscanner.l"
    00977 { return ':'; }
    00978     YY_BREAK
    00979 case 32:
    00980 YY_RULE_SETUP
    00981 #line 116 "./ppdscanner.l"
    00982 { yylval = yytext+1; QDEBUG1("Constraint keyword: %s",yytext); return KEYWORD; }
    00983     YY_BREAK
    00984 case 33:
    00985 YY_RULE_SETUP
    00986 #line 117 "./ppdscanner.l"
    00987 { yylval = yytext; QDEBUG1("Constraint option: %s",yytext); return OPTION; }
    00988     YY_BREAK
    00989 case 34:
    00990 YY_RULE_SETUP
    00991 #line 118 "./ppdscanner.l"
    00992 { kdeprint_ppdscanner_lno++; BEGIN(INITIAL); }
    00993     YY_BREAK
    00994 case 35:
    00995 YY_RULE_SETUP
    00996 #line 120 "./ppdscanner.l"
    00997 { kdeprint_ppdscanner_lno++; /* eat up */ }
    00998     YY_BREAK
    00999 case 36:
    01000 YY_RULE_SETUP
    01001 #line 121 "./ppdscanner.l"
    01002 { /* eat up */ }
    01003     YY_BREAK
    01004 case 37:
    01005 YY_RULE_SETUP
    01006 #line 123 "./ppdscanner.l"
    01007 ECHO;
    01008     YY_BREAK
    01009 #line 1010 "./ppdscanner.cpp"
    01010 case YY_STATE_EOF(INITIAL):
    01011 case YY_STATE_EOF(option):
    01012 case YY_STATE_EOF(value):
    01013 case YY_STATE_EOF(translation_1):
    01014 case YY_STATE_EOF(translation_2):
    01015 case YY_STATE_EOF(constr):
    01016     yyterminate();
    01017
    01018     case YY_END_OF_BUFFER:
    01019         {
    01020         /* Amount of text matched not including the EOB char. */
    01021         int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
    01022
    01023         /* Undo the effects of YY_DO_BEFORE_ACTION. */
    01024         *yy_cp = yy_hold_char;
    01025         YY_RESTORE_YY_MORE_OFFSET
    01026
    01027         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
    01028             {
    01029             /* We're scanning a new file or input source.  It's
    01030              * possible that this happened because the user
    01031              * just pointed yyin at a new source and called
    01032              * yylex().  If so, then we have to assure
    01033              * consistency between yy_current_buffer and our
    01034              * globals.  Here is the right place to do so, because
    01035              * this is the first action (other than possibly a
    01036              * back-up) that will match for the new input source.
    01037              */
    01038             yy_n_chars = yy_current_buffer->yy_n_chars;
    01039             yy_current_buffer->yy_input_file = yyin;
    01040             yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
    01041             }
    01042
    01043         /* Note that here we test for yy_c_buf_p "<=" to the position
    01044          * of the first EOB in the buffer, since yy_c_buf_p will
    01045          * already have been incremented past the NUL character
    01046          * (since all states make transitions on EOB to the
    01047          * end-of-buffer state).  Contrast this with the test
    01048          * in input().
    01049          */
    01050         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
    01051             { /* This was really a NUL. */
    01052             yy_state_type yy_next_state;
    01053
    01054             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
    01055
    01056             yy_current_state = yy_get_previous_state();
    01057
    01058             /* Okay, we're now positioned to make the NUL
    01059              * transition.  We couldn't have
    01060              * yy_get_previous_state() go ahead and do it
    01061              * for us because it doesn't know how to deal
    01062              * with the possibility of jamming (and we don't
    01063              * want to build jamming into it because then it
    01064              * will run more slowly).
    01065              */
    01066
    01067             yy_next_state = yy_try_NUL_trans( yy_current_state );
    01068
    01069             yy_bp = yytext_ptr + YY_MORE_ADJ;
    01070
    01071             if ( yy_next_state )
    01072                 {
    01073                 /* Consume the NUL. */
    01074                 yy_cp = ++yy_c_buf_p;
    01075                 yy_current_state = yy_next_state;
    01076                 goto yy_match;
    01077                 }
    01078
    01079             else
    01080                 {
    01081                 yy_cp = yy_c_buf_p;
    01082                 goto yy_find_action;
    01083                 }
    01084             }
    01085
    01086         else switch ( yy_get_next_buffer() )
    01087             {
    01088             case EOB_ACT_END_OF_FILE:
    01089                 {
    01090                 yy_did_buffer_switch_on_eof = 0;
    01091
    01092                 if ( yywrap() )
    01093                     {
    01094                     /* Note: because we've taken care in
    01095                      * yy_get_next_buffer() to have set up
    01096                      * yytext, we can now set up
    01097                      * yy_c_buf_p so that if some total
    01098                      * hoser (like flex itself) wants to
    01099                      * call the scanner after we return the
    01100                      * YY_NULL, it'll still work - another
    01101                      * YY_NULL will get returned.
    01102                      */
    01103                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
    01104
    01105                     yy_act = YY_STATE_EOF(YY_START);
    01106                     goto do_action;
    01107                     }
    01108
    01109                 else
    01110                     {
    01111                     if ( ! yy_did_buffer_switch_on_eof )
    01112                         YY_NEW_FILE;
    01113                     }
    01114                 break;
    01115                 }
    01116
    01117             case EOB_ACT_CONTINUE_SCAN:
    01118                 yy_c_buf_p =
    01119                     yytext_ptr + yy_amount_of_matched_text;
    01120
    01121                 yy_current_state = yy_get_previous_state();
    01122
    01123                 yy_cp = yy_c_buf_p;
    01124                 yy_bp = yytext_ptr + YY_MORE_ADJ;
    01125                 goto yy_match;
    01126
    01127             case EOB_ACT_LAST_MATCH:
    01128                 yy_c_buf_p =
    01129                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
    01130
    01131                 yy_current_state = yy_get_previous_state();
    01132
    01133                 yy_cp = yy_c_buf_p;
    01134                 yy_bp = yytext_ptr + YY_MORE_ADJ;
    01135                 goto yy_find_action;
    01136             }
    01137         break;
    01138         }
    01139
    01140     default:
    01141         YY_FATAL_ERROR(
    01142             "fatal flex scanner internal error--no action found" );
    01143     } /* end of action switch */
    01144         } /* end of scanning one token */
    01145     } /* end of yylex */
    01146
    01147
    01148 /* yy_get_next_buffer - try to read in a new buffer
    01149  *
    01150  * Returns a code representing an action:
    01151  *  EOB_ACT_LAST_MATCH -
    01152  *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
    01153  *  EOB_ACT_END_OF_FILE - end of file
    01154  */
    01155
    01156 static int yy_get_next_buffer()
    01157     {
    01158     register char *dest = yy_current_buffer->yy_ch_buf;
    01159     register char *source = yytext_ptr;
    01160     register int number_to_move, i;
    01161     int ret_val;
    01162
    01163     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
    01164         YY_FATAL_ERROR(
    01165         "fatal flex scanner internal error--end of buffer missed" );
    01166
    01167     if ( yy_current_buffer->yy_fill_buffer == 0 )
    01168         { /* Don't try to fill the buffer, so this is an EOF. */
    01169         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
    01170             {
    01171             /* We matched a single character, the EOB, so
    01172              * treat this as a final EOF.
    01173              */
    01174             return EOB_ACT_END_OF_FILE;
    01175             }
    01176
    01177         else
    01178             {
    01179             /* We matched some text prior to the EOB, first
    01180              * process it.
    01181              */
    01182             return EOB_ACT_LAST_MATCH;
    01183             }
    01184         }
    01185
    01186     /* Try to read more data. */
    01187
    01188     /* First move last chars to start of buffer. */
    01189     number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
    01190
    01191     for ( i = 0; i < number_to_move; ++i )
    01192         *(dest++) = *(source++);
    01193
    01194     if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    01195         /* don't do the read, it's not guaranteed to return an EOF,
    01196          * just force an EOF
    01197          */
    01198         yy_current_buffer->yy_n_chars = yy_n_chars = 0;
    01199
    01200     else
    01201         {
    01202         int num_to_read =
    01203             yy_current_buffer->yy_buf_size - number_to_move - 1;
    01204
    01205         while ( num_to_read <= 0 )
    01206             { /* Not enough room in the buffer - grow it. */
    01207 #ifdef YY_USES_REJECT
    01208             YY_FATAL_ERROR(
    01209 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
    01210 #else
    01211
    01212             /* just a shorter name for the current buffer */
    01213             YY_BUFFER_STATE b = yy_current_buffer;
    01214
    01215             int yy_c_buf_p_offset =
    01216                 (int) (yy_c_buf_p - b->yy_ch_buf);
    01217
    01218             if ( b->yy_is_our_buffer )
    01219                 {
    01220                 int new_size = b->yy_buf_size * 2;
    01221
    01222                 if ( new_size <= 0 )
    01223                     b->yy_buf_size += b->yy_buf_size / 8;
    01224                 else
    01225                     b->yy_buf_size *= 2;
    01226
    01227                 b->yy_ch_buf = (char *)
    01228                     /* Include room in for 2 EOB chars. */
    01229                     yy_flex_realloc( (void *) b->yy_ch_buf,
    01230                              b->yy_buf_size + 2 );
    01231                 }
    01232             else
    01233                 /* Can't grow it, we don't own it. */
    01234                 b->yy_ch_buf = 0;
    01235
    01236             if ( ! b->yy_ch_buf )
    01237                 YY_FATAL_ERROR(
    01238                 "fatal error - scanner input buffer overflow" );
    01239
    01240             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
    01241
    01242             num_to_read = yy_current_buffer->yy_buf_size -
    01243                         number_to_move - 1;
    01244 #endif
    01245             }
    01246
    01247         if ( num_to_read > YY_READ_BUF_SIZE )
    01248             num_to_read = YY_READ_BUF_SIZE;
    01249
    01250         /* Read in more data. */
    01251         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
    01252             yy_n_chars, num_to_read );
    01253
    01254         yy_current_buffer->yy_n_chars = yy_n_chars;
    01255         }
    01256
    01257     if ( yy_n_chars == 0 )
    01258         {
    01259         if ( number_to_move == YY_MORE_ADJ )
    01260             {
    01261             ret_val = EOB_ACT_END_OF_FILE;
    01262             yyrestart( yyin );
    01263             }
    01264
    01265         else
    01266             {
    01267             ret_val = EOB_ACT_LAST_MATCH;
    01268             yy_current_buffer->yy_buffer_status =
    01269                 YY_BUFFER_EOF_PENDING;
    01270             }
    01271         }
    01272
    01273     else
    01274         ret_val = EOB_ACT_CONTINUE_SCAN;
    01275
    01276     yy_n_chars += number_to_move;
    01277     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
    01278     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
    01279
    01280     yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
    01281
    01282     return ret_val;
    01283     }
    01284
    01285
    01286 /* yy_get_previous_state - get the state just before the EOB char was reached */
    01287
    01288 static yy_state_type yy_get_previous_state()
    01289     {
    01290     register yy_state_type yy_current_state;
    01291     register char *yy_cp;
    01292
    01293     yy_current_state = yy_start;
    01294
    01295     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
    01296         {
    01297         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
    01298         if ( yy_accept[yy_current_state] )
    01299             {
    01300             yy_last_accepting_state = yy_current_state;
    01301             yy_last_accepting_cpos = yy_cp;
    01302             }
    01303         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    01304             {
    01305             yy_current_state = (int) yy_def[yy_current_state];
    01306             if ( yy_current_state >= 172 )
    01307                 yy_c = yy_meta[(unsigned int) yy_c];
    01308             }
    01309         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    01310         }
    01311
    01312     return yy_current_state;
    01313     }
    01314
    01315
    01316 /* yy_try_NUL_trans - try to make a transition on the NUL character
    01317  *
    01318  * synopsis
    01319  *  next_state = yy_try_NUL_trans( current_state );
    01320  */
    01321
    01322 #ifdef YY_USE_PROTOS
    01323 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
    01324 #else
    01325 static yy_state_type yy_try_NUL_trans( yy_current_state )
    01326 yy_state_type yy_current_state;
    01327 #endif
    01328     {
    01329     register int yy_is_jam;
    01330     register char *yy_cp = yy_c_buf_p;
    01331
    01332     register YY_CHAR yy_c = 1;
    01333     if ( yy_accept[yy_current_state] )
    01334         {
    01335         yy_last_accepting_state = yy_current_state;
    01336         yy_last_accepting_cpos = yy_cp;
    01337         }
    01338     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    01339         {
    01340         yy_current_state = (int) yy_def[yy_current_state];
    01341         if ( yy_current_state >= 172 )
    01342             yy_c = yy_meta[(unsigned int) yy_c];
    01343         }
    01344     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    01345     yy_is_jam = (yy_current_state == 171);
    01346
    01347     return yy_is_jam ? 0 : yy_current_state;
    01348     }
    01349
    01350
    01351 #ifndef YY_NO_UNPUT
    01352 #ifdef YY_USE_PROTOS
    01353 static void yyunput( int c, register char *yy_bp )
    01354 #else
    01355 static void yyunput( c, yy_bp )
    01356 int c;
    01357 register char *yy_bp;
    01358 #endif
    01359     {
    01360     register char *yy_cp = yy_c_buf_p;
    01361
    01362     /* undo effects of setting up yytext */
    01363     *yy_cp = yy_hold_char;
    01364
    01365     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
    01366         { /* need to shift things up to make room */
    01367         /* +2 for EOB chars. */
    01368         register int number_to_move = yy_n_chars + 2;
    01369         register char *dest = &yy_current_buffer->yy_ch_buf[
    01370                     yy_current_buffer->yy_buf_size + 2];
    01371         register char *source =
    01372                 &yy_current_buffer->yy_ch_buf[number_to_move];
    01373
    01374         while ( source > yy_current_buffer->yy_ch_buf )
    01375             *--dest = *--source;
    01376
    01377         yy_cp += (int) (dest - source);
    01378         yy_bp += (int) (dest - source);
    01379         yy_current_buffer->yy_n_chars =
    01380             yy_n_chars = yy_current_buffer->yy_buf_size;
    01381
    01382         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
    01383             YY_FATAL_ERROR( "flex scanner push-back overflow" );
    01384         }
    01385
    01386     *--yy_cp = (char) c;
    01387
    01388
    01389     yytext_ptr = yy_bp;
    01390     yy_hold_char = *yy_cp;
    01391     yy_c_buf_p = yy_cp;
    01392     }
    01393 #endif  /* ifndef YY_NO_UNPUT */
    01394
    01395
    01396 #ifdef __cplusplus
    01397 static int yyinput()
    01398 #else
    01399 static int input()
    01400 #endif
    01401     {
    01402     int c;
    01403
    01404     *yy_c_buf_p = yy_hold_char;
    01405
    01406     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
    01407         {
    01408         /* yy_c_buf_p now points to the character we want to return.
    01409          * If this occurs *before* the EOB characters, then it's a
    01410          * valid NUL; if not, then we've hit the end of the buffer.
    01411          */
    01412         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
    01413             /* This was really a NUL. */
    01414             *yy_c_buf_p = '\0';
    01415
    01416         else
    01417             { /* need more input */
    01418             int offset = yy_c_buf_p - yytext_ptr;
    01419             ++yy_c_buf_p;
    01420
    01421             switch ( yy_get_next_buffer() )
    01422                 {
    01423                 case EOB_ACT_LAST_MATCH:
    01424                     /* This happens because yy_g_n_b()
    01425                      * sees that we've accumulated a
    01426                      * token and flags that we need to
    01427                      * try matching the token before
    01428                      * proceeding.  But for input(),
    01429                      * there's no matching to consider.
    01430                      * So convert the EOB_ACT_LAST_MATCH
    01431                      * to EOB_ACT_END_OF_FILE.
    01432                      */
    01433
    01434                     /* Reset buffer status. */
    01435                     yyrestart( yyin );
    01436
    01437                     /* fall through */
    01438
    01439                 case EOB_ACT_END_OF_FILE:
    01440                     {
    01441                     if ( yywrap() )
    01442                         return EOF;
    01443
    01444                     if ( ! yy_did_buffer_switch_on_eof )
    01445                         YY_NEW_FILE;
    01446 #ifdef __cplusplus
    01447                     return yyinput();
    01448 #else
    01449                     return input();
    01450 #endif
    01451                     }
    01452
    01453                 case EOB_ACT_CONTINUE_SCAN:
    01454                     yy_c_buf_p = yytext_ptr + offset;
    01455                     break;
    01456                 }
    01457             }
    01458         }
    01459
    01460     c = *(unsigned char *) yy_c_buf_p;  /* cast for 8-bit char's */
    01461     *yy_c_buf_p = '\0'; /* preserve yytext */
    01462     yy_hold_char = *++yy_c_buf_p;
    01463
    01464
    01465     return c;
    01466     }
    01467
    01468
    01469 #ifdef YY_USE_PROTOS
    01470 void yyrestart( FILE *input_file )
    01471 #else
    01472 void yyrestart( input_file )
    01473 FILE *input_file;
    01474 #endif
    01475     {
    01476     if ( ! yy_current_buffer )
    01477         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
    01478
    01479     yy_init_buffer( yy_current_buffer, input_file );
    01480     yy_load_buffer_state();
    01481     }
    01482
    01483
    01484 #ifdef YY_USE_PROTOS
    01485 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
    01486 #else
    01487 void yy_switch_to_buffer( new_buffer )
    01488 YY_BUFFER_STATE new_buffer;
    01489 #endif
    01490     {
    01491     if ( yy_current_buffer == new_buffer )
    01492         return;
    01493
    01494     if ( yy_current_buffer )
    01495         {
    01496         /* Flush out information for old buffer. */
    01497         *yy_c_buf_p = yy_hold_char;
    01498         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
    01499         yy_current_buffer->yy_n_chars = yy_n_chars;
    01500         }
    01501
    01502     yy_current_buffer = new_buffer;
    01503     yy_load_buffer_state();
    01504
    01505     /* We don't actually know whether we did this switch during
    01506      * EOF (yywrap()) processing, but the only time this flag
    01507      * is looked at is after yywrap() is called, so it's safe
    01508      * to go ahead and always set it.
    01509      */
    01510     yy_did_buffer_switch_on_eof = 1;
    01511     }
    01512
    01513
    01514 #ifdef YY_USE_PROTOS
    01515 void yy_load_buffer_state( void )
    01516 #else
    01517 void yy_load_buffer_state()
    01518 #endif
    01519     {
    01520     yy_n_chars = yy_current_buffer->yy_n_chars;
    01521     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
    01522     yyin = yy_current_buffer->yy_input_file;
    01523     yy_hold_char = *yy_c_buf_p;
    01524     }
    01525
    01526
    01527 #ifdef YY_USE_PROTOS
    01528 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
    01529 #else
    01530 YY_BUFFER_STATE yy_create_buffer( file, size )
    01531 FILE *file;
    01532 int size;
    01533 #endif
    01534     {
    01535     YY_BUFFER_STATE b;
    01536
    01537     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
    01538     if ( ! b )
    01539         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    01540
    01541     b->yy_buf_size = size;
    01542
    01543     /* yy_ch_buf has to be 2 characters longer than the size given because
    01544      * we need to put in 2 end-of-buffer characters.
    01545      */
    01546     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
    01547     if ( ! b->yy_ch_buf )
    01548         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    01549
    01550     b->yy_is_our_buffer = 1;
    01551
    01552     yy_init_buffer( b, file );
    01553
    01554     return b;
    01555     }
    01556
    01557
    01558 #ifdef YY_USE_PROTOS
    01559 void yy_delete_buffer( YY_BUFFER_STATE b )
    01560 #else
    01561 void yy_delete_buffer( b )
    01562 YY_BUFFER_STATE b;
    01563 #endif
    01564     {
    01565     if ( ! b )
    01566         return;
    01567
    01568     if ( b == yy_current_buffer )
    01569         yy_current_buffer = (YY_BUFFER_STATE) 0;
    01570
    01571     if ( b->yy_is_our_buffer )
    01572         yy_flex_free( (void *) b->yy_ch_buf );
    01573
    01574     yy_flex_free( (void *) b );
    01575     }
    01576
    01577
    01578
    01579 #ifdef YY_USE_PROTOS
    01580 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
    01581 #else
    01582 void yy_init_buffer( b, file )
    01583 YY_BUFFER_STATE b;
    01584 FILE *file;
    01585 #endif
    01586
    01587
    01588     {
    01589     yy_flush_buffer( b );
    01590
    01591     b->yy_input_file = file;
    01592     b->yy_fill_buffer = 1;
    01593
    01594 #if YY_ALWAYS_INTERACTIVE
    01595     b->yy_is_interactive = 1;
    01596 #else
    01597 #if YY_NEVER_INTERACTIVE
    01598     b->yy_is_interactive = 0;
    01599 #else
    01600     b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    01601 #endif
    01602 #endif
    01603     }
    01604
    01605
    01606 #ifdef YY_USE_PROTOS
    01607 void yy_flush_buffer( YY_BUFFER_STATE b )
    01608 #else
    01609 void yy_flush_buffer( b )
    01610 YY_BUFFER_STATE b;
    01611 #endif
    01612
    01613     {
    01614     if ( ! b )
    01615         return;
    01616
    01617     b->yy_n_chars = 0;
    01618
    01619     /* We always need two end-of-buffer characters.  The first causes
    01620      * a transition to the end-of-buffer state.  The second causes
    01621      * a jam in that state.
    01622      */
    01623     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    01624     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
    01625
    01626     b->yy_buf_pos = &b->yy_ch_buf[0];
    01627
    01628     b->yy_at_bol = 1;
    01629     b->yy_buffer_status = YY_BUFFER_NEW;
    01630
    01631     if ( b == yy_current_buffer )
    01632         yy_load_buffer_state();
    01633     }
    01634
    01635
    01636 #ifndef YY_NO_SCAN_BUFFER
    01637 #ifdef YY_USE_PROTOS
    01638 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
    01639 #else
    01640 YY_BUFFER_STATE yy_scan_buffer( base, size )
    01641 char *base;
    01642 yy_size_t size;
    01643 #endif
    01644     {
    01645     YY_BUFFER_STATE b;
    01646
    01647     if ( size < 2 ||
    01648          base[size-2] != YY_END_OF_BUFFER_CHAR ||
    01649          base[size-1] != YY_END_OF_BUFFER_CHAR )
    01650         /* They forgot to leave room for the EOB's. */
    01651         return 0;
    01652
    01653     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
    01654     if ( ! b )
    01655         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
    01656
    01657     b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
    01658     b->yy_buf_pos = b->yy_ch_buf = base;
    01659     b->yy_is_our_buffer = 0;
    01660     b->yy_input_file = 0;
    01661     b->yy_n_chars = b->yy_buf_size;
    01662     b->yy_is_interactive = 0;
    01663     b->yy_at_bol = 1;
    01664     b->yy_fill_buffer = 0;
    01665     b->yy_buffer_status = YY_BUFFER_NEW;
    01666
    01667     yy_switch_to_buffer( b );
    01668
    01669     return b;
    01670     }
    01671 #endif
    01672
    01673
    01674 #ifndef YY_NO_SCAN_STRING
    01675 #ifdef YY_USE_PROTOS
    01676 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
    01677 #else
    01678 YY_BUFFER_STATE yy_scan_string( yy_str )
    01679 yyconst char *yy_str;
    01680 #endif
    01681     {
    01682     int len;
    01683     for ( len = 0; yy_str[len]; ++len )
    01684         ;
    01685
    01686     return yy_scan_bytes( yy_str, len );
    01687     }
    01688 #endif
    01689
    01690
    01691 #ifndef YY_NO_SCAN_BYTES
    01692 #ifdef YY_USE_PROTOS
    01693 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
    01694 #else
    01695 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
    01696 yyconst char *bytes;
    01697 int len;
    01698 #endif
    01699     {
    01700     YY_BUFFER_STATE b;
    01701     char *buf;
    01702     yy_size_t n;
    01703     int i;
    01704
    01705     /* Get memory for full buffer, including space for trailing EOB's. */
    01706     n = len + 2;
    01707     buf = (char *) yy_flex_alloc( n );
    01708     if ( ! buf )
    01709         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
    01710
    01711     for ( i = 0; i < len; ++i )
    01712         buf[i] = bytes[i];
    01713
    01714     buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
    01715
    01716     b = yy_scan_buffer( buf, n );
    01717     if ( ! b )
    01718         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
    01719
    01720     /* It's okay to grow etc. this buffer, and we should throw it
    01721      * away when we're done.
    01722      */
    01723     b->yy_is_our_buffer = 1;
    01724
    01725     return b;
    01726     }
    01727 #endif
    01728
    01729
    01730 #ifndef YY_NO_PUSH_STATE
    01731 #ifdef YY_USE_PROTOS
    01732 static void yy_push_state( int new_state )
    01733 #else
    01734 static void yy_push_state( new_state )
    01735 int new_state;
    01736 #endif
    01737     {
    01738     if ( yy_start_stack_ptr >= yy_start_stack_depth )
    01739         {
    01740         yy_size_t new_size;
    01741
    01742         yy_start_stack_depth += YY_START_STACK_INCR;
    01743         new_size = yy_start_stack_depth * sizeof( int );
    01744
    01745         if ( ! yy_start_stack )
    01746             yy_start_stack = (int *) yy_flex_alloc( new_size );
    01747
    01748         else
    01749             yy_start_stack = (int *) yy_flex_realloc(
    01750                     (void *) yy_start_stack, new_size );
    01751
    01752         if ( ! yy_start_stack )
    01753             YY_FATAL_ERROR(
    01754             "out of memory expanding start-condition stack" );
    01755         }
    01756
    01757     yy_start_stack[yy_start_stack_ptr++] = YY_START;
    01758
    01759     BEGIN(new_state);
    01760     }
    01761 #endif
    01762
    01763
    01764 #ifndef YY_NO_POP_STATE
    01765 static void yy_pop_state()
    01766     {
    01767     if ( --yy_start_stack_ptr < 0 )
    01768         YY_FATAL_ERROR( "start-condition stack underflow" );
    01769
    01770     BEGIN(yy_start_stack[yy_start_stack_ptr]);
    01771     }
    01772 #endif
    01773
    01774
    01775 #ifndef YY_NO_TOP_STATE
    01776 static int yy_top_state()
    01777     {
    01778     return yy_start_stack[yy_start_stack_ptr - 1];
    01779     }
    01780 #endif
    01781
    01782 #ifndef YY_EXIT_FAILURE
    01783 #define YY_EXIT_FAILURE 2
    01784 #endif
    01785
    01786 #ifdef YY_USE_PROTOS
    01787 static void yy_fatal_error( yyconst char msg[] )
    01788 #else
    01789 static void yy_fatal_error( msg )
    01790 char msg[];
    01791 #endif
    01792     {
    01793     (void) fprintf( stderr, "%s\n", msg );
    01794     exit( YY_EXIT_FAILURE );
    01795     }
    01796
    01797
    01798
    01799 /* Redefine yyless() so it works in section 3 code. */
    01800
    01801 #undef yyless
    01802 #define yyless(n) \
    01803     do \
    01804         { \
    01805         /* Undo effects of setting up yytext. */ \
    01806         yytext[yyleng] = yy_hold_char; \
    01807         yy_c_buf_p = yytext + n; \
    01808         yy_hold_char = *yy_c_buf_p; \
    01809         *yy_c_buf_p = '\0'; \
    01810         yyleng = n; \
    01811         } \
    01812     while ( 0 )
    01813
    01814
    01815 /* Internal utility routines. */
    01816
    01817 #ifndef yytext_ptr
    01818 #ifdef YY_USE_PROTOS
    01819 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
    01820 #else
    01821 static void yy_flex_strncpy( s1, s2, n )
    01822 char *s1;
    01823 yyconst char *s2;
    01824 int n;
    01825 #endif
    01826     {
    01827     register int i;
    01828     for ( i = 0; i < n; ++i )
    01829         s1[i] = s2[i];
    01830     }
    01831 #endif
    01832
    01833 #ifdef YY_NEED_STRLEN
    01834 #ifdef YY_USE_PROTOS
    01835 static int yy_flex_strlen( yyconst char *s )
    01836 #else
    01837 static int yy_flex_strlen( s )
    01838 yyconst char *s;
    01839 #endif
    01840     {
    01841     register int n;
    01842     for ( n = 0; s[n]; ++n )
    01843         ;
    01844
    01845     return n;
    01846     }
    01847 #endif
    01848
    01849
    01850 #ifdef YY_USE_PROTOS
    01851 static void *yy_flex_alloc( yy_size_t size )
    01852 #else
    01853 static void *yy_flex_alloc( size )
    01854 yy_size_t size;
    01855 #endif
    01856     {
    01857     return (void *) malloc( size );
    01858     }
    01859
    01860 #ifdef YY_USE_PROTOS
    01861 static void *yy_flex_realloc( void *ptr, yy_size_t size )
    01862 #else
    01863 static void *yy_flex_realloc( ptr, size )
    01864 void *ptr;
    01865 yy_size_t size;
    01866 #endif
    01867     {
    01868     /* The cast to (char *) in the following accommodates both
    01869      * implementations that use char* generic pointers, and those
    01870      * that use void* generic pointers.  It works with the latter
    01871      * because both ANSI C and C++ allow castless assignment from
    01872      * any pointer type to void*, and deal with argument conversions
    01873      * as though doing an assignment.
    01874      */
    01875     return (void *) realloc( (char *) ptr, size );
    01876     }
    01877
    01878 #ifdef YY_USE_PROTOS
    01879 static void yy_flex_free( void *ptr )
    01880 #else
    01881 static void yy_flex_free( ptr )
    01882 void *ptr;
    01883 #endif
    01884     {
    01885     free( ptr );
    01886     }
    01887
    01888 #if YY_MAIN
    01889 int main()
    01890     {
    01891     yylex();
    01892     return 0;
    01893     }
    01894 #endif
    01895 #line 123 "./ppdscanner.l"
    01896
    01897
    01898 void kdeprint_ppdscanner_init(QIODevice *d)
    01899 {
    01900     kdeprint_ppdscanner_device = d;
    01901     kdeprint_ppdscanner_lno = 1;
    01902 }
    01903
    01904 void kdeprint_ppdscanner_terminate( bool deleteIt )
    01905 {
    01906     if (deleteIt)
    01907         delete kdeprint_ppdscanner_device;
    01908     kdeprint_ppdscanner_device = NULL;
    01909 }
    01910
    01911 int kdeprint_ppdscanner_numberoflines()
    01912 {
    01913     return kdeprint_ppdscanner_lno;
    01914 }

This file is part of the documentation for kdeprint Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:31:06 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003