1 #define yy_create_buffer kdeprint_ppd_create_buffer 2 #define yy_delete_buffer kdeprint_ppd_delete_buffer 3 #define yy_scan_buffer kdeprint_ppd_scan_buffer 4 #define yy_scan_string kdeprint_ppd_scan_string 5 #define yy_scan_bytes kdeprint_ppd_scan_bytes 6 #define yy_flex_debug kdeprint_ppd_flex_debug 7 #define yy_init_buffer kdeprint_ppd_init_buffer 8 #define yy_flush_buffer kdeprint_ppd_flush_buffer 9 #define yy_load_buffer_state kdeprint_ppd_load_buffer_state 10 #define yy_switch_to_buffer kdeprint_ppd_switch_to_buffer 11 #define yyin kdeprint_ppdin 12 #define yyleng kdeprint_ppdleng 13 #define yylex kdeprint_ppdlex 14 #define yyout kdeprint_ppdout 15 #define yyrestart kdeprint_ppdrestart 16 #define yytext kdeprint_ppdtext 18 #line 19 "./ppdscanner.cpp" 26 #define YY_FLEX_MAJOR_VERSION 2 27 #define YY_FLEX_MINOR_VERSION 5 78 #define YY_PROTO(proto) proto 80 #define YY_PROTO(proto) () 91 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 97 #define BEGIN yy_start = 1 + 2 * 103 #define YY_START ((yy_start - 1) / 2) 104 #define YYSTATE YY_START 107 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 110 #define YY_NEW_FILE yyrestart( yyin ) 112 #define YY_END_OF_BUFFER_CHAR 0 115 #define YY_BUF_SIZE 16384 117 typedef struct yy_buffer_state *YY_BUFFER_STATE;
120 extern FILE *yyin, *yyout;
122 #define EOB_ACT_CONTINUE_SCAN 0 123 #define EOB_ACT_END_OF_FILE 1 124 #define EOB_ACT_LAST_MATCH 2 146 *yy_cp = yy_hold_char; \ 147 YY_RESTORE_YY_MORE_OFFSET \ 148 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 149 YY_DO_BEFORE_ACTION; \ 153 #define unput(c) yyunput( c, yytext_ptr ) 159 typedef unsigned int yy_size_t;
162 struct yy_buffer_state
172 yy_size_t yy_buf_size;
183 int yy_is_our_buffer;
190 int yy_is_interactive;
203 int yy_buffer_status;
204 #define YY_BUFFER_NEW 0 205 #define YY_BUFFER_NORMAL 1 216 #define YY_BUFFER_EOF_PENDING 2 219 static YY_BUFFER_STATE yy_current_buffer = 0;
225 #define YY_CURRENT_BUFFER yy_current_buffer 229 static char yy_hold_char;
231 static int yy_n_chars;
237 static char *yy_c_buf_p = (
char *) 0;
238 static int yy_init = 1;
239 static int yy_start = 0;
244 static int yy_did_buffer_switch_on_eof;
246 void yyrestart YY_PROTO(( FILE *input_file ));
248 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
249 void yy_load_buffer_state YY_PROTO((
void ));
250 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file,
int size ));
251 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
252 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
253 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
254 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 256 YY_BUFFER_STATE yy_scan_buffer YY_PROTO((
char *base, yy_size_t size ));
257 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst
char *yy_str ));
258 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst
char *bytes,
int len ));
260 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
261 static void *yy_flex_realloc YY_PROTO((
void *, yy_size_t ));
262 static void yy_flex_free YY_PROTO((
void * ));
264 #define yy_new_buffer yy_create_buffer 266 #define yy_set_interactive(is_interactive) \ 268 if ( ! yy_current_buffer ) \ 269 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 270 yy_current_buffer->yy_is_interactive = is_interactive; \ 273 #define yy_set_bol(at_bol) \ 275 if ( ! yy_current_buffer ) \ 276 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 277 yy_current_buffer->yy_at_bol = at_bol; \ 280 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 284 #define YY_SKIP_YYWRAP 285 typedef unsigned char YY_CHAR;
286 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
287 typedef int yy_state_type;
289 #define yytext_ptr yytext 291 static yy_state_type yy_get_previous_state YY_PROTO((
void ));
292 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
293 static int yy_get_next_buffer YY_PROTO((
void ));
294 static void yy_fatal_error YY_PROTO(( yyconst
char msg[] ));
299 #define YY_DO_BEFORE_ACTION \ 300 yytext_ptr = yy_bp; \ 301 yyleng = (int) (yy_cp - yy_bp); \ 302 yy_hold_char = *yy_cp; \ 306 #define YY_NUM_RULES 37 307 #define YY_END_OF_BUFFER 38 308 static yyconst
short int yy_accept[172] =
310 0, 0, 0, 0, 0, 0, 21, 21, 29, 29,
311 0, 0, 38, 36, 35, 36, 19, 17, 20, 18,
312 27, 25, 25, 26, 28, 21, 23, 22, 29, 30,
313 34, 33, 36, 31, 16, 15, 16, 16, 16, 16,
314 16, 16, 16, 16, 16, 17, 25, 0, 25, 24,
315 21, 29, 33, 32, 15, 15, 15, 16, 16, 16,
316 16, 16, 16, 16, 16, 16, 24, 15, 16, 16,
317 13, 16, 16, 16, 16, 16, 16, 15, 16, 16,
318 16, 16, 16, 16, 16, 16, 16, 15, 16, 16,
319 16, 16, 16, 16, 16, 16, 16, 16, 15, 16,
321 16, 16, 16, 16, 16, 16, 16, 2, 16, 16,
322 15, 16, 4, 16, 16, 16, 16, 16, 16, 2,
323 16, 16, 15, 16, 4, 8, 8, 16, 16, 16,
324 16, 16, 16, 16, 15, 16, 7, 16, 16, 1,
325 16, 5, 16, 16, 15, 6, 16, 3, 16, 16,
326 16, 15, 16, 16, 16, 16, 15, 14, 16, 16,
327 16, 16, 12, 16, 16, 9, 16, 11, 16, 10,
331 static yyconst
int yy_ec[256] =
333 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
334 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
335 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
336 1, 3, 4, 5, 6, 4, 7, 4, 4, 4,
337 4, 8, 4, 4, 4, 4, 9, 10, 10, 10,
338 10, 10, 10, 10, 10, 10, 10, 11, 4, 4,
339 4, 4, 4, 4, 12, 10, 13, 14, 15, 10,
340 16, 10, 17, 18, 10, 19, 20, 21, 22, 23,
341 10, 10, 10, 24, 25, 10, 10, 10, 10, 10,
342 4, 4, 4, 4, 4, 4, 26, 27, 10, 28,
344 29, 30, 31, 10, 32, 10, 10, 33, 34, 35,
345 36, 37, 10, 38, 39, 40, 41, 10, 10, 10,
346 10, 10, 4, 4, 4, 4, 1, 1, 1, 1,
347 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
348 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
349 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
350 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
351 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
352 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
353 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
355 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
356 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
357 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
358 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
359 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
363 static yyconst
int yy_meta[42] =
365 1, 2, 3, 4, 4, 4, 4, 5, 1, 4,
366 6, 4, 4, 4, 4, 4, 4, 4, 4, 4,
367 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
368 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
372 static yyconst
short int yy_base[194] =
374 0, 1, 3, 14, 17, 28, 25, 30, 300, 299,
375 41, 45, 300, 303, 303, 50, 303, 0, 303, 303,
376 303, 0, 75, 303, 303, 0, 303, 303, 0, 303,
377 303, 0, 0, 303, 0, 78, 266, 269, 262, 262,
378 282, 258, 256, 266, 274, 0, 0, 285, 89, 0,
379 0, 0, 0, 0, 0, 276, 92, 252, 257, 258,
380 259, 265, 248, 253, 244, 267, 303, 257, 239, 251,
381 0, 245, 38, 250, 239, 244, 236, 251, 241, 228,
382 239, 234, 229, 248, 45, 226, 228, 248, 58, 228,
383 234, 223, 229, 244, 218, 238, 240, 214, 240, 213,
385 233, 209, 221, 208, 211, 209, 208, 100, 211, 202,
386 217, 204, 105, 231, 205, 208, 211, 200, 193, 110,
387 199, 194, 219, 189, 115, 0, 0, 200, 203, 210,
388 187, 188, 195, 197, 219, 184, 0, 208, 202, 0,
389 178, 0, 182, 184, 191, 0, 147, 0, 141, 135,
390 67, 97, 68, 70, 56, 45, 80, 303, 43, 34,
391 26, 20, 0, 23, 20, 0, 5, 0, 1, 0,
392 303, 123, 129, 135, 141, 147, 153, 156, 159, 161,
393 166, 172, 177, 6, 3, 183, 189, 195, 198, 200,
398 static yyconst
short int yy_def[194] =
400 172, 172, 173, 173, 174, 174, 175, 175, 176, 176,
401 177, 177, 171, 171, 171, 178, 171, 179, 171, 171,
402 171, 180, 181, 171, 171, 182, 171, 171, 183, 171,
403 171, 184, 185, 171, 178, 186, 178, 178, 178, 178,
404 178, 178, 178, 178, 178, 179, 180, 187, 181, 180,
405 182, 183, 184, 185, 188, 188, 186, 178, 178, 178,
406 178, 178, 178, 178, 178, 178, 171, 188, 178, 178,
407 178, 178, 178, 178, 178, 178, 178, 188, 178, 178,
408 178, 178, 178, 178, 178, 178, 178, 188, 178, 178,
409 178, 178, 178, 178, 178, 178, 178, 178, 188, 178,
411 178, 178, 178, 178, 178, 178, 178, 189, 178, 178,
412 188, 178, 190, 191, 178, 178, 178, 178, 178, 189,
413 178, 178, 188, 178, 190, 191, 192, 178, 178, 178,
414 178, 178, 178, 178, 188, 178, 192, 178, 178, 178,
415 178, 178, 178, 178, 188, 178, 178, 178, 178, 178,
416 178, 193, 178, 178, 178, 178, 193, 171, 178, 178,
417 178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
418 0, 171, 171, 171, 171, 171, 171, 171, 171, 171,
419 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
424 static yyconst
short int yy_nxt[345] =
426 171, 15, 15, 14, 17, 14, 54, 16, 16, 53,
427 171, 19, 171, 20, 14, 17, 14, 14, 21, 14,
428 171, 23, 19, 171, 20, 24, 27, 25, 14, 21,
429 14, 27, 23, 171, 171, 28, 24, 171, 25, 170,
430 28, 14, 31, 14, 169, 14, 31, 14, 33, 14,
431 82, 34, 33, 14, 168, 34, 36, 167, 166, 83,
432 95, 165, 37, 38, 39, 164, 40, 41, 163, 96,
433 42, 43, 44, 100, 45, 48, 48, 48, 55, 50,
434 56, 158, 101, 48, 162, 48, 55, 161, 55, 48,
435 48, 48, 55, 50, 55, 160, 159, 48, 158, 48,
437 55, 156, 55, 35, 35, 35, 35, 35, 35, 35,
438 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
439 35, 35, 35, 14, 14, 14, 14, 14, 14, 18,
440 18, 18, 18, 18, 18, 22, 22, 22, 22, 22,
441 22, 26, 26, 26, 26, 26, 26, 29, 29, 29,
442 29, 29, 29, 32, 32, 32, 32, 32, 32, 35,
443 35, 46, 46, 46, 47, 47, 49, 49, 49, 49,
444 49, 49, 51, 155, 51, 51, 51, 52, 154, 52,
445 52, 52, 52, 57, 153, 57, 57, 57, 57, 48,
446 48, 48, 48, 48, 48, 55, 152, 55, 55, 55,
448 55, 120, 120, 125, 125, 126, 126, 137, 137, 157,
449 157, 157, 157, 157, 157, 151, 150, 149, 148, 147,
450 146, 145, 144, 143, 142, 141, 140, 139, 138, 136,
451 135, 134, 133, 132, 131, 130, 129, 128, 127, 124,
452 123, 122, 121, 119, 118, 117, 116, 115, 114, 113,
453 112, 111, 110, 109, 108, 107, 106, 105, 104, 103,
454 102, 99, 98, 97, 94, 93, 92, 91, 90, 89,
455 88, 87, 86, 85, 84, 81, 80, 79, 78, 77,
456 76, 75, 74, 73, 72, 71, 70, 69, 68, 67,
457 66, 65, 64, 63, 62, 61, 60, 59, 58, 171,
459 30, 30, 13, 171, 171, 171, 171, 171, 171, 171,
460 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
461 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
462 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
466 static yyconst
short int yy_chk[345] =
468 0, 1, 2, 3, 3, 3, 185, 1, 2, 184,
469 0, 3, 0, 3, 4, 4, 4, 5, 5, 5,
470 0, 5, 4, 0, 4, 5, 7, 5, 6, 6,
471 6, 8, 6, 0, 0, 7, 6, 0, 6, 169,
472 8, 11, 11, 11, 167, 12, 12, 12, 11, 11,
473 73, 11, 12, 12, 165, 12, 16, 164, 162, 73,
474 85, 161, 16, 16, 16, 160, 16, 16, 159, 85,
475 16, 16, 16, 89, 16, 23, 23, 23, 36, 23,
476 36, 157, 89, 23, 156, 23, 36, 155, 36, 49,
477 49, 49, 57, 49, 57, 154, 153, 49, 152, 49,
479 57, 151, 57, 108, 108, 108, 108, 108, 113, 113,
480 113, 113, 113, 120, 120, 120, 120, 120, 125, 125,
481 125, 125, 125, 172, 172, 172, 172, 172, 172, 173,
482 173, 173, 173, 173, 173, 174, 174, 174, 174, 174,
483 174, 175, 175, 175, 175, 175, 175, 176, 176, 176,
484 176, 176, 176, 177, 177, 177, 177, 177, 177, 178,
485 178, 179, 179, 179, 180, 180, 181, 181, 181, 181,
486 181, 181, 182, 150, 182, 182, 182, 183, 149, 183,
487 183, 183, 183, 186, 147, 186, 186, 186, 186, 187,
488 187, 187, 187, 187, 187, 188, 145, 188, 188, 188,
490 188, 189, 189, 190, 190, 191, 191, 192, 192, 193,
491 193, 193, 193, 193, 193, 144, 143, 141, 139, 138,
492 136, 135, 134, 133, 132, 131, 130, 129, 128, 124,
493 123, 122, 121, 119, 118, 117, 116, 115, 114, 112,
494 111, 110, 109, 107, 106, 105, 104, 103, 102, 101,
495 100, 99, 98, 97, 96, 95, 94, 93, 92, 91,
496 90, 88, 87, 86, 84, 83, 82, 81, 80, 79,
497 78, 77, 76, 75, 74, 72, 70, 69, 68, 66,
498 65, 64, 63, 62, 61, 60, 59, 58, 56, 48,
499 45, 44, 43, 42, 41, 40, 39, 38, 37, 13,
501 10, 9, 171, 171, 171, 171, 171, 171, 171, 171,
502 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
503 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
504 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
508 static yy_state_type yy_last_accepting_state;
509 static char *yy_last_accepting_cpos;
514 #define REJECT reject_used_but_not_detected 515 #define yymore() yymore_used_but_not_detected 516 #define YY_MORE_ADJ 0 517 #define YY_RESTORE_YY_MORE_OFFSET 519 #line 1 "./ppdscanner.l" 521 #line 2 "./ppdscanner.l" 541 #include <tqstringlist.h> 542 #include <tqiodevice.h> 543 #define YYSTYPE TQStringList 544 #include "ppdparser.cpp.h" 546 #define yylval kdeprint_ppdlval 548 TQIODevice *kdeprint_ppdscanner_device = NULL;
549 #define YY_INPUT(buf,result,max_size) \ 551 if (kdeprint_ppdscanner_device) \ 553 result = kdeprint_ppdscanner_device->readBlock(buf,max_size); \ 560 int kdeprint_ppdscanner_lno = 0;
563 #define QDEBUG0(s) qDebug(s) 564 #define QDEBUG1(s,a) qDebug(s,a) 571 #define translation_1 3 572 #define translation_2 4 575 #line 576 "./ppdscanner.cpp" 581 #ifndef YY_SKIP_YYWRAP 583 extern "C" int yywrap YY_PROTO((
void ));
585 extern int yywrap YY_PROTO((
void ));
590 static void yyunput YY_PROTO((
int c,
char *buf_ptr ));
594 static void yy_flex_strncpy YY_PROTO((
char *, yyconst
char *,
int ));
597 #ifdef YY_NEED_STRLEN 598 static int yy_flex_strlen YY_PROTO(( yyconst
char * ));
603 static int yyinput YY_PROTO((
void ));
605 static int input YY_PROTO((
void ));
610 static int yy_start_stack_ptr = 0;
611 static int yy_start_stack_depth = 0;
612 static int *yy_start_stack = 0;
613 #ifndef YY_NO_PUSH_STATE 614 static void yy_push_state YY_PROTO((
int new_state ));
616 #ifndef YY_NO_POP_STATE 617 static void yy_pop_state YY_PROTO((
void ));
619 #ifndef YY_NO_TOP_STATE 620 static int yy_top_state YY_PROTO((
void ));
624 #define YY_NO_PUSH_STATE 1 625 #define YY_NO_POP_STATE 1 626 #define YY_NO_TOP_STATE 1 629 #ifdef YY_MALLOC_DECL 645 #ifndef YY_READ_BUF_SIZE 646 #define YY_READ_BUF_SIZE 8192 655 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 662 #define YY_INPUT(buf,result,max_size) \ 663 if ( yy_current_buffer->yy_is_interactive ) \ 666 for ( n = 0; n < max_size && \ 667 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 670 buf[n++] = (char) c; \ 671 if ( c == EOF && ferror( yyin ) ) \ 672 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 675 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 676 && ferror( yyin ) ) \ 677 YY_FATAL_ERROR( "input in flex scanner failed" ); 685 #define yyterminate() return YY_NULL 689 #ifndef YY_START_STACK_INCR 690 #define YY_START_STACK_INCR 25 694 #ifndef YY_FATAL_ERROR 695 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 702 #define YY_DECL int yylex YY_PROTO(( void )) 708 #ifndef YY_USER_ACTION 709 #define YY_USER_ACTION 714 #define YY_BREAK break; 717 #define YY_RULE_SETUP \ 722 yy_state_type yy_current_state;
726 #line 59 "./ppdscanner.l" 732 #line 733 "./ppdscanner.cpp" 751 if ( ! yy_current_buffer )
753 yy_create_buffer( yyin, YY_BUF_SIZE );
755 yy_load_buffer_state();
763 *yy_cp = yy_hold_char;
770 yy_current_state = yy_start;
774 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
775 if ( yy_accept[yy_current_state] )
777 yy_last_accepting_state = yy_current_state;
778 yy_last_accepting_cpos = yy_cp;
780 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
782 yy_current_state = (int) yy_def[yy_current_state];
783 if ( yy_current_state >= 172 )
784 yy_c = yy_meta[(
unsigned int) yy_c];
786 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
789 while ( yy_base[yy_current_state] != 303 );
792 yy_act = yy_accept[yy_current_state];
795 yy_cp = yy_last_accepting_cpos;
796 yy_current_state = yy_last_accepting_state;
797 yy_act = yy_accept[yy_current_state];
810 *yy_cp = yy_hold_char;
811 yy_cp = yy_last_accepting_cpos;
812 yy_current_state = yy_last_accepting_state;
816 #line 65 "./ppdscanner.l" 819 #line 65 "./ppdscanner.l" 820 { QDEBUG0(
"Open UI"); BEGIN(option);
return OPENUI; }
823 #line 67 "./ppdscanner.l" 826 #line 67 "./ppdscanner.l" 827 { QDEBUG0(
"Close UI"); BEGIN(value);
return CLOSEUI; }
831 #line 68 "./ppdscanner.l" 832 { QDEBUG0(
"Open group"); BEGIN(option);
return OPENGROUP; }
836 #line 69 "./ppdscanner.l" 837 { QDEBUG0(
"Close group"); BEGIN(option);
return CLOSEGROUP; }
841 #line 70 "./ppdscanner.l" 842 { yylval = yytext+9; BEGIN(option);
return DEFAULT; }
846 #line 71 "./ppdscanner.l" 847 { yylval = yytext+8; BEGIN(option);
return DEFAULT; }
850 #line 73 "./ppdscanner.l" 853 #line 73 "./ppdscanner.l" 854 { BEGIN(constr);
return CONSTRAINT; }
858 #line 74 "./ppdscanner.l" 859 { BEGIN(option);
return PAPERDIM; }
863 #line 75 "./ppdscanner.l" 864 { BEGIN(option);
return IMGAREA; }
868 #line 76 "./ppdscanner.l" 872 *yy_cp = yy_hold_char;
873 yy_c_buf_p = yy_cp -= 1;
876 #line 78 "./ppdscanner.l" 877 { yylval = yytext+12;
return FOODATA; }
881 #line 79 "./ppdscanner.l" 882 { QDEBUG0(
"Comment");
return COMMENT; }
886 #line 80 "./ppdscanner.l" 887 { yylval = yytext+1; QDEBUG1(
"Main keyword: %s",yytext+1); BEGIN(option);
return KEYWORD; }
894 #line 85 "./ppdscanner.l" 895 { yylval = yytext; QDEBUG1(
"Option: %s",yytext);
return OPTION; }
899 #line 86 "./ppdscanner.l" 900 { BEGIN(value);
return ':'; }
904 #line 87 "./ppdscanner.l" 905 { kdeprint_ppdscanner_lno++; BEGIN(INITIAL); }
909 #line 88 "./ppdscanner.l" 910 { BEGIN(translation_1);
return '/'; }
917 #line 93 "./ppdscanner.l" 918 { yylval = yytext; QDEBUG1(
"Translation: %s",yytext);
return TRANSLATION; }
922 #line 94 "./ppdscanner.l" 923 { BEGIN(value);
return ':'; }
927 #line 95 "./ppdscanner.l" 928 { kdeprint_ppdscanner_lno++; BEGIN(INITIAL); }
935 #line 100 "./ppdscanner.l" 936 { yylval = yytext; kdeprint_ppdscanner_lno += yylval[0].contains(
'\n'); QDEBUG1(
"Quoted value: %s",yytext);
return QUOTED; }
940 #line 101 "./ppdscanner.l" 941 { yylval = yytext; QDEBUG1(
"String part: %s",yytext);
return STRINGPART; }
945 #line 102 "./ppdscanner.l" 946 { BEGIN(translation_2);
return '/'; }
950 #line 103 "./ppdscanner.l" 951 { kdeprint_ppdscanner_lno++; BEGIN(INITIAL); }
955 #line 104 "./ppdscanner.l" 963 #line 109 "./ppdscanner.l" 964 { yylval = yytext; QDEBUG1(
"Translation: %s",yytext);
return TRANSLATION; }
968 #line 110 "./ppdscanner.l" 969 { kdeprint_ppdscanner_lno++; BEGIN(INITIAL); }
976 #line 115 "./ppdscanner.l" 981 #line 116 "./ppdscanner.l" 982 { yylval = yytext+1; QDEBUG1(
"Constraint keyword: %s",yytext);
return KEYWORD; }
986 #line 117 "./ppdscanner.l" 987 { yylval = yytext; QDEBUG1(
"Constraint option: %s",yytext);
return OPTION; }
991 #line 118 "./ppdscanner.l" 992 { kdeprint_ppdscanner_lno++; BEGIN(INITIAL); }
996 #line 120 "./ppdscanner.l" 997 { kdeprint_ppdscanner_lno++; }
1001 #line 121 "./ppdscanner.l" 1006 #line 123 "./ppdscanner.l" 1009 #line 1010 "./ppdscanner.cpp" 1010 case YY_STATE_EOF(INITIAL):
1011 case YY_STATE_EOF(option):
1012 case YY_STATE_EOF(value):
1013 case YY_STATE_EOF(translation_1):
1014 case YY_STATE_EOF(translation_2):
1015 case YY_STATE_EOF(constr):
1018 case YY_END_OF_BUFFER:
1021 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1024 *yy_cp = yy_hold_char;
1025 YY_RESTORE_YY_MORE_OFFSET
1027 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1038 yy_n_chars = yy_current_buffer->yy_n_chars;
1039 yy_current_buffer->yy_input_file = yyin;
1040 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1050 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1052 yy_state_type yy_next_state;
1054 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1056 yy_current_state = yy_get_previous_state();
1067 yy_next_state = yy_try_NUL_trans( yy_current_state );
1069 yy_bp = yytext_ptr + YY_MORE_ADJ;
1071 if ( yy_next_state )
1074 yy_cp = ++yy_c_buf_p;
1075 yy_current_state = yy_next_state;
1082 goto yy_find_action;
1086 else switch ( yy_get_next_buffer() )
1088 case EOB_ACT_END_OF_FILE:
1090 yy_did_buffer_switch_on_eof = 0;
1103 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1105 yy_act = YY_STATE_EOF(YY_START);
1111 if ( ! yy_did_buffer_switch_on_eof )
1117 case EOB_ACT_CONTINUE_SCAN:
1119 yytext_ptr + yy_amount_of_matched_text;
1121 yy_current_state = yy_get_previous_state();
1124 yy_bp = yytext_ptr + YY_MORE_ADJ;
1127 case EOB_ACT_LAST_MATCH:
1129 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1131 yy_current_state = yy_get_previous_state();
1134 yy_bp = yytext_ptr + YY_MORE_ADJ;
1135 goto yy_find_action;
1142 "fatal flex scanner internal error--no action found" );
1156 static int yy_get_next_buffer()
1158 char *dest = yy_current_buffer->yy_ch_buf;
1159 char *source = yytext_ptr;
1160 int number_to_move, i;
1163 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1165 "fatal flex scanner internal error--end of buffer missed" );
1167 if ( yy_current_buffer->yy_fill_buffer == 0 )
1169 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1174 return EOB_ACT_END_OF_FILE;
1182 return EOB_ACT_LAST_MATCH;
1189 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1191 for ( i = 0; i < number_to_move; ++i )
1192 *(dest++) = *(source++);
1194 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1198 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1203 yy_current_buffer->yy_buf_size - number_to_move - 1;
1205 while ( num_to_read <= 0 )
1207 #ifdef YY_USES_REJECT 1209 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1213 YY_BUFFER_STATE b = yy_current_buffer;
1215 int yy_c_buf_p_offset =
1216 (int) (yy_c_buf_p - b->yy_ch_buf);
1218 if ( b->yy_is_our_buffer )
1220 int new_size = b->yy_buf_size * 2;
1222 if ( new_size <= 0 )
1223 b->yy_buf_size += b->yy_buf_size / 8;
1225 b->yy_buf_size *= 2;
1227 b->yy_ch_buf = (
char *)
1229 yy_flex_realloc( (
void *) b->yy_ch_buf,
1230 b->yy_buf_size + 2 );
1236 if ( ! b->yy_ch_buf )
1238 "fatal error - scanner input buffer overflow" );
1240 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1242 num_to_read = yy_current_buffer->yy_buf_size -
1247 if ( num_to_read > YY_READ_BUF_SIZE )
1248 num_to_read = YY_READ_BUF_SIZE;
1251 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1252 yy_n_chars, num_to_read );
1254 yy_current_buffer->yy_n_chars = yy_n_chars;
1257 if ( yy_n_chars == 0 )
1259 if ( number_to_move == YY_MORE_ADJ )
1261 ret_val = EOB_ACT_END_OF_FILE;
1267 ret_val = EOB_ACT_LAST_MATCH;
1268 yy_current_buffer->yy_buffer_status =
1269 YY_BUFFER_EOF_PENDING;
1274 ret_val = EOB_ACT_CONTINUE_SCAN;
1276 yy_n_chars += number_to_move;
1277 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1278 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1280 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1288 static yy_state_type yy_get_previous_state()
1290 yy_state_type yy_current_state;
1293 yy_current_state = yy_start;
1295 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1297 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1298 if ( yy_accept[yy_current_state] )
1300 yy_last_accepting_state = yy_current_state;
1301 yy_last_accepting_cpos = yy_cp;
1303 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1305 yy_current_state = (int) yy_def[yy_current_state];
1306 if ( yy_current_state >= 172 )
1307 yy_c = yy_meta[(
unsigned int) yy_c];
1309 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1312 return yy_current_state;
1322 #ifdef YY_USE_PROTOS 1323 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1325 static yy_state_type yy_try_NUL_trans( yy_current_state )
1326 yy_state_type yy_current_state;
1330 char *yy_cp = yy_c_buf_p;
1333 if ( yy_accept[yy_current_state] )
1335 yy_last_accepting_state = yy_current_state;
1336 yy_last_accepting_cpos = yy_cp;
1338 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1340 yy_current_state = (int) yy_def[yy_current_state];
1341 if ( yy_current_state >= 172 )
1342 yy_c = yy_meta[(
unsigned int) yy_c];
1344 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1345 yy_is_jam = (yy_current_state == 171);
1347 return yy_is_jam ? 0 : yy_current_state;
1352 #ifdef YY_USE_PROTOS 1353 static void yyunput(
int c,
char *yy_bp )
1355 static void yyunput( c, yy_bp )
1360 char *yy_cp = yy_c_buf_p;
1363 *yy_cp = yy_hold_char;
1365 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1368 int number_to_move = yy_n_chars + 2;
1369 char *dest = &yy_current_buffer->yy_ch_buf[
1370 yy_current_buffer->yy_buf_size + 2];
1372 &yy_current_buffer->yy_ch_buf[number_to_move];
1374 while ( source > yy_current_buffer->yy_ch_buf )
1375 *--dest = *--source;
1377 yy_cp += (int) (dest - source);
1378 yy_bp += (int) (dest - source);
1379 yy_current_buffer->yy_n_chars =
1380 yy_n_chars = yy_current_buffer->yy_buf_size;
1382 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1383 YY_FATAL_ERROR(
"flex scanner push-back overflow" );
1386 *--yy_cp = (char) c;
1390 yy_hold_char = *yy_cp;
1397 static int yyinput()
1404 *yy_c_buf_p = yy_hold_char;
1406 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1412 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1418 int offset = yy_c_buf_p - yytext_ptr;
1421 switch ( yy_get_next_buffer() )
1423 case EOB_ACT_LAST_MATCH:
1439 case EOB_ACT_END_OF_FILE:
1444 if ( ! yy_did_buffer_switch_on_eof )
1453 case EOB_ACT_CONTINUE_SCAN:
1454 yy_c_buf_p = yytext_ptr + offset;
1460 c = *(
unsigned char *) yy_c_buf_p;
1462 yy_hold_char = *++yy_c_buf_p;
1469 #ifdef YY_USE_PROTOS 1470 void yyrestart( FILE *input_file )
1472 void yyrestart( input_file )
1476 if ( ! yy_current_buffer )
1477 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1479 yy_init_buffer( yy_current_buffer, input_file );
1480 yy_load_buffer_state();
1484 #ifdef YY_USE_PROTOS 1485 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1487 void yy_switch_to_buffer( new_buffer )
1488 YY_BUFFER_STATE new_buffer;
1491 if ( yy_current_buffer == new_buffer )
1494 if ( yy_current_buffer )
1497 *yy_c_buf_p = yy_hold_char;
1498 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1499 yy_current_buffer->yy_n_chars = yy_n_chars;
1502 yy_current_buffer = new_buffer;
1503 yy_load_buffer_state();
1510 yy_did_buffer_switch_on_eof = 1;
1514 #ifdef YY_USE_PROTOS 1515 void yy_load_buffer_state(
void )
1517 void yy_load_buffer_state()
1520 yy_n_chars = yy_current_buffer->yy_n_chars;
1521 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1522 yyin = yy_current_buffer->yy_input_file;
1523 yy_hold_char = *yy_c_buf_p;
1527 #ifdef YY_USE_PROTOS 1528 YY_BUFFER_STATE yy_create_buffer( FILE *file,
int size )
1530 YY_BUFFER_STATE yy_create_buffer( file, size )
1537 b = (YY_BUFFER_STATE) yy_flex_alloc(
sizeof(
struct yy_buffer_state ) );
1539 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1541 b->yy_buf_size = size;
1546 b->yy_ch_buf = (
char *) yy_flex_alloc( b->yy_buf_size + 2 );
1547 if ( ! b->yy_ch_buf )
1548 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1550 b->yy_is_our_buffer = 1;
1552 yy_init_buffer( b, file );
1558 #ifdef YY_USE_PROTOS 1559 void yy_delete_buffer( YY_BUFFER_STATE b )
1561 void yy_delete_buffer( b )
1568 if ( b == yy_current_buffer )
1569 yy_current_buffer = (YY_BUFFER_STATE) 0;
1571 if ( b->yy_is_our_buffer )
1572 yy_flex_free( (
void *) b->yy_ch_buf );
1574 yy_flex_free( (
void *) b );
1579 #ifdef YY_USE_PROTOS 1580 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1582 void yy_init_buffer( b, file )
1589 yy_flush_buffer( b );
1591 b->yy_input_file = file;
1592 b->yy_fill_buffer = 1;
1594 #if YY_ALWAYS_INTERACTIVE 1595 b->yy_is_interactive = 1;
1597 #if YY_NEVER_INTERACTIVE 1598 b->yy_is_interactive = 0;
1600 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1606 #ifdef YY_USE_PROTOS 1607 void yy_flush_buffer( YY_BUFFER_STATE b )
1609 void yy_flush_buffer( b )
1623 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1624 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1626 b->yy_buf_pos = &b->yy_ch_buf[0];
1629 b->yy_buffer_status = YY_BUFFER_NEW;
1631 if ( b == yy_current_buffer )
1632 yy_load_buffer_state();
1636 #ifndef YY_NO_SCAN_BUFFER 1637 #ifdef YY_USE_PROTOS 1638 YY_BUFFER_STATE yy_scan_buffer(
char *base, yy_size_t size )
1640 YY_BUFFER_STATE yy_scan_buffer( base, size )
1648 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1649 base[size-1] != YY_END_OF_BUFFER_CHAR )
1653 b = (YY_BUFFER_STATE) yy_flex_alloc(
sizeof(
struct yy_buffer_state ) );
1655 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_buffer()" );
1657 b->yy_buf_size = size - 2;
1658 b->yy_buf_pos = b->yy_ch_buf = base;
1659 b->yy_is_our_buffer = 0;
1660 b->yy_input_file = 0;
1661 b->yy_n_chars = b->yy_buf_size;
1662 b->yy_is_interactive = 0;
1664 b->yy_fill_buffer = 0;
1665 b->yy_buffer_status = YY_BUFFER_NEW;
1667 yy_switch_to_buffer( b );
1674 #ifndef YY_NO_SCAN_STRING 1675 #ifdef YY_USE_PROTOS 1676 YY_BUFFER_STATE yy_scan_string( yyconst
char *yy_str )
1678 YY_BUFFER_STATE yy_scan_string( yy_str )
1679 yyconst
char *yy_str;
1683 for ( len = 0; yy_str[len]; ++len )
1686 return yy_scan_bytes( yy_str, len );
1691 #ifndef YY_NO_SCAN_BYTES 1692 #ifdef YY_USE_PROTOS 1693 YY_BUFFER_STATE yy_scan_bytes( yyconst
char *bytes,
int len )
1695 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1696 yyconst
char *bytes;
1707 buf = (
char *) yy_flex_alloc( n );
1709 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_bytes()" );
1711 for ( i = 0; i < len; ++i )
1714 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1716 b = yy_scan_buffer( buf, n );
1718 YY_FATAL_ERROR(
"bad buffer in yy_scan_bytes()" );
1723 b->yy_is_our_buffer = 1;
1730 #ifndef YY_NO_PUSH_STATE 1731 #ifdef YY_USE_PROTOS 1732 static void yy_push_state(
int new_state )
1734 static void yy_push_state( new_state )
1738 if ( yy_start_stack_ptr >= yy_start_stack_depth )
1742 yy_start_stack_depth += YY_START_STACK_INCR;
1743 new_size = yy_start_stack_depth *
sizeof( int );
1745 if ( ! yy_start_stack )
1746 yy_start_stack = (
int *) yy_flex_alloc( new_size );
1749 yy_start_stack = (
int *) yy_flex_realloc(
1750 (
void *) yy_start_stack, new_size );
1752 if ( ! yy_start_stack )
1754 "out of memory expanding start-condition stack" );
1757 yy_start_stack[yy_start_stack_ptr++] = YY_START;
1764 #ifndef YY_NO_POP_STATE 1765 static void yy_pop_state()
1767 if ( --yy_start_stack_ptr < 0 )
1768 YY_FATAL_ERROR(
"start-condition stack underflow" );
1770 BEGIN(yy_start_stack[yy_start_stack_ptr]);
1775 #ifndef YY_NO_TOP_STATE 1776 static int yy_top_state()
1778 return yy_start_stack[yy_start_stack_ptr - 1];
1782 #ifndef YY_EXIT_FAILURE 1783 #define YY_EXIT_FAILURE 2 1786 #ifdef YY_USE_PROTOS 1787 static void yy_fatal_error( yyconst
char msg[] )
1789 static void yy_fatal_error( msg )
1793 (void) fprintf( stderr,
"[ppdscanner] %s\n", msg );
1794 exit( YY_EXIT_FAILURE );
1806 yytext[yyleng] = yy_hold_char; \ 1807 yy_c_buf_p = yytext + n; \ 1808 yy_hold_char = *yy_c_buf_p; \ 1809 *yy_c_buf_p = '\0'; \ 1818 #ifdef YY_USE_PROTOS 1819 static void yy_flex_strncpy(
char *s1, yyconst
char *s2,
int n )
1821 static void yy_flex_strncpy( s1, s2, n )
1828 for ( i = 0; i < n; ++i )
1833 #ifdef YY_NEED_STRLEN 1834 #ifdef YY_USE_PROTOS 1835 static int yy_flex_strlen( yyconst
char *s )
1837 static int yy_flex_strlen( s )
1842 for ( n = 0; s[n]; ++n )
1850 #ifdef YY_USE_PROTOS 1851 static void *yy_flex_alloc( yy_size_t size )
1853 static void *yy_flex_alloc( size )
1857 return (
void *) malloc( size );
1860 #ifdef YY_USE_PROTOS 1861 static void *yy_flex_realloc(
void *ptr, yy_size_t size )
1863 static void *yy_flex_realloc( ptr, size )
1875 return (
void *) realloc( (
char *) ptr, size );
1878 #ifdef YY_USE_PROTOS 1879 static void yy_flex_free(
void *ptr )
1881 static void yy_flex_free( ptr )
1895 #line 123 "./ppdscanner.l" 1898 void kdeprint_ppdscanner_init(TQIODevice *d)
1900 kdeprint_ppdscanner_device = d;
1901 kdeprint_ppdscanner_lno = 1;
1904 void kdeprint_ppdscanner_terminate(
bool deleteIt )
1907 delete kdeprint_ppdscanner_device;
1908 kdeprint_ppdscanner_device = NULL;
1911 int kdeprint_ppdscanner_numberoflines()
1913 return kdeprint_ppdscanner_lno;