kdeprint Library API Documentation

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: /home/kde/kdelibs/kdeprint/ppdscanner.cpp,v 1.2.2.1 2004/03/15 10:30:20 goffioul Exp $
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 
00561 #if 0
00562 #define QDEBUG0(s) qDebug(s)
00563 #define QDEBUG1(s,a) qDebug(s,a)
00564 #else
00565 #define QDEBUG0(s)
00566 #define QDEBUG1(s,a)
00567 #endif
00568 #define option 1
00569 #define value 2
00570 #define translation_1 3
00571 #define translation_2 4
00572 #define constr 5
00573 
00574 #line 575 "./ppdscanner.cpp"
00575 
00576 /* Macros after this point can all be overridden by user definitions in
00577  * section 1.
00578  */
00579 
00580 #ifndef YY_SKIP_YYWRAP
00581 #ifdef __cplusplus
00582 extern "C" int yywrap YY_PROTO(( void ));
00583 #else
00584 extern int yywrap YY_PROTO(( void ));
00585 #endif
00586 #endif
00587 
00588 #ifndef YY_NO_UNPUT
00589 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
00590 #endif
00591 
00592 #ifndef yytext_ptr
00593 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
00594 #endif
00595 
00596 #ifdef YY_NEED_STRLEN
00597 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
00598 #endif
00599 
00600 #ifndef YY_NO_INPUT
00601 #ifdef __cplusplus
00602 static int yyinput YY_PROTO(( void ));
00603 #else
00604 static int input YY_PROTO(( void ));
00605 #endif
00606 #endif
00607 
00608 #if YY_STACK_USED
00609 static int yy_start_stack_ptr = 0;
00610 static int yy_start_stack_depth = 0;
00611 static int *yy_start_stack = 0;
00612 #ifndef YY_NO_PUSH_STATE
00613 static void yy_push_state YY_PROTO(( int new_state ));
00614 #endif
00615 #ifndef YY_NO_POP_STATE
00616 static void yy_pop_state YY_PROTO(( void ));
00617 #endif
00618 #ifndef YY_NO_TOP_STATE
00619 static int yy_top_state YY_PROTO(( void ));
00620 #endif
00621 
00622 #else
00623 #define YY_NO_PUSH_STATE 1
00624 #define YY_NO_POP_STATE 1
00625 #define YY_NO_TOP_STATE 1
00626 #endif
00627 
00628 #ifdef YY_MALLOC_DECL
00629 YY_MALLOC_DECL
00630 #else
00631 #if __STDC__
00632 #ifndef __cplusplus
00633 #include <stdlib.h>
00634 #endif
00635 #else
00636 /* Just try to get by without declaring the routines.  This will fail
00637  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
00638  * or sizeof(void*) != sizeof(int).
00639  */
00640 #endif
00641 #endif
00642 
00643 /* Amount of stuff to slurp up with each read. */
00644 #ifndef YY_READ_BUF_SIZE
00645 #define YY_READ_BUF_SIZE 8192
00646 #endif
00647 
00648 /* Copy whatever the last rule matched to the standard output. */
00649 
00650 #ifndef ECHO
00651 /* This used to be an fputs(), but since the string might contain NUL's,
00652  * we now use fwrite().
00653  */
00654 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
00655 #endif
00656 
00657 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
00658  * is returned in "result".
00659  */
00660 #ifndef YY_INPUT
00661 #define YY_INPUT(buf,result,max_size) \
00662     if ( yy_current_buffer->yy_is_interactive ) \
00663         { \
00664         int c = '*', n; \
00665         for ( n = 0; n < max_size && \
00666                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00667             buf[n] = (char) c; \
00668         if ( c == '\n' ) \
00669             buf[n++] = (char) c; \
00670         if ( c == EOF && ferror( yyin ) ) \
00671             YY_FATAL_ERROR( "input in flex scanner failed" ); \
00672         result = n; \
00673         } \
00674     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
00675           && ferror( yyin ) ) \
00676         YY_FATAL_ERROR( "input in flex scanner failed" );
00677 #endif
00678 
00679 /* No semi-colon after return; correct usage is to write "yyterminate();" -
00680  * we don't want an extra ';' after the "return" because that will cause
00681  * some compilers to complain about unreachable statements.
00682  */
00683 #ifndef yyterminate
00684 #define yyterminate() return YY_NULL
00685 #endif
00686 
00687 /* Number of entries by which start-condition stack grows. */
00688 #ifndef YY_START_STACK_INCR
00689 #define YY_START_STACK_INCR 25
00690 #endif
00691 
00692 /* Report a fatal error. */
00693 #ifndef YY_FATAL_ERROR
00694 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
00695 #endif
00696 
00697 /* Default declaration of generated scanner - a define so the user can
00698  * easily add parameters.
00699  */
00700 #ifndef YY_DECL
00701 #define YY_DECL int yylex YY_PROTO(( void ))
00702 #endif
00703 
00704 /* Code executed at the beginning of each rule, after yytext and yyleng
00705  * have been set up.
00706  */
00707 #ifndef YY_USER_ACTION
00708 #define YY_USER_ACTION
00709 #endif
00710 
00711 /* Code executed at the end of each rule. */
00712 #ifndef YY_BREAK
00713 #define YY_BREAK break;
00714 #endif
00715 
00716 #define YY_RULE_SETUP \
00717     YY_USER_ACTION
00718 
00719 YY_DECL
00720     {
00721     register yy_state_type yy_current_state;
00722     register char *yy_cp, *yy_bp;
00723     register int yy_act;
00724 
00725 #line 58 "./ppdscanner.l"
00726 
00727 
00731 #line 732 "./ppdscanner.cpp"
00732 
00733     if ( yy_init )
00734         {
00735         yy_init = 0;
00736 
00737 #ifdef YY_USER_INIT
00738         YY_USER_INIT;
00739 #endif
00740 
00741         if ( ! yy_start )
00742             yy_start = 1;   /* first start state */
00743 
00744         if ( ! yyin )
00745             yyin = stdin;
00746 
00747         if ( ! yyout )
00748             yyout = stdout;
00749 
00750         if ( ! yy_current_buffer )
00751             yy_current_buffer =
00752                 yy_create_buffer( yyin, YY_BUF_SIZE );
00753 
00754         yy_load_buffer_state();
00755         }
00756 
00757     while ( 1 )     /* loops until end-of-file is reached */
00758         {
00759         yy_cp = yy_c_buf_p;
00760 
00761         /* Support of yytext. */
00762         *yy_cp = yy_hold_char;
00763 
00764         /* yy_bp points to the position in yy_ch_buf of the start of
00765          * the current run.
00766          */
00767         yy_bp = yy_cp;
00768 
00769         yy_current_state = yy_start;
00770 yy_match:
00771         do
00772             {
00773             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00774             if ( yy_accept[yy_current_state] )
00775                 {
00776                 yy_last_accepting_state = yy_current_state;
00777                 yy_last_accepting_cpos = yy_cp;
00778                 }
00779             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00780                 {
00781                 yy_current_state = (int) yy_def[yy_current_state];
00782                 if ( yy_current_state >= 172 )
00783                     yy_c = yy_meta[(unsigned int) yy_c];
00784                 }
00785             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00786             ++yy_cp;
00787             }
00788         while ( yy_base[yy_current_state] != 303 );
00789 
00790 yy_find_action:
00791         yy_act = yy_accept[yy_current_state];
00792         if ( yy_act == 0 )
00793             { /* have to back up */
00794             yy_cp = yy_last_accepting_cpos;
00795             yy_current_state = yy_last_accepting_state;
00796             yy_act = yy_accept[yy_current_state];
00797             }
00798 
00799         YY_DO_BEFORE_ACTION;
00800 
00801 
00802 do_action:  /* This label is used only to access EOF actions. */
00803 
00804 
00805         switch ( yy_act )
00806     { /* beginning of action switch */
00807             case 0: /* must back up */
00808             /* undo the effects of YY_DO_BEFORE_ACTION */
00809             *yy_cp = yy_hold_char;
00810             yy_cp = yy_last_accepting_cpos;
00811             yy_current_state = yy_last_accepting_state;
00812             goto yy_find_action;
00813 
00814 case 1:
00815 #line 64 "./ppdscanner.l"
00816 case 2:
00817 YY_RULE_SETUP
00818 #line 64 "./ppdscanner.l"
00819 { QDEBUG0("Open UI"); BEGIN(option); return OPENUI; }
00820     YY_BREAK
00821 case 3:
00822 #line 66 "./ppdscanner.l"
00823 case 4:
00824 YY_RULE_SETUP
00825 #line 66 "./ppdscanner.l"
00826 { QDEBUG0("Close UI"); BEGIN(value); return CLOSEUI; }
00827     YY_BREAK
00828 case 5:
00829 YY_RULE_SETUP
00830 #line 67 "./ppdscanner.l"
00831 { QDEBUG0("Open group"); BEGIN(option); return OPENGROUP; }
00832     YY_BREAK
00833 case 6:
00834 YY_RULE_SETUP
00835 #line 68 "./ppdscanner.l"
00836 { QDEBUG0("Close group"); BEGIN(option); return CLOSEGROUP; }
00837     YY_BREAK
00838 case 7:
00839 YY_RULE_SETUP
00840 #line 69 "./ppdscanner.l"
00841 { yylval = yytext+9; BEGIN(option); return DEFAULT; }
00842     YY_BREAK
00843 case 8:
00844 YY_RULE_SETUP
00845 #line 70 "./ppdscanner.l"
00846 { yylval = yytext+8; BEGIN(option); return DEFAULT; }
00847     YY_BREAK
00848 case 9:
00849 #line 72 "./ppdscanner.l"
00850 case 10:
00851 YY_RULE_SETUP
00852 #line 72 "./ppdscanner.l"
00853 { BEGIN(constr); return CONSTRAINT; }
00854     YY_BREAK
00855 case 11:
00856 YY_RULE_SETUP
00857 #line 73 "./ppdscanner.l"
00858 { BEGIN(option); return PAPERDIM; }
00859     YY_BREAK
00860 case 12:
00861 YY_RULE_SETUP
00862 #line 74 "./ppdscanner.l"
00863 { BEGIN(option); return IMGAREA; }
00864     YY_BREAK
00865 case 13:
00866 YY_RULE_SETUP
00867 #line 75 "./ppdscanner.l"
00868 { /* eat up */ }
00869     YY_BREAK
00870 case 14:
00871 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
00872 yy_c_buf_p = yy_cp -= 1;
00873 YY_DO_BEFORE_ACTION; /* set up yytext again */
00874 YY_RULE_SETUP
00875 #line 77 "./ppdscanner.l"
00876 { yylval = yytext+12; return FOODATA; }
00877     YY_BREAK
00878 case 15:
00879 YY_RULE_SETUP
00880 #line 78 "./ppdscanner.l"
00881 { QDEBUG0("Comment"); return COMMENT; }
00882     YY_BREAK
00883 case 16:
00884 YY_RULE_SETUP
00885 #line 79 "./ppdscanner.l"
00886 { yylval = yytext+1; QDEBUG1("Main keyword: %s",yytext+1); BEGIN(option); return KEYWORD; }
00887     YY_BREAK
00891 case 17:
00892 YY_RULE_SETUP
00893 #line 84 "./ppdscanner.l"
00894 { yylval = yytext; QDEBUG1("Option: %s",yytext); return OPTION; }
00895     YY_BREAK
00896 case 18:
00897 YY_RULE_SETUP
00898 #line 85 "./ppdscanner.l"
00899 { BEGIN(value); return ':'; }
00900     YY_BREAK
00901 case 19:
00902 YY_RULE_SETUP
00903 #line 86 "./ppdscanner.l"
00904 { BEGIN(INITIAL); }
00905     YY_BREAK
00906 case 20:
00907 YY_RULE_SETUP
00908 #line 87 "./ppdscanner.l"
00909 { BEGIN(translation_1); return '/'; }
00910     YY_BREAK
00914 case 21:
00915 YY_RULE_SETUP
00916 #line 92 "./ppdscanner.l"
00917 { yylval = yytext; QDEBUG1("Translation: %s",yytext); return TRANSLATION; }
00918     YY_BREAK
00919 case 22:
00920 YY_RULE_SETUP
00921 #line 93 "./ppdscanner.l"
00922 { BEGIN(value); return ':'; }
00923     YY_BREAK
00924 case 23:
00925 YY_RULE_SETUP
00926 #line 94 "./ppdscanner.l"
00927 { BEGIN(INITIAL); }
00928     YY_BREAK
00932 case 24:
00933 YY_RULE_SETUP
00934 #line 99 "./ppdscanner.l"
00935 { yylval = yytext; QDEBUG1("Quoted value: %s",yytext); return QUOTED; }
00936     YY_BREAK
00937 case 25:
00938 YY_RULE_SETUP
00939 #line 100 "./ppdscanner.l"
00940 { yylval = yytext; QDEBUG1("String part: %s",yytext); return STRINGPART; }
00941     YY_BREAK
00942 case 26:
00943 YY_RULE_SETUP
00944 #line 101 "./ppdscanner.l"
00945 { BEGIN(translation_2); return '/'; }
00946     YY_BREAK
00947 case 27:
00948 YY_RULE_SETUP
00949 #line 102 "./ppdscanner.l"
00950 { BEGIN(INITIAL); }
00951     YY_BREAK
00952 case 28:
00953 YY_RULE_SETUP
00954 #line 103 "./ppdscanner.l"
00955 { /* stay in the same state */ return ':'; }
00956     YY_BREAK
00960 case 29:
00961 YY_RULE_SETUP
00962 #line 108 "./ppdscanner.l"
00963 { yylval = yytext; QDEBUG1("Translation: %s",yytext); return TRANSLATION; }
00964     YY_BREAK
00965 case 30:
00966 YY_RULE_SETUP
00967 #line 109 "./ppdscanner.l"
00968 { BEGIN(INITIAL); }
00969     YY_BREAK
00973 case 31:
00974 YY_RULE_SETUP
00975 #line 114 "./ppdscanner.l"
00976 { return ':'; }
00977     YY_BREAK
00978 case 32:
00979 YY_RULE_SETUP
00980 #line 115 "./ppdscanner.l"
00981 { yylval = yytext+1; QDEBUG1("Constraint keyword: %s",yytext); return KEYWORD; }
00982     YY_BREAK
00983 case 33:
00984 YY_RULE_SETUP
00985 #line 116 "./ppdscanner.l"
00986 { yylval = yytext; QDEBUG1("Constraint option: %s",yytext); return OPTION; }
00987     YY_BREAK
00988 case 34:
00989 YY_RULE_SETUP
00990 #line 117 "./ppdscanner.l"
00991 { BEGIN(INITIAL); }
00992     YY_BREAK
00993 case 35:
00994 #line 120 "./ppdscanner.l"
00995 case 36:
00996 YY_RULE_SETUP
00997 #line 120 "./ppdscanner.l"
00998 { /* eat up */ }
00999     YY_BREAK
01000 case 37:
01001 YY_RULE_SETUP
01002 #line 122 "./ppdscanner.l"
01003 ECHO;
01004     YY_BREAK
01005 #line 1006 "./ppdscanner.cpp"
01006 case YY_STATE_EOF(INITIAL):
01007 case YY_STATE_EOF(option):
01008 case YY_STATE_EOF(value):
01009 case YY_STATE_EOF(translation_1):
01010 case YY_STATE_EOF(translation_2):
01011 case YY_STATE_EOF(constr):
01012     yyterminate();
01013 
01014     case YY_END_OF_BUFFER:
01015         {
01016         /* Amount of text matched not including the EOB char. */
01017         int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
01018 
01019         /* Undo the effects of YY_DO_BEFORE_ACTION. */
01020         *yy_cp = yy_hold_char;
01021         YY_RESTORE_YY_MORE_OFFSET
01022 
01023         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
01024             {
01025             /* We're scanning a new file or input source.  It's
01026              * possible that this happened because the user
01027              * just pointed yyin at a new source and called
01028              * yylex().  If so, then we have to assure
01029              * consistency between yy_current_buffer and our
01030              * globals.  Here is the right place to do so, because
01031              * this is the first action (other than possibly a
01032              * back-up) that will match for the new input source.
01033              */
01034             yy_n_chars = yy_current_buffer->yy_n_chars;
01035             yy_current_buffer->yy_input_file = yyin;
01036             yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
01037             }
01038 
01039         /* Note that here we test for yy_c_buf_p "<=" to the position
01040          * of the first EOB in the buffer, since yy_c_buf_p will
01041          * already have been incremented past the NUL character
01042          * (since all states make transitions on EOB to the
01043          * end-of-buffer state).  Contrast this with the test
01044          * in input().
01045          */
01046         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01047             { /* This was really a NUL. */
01048             yy_state_type yy_next_state;
01049 
01050             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
01051 
01052             yy_current_state = yy_get_previous_state();
01053 
01054             /* Okay, we're now positioned to make the NUL
01055              * transition.  We couldn't have
01056              * yy_get_previous_state() go ahead and do it
01057              * for us because it doesn't know how to deal
01058              * with the possibility of jamming (and we don't
01059              * want to build jamming into it because then it
01060              * will run more slowly).
01061              */
01062 
01063             yy_next_state = yy_try_NUL_trans( yy_current_state );
01064 
01065             yy_bp = yytext_ptr + YY_MORE_ADJ;
01066 
01067             if ( yy_next_state )
01068                 {
01069                 /* Consume the NUL. */
01070                 yy_cp = ++yy_c_buf_p;
01071                 yy_current_state = yy_next_state;
01072                 goto yy_match;
01073                 }
01074 
01075             else
01076                 {
01077                 yy_cp = yy_c_buf_p;
01078                 goto yy_find_action;
01079                 }
01080             }
01081 
01082         else switch ( yy_get_next_buffer() )
01083             {
01084             case EOB_ACT_END_OF_FILE:
01085                 {
01086                 yy_did_buffer_switch_on_eof = 0;
01087 
01088                 if ( yywrap() )
01089                     {
01090                     /* Note: because we've taken care in
01091                      * yy_get_next_buffer() to have set up
01092                      * yytext, we can now set up
01093                      * yy_c_buf_p so that if some total
01094                      * hoser (like flex itself) wants to
01095                      * call the scanner after we return the
01096                      * YY_NULL, it'll still work - another
01097                      * YY_NULL will get returned.
01098                      */
01099                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
01100 
01101                     yy_act = YY_STATE_EOF(YY_START);
01102                     goto do_action;
01103                     }
01104 
01105                 else
01106                     {
01107                     if ( ! yy_did_buffer_switch_on_eof )
01108                         YY_NEW_FILE;
01109                     }
01110                 break;
01111                 }
01112 
01113             case EOB_ACT_CONTINUE_SCAN:
01114                 yy_c_buf_p =
01115                     yytext_ptr + yy_amount_of_matched_text;
01116 
01117                 yy_current_state = yy_get_previous_state();
01118 
01119                 yy_cp = yy_c_buf_p;
01120                 yy_bp = yytext_ptr + YY_MORE_ADJ;
01121                 goto yy_match;
01122 
01123             case EOB_ACT_LAST_MATCH:
01124                 yy_c_buf_p =
01125                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
01126 
01127                 yy_current_state = yy_get_previous_state();
01128 
01129                 yy_cp = yy_c_buf_p;
01130                 yy_bp = yytext_ptr + YY_MORE_ADJ;
01131                 goto yy_find_action;
01132             }
01133         break;
01134         }
01135 
01136     default:
01137         YY_FATAL_ERROR(
01138             "fatal flex scanner internal error--no action found" );
01139     } /* end of action switch */
01140         } /* end of scanning one token */
01141     } /* end of yylex */
01142 
01143 
01144 /* yy_get_next_buffer - try to read in a new buffer
01145  *
01146  * Returns a code representing an action:
01147  *  EOB_ACT_LAST_MATCH -
01148  *  EOB_ACT_CONTINUE_SCAN - continue scanning from current position
01149  *  EOB_ACT_END_OF_FILE - end of file
01150  */
01151 
01152 static int yy_get_next_buffer()
01153     {
01154     register char *dest = yy_current_buffer->yy_ch_buf;
01155     register char *source = yytext_ptr;
01156     register int number_to_move, i;
01157     int ret_val;
01158 
01159     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
01160         YY_FATAL_ERROR(
01161         "fatal flex scanner internal error--end of buffer missed" );
01162 
01163     if ( yy_current_buffer->yy_fill_buffer == 0 )
01164         { /* Don't try to fill the buffer, so this is an EOF. */
01165         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
01166             {
01167             /* We matched a single character, the EOB, so
01168              * treat this as a final EOF.
01169              */
01170             return EOB_ACT_END_OF_FILE;
01171             }
01172 
01173         else
01174             {
01175             /* We matched some text prior to the EOB, first
01176              * process it.
01177              */
01178             return EOB_ACT_LAST_MATCH;
01179             }
01180         }
01181 
01182     /* Try to read more data. */
01183 
01184     /* First move last chars to start of buffer. */
01185     number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
01186 
01187     for ( i = 0; i < number_to_move; ++i )
01188         *(dest++) = *(source++);
01189 
01190     if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01191         /* don't do the read, it's not guaranteed to return an EOF,
01192          * just force an EOF
01193          */
01194         yy_current_buffer->yy_n_chars = yy_n_chars = 0;
01195 
01196     else
01197         {
01198         int num_to_read =
01199             yy_current_buffer->yy_buf_size - number_to_move - 1;
01200 
01201         while ( num_to_read <= 0 )
01202             { /* Not enough room in the buffer - grow it. */
01203 #ifdef YY_USES_REJECT
01204             YY_FATAL_ERROR(
01205 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
01206 #else
01207 
01208             /* just a shorter name for the current buffer */
01209             YY_BUFFER_STATE b = yy_current_buffer;
01210 
01211             int yy_c_buf_p_offset =
01212                 (int) (yy_c_buf_p - b->yy_ch_buf);
01213 
01214             if ( b->yy_is_our_buffer )
01215                 {
01216                 int new_size = b->yy_buf_size * 2;
01217 
01218                 if ( new_size <= 0 )
01219                     b->yy_buf_size += b->yy_buf_size / 8;
01220                 else
01221                     b->yy_buf_size *= 2;
01222 
01223                 b->yy_ch_buf = (char *)
01224                     /* Include room in for 2 EOB chars. */
01225                     yy_flex_realloc( (void *) b->yy_ch_buf,
01226                              b->yy_buf_size + 2 );
01227                 }
01228             else
01229                 /* Can't grow it, we don't own it. */
01230                 b->yy_ch_buf = 0;
01231 
01232             if ( ! b->yy_ch_buf )
01233                 YY_FATAL_ERROR(
01234                 "fatal error - scanner input buffer overflow" );
01235 
01236             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
01237 
01238             num_to_read = yy_current_buffer->yy_buf_size -
01239                         number_to_move - 1;
01240 #endif
01241             }
01242 
01243         if ( num_to_read > YY_READ_BUF_SIZE )
01244             num_to_read = YY_READ_BUF_SIZE;
01245 
01246         /* Read in more data. */
01247         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
01248             yy_n_chars, num_to_read );
01249 
01250         yy_current_buffer->yy_n_chars = yy_n_chars;
01251         }
01252 
01253     if ( yy_n_chars == 0 )
01254         {
01255         if ( number_to_move == YY_MORE_ADJ )
01256             {
01257             ret_val = EOB_ACT_END_OF_FILE;
01258             yyrestart( yyin );
01259             }
01260 
01261         else
01262             {
01263             ret_val = EOB_ACT_LAST_MATCH;
01264             yy_current_buffer->yy_buffer_status =
01265                 YY_BUFFER_EOF_PENDING;
01266             }
01267         }
01268 
01269     else
01270         ret_val = EOB_ACT_CONTINUE_SCAN;
01271 
01272     yy_n_chars += number_to_move;
01273     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
01274     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
01275 
01276     yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
01277 
01278     return ret_val;
01279     }
01280 
01281 
01282 /* yy_get_previous_state - get the state just before the EOB char was reached */
01283 
01284 static yy_state_type yy_get_previous_state()
01285     {
01286     register yy_state_type yy_current_state;
01287     register char *yy_cp;
01288 
01289     yy_current_state = yy_start;
01290 
01291     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
01292         {
01293         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01294         if ( yy_accept[yy_current_state] )
01295             {
01296             yy_last_accepting_state = yy_current_state;
01297             yy_last_accepting_cpos = yy_cp;
01298             }
01299         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01300             {
01301             yy_current_state = (int) yy_def[yy_current_state];
01302             if ( yy_current_state >= 172 )
01303                 yy_c = yy_meta[(unsigned int) yy_c];
01304             }
01305         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01306         }
01307 
01308     return yy_current_state;
01309     }
01310 
01311 
01312 /* yy_try_NUL_trans - try to make a transition on the NUL character
01313  *
01314  * synopsis
01315  *  next_state = yy_try_NUL_trans( current_state );
01316  */
01317 
01318 #ifdef YY_USE_PROTOS
01319 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
01320 #else
01321 static yy_state_type yy_try_NUL_trans( yy_current_state )
01322 yy_state_type yy_current_state;
01323 #endif
01324     {
01325     register int yy_is_jam;
01326     register char *yy_cp = yy_c_buf_p;
01327 
01328     register YY_CHAR yy_c = 1;
01329     if ( yy_accept[yy_current_state] )
01330         {
01331         yy_last_accepting_state = yy_current_state;
01332         yy_last_accepting_cpos = yy_cp;
01333         }
01334     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01335         {
01336         yy_current_state = (int) yy_def[yy_current_state];
01337         if ( yy_current_state >= 172 )
01338             yy_c = yy_meta[(unsigned int) yy_c];
01339         }
01340     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01341     yy_is_jam = (yy_current_state == 171);
01342 
01343     return yy_is_jam ? 0 : yy_current_state;
01344     }
01345 
01346 
01347 #ifndef YY_NO_UNPUT
01348 #ifdef YY_USE_PROTOS
01349 static void yyunput( int c, register char *yy_bp )
01350 #else
01351 static void yyunput( c, yy_bp )
01352 int c;
01353 register char *yy_bp;
01354 #endif
01355     {
01356     register char *yy_cp = yy_c_buf_p;
01357 
01358     /* undo effects of setting up yytext */
01359     *yy_cp = yy_hold_char;
01360 
01361     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01362         { /* need to shift things up to make room */
01363         /* +2 for EOB chars. */
01364         register int number_to_move = yy_n_chars + 2;
01365         register char *dest = &yy_current_buffer->yy_ch_buf[
01366                     yy_current_buffer->yy_buf_size + 2];
01367         register char *source =
01368                 &yy_current_buffer->yy_ch_buf[number_to_move];
01369 
01370         while ( source > yy_current_buffer->yy_ch_buf )
01371             *--dest = *--source;
01372 
01373         yy_cp += (int) (dest - source);
01374         yy_bp += (int) (dest - source);
01375         yy_current_buffer->yy_n_chars =
01376             yy_n_chars = yy_current_buffer->yy_buf_size;
01377 
01378         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01379             YY_FATAL_ERROR( "flex scanner push-back overflow" );
01380         }
01381 
01382     *--yy_cp = (char) c;
01383 
01384 
01385     yytext_ptr = yy_bp;
01386     yy_hold_char = *yy_cp;
01387     yy_c_buf_p = yy_cp;
01388     }
01389 #endif  /* ifndef YY_NO_UNPUT */
01390 
01391 
01392 #ifdef __cplusplus
01393 static int yyinput()
01394 #else
01395 static int input()
01396 #endif
01397     {
01398     int c;
01399 
01400     *yy_c_buf_p = yy_hold_char;
01401 
01402     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
01403         {
01404         /* yy_c_buf_p now points to the character we want to return.
01405          * If this occurs *before* the EOB characters, then it's a
01406          * valid NUL; if not, then we've hit the end of the buffer.
01407          */
01408         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01409             /* This was really a NUL. */
01410             *yy_c_buf_p = '\0';
01411 
01412         else
01413             { /* need more input */
01414             int offset = yy_c_buf_p - yytext_ptr;
01415             ++yy_c_buf_p;
01416 
01417             switch ( yy_get_next_buffer() )
01418                 {
01419                 case EOB_ACT_LAST_MATCH:
01420                     /* This happens because yy_g_n_b()
01421                      * sees that we've accumulated a
01422                      * token and flags that we need to
01423                      * try matching the token before
01424                      * proceeding.  But for input(),
01425                      * there's no matching to consider.
01426                      * So convert the EOB_ACT_LAST_MATCH
01427                      * to EOB_ACT_END_OF_FILE.
01428                      */
01429 
01430                     /* Reset buffer status. */
01431                     yyrestart( yyin );
01432 
01433                     /* fall through */
01434 
01435                 case EOB_ACT_END_OF_FILE:
01436                     {
01437                     if ( yywrap() )
01438                         return EOF;
01439 
01440                     if ( ! yy_did_buffer_switch_on_eof )
01441                         YY_NEW_FILE;
01442 #ifdef __cplusplus
01443                     return yyinput();
01444 #else
01445                     return input();
01446 #endif
01447                     }
01448 
01449                 case EOB_ACT_CONTINUE_SCAN:
01450                     yy_c_buf_p = yytext_ptr + offset;
01451                     break;
01452                 }
01453             }
01454         }
01455 
01456     c = *(unsigned char *) yy_c_buf_p;  /* cast for 8-bit char's */
01457     *yy_c_buf_p = '\0'; /* preserve yytext */
01458     yy_hold_char = *++yy_c_buf_p;
01459 
01460 
01461     return c;
01462     }
01463 
01464 
01465 #ifdef YY_USE_PROTOS
01466 void yyrestart( FILE *input_file )
01467 #else
01468 void yyrestart( input_file )
01469 FILE *input_file;
01470 #endif
01471     {
01472     if ( ! yy_current_buffer )
01473         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
01474 
01475     yy_init_buffer( yy_current_buffer, input_file );
01476     yy_load_buffer_state();
01477     }
01478 
01479 
01480 #ifdef YY_USE_PROTOS
01481 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
01482 #else
01483 void yy_switch_to_buffer( new_buffer )
01484 YY_BUFFER_STATE new_buffer;
01485 #endif
01486     {
01487     if ( yy_current_buffer == new_buffer )
01488         return;
01489 
01490     if ( yy_current_buffer )
01491         {
01492         /* Flush out information for old buffer. */
01493         *yy_c_buf_p = yy_hold_char;
01494         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
01495         yy_current_buffer->yy_n_chars = yy_n_chars;
01496         }
01497 
01498     yy_current_buffer = new_buffer;
01499     yy_load_buffer_state();
01500 
01501     /* We don't actually know whether we did this switch during
01502      * EOF (yywrap()) processing, but the only time this flag
01503      * is looked at is after yywrap() is called, so it's safe
01504      * to go ahead and always set it.
01505      */
01506     yy_did_buffer_switch_on_eof = 1;
01507     }
01508 
01509 
01510 #ifdef YY_USE_PROTOS
01511 void yy_load_buffer_state( void )
01512 #else
01513 void yy_load_buffer_state()
01514 #endif
01515     {
01516     yy_n_chars = yy_current_buffer->yy_n_chars;
01517     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
01518     yyin = yy_current_buffer->yy_input_file;
01519     yy_hold_char = *yy_c_buf_p;
01520     }
01521 
01522 
01523 #ifdef YY_USE_PROTOS
01524 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
01525 #else
01526 YY_BUFFER_STATE yy_create_buffer( file, size )
01527 FILE *file;
01528 int size;
01529 #endif
01530     {
01531     YY_BUFFER_STATE b;
01532 
01533     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
01534     if ( ! b )
01535         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01536 
01537     b->yy_buf_size = size;
01538 
01539     /* yy_ch_buf has to be 2 characters longer than the size given because
01540      * we need to put in 2 end-of-buffer characters.
01541      */
01542     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
01543     if ( ! b->yy_ch_buf )
01544         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
01545 
01546     b->yy_is_our_buffer = 1;
01547 
01548     yy_init_buffer( b, file );
01549 
01550     return b;
01551     }
01552 
01553 
01554 #ifdef YY_USE_PROTOS
01555 void yy_delete_buffer( YY_BUFFER_STATE b )
01556 #else
01557 void yy_delete_buffer( b )
01558 YY_BUFFER_STATE b;
01559 #endif
01560     {
01561     if ( ! b )
01562         return;
01563 
01564     if ( b == yy_current_buffer )
01565         yy_current_buffer = (YY_BUFFER_STATE) 0;
01566 
01567     if ( b->yy_is_our_buffer )
01568         yy_flex_free( (void *) b->yy_ch_buf );
01569 
01570     yy_flex_free( (void *) b );
01571     }
01572 
01573 
01574 
01575 #ifdef YY_USE_PROTOS
01576 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
01577 #else
01578 void yy_init_buffer( b, file )
01579 YY_BUFFER_STATE b;
01580 FILE *file;
01581 #endif
01582 
01583 
01584     {
01585     yy_flush_buffer( b );
01586 
01587     b->yy_input_file = file;
01588     b->yy_fill_buffer = 1;
01589 
01590 #if YY_ALWAYS_INTERACTIVE
01591     b->yy_is_interactive = 1;
01592 #else
01593 #if YY_NEVER_INTERACTIVE
01594     b->yy_is_interactive = 0;
01595 #else
01596     b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
01597 #endif
01598 #endif
01599     }
01600 
01601 
01602 #ifdef YY_USE_PROTOS
01603 void yy_flush_buffer( YY_BUFFER_STATE b )
01604 #else
01605 void yy_flush_buffer( b )
01606 YY_BUFFER_STATE b;
01607 #endif
01608 
01609     {
01610     if ( ! b )
01611         return;
01612 
01613     b->yy_n_chars = 0;
01614 
01615     /* We always need two end-of-buffer characters.  The first causes
01616      * a transition to the end-of-buffer state.  The second causes
01617      * a jam in that state.
01618      */
01619     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01620     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01621 
01622     b->yy_buf_pos = &b->yy_ch_buf[0];
01623 
01624     b->yy_at_bol = 1;
01625     b->yy_buffer_status = YY_BUFFER_NEW;
01626 
01627     if ( b == yy_current_buffer )
01628         yy_load_buffer_state();
01629     }
01630 
01631 
01632 #ifndef YY_NO_SCAN_BUFFER
01633 #ifdef YY_USE_PROTOS
01634 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
01635 #else
01636 YY_BUFFER_STATE yy_scan_buffer( base, size )
01637 char *base;
01638 yy_size_t size;
01639 #endif
01640     {
01641     YY_BUFFER_STATE b;
01642 
01643     if ( size < 2 ||
01644          base[size-2] != YY_END_OF_BUFFER_CHAR ||
01645          base[size-1] != YY_END_OF_BUFFER_CHAR )
01646         /* They forgot to leave room for the EOB's. */
01647         return 0;
01648 
01649     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
01650     if ( ! b )
01651         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
01652 
01653     b->yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
01654     b->yy_buf_pos = b->yy_ch_buf = base;
01655     b->yy_is_our_buffer = 0;
01656     b->yy_input_file = 0;
01657     b->yy_n_chars = b->yy_buf_size;
01658     b->yy_is_interactive = 0;
01659     b->yy_at_bol = 1;
01660     b->yy_fill_buffer = 0;
01661     b->yy_buffer_status = YY_BUFFER_NEW;
01662 
01663     yy_switch_to_buffer( b );
01664 
01665     return b;
01666     }
01667 #endif
01668 
01669 
01670 #ifndef YY_NO_SCAN_STRING
01671 #ifdef YY_USE_PROTOS
01672 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
01673 #else
01674 YY_BUFFER_STATE yy_scan_string( yy_str )
01675 yyconst char *yy_str;
01676 #endif
01677     {
01678     int len;
01679     for ( len = 0; yy_str[len]; ++len )
01680         ;
01681 
01682     return yy_scan_bytes( yy_str, len );
01683     }
01684 #endif
01685 
01686 
01687 #ifndef YY_NO_SCAN_BYTES
01688 #ifdef YY_USE_PROTOS
01689 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
01690 #else
01691 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
01692 yyconst char *bytes;
01693 int len;
01694 #endif
01695     {
01696     YY_BUFFER_STATE b;
01697     char *buf;
01698     yy_size_t n;
01699     int i;
01700 
01701     /* Get memory for full buffer, including space for trailing EOB's. */
01702     n = len + 2;
01703     buf = (char *) yy_flex_alloc( n );
01704     if ( ! buf )
01705         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
01706 
01707     for ( i = 0; i < len; ++i )
01708         buf[i] = bytes[i];
01709 
01710     buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
01711 
01712     b = yy_scan_buffer( buf, n );
01713     if ( ! b )
01714         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
01715 
01716     /* It's okay to grow etc. this buffer, and we should throw it
01717      * away when we're done.
01718      */
01719     b->yy_is_our_buffer = 1;
01720 
01721     return b;
01722     }
01723 #endif
01724 
01725 
01726 #ifndef YY_NO_PUSH_STATE
01727 #ifdef YY_USE_PROTOS
01728 static void yy_push_state( int new_state )
01729 #else
01730 static void yy_push_state( new_state )
01731 int new_state;
01732 #endif
01733     {
01734     if ( yy_start_stack_ptr >= yy_start_stack_depth )
01735         {
01736         yy_size_t new_size;
01737 
01738         yy_start_stack_depth += YY_START_STACK_INCR;
01739         new_size = yy_start_stack_depth * sizeof( int );
01740 
01741         if ( ! yy_start_stack )
01742             yy_start_stack = (int *) yy_flex_alloc( new_size );
01743 
01744         else
01745             yy_start_stack = (int *) yy_flex_realloc(
01746                     (void *) yy_start_stack, new_size );
01747 
01748         if ( ! yy_start_stack )
01749             YY_FATAL_ERROR(
01750             "out of memory expanding start-condition stack" );
01751         }
01752 
01753     yy_start_stack[yy_start_stack_ptr++] = YY_START;
01754 
01755     BEGIN(new_state);
01756     }
01757 #endif
01758 
01759 
01760 #ifndef YY_NO_POP_STATE
01761 static void yy_pop_state()
01762     {
01763     if ( --yy_start_stack_ptr < 0 )
01764         YY_FATAL_ERROR( "start-condition stack underflow" );
01765 
01766     BEGIN(yy_start_stack[yy_start_stack_ptr]);
01767     }
01768 #endif
01769 
01770 
01771 #ifndef YY_NO_TOP_STATE
01772 static int yy_top_state()
01773     {
01774     return yy_start_stack[yy_start_stack_ptr - 1];
01775     }
01776 #endif
01777 
01778 #ifndef YY_EXIT_FAILURE
01779 #define YY_EXIT_FAILURE 2
01780 #endif
01781 
01782 #ifdef YY_USE_PROTOS
01783 static void yy_fatal_error( yyconst char msg[] )
01784 #else
01785 static void yy_fatal_error( msg )
01786 char msg[];
01787 #endif
01788     {
01789     (void) fprintf( stderr, "%s\n", msg );
01790     exit( YY_EXIT_FAILURE );
01791     }
01792 
01793 
01794 
01795 /* Redefine yyless() so it works in section 3 code. */
01796 
01797 #undef yyless
01798 #define yyless(n) \
01799     do \
01800         { \
01801         /* Undo effects of setting up yytext. */ \
01802         yytext[yyleng] = yy_hold_char; \
01803         yy_c_buf_p = yytext + n; \
01804         yy_hold_char = *yy_c_buf_p; \
01805         *yy_c_buf_p = '\0'; \
01806         yyleng = n; \
01807         } \
01808     while ( 0 )
01809 
01810 
01811 /* Internal utility routines. */
01812 
01813 #ifndef yytext_ptr
01814 #ifdef YY_USE_PROTOS
01815 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
01816 #else
01817 static void yy_flex_strncpy( s1, s2, n )
01818 char *s1;
01819 yyconst char *s2;
01820 int n;
01821 #endif
01822     {
01823     register int i;
01824     for ( i = 0; i < n; ++i )
01825         s1[i] = s2[i];
01826     }
01827 #endif
01828 
01829 #ifdef YY_NEED_STRLEN
01830 #ifdef YY_USE_PROTOS
01831 static int yy_flex_strlen( yyconst char *s )
01832 #else
01833 static int yy_flex_strlen( s )
01834 yyconst char *s;
01835 #endif
01836     {
01837     register int n;
01838     for ( n = 0; s[n]; ++n )
01839         ;
01840 
01841     return n;
01842     }
01843 #endif
01844 
01845 
01846 #ifdef YY_USE_PROTOS
01847 static void *yy_flex_alloc( yy_size_t size )
01848 #else
01849 static void *yy_flex_alloc( size )
01850 yy_size_t size;
01851 #endif
01852     {
01853     return (void *) malloc( size );
01854     }
01855 
01856 #ifdef YY_USE_PROTOS
01857 static void *yy_flex_realloc( void *ptr, yy_size_t size )
01858 #else
01859 static void *yy_flex_realloc( ptr, size )
01860 void *ptr;
01861 yy_size_t size;
01862 #endif
01863     {
01864     /* The cast to (char *) in the following accommodates both
01865      * implementations that use char* generic pointers, and those
01866      * that use void* generic pointers.  It works with the latter
01867      * because both ANSI C and C++ allow castless assignment from
01868      * any pointer type to void*, and deal with argument conversions
01869      * as though doing an assignment.
01870      */
01871     return (void *) realloc( (char *) ptr, size );
01872     }
01873 
01874 #ifdef YY_USE_PROTOS
01875 static void yy_flex_free( void *ptr )
01876 #else
01877 static void yy_flex_free( ptr )
01878 void *ptr;
01879 #endif
01880     {
01881     free( ptr );
01882     }
01883 
01884 #if YY_MAIN
01885 int main()
01886     {
01887     yylex();
01888     return 0;
01889     }
01890 #endif
01891 #line 122 "./ppdscanner.l"
01892 
01893 
01894 void kdeprint_ppdscanner_init(QIODevice *d)
01895 {
01896     kdeprint_ppdscanner_device = d;
01897 }
01898 
01899 void kdeprint_ppdscanner_terminate( bool deleteIt )
01900 {
01901     if (deleteIt)
01902         delete kdeprint_ppdscanner_device;
01903     kdeprint_ppdscanner_device = NULL;
01904 }
KDE Logo
This file is part of the documentation for kdeprint Library Version 3.2.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Mar 3 19:24:24 2005 by doxygen 1.3.6 written by Dimitri van Heesch, © 1997-2003