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 
00020 
00021 
00022 
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 
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 
00046 #define YY_USE_PROTOS
00047 
00048 
00049 #define YY_USE_CONST
00050 
00051 #else   
00052 
00053 #if __STDC__
00054 
00055 #define YY_USE_PROTOS
00056 #define YY_USE_CONST
00057 
00058 #endif  
00059 #endif  
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 
00084 #define YY_NULL 0
00085 
00086 
00087 
00088 
00089 
00090 
00091 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00092 
00093 
00094 
00095 
00096 
00097 #define BEGIN yy_start = 1 + 2 *
00098 
00099 
00100 
00101 
00102 
00103 #define YY_START ((yy_start - 1) / 2)
00104 #define YYSTATE YY_START
00105 
00106 
00107 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00108 
00109 
00110 #define YY_NEW_FILE yyrestart( yyin )
00111 
00112 #define YY_END_OF_BUFFER_CHAR 0
00113 
00114 
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 
00127 
00128 
00129 
00130 
00131 
00132 
00133 
00134 
00135 
00136 
00137 
00138 
00139 
00140 
00141 
00142 #define yyless(n) \
00143     do \
00144         { \
00145          \
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;  \
00150         } \
00151     while ( 0 )
00152 
00153 #define unput(c) yyunput( c, yytext_ptr )
00154 
00155 
00156 
00157 
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;        
00167     char *yy_buf_pos;       
00168 
00169     
00170 
00171 
00172     yy_size_t yy_buf_size;
00173 
00174     
00175 
00176 
00177     int yy_n_chars;
00178 
00179     
00180 
00181 
00182 
00183     int yy_is_our_buffer;
00184 
00185     
00186 
00187 
00188 
00189 
00190     int yy_is_interactive;
00191 
00192     
00193 
00194 
00195 
00196     int yy_at_bol;
00197 
00198     
00199 
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     
00207 
00208 
00209 
00210 
00211 
00212 
00213 
00214 
00215 
00216 #define YY_BUFFER_EOF_PENDING 2
00217     };
00218 
00219 static YY_BUFFER_STATE yy_current_buffer = 0;
00220 
00221 
00222 
00223 
00224 
00225 #define YY_CURRENT_BUFFER yy_current_buffer
00226 
00227 
00228 
00229 static char yy_hold_char;
00230 
00231 static int yy_n_chars;      
00232 
00233 
00234 int yyleng;
00235 
00236 
00237 static char *yy_c_buf_p = (char *) 0;
00238 static int yy_init = 1;     
00239 static int yy_start = 0;    
00240 
00241 
00242 
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 
00297 
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 
00512 
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 
00524 
00525 
00526 
00527 
00528 
00529 
00530 
00531 
00532 
00533 
00534 
00535 
00536 
00537 
00538 
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 
00577 
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 
00637 
00638 
00639 
00640 #endif
00641 #endif
00642 
00643 
00644 #ifndef YY_READ_BUF_SIZE
00645 #define YY_READ_BUF_SIZE 8192
00646 #endif
00647 
00648 
00649 
00650 #ifndef ECHO
00651 
00652 
00653 
00654 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
00655 #endif
00656 
00657 
00658 
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 
00680 
00681 
00682 
00683 #ifndef yyterminate
00684 #define yyterminate() return YY_NULL
00685 #endif
00686 
00687 
00688 #ifndef YY_START_STACK_INCR
00689 #define YY_START_STACK_INCR 25
00690 #endif
00691 
00692 
00693 #ifndef YY_FATAL_ERROR
00694 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
00695 #endif
00696 
00697 
00698 
00699 
00700 #ifndef YY_DECL
00701 #define YY_DECL int yylex YY_PROTO(( void ))
00702 #endif
00703 
00704 
00705 
00706 
00707 #ifndef YY_USER_ACTION
00708 #define YY_USER_ACTION
00709 #endif
00710 
00711 
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;   
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 )     
00758         {
00759         yy_cp = yy_c_buf_p;
00760 
00761         
00762         *yy_cp = yy_hold_char;
00763 
00764         
00765 
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             { 
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:  
00803 
00804 
00805         switch ( yy_act )
00806     { 
00807             case 0: 
00808             
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 {  }
00869     YY_BREAK
00870 case 14:
00871 *yy_cp = yy_hold_char; 
00872 yy_c_buf_p = yy_cp -= 1;
00873 YY_DO_BEFORE_ACTION; 
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 {  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 {  }
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         
01017         int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
01018 
01019         
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             
01026 
01027 
01028 
01029 
01030 
01031 
01032 
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         
01040 
01041 
01042 
01043 
01044 
01045 
01046         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01047             { 
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             
01055 
01056 
01057 
01058 
01059 
01060 
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                 
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                     
01091 
01092 
01093 
01094 
01095 
01096 
01097 
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     } 
01140         } 
01141     } 
01142 
01143 
01144 
01145 
01146 
01147 
01148 
01149 
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         { 
01165         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
01166             {
01167             
01168 
01169 
01170             return EOB_ACT_END_OF_FILE;
01171             }
01172 
01173         else
01174             {
01175             
01176 
01177 
01178             return EOB_ACT_LAST_MATCH;
01179             }
01180         }
01181 
01182     
01183 
01184     
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         
01192 
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             { 
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             
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                     
01225                     yy_flex_realloc( (void *) b->yy_ch_buf,
01226                              b->yy_buf_size + 2 );
01227                 }
01228             else
01229                 
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         
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 
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 
01313 
01314 
01315 
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     
01359     *yy_cp = yy_hold_char;
01360 
01361     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01362         { 
01363         
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  
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         
01405 
01406 
01407 
01408         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01409             
01410             *yy_c_buf_p = '\0';
01411 
01412         else
01413             { 
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                     
01421 
01422 
01423 
01424 
01425 
01426 
01427 
01428 
01429 
01430                     
01431                     yyrestart( yyin );
01432 
01433                     
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;  
01457     *yy_c_buf_p = '\0'; 
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         
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     
01502 
01503 
01504 
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     
01540 
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     
01616 
01617 
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         
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;  
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     
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     
01717 
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 
01796 
01797 #undef yyless
01798 #define yyless(n) \
01799     do \
01800         { \
01801          \
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 
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     
01865 
01866 
01867 
01868 
01869 
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 }