1 #line 2 "qmake_lex.cpp" 3 #line 4 "qmake_lex.cpp" 5 #define YY_INT_ALIGNED short int 10 #define YY_FLEX_MAJOR_VERSION 2 11 #define YY_FLEX_MINOR_VERSION 5 12 #define YY_FLEX_SUBMINOR_VERSION 33 13 #if YY_FLEX_SUBMINOR_VERSION > 0 24 #define yyFlexLexer yyFlexLexer 51 #if __STDC_VERSION__ >= 199901L 56 #ifndef __STDC_LIMIT_MACROS 57 #define __STDC_LIMIT_MACROS 1 61 typedef int8_t flex_int8_t;
62 typedef uint8_t flex_uint8_t;
63 typedef int16_t flex_int16_t;
64 typedef uint16_t flex_uint16_t;
65 typedef int32_t flex_int32_t;
66 typedef uint32_t flex_uint32_t;
68 typedef signed char flex_int8_t;
69 typedef short int flex_int16_t;
70 typedef int flex_int32_t;
71 typedef unsigned char flex_uint8_t;
72 typedef unsigned short int flex_uint16_t;
73 typedef unsigned int flex_uint32_t;
78 #define INT8_MIN (-128) 81 #define INT16_MIN (-32767-1) 84 #define INT32_MIN (-2147483647-1) 87 #define INT8_MAX (127) 90 #define INT16_MAX (32767) 93 #define INT32_MAX (2147483647) 96 #define UINT8_MAX (255U) 99 #define UINT16_MAX (65535U) 102 #define UINT32_MAX (4294967295U) 133 #define yyconst const 151 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 165 #define BEGIN (yy_start) = 1 + 2 * 171 #define YY_START (((yy_start) - 1) / 2) 172 #define YYSTATE YY_START 175 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 178 #define YY_NEW_FILE yyrestart( yyin ) 180 #define YY_END_OF_BUFFER_CHAR 0 184 #define YY_BUF_SIZE 16384 189 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 191 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 192 #define YY_TYPEDEF_YY_BUFFER_STATE 193 typedef struct yy_buffer_state *YY_BUFFER_STATE;
205 #define EOB_ACT_CONTINUE_SCAN 0 206 #define EOB_ACT_END_OF_FILE 1 207 #define EOB_ACT_LAST_MATCH 2 216 #define YY_LESS_LINENO(n) \ 219 for ( yyl = n; yyl < yyleng; ++yyl )\ 220 if ( yytext[yyl] == '\n' )\ 229 int yyless_macro_arg = (n); \ 230 YY_LESS_LINENO(yyless_macro_arg);\ 231 *yy_cp = (yy_hold_char); \ 232 YY_RESTORE_YY_MORE_OFFSET \ 233 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 234 YY_DO_BEFORE_ACTION; \ 238 #define unput(c) yyunput( c, (yytext_ptr) ) 245 #ifndef YY_TYPEDEF_YY_SIZE_T 246 #define YY_TYPEDEF_YY_SIZE_T 247 typedef unsigned int yy_size_t;
250 #ifndef YY_STRUCT_YY_BUFFER_STATE 251 #define YY_STRUCT_YY_BUFFER_STATE 252 struct yy_buffer_state
258 std::istream* yy_input_file;
267 yy_size_t yy_buf_size;
278 int yy_is_our_buffer;
285 int yy_is_interactive;
301 int yy_buffer_status;
303 #define YY_BUFFER_NEW 0 304 #define YY_BUFFER_NORMAL 1 315 #define YY_BUFFER_EOF_PENDING 2 335 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 336 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 342 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 353 void *yyalloc (yy_size_t );
354 void *yyrealloc (
void *,yy_size_t );
355 void yyfree (
void * );
357 #define yy_new_buffer yy_create_buffer 359 #define yy_set_interactive(is_interactive) \ 361 if ( ! YY_CURRENT_BUFFER ){ \ 362 yyensure_buffer_stack (); \ 363 YY_CURRENT_BUFFER_LVALUE = \ 364 yy_create_buffer( yyin, YY_BUF_SIZE ); \ 366 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 369 #define yy_set_bol(at_bol) \ 371 if ( ! YY_CURRENT_BUFFER ){\ 372 yyensure_buffer_stack (); \ 373 YY_CURRENT_BUFFER_LVALUE = \ 374 yy_create_buffer( yyin, YY_BUF_SIZE ); \ 376 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 379 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 385 #define YY_SKIP_YYWRAP 389 typedef unsigned char YY_CHAR;
391 #define yytext_ptr yytext 392 #define YY_INTERACTIVE 394 #include <FlexLexer.h> 395 int yyFlexLexer::yylex()
397 LexerError(
"yyFlexLexer::yylex invoked but %option yyclass used" );
401 #define YY_DECL int TQMake::Lexer::yylex() 409 #define YY_DO_BEFORE_ACTION \ 410 (yytext_ptr) = yy_bp; \ 412 yyleng = (size_t) (yy_cp - yy_bp); \ 413 (yy_hold_char) = *yy_cp; \ 416 (yy_c_buf_p) = yy_cp; 419 #define YY_NUM_RULES 23 420 #define YY_END_OF_BUFFER 24 425 flex_int32_t yy_verify;
428 static yyconst flex_int16_t yy_accept[76] =
430 0, 0, 0, 0, 0, 0, 24, 23, 1, 21,
431 21, 5, 23, 17, 18, 5, 23, 5, 19, 9,
432 23, 14, 16, 23, 7, 2, 7, 7, 23, 23,
433 6, 1, 21, 5, 0, 22, 22, 0, 12, 10,
434 11, 0, 15, 0, 3, 3, 0, 13, 7, 7,
435 0, 2, 20, 20, 7, 0, 7, 0, 7, 0,
436 6, 4, 4, 0, 4, 4, 7, 0, 7, 7,
440 static yyconst flex_int32_t yy_ec[256] =
442 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
443 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
444 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
445 1, 2, 5, 6, 7, 8, 1, 1, 1, 9,
446 10, 11, 12, 1, 13, 14, 1, 15, 15, 15,
447 15, 15, 15, 15, 15, 15, 15, 16, 1, 1,
448 17, 1, 1, 1, 18, 18, 18, 18, 18, 18,
449 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
450 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
451 1, 19, 1, 1, 20, 1, 18, 18, 18, 18,
453 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
454 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
455 18, 18, 21, 22, 23, 24, 1, 1, 1, 1,
456 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
457 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
458 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
459 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
460 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
461 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
462 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
464 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
465 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
466 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
467 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
468 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
472 static yyconst flex_int32_t yy_meta[25] =
474 1, 2, 3, 3, 1, 1, 1, 1, 1, 1,
475 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
479 static yyconst flex_int16_t yy_base[85] =
481 0, 0, 23, 41, 28, 30, 132, 289, 126, 289,
482 123, 56, 32, 289, 289, 106, 105, 104, 35, 289,
483 77, 289, 289, 103, 34, 55, 47, 69, 87, 108,
484 106, 111, 289, 0, 79, 289, 96, 82, 289, 289,
485 289, 44, 289, 0, 289, 90, 59, 289, 68, 289,
486 85, 93, 289, 74, 105, 123, 141, 98, 99, 45,
487 42, 289, 47, 105, 289, 36, 159, 177, 195, 213,
488 108, 231, 249, 112, 289, 268, 271, 274, 27, 277,
492 static yyconst flex_int16_t yy_def[85] =
494 75, 1, 76, 76, 77, 77, 75, 75, 75, 75,
495 75, 75, 78, 75, 75, 12, 75, 12, 75, 75,
496 75, 75, 75, 75, 79, 75, 80, 78, 79, 81,
497 81, 75, 75, 12, 78, 75, 75, 78, 75, 75,
498 75, 75, 75, 21, 75, 75, 82, 75, 79, 75,
499 79, 75, 75, 75, 83, 84, 84, 80, 82, 81,
500 81, 75, 75, 82, 75, 75, 83, 84, 83, 84,
501 83, 84, 84, 84, 0, 75, 75, 75, 75, 75,
505 static yyconst flex_int16_t yy_nxt[314] =
507 8, 9, 10, 11, 12, 8, 13, 12, 14, 15,
508 16, 17, 18, 8, 12, 19, 20, 12, 21, 12,
509 22, 8, 23, 24, 26, 10, 11, 49, 27, 28,
510 8, 8, 8, 8, 36, 37, 42, 31, 65, 31,
511 50, 29, 26, 10, 11, 42, 27, 28, 56, 62,
512 38, 61, 51, 57, 61, 43, 52, 53, 54, 29,
513 34, 65, 66, 34, 43, 58, 34, 34, 34, 34,
514 34, 36, 37, 34, 50, 34, 53, 34, 44, 45,
515 46, 36, 37, 47, 62, 63, 51, 38, 44, 45,
516 46, 50, 45, 59, 52, 53, 54, 38, 36, 75,
518 38, 65, 66, 51, 57, 51, 68, 65, 66, 75,
519 69, 70, 32, 75, 70, 61, 58, 61, 68, 48,
520 41, 40, 39, 71, 68, 33, 71, 32, 73, 68,
521 74, 75, 75, 75, 75, 75, 75, 75, 75, 75,
522 75, 74, 68, 75, 75, 75, 73, 68, 75, 75,
523 75, 75, 75, 75, 75, 75, 75, 75, 75, 74,
524 68, 75, 75, 75, 69, 70, 75, 75, 75, 75,
525 75, 75, 75, 75, 75, 75, 75, 71, 68, 75,
526 75, 75, 73, 68, 75, 75, 75, 75, 75, 75,
527 75, 75, 75, 75, 75, 74, 68, 75, 75, 75,
529 69, 70, 75, 75, 75, 75, 75, 75, 75, 75,
530 75, 75, 75, 71, 68, 75, 75, 75, 73, 68,
531 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
532 75, 74, 68, 75, 75, 75, 73, 68, 75, 75,
533 75, 75, 75, 75, 75, 75, 75, 75, 75, 74,
534 68, 75, 75, 75, 73, 68, 75, 75, 75, 75,
535 75, 75, 75, 75, 75, 75, 75, 74, 25, 25,
536 25, 30, 30, 30, 35, 35, 35, 55, 55, 60,
537 60, 64, 64, 64, 67, 67, 72, 72, 7, 75,
538 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
540 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
544 static yyconst flex_int16_t yy_chk[314] =
546 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
547 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
548 1, 1, 1, 1, 3, 3, 3, 79, 3, 3,
549 5, 5, 6, 6, 13, 13, 19, 5, 66, 6,
550 25, 3, 4, 4, 4, 42, 4, 4, 27, 63,
551 13, 61, 25, 27, 60, 19, 26, 26, 26, 4,
552 12, 47, 47, 12, 42, 27, 12, 12, 12, 12,
553 12, 28, 28, 12, 49, 12, 54, 12, 21, 21,
554 21, 35, 35, 21, 38, 38, 49, 28, 29, 29,
555 29, 51, 46, 29, 52, 52, 52, 35, 37, 58,
557 38, 59, 59, 51, 58, 29, 55, 64, 64, 71,
558 55, 55, 32, 74, 71, 31, 58, 30, 74, 24,
559 18, 17, 16, 55, 56, 11, 71, 9, 56, 56,
560 74, 7, 0, 0, 0, 0, 0, 0, 0, 0,
561 0, 56, 57, 0, 0, 0, 57, 57, 0, 0,
562 0, 0, 0, 0, 0, 0, 0, 0, 0, 57,
563 67, 0, 0, 0, 67, 67, 0, 0, 0, 0,
564 0, 0, 0, 0, 0, 0, 0, 67, 68, 0,
565 0, 0, 68, 68, 0, 0, 0, 0, 0, 0,
566 0, 0, 0, 0, 0, 68, 69, 0, 0, 0,
568 69, 69, 0, 0, 0, 0, 0, 0, 0, 0,
569 0, 0, 0, 69, 70, 0, 0, 0, 70, 70,
570 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
571 0, 70, 72, 0, 0, 0, 72, 72, 0, 0,
572 0, 0, 0, 0, 0, 0, 0, 0, 0, 72,
573 73, 0, 0, 0, 73, 73, 0, 0, 0, 0,
574 0, 0, 0, 0, 0, 0, 0, 73, 76, 76,
575 76, 77, 77, 77, 78, 78, 78, 80, 80, 81,
576 81, 82, 82, 82, 83, 83, 84, 84, 75, 75,
577 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
579 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
584 static yyconst flex_int32_t yy_rule_can_match_eol[24] =
586 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
589 static yyconst flex_int16_t yy_rule_linenum[23] =
591 81, 83, 88, 94, 100, 105, 113, 119, 125, 131,
592 137, 143, 149, 155, 159, 163, 167, 172, 177, 183,
599 #define REJECT reject_used_but_not_detected 600 #define yymore() yymore_used_but_not_detected 601 #define YY_MORE_ADJ 0 602 #define YY_RESTORE_YY_MORE_OFFSET 627 #define DONT_INCLUDE_FLEXLEXER 629 #include "qmake_lex.h" 656 #line 657 "qmake_lex.cpp" 662 #ifndef YY_NO_UNISTD_H 674 #ifndef YY_EXTRA_TYPE 675 #define YY_EXTRA_TYPE void * 694 static void yy_flex_strncpy (
char *,yyconst
char *,
int );
697 #ifdef YY_NEED_STRLEN 698 static int yy_flex_strlen (yyconst
char * );
714 #ifndef YY_READ_BUF_SIZE 715 #define YY_READ_BUF_SIZE 8192 723 #define ECHO LexerOutput( yytext, yyleng ) 731 #define YY_INPUT(buf,result,max_size) \ 735 if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \ 736 YY_FATAL_ERROR( "input in flex scanner failed" ); 746 #define yyterminate() return YY_NULL 750 #ifndef YY_START_STACK_INCR 751 #define YY_START_STACK_INCR 25 755 #ifndef YY_FATAL_ERROR 759 #define YY_FATAL_ERROR(msg) LexerError( msg ) 780 #define YY_DECL_IS_OURS 1 784 #define YY_DECL int yyFlexLexer::yylex() 791 #ifndef YY_USER_ACTION 792 #define YY_USER_ACTION 797 #define YY_BREAK break; 801 #define YY_RULE_SETUP \ 810 register yy_state_type yy_current_state;
811 register char *yy_cp, *yy_bp;
817 #line 818 "qmake_lex.cpp" 844 if ( ! YY_CURRENT_BUFFER ) {
845 yyensure_buffer_stack ();
846 YY_CURRENT_BUFFER_LVALUE =
847 yy_create_buffer( yyin, YY_BUF_SIZE );
850 yy_load_buffer_state( );
856 yy_cp = (yy_c_buf_p);
859 *yy_cp = (yy_hold_char);
867 yy_current_state = (yy_start);
871 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
872 if ( yy_accept[yy_current_state] )
874 (yy_last_accepting_state) = yy_current_state;
875 (yy_last_accepting_cpos) = yy_cp;
877 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
879 yy_current_state = (int) yy_def[yy_current_state];
880 if ( yy_current_state >= 76 )
881 yy_c = yy_meta[(
unsigned int) yy_c];
883 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
886 while ( yy_base[yy_current_state] != 289 );
890 yy_act = yy_accept[yy_current_state];
893 yy_cp = (yy_last_accepting_cpos);
894 yy_current_state = (yy_last_accepting_state);
895 yy_act = yy_accept[yy_current_state];
902 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
905 for ( yyl = 0; yyl < yyleng; ++yyl )
906 if ( yytext[yyl] ==
'\n' )
918 std::cerr <<
"--scanner backing up\n";
919 else if ( yy_act < 23 )
920 std::cerr <<
"--accepting rule at line " << yy_rule_linenum[yy_act] <<
921 "(\"" << yytext <<
"\")\n";
922 else if ( yy_act == 23 )
923 std::cerr <<
"--accepting default rule (\"" << yytext <<
"\")\n";
924 else if ( yy_act == 24 )
925 std::cerr <<
"--(end of buffer or a NUL)\n";
927 std::cerr <<
"--EOF (start condition " << YY_START <<
")\n";
935 *yy_cp = (yy_hold_char);
936 yy_cp = (yy_last_accepting_cpos);
937 yy_current_state = (yy_last_accepting_state);
940 case YY_STATE_EOF(vallist):
944 return Parser::token::token::ENDOFFILE;
956 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
957 return Parser::token::token::LIST_WS;
966 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
967 return Parser::token::token::CONT;
976 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
977 return Parser::token::token::COMMENT_CONT;
984 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
985 return (Parser::token::token::ID_SIMPLE);
992 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
993 mylval->value = mylval->value.mid(0, mylval->value.length()-1);
996 return (Parser::token::token::ID_ARGS);
1001 #line 113 "qmake.ll" 1004 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1005 return Parser::token::token::VARIABLE_VALUE;
1010 #line 119 "qmake.ll" 1013 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1014 return Parser::token::token::QUOTED_VARIABLE_VALUE;
1019 #line 125 "qmake.ll" 1022 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1023 return Parser::token::token::EQ;
1028 #line 131 "qmake.ll" 1031 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1032 return Parser::token::token::PLUSEQ;
1037 #line 137 "qmake.ll" 1040 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1041 return Parser::token::token::MINUSEQ;
1046 #line 143 "qmake.ll" 1049 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1050 return Parser::token::token::STAREQ;
1055 #line 149 "qmake.ll" 1058 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1059 return Parser::token::token::TILDEEQ;
1064 #line 155 "qmake.ll" 1066 return Parser::token::token::LCURLY;
1071 #line 159 "qmake.ll" 1073 return Parser::token::token::LCURLY;
1078 #line 163 "qmake.ll" 1080 return Parser::token::token::RCURLY;
1085 #line 167 "qmake.ll" 1088 return Parser::token::token::LBRACE;
1093 #line 172 "qmake.ll" 1096 return Parser::token::token::RBRACE;
1101 #line 177 "qmake.ll" 1103 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1104 return Parser::token::token::COLON;
1110 #line 183 "qmake.ll" 1113 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1114 setLineEndingFromString( mylval->value );
1115 return Parser::token::token::NEWLINE;
1121 #line 190 "qmake.ll" 1124 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1125 setLineEndingFromString( mylval->value );
1126 return Parser::token::token::NEWLINE;
1132 #line 197 "qmake.ll" 1135 mylval->value = TQString::fromLocal8Bit( YYText(), YYLeng() );
1136 return (Parser::token::token::COMMENT);
1141 #line 203 "qmake.ll" 1144 #line 1145 "qmake_lex.cpp" 1145 case YY_STATE_EOF(INITIAL):
1146 case YY_STATE_EOF(funcargs):
1149 case YY_END_OF_BUFFER:
1152 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1155 *yy_cp = (yy_hold_char);
1156 YY_RESTORE_YY_MORE_OFFSET
1158 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1169 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1170 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1171 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1181 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1183 yy_state_type yy_next_state;
1185 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1187 yy_current_state = yy_get_previous_state( );
1198 yy_next_state = yy_try_NUL_trans( yy_current_state );
1200 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1202 if ( yy_next_state )
1205 yy_cp = ++(yy_c_buf_p);
1206 yy_current_state = yy_next_state;
1213 yy_cp = (yy_c_buf_p);
1214 goto yy_find_action;
1218 else switch ( yy_get_next_buffer( ) )
1220 case EOB_ACT_END_OF_FILE:
1222 (yy_did_buffer_switch_on_eof) = 0;
1235 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1237 yy_act = YY_STATE_EOF(YY_START);
1243 if ( ! (yy_did_buffer_switch_on_eof) )
1249 case EOB_ACT_CONTINUE_SCAN:
1251 (yytext_ptr) + yy_amount_of_matched_text;
1253 yy_current_state = yy_get_previous_state( );
1255 yy_cp = (yy_c_buf_p);
1256 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1259 case EOB_ACT_LAST_MATCH:
1261 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1263 yy_current_state = yy_get_previous_state( );
1265 yy_cp = (yy_c_buf_p);
1266 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1267 goto yy_find_action;
1274 "fatal flex scanner internal error--no action found" );
1283 yyFlexLexer::yyFlexLexer( std::istream* arg_yyin, std::ostream* arg_yyout )
1293 yy_did_buffer_switch_on_eof = 0;
1295 yy_looking_for_trail_begin = 0;
1298 yy_more_offset = yy_prev_more_offset = 0;
1300 yy_start_stack_ptr = yy_start_stack_depth = 0;
1301 yy_start_stack = NULL;
1303 (yy_buffer_stack) = 0;
1304 (yy_buffer_stack_top) = 0;
1305 (yy_buffer_stack_max) = 0;
1311 void yyFlexLexer::switch_streams( std::istream* new_in, std::ostream* new_out )
1315 yy_delete_buffer( YY_CURRENT_BUFFER );
1316 yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );
1323 #ifdef YY_INTERACTIVE 1324 int yyFlexLexer::LexerInput(
char* buf,
int )
1326 int yyFlexLexer::LexerInput(
char* buf,
int max_size )
1329 if ( yyin->eof() || yyin->fail() )
1332 #ifdef YY_INTERACTIVE 1333 yyin->get( buf[0] );
1344 (void) yyin->read( buf, max_size );
1349 return yyin->gcount();
1353 void yyFlexLexer::LexerOutput(
const char* buf,
int size )
1355 (void) yyout->write( buf, size );
1371 int yyFlexLexer::yy_get_next_buffer()
1374 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1375 register char *source = (yytext_ptr);
1376 register int number_to_move, i;
1379 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1381 "fatal flex scanner internal error--end of buffer missed" );
1383 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1385 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1390 return EOB_ACT_END_OF_FILE;
1398 return EOB_ACT_LAST_MATCH;
1405 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1407 for ( i = 0; i < number_to_move; ++i )
1408 *(dest++) = *(source++);
1410 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1414 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1419 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1421 while ( num_to_read <= 0 )
1425 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1427 int yy_c_buf_p_offset =
1428 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1430 if ( b->yy_is_our_buffer )
1432 int new_size = b->yy_buf_size * 2;
1434 if ( new_size <= 0 )
1435 b->yy_buf_size += b->yy_buf_size / 8;
1437 b->yy_buf_size *= 2;
1439 b->yy_ch_buf = (
char *)
1441 yyrealloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1447 if ( ! b->yy_ch_buf )
1449 "fatal error - scanner input buffer overflow" );
1451 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1453 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1458 if ( num_to_read > YY_READ_BUF_SIZE )
1459 num_to_read = YY_READ_BUF_SIZE;
1462 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1463 (yy_n_chars), (
size_t) num_to_read );
1465 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1468 if ( (yy_n_chars) == 0 )
1470 if ( number_to_move == YY_MORE_ADJ )
1472 ret_val = EOB_ACT_END_OF_FILE;
1478 ret_val = EOB_ACT_LAST_MATCH;
1479 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1480 YY_BUFFER_EOF_PENDING;
1485 ret_val = EOB_ACT_CONTINUE_SCAN;
1487 (yy_n_chars) += number_to_move;
1488 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1489 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1491 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1503 yy_state_type yyFlexLexer::yy_get_previous_state()
1506 register yy_state_type yy_current_state;
1507 register char *yy_cp;
1510 yy_current_state = (yy_start);
1512 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1515 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1516 if ( yy_accept[yy_current_state] )
1518 (yy_last_accepting_state) = yy_current_state;
1519 (yy_last_accepting_cpos) = yy_cp;
1521 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1523 yy_current_state = (int) yy_def[yy_current_state];
1524 if ( yy_current_state >= 76 )
1525 yy_c = yy_meta[(
unsigned int) yy_c];
1527 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1530 return yy_current_state;
1541 yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )
1544 register int yy_is_jam;
1546 register char *yy_cp = (yy_c_buf_p);
1548 register YY_CHAR yy_c = 1;
1549 if ( yy_accept[yy_current_state] )
1551 (yy_last_accepting_state) = yy_current_state;
1552 (yy_last_accepting_cpos) = yy_cp;
1554 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1556 yy_current_state = (int) yy_def[yy_current_state];
1557 if ( yy_current_state >= 76 )
1558 yy_c = yy_meta[(
unsigned int) yy_c];
1560 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1561 yy_is_jam = (yy_current_state == 75);
1563 return yy_is_jam ? 0 : yy_current_state;
1569 void yyFlexLexer::yyunput(
int c,
register char* yy_bp)
1572 register char *yy_cp;
1574 yy_cp = (yy_c_buf_p);
1577 *yy_cp = (yy_hold_char);
1579 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1582 register int number_to_move = (yy_n_chars) + 2;
1583 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1584 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1585 register char *source =
1586 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1588 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1589 *--dest = *--source;
1591 yy_cp += (int) (dest - source);
1592 yy_bp += (int) (dest - source);
1593 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1594 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1596 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1597 YY_FATAL_ERROR(
"flex scanner push-back overflow" );
1600 *--yy_cp = (char) c;
1608 (yytext_ptr) = yy_bp;
1609 (yy_hold_char) = *yy_cp;
1610 (yy_c_buf_p) = yy_cp;
1618 int yyFlexLexer::yyinput()
1623 *(yy_c_buf_p) = (yy_hold_char);
1625 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1631 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1633 *(yy_c_buf_p) =
'\0';
1637 int offset = (yy_c_buf_p) - (yytext_ptr);
1640 switch ( yy_get_next_buffer( ) )
1642 case EOB_ACT_LAST_MATCH:
1658 case EOB_ACT_END_OF_FILE:
1663 if ( ! (yy_did_buffer_switch_on_eof) )
1672 case EOB_ACT_CONTINUE_SCAN:
1673 (yy_c_buf_p) = (yytext_ptr) + offset;
1679 c = *(
unsigned char *) (yy_c_buf_p);
1680 *(yy_c_buf_p) =
'\0';
1681 (yy_hold_char) = *++(yy_c_buf_p);
1702 void yyFlexLexer::yyrestart( std::istream* input_file )
1706 if ( ! YY_CURRENT_BUFFER ){
1707 yyensure_buffer_stack ();
1708 YY_CURRENT_BUFFER_LVALUE =
1709 yy_create_buffer( yyin, YY_BUF_SIZE );
1712 yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1713 yy_load_buffer_state( );
1723 void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1732 yyensure_buffer_stack ();
1733 if ( YY_CURRENT_BUFFER == new_buffer )
1736 if ( YY_CURRENT_BUFFER )
1739 *(yy_c_buf_p) = (yy_hold_char);
1740 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1741 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1744 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1745 yy_load_buffer_state( );
1752 (yy_did_buffer_switch_on_eof) = 1;
1758 void yyFlexLexer::yy_load_buffer_state()
1761 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1762 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1763 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1764 (yy_hold_char) = *(yy_c_buf_p);
1776 YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( std::istream* file,
int size )
1781 b = (YY_BUFFER_STATE) yyalloc(
sizeof(
struct yy_buffer_state ) );
1783 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1785 b->yy_buf_size = size;
1790 b->yy_ch_buf = (
char *) yyalloc(b->yy_buf_size + 2 );
1791 if ( ! b->yy_ch_buf )
1792 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1794 b->yy_is_our_buffer = 1;
1796 yy_init_buffer( b, file );
1808 void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )
1815 if ( b == YY_CURRENT_BUFFER )
1816 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1818 if ( b->yy_is_our_buffer )
1819 yyfree((
void *) b->yy_ch_buf );
1821 yyfree((
void *) b );
1829 extern "C" int isatty (
int );
1840 void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, std::istream* file )
1846 yy_flush_buffer( b );
1848 b->yy_input_file = file;
1849 b->yy_fill_buffer = 1;
1855 if (b != YY_CURRENT_BUFFER){
1856 b->yy_bs_lineno = 1;
1857 b->yy_bs_column = 0;
1863 b->yy_is_interactive = 0;
1875 void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )
1887 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1888 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1890 b->yy_buf_pos = &b->yy_ch_buf[0];
1893 b->yy_buffer_status = YY_BUFFER_NEW;
1895 if ( b == YY_CURRENT_BUFFER )
1896 yy_load_buffer_state( );
1909 void yyFlexLexer::yypush_buffer_state (YY_BUFFER_STATE new_buffer)
1912 if (new_buffer == NULL)
1915 yyensure_buffer_stack();
1918 if ( YY_CURRENT_BUFFER )
1921 *(yy_c_buf_p) = (yy_hold_char);
1922 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1923 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1927 if (YY_CURRENT_BUFFER)
1928 (yy_buffer_stack_top)++;
1929 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1932 yy_load_buffer_state( );
1933 (yy_did_buffer_switch_on_eof) = 1;
1945 void yyFlexLexer::yypop_buffer_state (
void)
1948 if (!YY_CURRENT_BUFFER)
1951 yy_delete_buffer(YY_CURRENT_BUFFER );
1952 YY_CURRENT_BUFFER_LVALUE = NULL;
1953 if ((yy_buffer_stack_top) > 0)
1954 --(yy_buffer_stack_top);
1956 if (YY_CURRENT_BUFFER) {
1957 yy_load_buffer_state( );
1958 (yy_did_buffer_switch_on_eof) = 1;
1970 void yyFlexLexer::yyensure_buffer_stack(
void)
1975 if (!(yy_buffer_stack)) {
1982 (yy_buffer_stack) = (
struct yy_buffer_state**)yyalloc
1983 (num_to_alloc *
sizeof(
struct yy_buffer_state*)
1986 memset((yy_buffer_stack), 0, num_to_alloc *
sizeof(
struct yy_buffer_state*));
1988 (yy_buffer_stack_max) = num_to_alloc;
1989 (yy_buffer_stack_top) = 0;
1993 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1998 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1999 (yy_buffer_stack) = (
struct yy_buffer_state**)yyrealloc
2001 num_to_alloc *
sizeof(
struct yy_buffer_state*)
2005 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size *
sizeof(
struct yy_buffer_state*));
2006 (yy_buffer_stack_max) = num_to_alloc;
2023 void yyFlexLexer::yy_push_state(
int new_state )
2026 if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
2030 (yy_start_stack_depth) += YY_START_STACK_INCR;
2031 new_size = (yy_start_stack_depth) *
sizeof(
int );
2033 if ( ! (yy_start_stack) )
2034 (yy_start_stack) = (
int *) yyalloc(new_size );
2037 (yy_start_stack) = (
int *) yyrealloc((
void *) (yy_start_stack),new_size );
2039 if ( ! (yy_start_stack) )
2041 "out of memory expanding start-condition stack" );
2044 (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;
2052 void yyFlexLexer::yy_pop_state()
2055 if ( --(yy_start_stack_ptr) < 0 )
2056 YY_FATAL_ERROR(
"start-condition stack underflow" );
2058 BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
2064 int yyFlexLexer::yy_top_state()
2067 return (yy_start_stack)[(yy_start_stack_ptr) - 1];
2070 #ifndef YY_EXIT_FAILURE 2071 #define YY_EXIT_FAILURE 2 2077 void yyFlexLexer::LexerError( yyconst
char msg[] )
2079 std::cerr << msg << std::endl;
2080 exit( YY_EXIT_FAILURE );
2091 int yyless_macro_arg = (n); \ 2092 YY_LESS_LINENO(yyless_macro_arg);\ 2093 yytext[yyleng] = (yy_hold_char); \ 2094 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 2095 (yy_hold_char) = *(yy_c_buf_p); \ 2096 *(yy_c_buf_p) = '\0'; \ 2097 yyleng = yyless_macro_arg; \ 2122 yyFlexLexer::~yyFlexLexer()
2127 while(YY_CURRENT_BUFFER){
2128 yy_delete_buffer( YY_CURRENT_BUFFER );
2129 YY_CURRENT_BUFFER_LVALUE = NULL;
2130 yypop_buffer_state();
2134 yyfree((yy_buffer_stack) );
2135 (yy_buffer_stack) = NULL;
2138 delete [] (yy_state_buf);
2139 yyfree((yy_start_stack) );
2154 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n )
2157 for ( i = 0; i < n; ++i )
2162 #ifdef YY_NEED_STRLEN 2163 static int yy_flex_strlen (yyconst
char * s )
2166 for ( n = 0; s[n]; ++n )
2173 void *yyalloc (yy_size_t size )
2175 return (
void *) malloc( size );
2178 void *yyrealloc (
void * ptr, yy_size_t size )
2187 return (
void *) realloc( (
char *) ptr, size );
2190 void yyfree (
void * ptr )
2192 free( (
char *) ptr );
2197 #define YYTABLES_NAME "yytables" 2202 #line 203 "qmake.ll" 2207 Lexer::Lexer( std::istream* argin, std::ostream* argout )
2208 : yyFlexLexer(argin, argout), mylval(0), m_lineEnding(None)
2218 void Lexer::setLineEndingFromString(
const TQString& str )
2220 if( str.endsWith(
"\r\n") && m_lineEnding == None )
2221 m_lineEnding = Windows;
2222 else if ( str.endsWith(
"\r") && m_lineEnding == None )
2223 m_lineEnding = MacOS;
2224 else if ( m_lineEnding == None )
2225 m_lineEnding = Unix;
2228 Lexer::LineEnding Lexer::lineending()
2230 return m_lineEnding;
2236 return lexer->yylex( yylval );