./ 755 0 0 0 7442456516 4072 ./bin/ 755 0 0 0 7442456603 4637 ./bin/bison 755 0 0 340000 7442456576 6032 l8__PAGEZERO X__TEXT __text__TEXT<F__fvmlib_init0__TEXTPc__fvmlib_init1__TEXTd__cstring__TEXT0d__constructor__TEXT__const__TEXT *__destructor__TEXT__eh_frame__TEXT__DATA  __data__DATA__bss__DATA__common__DATA8__LINKEDIT07/usr/shlib/libsys_s.B.shlibX< O .#/H#R/H#aZJg yNJg yNJ8gaBJCgataa.aLPNV-|Nq d n"h n"P`N^NuHV,OHyHyHy aF @Hy/( aBN^NuHV,OH 0B 9й /Hxa!$@BP yJPg$ yJpo R0pRrR yJpf/9HxG_N#4PJg/HxN#C&<$ P&y0l l f C3 R B3 (TRR0mnְf A1 $# f# Jg / a8Xa`(Hxa*@;y*#aXHxHxG_N(@E9R y #Hxa*@;RR;R y # #HxHxN(@9RR y #L< N^NuHV,O/ /BBl0 y2p y00Hl y,D@1*RRmJgZHx Ѐ @Hha$@ y5h5B Ѐ/Hj/9,azJ$g y$ `##$$.$nN^NuHV,O/ a(/9ataXJg~Jg0$y2j y/04j/ HyHy(aZ y0h /pй/aZaa\alaV y#PJfaaa$nN^NuHV,OH00&n &./.HyHy(aB ct0s*/Hy Hy(aܮ03*HЀ$@`2Z y/0HyHy(a~ JRn0HD/HyHy(a\ RbHy(Hy#aLL N^NuHV,OH8Hy&Hy(a(9Pl y/0LHy.Hy(aB l "L9B lpЂ&  @: lpЂr"p8g2 й y/0 й/Hy:Hy(ajRm~RmFHy#Hy(a lpЂ&  @6 lpЂr"p8gh/Hy\Hy(aڀ y 00HЀ$@`2Z y/0HyHy(aF JRnHy(Hx a4PRoHRmHy#Hy(aLN^NuHV,OH>0pйjrЁ#B&9L8/Hxa#:$9PlB yT"H p,JPmz q,00JH y2p y2pml "L9B j|І y:&G L9B$CA "  lpЁ| " '8R"yT q,JpJlZRm8/9/9:aPJgaL |N^NuHV,OH>0 9L9>/HxaR#6a*9Pl$9l "L9B jvЃ&  @:" lpЁxp8gB yT"H p,JPo| "L9> q,00Jl@@H y6&G L9>$CC yT p,20J0l@@@0H" '8R"yT q,JpJnxRmRmJgaJ:g /9:aPL |N^NuHV,O/.Hxa#p йjrЁ#>/Hxa#2a6N^NuHV,OH>0&n(. Jg// Hyba JfDB>l y2 9L9>"@6!R>m`B>l y2BR>mBof0s*"y0qmJB>l@$y22s* y0p L9> @6 0R>mRnBBB 9>눰oz lpЁ& y2 lpЁ|"A , <gL y 2p` 9 y1* RRo0s*n 9 y1 RR 9>눰nv` 9 y1* RRnJg/9/9HyhaL |N^NuHV,OJg/9aXJ2g/92aXJ6g /96aN^NuHV,OJ$gH 9J(f& 9tFg//9FaPPJg#tF#(JHyaXJtg$/9(/9tHyoHy(a&`/9,HywHy(a Hy(Hy{aHn /.Hy(a@R0C(Sk i R`>C(J)l D l i / iB/` Hy(Hx aPHy(aC(J)l D l i / iB/` Hy(Hx aPHy(aN^NuHV,OHyaXJtg$/9(/9tHyoHy(a`/9,HywHy(a Hy(HyaHn /.Hy(a"C(Sk i R`>C(J)l D l i / iB/` Hy(Hx aPHy(a$HxaNqHV,OH08 n&. "yE 刐$q BJjo8C&y"ҁJqg0qI 刐0s fBqR0jnL N^NuNVH><&n(. y800JH y<0HHx 9Ѐ @Hha ^(@KBPlz"L9l lpЃ$  @4 lpЃr"C " (gV lpЃ" yP lpЃt"C $ g$ y Jp:g0p:oHy y/0< y80pJ// HyHnalE@HnaX$йLPc // a P//* Hna& ժ lpЃ" yP"H lpЃt$ $ F!// aP`N y 0p:lHy y/0< y80pJ// HyHnaٞE@HnaX$йLPc // a P//* HnaX ժ "L9l lpЃ y4$E L9l"BA lpЃr" " F%(`n y00: @gnJ@g` @g`Hy`Hy`Hy y/0< y80pJ// HyHnaؚE@HnaX$йLPc // a P//* HnaT ժ yJp:gB lpЃ" yP"H lpЃt$ $ F!// aP y p:gT"L9l lpЃ y4$E L9l"BA lpЃr" " F%( y p:f:Rm^ U8& Hx Ѐ @Hha yC" 剒!/// a>PO.a̲L<|N^NuHV,OH<<(. y"DCJ 刐J0 f\Bll yPB,Rlm$y&J*DKJ 刐(r BJloA"H0PK 刐0r l Ѐ IJpg`0pC 刐03 l@@6@$yP& * A0p*"yK 刐21 0l@@@Hp E<%R0lo&C0q*&yE 刐0s mf y*DKJ 刐Ѐ40H0p*oz DAJ 刐&փ y800*H yJpg>B`Rll0 L9l"@4 yP 1g//aPR C0h*n y"DCJ 刐Ѐ40H0p*o$DEJ 刐&փBll: L9l"@4 yP 1g yHHRlmBll, yP L9l"@4 1RlmR C0h*ntL<0*H rfJf y880HBll8$yP .L9l"@4 yL,1̰%RlmBlh lpЃ$ yP lpЃr"p,g2 y 0p"y/1//1<Hy/.a4Rm y 2p y/0/Hy$/.a` JoI0|-HBJf&.oGBll8$yP L9l"@4 yL 0F%RlmBlD4|*9P(9 lpЁ$ E lpЁ|"A , ,gRRn̹l(K-C y80p:-HBll yL"yP 1RlmRn&Bll yLB<RlmBJmoA&H0P"y$II 刐0q l Ѐ KJpg`0pC 刐02 l@@6@$yL$ ( A0p:"yI 刐21 0l@@@Hp D,%R0mo&G0s:$yC 刐0r mfBltB lpЃ$ yL lpЃr"p*ʰ,VID$.o("L9l lpЃ(  @4 lpЃr"pHgJfPgB$y802*H y2p y/04r*/ /0<HyM/.a2`|R`JgD$y8,.02jH y2p y/04rj/ /0<HyM/.aB$y802*H y2p y/04r*/ /0<Hy/.aRnRmJm. y .2p y/0/.Hyq/.aRL L9l"y E yb p<00*HL9lA 0RbR"yb q<Jp*lj"yf0q:f 9n yj40 HSn3t*g`EtBc. L9l y C L9lA #Rb 9n yj40 HSn yf1*fLA0p"yG 刐2q  yìJ1g/ /a4 G1jRPR0mnJg8"FHiHxaܴ&D'<"ҁ///az s<1jBPRVm/aBXVl DJ<g /0<aXRVmJg /aXJg/aLs g06h-KG yRl2sI 刐>p f C1*RTJRn yG 刐J0 f/8U/ / a SpUe80Rm.S/ C0p*/aN"F3JR2R yìPJ1WIDJgTJUnJgJ$DHjHxa׺ yZ!\BPo yZ p\&F1 Rn yZ p\1JRVmVJg /aXJg /aX/9V/9ZaL#ZL$@XpЊr e A($`pЊre A($`pЊre A($`/9X/ aP`,y\0 @Hna/Hy]at? AIfJf@r\f \\`p'f \'`r"f \"`pЂr^e`p f \t`r f \n`xp f \r`hr f \v`Xpf \b`Hr f \f`8\ "HRlp?Ђ0 "HRl^00BJg:$EHnaX&Ъ c // aюP//* Hnaת n SDLg6pfHyajXp fHya(/ Hx a Eڀ * Rc Hx/ aЊ j BR Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$L N^NuNV/ /B$J,g$ 9,#0(#4$B,`a$Rr}e |P p N#$p`Eڀ * RcHx/ aϤP j R "yXSk iBR`/9XaX$AbC(fp_gr.gEڀ * RcHx/ a8P j BR Aڀ"h f(@("( Ҩ (F€!A  (l!h !h #$/9X/a/9$av#(p`BtAb0(gvEڀ * RcHx/ aΈP j R ytA"BC#t"yXSk iBR`/9XaxX$Ab0(fEڀ * RcHx/ aP j BR Aڀ"h f(@("( Ҩ (F€!A  (l!h !h #$/9X/ap`xEڀ * RcHx/ a͈P j 'R Hx'HnHyڀa "yXSk iBR`/9XatX$p'g&HyaXHx'HnBar JfEڀ * RcHx/ aP j 'R Eڀ * RcHx/ aP j BR Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$/a @#(r!A hf1n`Eڀ * RcHx/ a$P j "R Hx"HnHyڀa^ JfEڀ * RcHx/ aP j BR Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$/a, @#(p!@`#$p`,#$p`#$p` #$p`#$p`Eڀ * RcHx/ aP j R "yXSk iBR`/9XaX$Eڀ * RcHx/ aʪP j R r fR(p gr gp gEڀ * RcHx/ abP j BR Aڀ"h f(@("( Ҩ (F€!A  (l!h !h #$r{fp`/9X/a`/9Xap`a`Eڀ * RcHx/ aɲP j R Eڀ * Rc Hx/ aɈ j BR Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$p$.$nN^NuNVH80BB"yXSk iBR`/9Xa*X$Eڀ * RcHx/ aP j %R Eڀ * RcHx/ aȦP j R p2gmr%g4p0g`hr=gm pgp{gV`@Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$p`Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$p `Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$p`rAڀ$( f(@("( Ҩ (F€!A  (l!h !h #$p` Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$p`Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$p `|Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$p`*Ab(fAڀ$( f(@("( Ҩ (F€!A  (l!h !h #$p`r_ft-Eڀ * RcHx/ aŐP j R "yXSk iBR`/9XaX$Ab(fp_gr-gp=fEڀ * RcHx/ aP j BR "yXSk iBR`/9Xa"X$r"fh(9ڌڈG`,Eڀ * RcHx/ aIJP j R Hx"HnBa Jf`/9X/ajPEڀ * RcHx/ a\P j BR Aڀ$( f(@("( Ҩ (F€!A  (l!h !h #$Jg&ւE8` Jg/ 9$R/aPJfJg(rg /a //9$HyraJ *rge rg``rg`JfHyHxHyHyOaFJg jJfL/aZ j` ժ Jdg/9dHy$/a E0/anX$Ъ c // arP//* Hna} ժ /9dHy.$/a E0/aX$Ъ c // aP//* Hna}t ժ /9dHyC$/aT E0/aX$Ъ c // aP//* Hna} ժ /9dHy\$/a E0/aNX$Ъ c // aRP//* Hna| ժ /9dHys$/a E0/aX$Ъ c // aP//* Hna|T ժ /9dHy$/a4 E0/aX$Ъ c // aP//* Hna{ ժ /9dHy$/a E0/a.X$Ъ c // a2P//* Hna{ժ "|L N^NuHV,O/ /J,gP k ,R p lDE0t 98E0t p Ъ cHx / a.P//* Hyap ժ 9R/Hxa(@BP` y 9 :R 9Rn < *9RJg\/Hy#Hna~, E0Hna~X$й<@c // aP//* Hnao ժ BHyGHyZHy.Hna}E0Hna~X$й<@c // aP//* Hnao~ ժ xvoG0 91*H&SnvBldz$L9(l lpЁ(  @4 lpЁt"A $ Hg"y y800:D@3RmSl yC 刐&p BJkoV4kJg`6 y1E0HnaiX$й<@c // aP//* HnaZ ժ xvoG0 94 u f"r r<>0 q gBRJg nJf^SjpL yðJ,gg /0,aTX yôJ,gg /0,aTXRvmJðg/9ðaTXJôg/9ôaTXJg /9aT$.$nN^NuNVH<8(y*90T/HypHyZHy.Hna^E0Hna_(X$й<@c // a(P//* HnaP ժ xvoG0 9X JJfJ4g/94aL"XJ8g/98aL Xa~ 9Ѐйlg /aKXJhg/9haKXJpg/9paKXaxaE0 * RcHx/ aP j  R aaE0 * RcHx/ ajP j  R a$nN^NuNVH>0BJdgR ժ Hy0aE^.Hy$/aL& E0/aLX$Ъ c // a}P//* Hna= ժ J,gl/9xHxa&/Hy$/aKE0/aL X$Ъ c // a}P//* Hna=r ժ y Jg$Jg /a@X BJfaܲaaŪJg/9a@XJ,gaaHaJg/9a@rXJfa&aL N^NuHV,O/$.Hx Ѐ @Hhaz @1B$.N^NuHV,OH>8(. n "yE 刐Ѐ qI6h Jg/ / ah(y&yPJgBo04jHЀ$@& JRoTJRn0H*D y$2p( y/0Hy/a?h y00(HЀ$@`2Z y/0Hy/a?6 b/Hx.a?(PJRo"2Z y/0Hy/a? JRn/Hy/a>/Hx a>Rn"/Hx a>L|N^NuHV,OH<<&.(. y"DCJ 刐Ѐ"@(p*0 *pJlf&Jf"fHy`Hy/a>b`BJlopG ЀJsgX4s yC 刐2p lBJf/ Hy/a> `/ y/0Hy/a=R0lnJo/Hx a=PJgFEJUo,2uJg y/0Hy9/a= R0UnJo/Hx a=P y&DGJ 刐J0 g:JgF E2(H y 2p y/0/Hy$/a=>`Jg //ayrP0loZE ЀJrg60r"yG 刐2q / y/0HyZ/a<R0ln/Hx a<(.Hy|Hy/E%.NHyHy/Nvn$y &@J g2r y/04r / /Hy/a; y00HЀ$@JRo&o<2Z y/0Hy/a; JRn`HyHy/a; /Hx a;PRoT/Hy#a;nHyHy/E%.N y/Hy/NB `nVK08 y p:g4B.2p: y/0N&@/ y2p: y/0a: E/ NЋXr2d/ Hy/a:6|B. /HyHnaEHyFHyca^ PE٠ * RcHx/ alNP j R "yXSk iBR`/9Xa+TX&Jg2p}g2E٠ * RcHx/ akP j %R B`L E٠/a5X$Ъ c // afP//* Hna& ժ `,E٠ * RcHx/ afbP j  R E٠/a5*X$Ъ c // af.P//* /a& ժ Jg>E/a4X$Ъ c // aeP//* /a&L ժ "yXSj`p/g\E٠ * RcHx/ aeP j R Jg*E * RcHx/ aejP j R p{gtmp gp/g`*p}g``R(`&yX&<٠E 9RcHx/ aeP j /R Jg0E٠ 9٬RٰcHx/ adP j /R Sk kBR` / a#X$p*g p/fx`B`/ /a5pP`bE 9RcHx/ adZP j R Jg.E٠ 9٬RٰcHx/ ad(P j R Sk kBR` / a#8X$BJfp*fI 9RcHx/ acP l R Jg.E٠ 9٬RٰcHx/ acP j R Sk kBR` / a"X$p*gp/fvE 9RcHx/ ac@P j R JgE٠ 9٬RٰcHx/ ac P j R `p ftR(E 9RcHx/ abP j R Jg.E٠ 9٬RٰcHx/ abP j R JfpSj~`pfHyaTX`~E 9RcHx/ abJP j R Jg.E٠ 9٬RٰcHx/ abP j R Sk kBR` / a!(X$Jg`R`JfHy|HyaR8PSJnE٠/a0X$Ъ c // aaP//* /a! ժ Jg>E/a0NX$Ъ c // aaRP//* /a! ժ a$p;g@/9X/a2 `0"yXSk iBR`/9Xa .X$pf.LN^NuHV,OH 8aj$/9X/a1AbP0(fHyaQ`$yXSk jBR` / aXtGr-fSk jBR` / aXtAb0g0(HA"@GSk jBR` / aZX4f/ /a0 L#DLN^NuHV,OH00BvE.Nrf/9$ad$p#ՒNXrg/9$Hy`P y(p!@!B 1|&HE.Nrf&9tNrf y( h "g/9$HyaOHx%a`" y(p!@!B 1C!K'HSL N^NuNVar%faQrex |\ p Na`HxHx`HxHxaP`a$`a`a`a`a`Hx`B`HxaX`ta^/9$HyaNHx%a `JrfHyaOX`2y\@Hnan/Hy*aNHx%a`N^NuNVH><*n,. J,gB/9Hy@$/a,X Ep/a,X$Ъ c // a]P&//* /a ժ Jfj/9tHxatR//9(Hy^/a+Ep/a,:X$Ъ c // a]>P//* Hna ժ Ep * RcHx/ a]P j {R z"yXSj ` p}g r'gm(p"gmrgp g0` r$g`p@gm r/g`p{g8`Ep * RcHx/ a\nP j R R(`Ep * RcHx/ a\:P j R R`$yXGp 9|RـcHx/ a\P k R Sj`rfHyaMvXp f"HyaL4/ Hx a,$ `Gp 9|RـcHx/ a[P k R r\flSk jBR` / aX$pfHyaLXGp 9|RـcHx/ a[&P k R r fR(Sk jBR` / a*X$fEp 9|RـcHx/ aZP j `2$yXGp 9|RـcHx/ aZP k /R Sk jBR` / aX$p*g r/fv`B`/ /a+8P`Gp 9|RـcHx/ aZ"P k R Sk jBR` / a2X$BJfp*fGp 9|RـcHx/ aYP k R Sk jBR` / aX$r*gp/fEp 9|RـcHx/ aYlP j `r f@R(Gp 9|RـcHx/ aY2P k R JfSjJ`VpfHyaJX`LGp 9|RـcHx/ aXP k R Sk jBR` / aX$Jg`($yXSk jBR` / aXBrHyKHyaERPEp * RcHx/ aSP j R "yXSk iBR`/9XaX&r}f|SgXEp * RcHx/ aS6P j R "yXSk iBR`/9XaX`LG 9 RcHx/ aLP k R Sk jBR` / a X$Jg`($yXSk jBR` / a XBrHyjHyca9:PE * RcHx/ aG|P j R r}fJg("yXSk iBR`/9XaxX&JgJn`p;fap&Et p Ъ cHx / aGP//* Hy\a` ժ r{g4p=f:"yXSk iBR`/9XaX&r{f// a`/9X/a~L0j"y qg(//*0j2q y/0HyYa.2j y1$jJfv$nN^NuHV,OH0 t 9R/HxE_N# 9R/HxN#ڬ/9HxN# /9HxN# y  yڬBP#`&<$yڰ Jg^pf09j`JgJjf j1B5BR j0(jgFJjg6J@g jf/(/*Hya-v Jjg j1j` j5h j *gFJg8Jg jf/(/*Hya-" Jg j!j` j%h jgp`5BRpf jfR5C0j`o#`2j y!2j yڬ12j y 12j y1$jJfa, y՞0h#X yՎJf/(Hya-f` yՎpf/(Hya-F yՎ0h#L N^NuHV,OH 8 9R/HxE_N#/9HxNrҀ#Br&yՆJg(k $y$"B k555 t% &SJgPJgJ$$B"y k3 R ktf"y3 k3Jg &SJgJfJg"y$ B333 y4DB1 RRJg&SJfB yBp Jg Hy(aQLN^NuNV/ /BՊBՎp#BBBBՖB՚B,BdBՆacXp#(aHyE;N @#՞p!@1|HyN @#բp!@1|XO./9t <>Jg <!/HyM$/aE0/aRX$Ъ c // a9VP//* Hna ժ E0t2p2Ъ cHx2/ a9P//* Hy{a| ժ aazaJgHyanXa}Jg jrЁ("yզ0B" lpЁ~ " Lg.0l@@0@"0l@@@0H$ 'TJRl lpЃ" lpЃ~ C $ RopйjvЃ// /9ծa Jf &yծ#ծ`Jծg/9ծaX#ծ| yծ~ yծpJժg/9ժaX#ժp йjrЁ//9ժa#ն$9#պBվ&9lFz(9ծ$9 lpЃ" D lpЃ|. , gRվRn.9վ# vlbx y JpgF00l@@4@"yղ$ &I y 200l@@@0H" ,#RmLN^NuHV,OH> Jպo\rnR$yz(9ժ"y& lpЁ$ D lpЁ|, , ,VID%8 RlL|N^NuHV,OH8/Hy(E%.N J oJպoFHymHy(NPJպo./9պ <rպf <s/Hy(a HyHy(aHy(a$nN^NuHV,O//pйjrЁ/Hxa'z#զp йjvЃ/Hxa'X#ժpйjrЁ/Hxa'6#ծpйjvЃ/Hxa'#ղ aRa 9 йպJoa8 9jrЁ$ yզ"9 lpЁvp,f 9 y/0 HyaPapJ oaJg6Hy(aF/9/9/9/9tHyHy(ax$.&.N^NuHV,OJզg/9զalXJծg/9ծaVXJղg/9ղa@XJժg /9ժa*N^NuHV,O/ nBJg ЀI$?Jf L< "҂p Ѐ 툐Ё $N^NuHV,OH0 &.$. Hx"a% $@ y$,B/a+%@B BjBjB5|BBR L N^NuHV,OHxHxa%#BڰBN^NuHV,OH8 (./a& y$p<BXJg /*/aPJft`$RJgJgJf6//a $@Jڰf#ڰ` y!J# y!< LN^NuHV,OH0 B y$p<Jg($Jg /*aXJg / aX$BJfR oJg /9aZL N^NuHV,OH?0&n.. *.|܅ ,/ Hy Hy(aHy(HyaBcE(Sk( jR"L<g 0` `A(J(lH D l> h"L<g0`  gR`C(J)l D l i / iB/` Hy(Hx aLPHy(HyaBPc8"L< @A Ѐ"/HyHy(a RbC(Sk i R`>C(J)l D l i / iB/` Hy(Hx aPHy(Hya(BPcTE(Sk j-R`6C(J)l D l i-R`Hy(Hx-aЇ*Jg// Hy>a" BoBo"L lpЄ$A lpЄr"p(gBo$L(-B6|&L8*C lpЁ$ n lpЁv"A & (g>$L( lpЁ&E("CA lpЁt$ $ %8RnRn2Rn"Jg// HyHaLЅ(//aBoL~$L( lpЁ&$F L"C F lpЁt$ $ %8RnLN^NuHV,O/.HxBa6bN^NuHV,O/ $nBBBB BBp%@%@pd%@ %@$p%@(B,B0B4p%@8%@$N^NuHV,O .rgbrg` <y`, <`$ <`HyHxHysHyOa=N^NuHV,O .rgbrgrg` <`4 <`, <`$ <`HyHxHysHyOa=vN^NuHV,O .r e~ |0 p N <` <`| <`t <`l <`d < `\ <`T <`L <)`D <5`< <B`4 <O`, <[`$ <_`HydHx/HysHyOa/Hya`./Hya`/Hya`/Hya$.N^NuHV,O/.HyaڪN^NuHV,O/.HyaڒN^NuHV,O/.HyazN^NuHV,O/.Hy#abN^NuHV,OH 0&n$. /Hx a<$kPJg&/a// an/a$jPJf/Hx a$kPJg(// a// a/a&$jHJf/HyaL N^NuHV,OH0 $n&. Jg/a/Hy-/aلJg/*a/Hy:/a`pg g/* /*HyG/a8pg/*Hy`/a pg/*Hyv/a pg/*Hy/a pg/*Hy/a p g/* Hy/aآ p$g/*$Hy/a؄ p(g/*(Hy/af J0g/*0a>/Hy/aBJ,g/*,aj/Hy/ap4g/*4Hy/a J8g/*8av/Hy/ap< n(n "yE 刐*q Jm gHBJm o>,A00JHЀ&@* JSoTJSn0H&DJg($L , RcHx/ apP j  R /Hy/a $L/a(X$Ь c // a,P//* Hnaǎ ժ y 2p y/0Hy$/a\ $L/aպX$Ь c // aP//* Hna ժ y 00HЀ&@cf&$L0S"y/1Hy/aPO.a/9Hna/9a:Hy/a\rҎB//avL tN^NuHV,O/JgHy/9la @#HyaB~Bfp#֪BֆB֎B֒B#ֺ/9a/9HyaBl/aJXRm/9Hya/9a $.N^NuHV,OJg yNHy|HycB/9aHxa NqHV,O/.aDXJfaN^NuHV,O/. /.a͢PJfaN^NuHV,O/. /.aPJfalN^NuHV,O/ / &n". . nfpJf"<'H'n &S'@+(J+(l //+$NP` / kNX'@$@Jf yN P'@'@ Г$'@B+(+(p$n&nN^NuHV,O/ / &n". ."n nfpJf"<'I'n &S'@'H$+(J+(l //NP` / kNX'@$@Jf yN P'@'@ Г$'@B+(+(p$n&nN^NuHV,OH0<$n*j&* $Ԯ ԀԪpdԀl$J*(l//*$ jNP` / jNX&@Jf yN%K'M Ђ%@& *PI *F" €(A *Rrl, "@` j)SJlp`/ /*$ j N`>B"@o jRn Pf*(f'mJ*(m/ j N%L֪%C *(L< N^NuHV,O n . hJgcbJVIDN^NuHV,OH0 $n&. j`,$(J*(l//*$ j NP` / j NX B*@(Jgc̶bJg%C %C%P%H` Jga&L N^NuHV,OH0 $n&. j`,$(J*(l//*$ j NP` / j NX B*@(Jgc̶bJg%C %C%P%H` JgaL N^NuHV,O nB` Ҁ hJf N^NuHV,OHyHyHy(ap/9aNqHV,O/ $n"Jp IJg /fC`BRJfJf /fJgSJf$ (/fHyHxDHyHyOa $nN^NuHV,O/.aXJf </HyHy(aN^NuHV,O//&.$. /./.Hy(aRڸ Jg /aXC(Sk i R`>C(J)l D l i / iB/` Hy(Hx aPHy(aXJg/a$.&.N^NuHV,OHyaXJڼg yڼN`/9,HyHy(a Hn/./. /.aN^NuHV,O//$.&.J$g2עfמg//9מaVPJg|#מ#עHya(XJڼg yڼN`/9,HywHy(a2 Jg//HyoHy(aHn/./. /.a8$.&.N^NuHV,O"n n Jf SN^NuHV,O .//aXR/a4.aɚN^NuHV,OH 0$./. /a>&@Hka$@ JgB3/ / /a `BL N^NuHV,OB/./././. /.aN^NuHV,OHx/./././. /.a\N^NuHV,O n". JgIf `RJfBN^NuHV,OH> $n(9ײ&9׶,9`h "l2$Co$ *"҉ r Љ% % Rn䜂`*$Co"҉ r Љ% % Rn؂lm 9׶ѹײ#׶L|N^NuHV,O/ $n 9#׶#ײBצHya#׮ -f p#תR`( +f BתR`J׮gBת`p#ת $nN^NuNVH?<*n ,.(9 F :fBJoB\JgJf,Jfp#// /.a0,p# Jצg yצJf y׶o #׶"yײo #ײpתf yײ׶g"y׶g$/ aX` 9׶g #ײ no*`R"no 9 u -fJ(g#׶ .g~Hy 9/5 aJ׮gI//HyHy(a`I//HyHy(aI#p?` Wfb );fXBBBB yצJg#\`R nf8JgI//HyHy(anI#t? F :ft:` 9# \R&y\#צ`RJg =f$nI`Jf& * `~RJg@"Kצ/ /9צ/a Jf$ צ/aXf& * p-@JgJJfDJg" 9/5 /Hy?Hy(a/9צaѹצRp?`Jg (EJgL CJg R#\`Jg"C//Hy`Hy(a</9צa6ѹצp?``p Cfl"no 9# \R`JJg" 9/5 /Hy~Hy(a/9צaѹצp? F :fp:`/9צaѹצJg"n" CJg h"C B` C ( `BצpW` ):f ):f yצJg#\`hB\`f yצJg#\`N"nf4JgI//HyHy(aI#t? F :ft:` 9# \RBצILc8RR n2`Jg" nXr„ 0 g c\8Rc8RRpf".J2fF`f>JgJgc8RRJfcB38 `8|`XL (.,. *. la~e$R& 戰ga f&Hxa @# 9"9 !AX//9a# /B 9й/a"# y&0N$0N/Hx///Ev^Ne> y&R!N/ ׺VI/a@ y$!N/Hx///N L|N^NuHV,OHyغ/. /.aN^NuHV,O/.BaN^NuNV". .-n BBBBBBBBHn//anN^NuHV,O/. /.BaN^NuNV//&..-yغ-yؾ-y-y-y-y-y-y-yHxI/tԎ/a//Ba$.&.N^NuHV,OHx:/.anN^NuHV,O//&.$. /B/aJJg$ $.&.N^NuHV,O//"nBBBp娆Jl^` n $&N^NuHV,O//"nBBBp娆^Jmpe gp娆 n $&N^NuHV,OH 8&n(n $,gD"+S T$p,Jg"S q (Jo Ђ# Sf Ђ S! Jf ,ѫLN^NuHV,OH80&n$. ga(Hk/ a +Ы PgaA"P&((g"S( Ѐ$`h Tc6$q q *Jo" q *Jo## Ѐ"T`$ q$q (Jo## Ѐ"R$Ԃ RbJfpdtS "<#<Bcn ЀTc6$q q *Jo" q *Jo## Ѐ"T`$ q$q (Jo## Ѐ"R ЀRbpezE/ / a6/a L N^NuHV,O nBJgJgJgR А @XJf N^NuHV,OH 8"n$n &n(n"$Jg>Jg,Jg& * R! Rc") )Щ d$ Б"@XJf&(LN^NuNVH00&nJ g$k BJg /aHրXJf`/+a4&X'C$/a-@/a-@BBPp-@BJ g&$k Jg8HnHnHn/aJf`HnHnHn/+a/Hna*'@ &'nL N^NuHV,OH0 &.$y`$jJgZJf / aXe涪dJf`< `:B"jc.$j Љ" rd"A` (Ш b$RbBL N^NuNVH8 n&n  &Hy/E0NPJgHy/NPJg S zgB`n/a$@RHy/aJ Jf'Z`BHk/ Iy NHk /aV$@B'@ S zfHn/ N$@ LN^NuNVH 8$n&n (n"nBgp?L,ё`@Jl&p?-@Hn/ a$@".L, -A`tgp?-@B3x`p/e |6 pN"`Bё`B0ё`"ӑ`Hn/ Ey NHn/N$@ .L, -@ .x .A! `Hn/ a$@ .B3x`lHn/ Ey NHn/N$@ .x .A! `8Hn/ Ey NHn/N$@7nt'n`Hn/ a$@7nt`Hn/ al$@'n`HxaD$Hx// a'B`$+Hx/ /aPO.a\`r-ApeCxA .".pЁ!Rrd``Hn/ a$@'n `JHn/ Ey NHn/N$@ .L, -@ .x .A".D! `a LN^NuHV,O n !nBBB B!y#N^NuHV,O/$.Hxa"//a$.N^NuHV,O . n !@!@ BBB!y#N^NuHV,O/$.Hxa//a$.N^NuHV,O/ .CJg* Qf$H"Jg /* a ` QCJfa$nN^NuHV,O/.a/aN^NuNVLH< (.*. /a$@XJgHn/ a$PfB`HxHnVaP=n-nZ *Y J&XcBHnHnV/a$btԊ n zfHnR/a$ԮRP В&X-jN`HnNHnHnV/a$cNdHx/HnVa8 L<8N^NuHV,OH0<*n&n &-r 刟(OBc@`, U"p,$p )j + S! R UB"4pf),"RbBBc UJ,g!,RRb+AL< N^NuHV,O/././. /.Hy(aHy(aaNqHV,OHyHyHy az @/( aN^Nu =hd=jT=dP=^D=X@=R<$P8$J420$V,$D$,$&$ $>($\H$ $2$$$$8 (d.L) )))%F)2-z" ($    __eh_frame__TEXTEntering new_itemsets, state = %d Entering new_state, state = %d, symbol = %d (%s) too many states (max %d)Entering get_state, state = %d, symbol = %d (%s) Exiting get_state => %d Entering append_states, state = %d Processing state %d (reached by %s) Closure: %s %2d: . %s (rule %d) FIRSTS %s firsts %d (%s) FDERIVES %s derives %d:inputoutput%s:%d: %s:warning: fatal error: Conflict in state %d between rule %d and token %s resolved as %s. reduceshiftan error%d shift/reduce conflict%d shift/reduce conflictsand %s %d reduce/reduce conflict%d reduce/reduce conflictsState %d contains conflicts: %d shift/reduce, %d reduce/reduce%s contains plural.yexpected %d shift/reduce conflict expected %d shift/reduce conflicts %-4s [reduce using rule %d (%s)] $default reduce using rule %d (%s) %-4s reduce using rule %d (%s) $default reduce using rule %d (%s) DERIVES (rule %d) BISON_cannot open file `%s'cannot close filew#ifndef %s # define %s #endif /* not %s */ .tab_taby.c.h.vcg.output.styper.act.guardyvgdhrltknVo:b:p:S:tracegraphoutput-filefile-prefixverbosedefinestoken-tablerawno-parserno-linesname-prefixlocationsdebugskeletonfixed-output-filesyaccversionhelpGNU bison generates parsers for LALR(1) grammars. Usage: %s [OPTION]... FILE If a long option shows an argument as mandatory, then it is mandatory for the equivalent short option also. Similarly for optional arguments. Operation modes: -h, --help display this help and exit -V, --version output version information and exit -y, --yacc emulate POSIX yacc Parser: -S, --skeleton=FILE specify the skeleton to use -t, --debug instrument the parser for debugging --locations enable locations computation -p, --name-prefix=PREFIX prepend PREFIX to the external symbols -l, --no-lines don't generate `#line' directives -n, --no-parser generate the tables only -k, --token-table include a table of token names Output: -d, --defines also produce a header file -v, --verbose also produce an explanation of the automaton -b, --file-prefix=PREFIX specify a PREFIX for output files -o, --output=FILE leave output to FILE -g, --graph also produce a VCG description of the automaton Report bugs to . 1.33bison (GNU Bison) %sCopyright 1984, 1986, 1989, 1992, 2000, 2001, 2002 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. --raw`%s' is no longer supportedTry `%s --help' for more information. %s: no grammar file given %s: extra arguments ignored after `%s' RITEM %stoo many gotos (max %d)0lalr.c%s:%u: failed assertion `%s' found%3d: %3d transpose: input transpose: output unexpected `/' found and ignoredunterminated commentunexpected end of fileunescaped newline in constantoctal value outside range 0...255: `\%o'hexadecimal value above 255: `\x%x'cunknown escape sequence: `\' followed by `%s'unterminated type name at end of fileunterminated type nameEOFuse "..." for multi-character literal tokens:;|{pure-parsersemantic-parserprecbinarynonassocrightleftstartthongexpectunionguardtypentermtermtoken`%s' supports no argument: %stx->set_flaglex.c`%s' requires an argumentNULLABLE yesno %s: %s Entering set_nullable ritem[rule_table[ruleno].rhs] == -rulenonullable.c/* %s. */ static const %s %s[] = { %6d %6d }; short #include %s extern int yyerror; extern int yycost; extern char * yymsg; extern YYSTYPE yyval; yyguard(n, yyvsp, yylsp) register int n; register YYSTYPE *yyvsp; register YYLTYPE *yylsp; { yyerror = 0; yycost = 0; yymsg = 0; switch (n) { #include %s extern YYSTYPE yyval; extern int yychar; yyaction(n, yyvsp, yylsp) register int n; register YYSTYPE *yyvsp; register YYLTYPE *yylsp; { switch (n) { switch (yyn) { #define yyparse %sparse #define yylex %slex #define yyerror %serror #define yylval %slval #define yychar %schar #define yydebug %sdebug #define yynerrs %snerrs } } } } /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ #define YYTRANSLATE(x) ((unsigned)(x) <= %d ? yytranslate[x] : %d) YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEXcharyytranslate #if YYDEBUG yyprhsyyrhs #endif YYSTOS[STATE] -- Accessing symbol to the STATEyystosYYRLINE[YYN] -- source line where rule number YYN was definedyyrline#endif #define YYNTOKENS %d #define YYNNTS %d #define YYNRULES %d #define YYNSTATES %d #define YYMAXUTOK %d #if (YYDEBUG) || defined YYERROR_VERBOSE /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ static const char *const yytname[] = { \%c\n\t\b\%03o", NULL }; YYTOKNUM[YYLEX] -- Index in YYTNAME corresponding to YYLEXyytoknumYYR1[YYN] -- Symbol number of symbol that rule YYN derivesyyr1YYR2[YYN] -- Number of symbols composing right hand side of rule YYNyyr2 #define YYFINAL %d #define YYFLAG %d #define YYNTBASE %d YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE doesn't specify something else to do. Zero means the default is an erroryydefactyydefgototoutput.cmaximum table size (%d) exceededpack_vector_succeededyypactyypgoto #define YYLAST %d yytableyycheck#define YYPURE 1 /usr/local/share/bison/bison.hairyBISON_HAIRY/usr/local/share/bison/bison.simpleBISON_SIMPLE#lin#li#l#%% action%% actio%% acti%% act%% ac%% a%% %%%#line %d %s actions_dumped == 1#ifndef YYDEBUG # define YYDEBUG %d #endif #include %s %s -> %s (rule %d) $default accept NO ACTIONS $ go to state %d %-4s shift, and go to state %d %-4s error (nonassociative) %-4s go to state %d state %dGrammar%s Number, Line, Rule %s %3d %3d %s ->empty /* %s */Terminals, with rules where they appear%s (-1) %s (%d) %d%s Nonterminals, with rules where they appear on left: on right: Skipping to next \n Skipping to next %cinvalid $ valueunterminated string at end of fileunterminated stringyylocinvalid @ valueyylsp[%d]@c%s is invalidyyval.%s$$ of `%s' has no declared typeyyvsp[%d]$%d of `%s' has no declared type$cunterminated `%{' definition%sPremature EOF after %ssymbol `%s' used more than once as a literal stringsymbol `%s' given more than one literal stringsymbol %s redefinedtype redeclaration for %s%token%nterm`%s' is invalid in %s%startmultiple %s declarationsinvalid %s declaration%type declaration has no invalid %%type declaration due to item: %sredefining precedence of %sinvalid text (%s) - number should be after identifierunexpected item: %s#ifndef YYSTYPE typedef union yystype; # define YYSTYPE yystype #endif %union #line %d %s `}'unmatched %sargument of %%expect is not an integerunrecognized item %s, expected an identifierexpected string constant instead of %sunrecognized: %sno input grammarunknown character: %s case %d: `{'} break;; break;}unterminated %guard clause@%dill-formed rule: initial symbol not followed by colongrammar starts with vertical barrule given for %s, which is a tokentwo @prec's in a row%%guard present but %%semantic_parser not specifiedtwo actions at end of one ruletype clash (`%s' `%s') on default actionempty rule for typed nonterminal, and no actioninvalid input: %stoo many symbols (tokens plus nonterminals); maximum %dno rules in the input grammar#ifndef YYSTYPE #define YYSTYPE int #endif # ifndef YYSTYPE # define YYSTYPE int # endif symbol %s is used, but is not defined as a token and has no rules# define %s %d # define T%s %d extern YYSTYPE %slval; extern YYSTYPE yylval; # define NT%s %d bp->user_token_number != SUNDEFreader.ctokens %s and %s both assigned number %dconflicting precedences for %s and %sconflicting assoc values for %s and %sthe start symbol %s is undefinedthe start symbol %s is a tokenerror$undefined.Bison-generated parse tablesA Bison parser/* %s, made from %s by GNU bison %s. */ #define YYBISON 1 /* Identify Bison output. */ #define YYLSP_NEEDED 1 #ifndef YYLTYPE typedef struct yyltype { int first_line; int first_column; int last_line; int last_column; } yyltype; # define YYLTYPE yyltype #endif Useless nonterminals: %s Terminals which are not used:Useless rules:#%-4d ; REDUCED GRAMMAR ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nitems = %d Variables --------- Value Sprec Sassoc Tag %5d %5d %5d %s Rules ----- Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num] %3d (%2d, %2d, %2d, %2d-%2d) %2d ->%3d [%d] Rules interpreted ----------------- %-5d %s :%d rule never reduced %d rules never reduced %d useless nonterminal%d useless nonterminals and %d useless rule%d useless rules Start symbol %s does not derive any sentencereduced %s defines %d terminals, %d nonterminals, and %d productions. %s BEGIN %d .. %2d|1 | `' %s END TC: InputTC: OutputwhiteblueredgreenyellowmagentacyandarkgreydarkbluedarkreddarkgreendarkyellowdarkmagentadarkcyangoldlightgreylightbluelightredlightgreenlightyellowlightmagentalightcyanlilacturquoiseaquamarinekhakipurpleyellowgreenpinkorangeorchidblackA_known_default_colorvcg.ccenterleft_justifyright_justifyA_known_text_modeboxrhombellipsetriangleA_known_shapenormalmaxdepthmindepthmaxdepthslowmindepthslowmaxdegreemindegreemaxindegreeminindegreemaxoutdegreeminoutdegreeminbackwarddfstreeA_known_layout_algorithmEither_yes_nor_notop_to_bottombottom_to_topleft_to_rightright_to_leftA_knownn_orientationtopbottomA_known_alignementfixedfreeA_known_arrow_modebarymedianbarymedianmedianbaryA_known_crossing_typenormal_viewcfishpfishfcfishfpfishA_known_viewcontinuousdasheddottedinvisibleA_known_line_stylesolidlinenoneA_known_arrow_style edge: { backedge: { nearedge: { bentnearedge: { } node: { graph: { title: %s label: %s loc { x: %d y: %d } vertical_order: %d horizontal_order: %d width: %d height: %d shrink: %d stretch: %d folding: %d textmode: %s shape: %s borderwidth: %d color: %s textcolor: %s bordercolor: %s info%d: %s sourcename: %s targetname: %s linestyle: %s thickness: %d class: %d arrowcolor: %s backarrowcolor: %s arrowsize: %d backarrowsize: %d arrowstyle: %s backarrowstyle: %s priority: %d anchor: %d title: %s label: %s info%d: %s color: %s textcolor: %s bordercolor: %s width: %d height: %d borderwidth: %d x: %d y: %d folding: %d shrink: %d stretch: %d textmode: %s shape: %s vertical_order: %d horizontal_order: %d xmax: %d ymax: %d xbase: %d ybase: %d xspace: %d yspace: %d xlspace: %d xraster: %d yraster: %d xlraster: %d hidden: %d classname %d : %s infoname %d : %s colorentry %d : %d %d %d layoutalgorithm: %s layout_downfactor: %d layout_upfactor: %d layout_nearfactor: %d layout_splinefactor: %d late_edge_labels: %s display_edge_labels: %s dirty_edge_labels: %s finetuning: %s ignore_singles: %s straight_phase: %s priority_phase: %s manhattan_edges: %s smanhattan_edges: %s near_edges: %s orientation: %s node_alignement: %s port_sharing: %s arrow_mode: %s treefactor: %f spreadlevel: %d crossing_weight: %s crossing_phase2: %s crossing_optimization: %s view: %s edges: %s nodes: %s splines: %s bmax: %d cmin: %d cmax: %d pmin: %d pmax: %d rmin: %d rmax: %d smax: %d %d: %s -> memory exhaustedall_slashes || !ISSLASH (*(p - 1))basename.cUnknown system error: %s%s: POSIXLY_CORRECT--%s: option `%s' is ambiguous %s: option `--%s' doesn't allow an argument %s: option `%c%s' doesn't allow an argument %s: option `%s' requires an argument %s: unrecognized option `--%s' %s: unrecognized option `%c%s' %s: illegal option -- %c %s: invalid option -- %c %s: option requires an argument -- %c %s: option `-W %s' is ambiguous %s: option `-W %s' doesn't allow an argument clocalelocaleescapeshell-alwaysshellliteral"`'eh=xFx$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$x$wx$x$whx$x$x$x$x$x$x$x$x$x$x$x x$wx$x$w|wTx$x$wwx$wxxx$wx$wx$wx$x$wHF``````````````````````````````````&~l>.&`Z`4 >`hr8CCCCCDDDD$D.D8DBDLDVD`DjDtD~DDDDDDDDDDDDDDEEEEFF FFF$F,F4F<FDFLHH$H,H4HtNtFtRtBtJtttttttttttttttttttttttttnttutttttttttuuuuuuuuuuuuuuuuttttuttstuuuuuuuuuuuuuuuuuuuuuuuuuutttVuttuttuuuuuuuuuuuuuuuuuuuuuuuuuuuttutnt uuuuut t t uuut ut uuuuuuuuuuuut t t ~~~~~ $X.DjChVyyStplnrkd{vobhoco]gWl g a \ V PIC=82)"]h\o`d{ ,d$c?׺./share/ 755 0 0 0 7442456511 5167 ./share/bison/ 755 0 0 0 7442456513 6303 ./share/bison/bison.simple 644 0 0 60044 7442450667 10745 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ #line /* Skeleton output parser for bison, Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* As a special exception, when this file is copied by Bison into a Bison output file, you may use that output file without restriction. This special exception was added by the Free Software Foundation in version 1.24 of Bison. */ /* This is the parser code that is written into each bison parser when the %semantic_parser declaration is not specified in the grammar. It was written by Richard Stallman by simplifying the hairy parser used when %semantic_parser is specified. */ /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. There are some unavoidable exceptions within include files to define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ #ifdef __cplusplus # define YYSTD(x) std::x #else # define YYSTD(x) x #endif #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) /* The parser invokes alloca or malloc; define the necessary symbols. */ # if YYSTACK_USE_ALLOCA # define YYSTACK_ALLOC alloca # else # ifndef YYSTACK_USE_ALLOCA # if defined (alloca) || defined (_ALLOCA_H) # define YYSTACK_ALLOC alloca # else # ifdef __GNUC__ # define YYSTACK_ALLOC __builtin_alloca # endif # endif # endif # endif # ifdef YYSTACK_ALLOC /* Pacify GCC's `empty if-body' warning. */ # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) # else # ifdef __cplusplus # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T std::size_t # else # ifdef __STDC__ # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # endif # endif # define YYSTACK_ALLOC YYSTD (malloc) # define YYSTACK_FREE YYSTD (free) # endif /* A type that is properly aligned for any stack member. */ union yyalloc { short yyss; YYSTYPE yyvs; # if YYLSP_NEEDED YYLTYPE yyls; # endif }; /* The size of the maximum gap between one aligned stack and the next. */ # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # if YYLSP_NEEDED # define YYSTACK_BYTES(N) \ ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + 2 * YYSTACK_GAP_MAX) # else # define YYSTACK_BYTES(N) \ ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ + YYSTACK_GAP_MAX) # endif /* Relocate the TYPE STACK from its old location to the new one. The local variables YYSIZE and YYSTACKSIZE give the old and new number of elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ # define YYSTACK_RELOCATE(Type, Stack) \ do \ { \ YYSIZE_T yynewbytes; \ yymemcpy ((char *) yyptr, (char *) (Stack), \ yysize * (YYSIZE_T) sizeof (Type)); \ Stack = &yyptr->Stack; \ yynewbytes = yystacksize * sizeof (Type) + YYSTACK_GAP_MAX; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ while (0) #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) # define YYSIZE_T __SIZE_TYPE__ #endif #if ! defined (YYSIZE_T) && defined (size_t) # define YYSIZE_T size_t #endif #if ! defined (YYSIZE_T) # ifdef __cplusplus # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T std::size_t # else # ifdef __STDC__ # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # endif # endif #endif #if ! defined (YYSIZE_T) # define YYSIZE_T unsigned int #endif #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY -2 #define YYEOF 0 #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrlab1 /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ #define YYFAIL goto yyerrlab #define YYRECOVERING() (!!yyerrstatus) #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ { \ yychar = (Token); \ yylval = (Value); \ yychar1 = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ { \ yyerror ("syntax error: cannot back up"); \ YYERROR; \ } \ while (0) #define YYTERROR 1 #define YYERRCODE 256 /* YYLLOC_DEFAULT -- Compute the default location (before the actions are run). When YYLLOC_DEFAULT is run, CURRENT is set the location of the first token. By default, to implement support for ranges, extend its range to the last symbol. */ #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ Current.last_line = Rhs[N].last_line; \ Current.last_column = Rhs[N].last_column; #endif /* YYLEX -- calling `yylex' with the right arguments. */ #if YYPURE # if YYLSP_NEEDED # ifdef YYLEX_PARAM # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) # else # define YYLEX yylex (&yylval, &yylloc) # endif # else /* !YYLSP_NEEDED */ # ifdef YYLEX_PARAM # define YYLEX yylex (&yylval, YYLEX_PARAM) # else # define YYLEX yylex (&yylval) # endif # endif /* !YYLSP_NEEDED */ #else /* !YYPURE */ # define YYLEX yylex () #endif /* !YYPURE */ /* Enable debugging if requested. */ #if YYDEBUG # ifndef YYFPRINTF # ifdef __cplusplus # include /* INFRINGES ON USER NAME SPACE */ # else # include /* INFRINGES ON USER NAME SPACE */ # endif # define YYFPRINTF YYSTD (fprintf) # endif # define YYDPRINTF(Args) \ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (0) /* Nonzero means print parse trace. [The following comment makes no sense to me. Could someone clarify it? --akim] Since this is uninitialized, it does not stop multiple parsers from coexisting. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) #endif /* !YYDEBUG */ /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 #endif /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only if the built-in stack extension method is used). Do not make this value too large; the results are undefined if SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ #if YYMAXDEPTH == 0 # undef YYMAXDEPTH #endif #ifndef YYMAXDEPTH # define YYMAXDEPTH 10000 #endif #if ! defined (yyoverflow) && ! defined (yymemcpy) # if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ # define yymemcpy __builtin_memcpy # else /* not GNU C or C++ */ /* This is the most reliable way to avoid incompatibilities in available built-in functions on various systems. */ static void # if defined (__STDC__) || defined (__cplusplus) yymemcpy (char *yyto, const char *yyfrom, YYSIZE_T yycount) # else yymemcpy (yyto, yyfrom, yycount) char *yyto; const char *yyfrom; YYSIZE_T yycount; # endif { register const char *yyf = yyfrom; register char *yyt = yyto; register YYSIZE_T yyi = yycount; while (yyi-- != 0) *yyt++ = *yyf++; } # endif #endif #ifdef YYERROR_VERBOSE # ifndef yystrlen # if defined (__GLIBC__) && defined (_STRING_H) # define yystrlen strlen # else /* Return the length of YYSTR. */ static YYSIZE_T # if defined (__STDC__) || defined (__cplusplus) yystrlen (const char *yystr) # else yystrlen (yystr) const char *yystr; # endif { register const char *yys = yystr; while (*yys++ != '\0') continue; return yys - yystr - 1; } # endif # endif # ifndef yystpcpy # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) # define yystpcpy stpcpy # else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in YYDEST. */ static char * # if defined (__STDC__) || defined (__cplusplus) yystpcpy (char *yydest, const char *yysrc) # else yystpcpy (yydest, yysrc) char *yydest; const char *yysrc; # endif { register char *yyd = yydest; register const char *yys = yysrc; while ((*yyd++ = *yys++) != '\0') continue; return yyd - 1; } # endif # endif #endif #line /* The user can define YYPARSE_PARAM as the name of an argument to be passed into yyparse. The argument should have type void *. It should actually point to an object. Grammar actions can access the variable by casting it to the proper pointer type. */ #ifdef YYPARSE_PARAM # ifdef __cplusplus # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM # define YYPARSE_PARAM_DECL # else /* !__cplusplus */ # define YYPARSE_PARAM_ARG YYPARSE_PARAM # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; # endif /* !__cplusplus */ #else /* !YYPARSE_PARAM */ # define YYPARSE_PARAM_ARG # define YYPARSE_PARAM_DECL #endif /* !YYPARSE_PARAM */ /* Prevent warning if -Wstrict-prototypes. */ #ifdef __GNUC__ # ifdef YYPARSE_PARAM int yyparse (void *); # else int yyparse (void); # endif #endif /* YY_DECL_VARIABLES -- depending whether we use a pure parser, variables are global, or local to YYPARSE. */ #define YY_DECL_NON_LSP_VARIABLES \ /* The lookahead symbol. */ \ int yychar; \ \ /* The semantic value of the lookahead symbol. */ \ YYSTYPE yylval; \ \ /* Number of parse errors so far. */ \ int yynerrs; #if YYLSP_NEEDED # define YY_DECL_VARIABLES \ YY_DECL_NON_LSP_VARIABLES \ \ /* Location data for the lookahead symbol. */ \ YYLTYPE yylloc; #else # define YY_DECL_VARIABLES \ YY_DECL_NON_LSP_VARIABLES #endif /* If nonreentrant, generate the variables here. */ #if !YYPURE YY_DECL_VARIABLES #endif /* !YYPURE */ int yyparse (YYPARSE_PARAM_ARG) YYPARSE_PARAM_DECL { /* If reentrant, generate the variables here. */ #if YYPURE YY_DECL_VARIABLES #endif /* !YYPURE */ register int yystate; register int yyn; int yyresult; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; /* Lookahead token as an internal (translated) token number. */ int yychar1 = 0; /* Three stacks and their tools: `yyss': related to states, `yyvs': related to semantic values, `yyls': related to locations. Refer to the stacks thru separate pointers, to allow yyoverflow to reallocate them elsewhere. */ /* The state stack. */ short yyssa[YYINITDEPTH]; short *yyss = yyssa; register short *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs = yyvsa; register YYSTYPE *yyvsp; #if YYLSP_NEEDED /* The location stack. */ YYLTYPE yylsa[YYINITDEPTH]; YYLTYPE *yyls = yylsa; YYLTYPE *yylsp; #endif #if YYLSP_NEEDED # define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) #else # define YYPOPSTACK (yyvsp--, yyssp--) #endif YYSIZE_T yystacksize = YYINITDEPTH; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; #if YYLSP_NEEDED YYLTYPE yyloc; #endif /* When reducing, the number of symbols on the RHS of the reduced rule. */ int yylen; YYDPRINTF ((stderr, "Starting parse\n")); yystate = 0; yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ yyssp = yyss; yyvsp = yyvs; #if YYLSP_NEEDED yylsp = yyls; #endif goto yysetstate; /*------------------------------------------------------------. | yynewstate -- Push a new state, which is found in yystate. | `------------------------------------------------------------*/ yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. so pushing a state here evens the stacks. */ yyssp++; yysetstate: *yyssp = yystate; if (yyssp >= yyss + yystacksize - 1) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; #ifdef yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; short *yyss1 = yyss; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. */ # if YYLSP_NEEDED YYLTYPE *yyls1 = yyls; /* This used to be a conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow ("parser stack overflow", &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yyls1, yysize * sizeof (*yylsp), &yystacksize); yyls = yyls1; # else yyoverflow ("parser stack overflow", &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yystacksize); # endif yyss = yyss1; yyvs = yyvs1; } #else /* no yyoverflow */ /* Extend the stack our own way. */ if (yystacksize >= YYMAXDEPTH) goto yyoverflowlab; yystacksize *= 2; if (yystacksize > YYMAXDEPTH) yystacksize = YYMAXDEPTH; { short *yyss1 = yyss; union yyalloc *yyptr = (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyoverflowlab; YYSTACK_RELOCATE (short, yyss); YYSTACK_RELOCATE (YYSTYPE, yyvs); # if YYLSP_NEEDED YYSTACK_RELOCATE (YYLTYPE, yyls); # endif # undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } #endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; #if YYLSP_NEEDED yylsp = yyls + yysize - 1; #endif YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); if (yyssp >= yyss + yystacksize - 1) YYABORT; } YYDPRINTF ((stderr, "Entering state %d\n", yystate)); goto yybackup; /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ /* yyresume: */ /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; if (yyn == YYFLAG) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ /* yychar is either YYEMPTY or YYEOF or a valid token in external form. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } /* Convert token to internal form (in yychar1) for indexing tables with */ if (yychar <= 0) /* This means end of input. */ { yychar1 = 0; yychar = YYEOF; /* Don't call YYLEX any more */ YYDPRINTF ((stderr, "Now at end of input.\n")); } else { yychar1 = YYTRANSLATE (yychar); #if YYDEBUG /* We have to keep this `#if YYDEBUG', since we use variables which are defined only if `YYDEBUG' is set. */ if (yydebug) { YYFPRINTF (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); /* Give the individual parser a way to print the precise meaning of a token, for further debugging info. */ # ifdef YYPRINT YYPRINT (stderr, yychar, yylval); # endif YYFPRINTF (stderr, ")\n"); } #endif } yyn += yychar1; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) goto yydefault; yyn = yytable[yyn]; /* yyn is what to do for this token type in this state. Negative => reduce, -yyn is rule number. Positive => shift, yyn is new state. New state is final state => don't bother to shift, just return success. 0, or most negative number => error. */ if (yyn < 0) { if (yyn == YYFLAG) goto yyerrlab; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; /* Shift the lookahead token. */ YYDPRINTF ((stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1])); /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; #if YYLSP_NEEDED *++yylsp = yylloc; #endif /* Count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; yystate = yyn; goto yynewstate; /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; goto yyreduce; /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; /* If YYLEN is nonzero, implement the default value of the action: `$$ = $1'. Otherwise, the following line sets YYVAL to the semantic value of the lookahead token. This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; #if YYLSP_NEEDED /* Similarly for the default location. Let the user run additional commands if for instance locations are ranges. */ yyloc = yylsp[1-yylen]; YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); #endif #if YYDEBUG /* We have to keep this `#if YYDEBUG', since we use variables which are defined only if `YYDEBUG' is set. */ if (yydebug) { int yyi; YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", yyn, yyrline[yyn]); /* Print the symbols being reduced, and their result. */ for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); } #endif %% actions /* The action file replaces this line. */ #line yyvsp -= yylen; yyssp -= yylen; #if YYLSP_NEEDED yylsp -= yylen; #endif #if YYDEBUG if (yydebug) { short *yyssp1 = yyss - 1; YYFPRINTF (stderr, "state stack now"); while (yyssp1 != yyssp) YYFPRINTF (stderr, " %d", *++yyssp1); YYFPRINTF (stderr, "\n"); } #endif *++yyvsp = yyval; #if YYLSP_NEEDED *++yylsp = yyloc; #endif /* Now `shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTBASE] + *yyssp; if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTBASE]; goto yynewstate; /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ yyerrlab: /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { ++yynerrs; #ifdef YYERROR_VERBOSE yyn = yypact[yystate]; if (yyn > YYFLAG && yyn < YYLAST) { YYSIZE_T yysize = 0; char *yymsg; int yyx, yycount; yycount = 0; /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. */ for (yyx = yyn < 0 ? -yyn : 0; yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) if (yycheck[yyx + yyn] == yyx) yysize += yystrlen (yytname[yyx]) + 15, yycount++; yysize += yystrlen ("parse error, unexpected ") + 1; yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); yymsg = (char *) YYSTACK_ALLOC (yysize); if (yymsg != 0) { char *yyp = yystpcpy (yymsg, "parse error, unexpected "); yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); if (yycount < 5) { yycount = 0; for (yyx = yyn < 0 ? -yyn : 0; yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) if (yycheck[yyx + yyn] == yyx) { const char *yyq = ! yycount ? ", expecting " : " or "; yyp = yystpcpy (yyp, yyq); yyp = yystpcpy (yyp, yytname[yyx]); yycount++; } } yyerror (yymsg); YYSTACK_FREE (yymsg); } else yyerror ("parse error; also virtual memory exhausted"); } else #endif /* defined (YYERROR_VERBOSE) */ yyerror ("parse error"); } goto yyerrlab1; /*--------------------------------------------------. | yyerrlab1 -- error raised explicitly by an action | `--------------------------------------------------*/ yyerrlab1: if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an error, discard it. */ /* return failure if at end of input */ if (yychar == YYEOF) YYABORT; YYDPRINTF ((stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1])); yychar = YYEMPTY; } /* Else will try to reuse lookahead token after shifting the error token. */ yyerrstatus = 3; /* Each real token shifted decrements this */ goto yyerrhandle; /*-------------------------------------------------------------------. | yyerrdefault -- current state does not do anything special for the | | error token. | `-------------------------------------------------------------------*/ yyerrdefault: #if 0 /* This is wrong; only states that explicitly want error tokens should shift them. */ /* If its default is to accept any token, ok. Otherwise pop it. */ yyn = yydefact[yystate]; if (yyn) goto yydefault; #endif /*---------------------------------------------------------------. | yyerrpop -- pop the current state because it cannot handle the | | error token | `---------------------------------------------------------------*/ yyerrpop: if (yyssp == yyss) YYABORT; yyvsp--; yystate = *--yyssp; #if YYLSP_NEEDED yylsp--; #endif #if YYDEBUG if (yydebug) { short *yyssp1 = yyss - 1; YYFPRINTF (stderr, "Error: state stack now"); while (yyssp1 != yyssp) YYFPRINTF (stderr, " %d", *++yyssp1); YYFPRINTF (stderr, "\n"); } #endif /*--------------. | yyerrhandle. | `--------------*/ yyerrhandle: yyn = yypact[yystate]; if (yyn == YYFLAG) goto yyerrdefault; yyn += YYTERROR; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) goto yyerrdefault; yyn = yytable[yyn]; if (yyn < 0) { if (yyn == YYFLAG) goto yyerrpop; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; YYDPRINTF ((stderr, "Shifting error token, ")); *++yyvsp = yylval; #if YYLSP_NEEDED *++yylsp = yylloc; #endif yystate = yyn; goto yynewstate; /*-------------------------------------. | yyacceptlab -- YYACCEPT comes here. | `-------------------------------------*/ yyacceptlab: yyresult = 0; goto yyreturn; /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: yyresult = 1; goto yyreturn; /*---------------------------------------------. | yyoverflowab -- parser overflow comes here. | `---------------------------------------------*/ yyoverflowlab: yyerror ("parser stack overflow"); yyresult = 2; /* Fall through. */ yyreturn: #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); #endif return yyresult; } f } yyn += yychar1; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) goto yydefault; yyn = yytable[yyn]; /* yyn is what to do for this token type in this state. Negative => reduce, -yyn is rule number. Positive => shift, yyn is new state. New state is final state => don't bother to shift, just return success. 0, or most negative number => error. */ if (yyn < 0) { if (yyn == YYFLAG) goto yyerrlab; ./share/bison/bison.hairy 644 0 0 14634 7442450670 10566 /* -*- C -*- */ extern int timeclock; int yyerror; /* Yyerror and yycost are set by guards. */ int yycost; /* If yyerror is set to a nonzero value by a */ /* guard, the reduction with which the guard */ /* is associated is not performed, and the */ /* error recovery mechanism is invoked. */ /* Yycost indicates the cost of performing */ /* the reduction given the attributes of the */ /* symbols. */ /* YYMAXDEPTH indicates the size of the parser's state and value */ /* stacks. */ #ifndef YYMAXDEPTH #define YYMAXDEPTH 500 #endif /* YYMAXRULES must be at least as large as the number of rules that */ /* could be placed in the rule queue. That number could be determined */ /* from the grammar and the size of the stack, but, as yet, it is not. */ #ifndef YYMAXRULES #define YYMAXRULES 100 #endif #ifndef YYMAXBACKUP #define YYMAXBACKUP 100 #endif short yyss[YYMAXDEPTH]; /* the state stack */ YYSTYPE yyvs[YYMAXDEPTH]; /* the semantic value stack */ YYLTYPE yyls[YYMAXDEPTH]; /* the location stack */ short yyrq[YYMAXRULES]; /* the rule queue */ int yychar; /* the lookahead symbol */ YYSTYPE yylval; /* the semantic value of the */ /* lookahead symbol */ YYSTYPE yytval; /* the semantic value for the state */ /* at the top of the state stack. */ YYSTYPE yyval; /* the variable used to return */ /* semantic values from the action */ /* routines */ YYLTYPE yylloc; /* location data for the lookahead */ /* symbol */ YYLTYPE yytloc; /* location data for the state at the */ /* top of the state stack */ int yynunlexed; short yyunchar[YYMAXBACKUP]; YYSTYPE yyunval[YYMAXBACKUP]; YYLTYPE yyunloc[YYMAXBACKUP]; short *yygssp; /* a pointer to the top of the state */ /* stack; only set during error */ /* recovery. */ YYSTYPE *yygvsp; /* a pointer to the top of the value */ /* stack; only set during error */ /* recovery. */ YYLTYPE *yyglsp; /* a pointer to the top of the */ /* location stack; only set during */ /* error recovery. */ /* Yyget is an interface between the parser and the lexical analyzer. */ /* It is costly to provide such an interface, but it avoids requiring */ /* the lexical analyzer to be able to back up the scan. */ yyget() { if (yynunlexed > 0) { yynunlexed--; yychar = yyunchar[yynunlexed]; yylval = yyunval[yynunlexed]; yylloc = yyunloc[yynunlexed]; } else if (yychar <= 0) yychar = 0; else { yychar = yylex(); if (yychar < 0) yychar = 0; else yychar = YYTRANSLATE(yychar); } } yyunlex(chr, val, loc) int chr; YYSTYPE val; YYLTYPE loc; { yyunchar[yynunlexed] = chr; yyunval[yynunlexed] = val; yyunloc[yynunlexed] = loc; yynunlexed++; } yyrestore(first, last) register short *first; register short *last; { register short *ssp; register short *rp; register int symbol; register int state; register int tvalsaved; ssp = yygssp; yyunlex(yychar, yylval, yylloc); tvalsaved = 0; while (first != last) { symbol = yystos[*ssp]; if (symbol < YYNTBASE) { yyunlex(symbol, yytval, yytloc); tvalsaved = 1; ssp--; } ssp--; if (first == yyrq) first = yyrq + YYMAXRULES; first--; for (rp = yyrhs + yyprhs[*first]; symbol = *rp; rp++) { if (symbol < YYNTBASE) state = yytable[yypact[*ssp] + symbol]; else { state = yypgoto[symbol - YYNTBASE] + *ssp; if (state >= 0 && state <= YYLAST && yycheck[state] == *ssp) state = yytable[state]; else state = yydefgoto[symbol - YYNTBASE]; } *++ssp = state; } } if ( ! tvalsaved && ssp > yyss) { yyunlex(yystos[*ssp], yytval, yytloc); ssp--; } yygssp = ssp; } int yyparse() { register int yystate; register int yyn; register short *yyssp; register short *yyrq0; register short *yyptr; register YYSTYPE *yyvsp; int yylen; YYLTYPE *yylsp; short *yyrq1; short *yyrq2; yystate = 0; yyssp = yyss - 1; yyvsp = yyvs - 1; yylsp = yyls - 1; yyrq0 = yyrq; yyrq1 = yyrq0; yyrq2 = yyrq0; yychar = yylex(); if (yychar < 0) yychar = 0; else yychar = YYTRANSLATE(yychar); yynewstate: if (yyssp >= yyss + YYMAXDEPTH - 1) { yyabort("Parser Stack Overflow"); YYABORT; } *++yyssp = yystate; yyresume: yyn = yypact[yystate]; if (yyn == YYFLAG) goto yydefault; yyn += yychar; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar) goto yydefault; yyn = yytable[yyn]; if (yyn < 0) { yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrlab; yystate = yyn; yyptr = yyrq2; while (yyptr != yyrq1) { yyn = *yyptr++; yylen = yyr2[yyn]; yyvsp -= yylen; yylsp -= yylen; yyguard(yyn, yyvsp, yylsp); if (yyerror) goto yysemerr; yyaction(yyn, yyvsp, yylsp); *++yyvsp = yyval; yylsp++; if (yylen == 0) { yylsp->timestamp = timeclock; yylsp->first_line = yytloc.first_line; yylsp->first_column = yytloc.first_column; yylsp->last_line = (yylsp-1)->last_line; yylsp->last_column = (yylsp-1)->last_column; yylsp->text = 0; } else { yylsp->last_line = (yylsp+yylen-1)->last_line; yylsp->last_column = (yylsp+yylen-1)->last_column; } if (yyptr == yyrq + YYMAXRULES) yyptr = yyrq; } if (yystate == YYFINAL) YYACCEPT; yyrq2 = yyptr; yyrq1 = yyrq0; *++yyvsp = yytval; *++yylsp = yytloc; yytval = yylval; yytloc = yylloc; yyget(); goto yynewstate; yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; yyreduce: *yyrq0++ = yyn; if (yyrq0 == yyrq + YYMAXRULES) yyrq0 = yyrq; if (yyrq0 == yyrq2) { yyabort("Parser Rule Queue Overflow"); YYABORT; } yyssp -= yyr2[yyn]; yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTBASE] + *yyssp; if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTBASE]; goto yynewstate; yysemerr: *--yyptr = yyn; yyrq2 = yyptr; yyvsp += yyr2[yyn]; yyerrlab: yygssp = yyssp; yygvsp = yyvsp; yyglsp = yylsp; yyrestore(yyrq0, yyrq2); yyrecover(); yystate = *yygssp; yyssp = yygssp; yyvsp = yygvsp; yyrq0 = yyrq; yyrq1 = yyrq0; yyrq2 = yyrq0; goto yyresume; } %% actions yunchar[yynunlexed]; yylval = yyunval[yynunlexed]; yylloc = yyunloc[yynunlexed]; } ./info/ 755 0 0 0 7442456515 5024 ./info/bison.info 644 0 0 0 7442455233 7002 ./man/ 755 0 0 0 7442456516 4645 ./man/man1/ 755 0 0 0 7442456517 5502 ./man/man1/bison.1 644 0 0 15102 7442450672 6776 .TH BISON 1 local .SH NAME bison \- GNU Project parser generator (yacc replacement) .SH SYNOPSIS .B bison [ .BI \-b " file-prefix" ] [ .BI \-\-file-prefix= file-prefix ] [ .B \-d ] [ .BI \-\-defines= defines-file ] [ .B \-g ] [ .BI \-\-graph= graph-file ] [ .B \-k ] [ .B \-\-token-table ] [ .B \-l ] [ .B \-\-no-lines ] [ .B \-n ] [ .B \-\-no-parser ] [ .BI \-o " outfile" ] [ .BI \-\-output-file= outfile ] [ .BI \-p " prefix" ] [ .BI \-\-name-prefix= prefix ] [ .B \-t ] [ .B \-\-debug ] [ .B \-v ] [ .B \-\-verbose ] [ .B \-V ] [ .B \-\-version ] [ .B \-y ] [ .B \-\-yacc ] [ .B \-h ] [ .B \-\-help ] [ .B \-\-fixed-output-files ] file .SH DESCRIPTION .I Bison is a parser generator in the style of .IR yacc (1). It should be upwardly compatible with input files designed for .IR yacc . .PP Input files should follow the .I yacc convention of ending in .BR .y . Unlike .IR yacc , the generated files do not have fixed names, but instead use the prefix of the input file. Moreover, if you need to put .IR C++ code in the input file, you can end his name by a C++-like extension (.ypp or .y++), then bison will follow your extension to name the output file (.cpp or .c++). For instance, a grammar description file named .B parse.yxx would produce the generated parser in a file named .BR parse.tab.cxx , instead of .IR yacc 's .BR y.tab.c or old .IR Bison versions .BR parse.tab.c . .PP This description of the options that can be given to .I bison is adapted from the node .B Invocation in the .B bison.texinfo manual, which should be taken as authoritative. .PP .I Bison supports both traditional single-letter options and mnemonic long option names. Long option names are indicated with .B \-\- instead of .BR \- . Abbreviations for option names are allowed as long as they are unique. When a long option takes an argument, like .BR \-\-file-prefix , connect the option name and the argument with .BR = . .SS OPTIONS .TP .BI \-b " file-prefix" .br .ns .TP .BI \-\-file-prefix= file-prefix Specify a prefix to use for all .I bison output file names. The names are chosen as if the input file were named \fIfile-prefix\fB.c\fR. .TP .B \-d .br .ns Write an extra output file containing macro definitions for the token type names defined in the grammar and the semantic value type .BR YYSTYPE , as well as a few .B extern variable declarations. .sp If the parser output file is named \fIname\fB.c\fR then this file is named \fIname\fB.h\fR. .sp This output file is essential if you wish to put the definition of .B yylex in a separate source file, because .B yylex needs to be able to refer to token type codes and the variable .BR yylval . .TP .BI \-\-defines= defines-file The behaviour of .BI \-\-defines is the same than .BI \-d option. The only difference is that it has an optionnal argument which is the name of the output filename. .TP .BI \-g .br .ns Output a VCG definition of the LALR(1) grammar automaton computed by Bison. If the grammar file is .BR foo.y , the VCG output file will be .BR foo.vcg . .TP .BI \-\-graph= graph-file The behaviour of .BI \-\-graph is the same than .BI \-g option. The only difference is that it has an optionnal argument which is the name of the output graph filename. .TP .B \-k .br .ns .TP .B \-\-token-table This switch causes the \fIname\fB.tab.c\fR output to include a list of token names in order by their token numbers; this is defined in the array .IR yytname . Also generated are #defines for .IR YYNTOKENS , .IR YYNNTS , .IR YYNRULES , and .IR YYNSTATES . .TP .B \-l .br .ns .TP .B \-\-no-lines Don't put any .B #line preprocessor commands in the parser file. Ordinarily .I bison puts them in the parser file so that the C compiler and debuggers will associate errors with your source file, the grammar file. This option causes them to associate errors with the parser file, treating it an independent source file in its own right. .TP .B \-n .br .ns .TP .B \-\-no-parser Do not generate the parser code into the output; generate only declarations. The generated \fIname\fB.tab.c\fR file will have only constant declarations. In addition, a \fIname\fB.act\fR file is generated containing a switch statement body containing all the translated actions. .TP .BI \-o " outfile" .br .ns .TP .BI \-\-output-file= outfile Specify the name .I outfile for the parser file. .sp The other output files' names are constructed from .I outfile as described under the .B \-v and .B \-d switches. .TP .BI \-p " prefix" .br .ns .TP .BI \-\-name-prefix= prefix Rename the external symbols used in the parser so that they start with .I prefix instead of .BR yy . The precise list of symbols renamed is .BR yyparse , .BR yylex , .BR yyerror , .BR yylval , .BR yychar , and .BR yydebug . .sp For example, if you use .BR "\-p c" , the names become .BR cparse , .BR clex , and so on. .TP .B \-t .br .ns .TP .B \-\-debug In the parser file, define the macro .B YYDEBUG to 1 if it is not already defined, so that the debugging facilities are compiled. .TP .B \-v .br .ns .TP .B \-\-verbose Write an extra output file containing verbose descriptions of the parser states and what is done for each type of look-ahead token in that state. .sp This file also describes all the conflicts, both those resolved by operator precedence and the unresolved ones. .sp The file's name is made by removing .B .tab.c or .B .c from the parser output file name, and adding .B .output instead. .sp Therefore, if the input file is .BR foo.y , then the parser file is called .B foo.tab.c by default. As a consequence, the verbose output file is called .BR foo.output . .TP .B \-V .br .ns .TP .B \-\-version Print the version number of .I bison and exit. .TP .B \-h .br .ns .TP .B \-\-help Print a summary of the options to .I bison and exit. .TP .B \-y .br .ns .TP .B \-\-yacc .br .ns .TP .B \-\-fixed-output-files Equivalent to .BR "\-o y.tab.c" ; the parser output file is called .BR y.tab.c , and the other outputs are called .B y.output and .BR y.tab.h . The purpose of this switch is to imitate .IR yacc 's output file name conventions. Thus, the following shell script can substitute for .IR yacc : .sp .RS .ft B bison \-y $* .ft R .sp .RE .SH FILES /usr/local/share/bison/bison.simple simple parser .br /usr/local/share/bison/bison.hairy complicated parser .SH "ENVIRONMENT VARIABLES" .TP .SM BISON_SIMPLE If this is set, it specifies the location in which the .B bison.simple parser can be found. .TP .SM BISON_HAIRY If this is set, it specifies the location in which the .B bison.hairy parser can be found. .SH SEE ALSO .IR yacc (1) .br The .IR "Bison Reference Manual" , included as the file .B bison.texinfo in the .I bison source distribution. .SH DIAGNOSTICS Self explanatory. == *ssp) state = yytable[state]; else state = yydefgoto[symbol - YYNTBASE]; } *++ssp = state; } } if ( ! tvalsaved && ssp > yyss) { yyunlex(yystos[*ssp], yytval, yytloc); ssp--; } yygssp = ssp; } int yyparse() { register int yystate; register int yyn; register short *yyssp; register short *yyrq0; register short *yyptr; register YYSTYPE *yyvsp; int yylen; YYLTYPE *yylsp; .TH BISON 1 local .SH NAME bison \- GNU Project parser generator (yacc replacement) .SH SYNOPSIS .B bison [ .BI \-b " file-prefix" ] [ .BI \-\-file-prefix= file-prefix ] [ .B \-d ] [ .BI \-\-defines= defines-file ] [ .B \-g ] [ .BI \-\-graph= graph-file ] [ .B \-k ] [ .B \-\-token-table ] [ .B \-l ] [ .B \-\-no-lines ] [ .B \-n ] [ .B \-\-no-parser ] [ .BI \-o " outfile" ] [ .BI \-\-output-file= outfile ] [ .BI \-p " prefix" ] [ .BI \-\-name-prefix= prefix ] [ .B \-t ] [ .B \-\-debug ] [ .B \-v ] [ .B \-\-verbose ] [ .B \-V ] [ .B \-\-version ] [ .B \-y ] [ .B \-\-yacc ] [ .B \-h ] [ .B \-\-help ] [ .B \-\-fixed-output-files ] file .SH DESCRIPTION .I Bison is a parser generator in the style of .IR yacc (1). It should be upwardly compatible with input files designed for .IR yacc . .PP Input files should follow the .I yacc convention of ending in .BR .y . Unlike .IR yacc , the generated files do not have fixed names, but instead use the prefix of the input file. Moreover, if you need to put .IR C++ code in the input file, you can end his name by a C++-like extension (.ypp or .y++), then bison will follow your extension to name the output file (.cpp or .c++). For instance, a grammar description file named .B parse.yxx would produce the generated parser in a file named .BR parse.tab.cxx , instead of .IR yacc 's .BR y.tab.c or old .IR Bison versions .BR parse.tab.c . .PP This description of the options that can be given to .I bison is adapted from the node .B Invocation in the .B bison.texinfo manual, which should be taken as authoritative. .PP .I Bison supports both traditional single-letter options and mnemonic long option names. Long option names are indicated with .B \-\- instead of .BR \- . Abbreviations for option names are allowed as long as they are unique. When a long option takes an argument, like .BR \-\-file-prefix , connect the option name and the argument with .BR = . .SS OPTIONS .TP .BI \-b " file-prefix" .br .ns .TP .BI \-\-file-prefix= file-prefix Specify a prefix to use for all .I bison output file names. The names are chosen as if the input file were named \fIfile-prefix\fB.c\fR. .TP .B \-d .br .ns Write an extra output file containing macro definitions for the token type names defined in the grammar and the semantic value type .BR YYSTYPE , as well as a few .B extern variable declarations. .sp If the parser output file is named \fIname\fB.c\fR then this file is named \fIname\fB.h\fR. .sp This output file is essential if you wish to put the definition of .B yylex in a separate source file, because .B yylex needs to be able to refer to token type codes and the variable .BR yylval . .TP .BI \-\-defines= defines-file The behaviour of .BI \-\-defines is the same than .BI \-d option. The only difference is that it has an optionnal argument which is the name of the output filename. .TP .BI \-g .br .ns Output a VCG definition of the LALR(1) grammar automaton computed by Bison. If the grammar file is .BR foo.y , the VCG output file will be .BR foo.vcg . .TP .BI \-\-graph= graph-file The behaviour