d Wdž-̀\ `D$4 `ؤP踇cUP`[̀UWVS} WʈMȧE1҃9}5E09tQB9|u95)jP Q聓CM e[^_]US9t[tdtjPȧS#ȧjtSS jtSS=uȧ@# ȧ\\]]ÐUU]-%sUWVSuF9Fwj[V_[F191U <}F9Fwj V4_ FVSoP`U GC9~8uC9E}P<PhV`F9Fwj V_ FGC9TF9Fwj]V_]Fe[^_]State #%d is non-accepting - US]=t<t=ur<ug=tXSh Q`S Q3M Q QP9Pwj P_ @]]dangerous trailing contextUWVS} ]U4}tN<uC}u=}~7EM}@@t84Vh蓼9~كM }9~e[^_] associated rule line numbers: %dUWVS}E 1~t h 8dShd`9`9lt@9~9~cF`l9~VlPhW_9O؅}C$)ȃuG9Gwj W_ GlQhW_ C9~G9Gwj W_ GT[^_] out-transitions: jam-transitions: EOF UWVS]u 19~&}؋B9hS_PSf1҃9~!ǃB9hS_PS C9Cwj S_ C[^_]consistency check failed in epsclosure()UWVSU U=u j Qd@E1E9]UU萐M4̧<|vG9=>jPQ脌EjR @Ql@@4̧t EEUuC9]oE9}DMU M쐐@U4< ̧}<G9=AjPMQ觋EjR @Q菋@@̧tEEU<t[EM9 AjPUREj Q@R@MU]ħ̧<G9=AjPMQ蚊EjR @Q肊@@̧tEEU<t[EM9 AjPUREj Q@R@MU]E9}E9}D@M̧<}}hE9}~UM MU UMEe[^_]ÐU塀jPR5jRRjRR$jRRjRRʈjRR谈$jRR蓈 =tjRRm] DFA Dump: longshortstatic const %s yy_nxt[][%d] = { could not create unique end-of-buffer statestate # %d: %d %d UTWVSj @P2{j5V{DžDž1ۃ9 | DŽDŽC9}19 |C9 }=t $@P#h `h `_ h=Dul9uV9%=\t%u%9|9t9}tj5Vz=DtO19|DŽC9}jjPo =\t~=t  5FQ =(t Ph _1ۃ 9~jC9Ч  5<9,Dž؉Љ)ȃu$TV-$P$R葎PPVPQPVQVQV,tT 5x=t-~$QVQV2C9=DuDhjjQjVKu h+ v|9xDžDž9|DŽC9}=tVhW h `_ PPQV9=DŽAQWVQPPVPQ$PVQVQVtT x5=t-~$QVQV=tVWhd h `l_DŽ`=t RWhd h `_1C9uDŽG9=# =t+=u"AaC@Z~닍9~PV =t&P4DŽ=\{9u P Qz9~%uPzC9Ч  =Dt'VQPi 9u"hjjPja11һ9|#9~C9}PRVQP[9=\tvd=DuP]=~= Q4V 0QHPe =3aVQ[^_]ÐUWVSE95M9 M 9 u~<}uQMQrE9] |!U9u C9] }9] }!M110F95Q9=jE @Pq}uM QMQ r9u | U F9u }M M }u+=twMQMQqjE@Pp9u|8Ӌ XMU 9 | MF9u}ۡM I C9u|E9}F9u}9 | XM9e[^_]consistency check failed in symfollowsetUWVSE} A]]u} ̧E١ȧE𡼧E졐<tC19U EuP9EB9U19U EuP9E|jt3B9U`Aw(=ths5E}>(t}9Eu E]E} ]9EEe[^_]bad transition character detected in sympartition()UWVS9| r}4B9}}GDŽ} uq9|9 h<gr|4uVPS} #ۡȧ5PV=WuVPWP<~119}M5؋8uPA9}uA9|C9A9 |Y}A9 }=19~/ uPuC9׃} u9W[^_]ÐUWVS9|]1ȧE19<~1 E~ EGF94ҡ= %d ) yy_c = yy_meta[(unsigned int) yy_c];yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];UURh-*h/-0h' hv-=ht1Ph-f_h-  hu h-]yy_ec[YY_SC_TO_UI(*yy_cp)]YY_SC_TO_UI(*yy_cp)yy_ec[YY_SC_TO_UI(*++yy_cp)]YY_SC_TO_UI(*++yy_cp)while ( (yy_current_state = yy_nxt[yy_current_state][%s]) > 0 )++yy_cp;yy_current_state = -yy_current_state;register const struct yy_trans_info *yy_trans_info; register YY_CHAR yy_c; for ( yy_c = %s; (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->yy_verify == yy_c; yy_c = %s )yy_current_state += yy_trans_info->yy_nxt;dowhile ( yy_base[yy_current_state] != %d ); while ( yy_current_state != %d ); UVS.=t./=t/=\Sh3/=~Gh'A, `9 `wj h `'_  `hs/=~ hu  `9 `wj h `_  `h|/=Dh'yh/oh/eSh/h0PhA0FVhT0$=~ h'hf0=~A `9 `wj h `_  `hu huh0h'jhs/hu{ 0=tRh0Rh0_=u=uhu h e[^](*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : %d)(*yy_cp ? YY_SC_TO_UI(*yy_cp) : %d)if ( *yy_cp )yy_current_state = yy_nxt[yy_current_state][%s];yy_current_state += yy_current_state[%s].yy_nxt;yy_current_state = yy_NUL_trans[yy_current_state];*yy_state_ptr++ = yy_current_state;US]tO=uF=tPRh3PRh3P_ &.=t.PP_t==t4=\u=Du9h3? h'/ =\tPh3=DtPh 4 Pt<=t3hu h{) h>4  =Du =\tz=t hq4w ]register char *yy_cp = yy_c_buf_p;yy_is_jam = (yy_current_state == 0);yy_current_state = yy_nxt[yy_current_state][%d]; yy_is_jam = (yy_current_state <= 0);register int yy_c = %d; yy_trans_info = &yy_current_state[(unsigned int) yy_c];yy_is_jam = (yy_trans_info->yy_verify != yy_c);%dyy_is_jam = (yy_current_state == %d); if ( ! yy_is_jam )UVS1=~ =t h6  `9 `wj h `_  `=th>4 hB6 =\t7BPRhg6_h6g =DtGPRh6_h/' h6 hf0 h7 QPRh?7]S_S=t hq4RhB7*_tw=Du =\te `9 `w j h `_  `hi7]h'M8hu> e[^] + (yy_bp[-1] == '\n' ? 1 : 0)yy_current_state = yy_start_state_list[yy_start%s];yy_current_state = yy_start;if ( yy_bp[-1] == '\n' )++yy_current_state;yy_state_ptr = yy_state_buf;U=Dt$|9=t]9Ph}9]Ðh96=t#h9 h9 =th9hq4]yy_accliststate # %d accepts: [%d], Meta-Equivalence Classes: yy_meta%d = %d yy_baseyy_defyy_nxtyy_chkUWVS Cj=WLE=E]M }@Ph:2=(t^PL_E 9%}}}M9<EU=tSh:h `n_ 9uMM}E=t@u~9 |<u RR=t_M Qh:h `_ 9u~h `h:_. `9 `wj h `_  `EF9uQEC9M} NNI59|UF8:C9}M5=tFVh<,2=(t^P_ 9|Mu>WQ=u$=t>tQShF,h `_C9}}= YYLMAX ) \YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \#define YY_END_OF_BUFFER %d longshortstruct yy_trans_infolong yy_verify;short yy_verify;%s yy_nxt;};static yy_state_type yy_last_accepting_state;static char *yy_last_accepting_cpos; yy_NUL_transextern int yy_flex_debug;int yy_flex_debug = 1; yy_rule_linenumstatic yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;static char *yy_full_match;static int yy_lp;static int yy_looking_for_trail_begin = 0;static int yy_full_lp;static int *yy_full_state;#define YY_TRAILING_MASK 0x%x #define YY_TRAILING_HEAD_MASK 0x%x #define REJECT \{ \*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \yy_cp = yy_full_match; /* restore poss. backed-over text */ \yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \yy_state_ptr = yy_full_state; /* restore orig. state */ \yy_current_state = *yy_state_ptr; /* restore curr. state */ \++yy_lp; \goto find_rule; \/* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. */#define REJECT reject_used_but_not_detectedstatic int yy_more_flag = 0;static int yy_more_len = 0;#define yymore() (yy_more_flag = 1)#define YY_MORE_ADJ yy_more_len#define yymore() yymore_used_but_not_detected#define YY_MORE_ADJ 0#ifndef YYLMAX#define YYLMAX 8192#endif char yytext[YYLMAX];char *yytext_ptr;char *yytext; if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); if ( yy_current_buffer->yy_is_interactive ) \ { \ int c = getc( yyin ); \ result = c == EOF ? 0 : 1; \ buf[0] = (char) c; \ } \ else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ && ferror( yyin ) ) \ yy_more_len = 0;if ( yy_more_flag )yy_more_len = yyleng;yy_more_flag = 0;yy_match:if ( yy_act != YY_END_OF_BUFFER )int yyl;for ( yyl = 0; yyl < yyleng; ++yyl )if ( yytext[yyl] == '\n' )++yylineno;if ( yy_flex_debug )if ( yy_act == 0 )fprintf( stderr, "--scanner backing up\n" );else if ( yy_act < %d ) fprintf( stderr, "--accepting rule at line %d (\"%s\")\n", yy_rule_linenum[yy_act], yytext );else if ( yy_act == %d ) fprintf( stderr, "--accepting default rule (\"%s\")\n", yytext );fprintf( stderr, "--(end of buffer or a NUL)\n" );else fprintf( stderr, "--EOF (start condition %d)\n", YY_START );case YY_STATE_EOF(%s): yyterminate();yy_cp = yy_c_buf_p;register char *yy_bp = yytext_ptr; if ( c == '\n' )--yylineno;UVS1H=t!hAGhA=hA&BH=@t-hA hB hLB G @PhB<_=Dl@= =(t B BhBwh'g=(t hB hBFShBhB.  =Dt =\t=~)=u =uhBhC=to@PhACh_ 9|D=DtPh)"_PAC9}==tkhNC>hhC4 RhC2=(t^P胻_9 ~8P@C9 <==u!hCy_hCo_hCe_ =tK=u!hDF_h,D<_hCD2_ h h^Dغ_h@h}Dɺ_hD_hD_hD_hD_=t!h5Eк_hnEƺ_hE輺_ hE诺_hE襺_hu蛺_ 5hF肺_hME }D}u8=\u =Dt=u}u*=\u =Dt =|t]=t hpf=\u =Dt hfx@=\u =Dt=ht hf=\u =Dt=t hfg=\t=Dt hfH=t=Dt hg)=uc;g=t8gP `QTRhDq_h `h=ghD]_uhDh?gwXM $U ~1P脙=t,h=ghSg豒_uh^g[ <=\t1hzg \Q\_Hu\Rh|g5`FUhg `Qhghg薗_hg`Rhghg{_ hg `Qhghg]_hg`RhghgB_ hg `Qhghg$_hg`Rhghg _ hg `Qhghg_hh`RhhhgЖ_ hh `Qhhhg貖_hh`Rhhhg藖_ hh `Qhhhgy_h!h`Rh!hhg^_ h)h `Qh)hhg@_h.h`Rh.hhg%_ h3h_4 xЧ(0=tL9|@C9}59|"C9}e[^_]fatal parse error-l AT&T lex compatibility option entails a large performance penalty and may be the actual source of other reported performance penalties -I (interactive) entails a minor performance penalty yymore() entails a minor performance penalty REJECT entails a large performance penalty Variable trailing context rules entail a large performance penalty REJECT cannot be used with -f or -Fvariable trailing context rules cannot be used with -f or -Ftypedef unsigned char YY_CHAR;typedef char YY_CHAR;#define yytext_ptr yytext#define YY_INTERACTIVEtypedef const struct yy_trans_info *yy_state_type; typedef int yy_state_type; #define YY_USES_REJECT #define FLEX_DEBUGFILE *yyin = stdin, *yyout = stdout; extern int yylineno; int yylineno = 1; FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; #include extern char yytext[]; extern char *yytext;U|jU1thuGj=t j=xu=xu =u=u ==|t!huh `蔊_hvh `腊_=~6=thIvh `a_=thvh `F_=thvh `+_=thvh `_=t `=t =\u =Dt&=t=`thwhAwZ=uh~whwR_=t#hw<_=t hw&_=Dthw=u hx豎_=t h4x蛎_=t hMx͎_=|t%haxo_hxe_hx[_ =uhxA_=thx+_9=@thxY_hyB_hw8_=t Rhh }أP=t!]ÐULjh+ jLR 4jLR ,jLR  jLR ̧jLR ħjLR jLR  jLR djjdu jRb 8jRO X<( jj(4 $j<R! $j<R j<R  j<R j<R tdjjd ȧjtR  jtR jhv @jhQ j@R>  jh jh jRjR jRjRjRjR]%s [-bcdfhilnpstvwBFILTV78+ -C[aefFmr] -Pprefix -Sskeleton] [file ...] -b generate backing-up information to lex.backup -c do-nothing POSIX option -d turn on debug mode in generated scanner -f generate fast, large scanner -h produce this help message -i generate case-insensitive scanner -l maximal compatibility with original lex -n do-nothing POSIX option -p generate performance report to stderr -s suppress default rule to ECHO unmatched text -t write generated scanner on stdout instead of lex.yy.c -v write summary of scanner statistics to stderr -w do not generate warnings -B generate batch scanner (opposite of -I) -F use alternative fast scanner representation -I generate interactive scanner (opposite of -B) -L suppress #line directives in scanner -T %s should run in trace mode -V report %s version -7 generate 7-bit scanner -8 generate 8-bit scanner -+ generate C++ scanner class -C specify degree of table compression (default is -Cem): -Ca trade off larger tables for better memory alignment -Ce construct equivalence classes -Cf do not compress scanner tables; use -f representation -CF do not compress scanner tables; use -F representation -Cm construct meta-equivalence classes -Cr use read() instead of stdio for scanner input -P specify scanner prefix other than "yy" -S specify skeleton file U0RhCh `_hh `_hh `_hh `v_$h h `d_h.h `U_hNh `F_hvh `7_ hh `%_h€h `_hh `_h!h `~_ h]h `~_hh `~_hh `~_hށh `~_ hh `~_hDh `~_0Rhoh `~_0Rhh `l~_(hh `Z~_hƂh `K~_hh `<~_hh `-~_ hAh `~_h}h ` ~_hh `}_hh `}_ hh `}_hJh `}_hh `}_hh `}_]ÐUWVS]0Љǃ&5jP5V2  9}SPԆ_=e[^_]request for < 1 byte in allocate_array()memory allocation failed in allocate_array()US] ] h\S覃Ãu h؋]]ÐUU:t+  `:| Au1]ÐB:u޸]ÐUU:t+  `:| Au1]ÐB:u޸]ÐUWVSu] ~/9}N9T} |9T@9|Kԍe[^_]bad character '%s' detected in check_char()scanner requires -8 flag to use the character '%s'US]~S Phʈ 9S Pht]]ÐUU|6 `Pt+%9t `%]dynamic memory failure in copy_string()UVSUӀ:tB:u)@Pgƃu hˉLCVt CBue[^]ÐUSUӀ:tB:uj)@P=CQt CBuȋ]]ÐUWVSuE ] e9] ~PAىM}t<1t.<2t22M81s2M 1 2M1)yG9} e[^_] } ; U=Ч~/h>~_Ч]ÐU塜 `9 `w j h `t_  `= ~; `9 `wj h `t_  `Ч]%s: %s UUR0Rh!h `;x_j]%s: fatal internal error, %s UUR0RhXh `w_j,w_USU RURS_S\]ÐUSU RURS貀_S,]%xUEPhUR蘀_E]ÐUU `Pt]ÐR%fa}1]# line %d "%s" UVSu=Pt?=8t6PRRh{S_t VSv_S[^]ÐU]ÐU  ] %5dU=Ч ~2 `9 `wj,h `q_, `=Чuh `hwu_. `9 `wj,h `q_ , `ЧURh|z_]ÐU=Ч ~2 `9 `wj,h `;q_, `"=Чuh `hwu_. `9 `wj,h `p_ , `ЧURh|3z_]%dUEEPhяUR}_E]ÐUWVS}GЃHT$@pБ0   |%G5 `FtWBC:| Fu ;M;GP}M ;%T|_PtCF;} >M>GPM >% Ge[^_]%oUEPhUR{_E]\b\f\n\r\t\a\v\%.3o' 'UUv ~B$0pP@`]В]ÐŒ]ÐȒ]Ð˒]ÐΒ]Ðђ]ÐRhԒhz_]Ð t]Ðڒ]attempt to increase array size by less than 1 byteattempt to increase array size failedUS] ] hSUR"wÃu h؋]]bad line in skeleton file%s UVS=HtHRhSmo_ u LL;%}C<*t<%J<+t <-t65뀐=fhF0=Hth `Sn_Sh5t_[^]%7d, %5d,UM QMQhs_Ч =ЧJ~{ `9 `wj h `Oj_  ` u) `9 `wj h `j_  `Ч]memory allocation failed in yy_flex_xmalloc()USURtÃu h؋]]ÐUEU 9s @9r]UVSu] ,<uhV PVe[^]ÐUWVS} h ƻ9URsPVƃ C9~e[^_] ********** beginning dump of nfa with start state %d state # %4d %3d: %4d, %4d [%d] ********** end of dump UWVSURh֗h `#l_ 95|}Vhh `l_ ̧ħ<R QShh `k_ tWh*h `k_ h1h `k_F95}h3h `k_e[^_]empty machine in dupmachine()UWVS14ME9]||PZơ̧<tK)P,Pd <u$ħ<t)P,P2 <t,hVS)WS"e[^_]ÐUURP]ÐUS],<u ̧<th~PS'à hhSPá,PS؋]]ÐUWVSu} uhVPWV. ,<u$̧<u<uS= %d NFA states)US]9LLL=|~Ph}j LQ Q7j LQ 4Q4j LQ ,Q,$j LQ Qj LQ ̧Q̧j LQ ħQħ$j LQ Qj LQ Q{j LQ Qa$,4̧ħ    |@u 0S=thh؅uP_{]]found too many transitions in mkxtion()UUM ̧<u ]Ð<u ħ<thQ]Ð ]too many rules (> %d)!U  9^djP Qj Q 8Q8j Q XQxX$= ~hhI 8  X]   !"""#$$%%%&&'((((((())*+**,----../001111111111112233344  1.,86 "%-6 #$&'( 7/052!3+4*)S  '(? !,)=@ "0!6&/+89&;8.K7PQ )5PD$D2M0NB@*< =Q4EFK ."/5A#+-%6:;789I&>123H2LORTUGJC   /  G   2=+parser stack overflowYY_FATAL_ERROR( "flex scanner jammed" )ECHO; YY_BREAK INITIALunknown error processing section 1bad start condition list'^' operator results in sub-optimal performanceall start conditions already have <> rulesunrecognized ruleundeclared start condition %stoo many start conditions in <> construct!trailing context made variable due to preceding '|' actiontrailing context used twicebad iteration valuesiteration value must be positivenegative range in character classparse errorUWVSp@P<Dž8DžLDžDnH> rules for start condition %scase YY_STATE_EOF(%s): UVS9|h <tRh?+RhmVM_VC9}jy [^]ÐUSU RURSbM_S ]ÐUEPZ]ÐUPEPn]ÐUSU RURSL_S ]ÐUPEPn]warning, %sUS=uURhSL_U RS]"%s", line %d: %s UURU RPRh<h `C_]ÐU]Ð))nnqooooo<56</<;<<<<,+<<-.)*)('((nnA=>@BPQPNMOCECDCHHHJLJJJK\a\`bb]]]Z[ooSoRefedgigjkXXYXXXXXX$! $$$X 566229lll101,++8,)*(''%&nn?@QMEmmmFGLI\a_^]]]SefeffcgihXXXYUXXX$! $$T  34999ll11:8%&mm]]UUXX$$ 449999lm]]XX$$ 9999]]XX$$99VWVW"# 7    !"#$%&'( !"#$%&'()*+  +U~YfKJElo76twbz)]hRT  <;GOBB@@8O==OO0,K99n,O66643O11O OOOOOOOOLOM~OvNOggOU[J8OO[ZVORE3"7[-+O^O_OfOiVkO}mOOoOeO"LaTOOOG@OO%v-OOOFOOEOOOOOOO51uKxOJOOBOAOOOO%">OOR21U'O&NLO   XZObOO#Y1OOOOOZ?^eVRfjOOOlnqO_OZhv&39FTbp~ )7ES[hv#  %%%  <,-./,,,,,,,,,,,,,,,,00000000000000000000,,,,123,,4,,,,,5,,,,,,,66666666666666666666,,,89:;<IJ===>,?@LIMNZ[\Z[\noijkijk,A=BCD;<El==l=nFo?@GqrqrsstutuA=QQRSQQQQQTQQQQQQQQQQUUUUUUUUUUUUUUVUUUUWQQQ]],]]]]]]^^]]]]_]]]]````````````````````]]]cdcdeeffg,gvvwxyvvzvvvv{vvvvvvv||||||||||||||}||||~v , $%() !-  .BC$%S%Y,()o,111111111121211111122222222222222222222113U)KWBCeC+Kq,,X99:;99999<9999999999<<<<<<<<<<<<<<<<<<<<999DD,DDDDDDEDDDDDDDDDDEEEEEEEEEEEEEEEEEEEEDDDZ0>[,0>[ZZZZZZ<<,`<<<<<~<<<<<<<<<<a}|{azyxwdvu_^tsnTRm<<<EElEEEEEEkEEEEEEEEEEjihgfdcb_^]\,VTRPOEEEpMLJ,JIHpppppprGF, rrrrrr@,?=77777777777777HHHHHHHHHHHHHHKKKKKKKKKKKKKKOOOOOOOOOOOOOOYYYYYYYYYYYYYY,,,,,,,,,,,,,,bbbbbbbbbbbbbbhhhhhhhhhhhhhhmmmmmmmmmmmmmmpppppppppppppp87/,*&            """##############''''''''''''''++++++++++++111111111111444444444444455555555555556666666666666AAAAAAAAAAAAAANNNNNQQQQQaaXPP+ EooE   !!NN!""###"$$$---111#<<<$@lntz~z@lnt}%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%'''(((888|8BBB B zy'(x'(4w8##B%%-4v4-4''u444444t44W4AAWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAs)),AACC,{{KKKYoYo,  r                                        ........<<q<<<<<<n<<<<<<<<<<lkjihgfecb`_]\VUSP<<<EEOEEEEEEMEEEEEEEEEELIHGFB@?=;:87/+*($! EEEXXXXXXXXZZ ZZZZZZpppppppp~}{xwrqjifdc_\[ZXWVSROMLJIFDC?>:9532/.+*) %pointer incompatible with -l option%array incompatible with -+ option%used/%unused have been deprecatedunrecognized '%' directiveincomplete name definitionunrecognized %used/%unused constructbad character classundefined definition {%s}bad : %smissing quotebad character inside {}'smissing }bad name in {}'s YY_BREAK EOF encountered inside an actionbad character: %sflex scanner jammedfatal flex scanner internal error--no action foundU WVSDž=p=tu t=u < `=u  `=htRhRh@Rhrp5lt uCf<]t:5,]~ ]hE9u]hEFf<]hOd]=)|5l=h$(HhHxXHX2>8h(x08h0(8hX(Hh(HxHhX(HbXx(h8Xhh(Hx5t RLtj軜t ?ߜjhtl=|th%@=th@hht'Bh Rh_t R薔t RV=tRSU_0ЍX|+ t + uKyƄ+Phz=u h2tttR茔tMdRtx4hMN w5l=)|WG5l=c =l=|=lwtXc 9%%DžQt <l t"L w5l=)|WG5lt{ tiw5l=)|WG5l$ t%  f t 8 tRj t  t1 Rh'_hvà t,]t hr@ r @Phuw5l=)|WG5lt[ @Phw_|ƀhuvƃ uhh0Ѓ=|u>^t ~[|$uT0ЍX|R3P Ky>^tRj) 0ЍX|R3P KyRj(s tt>w5l=)|WG5lt>hRh_ERhKt^ t"h~t"w5l=)|WG5ltGw5l=)|WG5ltw5l=)|WG5l-4hrNt]R謔e,Vht}2ht} hhIRR@%R謊RRf=t=u h-DžtaR>R܉ R載t!R蜉t#Rv=h\tR<tt)qtYRt:R܈$h>Rܑ%`R輑%t6Rj|RRl_%Rh)g_h;+XhxuP@h@9lwTlSS =tl5l5lit&z t-ltHr'=+Rl_Ë5l=h@l(Ë5l=ihO [^_]fatal flex scanner internal error--end of buffer missedfatal error - scanner input buffer overflowinput in flex scanner failedUWVShrK@9lv hhxu2l+u=l+=19} CF@9|hxu^h5l+sK ȉC PKQCu h9s5lh@ )H~= ~ hztfB9BwR_tP@ h@N QPjBP_u Q+_t hb=uFu! Q0h@1ۉh@h@Dh@@؍e[^_]ÐUVS tx uA95l>t fS8]]ÐUS]U C CC@C@KAKtR_P_CCCC]]out of memory expanding start-condition stackUVSx9|V||ƒ=uPR5V#=u hx tHxu te[^]start-condition stack underflowU xy h Kx t]ÐUxD]%s UURhN h `_j[_UEuP _]ÐUU RURP_]ÐUEP_]U $=$]ÐP,1]rcan't open %sUS]t5Ph S,_u,Sh 腁< `P ]]ÐUUR]UU RUR]ÐUEP] free( ptr );static void yy_flex_free( ptr )static void yy_flex_free( void *ptr ) return (void *) realloc( ptr, size );void *ptr;static void *yy_flex_realloc( ptr, size )static void *yy_flex_realloc( void *ptr, unsigned int size ) return (void *) malloc( size );unsigned int size;static void *yy_flex_alloc( size )static void *yy_flex_alloc( unsigned int size ) s1[i] = s2[i]; for ( i = 0; i < n; ++i ) register int i;int n;const char *s2;char *s1;static void yy_flex_strncpy( s1, s2, n )static void yy_flex_strncpy( char *s1, const char *s2, int n )/* Internal utility routines. */ yyleng = n; \ *yy_c_buf_p = '\0'; \ yy_hold_char = *yy_c_buf_p; \ yy_c_buf_p = yytext + n - YY_MORE_ADJ; \ yytext[yyleng] = yy_hold_char; \#undef yyless/* Redefine yyless() so it works in section 3 code. */ cerr << msg << '\n';void yyFlexLexer::LexerError( const char msg[] ) exit( 1 ); (void) fprintf( stderr, "%s\n", msg );char msg[];static void yy_fatal_error( msg )static void yy_fatal_error( const char msg[] ) return yy_start_stack[yy_start_stack_ptr - 1];int yyFlexLexer::yy_top_state()static int yy_top_state() BEGIN(yy_start_stack[yy_start_stack_ptr]); YY_FATAL_ERROR( "start-condition stack underflow" ); if ( --yy_start_stack_ptr < 0 )void yyFlexLexer::yy_pop_state()static void yy_pop_state() BEGIN(new_state); yy_start_stack[yy_start_stack_ptr++] = YY_START; "out of memory expanding start-condition stack" ); (void *) yy_start_stack, new_size ); yy_start_stack = (int *) yy_flex_realloc( yy_start_stack = (int *) yy_flex_alloc( new_size ); if ( ! yy_start_stack ) new_size = yy_start_stack_depth * sizeof( int ); yy_start_stack_depth += YY_START_STACK_INCR; int new_size; if ( yy_start_stack_ptr >= yy_start_stack_depth )void yyFlexLexer::yy_push_state( int new_state )int new_state;static void yy_push_state( new_state )static void yy_push_state( int new_state ) b->yy_buffer_status = YY_BUFFER_NEW; b->yy_fill_buffer = 1; b->yy_is_interactive = 0; b->yy_is_interactive = file ? isatty( fileno(file) ) : 0; b->yy_buf_pos = &b->yy_ch_buf[1]; b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR; b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; * a jam in that state. * a transition to the end-of-buffer state. The second causes /* We always need two end-of-buffer characters. The first causes b->yy_n_chars = 1; b->yy_ch_buf[0] = '\n'; * initial match-at-newline will be true. /* We put in the '\n' and start reading from [1] so that an b->yy_input_file = file;void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )void yy_init_buffer( b, file )void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) yy_flex_free( (void *) b ); yy_flex_free( (void *) b->yy_ch_buf ); yy_current_buffer = (YY_BUFFER_STATE) 0; if ( b == yy_current_buffer )void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )YY_BUFFER_STATE b;void yy_delete_buffer( b )void yy_delete_buffer( YY_BUFFER_STATE b ) return b; yy_init_buffer( b, file ); if ( ! b->yy_ch_buf ) b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); * we need to put in 2 end-of-buffer characters. /* yy_ch_buf has to be 2 characters longer than the size given because b->yy_buf_size = size; YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); if ( ! b ) b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); YY_BUFFER_STATE b;YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )int size;FILE *file;YY_BUFFER_STATE yy_create_buffer( file, size )YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) yy_hold_char = *yy_c_buf_p; yyin = yy_current_buffer->yy_input_file; yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; yy_n_chars = yy_current_buffer->yy_n_chars;void yyFlexLexer::yy_load_buffer_state()void yy_load_buffer_state()void yy_load_buffer_state( void ) yy_did_buffer_switch_on_eof = 1; * to go ahead and always set it. * is looked at is after yywrap() is called, so it's safe * EOF (yywrap()) processing, but the only time this flag /* We don't actually know whether we did this switch during yy_current_buffer = new_buffer; yy_current_buffer->yy_n_chars = yy_n_chars; yy_current_buffer->yy_buf_pos = yy_c_buf_p; *yy_c_buf_p = yy_hold_char; /* Flush out information for old buffer. */ if ( yy_current_buffer ) return; if ( yy_current_buffer == new_buffer )void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )YY_BUFFER_STATE new_buffer;void yy_switch_to_buffer( new_buffer )void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) yy_load_buffer_state(); yy_init_buffer( yy_current_buffer, input_file ); yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); if ( ! yy_current_buffer )void yyFlexLexer::yyrestart( istream* input_file )FILE *input_file;void yyrestart( input_file )void yyrestart( FILE *input_file ) return c; yy_hold_char = *++yy_c_buf_p; *yy_c_buf_p = '\0'; /* preserve yytext */ c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ "unexpected last match in input()" ); "unexpected last match in yyinput()" ); YY_FATAL_ERROR( case EOB_ACT_LAST_MATCH: break; case EOB_ACT_CONTINUE_SCAN: return input(); return yyinput(); YY_NEW_FILE; } return EOF; yytext_ptr + YY_MORE_ADJ; yy_c_buf_p = { if ( yywrap() ) case EOB_ACT_END_OF_FILE: switch ( yy_get_next_buffer() ) ++yy_c_buf_p; yytext_ptr = yy_c_buf_p; { /* need more input */ *yy_c_buf_p = '\0'; /* This was really a NUL. */ if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) * valid NUL; if not, then we've hit the end of the buffer. * If this occurs *before* the EOB characters, then it's a /* yy_c_buf_p now points to the character we want to return. if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) *yy_c_buf_p = yy_hold_char; int c;int yyFlexLexer::yyinput()static int input()static int yyinput() YY_DO_BEFORE_ACTION; /* set up yytext again */ * macro to now work correctly. /* Note: the formal parameter *must* be called "yy_bp" for this%% update yylineno here, if doing -l *--yy_cp = (char) c; yy_cp[-2] = '\n'; if ( yy_cp > yy_bp && yy_cp[-1] == '\n' ) YY_FATAL_ERROR( "flex scanner push-back overflow" ); if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) yy_n_chars = yy_current_buffer->yy_buf_size; yy_bp += dest - source; yy_cp += dest - source; *--dest = *--source; while ( source > yy_current_buffer->yy_ch_buf ) &yy_current_buffer->yy_ch_buf[number_to_move]; register char *source = yy_current_buffer->yy_buf_size + 2]; register char *dest = &yy_current_buffer->yy_ch_buf[ register int number_to_move = yy_n_chars + 2; /* +2 for EOB chars. */ { /* need to shift things up to make room */ if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ register char *yy_cp = yy_c_buf_p;void yyFlexLexer::yyunput( int c, register char* yy_bp )register char *yy_bp;int c;static void yyunput( c, yy_bp )static void yyunput( int c, register char *yy_bp ) return yy_is_jam ? 0 : yy_current_state;%% code to find the next state, and perhaps do backing up, goes here register int yy_is_jam;yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )yy_state_type yy_current_state;static yy_state_type yy_try_NUL_trans( yy_current_state )static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) * next_state = yy_try_NUL_trans( current_state ); * synopsis/* yy_try_NUL_trans - try to make a transition on the NUL character return yy_current_state;%% code to find the next state goes here for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )%% code to get the start state into yy_current_state goes here register char *yy_cp;yy_state_type yyFlexLexer::yy_get_previous_state()static yy_state_type yy_get_previous_state()/* yy_get_previous_state - get the state just before the EOB char was reached */ return ret_val; yytext_ptr = &yy_current_buffer->yy_ch_buf[1]; * yy_get_previous_state() will have with '^' rules active. * buffer; it needs to be kept around in case it's a newline, so * character is the one which preceded it before reading in the latest /* yytext begins at the second character in yy_ch_buf; the first yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; yy_n_chars += number_to_move; ret_val = EOB_ACT_CONTINUE_SCAN; YY_BUFFER_EOF_PENDING; yy_current_buffer->yy_buffer_status = ret_val = EOB_ACT_LAST_MATCH; yyrestart( yyin ); ret_val = EOB_ACT_END_OF_FILE; if ( number_to_move - YY_MORE_ADJ == 1 ) if ( yy_n_chars == 0 ) yy_n_chars, num_to_read ); YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), /* Read in more data. */ num_to_read = YY_READ_BUF_SIZE; if ( num_to_read > YY_READ_BUF_SIZE ) number_to_move - 1; num_to_read = yy_current_buffer->yy_buf_size - yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; "fatal error - scanner input buffer overflow" ); YY_FATAL_ERROR( if ( ! b->yy_ch_buf ) b->yy_buf_size ); yy_flex_realloc( (void *) b->yy_ch_buf, b->yy_ch_buf = (char *) b->yy_buf_size *= 2; int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf; YY_BUFFER_STATE b = yy_current_buffer; /* just a shorter name for the current buffer */"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); YY_FATAL_ERROR(#ifdef YY_USES_REJECT { /* Not enough room in the buffer - grow it. */ while ( num_to_read <= 0 ) yy_current_buffer->yy_buf_size - number_to_move - 1; int num_to_read = yy_n_chars = 0; * just force an EOF /* don't do the read, it's not guaranteed to return an EOF, if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) *(dest++) = *(source++); for ( i = 0; i < number_to_move; ++i ) number_to_move = yy_c_buf_p - yytext_ptr; /* First move last chars to start of buffer. */ /* Try to read more data. */ return EOB_ACT_LAST_MATCH; * process it. /* We matched some text prior to the EOB, first return EOB_ACT_END_OF_FILE; * treat this as a final EOF. /* We matched a singled characater, the EOB, so if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) { /* Don't try to fill the buffer, so this is an EOF. */ if ( yy_current_buffer->yy_fill_buffer == 0 ) "fatal flex scanner internal error--end of buffer missed" ); if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) int ret_val; register int number_to_move, i; register char *source = yytext_ptr - 1; /* copy prev. char, too */ register char *dest = yy_current_buffer->yy_ch_buf;int yyFlexLexer::yy_get_next_buffer()static int yy_get_next_buffer() * EOB_ACT_END_OF_FILE - end of file * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_LAST_MATCH - * Returns a code representing an action:/* yy_get_next_buffer - try to read in a new buffer (void) yyout->write( buf, size );void yyFlexLexer::LexerOutput( const char* buf, int size ) return yyin->gcount(); else (void) yyin->read( buf, max_size ); return 1; return -1; if ( yyin->bad() ) if ( yyin->eof() ) yyin->get( buf[0] ); return 0; if ( yyin->eof() || yyin->fail() )int yyFlexLexer::LexerInput( char* buf, int max_size )int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )#ifdef YY_INTERACTIVE } /* end of yylex */ } /* end of scanning one token */ } /* end of action switch */ "fatal flex scanner internal error--no action found" ); YY_FATAL_ERROR( default: break; &yy_current_buffer->yy_ch_buf[yy_n_chars]; case EOB_ACT_LAST_MATCH: yy_bp = yytext_ptr + YY_MORE_ADJ; yy_cp = yy_c_buf_p; yy_current_state = yy_get_previous_state(); yytext_ptr + yy_amount_of_matched_text; yy_c_buf_p = case EOB_ACT_CONTINUE_SCAN: break; YY_NEW_FILE; if ( ! yy_did_buffer_switch_on_eof ) else } goto do_action; yy_act = YY_STATE_EOF(YY_START); yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; */ * YY_NULL will get returned. * YY_NULL, it'll still work - another * call the scanner after we return the * hoser (like flex itself) wants to * yy_c_buf_p so that if some total * yytext, we can now set up * yy_get_next_buffer() to have set up /* Note: because we've taken care in { if ( yywrap() ) yy_did_buffer_switch_on_eof = 0; case EOB_ACT_END_OF_FILE: else switch ( yy_get_next_buffer() ) goto yy_find_action;%% code to do back-up for compressed tables and set up yy_cp goes here else } goto yy_match; yy_current_state = yy_next_state; yy_cp = ++yy_c_buf_p; /* Consume the NUL. */ { if ( yy_next_state ) yy_bp = yytext_ptr + YY_MORE_ADJ; yy_next_state = yy_try_NUL_trans( yy_current_state ); * will run more slowly). * want to build jamming into it because then it * with the possibility of jamming (and we don't * for us because it doesn't know how to deal * yy_get_previous_state() go ahead and do it * transition. We couldn't have /* Okay, we're now positioned to make the NUL yy_current_state = yy_get_previous_state(); yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; yy_state_type yy_next_state; { /* This was really a NUL. */ if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) * in input(). * end-of-buffer state). Contrast this with the test * (since all states make transitions on EOB to the * already have been incremented past the NUL character * of the first EOB in the buffer, since yy_c_buf_p will /* Note that here we test for yy_c_buf_p "<=" to the position } yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; yy_current_buffer->yy_input_file = yyin; yy_n_chars = yy_current_buffer->yy_n_chars; */ * back-up) that will match for the new input source. * this is the first action (other than possibly a * globals. Here is the right place to do so, because * consistency between yy_current_buffer and our * yylex(). If so, then we have to assure * just pointed yyin at a new source and called * possible that this happened because the user /* We're scanning a new file or input source. It's { if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) /* Undo the effects of YY_DO_BEFORE_ACTION. */ int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1; /* Amount of text matched not including the EOB char. */ case YY_END_OF_BUFFER:%% actions go here { /* beginning of action switch */ switch ( yy_act )%% debug code goes heredo_action: /* This label is used only to access EOF actions. */%% code for yylineno update goes here, if -l option YY_DO_BEFORE_ACTION;%% code to find the action number goes hereyy_find_action:%% code to set up and find next match goes here yy_bp = yy_cp; */ * the current run. /* yy_bp points to the position in yy_ch_buf of the start of *yy_cp = yy_hold_char; /* Support of yytext. */ yy_cp = yy_c_buf_p;%% yymore()-related code goes here while ( 1 ) /* loops until end-of-file is reached */ } yy_init = 0; yy_load_buffer_state(); yy_create_buffer( yyin, YY_BUF_SIZE ); yy_current_buffer = else yy_init_buffer( yy_current_buffer, yyin ); if ( yy_current_buffer ) yyout = &cout; yyout = stdout; if ( ! yyout ) yyin = &cin; yyin = stdin; if ( ! yyin ) yy_start = 1; /* first start state */ if ( ! yy_start ) YY_USER_INIT;#ifdef YY_USER_INIT { if ( yy_init )%% user's declarations go here register int yy_act; register char *yy_cp, *yy_bp; register yy_state_type yy_current_state;YY_DECL#define YY_BREAK break;#ifndef YY_BREAK/* Code executed at the end of each rule. */#define YY_USER_ACTION#ifndef YY_USER_ACTION * have been set up./* Code executed at the beginning of each rule, after yytext and yyleng#define YY_DECL int yyFlexLexer::yylex()#define YY_DECL int yylex YY_PROTO(( void ))#ifndef YY_DECL * easily add parameters./* Default declaration of generated scanner - a define so the user can#define YY_FATAL_ERROR(msg) LexerError( msg )#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )#ifndef YY_FATAL_ERROR/* Report a fatal error. */#define YY_START_STACK_INCR 25#ifndef YY_START_STACK_INCR/* Number of entries by which start-condition stack grows. */#define yyterminate() return YY_NULL#ifndef yyterminate * some compilers to complain about unreachable statements. * we don't want an extra ';' after the "return" because that will cause/* No semi-colon after return; correct usage is to write "yyterminate();" - YY_FATAL_ERROR( "input in flex scanner failed" ); if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \%% fread()/read() definition of YY_INPUT goes here unless we're doing C++#define YY_INPUT(buf,result,max_size) \#ifndef YY_INPUT * is returned in "result"./* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,#define ECHO LexerOutput( yytext, yyleng )%+ C++ definition#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) * we now use fwrite()./* This used to be an fputs(), but since the string might contain NUL's,#ifndef ECHO/* Copy whatever the last rule matched to the standard output. */#define YY_READ_BUF_SIZE 8192#ifndef YY_READ_BUF_SIZE/* Amount of stuff to slurp up with each read. */ * or sizeof(void*) != sizeof(int). * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)/* Just try to get by without declaring the routines. This will fail#if __STDC__YY_MALLOC_DECL#ifdef YY_MALLOC_DECL * section 1./* Macros after this point can all be overridden by user definitions in%% data tables for the DFA and the user's section 1 definitions go here yy_c_buf_p = yy_cp;%% code to copy yytext_ptr to yytext[] goes here, if %array *yy_cp = '\0'; \ yy_hold_char = *yy_cp; \%% code to fiddle yytext and yyleng for yymore() goes here yytext_ptr = yy_bp; \#define YY_DO_BEFORE_ACTION \ * corresponding action - sets up yytext./* Done after the current pattern has been matched and before thestatic void yy_fatal_error YY_PROTO(( const char msg[] ));static int yy_get_next_buffer YY_PROTO(( void ));static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));static yy_state_type yy_get_previous_state YY_PROTO(( void ));static int input YY_PROTO(( void ));static int yyinput YY_PROTO(( void ));static void yy_flex_strncpy YY_PROTO(( char *, const char *, int ));#ifndef yytext_ptr%% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here#define yy_new_buffer yy_create_bufferstatic void yy_flex_free YY_PROTO(( void * ));static void *yy_flex_realloc YY_PROTO(( void *, unsigned int ));static void *yy_flex_alloc YY_PROTO(( unsigned int ));static int yy_top_state YY_PROTO(( void ));static void yy_pop_state YY_PROTO(( void ));static void yy_push_state YY_PROTO(( int new_state ));static int *yy_start_stack = 0;static int yy_start_stack_depth = 0;static int yy_start_stack_ptr = 0;void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));void yy_load_buffer_state YY_PROTO(( void ));void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));void yyrestart YY_PROTO(( FILE *input_file ));static void yyunput YY_PROTO(( int c, char *buf_ptr ));static int yy_did_buffer_switch_on_eof; * instead of setting up a fresh yyin. A bit of a hack .../* Flag which is used to allow yywrap()'s to do buffer switchesstatic int yy_start = 0; /* start state number */static int yy_init = 1; /* whether we need to initialize */static char *yy_c_buf_p = (char *) 0;/* Points to current character in buffer. */int yyleng;static int yy_n_chars; /* number of characters read into yy_ch_buf */static char yy_hold_char;/* yy_hold_char holds the character lost when yytext is formed. */#define YY_CURRENT_BUFFER yy_current_buffer * "scanner state". * future we want to put the buffer states in a more general/* We provide macros for accessing buffer states in case in thestatic YY_BUFFER_STATE yy_current_buffer = 0;%- Standard (non-C++) definition };#define YY_BUFFER_EOF_PENDING 2 * just pointing yyin at a new input file. * (via yyrestart()), so that the user can continue scanning by * When we actually see the EOF, we change the status to "new" * * possible backing-up. * still have a bunch of tokens to match, though, because of * shouldn't try reading from the input source any more. We might * then we mark the buffer as YY_EOF_PENDING, to indicate that we /* When an EOF's been seen but there's still some text to process#define YY_BUFFER_NORMAL 1#define YY_BUFFER_NEW 0 int yy_buffer_status; int yy_fill_buffer; * end of it. /* Whether to try to fill the input buffer when we reach the int yy_is_interactive; * each newline. * instead of fread(), to make sure we stop fetching input after * if we're using stdio for input, then we want to use getc() /* Whether this is an "interactive" input source; if so, and int yy_n_chars; /* Number of characters read into yy_ch_buf, not including EOB int yy_buf_size; */ * characters. /* Size of input buffer in bytes, not including room for EOB char *yy_buf_pos; /* current position in input buffer */ char *yy_ch_buf; /* input buffer */ istream* yy_input_file; FILE *yy_input_file; {struct yy_buffer_state#define unput(c) yyunput( c, yytext_ptr ) while ( 0 ) } \ YY_DO_BEFORE_ACTION; /* set up yytext again */ \ yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ *yy_cp = yy_hold_char; \ /* Undo effects of setting up yytext. */ \ { \ do \#define yyless(n) \/* Return all but the first 'n' matched characters back to the input stream. */ * done when it reached the ';' after the yyless() call. * "else" because it interpreted the "if" statement as being all * Prior to using the do-while the compiler would get upset at the * do_something_else(); * else * yyless( 5 ); * if ( condition_holds ) * * avoids problems with code like: * int a single C statement (which needs a semi-colon terminator). This/* The funky do-while in the following #define is used to turn the definition#define EOB_ACT_LAST_MATCH 2#define EOB_ACT_END_OF_FILE 1#define EOB_ACT_CONTINUE_SCAN 0 } extern int yywrap YY_PROTO(( void ));extern "C" {extern FILE *yyin, *yyout;extern int yyleng;typedef struct yy_buffer_state *YY_BUFFER_STATE;#define YY_BUF_SIZE 16384/* Size of default input buffer. */#define YY_END_OF_BUFFER_CHAR 0#define YY_NEW_FILE yyrestart( yyin ) * only for backward compatibility with previous versions of flex./* Special action meaning "start processing a new file". Now included#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)/* Action number for EOF rule of a given start state. */#define YY_START ((yy_start - 1) / 2) * to BEGIN to return to the state./* Translate the current start state into a value that can be later handed#define BEGIN yy_start = 1 + 2 * * definition of BEGIN. * but we do it the disgusting crufty way forced on us by the ()-less/* Enter a start condition. This macro really ought to take a parameter,#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) * double cast. * we want to instead treat it as an 8-bit unsigned char, hence the * integer for use as an array index. If the signed char is negative,/* Promotes a possibly negative, possibly signed char to an unsigned#define YY_NULL 0/* Returned upon end-of-file. */#define YY_PROTO(proto) ()#else#define YY_PROTO(proto) proto#ifdef YY_USE_PROTOS#define const#ifndef const#ifndef YY_USE_CONST#ifdef __TURBOC__#endif /* ! __cplusplus */#endif /* __STDC__ */#ifdef __STDC__#else /* ! __cplusplus */#define YY_USE_CONST/* The "const" storage-class-modifier is valid. */#define YY_USE_PROTOS/* Use prototypes in function declarations. */#include class istream;%+#include #ifdef __cplusplus#endif#define __cplusplus#ifndef __cplusplus#ifdef c_plusplus/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */%*#include %-#define FLEX_SCANNER */ * $Header: /home/daffy/u0/vern/flex/flex-2.4.7/RCS/flex.skl,v 1.2 94/08/03 11:13:24 vern Exp $/* Scanner skeleton version:/* A lexical scanner generated by flex */symbol table memory allocation failedUWVS}URWMƋUtSRW计_t;[ujÃu hlUt C -C{U S USU1e[^_]ÐUjehU RjURcP.]ÐUjehUR @]ÐUVSu] URVKt(SRV負_u[uٸe[^]ÐUSE] 1Ҁ8tPAЙ9uЋ]]name defined twiceUS]jeh jU RcPSP$t hm?R]]ÐUjeh UR@ ]ÐU<(<jP$R%$j<R$R%$j<RR%$j<RR%j<RRl%j<RRR%]#define %s %d start condition %s declared twiceUVS]5<VSho袚_< <9<S <jehQjPtShoPh0 <$h0 <$u 4e[^]ÐUjehUR @]ÐUWVSDžuvƍ=)9}VhM QWMIڋ5}9~MtoM9 tuSPSEtPQuV ǃ M9~it_+ЋPSuV, 9}ljuǍMI9~juv)9| MQu VMQ uVM QuVMQhu V QuVfW Qu V QPu9|MQu VMQY V [^_]ÐUWVSlT=ht(=Whphd*  == ߗ@9~Dž1۹9 ==tȋ=ht>~&~CA9 }Sh@P= WW)9=[^_]ÐUS@@jPRj@RRh@S"]]ÐUWVS} ~$=l l+ K9@~> C 9@~|uσ<u}  {=u 9t*t:u9u9tC>؍e[^_]ÐU @P Q3!l=htDt9|td@B9}d]ÐUVS5F5l l9@~l 5454=~-ˉѡl@l54@9~5l55l455le[^]ÐUWVSu UuM}uM]]M9"E8t8u}uG9~u MQ]SWMQk0u~(]8t8u}u M}R)959}7F:tF8u9|؋E)@9@EM9 @~9U]u C}>End Marker*Something Weird* - tok: %d val: %d US=(tlÍCw3(=uh @1ۃ==Ȥt# @Phh `~_Ȥ ^[#/N( <r"$i<Q?H>?B} {p(D" T h `9 `w% `z `9 `wj h `~_  `h `h݂_3h `h!轂_ `9 `wj Q  `h `h$m_=Ȥhh(=ރ[$|                                                                         Qh-=| `Pu Qh1d `9 `w#Ph `5|_  `w Qh7 Qh:h `_Oh?hGh `_& QShRh `_؋]]USu1= t@< uÅtKu]]ÐUS=tЃ;uh"|_]]ÐU=ФuФ]ÐS\$̀}أ[Ð[ÐSV\$̀}أ[Ð[ÐS\$L$ T$̀}أ[Ð[ÐS[\$L$ ̀}أ[Ð[/lib/ld.so: can't load dynamic linker '/lib/ld.so' statically linked 8UWVSl$L\$P=D$D bh~t[|$ ft8t@8u+PSj j*D$Pj hZ񐐐hhT$\RSD$ PPD$\ЋT$,RT$,R &|$+jD$PjM j[^_]8ÃfT$fur|$fD$f%fD$f%?fT$f fD$l$ÐUWVSl$|$19v WUT$RЃ C9w[^_]Ðlibc.so.4DLL Jump 4.5pl26static const int %s[%d] = { 0, static const short int %s[%d] = { 0, static const long int %s[%d] = { 0, static const yy_state_type %s[%d] = { 0, static const YY_CHAR %s[%d] = { 0, @(#) Copyright (c) 1990 The Regents of the University of California. All rights reserved. 2.4.7_k_^^m^_U^k^^_]k]]]f]#]\\\\D\\[_[[k[d[)kk$[ZZWkZkk[dZJZkZkkYkYYgY5YkXXWkXkYX*XWWtW=WVkVVV]V0VV)kkUU]Uk6UkTkTTjk[jqThLTj)kk[ TSSOS)kk SRWkRRsRYRGR RQkQkfQXQWkkBQ3Qh&QjjjhPPsPWkjjkAP(P PjkOkO[rOZOWk#OON)kjkNzNWkiNANMOMM)kjk9MLLWkL{Ljk=L!LLjkKK?kKjoK)kjk(KKWkJ[JOJ)kjk`JKJWk4JJjkIIIjkI`IvI`IkAIk1I-II IjkHHkH?kHjH)kkH?kwHjeH)kkJHHHGGkGkGGkoG-ILG6GkGGkFFFFkfFkVF*FkFkEkEkEksEOE>>Bk^>k9>k!>>>====k=>X=?==Ak=;D<><k<<<e<C<<;;;t;k;?;k;;:k:<::::=k:|:O:k:k:9=k9|:9k:k:9?=A9Gk9q969988kj88hT8j`08$8k88k7$8k77k7kh7k7777jdkO7`,7d)kk6c66s6N6Wkk?k.6j6)k`55n5`5k5q94k4t4@4;D 43B3AkH;D33Bj3AGkL3k32k22kh2*22F2k7-I11k1d1N1;10hk00kZ0kB0'0//k///kN/k//jAk..k._.A.Gk).-I-;D--AkH;D-|-a-AGk7>-k-,,kS, ,++_k\+kK+dkk*k?k*j*)k`I*kD*k)-I)Gk)dkkv)cj)7)Wkk?ki(h((jjG()k`.('k'dkk?ki'hl'e'O'jj')k`&k&&k&Q&7&&%%%Y%k'%%k$$$kz$B$Gk$$k#k#k#f#_6#dkk?kj!#h#jj")k`"k"k"-Ib"%"!F!!p!kHU!9!(!k!> <     } kk jT h? j:k ?; kjhj=AGkIkdkk?kihjjo)k`Skdkk?kihmQjj )k`k-IuGGkkE"_dkk?kihjj)k`l2dkk?kihwmjj$)k`kkwk_k_kwktkidkk?ki>h#jj)k`kfIdkk?kihwjj)k`kY._kk~e_;kk?kj)kkkZdkk?ki/hjj)k`-IkV#k kH{k ;1EGkkdkk?kj)k`lk@dkk?k&j)k`dkk?kihyj`QEdkjk`Ed)kkkkaaa[akK3#``kkkTi h   y j`h M < djkki h  j` dkix hN C  j` dki h C j` dԤ`j``?`4