Category : Linux Files
Archive   : BISON118.ZIP
Filename : BISON11B.TAR

 
Output of file : BISON11B.TAR contained in archive : BISON118.ZIP
./bin/bison 755 0 0 322004 5213513115 11056 0ustar rootroot dèw¸-»Í€£ôÙ-:‹D$£•èÒMPè\è[¸̀ë÷bU‰åWVS1ۋ=@˜}Pèé ‰Æ‹ä™¿ƒÂƒÄ…Àt…À~CfÿF¿ƒÂ…Àuí‹=@˜½Pè® £—]Pèœ £ —1Û1҃Ä9@˜~'‹
—] —‰‘¿VÃB9@˜á‰5 —‹=@˜½PèH £—eô[^_ÉÃU‰åè,ÿÿÿ‹@˜UPè £—¡@š@ÀPè
£—hÄèû£$—ÉÃU‰åƒ= —tÿ5 —èeãƒÄƒ=—tÿ5—èNãƒÄƒ=—tÿ5—è7ãƒÄƒ=—tÿ5—è ãƒÄƒ=—tÿ5—è ãƒÄƒ= —tÿ5 —èòâƒÄƒ=$—t ÿ5$—èÛâÉÐU‰åèÿÿÿÿ5@™è‘è$ƒÄƒ=ø–tM¡ø–¿@ P¡ø–ƒÀPèd è¯è>èŃă=—~è¡ø–‹£ø–ƒ=ø–u³èš èáþÿÿè ÉАU‰åWVS1É9
@˜~¡—ÇˆA9
@˜ð1ÿ‹5Dš950™vD¿ƒÆ¡ä™¿H…Û~å¡—‹˜…Òu¡ —f‰xG¡—‹˜fAf‰
¡—ƒÂ‰˜ëµ‰=—eô[^_ÉÃU‰åƒìWVS»9—~H‹= —‰}ü¿ _‰Ú…Û~(¿D_þ9È~‹Eüf‹tPþf‰4PJ…Ò~ ‰Eü¿DPþ9Èãf‰ WC9—¾1Û9—~%¡ —¿ XQè!‹—f‰ZƒÄC9—ۍeð[^_ÉÃU‰åƒì WVS¡—‹}‹ ¸¡—‹<¸‰}ü)ω}øÑ}ø1Û9Müv¿ÃÁ9Müwó‰Ø¿ñ™÷ÿ‰Ó¡$—‹4˜…ötÇEô¿F 9Eøu>ÇEô¡—‹U‹ ^9Müv$f‹ƒÃf‹ƒÁf9ÐtÇEôƒ}ôt 9Müw݃}ôu>ƒ~t‹vëÿuè@‰F‰ÆÇEôƒÄƒ}ôt‹ëÿuè ‹$—‰Æ‰4š¿Feè[^_ÉÃstatesU‰åWVS=P˜þ~
hè¨JƒÄ¡—‹M‹4ˆ¡—‹<ˆ‰û)óÑû]Pèg‰Âf‹Mf‰J

P˜f‰Jf‰Z B9þsf‹f‰ƒÆƒÀ9þrð¡ü–‰‰ü–ÿP˜‰Ðeô[^_ÉÃU‰åjè
£ø–£ü–£šÇP˜ÉАU‰åVS‹5—uƒÀ
Pèщáø–f‹@f‰Cf‹5—f‰s‹—K‹5—uÐ9Âsf‹2f‰1ƒÂƒÁ9Ârðƒ=—t ¡—‰ë‰X™‰—eø[^ÉÃU‰åWVS1ö‹Dš90™v,‹ä™‹
—¿¿C…À}f÷Øf‰qFƒÂ90™wâ…ötbuC

‰Á¡ø–f‹@f‰Af‰q¡—QÃ9Øsf‹8f‰:ƒÀƒÂ9Ørðƒ=—t ¡—‰ë‰
™‰
—eô[^_ÉÃU‰åƒìWVS‹X™…Û„Mfƒ{…¿{¡š‹‰Eð¿@
9ԙ~(‹uð¿F9ø}‹Mð‹ ‰Mð¿A
9ԙ~¿A9ø|ä‹Uð¿B
9ԙ…ñ¿z됐‰]ü‹…Û„Ÿ¿C9ø|ë…Û„¿C9ø…ƒ¿CE Pèö‰Eôf‰xf‹sfFf‰pf‹
P˜f‰H¿S‰UøƒÄ…Ò~‹uøf‹Ts‹Môf‰TqÿMøƒ}øç‹ ‹uô‰‹Uü‰29—u‰5—…Û„sSèÝéej è}‰Eôf‰xfÇ@f‹5P˜f‰p‰‹Mü‰ƒÄ…Û…5£—é+‹X™¿CE Pè1‰Eôf‹SfBf‰P¡š‹‰EðÇEøƒÄ1ÿfƒ{~L‹uð¿F
9ԙ}9}øuf‹P˜‹Môf‰TyG‹uøf‹Ls‹uôf‰L~‹Uð‹‰UðGÿEø¿C9Eø|·9}øuf‹
P˜‹uôf‰L~‹3‹Uô‰2‰X™9—u‰—…Ût Sè
܃ÄèúëZj èq‰ÃfÇCf‹
P˜f‰K‹X™‰‰X™ë(j èE‰ÃfÇCf‹5P˜f‰s‰X™‰—衃Äjè‰Eðf‹
P˜f‰H¡ü–‹Uð‰‰ü–j èò‰Ãf‹5P˜f‰sÿP˜fÇCf‹
P˜f‰K¡—‰‰—‹P˜‰À™j讉Eðf‹5P˜f‰pÿP˜¡ü–‹Mð‰‰
ü–eä[^_ÉÃU‰åjèvf‹
P˜f‰Hf‹
ԙf‰H
‹ü–‰£ü–j èLf‹
P˜f‰HÿP˜fÇ@f‹
P˜f‰H‹—‰£—ÉА%s: memory exhausted
U‰åS‹E…Àu¸jPèä܉ÃÄ…Ûuÿ5̙h,
h„”èþüjèӉ؋]üÉÃU‰åÿuè±ÿÿÿÉАU‰å‹UUPè™ÿÿÿ£Dš¡@šƒÀ yƒÀÁø£4—ÁàPèvÿÿÿ£(—èÉАU‰åƒì$WVS¡4š¯4—ÁàPèJÿÿÿ‹Й¯4—Áâ)У,—è^¡Ð™¯4—Áà,—‰Eü‹5Й‰uèƒÄ95@˜Ž‹4—Áã‰]䐐‹Eè+Й¯8—Áà0—‰Eø‰Æ‹6‰uðƒEøÇEì‹Й‰]ô9@˜Ž¦‹uð‹]ì£Þs`¡D˜‹uô‹<°ëI‰U܅Ò}Z‰]ÜÁ}܉Uà…Ò}r‰uàÁ}à‰Ñ…Ò}J‰È$à‰Ñ)Á¸Óà‹uü‹]à ž‹]܉ž¿ƒÇ…Ò­ÿEìƒ}ì~‹Eô@9@˜~‹]ø‹‰]ðƒEøÇEìÿEô‹uô95@˜[ÿÿÿ‹]ä]üÿEè‹uè95@˜ÿþÿÿƒ=0—t ÿ50—èc؍eÐ[^_ÉÃU‰åƒìWVS‹=4šƒÇ‰}øyƒEøÁ}ø‹uø‰58—‰ð¯4šÁàPè–ýÿÿ£0—‰Eü‹=Й‰}ôƒÄ9=@˜Ž­‹5à™‰uð¡D˜‹}ô‹<¸‰}ìfƒ?|q‹uì¿‹}ð¿G¡ä™¿P‰UèƒEì9ЙC‰Ó+Й‰]èyƒÃÁû‹Uè…Ò}ƒÂÁú‹Mè…É}ƒÁ‰È$à‹Mè)Á¸Óà‹uü –‰ž‹}ìfƒ?}‹uø‹}ü4·‰uüÿEô‹uô95@˜]ÿÿÿÿ54šÿ50—èHƍeÜ[^_ÉÃU‰åƒìWVS‹u‹U ‹
(—‹=4—½ȉEô (—9Môvɐ‹8 9ƒÀƒÁ9Môwñ뷐ÇEð‹=Dš‰=0™‰ó‹
(—9Mô†‹9‰}üƒÁ…ÿuƒEð ë吐1ö‹}ü£÷s@¡à™‹}ð¿x됐¡0™f‹;f‰8ƒÃƒ0™9]øv¿9Ð|ß¡0™f‰ƒ0™ÿEðFƒþ~¯ëŒ¡0™f‹;f‰8ƒÃƒ0™9]øwæeä[^_ÉÃU‰åƒ=Dštÿ5Dšè±ÕƒÄƒ=(—tÿ5(—èšÕƒÄ¡Ð™¯4—Áà,—tPèzÕÉÃU‰åSÿ5P˜èáúÿÿ£$™‹<™•PèÉúÿÿ£<—‹<™•Pè±úÿÿ£@—‹P˜•Pè™úÿÿ£À˜Æ ™1ۃÄ9P˜~SèƒÄC9P˜î‹]üÉÃU‰åƒìWVS¡Ü™‹u€<…Î1Û9<™~¡@—Ç˜C9<™ð¡(™‹}‹<¸‰}ø…ÿ„„¿‰}ü1Û9û}w‹5´˜‰uð‹=@—‰}쐐‹uø¿D^‹}ð¿ ô˜‹@—9Uäv‹#ƒÂƒÁ…ÀtíSÿu豃ÄC9]ü¬¡š‹}¿x9]ü~x‰Ø¯<™Áà‰Á
ô˜‰Mô‹@—9Uäv.‹5$™‰u萋#ƒÂƒÁ…Àt‹}è‹uÆ>Æ ™9Uäw܋Mô‹@—9Uäv‹9 :ƒÁƒÂ9UäwñC9]ü‹eØ[^_ÉÃreduceshiftan errorU‰åƒìWVS‹
ЙMƒÀ$ü)ĉeôL$‰Mð¡L™‹M ¿H¡,™¿P‰Uø¾‰È¯<™Áàô˜‰Eü‹=@—1Û9ЙŽd‰ð#‹Mü…„5¡8™fƒ ëHfƒøt"ë=ƒ=ø˜t4hÔëƒ=ø˜t$hÍëƒ=ø˜thÚSÿu ÿuèRƒÄ¡™fƒ U‰å‹M ‹Uÿu¡ü™ÿ4¡L™¿HPÿuhYÿ5è«òÉÐU‰åSÇD—ÇH—1Û9P˜~=¡$™€<t'SèSSèí‹L—D—‹P—H—ƒÄC9P˜ÅèH‹]üÉÃState %d contains 1 shift/reduce conflict %d shift/reduce conflicts and 1 reduce/reduce conflict %d reduce/reduce conflictsU‰åSÇD—ÇH—1Û9P˜ŽQ¡$™€<„3Sè_Sèù‹
L—
D—‹
P—
H—Sh9ÿ5èPñƒÄƒ=L—uhKÿ5è4ñƒÄë%ƒ=L—~ÿ5L—hdÿ5è
ñƒÄ ƒ=L—~ƒ=P—~hÿ5èèðƒÄƒ=P—uh„ÿ5èÌðƒÄë%ƒ=P—~ÿ5P—hžÿ5è¥ðƒÄ ¡‹H9Hr
j.Pè]ۃÄ롐‹PÆ.ÿ@¡‹H9Hr
j
Pè5ۃÄ롐‹PÆ
ÿ@C9P˜±þÿÿèD‹]üÉÃconflicts: %d shift/reduce, %d reduce/reduce%s containsU‰å‹™9D—u
ƒ=H—„¼ƒ= „¥h=h„”èÂïƒÄƒ=D—~<ÿ5D—hIh„”è¡ïƒÄ ƒ=D—~ƒ=H—~3hZh„”è}ïƒÄƒ=H—~ÿ5H—h\h„”è\ïƒÄ ‹œ”9˜”rj
h„”èÚÉј”Æ
ÿ˜”ÉÃÿ5P™hnh„”èïƒÄ ƒ=D—uhKh„”èüîƒÄë$ƒ=D—~ÿ5D—hdh„”èÖîƒÄ ƒ=D—~ƒ=H—~hh„”è²îƒÄƒ=H—uh„h„”è—îƒÄë#ƒ=H—~ÿ5H—hžh„”èrîƒÄ ‹œ”9˜”rj.h„”è%كÄ롘”Æ.ÿ˜”‹œ”9˜”ƒåþÿÿ¡˜”Æ
ÿ˜”ÉÃU‰åƒìWVSÇL—¡(™‹}‹<¸‰}ø…ÿ„n1Û9<™~$‹<—¡@—ÇšÇ˜C9<™é‹}ø¿‰}ü1Û9û}z‹=´˜‰}ô‹=<—‰}𐐐‹}øfƒ|_tT¿D_‹}ô¿ @—‹}¿z9]ü~1‰Ø¯<™Áàô˜‹@—9Ês‹8 :ƒÀƒÂ9ÊròC9]üС<—‹@—9Ês‹8!:ƒÀƒÂ9Êrò¸‹@—1Û9Й~ …tÿL—Àu¸ƒÂC9Йáeà[^_ÉÃU‰åƒìWVS‹UÇP—¡š¿ $default reduce using rule %d (%s)

%-4s reduce using rule %d (%s)
$default reduce using rule %d (%s)
U‰åƒìLWVSÇEÐ1ÿ9=<™~¡<—Ç¸G9=<™ð¡(™‹M‹ ˆ‰M؅É„“¿I‰Mü1ÿ9ύ‚‹5<—‰űMØfƒ|yth¿Ty¡´˜¿P9Й~X90šuÇEЉU¸…Ò}r‰u¸Á}¸‰Ó…Ò}ZÁû‰Ð…Ò}B$à)‰о‰ÁÓæ‰ð‹uÌ ž‹M¸‰ŽG9}ü‡¡À˜‹M‹ ˆ‰MԅÉtn¿ ‰Mü1ÿ9Ï}b‹5<—‰uȋMÔfƒ|ytH¿Ty‰U¸…Ò}r‰u¸Á}¸‰Ó…Ò}ZÁû‰Ð…Ò}B$à)‰о‰ÁÓæ‰ð‹uÈ ž‹M¸‰ŽG9}ü§¡š‹M¿ H‰Mì‹u¿tp‰uè‰ð)ȃø…üƒ}Ð…ò¡L™¿ H‰Mà‹Eì¯<™Áàô˜‰Eø‹
<—‰Mô‹@—‹5<™µ‰ÂÚ9Ós‹Mø‹1‹Mô#1‰3ƒEôƒEøƒÃ9ÓråÇEð‹@—1ÿ9=Й~M‹Mð… t,¡š‹uà¿p‹ü™ÿ4‚Vÿ4ºh£ÿ5èéƒÄÑeðu
ÇEðƒÃG9=Йµ¡š‹Mà¿H¡ü™ÿ4QhÉÿ5èÄè驐‹Eè+Eì…ÀŽ˜ÇE´ÇEäÿÿÿÿ‹5<™µ‰Â@—ƒ}Ð…é‹}ì9}èŽÝ‰ø¯<™Áàô˜‰Eø‹
<—‰Mô‹@—9Ós‹uô‹÷ЋMø#‰ƒEôƒEøƒÃ9ÓrãÇEÜÇEð‹@—ÇE¸ë‹Mð… tÿEÜÑeðu
ÇEðƒÃÿE¸‹u¸95ЙًM´9MÜ~‹u܉u´‰}ä¡L™‰ù¿ H‰Mà‹5<—‰uô‹@—9Ós‹Mô‹3 1ƒÃƒEô9ÓrîG9}è$ÿÿÿ1ÿ9=<™~¡<—Ç¸G9=<™ðƒ}Ø„Š‹MØ¿I‰Mü1ÿ9Ï}z‹5´˜‰uċ
<—‰MÀ‹uØfƒ|~tW¿D~‹MÄ¿A9Й~I‰U¸ƒ}¸}ƒE¸Á}¸‰Ó…Û}ƒÃÁû‰Ð…À}ƒÀ$à)‰о‰ÁÓæ‰ð‹uÀ ž‹M¸‰ŽG9}ü˜ÇEð‹Eì¯<™Áàô˜‰Eø‹
<—‰Mô1ÿ9=ЙŽFÇE¼‹Mð‹uô…•À%ÿ‰E܋]ø‹uì‰u¸‹Mè9΍û‹uð…3„Ѓ}ÜuO‹Mä9M¸t;¡L™‹u¸¿4p‰u´¡š¿p¡ü™ÿ4Vÿ4¸hòÿ5è3æƒÄë ÇE¼ÿEÜë{ƒ}¼t>¡L™‹Mä¿ H‰M´¡š¿H¡ü™ÿ4Qÿ4¸hòÿ5èæåÇE¼ƒÄ¡L™‹u¸¿4p‰u´¡š¿p¡ü™ÿ4Vÿ4¸h£ÿ5è¨åƒÄ‹
<™ÃÿE¸‹uè9u¸ŒÿÿÿÑeðu ÇEðƒEøG9=Йºþÿÿƒ}ä|(¡š‹Mà¿H¡ü™ÿ4Qhÿ5è?åƒÄ¡‹p9pr j
Pè÷Ï됡‹PÆ
ÿ@e¨[^_ÉÃU‰åƒ=$™tÿ5$™èIƒÄƒ=<—tÿ5<—è2ƒÄƒ=@—t ÿ5@—èÂÉÐU‰åƒìWVS‹54šµPètçÿÿ‹5Йµ‰Ã)Ó¡@š@ÁàPèTçÿÿ‰Ç‹
@šƒÄ…É~(‹5š‰uü‹uü¿N…Ò|‹4“‰0f‰H‰“ƒÀI…Éá‹54šµPè
çÿÿ‹5Йµ)УD˜¡4š@šÀPèãæÿÿ‰Â‹
ЙƒÄ9
@˜~1¡D˜‰ˆ‹‹…Àtf‹pf‰2ƒÂ‹…ÀuðfÇÿÿƒÂA9
@˜ϋ5ЙµØt PèÁƒÄ…ÿtWèÁeð[^_ÉÃU‰å‹Й¡D˜ƒ<t ÿ4èÜÀƒÄ‹
ЙD˜tPè¾ÀÉÃU‰åƒì WVS‹u ‹U‰Uü1Û됐CŠB„ÀuøDPè
æÿÿ‰Eô‹Uô‹}‰}ø1Û9ó}‹}øŠˆ
ÿEøBC9ó|ð‹Mü‰Mø‹}øŠˆÿEøB„Àuñ‹Eôeè[^_ÉÃ/tmp/b..c.tab_taby.y.yrBISON_SIMPLE/usr/lib/bison.simple.out.outputw.hact.XXXXXXattrs.XXXXXXtab.XXXXXXw+.stype.h.guard.cU‰åƒìWVSh~$衺‰EøƒÄƒ=ô™tr‹ô™S膺‰Eütþ¿†$¹ó¦ŠFÿ*GÿƒÄ„ÀuƒEüþ‹uüjh‰$DüPè&¹ƒÄ …ÀtjhŽ$DüPè¹ƒÄ …À…©ƒÆü顐ƒ=Ęt;ÿ5Ęè º‰ÆV‰UüFPèäÿÿ‰Ãÿ5ĘSèe¸h‰$Sèr¸ƒÄë[ƒ= t»“$ë‹P™SèÀ¹‰Eütþ¿—$¹ó¦ŠFÿ*GÿƒÄ„ÀuƒEüþ‹uüh‰$VSèÝýÿÿ‰ÃV‰UüƒÄ hš$ÿ5P™è¾£hœ$è£åhš$…Àu¸©$P蛣ƒÄƒ=ø˜t>ƒ=™t h¿$됐hÄ$VSèpýÿÿ£œ˜ƒÄ hÌ$ÿ5œ˜èT£ƒÄƒ=è™t&hÎ$ÿuüSè9ýÿÿ£H™hÌ$Pè%£ƒÄhÑ$ÿuøh~$èýÿÿPèå£šhÜ$ÿuøh~$èòüÿÿPè€å£ì˜ƒÄ hé$ÿuøh~$èÒüÿÿPè`壘˜hô$ÿ5šè³£hô$ÿ5ì˜èž£ƒÄ hô$ÿ5˜˜è†£ ÿ5šèZ¹ÿ5ì˜èO¹ÿ5˜˜èD¹ƒÄƒ=ô™t‹ô™‰šëh†$ÿuüSè:üÿÿ£šƒÄ h÷$VSè&üÿÿ£H˜h%VSèüÿÿ£T™eì[^_ÉÃBISON_HAIRY/usr/lib/bison.hairyU‰åSÿ5è½àh(è»ãhš$…Àu¸(Pè³£hÌ$ÿ5H˜螉Ãÿ5èáƒÄ¡‹H9HrPèȃăøÿu ºÿÿÿÿ됐¡‹P¶ÿ@ƒúÿt%‹K9Kr¶ÂPSèɃÄ벐‹CˆÿC릐ÿ5èà‰hÌ$ÿ5T™è£‹]üÉÃ%s: U‰åVS‹uÿu VèÇá‰ÃƒÄ…Ûu"ÿ5̙h)h„”è=ÞVè?âjè ‰Øeø[^ÉÃU‰åVS‹uƒ=tÿ5èˆßƒÄƒ=tÿ5èq߃ă=tÿ5èZ߃ă=tÿ5èC߃ă=tÿ5è,߃ă=tÿ5è߃Ä…ö…žƒ= „‘hÌ$ÿ5šèÿÿÿ‰Ãÿ5 èð៎ ¡ ‹H9HrPèuƃăøÿu ºÿÿÿÿ됐¡ ‹P¶ÿ@ƒúÿt%‹K9Kr¶ÂPSèãǃÄ벐‹CˆÿC릐SèzÞÿ5 èoރÄVèú½eø[^ÉÃdebugdefinesfile-prefixfixed-output-filesname-prefixno-linesoutput-fileverboseversionyaccyvdltVo:b:p:%sUsage: %s [-dltvyV] [-b file-prefix] [-o outfile] [-p name-prefix]
[--debug] [--defines] [--fixed-output-files] [--no-lines]
[--verbose] [--version] [--yacc]
[--file-prefix=prefix] [--name-prefix=prefix]
[--output-file=outfile] grammar-file
%s: no grammar file given
%s: warning: extra arguments ignored
U‰åƒìWVS‹u‹} Çø˜Çè™Ç(šÇ »$EüPh$hÿ*WVè»°ƒÄƒøÿ„3…Àu‹UüÁâƒ|u‹D ƒøo„½+ƒøb„Æ…Àt°ƒøVtOéސƒødtkƒøltvé͐ƒøtt{ƒøp„¨é·ƒøvt3ƒøy…¦Ç é_ÿÿÿÿ5ؐh +èÀكÄéDÿÿÿÇø˜é5ÿÿÿÇè™é%ÿÿÿÇȘéÿÿÿÇ(šéÿÿÿ‹
ܐ‰
ô™éóþÿÿ‹
ܐ‰
Ęéßþÿÿ‹
ܐ‰
™éËþÿÿÿ5̙h+h„”èÙj蜺95àuÿ5̙h,h„”èkÙjèxºFÿ9à}ÿ5̙h8,h„”èDÙ¡à‹‡£P™eð[^_ÉÃU‰åÉÃU‰å¡Ð™ƒÀyƒÀÁø£<™è7èrè±èìè'è^è!èˆè·èæ è9 ÉАU‰åS‹P˜Pè…Ûÿÿ£Ô˜‹š…Òt‹
Ԙ¿B‰‹…Òuó‹]üÉÃU‰åS‹P˜]PèEÛÿÿ£´˜‹š…Òt‹
´˜¿Bf‹Z
f‰A‹…Òuî‹]üÉÃU‰åS‹P˜PèÛÿÿ£(™‹X™…Òt‹
(™¿B‰‹…Òuó‹]üÉÃU‰åS‹P˜PèÁÚÿÿ£T˜‹ ™…Òt‹
T˜¿B‰‹…Òuó‹]üÉÃU‰å1Ò1É¡ä™fƒ8tfƒ8~Bë 9Ê~‰Ñ1҃Àfƒ8uã‰
X—ÉАU‰åƒì WVSÿ5P˜èHÚÿÿ£Ü™¡P˜@ÀPè5Úÿÿ£šÇEô1ۃÄ9P˜Ž¦‹=´˜‰}ü‹=ܙ‰}ø¡šf‹}ôf‰¡Ü™€<u)¡T˜‹ ˜…Ét1Òfƒy~f‹|Qf‰>ƒÆB¿A9Â|ìC9P˜Íeè[^_ÉÃgotosU‰åƒìWVS¡4š@ÀPè}Øÿÿ‹Й])У™¡4š@ÀPè[Øÿÿ‹
ЙM)ЉEüÇ\—‹=X™ƒÄ…ÿt[¿Gpÿ…ö|H¿Tw¡´˜¿P‰Uè9Й.=\—ÿu
h©1è
ƒÄÿ\—¡™‹]èfÿXNy¹‹?…ÿu§1ҋ5Й95@˜~‹=™‹Müf‰q¿wÂF95@˜ê‹5Й95@˜~¡™‹]üf‹ sf‰ pF95@˜ì‹@˜¡™f‹\—f‰Pf‹\—‹Müf‰Q‹
\—MPèI×ÿÿ£Ü˜‹\—]Pè1×ÿÿ£è˜‹=X™ƒÄ…ÿtl‹
´˜‰Mø‹ܘ‰]ô‹
蘉Mð¿_‰]ì¿Gpÿ…ö|9¿Dw‹Mø¿ A‰Mè9
Й ‹]ü¿KfÿKf‹]ì‹Môf‰Q‹Mðf‰QNyɋ?…ÿu¯‹Й]EütPè#±eÜ[^_ÉÃmap_gotoU‰åWVS‹u‹U ¡™¿P¿LPI9Ë,‹=ܘ…À}@Ñø¿G9òt}X됐Hÿ9Ë~Ýh±3è“1Àeô[^_ÉÃU‰åƒì,WVS¡\—¯<™ÁàPè
Öÿÿ£`—‹5\—µPèòÕÿÿ‰Eè¡\—@ÀPèáÕÿÿ‰EðÇEä‹=`—‰}ìÇEüƒÄ ‹uü95\—ŽT¡è˜‹}ü¿ t ÿ4¾è¶®ƒÄÿEü‹}ü9=\—ك}èt ÿuè藮ƒÄƒ}ðtÿuð膮eÈ[^_ÉÃU‰åƒì0WVS‹5\—µPèØÓÿÿ£d—¡\—@ÀPèÅÓÿÿ‰Eä¡X—@ÀPè´Óÿÿ‰EàÇEüƒÄ ‹}ü9=\—Ž¸ÇEð¡Ü˜‹uü¿4p‰uì¡è˜‹}ü¿x¡´˜¿P¡D˜‹‰Uøfƒ:Ž ÇEôf‹}ì‹uàf‰>‹Mì‹uø¿¡à™¿PÀ‰Ãä™fƒ;~a‹=(™‰}܋5´˜‰uؐ¿;‰}è‹u܋4Ž‰uпv‰uÔ1Ò9ò}‹}пLW‹uØ¿N9EètB9UÔæ‹}ô‹uàf‰ ~ÿEôƒÃfƒ;´¡Ü™€<uÿuü‹}ø¿PQèiƒÄ ÿMô¸ƒÃþ9ä™wC¿9Й8ÿMô‹uô‹}à¿ wRQèéûÿÿ‹uð‹}äf‰wÿEð¿¡Ø˜ƒÄ€<”À%ÿ…Àt©ƒEø‹uøfƒ>àþÿÿƒ}ðt@‹}ð}Pè"Òÿÿ‹d—‹uü‰²1҃Ä9ú}‹}äf‹4Wf‰4PB9Uðï‹}ðfÇxÿÿÿEü‹uü95\—Hþÿÿÿ5\—ÿ5d—è‰ÃÇEüƒÄ됡d—‹uüƒ<°t
t ÿ4°è0¬ƒÄÿEü‹}ü9=\—׃=d—tÿ5d—è ¬ƒÄ‰d—ƒ}ät ÿuäèô«ƒÄƒ}àtÿuàè㫍eÄ[^_ÉÃadd_lookback_edgeU‰åƒìWVS‹U‹} ¡š¿P¿TP1ö9Ó}‹
L™‰Mü‹Mü¿Y9øtC…öu9Ó|ì…öu
hñ8èRƒÄjèèÐÿÿ‹h—‹ š‰f‹Mf‰H‰šeð[^_ÉÃU‰åƒìWVS‹U UPè¯Ðÿÿ‰Eø1ۃÄ9] ~+‹U‹ š…Étfƒ9|¿‹UøfÿBƒÁfƒ9}íC9] ׋U •SègÐÿÿ‰EüSè^Ðÿÿ‰Ç1ۃÄ9] ~4‹Uø¿4Z…ö~!uPè8Ðÿÿ‰Á‹Uü‰ š‰ ŸfÇqÿÿƒÄC9] ΃}øt ÿuø蘪ƒÄ1Û9] ~.‹U‹ š…Étfƒ9|¿‹‡f‰ƒ‡ƒÁfƒ9}êC9] ԅÿtWèVª‹Eüeì[^_ÉÃU‰åSÿ5d—è11ۃÄ9\—~!¡d—ƒ<˜t
t ÿ4˜èªƒÄC9\—߃=d—t ÿ5d—è÷©‹]üÉÃU‰åƒìWVS‹=ô˜‰}ø‹P˜¡š¿P‰Uü1ö9Ö}[‹=<™½‹]øáh—‹ °…Ét2‹Uø¿A¯<™Áà`—9]øs‹8 :ƒÀƒÂ9Úrò‹ …ÉuЉ]øF9uü§1ö9uü~'¡h—‹ °…Ét‹…Ét QèL©ƒÄ‰Ù…ÉuëF9uüك=h—tÿ5h—è)©ƒÄƒ=`—t ÿ5`—詍eì[^_ÉÃU‰åS‹]‹\—ƒÂ‰T—¡\—@ÀPè\Îÿÿ£p—¡\—@ÀPèIÎÿÿ£t—Çx—‰l—1ۃÄ9\—~¡p—fÇXC9\—ñ1Û9\—~,¡p—fƒ <™‹}øÇ¡l—‹u‹4°‰uô…ötbëU¡p—fƒ ƒÀƒÂ9úrò‹uô¿ƒEô…Û} ‹
p—‰Mô‹u¿q9Eüu{‹x—¡t—¿Pÿ
x—f‹5T—f‰4Y9]tV‹Uø‰Ø¯<™Áà`—9ús‹
‰ƒÂƒÀ9úrò¡x—‹t—¿Bÿ
x—¡p—f‹5T—f‰4X9]u¬eè[^_ÉÃU‰åÇ|—d¡|—@Pè'Ìÿÿ£šÇ€—ÿÿÿÿÉАvirtual memory exhaustedU‰åS‹]+šÑ%|—¡|—@Pÿ5š触£šƒÄ…Àu
h0>è%‰Øš‹]üÉÃunexpected `/%c' foundunterminated commentU‰åWVS¡‹H9HrPè˱ƒÄƒøÿ„+¡‹P¶ÿ@C÷ƒø&‡ÿ$…?Æ>AAÆ>AAAAAAAAAAAAAAAAAAAÆ>AAAAAAAAAAAAAA¤?¡‹H9HrPèí°ƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ƒû*tƒû/tSh”>è
ƒÄƒû/”À¶ø¡‹H9HrP蚰ƒÄƒøÿu
»ÿÿÿÿ됐¡‹P¶ÿ@¾…ÿudƒû*u_¡‹H9HrPèU°ƒÄƒøÿu »ÿÿÿÿ됐‹‹B¶ÿBƒû*tȃû/u}1ö¡‹H9Hr`P调ăøÿtIëPƒû
uÿș…ÿ…Iþÿÿëΐƒûÿuh«>èí
ƒÄë2¡‹H9HrPèͯƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@…ö…2ÿÿÿéñýÿÿÿșé·ýÿÿ»ÿÿÿÿéÚýÿÿ‰Øeô[^_ÉÃU‰å‹E£€—¡¨˜£„—ÉÐmalformatted literal token `\%03o'malformatted literal token `\x%x'unknown escape sequence `\%c'unknown escape sequence: `\' followed by char code 0x%xmulticharacter literal tokens not supportedunterminated type nameU‰åWVSƒ=€—|%‹
„—‰
¨˜‹€—Ç€—ÿÿÿÿ‰ØéSègüÿÿ‰ÃCƒø}‡9ÿ$…pBhD J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J J˜J JxE J J J J\I JpD JEEEEEEEEEEhItIüIŒI J J JpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpD J J J JpD JpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDpDÝI€I1Àé6‹5šëR¡š|—9Æu Vè¿ùÿÿ‰ÆƒÄˆØˆF¡‹H9HrPèú«ƒÄƒøÿu
»ÿÿÿÿ됐¡‹P¶ÿ@¡ˆ’öX u£ƒû_tžƒû.t™Æÿ5SèîÂÿ5šèC£¨˜¸éÇšëB¡š€DCУš¡‹H9HrPèl«ƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@¡ˆ’ŠX$u²ÿ5Sèn¸é-ÇX˜ÿÿÿÿ¡‹H9HrP諃ăøÿu»ÿÿÿÿ롐‹P¶ÿ@1ÿƒû\…O¡‹H9HrPèÔªƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@ƒû7}ƒû/~xƒû7=ƒû/Ž4|ûС‹H9HrP聪ƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ÿÿ…ÿ}Wh@A蟃ăû7Ùƒû/¢éϐƒûtu ¿ éoƒûnu ¿
é_ƒûau ¿éOƒûru ¿
é?ƒûfu ¿ é/ƒûbu ¿éƒûvu ¿ 鐃ûx…¿¡‹H9HrP訩ƒÄƒøÿ„ˆ¡‹P¶ÿ@ƒû9ƒû/ƒû`~ƒûz~
ƒû@~gƒûZbÁçƒû9ƒû/~ |;Ðë!ƒû`~ ƒûz|;©ëƒû@~ ƒûZ|;Ɂÿÿ…ÿoÿÿÿWhcAèsƒÄé\ÿÿÿ»ÿÿÿÿ끐ÿ5Sè8ÀëEƒû\u¿\ë:ƒû'u¿'ë.ƒû"u¿"ë"ƒû~ƒû
Sh…A됐Sh£Aè
ƒÄ¡‹H9Hr5P裨ƒÄƒøÿt ë%‰ß¡‹H9HrP胨ƒÄƒøÿu»ÿÿÿÿ롐‹P¶ÿ@ƒû't
hÛAè_ƒÄ‹5šÆ'Fƒÿ\u
Æ\FÆ\鿐ƒÿ'uÆ\FÆ'魐ƒÿ~ƒÿt
‰ùˆÈ镐ƒÿ uÆ\FÆt酐ƒÿ
u Æ\FÆnëtƒÿ
u Æ\FÆrëdƒÿ u Æ\FÆvëTƒÿu Æ\FÆbëDƒÿ u Æ\FÆfë4‰ø‰òF…ÿ}G?Áè0ˆ‰ø‰òF…ÿ}GÁè$0ˆ‰ùˆÈ$0ˆFÆ'ÆFÿ5šèÿˆ£¨˜Æ@fƒx…­ûÿÿf‰xé¤ûÿÿ¸é?¸é3¸é'¸é¡‹H9HrP觃ăøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ƒû
uÿșƒû t¾ƒû
t¹ƒû t´ƒû{u ¸龐ÿ5Sèè½é§‹5š¡‹H9HriP菦ƒÄƒøÿtTëYƒû
tƒûÿu
hBèxƒÄ¡š|—9Æu Vèôÿÿ‰ÆƒÄˆØˆF¡‹H9HrPè;¦ƒÄƒøÿu»ÿÿÿÿ롐‹P¶ÿ@ƒû>u•Æ¸ëè{됸eô[^_ÉÃtokentermntermtypeguardunionexpectstartleftrightnonassocbinarysemantic_parserpure_parserprecU‰åWVS‹5š¡‹P9PrPèm¥ƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ƒû2„1ƒû%t6ƒû0„ïëCƒû=„o
ƒû<„´ë*ƒû>„ǃû{të¸éK¸é?¡ˆ’ŠX$„ ¡š|—9Æu Vèsòÿÿ‰ÆƒÄˆØˆF¡‹P9PrP认ƒÄƒøÿu
»ÿÿÿÿ됐¡‹P¶ÿ@¡ˆ’ŠX$u¢ƒû_tÿ5S詻Ƌ5š¿­J¹ó¦t‹5š¿³J¹ó¦u
¸ 鉋5š¿¸J¹ó¦u ¸
ék‹5š¿¾J¹ó¦u ¸ éK‹5š¿ÃJ¹ó¦u ¸ é+‹5š¿ÉJ¹ó¦u ¸
é ‹5š¿ÏJ¹ó¦u ¸é됐‹5š¿ÖJ¹ó¦u ¸éː‹5š¿ÜJ¹ó¦u ¸髐‹5š¿áJ¹ó¦u ¸鋐‹5š¿çJ¹ ó¦t‹5š¿ðJ¹ó¦u¸ëZ‹5š¿÷J¹ó¦u¸ë>‹5š¿K¹ ó¦u¸ë"‹5š¿K¹ó¦t¸ë¸eô[^_ÉÃU‰åVS‹u‹] 萋£Ì™Çð™ÇșSVè2ÞÿÿèÙÖÿÿèô9è³pèrÔÿÿèy訳ÿÿèàÿÿèþÀÿÿƒÄƒ=ø˜t
è+됐èÿ*è"ÿ5ð™èÓÚÿÿeø[^ÉÃfatal error: %s
"%s", line %d: %s
U‰å‹Eƒ=P™uPhˆNh„”è­¸ƒÄ ëPÿ5șÿ5P™h™Nh„”茸ƒÄjè^ÚÿÿÉÃU‰åìÈSÿu(ÿu$ÿu ÿuÿuÿuÿuÿu ÿu8ÿÿÿS蹃Ä(Sèzÿÿÿ‹4ÿÿÿÉÃlimit of %d exceeded, too many %sU‰åìÈSÿuhÿh:O8ÿÿÿS蹸Sè'ÿÿÿ‹4ÿÿÿÉÃinternal error, %s
U‰åÿuhOh„”迷讗ÉÃU‰åƒìWVSÿ54šèpºÿÿ+Й£Ø˜‹54šuPèRºÿÿ‰Eø‰Eä‰Eü¡@š@ÀPè;ºÿÿ‰Eè‹=4š½Pè%ºÿÿ‹5Йµ)ЉEô¡@™4šÅPèû¹ÿÿ‰Eð‹]ð‹
䙃Äfƒ9„Š}4¿÷؋š¿BƒÁ…À|ދؘ€<uÒÆ‹}äf‰ƒEä됐‰Mì0Òë 9Й~²¿ƒÁ…Àì„Òu ‰Â÷ڋMì됐‹uèfÿV‹}ô‹4‡‰3f‰S‰‡ƒÃ¿ƒÁ…ÀÝélÿÿÿ‹}ä9}üsT‹uü¿‹}ô‹‡ƒEü…Ût8¿S‹‹uèfÿ Vuí¡š¿P…À|à‹ؘ€<uÔÆ‹}äf‰ƒEäëċuä9uür¬ƒ}øt ÿuøèv“ƒÄƒ}èt ÿuèèe“ƒÄ‹=Й½Eôt PèJ“ƒÄƒ}ðtÿuðè9“eØ[^_ÉÃU‰å¡Ø˜ЙtPè“ÉÃ
#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
U‰åƒ=4™tÿ5H˜h´Qÿ5èb³ƒÄ ÿ5H˜¸PSƒ=4™t¸¬RPÿ5è:³ƒÄ ƒ=™„‡ÿ5™hcSÿ5 è³ÿ5™h|Sÿ5 èþ²ÿ5™h‘Sÿ5 è貃Ä$ÿ5™hªSÿ5 èϲÿ5™hÁSÿ5 è¹²ÿ5™hØSÿ5 裲ÉÐ
}
}

}
U‰åƒ=4™t$hØTÿ5èt²hØTÿ5èd²ÉАhâTëê#ifndef YYDEBUG
#define YYDEBUG %d
#endif

#include "%s"
#include

#ifndef __STDC__
#define const
#endif

U‰åSƒ=4™usÿ5èX´ƒÄ¡‹X9XrPèݚƒÄƒøÿu ¹ÿÿÿÿ됐¡‹P¶
ÿ@ƒùÿt-‹ ‹Z9Zr¶ÁPRèEœƒÄ묡 ‹Pˆ
ÿ@띐ƒ=(št•À%ÿPh Uÿ5 è>±ƒÄ ƒ=4™tÿ5H˜hLUÿ5 è±ƒÄ h[Uÿ5 è ±hpUÿ5 èù°è,"ès è
葃=ä™tÿ5ä™è%ŽƒÄƒÄƒ=4™tèè<è èè-!‹]üÉÃ
#define YYTRANSLATE(x) ((unsigned)(x) <= %d ? yytranslate[x] : %d)

static const char yytranslate[] = { 0
static const short yytranslate[] = { 0%6d
};

#define YYTRANSLATE(x) (x)
U‰åVSƒ=X˜„öÿ5@˜ÿ5,šhÔVÿ5 貯ƒÄƒ=Й~
hW됐hDWÿ5 茯ƒÄ»
¾95,šŒ’¡ ‹H9Hrj,Pè+šƒÄ됐¡ ‹PÆ,ÿ@ƒû ~5¡ ‹H9Hrj
Pèü™ƒÄ됐¡ ‹PÆ
ÿ@»ëC¡\˜¿pPhpWÿ5 èñ®ƒÄ F95,šqÿÿÿhtW됐hyWÿ5 èÈ®eø[^ÉÃ
#if YYDEBUG != 0
static const short yyprhs[] = { 0
#endif

static const short yyrhs[] = {%6d 0U‰åVSƒ=4™uh·Xÿ5 è6®ƒÄhÉXÿ5 è#®»
¾ƒÄ95@šŒ‘¡ ‹H9Hrj,Pè؃Ä됐¡ ‹PÆ,ÿ@ƒû ~5¡ ‹H9Hrj
P蔘ƒÄ됐¡ ‹PÆ
ÿ@»ëC¡à™¿pPhpWÿ5 艭ƒÄ F95@šqÿÿÿhtWÿ5 èi­ƒÄƒ=4™uhðXÿ5 èM­ƒÄ¡ä™¿PhùXÿ5 è1­»
‹5ä™ƒÆƒÄ fƒ>„¦¡ ‹H9Hrj,PèϗƒÄ됐¡ ‹PÆ,ÿ@ƒû ~5¡ ‹H9Hrj
P蠗ƒÄ됐¡ ‹PÆ
ÿ@»ëCfƒ>~¿PhpWÿ5 蕬ƒÄ ëhYÿ5 耬ƒÄƒÆfƒ>…\ÿÿÿhtWÿ5 è`¬eø[^ÉÃ
static const short yystos[] = { 0U‰åVSh[ÿ5 è¬»
¾ƒÄ95P˜Ž‘¡ ‹H9Hrj,P軖ƒÄ됐¡ ‹PÆ,ÿ@ƒû ~5¡ ‹H9Hrj
P茖ƒÄ됐¡ ‹PÆ
ÿ@»ëC¡´˜¿pPhpWÿ5 聫ƒÄ F95P˜qÿÿÿhtWÿ5 èa«eø[^ÉÃ
#if YYDEBUG != 0
static const short yyrline[] = { 0
};

static const char * const yytname[] = { "%s"\%c\n\t\b\%03o
};
#endif

static const short yyr1[] = { 0
};

static const short yyr2[] = { 0%6d
};
U‰åWVSh\ÿ5 èfª¾
¿ƒÄ9=@šŒ¡ ‹H9Hrj,P蕃Ä됐¡ ‹PÆ,ÿ@ƒþ ~5¡ ‹H9Hrj
PèؔƒÄ됐¡ ‹PÆ
ÿ@¾ëF¡Ä™¿xPhpWÿ5 èÍ©ƒÄ G9=@šqÿÿÿ¡ü™ÿ0hS\ÿ5 覩¡ü™ÿ0è⁉ƃÆ,¿ƒÄ9=@˜Œ•¡ ‹H9Hrj,Pè;”ƒÄ됐¡ ‹PÆ,ÿ@FƒþK~,¡ ‹H9Hrj
Pè ”ƒÄ됐¡ ‹PÆ
ÿ@1ö¡ ‹H9Hrj"PèߓƒÄ됐¡ ‹PÆ"ÿ@F¡ü™‹¸é½€;"t€;\u"¾Ph‡\ÿ5 èΨƒÆƒÄ 铐€;
uh‹\ë€; uhŽ\ë
€;uh‘\ÿ5 蓨ƒÆƒÄë[€;~€;~~¾Ph”\ÿ5 èj¨ƒÆƒÄ ë2‹ ‹J9Jr¶PR蓃Ä됐¡ ‹PŠ ˆ
ÿ@FC…Ût €;…6ÿÿÿ¡ ‹H9Hr
j"PèݒƒÄë¡ ‹PÆ"ÿ@FG9=@˜lþÿÿhš\ÿ5 èܧ¾
¿ƒÄ9=@šŒ’¡ ‹H9Hrj,Pè{’ƒÄ됐¡ ‹PÆ,ÿ@ƒþ ~5¡ ‹H9Hrj
PèL’ƒÄ됐¡ ‹PÆ
ÿ@¾ëF¡š¿xPhpWÿ5 èA§ƒÄ G9=@šqÿÿÿ¡šƒÀt Pèu„ƒÄhÊ\ÿ5 è§¾
¿ƒÄ9=@šŽ˜¡ ‹H9Hrj,P译ƒÄ됐¡ ‹PÆ,ÿ@ƒþ ~5¡ ‹H9Hrj
P耑ƒÄ됐¡ ‹PÆ
ÿ@¾ëF¡à™¿Tx¿x)ÂJRhpWÿ5 èm¦ƒÄ G9=@šiÿÿÿ¡ ‹H9Hrj,P葃Ä됐¡ ‹PÆ,ÿ@ƒþ ~+¡ ‹H9Hrj
Pè萃Ä됐¡ ‹PÆ
ÿ@‹@š¡à™¿P‹
@™)Á‰ÈHPhó\ÿ5 è×¥¡à™ƒÀtP胍eô[^_ÉÃ

#define YYFINAL %d
#define YYFLAG %d
#define YYNTBASE %d
U‰åÿ5À™h¹aÿ5 èc¥h€ÿÿhÐaÿ5 èN¥ÿ5Йhäaÿ5 è8¥ÉАU‰å¡P˜4š£ˆ—ÁàPèä§ÿÿ£—‹ˆ—•Pȩ̀ÿÿ£”—‹ˆ—UPè´§ÿÿ£˜—‹ˆ—UP蜧ÿÿ£œ—èúè9ètƒ=štÿ5šèüƒÄƒ=ô˜tÿ5ô˜è偃ă=L™tÿ5L™è΁ƒÄƒ=´˜tÿ5´˜跁ƒÄè#‹ЙU™t P蔁ƒÄƒ=ܘtÿ5ܘè}ƒÄƒ=è˜tÿ5è˜èfƒÄè–èyè(
èèJÉÃ
static const short yydefact[] = {%6dU‰åVS‹
ЙMP耦ÿÿ£ —jèôPh„cÿ5 藣jè\¾
»ƒÄ9P˜Ž•¡ ‹H9Hrj,Pè/ŽƒÄ됐¡ ‹PÆ,ÿ@ƒþ ~5¡ ‹H9Hrj
P莃Ä됐¡ ‹PÆ
ÿ@¾ëFSèUPhpWÿ5 èø¢S较ÄC9P˜nÿÿÿhtWÿ5 èÒ¢ƒ= —t ÿ5 —耍eø[^ÉÃU‰åƒì,WVSÇEè1Û9Й~¡ —fÇXC9ЙñÇEôÇEð¡T˜‹}‹<¸‰}ì…ÿ„—¿‰}ð…ÿŽˆ¡š‹}¿ 1Û9Ë}‹5 —¿DZfÇF€C9Ë|ðƒ}ðŽ½ƒ}è…³¡Ü™‹}€<t‹}쿉}ô閐ÇEԋ]ü9]ø~S‹=L™‰}܋= —‰}ؐ1ɋ}Ü¿4_÷Þ1Ò9Й~‹}Ø¿W9ðuAB9Йë9MÔ}‰MԉuôC9]øƒ}Ô~+1Ò9Й~‹
 —¿Q9EôufÇQB9Йè÷]ôƒ}ôu*1ҋ}ô9=Й~¡ —f static const short yydefgoto[] = {%6dU‰åWVS‹
P˜MPèë¡ÿÿ£¤—ÿ5Йèÿ‰ÃShhÿ5 èüžSÿ5Йè|¿
‹5ЙFƒÄ95@˜Ž–¡ ‹H9Hrj,P菉ƒÄ됐¡ ‹PÆ,ÿ@ƒÿ ~5¡ ‹H9Hrj
Pè`‰ƒÄ됐¡ ‹PÆ
ÿ@¿ëGVèY‰ÃShpWÿ5 èVžSVèۃÄF95@˜kÿÿÿhtWÿ5 è/žƒ=¤—t ÿ5¤—èo{eô[^_ÉÃU‰åVS‹U¡™¿ P¿\P9Ùu
¸ÿÿÿÿër1Ò9P˜~¡¤—fÇPB9P˜ñ‰Ê9Ú}‹5蘋
¤—¿VfÿAB9Ú|ó1À»ÿÿÿÿ1Ò9P˜~‹5¤—¿ V9Á~‰È‰ÓB9P˜ë‰Øeø[^ÉÃU‰åƒìWVS¡™‹u¿4p‰uü‹]¿\X‰]ø1ÿ‹Uü9Ú}‹
蘐¿Q9E tGB9Uøð…ÿ„«‹u+5Й‰uð‹P˜]ð4}Vèҟÿÿ‹—‰Eô‰Eè‹]ð‰šV躟ÿÿ‹”—‰Á‰ š‹Uü9Uø~9¡è˜¿P9E t"¡Ü˜f‹P‹uèf‰ƒEè¡è˜f‹Pf‰ƒÁB9UøÊ¡˜—‹]ðf‰ Œ—Ix6¿K‹}ô¿G9Eðí됐I…É|¿K‹}ô¿W9Eðu ‹}ø¿W9Eüß¡Œ—ë f‹ žÿÿ£¸—Ǽ—ÇÀ—1ۃÄ9ˆ—~¡¬—fÇX€C9ˆ—ñ1Û¡¸—fÇXÿÿCûþ~ñ1Û9Œ—~LSè҉ƒÄ…Ò}
Sè ‰ÁƒÄë ¡¬—¿ P¡°—f‰ X¡¨—¿X¡¬—f‰ PC9Œ—·1Û9ˆ—~:¡—ƒ<˜t
t ÿ4˜èÇwƒÄ¡”—ƒ<˜t
t ÿ4˜è¯wƒÄC9ˆ—ǃ=—tÿ5—èwƒÄƒ=”—tÿ5”—èxwƒÄƒ=°—t ÿ5°—èaweø[^ÉÃU‰åƒì$WVS‹M¡¨—¿H‰Eü9P˜é搐‰ðéᐡ˜—‹]ü¿X‰]ø¡œ—‹Uü¿P‰Uôyÿ…ÿŒ²‹”—‰]ð‹—‰U䐡¨—¿4x¡œ—¿p9Eô…„¡˜—¿p9EøuvÇEà1É9Mø~W‹]ð‹³‰]ì‹Uü‹]ð‹“‰Uè‹Uèf‹J‹Uìf9Ju‹U䋲‰U܋]ü‹Uä‹šf‹H‹]Üf9KtÇEàAƒ}àt9Mø¾ƒ}à…$ÿÿÿO‰aÿÿÿ¸ÿÿÿÿeÐ[^_ÉÃpack_vectormaximum table size (%d) exceededU‰åƒìWVS¡¨—‹M¿H¡˜—¿X‰Eø…Àu
hŒnè¹àÿÿƒÄ¡—‹˜‰Eô¡”—‹˜‰]ð‹Uô¿‹
¼—)Á‰Müùþ¾1Û9]ø~>‹Uô¿Z‹}üǁÿÿ~hÿh˜nè¥ßÿÿƒÄ¡´—fƒ °—‰M쐐‹Uì¿Z9Eüu1öC…ö„9]ä…ö„€1Û9]ø~<‹5´—‹
¸—‰M쐐‹Uô¿Z‹}üNjMðf‹Yf‰~‹Môf‹Y‹Mìf‰yC9]øՋ¼—¡´—‰Ãfƒ static const short yypact[] = {%6d
};

static const short yypgoto[] = {%6dU‰åVS¡¬—¿PhPpÿ5 躖»
¾ƒÄ 95P˜Ž¡ ‹H9Hrj,Pè[ƒÄ됐¡ ‹PÆ,ÿ@ƒû ~5¡ ‹H9Hrj
Pè,ƒÄ됐¡ ‹PÆ
ÿ@»ëC¡¬—¿pPhpWÿ5 è!–ƒÄ F95P˜qÿÿÿ¡P˜‹¬—¿BPhtpÿ5 èñ•»
‹5P˜FƒÄ 95ˆ—Ž‘¡ ‹H9Hrj,P菀ƒÄ됐¡ ‹PÆ,ÿ@ƒû ~5¡ ‹H9Hrj
Pè`€ƒÄ됐¡ ‹PÆ
ÿ@»ëC¡¬—¿pPhpWÿ5 èU•ƒÄ F95ˆ—qÿÿÿhtWÿ5 è5•ƒ=¬—t ÿ5¬—èureø[^ÉÃ

#define YYLAST %d


static const short yytable[] = {%6dU‰åVSÿ5À—h^rÿ5 èÁ”¡´—¿Phurÿ5 訔»
¾ƒÄ95À—Œ’¡ ‹H9Hrj,PèGƒÄ됐¡ ‹PÆ,ÿ@ƒû ~5¡ ‹H9Hrj
PèƒÄ됐¡ ‹PÆ
ÿ@»ëC¡´—¿pPhpWÿ5 è
”ƒÄ F95À—qÿÿÿhtWÿ5 è퓃=´—t ÿ5´—è-qeø[^ÉÃ
static const short yycheck[] = {%6dU‰åVS¡¸—¿Ph¦sÿ5 莓»
¾ƒÄ 95À—Œ¡ ‹H9Hrj,Pè/~ƒÄ됐¡ ‹PÆ,ÿ@ƒû ~5¡ ‹H9Hrj
Pè~ƒÄ됐¡ ‹PÆ
ÿ@»ëC¡¸—¿pPhpWÿ5 èõ’ƒÄ F95À—qÿÿÿhtWÿ5 èՒƒ=¸—t ÿ5¸—èpeø[^ÉÃ#define YYPURE 1

#lin#li#l#U‰åVSƒ=<šth¾tÿ5 èz’ƒÄ¾¡‹H9HrPèˆ{ƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@ƒ=Ș„ ƒû#…¡‹H9HrPèA{ƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ƒûl…É¡‹H9HrPè{ƒÄƒøÿu
»ÿÿÿÿ됐¡‹P¶ÿ@ƒûi……¡‹H9HrPèÊzƒÄƒøÿu
»ÿÿÿÿ됐¡‹P¶ÿ@ƒûnuE¡‹H9HrPè’zƒÄƒøÿu
»ÿÿÿÿ됐¡‹P¶ÿ@ƒûeu1öë,hÑtëhÖtëhÚtëhÝtÿ5 è‘ƒÄƒû
„<ƒûÿ„k…ö„éƒû$…³ÿ5èp“¡‹H9HrPèùyƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ƒÄƒûÿ„—‹ ‹J9Jr¶ÃPRèX{ƒÄ됐‹ ‹BˆÿB¡‹H9HrPè‹yƒÄƒøÿu»ÿÿÿÿ닐‹B¶ÿBƒûÿuœë/‹ ‹J9Jr¶ÃPRèðzƒÄ됐¡ ‹Pˆÿ@¡‹H9HrPè$yƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@ƒû
t ƒûÿ…Ðþÿÿƒûÿt3‹ ‹J9Jr¶ÃPRèzé0ýÿÿ¡ ‹Pˆÿ@é"ýÿÿeø[^ÉÃ#line %d "%s"
U‰åSƒ=Șuÿ5P™ÿ5șhëwÿ5 èSƒÄ¡‹X9XrcPèixƒÄƒøÿtMëS‹ ‹Z9Zr¶ÁPRèèyƒÄ됐¡ ‹Pˆ
ÿ@¡‹X9XrPèxƒÄƒøÿu¹ÿÿÿÿ됡‹P¶
ÿ@ƒùÿu‹]üÉÃU‰åSƒ=Ԙtÿ5ԘèlƒÄ¡š…Àt‹…Àt PèìkƒÄ‰Ø…Àuë‹]üÉÃU‰åSƒ=(™tÿ5(™èÄkƒÄ¡X™…Àt‹…Àt Pè¬kƒÄ‰Ø…Àuë‹]üÉÃU‰åSƒ=T˜tÿ5T˜è„kƒÄ¡ ™…Àt‹…Àt PèlkƒÄ‰Ø…Àuë‹]üÉÃU‰å€= ™tèO›ÿÿÉÐU‰åS€= ™tè&œÿÿè%1Û9P˜~SèVƒÄC9P˜î‹]üÉà type %d is %s
U‰å‹U ¡ü™ÿ4ÿuh¿yÿ5臍ÉÐ

state %d

U‰åS‹]Shôyÿ5è\Sè.Sè„‹]üÉà %s -> %s %s (rule %d)U‰åƒìWVS‹U¡Ô˜‹‰Uô‰×¿ ‰}ø…ÿ„fÇEü9}ü0‹}ô‹Mü¿DOÀ‰Ã䙉]ðfƒ;~ ƒÃfƒ;÷¿3÷Þ¡š¿p¡ü™ÿ4h-zÿ5行¡à™¿pÀ‰Ãä™ƒÄ 9]ðv(¿¡ü™ÿ4h:zÿ5èiŒƒÄ ƒÃ9]ðwÚ¡‹H9Hr
j.PèwƒÄë1¡‹PÆ.ÿ@ë!¿¡ü™ÿ4h>zÿ5èŒƒÃƒÄ fƒ;ÙVhBzÿ5èü‹¡‹x9xrj
Pè·vƒÄ됐¡‹PÆ
ÿ@ƒÄ ÿEü‹Mø9MüŒÐþÿÿ¡‹x9xr j
Pè{v됡‹PÆ
ÿ@eä[^_Éà $default accept
NO ACTIONS
$ go to state %d
%-4s shift, and go to state %d
%-4s error (nonassociative)
$default reduce using rule %d (%s)

%-4s go to state %d
U‰åƒìWVS¡(™‹}‹<¸‰}ø¡T˜‹}‹<¸‰}ð¡À˜‹}‹<¸‰}ôƒ}øu=ƒ}ðu-‹}9=À™u
hæ{됐hû{ÿ5èhŠé鐐ƒ}ø„ž‹}ø¿‰}ü1ö9þ}`‹}øfƒ|wtM¿Tw¡´˜¿ P9
Й~=…ÉuRh |ÿ5èŠƒÄ ëR¡ü™ÿ4ˆh$|ÿ5èÄF9uü¢…ö~3¡‹x9xr
j
PètƒÄ롐‹PÆ
ÿ@ë 1öÇEüƒ}ôto‹}ô¿?‰}ì1Û9û}3‹}ôfƒ|_t ¿L_¡ü™ÿ4ˆhH|ÿ5èp‰ƒÄ C9]ìυÛ~)¡‹x9xrj
PètƒÄ됡‹PÆ
ÿ@¡Ü™‹}€<t8ƒ}ðtC‹}ð¿G‹š¿ B‹ü™ÿ4ŠPhi|ÿ5èûˆƒÄ됐ƒ}ðt ÿu讝ÿÿƒÄ9uü~d‹}øfƒ|wt*¿Tw¡´˜¿ PR¡ü™ÿ4ˆh’|ÿ5誈ƒÄF9uüÅ¡‹x9xr j
Pè\s됐¡‹PÆ
ÿ@eà[^_ÉÃ
Grammar
rule %-4d %s -> /* empty */
Terminals, with rules where they appear

%s (-1)
%s%s
(%d) %d%s

Nonterminals, with rules where they appear

on left:, on right:U‰åƒìpWVSÿ5h蓈ÇE ƒÄéÁ¡š‹M fƒzÿ5è‡ƒÄ fƒ;Ù됐ÿ5h èô‡ƒÄ¡‹H9Hrj
Pè¸qƒÄ됐¡‹PÆ
ÿ@ÿE ‹M 9
@š0ÿÿÿÿ5h.複¡ü™ÿ0hYÿ5虆ƒÄƒ=X˜„}ÇE ‹M 9
,šŒ³}¤¡\˜‹M fƒ ,š¤þÿÿéOÇE ‹M 9
ЙŽ6}¤ÆE¤¡ü™‹M ÿ4ˆè$]‰Eœ¡ü™‹M ÿ4ˆhbÿ5辄Wè]EœƒÄƒø2vWheÿ5蜄ÇEœÆE¤ƒÄ ÿu hlWè@…¾ƒÄ 95@šŒ†¡à™¿pÀ‰Ãä™fƒ;~`¿9E uLWèŠ\EœƒÄƒøAvWheÿ5è&„ÇEœÆE¤ƒÄ VhrWèT\ƒÄøPèÁ„ƒÄ ë ƒÃfƒ;£F95@šzÿÿÿWhvÿ5èՃƒÄ ÿE ‹M 9
ЙÐþÿÿÿ5hz褄‹
Й‰M ƒÄ¡@˜H9ÁÚ}¤ÇE˜ÇE”¾95@š|W‹
š‰M‹à™‹M¿q9E uÿE˜¿rÀ‰Ãä™fƒ;~¿9E uÿE”ë ƒÃfƒ;çF95@š}ºÆE¤¡ü™‹M ÿ4ˆhbÿ5èÿ‚¡ü™‹M ÿ4ˆè7[‰Eœÿu hlW螃Wè [EœƒÄ …ÀtWheÿ5轂ÇEœÆE¤ƒÄ ƒ}˜ŽºWèçZEœƒÄƒø2vWheÿ5胂ÇEœÆE¤ƒÄ h¨Wè²ZƒÄøP胾ƒÄ95@š|dWèŽZEœƒÄƒøAvWheÿ5è*‚ÇEœÆE¤ƒÄ ¡š¿p9E uVhrWèJZƒÄøP跂ƒÄ F95@š}Ÿƒ}”Žÿƒ}˜~h²WèZƒÄøP腂ƒÄWèZEœƒÄƒø2vWheÿ5蠁ÇEœÆE¤ƒÄ h´WèÏYƒÄøPè<‚¾ƒÄ95@šŒ†¡à™¿pÀ‰Ãä™fƒ;~`¿9E uLWè†YEœƒÄƒøAvWheÿ5è"ÇEœÆE¤ƒÄ VhrWèPYƒÄøP轁ƒÄ ë ƒÃfƒ;£F95@šzÿÿÿWhvÿ5èрƒÄ ÿE ¡@˜H9E Ž,ýÿÿe„[^_ÉÃerror$illegal.
/* A Bison parser, made from %s */

#define YYBISON 1 /* Identify Bison output. */


#ifndef YYLTYPE
typedef
struct yyltype
{
int timestamp;
int first_line;
int first_column;
int last_line;
int last_column;
char *text;
}
yyltype;

#define YYLTYPE yyltype
#endif

#define YYLSP_NEEDED

U‰åÇø™ÇؙÇX˜Ç@˜Ç4šÇ@šÇ@™Ç8š
j辁ÿÿ£Ä™ÇȗÇ̗ÇЗÇ4™Ç<šÇؗÇä˜è.µÿÿÇșè/IhĆèMI£Ô—Æ@fÇ@hʆè4IÆ@ÿ5P™hԆÿ5 èV~hü†ÿ5 èF~ƒÄ èh/‡ÿ5è.~è¥Êÿÿè(ƒÄƒ=ؗtƒ=th/‡ÿ5èÿ}ƒÄègËÿÿƒ=ؗthˆÿ5 èÞ}ƒÄèR.èý1è@IÉАjunk after `%%' in definition sectionno input grammarunknown character `%c' in declaration sectionunknown character with code 0x%x in declaration sectionU‰åèg´ÿÿƒø%…è±ÀÿÿƒÀùƒø‡íÿ$…|Š¨‹ÀŠÈŠÐŠ`‹äŠüŠðŠ‹‹‹`‹,‹P‹`‹`‹‹èO덐jj됐jj臃Äésÿÿÿèg éfÿÿÿèÛéZÿÿÿès éNÿÿÿèãéBÿÿÿjëjëjèI
ƒÄé)ÿÿÿƒ=4™…ÿÿÿÇ4™èäœÿÿéÿÿÿÇ<šéõþÿÿh°‰ë ƒøÿuh։è5ÃÿÿƒÄéÕþÿÿƒø~ƒø
Phç‰ëPhŠèYÃÿÿƒÄé­þÿÿÉА#line %d "%s"
unterminated stringunterminated comment in `%{' definitionunterminated `%{' definitionU‰åƒìWVSƒ=Șuÿ5P™ÿ5șh¬‹ÿ5è6{ƒÄÇEü¡‹H9HrPèEdƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@Cƒø0‡Ñÿ$…”ŒP‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘X]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘]‘œ]‘]‘]‘œ]‘]‘]‘]‘]‘]‘]‘‹‹J9Jr¶ÃPRèØdƒÄ됐¡‹Pˆÿ@ÿșéùÇEüÿÿÿÿéí‰Þ‹‹J9Jr¶ÃPRè’dƒÄ됡‹Pˆÿ@¡‹H9H‚þPèÄbƒÄƒøÿ„ãé琐ƒûÿtƒû
u
h»‹è¤ÀÿÿƒÄ‹‹J9Jr¶ÃPRè%dƒÄë
¡‹Pˆÿ@ƒû\uz¡‹H9HrPèWbƒÄƒøÿu»ÿÿÿÿ롐‹P¶ÿ@ƒûÿu
h»‹è3ÀÿÿƒÄ‹‹J9Jr¶ÃPRè´cƒÄ됐¡‹Pˆÿ@ƒû
uÿș¡‹H9HrPèÝaƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@9ó…ÿÿÿ‹‹J9Jƒkéw‹‹J9Jr¶ÃPRè(cƒÄ됐¡‹Pˆÿ@¡‹H9HrPè\aƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@ƒû*t ƒû/… ýÿÿƒû/”À¶ð‹‹J9Jr¶ÃPRè³bƒÄ됐¡‹Pˆÿ@¡‹H9HrPèè`ƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@1ÿ…ö…”ƒû*…‹‹‹J9Jr¶ÃPRè@bƒÄ됐‹‹BˆÿB¡‹H9HrPès`ƒÄƒøÿu»ÿÿÿÿ닐‹B¶ÿBƒû*tœƒû/…顐‹H9H‚j/Péúƒû
uWÿș¡‹H9Hrj
Pè°aƒÄ됐¡‹Pˆÿ@…ö…Ô¡‹H9HrvPèÜ_ƒÄƒøÿt`ëfƒûÿuhϋèɽÿÿƒÄë^‹‹J9Jr¶ÃPRèHaƒÄ됐¡‹Pˆÿ@¡‹H9HrPè|_ƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@…ÿ„Žþÿÿë9h÷‹èR½ÿÿƒÄ‹‹J9Jr¶ÃPRèÓ`ƒÄ됐¡‹Pˆÿ@¡‹H9HrPè_ƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@ƒ}üt.ƒû}t7¡‹H9Hrj%Pèn`ƒÄ됡‹PÆ%ÿ@ÇEüé†úÿÿeð[^_ÉÃsymbol %s redefinedtype redeclaration for %sinvalid text in %token or %nterm declarationU‰åWVS1ö1ÿÿ5èI¬ÿÿPè_uƒÄƒø%„‰ó萯ÿÿ‰ÆƒþtՃþu0ÿ5šèM@Pè–wÿÿ‰Çÿ5šWè|KÇėƒÄ롐ƒþu¡¨˜¾X9] uÿph’è ¼ÿÿƒÄ¡¨˜ŠUˆPƒ}uƒûtf‹4šf‰Pÿ4š…ÿ„Nÿÿÿ¡¨˜ƒx u ‰x é;ÿÿÿ¡¨˜ÿph’è²»ÿÿƒÄéÿÿÿƒûu'ƒþu"¡¨˜f‹šf‰PÇX˜éóþÿÿh2’è&»ÿÿƒÄéÞþÿÿeô[^_ÉÃmultiple %start declarationsinvalid %start declarationU‰åƒ=ø™t
h˜“èƺÿÿƒÄÇø™è(®ÿÿƒøt
hµ“襺ÿÿ‹¨˜‰ؙÉАill-formed %type declarationinvalid %type declarationU‰åSèÇ­ÿÿƒøt
h”èDºÿÿƒÄÿ5šèJK@PèÇuÿÿ‰Ãÿ5šSè­IƒÄÿ5è%ªÿÿPè;sƒÄƒø%tSèr­ÿÿƒøt݃øt
ë0ƒøu+ë͐¡¨˜ƒx u‰X 뼡¨˜ÿph’èºÿÿƒÄ륐h5”趹ÿÿƒÄ땐‹]üÉÃredefining precedence of %sinvalid text in association declarationmalformatted association declarationU‰åWVS1ö1Ûÿ̗ÿ5è9©ÿÿPèOrƒÄƒø%„W肬ÿÿ‰ÇGÿƒø‡0ÿ$…´•4–é–Ü–ð–Ü–Ü–Ü–Ü–Ü–Ü–Ü–Ü–Ü–Ü–Ü–Ü–Ü–Ü–Ü–Ü– –°–ÿ5šè©I@Pè&tÿÿ‰Æÿ5šVè HƒÄ鵡¨˜fƒxtÿph•è«¸ÿÿƒÄ¡¨˜f‹̗f‰Pf‹Uf‰P€xuÿph’è}¸ÿÿƒÄ¡¨˜Æ@…öt^ƒx u‰p ëS¡¨˜ÿph’èN¸ÿÿƒÄë:ƒûu¡¨˜f‹šf‰PÇX˜ëh•ëhE•èÆ·ÿÿƒÄ‰ûéŒþÿÿeô[^_ÉÃmultiple %union declarations
#line %d "%s"

typedef unionunterminated commentunmatched close-brace (`}') YYSTYPE;
U‰åƒìWVSƒ=ȗt
hø–è·ÿÿƒÄÇȗƒ=Șu"ÿ5P™ÿ5șh—ÿ5è¶oƒÄëh%—ÿ5è oƒÄh'—ÿ5èoƒÄƒ=th'—ÿ5èqoƒÄÇEü¡‹H9H‚®Pè|XƒÄƒøÿ„“闐‹‹J9Jr¶ÃPRèôYƒÄ됐¡‹Pˆÿ@ƒ=t+‹‹J9Jr¶ÃPRè¾YƒÄ됡‹Pˆÿ@ƒû{„šƒû
tƒû/t"éõƒû}„‡é搐ÿșéِ¡‹H9HrPè½WƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ƒû*tƒû/tÿ5SèÀnƒÄ鈋‹J9Jr¶ÃPRè YƒÄ됐¡‹Pˆÿ@ƒ=t+‹‹J9Jr¶ÃPRèÖXƒÄ됡‹Pˆÿ@ƒû/”À¶ø¾¡‹H9HrPèþVƒÄƒøÿu
»ÿÿÿÿ됐¡‹P¶ÿ@…ö„ސƒû
u ÿș…ÿt1öƒûÿu
h5—è¼´ÿÿƒÄ‹‹J9Jr¶ÃPRè=XƒÄë
¡‹Pˆÿ@ƒ=t+‹‹J9Jr¶ÃPRè
XƒÄ됡‹Pˆÿ@…ÿ…«ƒû*…¢¡‹H9HrPè/VƒÄƒøÿu»ÿÿÿÿ롐‹P¶ÿ@ƒû/…›¡‹H9Hrj/Pè˜WƒÄ됐¡‹PÆ/ÿ@ƒ=„Ù¡‹H9Hrj/Pè`WƒÄ鼡‹PÆ/ÿ@驐¡‹H9HrPèUƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@…ö…’þÿÿëlÿEüëgƒ}üu
hJ—èT³ÿÿƒÄÿMüuLhf—ÿ5èlƒÄƒ=thf—ÿ5èìkƒÄè,£ÿÿ‰Ãƒû;tLÿ5Sè5lë>¡‹H9HrPèåTƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ƒûÿ…Uüÿÿeð[^_ÉÃU‰åƒìS¡‹H9Hr4PèšTƒÄƒøÿtë$¡‹H9HrPè}TƒÄƒøÿu ºÿÿÿÿ됐¡‹P¶ÿ@ƒú tɃú tÄ1Ûë:ƒûˆT+ìC¡‹H9HrPè3TƒÄƒøÿuºÿÿÿÿ롐‹P¶ÿ@ƒú/~ƒú9~¼ÆD+ìÿ5Rè3kEìPèÆK£™‹]èÉÃinvalid $ valueU‰åWVS‹}…ÿ}ÿ5ԐèȱÿÿƒÄ‹] 1ö9þ}‹…Ûtƒ{uÿ5Ԑ襱ÿÿƒÄF9þ|á‹C‹@ eô[^_ÉÃ
case %d:
unmatched right brace ('}')yyval.%s%s:%d: warning: $$ of '%s' has no declared type.
yyvsp[%d]%s:%d: warning: $%d of '%s' has no declared type.
$%c is invalid@%c is invalidyylsp[%d]unterminated %guard clause;
break;}U‰åƒìWVSÇEøƒ=4™tÇE ÿ5@šhÿ5è.iƒÄ ƒ=Șuÿ5P™ÿ5șh¬‹ÿ5èiƒÄ¡‹H9Hrj{Pè¾SƒÄ됡‹PÆ{ÿ@1ÿéԐƒû;„‡ƒû/„’@ƒû$„ß%ƒû"„ëƒûÿ„Õƒû
t<éؐƒû'„ëéǐƒû{tWƒû@„à鰐ƒû}t{飐‹‹J9Jr¶ÃPRèSƒÄ됐¡‹Pˆÿ@ÿșé•‹‹J9Jr¶ÃPRèØRƒÄ됐¡‹Pˆÿ@ÇEøGé[‹‹J9Jr¶ÃPRèœRƒÄ됐¡‹Pˆÿ@…ÿ~Oé"h(èÖ®ÿÿƒÄ鐐‰Þ‹‹J9Jr¶ÃPRèNRƒÄ됡‹Pˆÿ@¡‹H9H‚þPè€PƒÄƒøÿ„ãé琐ƒûÿtƒû
u
h»‹è`®ÿÿƒÄ‹‹J9Jr¶ÃPRèáQƒÄë
¡‹Pˆÿ@ƒû\uz¡‹H9HrPèPƒÄƒøÿu»ÿÿÿÿ롐‹P¶ÿ@ƒûÿu
h»‹èï­ÿÿƒÄ‹‹J9Jr¶ÃPRèpQƒÄ됐¡‹Pˆÿ@ƒû
uÿș¡‹H9HrPè™OƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@9ó…ÿÿÿ‹‹J9Jƒ‹é—‹‹J9Jr¶ÃPRèäPƒÄ됐¡‹Pˆÿ@¡‹H9H‚ŽPèOƒÄƒøÿ„uéw¡‹H9HrPèíNƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@1öƒû<……‹5š¡‹H9HrPè©NƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ƒû>t
…Û~ ˆØˆF뾐Æ‹5š¡‹H9HrPè\NƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@ƒû$uyhDÿ5èýdƒÄ…öu
‹M‹A‹p …ötVhJÿ5èØdƒÄ …ö…Bƒ=ȗ„5‹M‹Aÿpÿ5șÿ5P™hNh„”èœdƒÄé ¡ˆ’ŠX$u ƒû-…ßÿ5Sè×dÿ5è4‰Eü¡‹H9HrPè~MƒÄƒøÿu
»ÿÿÿÿ됐¡‹P¶ÿ@ƒÄ …öuƒ}ü~ÿuÿuüènùÿÿ‰ÆƒÄ‹Eü+E Ph‚ÿ5èþcƒÄ …ötVhJÿ5èæcƒÄ 錐ƒ=ȗ„}‹M‹Aÿpÿuüÿ5șÿ5P™hŒh„”è¨cƒÄéNShÁè«ÿÿƒÄ鐡‹H9HrPè¥LƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@¡ˆ’ŠX$uƒû-uQÿ5Sè¡cÿ5èþ‰Eü¡‹H9HrPèHLƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@ƒÄ ëShНèmªÿÿƒÄ‹Eü+E Phߝÿ5èÓbÇؗƒÄ ërhéèî©ÿÿƒÄ‹‹J9Jr¶ÃPRèoMƒÄ됐¡‹Pˆÿ@ƒû}u…ÿt0¡‹H9HrPè›KƒÄƒøÿu»ÿÿÿÿ롐‹P¶ÿ@ƒ}ø„xùÿÿ…ÿyùÿÿ胙ÿÿ‰Ãhžÿ5è)bƒÄƒû{t<ƒû=uD¡‹H9HrPè5KƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ƒû{uÿu ÿuè:ë ÿ5Sè0beì[^_ÉÃinvalid @-constructunmatched '{'U‰åƒìWVSƒ=4™tÇE ÿ5@šhÿ5èqaƒÄ ƒ=Șuÿ5P™ÿ5șh¬‹ÿ5èIaƒÄ¡‹H9Hr
j{PèLƒÄ롐‹PÆ{ÿ@ÇEü¡‹H9H‚®Pè,JƒÄƒøÿ„”闐ƒû'„Ë1ƒû"„Àƒûÿ„­ƒû
t@鰐ƒû$„w韐ƒû@„¿ƒû/„ü鄐ƒû{t?éw‹‹J9Jr¶ÃPRè@KƒÄ됐¡‹Pˆÿ@ÿșéi‹‹J9Jr¶ÃPRèKƒÄ됐¡‹Pˆÿ@ÿEüé4‰Þ‹‹J9Jr¶ÃPRèÎJƒÄ됡‹Pˆÿ@¡‹H9HrPèIƒÄƒøÿ„ô¡‹P¶ÿ@éøƒûÿtƒû
u
h»‹èئÿÿƒÄ‹‹J9Jr¶ÃPRèYJƒÄ닐‹BˆÿBƒû\u~¡‹H9HrPèŠHƒÄƒøÿu
»ÿÿÿÿ됐‹‹B¶ÿBƒûÿu
h»‹èb¦ÿÿƒÄ‹‹J9Jr¶ÃPRèãIƒÄ됐‹‹BˆÿBƒû
uÿș¡‹H9HrPè HƒÄƒøÿu»ÿÿÿÿ됋‹B¶ÿB9ó…ÿÿÿ‹‹J9Jƒ¢é®‹‹J9Jr¶ÃPRèXIƒÄ됐¡‹Pˆÿ@¡‹H9HrPèŒGƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@ƒû*t ƒû/…~ƒû/”À¶ð‹‹J9Jr¶ÃPRèãHƒÄ됐¡‹Pˆÿ@¡‹H9HrPèGƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@…ö…¤ƒû*…›‹‹J9Jr¶ÃPRèpHƒÄ됐‹‹BˆÿB¡‹H9HrPè£FƒÄƒøÿu»ÿÿÿÿ닐‹B¶ÿBƒû*tœƒû/…ú¡‹H9Hr
j/Pé6‹‹BˆÿBé:ƒû
uWÿș¡‹H9Hrj
PèÐGƒÄ됐‹‹BˆÿB…ö…û¡‹H9HruPèûEƒÄƒøÿt`ëeƒûÿuh5—èé£ÿÿƒÄë_‹‹J9Jr¶ÃPRèhGƒÄ됐‹‹BˆÿB¡‹H9HrPè›EƒÄƒøÿu»ÿÿÿÿ닐‹B¶ÿB1ɅÉ„{þÿÿé[¡‹H9HrPèYEƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@1öƒû<…‘‹5š¡‹H9HrPèEƒÄƒøÿu »ÿÿÿÿ됐‹‹B¶ÿBƒû>t …Û~ˆØˆF뽐Æ‹5šÇė¡‹H9HrPè¾DƒÄƒøÿu
»ÿÿÿÿ됐¡‹P¶ÿ@ƒû$…hDÿ5èY[ƒÄ…öuÿujèœðÿÿ‰ÆƒÄ…ötVhJÿ5è.[ƒÄ …ö…<ƒ=ȗ„/‹M‹Aÿpÿ5șÿ5P™hNh„”èòZƒÄ鐐¡ˆ’ŠX$u ƒû-…×ÿ5Sè+[ÿ5èˆ‰Ç¡‹H9HrPèÓCƒÄƒøÿu»ÿÿÿÿ롐‹P¶ÿ@ƒÄ …öu…ÿ~ÿuWèÊïÿÿ‰ÆƒÄ‰ø+E Ph‚ÿ5è[ZƒÄ …ötVhJÿ5èCZƒÄ 酐ƒ=ȗ„u‹M‹AÿpWÿ5șÿ5P™hŒh„”èZƒÄéHShÁèq¡ÿÿƒÄ鐡‹H9HrPèCƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@¡ˆ’ŠX$uƒû-uQÿ5SèýYÿ5èZ‰Ç¡‹H9HrPè¥BƒÄƒøÿu »ÿÿÿÿ됐¡‹P¶ÿ@ƒÄ ëh´¥è~ ÿÿƒÄ‰ø+E Phߝÿ5è1YÇؗƒÄ ëlhÈ¥èJ ÿÿƒÄ‹‹J9Jr¶ÃPRèËCƒÄ됐¡‹Pˆÿ@¡‹H9HrPèBƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@ƒû}…Á÷ÿÿÿMütd‹‹J9Jr¶ÃPRè`CƒÄ됐¡‹Pˆÿ@¡‹H9HrPè”AƒÄƒøÿu»ÿÿÿÿ됡‹P¶ÿ@ƒ}üŽhžÿ5è4Xeð[^_ÉÃ@%dU‰åÿЗÿ5ЗhL¯ÿ5šèÉXÿ5šèÂ"Æ@f‹4šf‰Pÿ4šÉАill-formed rulegrammar starts with vertical barrule given for %s, which is a token%guard present but %semantic_parser not specifiedtwo actions at end of one rule%s:%d: warning: type clash ('%s' '%s') on default action
%s:%d: warning: empty rule for typed nonterminal, and no action
invalid inputtoo many symbols (tokens plus nonterminals); maximum %d#ifndef YYSTYPE
#define YYSTYPE int
#endif
symbol %s used, not defined as token, and no rules for it
U‰åƒì WVSÇEø魐ƒþt ƒþ…BÇEìÇEèÇEäÇEàƒþu"‹
¨˜‰Müècÿÿ‰Æƒþt
h”¯èޜÿÿƒÄƒ=@šu$ƒþu
h¤¯èÜÿÿƒÄƒ=ø™u ‹Uü‰ؙÿ@šÿ@™è5j è.Xÿÿ‰Ã‹Mü‰K‹Uø‰UðƒÄ…Òt‰ë‰ä˜‰]ø‰]ô‹Mü€yuÆAf‹4šf‰Qÿ4šë‹Mü€yuÿqhů膜ÿÿƒÄè£ÿÿ‰Æƒþt ƒþ…óë/‹=¨˜腏ÿÿ‰ÃS腎ÿÿ‰=¨˜ƒÄƒû„˃}àu‰}àƒ}ìtrè‡üÿÿ‰Çÿ@šÿ@™èhj èaWÿÿ‰ÃƒÄƒ}ðt
‹Uð‰ë ‰ä˜‰{j è ¨˜‰K‹Uø‰‰]øƒÄëÿuèÿuôèmòÿÿÇEìÿEäƒÄÿEèéøþÿÿj è½Vÿÿ‰Ã‹Mø‰‰]øƒÄƒþu肎ÿÿ‹
¨˜‹Uô‰JèqŽÿÿ‰Æƒþ u&ƒ=4™u
hé¯èãšÿÿƒÄÿuèÿuôè=êÿÿë&ƒþu/ƒ}ìt
h°è»šÿÿƒÄÿuèÿuôèÙñÿÿèŽÿÿ‰ÆƒÄ鹐ƒ}ä…­ƒ}àtt‹Uà‹J ‹Uü9J tfƒz t‹Uàƒz tÿr ‹Müÿq è)*ƒÄ…Àtu‹Uà‹B …Àu¸:°P‹Mü‹A …Àu¸:°Pÿ5șÿ5P™h;°h„”èëRƒÄë5ƒ}äu-ƒ}àu'‹Uüƒz tÿ5șÿ5P™hw°h„”è´RƒÄƒþuuë\ƒþ ujjë
ƒþ
ujjèvÝÿÿè1ÿÿ‰ÆƒÄëKƒþ u 趉Æë;ƒþ
uèbâÿÿëƒþuèÒæÿÿë
ƒþuè¦ÞÿÿèñŒÿÿ‰Æëh¹°èn™ÿÿƒÄƒþt…ö…2üÿÿ=@˜ÿ~hÿhǰ菙ÿÿƒÄƒ=@šu
h։è-™ÿÿƒÄƒ=ȗu8ƒ=ėu/hÿ°ÿ5èÔQƒÄƒ=thÿ°ÿ5è¸QƒÄ‹$š…ÛtD€{u4ÿsh+±h„”èQÇð™ÆCf‹
4šf‰Kÿ4šƒÄ ‹[…Ûu¿‹@˜+4š‰ЙeÔ[^_ÉÃ%s: memory exhausted
U‰å‹
8š9
@š|I¡@š E‰
8šÁàPÿ5ęè¢.£Ä™ƒÄ…Àuÿ5̙h+¶h„”èáPjè¶rÿÿ‹@š¡Ä™f‹
șf‰ PÉАU‰åSè_‹ÿÿƒøt
h”èܗÿÿƒÄÿ5šèâ(@Pè_Sÿÿ‰Ãÿ5šSèE'ƒÄè#‹ÿÿƒøtöƒøtë5ƒøu/è
‹ÿÿë(¡¨˜ƒx u‰X ëС¨˜ÿph’è¾—ÿÿƒÄ빐‹]üÉÃ$tokens %s and %s both assigned number %dthe start symbol %s is undefinedthe start symbol %s is a token
extern YYSTYPE %slval;

extern YYSTYPE yylval;
#define NT%s %d
U‰åƒì WVS¾¡@˜@ÁàPè3Rÿÿ£ü™ÇE·‹
@˜MPèRÿÿ£8™‹=@˜}PèýQÿÿ£™Ç,šÇEô‹$šƒÄ …Û„‹‹
ü™‰Mü‹=8™‰}ø€{uf‹
ЙfKë2ƒ=X˜tfƒ{u ÿEôf‹}ôf‰{¿C9,š}£,šf‰sF¿C‹{‹Mü‰<¿Cf‹{‹Møf‰ ÿphp·ë¡Ø™€xuÿph‘·è•ÿÿƒÄ¡Ø™¿@£Ô™ƒ=虄ªÿ5èǃă=<šu:ƒ=™tÿ5™h°·ÿ5è #define T%s %d
U‰åVS‹u‹$š…Û„”¿S9Й~{¡ü™‹€8'tn9ԗtf‰ÂŠB„Àt<.uõ„ÀuTƒ=X˜t¿C됐¿CP¿S¡ü™ÿ4h¸ºVè(LƒÄƒ=4™t¿SR¡ü™ÿ4hǺVèLƒÄ‹[…Û…nÿÿÿ‹N9Nr
j
Vè¶6ë ‹FÆ
ÿFeø[^ÉÃU‰åƒìWVS¡@™@ÀPè‰Nÿÿ£ä™‹5@šuPèqNÿÿƒÀþ£š‹=@š}PèVNÿÿƒÀþ£à™‹5@šuPè;NÿÿƒÀþ£,™‹=@š}Pè NÿÿƒÀþ£Ì˜‹5@šuPèNÿÿƒÀþ£™1Û¹‹ä˜…Ò„Ó‹=š‰}ü‹5䙉uø‹=,™‰}ô‹5™‰uð‹Bf‹@‹}üf‰O¡à™f‰H‹r‰uìë6‹Bf‹@‹}øf‰_C‹B€xuf‹@‹uôf‰N‹Bf‹@‹}ðf‰O…Òt ‹…Òtƒzu¿ƒ}ìt,‹uìf‹~‹uôf‰ ‹…Ò…Qÿÿÿ¡ä™fÇXeà[^_ÉÃU‰åWVS‹]‹K9KrSèI3ƒÄƒøÿu ºÿÿÿÿë ‹C¶ÿC¿ƒú-u+‹K9KrSè3ƒÄƒøÿuºÿÿÿÿë ‹C¶ÿC¿ÿÿÿÿ1öë/¶tBЋK9KrSèß2ƒÄƒøÿuºÿÿÿÿë ‹C¶ÿC¡ˆ’ŠP$uÇSRèìI‰ð¯Çeô[^_ÉÃU‰åS‹M‹U ‹Eë
‹‚9t1ÀëHyñ¸‹]üÉÃU‰å‹U1ɅÒt
Bÿ!ÂA…Òuö‰ÈÉАU‰åWVS‹}1ö‹] ë
ÿ4ŸèÌÿÿÿƃÄKyð‰ðeô[^_ÉÃStart symbol %s does not derive any sentence.sreduced %s defines %d terminal%s, %d nonterminal%s, and %d production%s.
U‰åVS¡4šƒÀyƒÀÁøÁàPè6Kÿÿ£à—¡@šƒÀ yƒÀÁøÁàPèKÿÿ£ä—¡@˜ƒÀyƒÀÁøÁàPèúJÿÿ£è—¡@˜ƒÀyƒÀÁøÁàPèÜJÿÿ£ì—èÞèÅ‹ü—ô—ƒÄ…ÛŸÀ¶Øƒ=ø˜tè, …Û„ßè‹ԙ+ЙyƒÂÁú‹5à—‹
ԙ+
Й‰ËyƒÁ‰È$à‰Ù)Á¸Óà…–u‹ԙ¡ü™ÿ4hr¾èöŽÿÿƒÄèÇܗƒ=ܗuf¸¡¾ƒ=@šu¸ ¾Pÿ5@š¸¡¾ƒ=4šu¸ ¾Pÿ54š¸¡¾ƒ=Йu¸ ¾Pÿ5Йÿ5P™h£¾h„”èøFƒÄ$ƒ=à—tÿ5à—è5$ƒÄƒ=è—tÿ5è—è$ƒÄƒ=ä—t ÿ5ä—è$eø[^ÉÃU‰åWVS‹U‹} ¡à™¿PÀ‰Æ5ä™fƒ>~Pf‹¿Ð9Й6+ЙyƒÂÁú˜‰Á+
Й‰ËyƒÁ‰È$à‰Ù)Á¸Óà…—u1ÀëƒÆfƒ>³¸eô[^_ÉÃU‰åƒìWVS¡4šƒÀyƒÀÁøÁàPèÒHÿÿ‰EüƒÄ¡4šƒÀyƒÀÁøXÿ…Û|¡à—‹<˜‹uü‰<žKyô»9@šŒ$‰Ú…Û}SÁú‹5ä—‰uð‰Ù…Û}K‰È$à‰Ù)Á¸Óà‹}ð…—…Ûÿ5à—SèÓþÿÿƒÄ…À„Ä¡š¿X+Й‰Eðƒ}ð}ƒEðÁ}ð¡š¿X‰Â+ЙyƒÂÁú¡š¿X‰Á+
Й‰MôyƒÁ‰È$à‹Mô)Á¸Óà‹}ü —‹uð‰·‰]ð…Û}s‰uðÁ}ð‹=ä—‰}ø‰Ú…Û}SÁú‹5ä—‰uô‰Ù…Û}K‰È$à‰Ù)Á¸Óà‹}ô —‹}ð‹uø‰¾C9@šßþÿÿ¡4šƒÀyƒÀÁøPÿuüÿ5à—è ûÿÿƒÄ …Àu‹Eü‹5à—‰uü£à—égþÿÿƒ=à—t ÿ5à—è¤!‹}ü‰=à—eä[^_ÉÃU‰åƒì0WVS¡@˜ƒÀyƒÀÁøÁàPèæFÿÿ‰Eü¡@šƒÀ yƒÀÁøÁàPèÊFÿÿ‰Eø‹ԙ+ЙyƒÂÁú‹5à—‹
ԙ+
Й‰MÐyƒÁ‰È$à‹MÐ)Á¸ÓàƒÄ…–„Í‹ԙ‰]ЅÛ}ƒEÐÁ}Ћ=è—‰}ð‹ԙ…Ò}ƒÂÁú‹è—‰]؋
ԙ‰Î…É}ƒÁ‰È$à‰ñ)Á¸Óà‹}Ø —‹}Ћ]ð‰»¡@˜ƒÀyƒÀÁøpÿ…ö|¡è—‹<°‹]ü‰<³Nyô¾95@šŒò‹ä—‰]ì‹=è—‰}è‹à—‰]ä‰ò…ö}VÁú‰ñ…ö}N‰È$à‰ñ)Á¸Óà‹}ø…—…š‰ò…ö}VÁú‰ñ…ö}N‰È$à‰ñ)Á¸Óà‹]ì…“„j¡šf‹pf…À}fƒÀfÁø˜‰EСšf‹p‰Âf…À}fƒÀ$àf)‰Ð¿È¸Óà‹}Ћ]è…»„¡à™¿pÀ䙉Eôfƒ8Œ½‹}ôf‹f‰]Ô¿Ã9Й<‰Â+ЙyƒÂÁú¿EԉÁ+
Й‰MØyƒÁ‰È$à‹MØ)Á¸Óà‹}ä…—t[f‹EÔfƒ}Ô}fƒÀfÁø˜‰EØf‹EÔfƒ}Ô}fƒÀfÁø¿Ðf‹EÔf…À}fƒÀ$àf‹]Ôf)ÉؿȸÓà‹]ü “‹}؉»ƒEô‹}ôfƒ?Cÿÿÿ‰uЅö}^‰]ÐÁ}Љò…ö}VÁú‰ñ…ö}N‰È$à‰ñ)Á¸Óà‹]ø “‹}Љ»F95@š)þÿÿ¡@˜ƒÀyƒÀÁøPÿuüÿ5è—èŠ÷ÿÿƒÄ …Àu‹Eü‹=è—‰}ü£è—é™ýÿÿƒ=è—tÿ5è—è$ƒÄ‹]ü‰è—€ ¡è—€¡è—€ƒ=ä—tÿ5ä—èñƒÄ‹}ø‰=ä—¡@šƒÀ yƒÀÁøPÿ5ä—èE÷ÿÿ£ð—‹@š)Éô—Çø—‹5Й95@˜~E‹=è—‰}А‰ò…ö}VÁú‰ñ…ö}N‰È$à‰ñ)Á¸Óà‹]Ѕ“tÿø—F95@˜ŋ=4š+=ø—‰=ü—¾95@šŽ„‹̘‰]Ћ=ì—‰}܋]Ðfƒ ЙM)ЉEø‰ËƒÄ9@˜~‹}øfÇ_ÿÿC9@˜î‹Й‰Þ9@˜~G‹=è—‰}ü‰Ú…Û}SÁú‰Ù…Û}K‰È$à‰Ù)Á¸Óà‹}ü…—t‹}øf‰4_FC9@˜ËЙ9@˜~N‹}ø¿4_…ö|)¡™f‹ ̘fƒ ‹}øf‹Wf‰ƒÀfƒ8uâ¡Ô™‹}ø¿
%s


Terminals which are not used:



Useless rules:

#%-4d %s : %s;


U‰åWVSƒ=ü—~thZÊÿ5è‘<‹5ЙƒÄ95@˜~S‰ò…ö}VÁú‹è—‰ñ…ö}N‰È$à‰ñ)Á¸Óà…“u¡ü™ÿ4°hrÊÿ5è9<ƒÄ F95@˜­1ÿ1ö9=ЙŽ£‰ò…ö}VÁú‹è—‰ñ…ö}N‰È$à‰ñ)Á¸Óà…“uf‰ò…ö}VÁú‹ì—‰ñ…ö}N‰È$à‰ñ)Á¸Óà…“u7…ÿuhyÊÿ5èª;¿ƒÄ¡ü™ÿ4°hrÊÿ5èŠ;ƒÄ F95Й^ÿÿÿƒ=ô—Žðh›Êÿ5è];¾ƒÄ95@šŒÌ‰ò…ö}VÁú‹ä—‰ñ…ö}N‰È$à‰ñ)Á¸Óà…“…‹Vh®Êÿ5è;¡š¿p¡ü™ÿ4h¶Êÿ5èã:¡à™¿pÀ‰Ã䙃Äfƒ;|*¿¡ü™ÿ4h¼Êÿ5è©:ƒÄ ƒÃfƒ;}ÙhÀÊÿ5è:ƒÄF95@š5ÿÿÿƒ=ü—
ƒ=ô—…ÿthÃÊÿ5èW:eô[^_ÉÃntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nitems = %d

Variables
---------

Value Sprec Sassoc Tag
%5d %5d %5d %s
Rules
-----

%-5d(%5d%5d)%5d : (@%-5d)%5d [%d]
Rules interpreted
-----------------

%-5d %s :
U‰åVSÿ5@™ÿ5@šÿ5@˜ÿ54šÿ5Йh)Íÿ5è-9hjÍÿ5è9ƒÄ$h€Íÿ5è
9‹5ЙƒÄ95@˜~:¡ü™ÿ4°¡™¿pP¡8™¿pPVhŸÍÿ5èË8ƒÄF95@˜ÇhÃÊÿ5è¯8h²Íÿ5èŸ8¾ƒÄ95@šŒ¡¡à™¿pP¡š¿pP¡™¿pP¡,™¿pPVhÀÍÿ5èO8¡à™¿pÀ‰Ã䙃Äfƒ;~#¿PhÚÍÿ5è8ƒÄ ƒÃfƒ;à¿÷ØPhÞÍÿ5èú7ƒÄ F95@šbÿÿÿhÃÊÿ5èÚ7håÍÿ5èÊ7¾ƒÄ95@šŒ‰¡š¿p¡ü™ÿ4Vh Îÿ5è’7¡à™¿pÀ‰Ã䙃Äfƒ;~)¿¡ü™ÿ4h¼Êÿ5èY7ƒÄ ƒÃfƒ;ÙhÎÿ5è=7ƒÄF95@šyÿÿÿhÃÊÿ5è7eø[^ÉÃ%d rules never reduced
%s contains %d useless nonterminal%s and %d useless rule%s.
U‰åƒ= t!ƒ=ô—tÿ5ô—hbÐh„”è’6ƒÄ ÿ5P™hzÐh„”èz6ƒÄ ƒ=ü—~P¸¡¾ƒ=ü—u¸ ¾Pÿ5ü—h‡Ðh„”èE6ƒÄƒ=ü—~ƒ=ô—~Gh Ðh„”è!6ƒÄƒ=ô—~,¸¡¾ƒ=ô—u¸ ¾Pÿ5ô—h¦Ðh„”èì5ƒÄh¸Ðh„”èÚ5h„”èø7ÉАU‰åS‹M1À€9tÀ¾1Ð%ÿ?A€9uî»ñ™÷û‰Ð‹]üÉÃU‰åVS‹uº‰ð€>tB@€8uùRèC8ÿÿ‰ÃVSè. ‰Øeø[^ÉÃU‰åhÄè#8ÿÿ£¤˜Ç$šÇ¼™ÉÃU‰åWVSÿuèbÿÿÿ‰Ç¡¤˜‹¸1öƒÄ…Ût)ÿsÿuè ƒÄ…Àu
¾ë‹…Ût…ötڅöuXÿ@˜jè­7ÿÿ‰Ã¡¤˜‹¸‰ÇCÿuè.ÿÿÿ‰CÆCƒ=$šu
‰$šë
¡¼™‰X‰¼™¡¤˜‰¸‰Øeô[^_ÉÃU‰åVS1ö¡¤˜‹°…Àt‹…Àt PèÀƒÄ‰Ø…ÀuëFþð~փ=¤˜t ÿ5¤˜èšeø[^ÉÃU‰åƒìWVS‹E X…Û}X>ÁûÁã¯ÃE‰Eü‹M‰Mø¿‰Mô9ÁsV‹uø‹E9Eüv2…>t$‹Uô ‰Mð9Ès‹
ƒÂƒÀ9Eðwñ됐ØÞ9EüwÏÿu ¿ƒEø]ô‹Mü9Môr«eä[^_ÉÃU‰åVS‹u‹] SVèVÿÿÿK…É}K>ÁùÁá‰Ø¯Á0º‰ð9Øs ÒuºƒÀÈ9Ørìeø[^ÉÃGNU Bison version 1.18
U‰å‹U‹M €:t¾9Èu‰ÐÉÐB€:uî1ÀÉАU‰åVS‹]‹u ‹U1À9Ð} Š ˆ 0@9Ð|õeø[^ÉÃU‰åWVS‹u‹ ˜+˜Áã‰Ø)ĉçSW‹˜•ðPè£ÿÿÿ¡à+ ˜ÁàP‹˜•ðP‹ ˜•ðPèoÿÿÿS¡˜à+ ˜†PWèSÿÿÿ¡à+ ˜˜‹à‰ ˜eô[^_ÉÃ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: unrecognized option, character code 0%o
%s: unrecognized option `-%c'
%s: option `-%c' requires an argument
U‰åƒìWVS‹]Çܐƒ=à…ƒÇàÇ ˜Ç˜Ç˜‹U€:-uǘÿEëD‹M€9+uǘÿEë+h:ÕèÚ4ƒÄ…Àtǘë
Ç˜ƒ=˜t¡˜€8…õƒ=˜…Ÿ‹ ˜9˜t‹
à9Êt"ÿu èýÿÿƒÄ됋à9 ˜t‰˜‹M9
à}N¡à‹U ‹‚ë6…Ût¡à‹M ‹€8+u€xu'ÿà‹U9à}¡à‹M ‹€8-uŀxt¿‹à‰ ˜‹M9
àt|¡à‹U ‹4‚¿JÕ¸‰Áó¦uVÿà‹ ˜9˜t'‹
à9Êtÿu è;üÿÿƒÄ됐‹ ˜9˜u ‹
à‰
˜‹U‰ ˜‰à‹M9
àu‹ ˜9˜tG‹
˜‰
àë9¡à‹U ‹‚€8-u€xuf…Ût¡à‹M ‹€8+u€xuLƒ=˜u ¸ÿÿÿÿéX¡à‹U ‹‚£Üÿà¸é7‰uð‹Mü‰MìÇEøéù‹5à1À…Ût‹U ‹²€x-”À%ÿ@‹M ±£˜…Û„ê¡à‹U ‹‚€8-u €x-tƒ}u¡à‹M ‹€8+…º‹=˜ÇEøÇEôÇEðëG€?t€?=uõ‰ÞÇEüƒ>t]‰ø+˜Pÿ5˜ÿ6è¾ƒÄ …Àu2‰û+˜ÿ6èЃÄ9Äÿÿÿƒ}ðu ‰uð‹Uü‰UìëÇEôƒÆÿEüƒ>u¦ƒ}ôt8ƒ}øu2ƒ=䐄î¡à‹M ÿ4ÿ1hMÕh„”è%-ƒÄéʐƒ}ð„6‹Uì‰Uüÿà€?tq‹Mðƒyt G‰=ܐé̃=䐄¤¡à‹U ‹D‚ü€x-u‹Mðÿ1ÿ2hkÕëw‹Uðÿ2¡à‹M ‹Dü¾Pÿ1h˜Õh„”è–,ƒÄëV‹Uðƒzug‹M9
à}¡à‹U ‹‚£ÜÿàëDƒ=ät ¡à‹M ÿtüÿ1hÅÕh„”è>,ƒÄÿ5˜èx˜¸?éïÿ5˜è]˜ƒ}t‹Mü‹U‰
‹Uðƒzt‹B‹J ‰1À鸐‹Uð‹B 鬐ƒ}t.¡à‹M ‹€x-t€8+t¡˜¾PÿuèwøÿÿƒÄ…Àutƒ=ätL¡à‹U ‹‚€x-uÿ5˜ÿ2hëÕéMþÿÿÿ5˜¡à‹M ‹¾Pÿ1h Öh„”èV+ƒÄÿ5˜è˜ÿàé
ÿÿÿ¡˜Šÿ˜¾ÃPÿuèã÷ÿÿ‰Æ¡˜ƒÄ€8uÿà…öt€û:uIƒ=䐄Æþÿÿ€û~€û~~¾ÃP‹U ÿ2h+Ö됐¾ÃP‹M ÿ1hXÖh„”è¼*éþÿÿ€~:uz€~:u¡˜€8uUÇܐëT¡˜€8u=‹U9àu'ƒ=ät¾ÃP‹M ÿ1hwÖh„”èZ*³?됐¡à‹U ‹‚£ÜÿàÇ˜¾Ãeà[^_ÉÃU‰åjjjÿuÿu ÿuè9ùÿÿÉАU‰åjÿuÿuÿuÿu ÿuèùÿÿÉÐU‰åjÿuÿuÿuÿu ÿuèÿøÿÿÉÐS‹¬˜ƒúÿu1҃<•°˜t¸°˜ƒÀBƒ8u÷‰Ð…À~…¬˜‹ÿЃÃüû¬˜ñ[АS»¼˜ƒ=¼˜t
‹ƒÃÿЃ;uôh¤Ýè® ƒÄ[Ѓ=ìuÇìè¼ÿÿÿАWV‹T$ ‹t$‰×ü¬ª„Àuú‰Ð^_ÃWV‹T$ ‹t$‰×1À¹ÿÿÿÿüò®O¬ª„Àuú‰Ð^_АWV‹|$ ‹t$ü¬®u„Àuø1Àë ¸|÷Ø^_ÐWV‹|$ ‹t$‹L$üAIt¬®u„Àuõ1Àë ¸|÷Ø^_ÐV‹D$ ‹t$üˆÄ¬8àt „Àu÷¾‰ðH^ÐV1ҋt$‹D$ üˆÄ¬8àu‰òJ„Àuô‰Ð^АƒìUWVS‹l$‹\$‰î1À¹ÿÿÿÿü‰ßò®÷ÑI‰Ê¬„Àt‰ß‰Ñò®tóN)î‰t$‹D$[^_]ƒÄАƒìUWVS‹l$‹\$‰î1À¹ÿÿÿÿü‰ßò®÷ÑI‰Ê¬„Àt‰ß‰Ñò®uóN)î‰t$‹D$[^_]ƒÄАWVS‹t$‹\$1À¹ÿÿÿÿü‰ßò®÷ÑI‰Ê¬„Àt ‰ß‰Ñò®uóNë1ö‰ð[^_ÃW¹ÿÿÿÿ‹|$1Àüò®÷ÑI‰È_АWV‹D$ ‹L$‹t$‰Çüó¤^_АWVS‹\$‹D$9Ãs
‹L$‰Æ‰ßüó¤ë‹L$TÿDÿ‰Ö‰Çýó¤ü‰Ø[^_АWV1À‹|$ ‹t$‹L$üó¦t ¸|÷Ø^_АW‹T$…Òt‹D$ ‹|$‰Ñüò®t¿O‰ø_А1À_ÃW‹T$‹D$ ‰×‹L$üóª‰Ð_АS‹\$¸-̀£ô9ØtÇ š ¸ÿÿÿÿ[А1À[ÃS‹T$‰Óô¸-̀£ô9ØtÇ š ¸ÿÿÿÿ[А‰Ø)Ð[АS‹\$¸
̀…À} ÷Ø£ š¸ÿÿÿÿ[АƒìUWVS‹T$$+ð˜yÂÿÁú j‹=à˜‰|$tm‰t$Ád$‹L$‹ ‰L$…É…ãÿ
ü˜‹t$‹D7Áà )왋D7Áà  š‹
™‰L$9év‹T$‹|$‹D‚‰D$9èwíë5‹T$‹t$v‹D‚‰D$…Àt9l$rç‹à˜‹L$I‹T‚‰T$‹=à˜‰|$‹t$vÁã‰ð9ÅuDm‹D‡‹l$ë:TmÁâ‹L$‹|‰<‹\‰\‹t$‰tv‰l‹D@‰lÿИ‹à˜TmÁâ‰è9Du)@‹ƒ‹D@‹Dƒ‰D‹D@‰lƒÿ
И¡à˜Lm‰L$Ád$‹|$‹<8‰|$ƒÿ†„‰ë\$9D™uvj¡T•ÿЍSÿÁâ ð˜ƒÄ9ÐuZ‰ûÁã )=D™‰Ø÷ØP¡T•ÿЋà˜‹t$‹D2@‹L2‰L‚‹|$‹D:@‹t:‰t‚‹L$‹l
ÿ
И) šƒÄ‰-™[^_]ƒÄÐÿ
ü˜¸‹L$Óà)ì™ÿИ š‰ÐÁà ð˜‹|$‹t$‹T>ÓâÇD$Ó|$‹D$H9D>…š‰ÚÇD$‹L$9L$s‹ÿD$‹|$9|$rð‹C‰…Òt‹[‰Z‹à˜DmÁàÇÇDÿü˜ì™¸‹L$Óø)И šðÿÿEÿÁà ð˜P訃Ä[^_]ƒÄЋ|$‹t$ƒ|>t-‹;‹L$$‰9‰Y‰ ƒ9t‹‰H‹à˜DmÿD‚[^_]ƒÄË\$$‹t$‹L$ÇD1‰Ø%ÿ‹L$Óè‹L$‰D1‹|$‹4ý\™‰3ý‰ÁÁ\™‰K‰˜\™ƒ;t‹‰X[^_]ƒÄËT$…ÒtA¡ø…Àt9Pt‹…Àuõƒ=L˜tR¡L˜ÿЃÄÃÇ@‹PëßRèþûÿÿƒÄАƒìUWVS‹l$ …íuÿt$èœÿÿÿjèý3ƒÄ[^_]ƒÄАƒ|$uUèã3ƒÄ[^_]ƒÄÃ= ˜tUÿt$ ¡ ˜ÿЃÄ[^_]ƒÄËD$+ð˜yÿÁø @‰D$‹à˜@‹4‚…ö…ýw3Uè}3‰ÃƒÄ…Ût$Uÿt$ Sè
úÿÿƒÄ ÿt$èõþÿÿ‰ØƒÄ[^_]ƒÄͅÿ‰ÆÁî ‹à˜‹|$<‰|$Ád$‹L$9t v=‹T$òRÁàÇ‹| )÷‰|‰t JÁâ ð˜RèŒþÿÿ‹\$ é琐‹L$9t „‰‹|$‹t;‹D™ÇD™ÿt$èQþÿÿ‰D™Uè­2‰ÃƒÄ…Ûu‰ðÁà Pè™21ÀƒÄ[^_]ƒÄÃ9\$„‰ðÁà Pÿt$ Sè.ùÿÿƒÄ ëlNÿ¸Óà9Åv¸‰ñÓà9Åw ‹\$ëJUèB2‰ÃƒÄ…Ûu
1À[^_]ƒÄАº‰ñÓâ‰è9Ðv‰ÐPÿt$ Sè´øÿÿƒÄ ÿt$èœýÿÿƒÄ‰Ø[^_]ƒÄАVS‹t$ ¯t$Vèã1‰ÃƒÄ…Ût VjSèùÿÿƒÄ ‰Ø[^ЃìVS1ö\$Sè—&ƒÄ…ÀujSè&ƒÄ…Àu
jSjèÓ&ƒÄ …öuè«#jèÝ%ƒÄ…Àtòjè«-è…ÀtÇ‹T$‰P1ÀА¸ÿÿÿÿАWVS‹
„’…Ét/1Û9Yv‰È1Ґ‰ÖƒxtHƒÀ V C9Ywìƒyv>‹ …ÉuÔhˆè1‰ÁƒÄ…Ét9‹=„’‰9‰
„’ÇAA[^_ЍD[^_ËA@DÿA[^_А1À[^_Аj
jÿt$ èkƒÄ АUWVS‹l$‹=„’…ÿtG‹_‰ØK…Àt5[4…>‹…ÀtƒøuÿrU‹BÿЃÄë‹BÿЉ؃ÆôK…ÀuՋ?…ÿu»èj"Uè|,ƒìUWVS‹|$8…ÿ|
ƒÿtƒÿ$~¿
‹\$0¾‹5ˆ’됐C¾ŠF$uõ€;„€€;-u ÆD$(ÿC됐€;+u ÆD$(C됐ÆD$(ƒÿu€;0u¾S¡’€<XuƒÃ…ÿu,€;0u"¾S¡’€<Xu ƒÃ¿ë¿ë¿
‰\$¸ÿÿÿÿ1Ò÷÷‰T$ ‰D$$ÇD$1öŠ ˆL$„Éto‹-ˆ’¶T$‰T$ŠDU$t€D$Ðë‹L$ŠDM$tE¡’ŠɈD$¶D$9ø}.9t$$ru9D$ s ÇD$ë ¯÷¶D$ÆCŠˆT$„Òu—9\$tqƒ|$4t‹L$4‰¸€€|$(~¸ÿÿÿ9ÆvÇD$ƒ|$t0Ç š"€|$(~¸ÿÿÿ[^_]ƒÄА¸€[^_]ƒÄА¾D$(¯Æ[^_]ƒÄÃ|$4t
‹L$0‹T$4‰
1À[^_]ƒÄЋD$‹@ËT$‹B‹L$‰JЋD$¾@А‹D$ŠPŠL$ˆH¾ÂА‹D$‹@ ËT$‹B ‹L$‰J ЋD$·@А‹D$f‹Pf‹L$f‰H·ÂА‹T$‹B ‹L$ J ÐS‹\$‹L$‹C ‰Ê÷Ò#S #L$ ʉS [А‹T$‹L$‰È#B ÷Ñ!J ЋD$‹@ËT$‹B‹L$‰JЋD$‹Ã‹D$ŠT$ˆPËD$€x”À%ÿА‹D$Š@ƒàЋD$Š@ƒàЋD$Š@ƒàЋD$¶@А‹D$ŠT$PËT$ŠJöÁ”À%ÿ÷Ø!ÐЋD$Š@ƒàЋT$ŠD$öÐ BА‹D$‹T$‰Æ@Ç@Æ@ Ç@ fÇ@ЋD$ƒxþ”À%ÿА‹D$‹T$‰PËD$‹T$‰P Ç@þÿÿÿЋD$ƒÀ$ËD$‹@ËD$‹@ËD$‹@ËD$‹@ËD$‹@ËD$‹@ ËD$‹@ ËD$‹@ËD$‹PŠL$ˆ
ÿ@А‹D$‹Ã‹T$‹‹L$‰
А‹D$‹T$ ЋD$‹T$PËD$‹T$PËD$‹T$‹L$ ‰P‰P‰HАS‹D$‹T$‹L$‹\$ ‰X ‰P‰H[ËD$‹%ËT$‹%t‹B(А‹B ËT$‹%t‹B0А‹BËT$‹%t‹B А‹B(ËD$‹@,ËT$‹%t‹BА‹B0ËD$‹@(ËD$‹@0ËD$ƒx(•À%ÿА‹D$ƒx4•À%ÿА‹D$‹ÑèƒàËD$‹Áè ƒàА‹D$ƒ|$t€Ѓ ýËD$ƒ|$t ë ÿýÿÿƒ ýА‹T$‹J8ƒzu¿AÐP‹AÿЃÄА1ÀЋD$‹P+P‰ÐА‹D$‹P+P‰ÐАS‹\$‹S9SrSèñƒÄƒøÿu ¸ÿÿÿÿ[А‹C¶ÿC[ÐS‹\$‹S9SrSèÁƒÄƒøÿu ¸ÿÿÿÿ[А‹C¶[ÃS‹\$ÿC‹S9SrS蒃ăøÿu
¸ÿÿÿÿ[А‹C¶[ÃS‹T$‹L$ ‹Z9Zr¶ÁPRèƒÄ[ËBˆÿB¶Á[АS‹\$‹D$ €Ì@PSè‘ÇC8$“ƒÄ‰Ø[А‹T$‹D$ÇB8$“PRèÞƒÄА‹D$¿@>÷ÐÁèА‹D$¿P>¸ÿÿÿÿ…Ò|‰ÐËD$‹P9P •À%ÿЋD$‹P9P u‹@Ë@ËT$‹%t‹B0А‹BËD$‹‹ƒàËD$‹‹ƒàËD$‹‹ƒà ËD$‹P+P ‹@4…Àt9P }‹P ‹…Àuò‰ÐА‹D$ ÿþÿÿ‹P‹H0‰H‰P0‹P ‹H(‰H ‰P(‹H ‰HА‹D$‹P‹H0‰H‰P0‹P ‹H(‰H ‰P(‹H‰HАÿt$èƒÄАƒìUWVS‹t$‹%t Vè~ÿÿÿƒÄ‹N9Ns‹F¾[^_]ƒÄЃ~4„Vè,ÿÿÿ‰Ã‹F+F ‰Ç)ߋF0+F(ƒÄ9Ç~sÇD$W蝕‰ÅƒÄ…Û}(‰Ø÷؉ÚV0PRUèŸîÿÿƒÄ ‰ê)ڋF+F Pÿv Rë ‰ØF WPUè{îÿÿƒÄ ƒ~(t ÿv(è┃ĉn(‰èD$ø‰F0ë^)ø‰D$…Û}6‰Ø÷ØP‰ØF0P‹D$F(PèJîÿÿ‹T$V()ڋF+F Pÿv RèîÿÿƒÄ ë…ÿ~‹T$V(‰ØF WPRèüíÿÿƒÄ ‹L$N(‰N,‹V+V ‹F4…Àt6)P ‹…Àu÷ë)ƒ~(t"t ÿv(è<”ƒÄÇF(ÇF0ÇF,‹V8¿BðP‹B ÿЃÄ[^_]ƒÄАÿt$ÿt$èƒÄА‹D$‹H8ÿt$¿QÐP‹AÿЃÄÐUWVS‹l$‹t$‹|$‹]+]…Û~D9û~‰ûƒû~SVÿuè1íÿÿƒÄ Þ]ë#…Û1Ûë‹UCÿ…À| Šˆ
FBHy÷‰U)߅ÿt¶PFUècÿÿÿƒÄƒøÿtO똋D$)ø[^_]ÐUWVS‹l$‹t$‹|$‹]+]…Û~D9û~‰ûƒû~SÿuVè­ìÿÿƒÄ Þ]ë#…Û1Ûë‹UCÿ…À| Š
ˆBFHy÷‰U)߅ÿtUè@ýÿÿƒÄƒøÿu ‹D$)ø[^_]ЋD$‹P9Pu ‹P9Pu1ÀиÿÿÿÿА¸ÿÿÿÿАS‹\$‹S8jjjÿ¿B ØP‹B$ÿЃÄƒøÿu
¸ÿÿÿÿ[А‹K9KrSèÊüÿÿƒÄƒøÿtà‹C¶[АS‹\$‹T$ ‹D$…Òt…Àu€ jÐPRSèXƒÄÇCÇCÇCÇC ÇCÇC‰Ø[А‹T$‹J8ÿt$ jÿt$¿A ÂR‹A$ÿЃÄАS‹\$ƒ{t3Š$t-ƒ{t
‹S‰ÐBüt‹C됐ÇBü‹CƒÀøP譑ƒÄ‹L$ ‰K‹L$‰K ƒ|$tƒ#þ[À [АhèꑉƒÄ…Òtj‚PRÿt$èzÿÿÿ¸ƒÄиÿÿÿÿА‹D$‹T$Ç@8Œ“Ê­û‰Ç@Ç@ Ç@ Ç@Ç@Ç@Ç@Ç@Ç@$Ç@(Ç@,Ç@0Ç@4ÐVS‹\$ ‹t$ÇC8Œ“ƒ{t3Š$u-ƒ{t
‹S‰ÐBüt‹C됐ÇBü‹CƒÀøP蕐ƒÄ‹C4…ÀtÇ@‹…Àuó÷Æt SèmƒÄ[^А¸ÿÿÿÿАS‹L$ŠD$ ‹Q8‹Y 9Yw¾ÀP¿B@ÈP‹BDÿЃÄ[А‹QJ‰Q8tˆ%ÿ[ÃS‹T$‹J8‹Z 9Zw¿AHÐP‹ALÿЃÄ[А‹BH‰B¶[ÃVS1ö‹•…Ût'‹S8jÿ¿BØP‹BÿЃÄƒøÿu¾ÿÿÿÿ‹[$…Ûuۉð[^АS‹•…Ût#‹S8‹Áè ¨t¿B8ØP‹B<ÿЃÄ‹[$…ÛuÞ[øÿÿÿÿА¸ÿÿÿÿАVS‹\$ ‹T$‰S‹J8f‹f%@u#jjj¿A ÐP‹A$ÿЃÄ‰CÇë/‹%t ‹r+rë ‹r+r ‰s ÇCþÿÿÿ‹r4‰3‰Z4‰Ø[^АS‹T$‹L$ ƒzþu ‹BƒÀ4ƒ8t9u‹‰ë ‹ƒ8uíöÁt RèƎƒÄ[ЋT$‹D$‹H9Jt¸ÿÿÿÿАƒzþuƒxþu ‹R +P ‰ÐАƒzþtƒxþt ‹R+P‰ÐА¸ÿÿÿÿАS‹\$ƒ{u ¸ÿÿÿÿ[Аƒ{þu&‹S‹%t
‹B+B됐‹B+B ‹[ )ÉØ[Ѓ{ÿtŋC‹P8jjj¿B CP‹B$ÿЃÄƒøÿuϸÿÿÿÿ[АVS‹\$ ‹t$‹S89^t
¸ÿÿÿÿ[^Аƒ~þtjÿv¿B(ØP‹B,ÿÐƒÄ [^Аƒ~ |‹%t Sè«÷ÿÿƒÄ‹K 됐‹%u Sè½÷ÿÿƒÄ‹KN ‰K1À[^ÃUWVS‹\$ƒ{(t‹%u Sè÷ÿÿƒÄƒ{(u&h€èÀ‰C(€‰C0‰C,Sèh÷ÿÿƒÄë\‹C 9CwQ‹{)Ǎ,}U芍‰Æ‰è)øðƒÄWÿs Pè‘æÿÿƒÄ ‹C …Àt PèùŒƒÄ‰è)ø‰s ð‰Cî‰s‹K‰K,‹SJ‰S¾9D$tŠL$ˆ
¶D$[^_]А‹T$‹D$ÇB8$“PRèÊûÿÿƒÄАƒì WVS‹t$0‹Ñè¨t:jF>PF=PVè–úÿÿƒÄ‹F‰F‰F‰F‹F‰F ‰F‰F¸[^_ƒÄ А¿V>¸ÿÿÿÿ…Ò|‰Ð…À|!D$ P¿V>¸ÿÿÿÿ…Ò|‰ÐPèsƒÄ…À}1ÿëf‹D$f%ðf= ”À¶ø»SèjŒjRPVè úÿÿƒÄ…ÿt2¿V>¸ÿÿÿÿ…Ò|‰ÐPèõƒÄ…Àt‹F‰F‰F‰F됐‹F‹V ‰F‰F‰V‹F‰F ‰F‰F¸[^_ƒÄ ЋT$‹D$ÇB8$“PRèžúÿÿƒÄАS‹\$ÇCDSèFfÇC>ÿÿƒÄ[АS‹L$€9}+º•ƒ=•t9
u‹Y$‰ë ‹P$ƒx$ué!ÿÿÿ[ЋD$€8|€€‹•‰P$£•ÐS‹\$hÀSè ùÿÿƒÄÇC8”’SèlÿÿÿƒÄ‰Ø[ÐVS‹\$ ‹t$hÀSèsùÿÿƒÄÇC8”’Sè?ÿÿÿVSè(ƒÄ ‰Ø[^ÃUWVS‹\$‹t$‹l$‹|$ hÀSè5ùÿÿƒÄÇC8”’SèÿÿÿVSèêWUSè®
ƒÄ‰Ø[^_]ÃS‹\$ÇC8”’Š$@u S訃ÄSèçþÿÿƒÄÇC8$“ÿt$ SèKùÿÿƒÄ[АWVS‹|$‹\$fƒ>|1À[^_É؃àƒøu¸¾ ë*öÃ
t¸¾ëöÃt 1À¾ë1À1ööÃuƒûu€ÌöÃt€Ìöà uƒût @öÃ@t €ÿt$Pÿt$èŽƒÄ …ÀŒyÿÿÿf‰G> 7öÃt!‹W8jjj¿B øP‹B$ÿЃÄƒøÿ„MÿÿÿWè9þÿÿ‰øƒÄ[^_ÃVS‹t$ ‹T$fƒ~>|1À[^А1ɊB ¸» h¶ ÈPÿt$è¥ƒÄ …À|f‰F> Vèzýÿÿ‰ðƒÄ[^А1À[^А‹D$fƒx>}
f‹T$f‰P>€LÃ1ÀЃì UWVS‹t$ ‹l$$‹N8‰L$Š$u¸ÿÿÿÿ[^_]ƒÄ А‹N9Nuƒýÿu 1À[^_]ƒÄ ЋN9N tO‹F9Ft9Fs
VèaƒÄ…Àu¶f‹f%t‹F‰F‰F‰F됐‹F‹V ‰F‰F‰V‹F‰F ‰F‰F‹V8ƒ~u¿BðP‹BÿЃÄƒýÿu ÇD$1íëÇD$‹V9Vu<‹Áè ¨t3…Òt/‹F9F v'ƒ|$u ‰éˆÿFƒý
t ¶Á[^_]ƒÄ ÐÇD$‹^+^tg‹~SW‹L$¿AxðP‹L$ ‹A|ÿÐƒÄ ƒøÿ„ÞþÿÿFD)ÃtÇëӐf‹f%t‹F‰F‰F‰F됋F‹V‰F‰F‰V‹F‰F ‰F‰Fƒ|$t
‰è[^_]ƒÄ ËF9Fv‰éˆÿF¶Á[^_]ƒÄ А‰éˆL$jD$P‹L$¿AxðP‹L$ ‹A|ÿÐƒÄ ƒøu‰é¶Á[^_]ƒÄ А¸ÿÿÿÿ[^_]ƒÄ АWVS‹\$‹{8Š$u ¸ÿÿÿÿ[^_А‹C9Cv¶[^_Ѓ{u¿GØP‹GÿЃÄf‹f%u‹Ñè¨tèmöÿÿ‹S9Sv
SègƒÄ…Àu¤‹C…Àu s=C>됉ƋC )ðPV¿GhØP‹GlÿÐƒÄ …À|‰s ‰sƉs…À…Àu € é]ÿÿÿ€ éTÿÿÿCD‹C¶[^_АUWVS‹t$‹n8‹V‹F9Ât#j)ÐP¿EpðP‹EtÿÐƒÄ ƒøÿu
¸ÿÿÿÿ[^_]ËF‹^)ÉDžÛ~)SW¿ExðP‹E|ÿÐƒÄ ƒøÿtЃ~D|FD)ÃDžÛًF‰F ‰F‰F‹F‰F‰F‰F1À[^_]АVS‹\$ ‹s8‹K9KvSèYÿÿÿƒÄ…Àt
¸ÿÿÿÿ[^А‹C‹S9Ðtj)ÐP¿FpØP‹FtÿÐƒÄ ƒøÿtÓ1À[^Ãì$UWVS‹\$8‹|$<‹t$@‹K8‰L$‹K9KvSèøþÿÿƒÄ…Àt
¸ÿÿÿÿ[^_]ƒÄ$ËÑ訅ƒ{„†…ö„ƒƒþu=ƒ{D}"jj‹L$¿ApØP‹L$‹AtÿЉCDƒÄ …À|¨{D‹C+C)NjC+CÇëAD$P‹L$¿€ØP‹L$‹„ÿЃÄ…À…f‹D$f%ðf=€…ÿ|$$ƒ{D|Q‹%t‹C0됐‹C‹k‰ú+SD)èÂx/‹s‰ð)è9Â$‰k Չk‰s‹C‰C‰C‰C‰ø[^_]ƒÄ$А‹S +S‰Ð÷Ø!ø‰þ)Æ9Ö~‰ø1öjP‹L$¿ApØP‹L$‹AtÿÐ‰ÅƒÄ …팿þÿÿ…öu1Òë<‹S‹C )ÐPR‹L$¿AhØP‹L$‹AlÿÐ‰ÂƒÄ 9ò}ƒúÿu‰÷ë‰÷)×¾ë%‹C‰C ƉsЉCՉkDƒ#ï‰ø[^_]ƒÄ$АVW‹L$¿ApØP‹L$‹AtÿÐ‰ÅƒÄ ƒýÿtƒ#ï‰kD‹Ñè¨tC=됋C‰C ‰C‰C‰C‰C‰C‰è[^_]ƒÄ$ÐVS‹t$ ‹^8fƒ~>}1À[^Аjÿ¿CðP‹CÿЃÄƒ~t3Š$u-ƒ~t
‹V‰ÐBüt‹F됐ÇBü‹FƒÀøPè=‚ƒÄjjjVèFðÿÿ¿ƒˆðP‹ƒŒÿЉÃVèÀöÿÿÇ€­ûfÇF>ÿÿÇFDƒÄÇF ÇFÇFÇFÇFÇF…ÛŒ@ÿÿÿ‰ð[^А‹D$ÿt$ ÿt$ ¿@>PèÒƒÄ А‹D$ÿt$ ÿt$ ¿P>¸ÿÿÿÿ…Ò|‰ÐPè[ƒÄ А‹D$ÿt$ ÿt$ ¿P>¸ÿÿÿÿ…Ò|‰ÐPèƒÄ А‹D$ÿt$¿P>¸ÿÿÿÿ…Ò|‰ÐP臃ÄА‹D$¿P>¸ÿÿÿÿ…Ò|‰ÐPèGƒÄАƒìUWVS‹l$(‹t$,‹M8‰L$ ‹|$0‹]+]…Û~A9\$0}‹\$0ƒû~SVÿuè_ÚÿÿƒÄ Þë‹UCÿ‰D$…À|Šˆ
FBÿL$yô])߅ÿŽÈjÿUè—ìÿÿƒÄƒøÿu‹D$0)ø[^_]ƒÄЋU+Uƒú~ ‰ø‰Ñ™÷ùëN1ÒëJ‰ø)ÐPV‹L$(¿Ax‰D$ l$ ÿt$ ‹L$,‹A|‰D$ ‰T$(‹L$ ÿÑ‰ÃƒÄ ‹T$ƒûÿtœƒ}D|]DÞ)ß9ײ‹]+]9û~‰ûƒû~SVÿuèÙÿÿƒÄ 됐‹UCÿ‰D$…À|Šˆ
FBÿL$yô])ߋD$0)ø[^_]ƒÄÐÿt$ ÿt$ ÿt$ èkìÿÿƒÄ АUWVS‹t$‹\$‹l$j|WSVè²íÿÿƒÄ…Ût…íu€‹F8¿PòR‹@ÿЃÄë‰^‰^‰~‰^ ‰^‰^‰ð[^_]А‹T$‹D$ÇB8$“PRèjîÿÿƒÄА¡<”%ÿÿ=¼úu ‹@”됐1Ò=­ûuº<”…ÒtD$Pÿt$Rè{"ƒÄ А¸ÿÿÿÿА‹T$‹D$ÇB8$“PRèîÿÿƒÄА‹T$‹%ÿÿ=¼úu‹Rë=­û”À%ÿ÷Ø!…ÒtD$ Pÿt$ Rè"ƒÄ øÿÿÿÿА‹T$‹D$ÇB8$“PRèžíÿÿƒÄА‹L$‹T$‹%ÿÿ=¼úu‹R‹%ÿÿ=­ûuƒùÿu¸ÿÿÿÿАQRèÝíÿÿƒÄЋT$‹D$ÇB8$“PRèBíÿÿƒÄАD$ Pÿt$ ÿt$ èƒÄ А‹T$‹D$ÇB8$“PRèíÿÿƒÄАWVS‹|$‹t$‹%ÿÿ=¼úu‹v‹%ÿÿ=­ûtÇ š¸ÿÿÿÿ[^_А‹^8Wè ×ÿÿƒÄPW¿CXðP‹C\ÿÐƒÄ ƒøÿ”À%ÿ÷Ø[^_А‹T$‹D$ÇB8$“PRè‚ìÿÿƒÄАVS‹\$ ‹%ÿÿ=¼úu‹[‹%ÿÿ=­ûtÇ š¸ÿÿÿÿ[^Ð1öfƒ;}/SèvúÿÿƒÄ…À”À%ÿ‰Æ÷ށûô“t(û<”t û„”t…Ût‹C8j¿P0ÚR‹@4ÿЃÄ‰ð[^ËT$‹D$ÇB8$“PRèÚëÿÿƒÄА‹T$…Òuè·ìÿÿА‹%ÿÿ=¼úu‹R‹%ÿÿ=­ûu
jÿRèqèÿÿƒÄÐÇ š¸ÿÿÿÿËT$‹D$ÇB8$“PRèrëÿÿƒÄА‹L$‹%ÿÿ=¼úu‹I‹%ÿÿ=­ûu‹A8jjj¿P ÊR‹@$ÿЃÄËT$‹D$ÇB8$“PRèëÿÿƒÄАƒìLWVS‹D$\‹t$`‹\$dPjÿP|$WèxSVWè@‰ÃƒÄ‹T$$9T$ r
jWè©çÿÿƒÄë ‹D$ ÆÿD$ jD$PèƒÄ‰Ø[^_ƒÄLЋT$‹D$ÇB8$“PRè–êÿÿƒÄАUWVS‹t$‹\$jHèÅ{PèSðÿÿ‰Ç‰ýSVWèûñÿÿƒÄ…Àt‰ø[^_]Ѕít‹E8j¿P0êR‹@4ÿЃÄ1À[^_]ЋT$‹D$ÇB8$“PRè&êÿÿƒÄАè ëÿÿА‹T$‹D$ÇB8$“PRèêÿÿƒÄА:
ƒì S‹D$(\$…Àt*€8t%‰D$Pè!Ôÿÿ‰D$ ÇD$x ÇD$\$ƒÄÿ5 šè¿‰PèóÓÿÿ‰CƒÃÇ{ ÇCT$ ‰Ø)ÐÁø@PRjè߃Ä[ƒÄ АWVS‹|$Wè³Óÿÿ‰Æ‹•ƒÄƒ;t/VWÿ3èoÒÿÿƒÄ …Àu‹€<=u F[^_АƒÃƒ;uÔ1À[^_АabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789XXXXXX%c%.5uƒìUWVSè ‰Ãÿt$$èÓÿÿ‰ÅƒÄƒýv‹L$$t)ú¿“ º‰Ñó¦tÇ š‹D$$[^_]ƒÄÐ9•tǘ‰•‹
˜ŠT ˆD$ÿ˜‹˜‰Ð¹>1Ò÷ñ‰˜‰Ø¹ †1Ò÷ñR¾D$‰D$Phš ‹L$0l)ú‰l$ÿt$èÏúÿÿ‰D$ ƒÄƒ|$u
‹D$$[^_]ƒÄÐ1À[^_]ƒÄАÿt$è'PèaƒÄЋT$‹D$ƒø…ÀÇ š¸ÿÿÿÿАHÿ¸Óà ¸А‹T$‹D$ƒø…ÀÇ š¸ÿÿÿÿАHÿ¸þÿÿÿÓÀ!¸А‹D$ǸËD$Çÿÿÿÿ¸ËT$‹D$ƒø…ÀÇ š¸ÿÿÿÿАHÿ¸Óà…•À%ÿАUWVS‹t$‹|$1Ûè)‰Å…ÿt7ƒþt…öt ë*ƒþtë!‰è P됋÷Ð!èP됐ÿ7èá‰ÃƒÄƒ|$t‹T$‰*‰Ø[^_]ÃU‰åƒìWVSÇEô1ۋU9Uôs‹M ‹TÙUôC9]wð‹EôƒÀ$ü)ĉeü‹}ô‰eø1Û9]v;‹M ‰Mì‰þ‹U 9|Ús‹tÚV‹Mìÿ1ÿuøè›ÐÿÿƒÄ uø)÷ƒ}ôt
ƒEìC9]wËÿuôÿuüÿuè­ƒÄ eà[^_ÉÃì$‰àPhTÿt$0èT÷ÐÁèƒÄ ƒÄ$ÃS‹\$¸‹L$ ‹T$̀…À}¸ÿÿÿÿ[ÐVS‹t$ \$‹T$…Òt'‰Ð€:t@€8uú)ÐPRVè´ÿÿÿƒÄ ƒÃ‹Sü…ÒuÛ[^Ã'
: can't load library 'Invalid argument: Over the limits?
No such file or directory.
Permission denied.
Exec format error.

U‰åVS‹U ƒ}Ž²¾ô–ƒ=ô–„Ü‹¸V̀‰Á»ÿÿÿÿ…É|‰Ë…Ûtvjhìÿ6hñÿ2jèßþÿÿƒÄƒût7 ƒûtë>ƒû
tƒûu2jhë jh-됐jhJë
jh_jè’þÿÿ»€¸̀ëòƒÆƒ>…dÿÿÿë>¾ô–ƒ=ô–t"jhtÿ6hwjèKþÿÿƒÄƒÆƒ>uà1Û¸̀ëõeø[^ÉËD$…À|9h},PhA•h •è”öÿÿƒÄ ƒøw1ÀÐƀ•¸ •А‹…ÀÃUnknown errorOperation not permittedNo such file or directoryNo such processInterrupted system callI/O errorNo such deviceArgument list too longExec format errorBad file descriptorNo child processesTry againOut of memoryPermission deniedInvalid addressBlock device requiredDevice or resource busyFile existsCross device linkNot a directoryIs a directoryInvalid argumentFile table overflowToo many open filesInappropriate ioctlText file busyFile too largeNo space left on deviceInvalid seekRead-only file systemToo many linksBroken pipeMath argument out of domainResult too largeResource deadlock would occurFilename too longNo locks availableFunction not implementedDirectory not emptyToo many levels of symbolic linksÈÖî0:I`r†™£±ÃÓé
:/>Ocw‹š©ÁÎäóÿ,J\oˆœ)S‹\$¸̀[АS‹\$¸̀…À} ÷Ø£ š¸ÿÿÿÿ[АS‹\$¸‹L$ ̀…À} ÷Ø£ š¸ÿÿÿÿ[А¸̀…À} ÷Ø£ š¸ÿÿÿÿÃS‹\$¸6‹L$ ‹T$̀…À} ÷Ø£ š¸ÿÿÿÿ[АS‹\$¸%‹L$ ̀…À} ÷Ø£ š¸ÿÿÿÿ[АS‹\$¸‹L$ ‹T$̀…À} ÷Ø£ š¸ÿÿÿÿ[АS‹\$¸‹L$ ‹T$̀…À} ÷Ø£ š¸ÿÿÿÿ[АS‹\$¸‹L$ ‹T$̀…À} ÷Ø£ š¸ÿÿÿÿ[АS‹\$¸È[А¸D̀ÃS‹\$¸0‹L$ º”<̀[ÐS‹D$‹L$ ‰Ã‹A%@t ÇA ”<ë ÇA œ<¸C‹T$̀…À} ÷Ø£ š¸ÿÿÿÿ[ÃS‹\$¸‹L$ ‹T$̀…À} ÷Ø£ š¸ÿÿÿÿ[АVSÿt$ ¡T•ÿЉƉóãÿƒÄ…Ûtº)ډÓS¡T•ÿÐރĉð[^АÇ˜h0è°ÿÿÿ‰Â‰à˜ƒÄ…ÒtQ¡˜@ÁàPjRèÉÈÿÿ¡à˜ÇÇ@Ç@Ç™£ð˜Ç™¸ƒÄ А1ÀÐUWVSÿt$è?ÿÿÿ‰ÅƒÄ…íu
1À[^_]А‰èD$+ð˜yÿÁø @9˜ƒà‹5˜‰êT$‰Ð+ð˜yÿÁø @9ðvöë名vÁãSèÔþÿÿ‰ÇƒÄ…ÿu‹D$÷ØP¡T•ÿÐ1ÀƒÄ[^_]АSjWèãÇÿÿ¡˜@ÁàPÿ5à˜Wè/ÇÿÿƒÄ ‹à˜‰Ø+ð˜yÿÁø @ÇD‡ ‰Ø+ð˜yÿÁø @¡˜@…ÿÁè ‰D—‰=à˜Sè
Èÿÿ‰5˜ƒÄ‰èD$+ð˜yÿÁø @£D™‰è[^_]АƒìUWVS‹\$(…Ûu
1À[^_]ƒÄАƒ=`˜tS¡`˜ÿЃÄ[^_]ƒÄÃ=™u èúýÿÿ…ÀtŃûw»û‡€¿KëGÑëuû‹ý\™…Ûtx‰Ý‹E‹u‰0ƒ}t ‹E‹M‰H‰è+ð˜yÿÁø @‰D$‹5à˜‰t$@ÁâÿLt‹%ÿ‰ùÓè‰Dÿü˜¸‰ùÓàì™ÿ
Иéøhèÿÿÿ‰ÅƒÄ…í„ÿÿÿº¸‰ùÓø9ÂsO4ý‰t$Æ\™‰t$‰D$‰Ð‰ùÓà(‹4ý\™‰3‹L$‰K‹t$‰ž\™ƒ;t‹‰XB9T$w̉è+ð˜yÿÁø @‰D$@Áà‹
à˜‰<J‰T‰T‹ИJ¸‰ùÓø‰И¡ šºÓâ)У š¡ì™ðÿÿУì™éƒÿÁè ‰D$ ‹5™‰t$‰t$‹à˜é‹t$v‹D‚‰D$‹L$9È…Ý‹r‰t$ ™‰Lƒ‰L“ë-‹D;@‹t;‰tƒ‹D;@‹T;‰™‰Tƒÿ
И¡à˜‹L$IÁâÇ‹t$ ‰tÿü˜‰ðÁà ì™) š‰è[^_]ƒÄАÿt$èƒÃÿÿƒÄƒøÿu1ÀÐ@@@@@@@@@@@@@@@((((((((((@@@@@@@!!!!!!@@@@@@""""""@@@@ÿ

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿÿ

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ@BC ‹D$‹@HËT$ƒ|$•À‰Áƒá‰JHА‹D$‹Ãÿt$ÿt$è$ƒÄА‹D$ÿ0è9ƒÄЋD$ÿ0èƒÄЋD$‹ƒ|$•À‰Áƒá‰JHЋD$‹‹@HА‹D$‹Ãÿt$ÿt$èç6ƒÄА‹D$ÿ0èÙƒÄЋD$ÿ0è¹ƒÄЋD$‹ƒ|$•À‰Áƒá‰JHЋD$‹‹@HА‹D$‹Ãÿt$ÿt$èç9ƒÄАVS‹\$ ‹t$jjSè#ƒÄ jjVjLèMdƒÄP耉ƒÄ‰Ø[^АWVS‹\$‹|$‹t$jjSèË"ƒÄ jVWjLèdƒÄPèD‰ƒÄ‰Ø[^_ÐS‹\$jjSèÅ5ƒÄ jLèãcPè)‰ƒÄ‰Ø[ÃWVS‹|$‹\$‹t$jjWè“5ƒÄ ƒþtƒþuS謼ÿÿ؃Ä됉ØPÿt$SjLè‘cƒÄPèĉƒÄ‰ø[^_ÐS‹\$jjSè¥8ƒÄ jLèccP詉ƒÄ‰Ø[ÃWVS‹|$‹\$‹t$jjWès8ƒÄ ƒþtƒþuSè,¼ÿÿ؃Ä됉ØPÿt$SjLècƒÄPèD‰ƒÄ‰ø[^_ЋD$Ç@H‹@DЋT$‹B+B9B ‹SD‰ÐBüt‹CDëÇBü‹CDƒÀøPè=_ƒÄÇC8$“ÿt$ SèMÎÿÿƒÄ[ÃUWVS‹t$‹\$‹l$ VèŽüÿÿ‰ÁºÿÿÿÿƒÄ÷ÅtLŠ$tFƒ|$t ƒ|$u Ëë‹F+FÅÛ|9Ëv ¸ÿÿÿÿ[^_]А‰ØFD‰ÊVD‹~D‰~ ‰F‰V‰Ú÷Åt2Š$t,ƒ|$t ƒ|$u Ëë‹F+FÅÛ|°9Ëw¬‰ß~D‰~‰Ú‰Ð[^_]А‹T$‹D$ÇB8$“PRèzÍÿÿƒÄАUWVS‹\$‹|$‹k‹s)ît‹CD‹P8VU¿BXCDP‹B\ÿÐƒÄ )sƒÿÿtƒ{@u‹CD‹P8W¿BCDP‹BÿЃÄ[^_]ËK9Kr‰ù¶ÁPSèÜÉÿÿƒÄ[^_]ËC‰ùˆÿC¶Á[^_]АVS‹\$ ÇC8À•‹K‹s)Ît‹CD‹P8VQ¿BXCDP‹B\ÿÐƒÄ )sÇC8$“ÿt$Sè©ÌÿÿƒÄ[^АìHUWVS‹¼$\‹¬$dt$\$Xh@VèÌÿÿƒÄÇD$HÀ•‰|$T‰\$LÇD$Pd$ÿýÿÿƒd$ý‹D$LD$P‰\$$‰\$ ‰D$(Uÿ´$dVè‰ÃjVè5ÿÿÿƒÄ‰ØƒÄ [^_]ÄHА 0000000000000000(null)0123456789ABCDEF0123456789abcdefbug in vform: bad baseU‰åìWVS‹U ‹M‹I8‰œþÿÿ‹}Džtþÿÿ‹M‹Ñè¨tWRÿuèÏþÿÿƒÄ é¬
‰•˜þÿÿDžþÿÿ‹µ˜þÿÿ¾ëÿ…˜þÿÿ‹˜þÿÿ¾ ‰”þÿÿ…Ét ƒ½”þÿÿ%uދ˜þÿÿ)ót&SV‹œþÿÿ¿AXEP‹A\ÿÐƒÄ 9Ø…<
þÿÿƒ½”þÿÿ„!
ÿ…˜þÿÿDžpþÿÿDž€þÿÿDž„þÿÿDžŒþÿÿDžˆþÿÿÿÿÿÿƅ¢þÿÿ‹˜þÿÿ¾ ‰”þÿÿÿ…˜þÿÿ‹…”þÿÿƒÀàƒøX‡;ÿ$…ø*\,,1,1x,,1,1,1,1,1,1„,¬,,1ž,¸,,1X-d-d-d-d-d-d-d-d-d-,1,1,1,1,1,1,1,1,1,1Ø- .,1 .,1,1,1,1 -,1,1/,1,1,1,1,1ì/,1,1$0,1,1,1,1,1,1,1,1,1,1Ä-ß- . . .¬-ß-,1,1¸-,1Ø./P/,1,1t/,1ó/,1,1$0€½¢þÿÿ…aþÿÿƅ¢þÿÿ éUþÿÿ€pþÿÿéFþÿÿƒÇ‹Oü‰Œþÿÿ…ɍ2þÿÿ÷Œþÿÿ€pþÿÿé þÿÿÆ…¢þÿÿ+éþÿÿ‹˜þÿÿ¾ ‰”þÿÿÿ…˜þÿÿƒù*u*ƒÇ‹_ü‰ˆþÿÿƒ½ˆþÿÿßýÿÿDžˆþÿÿÿÿÿÿéÐýÿÿ1ۋ…”þÿÿë&›‹”þÿÿ\AЋ˜þÿÿ¾ ‰”þÿÿÿ…˜þÿÿ‰ÈƒÀЃø vԉˆþÿÿƒ½ˆþÿÿ˜ýÿÿDžˆþÿÿÿÿÿÿé‰ýÿÿ€pþÿÿ éfýÿÿ1ې›‹”þÿÿ\AЋ˜þÿÿ¾ ‰”þÿÿÿ…˜þÿÿ‰ÈƒÀЃø vԉŒþÿÿé@ýÿÿ€pþÿÿéýÿÿ€pþÿÿéýÿÿ€pþÿÿéýÿÿµ¤þÿÿƒÇŠOüép€pþÿÿ‹pþÿÿöÁu‹pþÿÿöÁt ƒÇ¿Wü됐ƒÇ‹Wü…Ò} ÷Úƅ¢þÿÿ-¸éOƒÇÝGøƒ½ˆþÿÿ'~9ƒ½”þÿÿgt ƒ½”þÿÿGu ‹pþÿÿöÁt‹ˆþÿÿƒÁى„þÿÿDžˆþÿÿ'됃½ˆþÿÿÿu
Džˆþÿÿµ¤þÿÿƅ¤þÿÿUVÿµ”þÿÿ…£þÿÿPÿµpþÿÿÿµˆþÿÿƒìÝ$蚉…tþÿÿƒÄ €½£þÿÿtƅ¢þÿÿ-€>…ŒF醐‹pþÿÿöÁu!‹pþÿÿöÁtƒÇ‹Güf‹þÿÿf‰éûÿÿƒÇ‹Gü‹þÿÿ‰é ûÿÿ€pþÿÿ‹pþÿÿöÁu‹pþÿÿöÁt ƒÇ·Wü됐ƒÇ‹Wü1À鐐ƒÇ‹Wü¸€pþÿÿ@Dž”þÿÿxéôƒÇ‹wü…öu¾ˆ)ƒ½ˆþÿÿ|LÿµˆþÿÿjVè²°ÿÿƒÄ …Àt#)ð‰…tþÿÿ‹ˆþÿÿ9ÈŽž‰tþÿÿ铐‹ˆþÿÿ‰tþÿÿ逐Vèâ¯ÿÿ‰…tþÿÿƒÄéi€pþÿÿ‹pþÿÿöÁu‹pþÿÿöÁt ƒÇ·Wü됐ƒÇ‹Wü¸ëD‹pþÿÿöÁu‹pþÿÿöÁt
ƒÇ·Wü됃NjWü¸‹pþÿÿöÁt …Òt€pþÿÿ@ƅ¢þÿÿ‹ˆþÿÿ‰€þÿÿ…É|ƒ¥pþÿÿ߉î…Òu
ƒ½ˆþÿÿ„ŠƒøtH…Àt ëuƒøtGëmNˆÐ$0ˆÁêuò‹pþÿÿöÁt[€>0tVNÆ0ëPN‰Ð¹
1Ò÷ñ€Â0ˆ‰Âƒú wèN€Â0ˆë0» )ƒ½”þÿÿXu»)N‰ÐƒàŠˆÁêuðë
¾±)ë=‰é)ñ‰tþÿÿë0ƒ½”þÿÿ„sµ¤þÿÿŠ”þÿÿˆ¤þÿÿDžtþÿÿƅ¢þÿÿ‹tþÿÿ„þÿÿ‰|þÿÿ€½¢þÿÿt ÿ…|þÿÿ됋pþÿÿöÁ@tƒ…|þÿÿ‹€þÿÿ‰xþÿÿ‹|þÿÿ9xþÿÿ}‰xþÿÿö…pþÿÿ0ug‹Œþÿÿ+xþÿÿ…Û~Wƒû~.jhh)‹œþÿÿ¿AXEP‹A\ÿÐƒÄ ƒø…¾ƒÃðƒûÒShh)‹œþÿÿ¿AXEP‹A\ÿÐƒÄ 9Ø…’€½¢þÿÿt-j…¢þÿÿP‹œþÿÿ¿AXEP‹A\ÿÐƒÄ ƒø…aë_‹pþÿÿöÁ@tQƅ þÿÿ0f¶…”þÿÿfÁàf¶ þÿÿf‰ þÿÿf … þÿÿj… þÿÿP‹œþÿÿ¿AXEP‹A\ÿÐƒÄ ƒø…‹…pþÿÿƒà0ƒø uh‹Œþÿÿ+xþÿÿ…Û~Xƒû~/jhx)‹œþÿÿ¿AXEP‹A\ÿÐƒÄ ƒø…¶ƒÃðƒûÒShx)‹œþÿÿ¿AXEP‹A\ÿÐƒÄ 9Ø…Š‹€þÿÿ+|þÿÿ…Û~Xƒû~/jhx)‹œþÿÿ¿AXEP‹A\ÿÐƒÄ ƒø…NƒÃðƒûÒShx)‹œþÿÿ¿AXEP‹A\ÿÐƒÄ 9Ø…"ÿµtþÿÿV‹œþÿÿ¿AXEP‹A\ÿÐƒÄ 9…tþÿÿ…ù‹„þÿÿ…Û~Yƒû~0jhx)‹œþÿÿ¿AXEP‹A\ÿÐƒÄ ƒø…ƒÃðƒûÒShx)‹œþÿÿ¿AXEP‹A\ÿÐƒÄ 9Ø…–‹pþÿÿöÁta‹Œþÿÿ+xþÿÿ…Û~Qƒû~,jhh)‹œþÿÿ¿AXEP‹A\ÿÐƒÄ ƒøuRƒÃðƒûÖShh)‹œþÿÿ¿AXEP‹A\ÿÐƒÄ 9Øu*‹…Œþÿÿ9…xþÿÿ~‹…xþÿÿ…þÿÿéwõÿÿ‹…þÿÿë¸ÿÿÿÿ¥dþÿÿ[^_ÉÁì8VS‹œ$D‹„$HŠ”$LˆC…À}÷ØÆ-ëÆ+C´$@‰ñƒø ~BI¾
™÷þ‰T$ŠT$€Â0ˆƒø åI0ˆ´$@9ñsŠˆAC´$@9ñrïë
Æ0C0ˆC‰Ø[^Ä8Ã$@@ƒìUWVSÝD$‹|$$‹t$(‹\$,ŠT$0‹l$4Ùäßàžt&D$PÜ
X5ƒìÝ$è¸ÝØƒÄ ëÆ1ÿëiÝؾƒÀÐPÛ$ƒÄÝ\$ÝD$Ü`5ßàžv&€;.uKþ€;9~7Æ09óu …ÿu¼ÆFÿ1Në%Këݐ€}-u€;.uK€;0u
9óuÆEKëꐐ‰ð[^_]ƒÄА$@{®Gáz„?-Cëâ6?ƒì0UWVSÝD$D‹|$L‹l$\‹T$`ÇD$(ÇD$,Ý(6ØÙßàžv Ùà‹D$TÆ-됋D$TƍD$8PƒìÝ$‰T$0è¹E‰î‹T$0ZÿƒÄ ÝD$8ÙäÝØßàž„•Ý06됐ÙɍD$8PÙÀÜ|$<ƒìÝ$‰T$0ÙÉÝ\$(Ý\$ èjÝ\$<Ý86ÜD$<ÝD$ ÜÉÙɃìÙ<$f‹$f
f‰D$Ùl$Û\$ Ù,$ƒÄŠD$0ˆKƒÄ ÿD$,ÝD$8‹T$$ÝD$ÙÉÙäÝØßàž…xÿÿÿÝًL$XƒÁ»ƒù"‡Êÿ$p7È80<:0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<0<È8ü7:ƒ|$,tC9ÓsŠˆFC9ÓröëÆ0F…ÿu‹D$P¨tÆ.FÙäßàžt}…ÿtRD$0PÜ
06ƒìÝ$èÝD$<ƒìÙ<$f‹$f
f‰D$Ùl$Û\$ Ù,$ƒÄŠD$0ˆFƒÄ OtÙäßàžu¯Ùäßàžt ÿt$TjFÿPUjƒìÝ$èÄüÿÿ‰ÅƒÄëÝØOƒÿÿ„zÆ0FOƒÿÿuöékƒ|$,tiCŠˆF…ÿu‹D$P¨t
Æ.F됊ˆFO…ÿt C9Órñ…ÿu1C9Ós,ÝØÙîÿt$T¾PFÿPUD$ 06ƒìÝ$èþƒÄ ÝD$0ÙäÝØßàžuÿL$,ëØÝD$0ƒìÙ<$f‹$f
f‰D$Ùl$Û\$Ù,$ƒÄŠD$0ˆëÆ0F…ÿu‹D$P¨tÆ.FÙäßàž„‰…ÿtRD$0PÜ
06ƒìÝ$è~ÝD$<ƒìÙ<$f‹$f
f‰D$Ùl$Û\$ Ù,$ƒÄŠD$0ˆFƒÄ OtÙäßàžu¯Ùäßàžt,ÿt$TjFÿPUD$0tö€>.uNFÿt$Xÿt$0VèAúÿÿ‰ÆƒÄ 饐…ÿu¿9|$,ƒ|$,u-ÙäßàžtÜ@6ßàžsOƒD$XþÇD$(éýýÿÿƒ|$,tC9ÓsŠˆFOC9Órõ됐Æ0F…ÿu‹D$P¨t »Æ.Fë1ÛÙäßàž„ë…ÿ„¼D$0PÜ
06ƒìÝ$è*ÝD$<ƒìÙ<$f‹$f
f‰D$Ùl$Û\$ Ù,$ƒÄŠD$0ˆFƒÄ ÝD$0ÙäÝØßàžuƒ|$,t¥Ot[Ùäßàžt{D$0PÜ
06ƒìÝ$èÂÝD$<ƒìÙ<$f‹$f
f‰D$Ùl$Û\$ Ù,$ƒÄŠD$0ˆFƒÄ OtÙäßàžu¯Ùäßàžt ÿt$TjFÿPUjƒìÝ$ètùÿÿ‰ÅƒÄëÝ؋D$P¨tOƒÿÿt&Æ0FOƒÿÿuöë…Ût9îvN€>0tö€>.tF됐Ý؉ð)è[^_]ƒÄ0А‹T$‹D$ÇB8$“PRè¹ÿÿƒÄАƒì‹T$ Ù|$f‹D$€Ì f‰D$Ùl$ÝD$ÙüÝT$Ùl$ÝÝD$Üd$ƒÄÃÄXYZÃƒÄèøÙÿÿƒÄXYZÃ‹D$€xt1ÀАƒxt ÿpè>ƒÄ¸ЋD$ö@
`t P蘃ÄËD$‹Ãÿt$ ÿt$ ÿt$ è3ƒÄ Аÿt$ ÿt$ ÿt$ èƒÄ А¾D$Pÿt$èåƒÄÐÿt$ÿt$è+ƒÄА¿D$Pÿt$蹃ÄзD$Pÿt$èƒÄЋD$ÿt$ÿЃÄАS‹\$‹D$ SÿЉ؃Ä[ЋD$‹Ãÿt$ÿt$菃ÄАÿt$ ÿt$ ÿt$ èo ƒÄ Аÿt$ ÿt$ ÿt$ èW ƒÄ АVS‹\$ ‹t$€{t €K1À[^Аƒ{t…öt‹‹P+P‰Ð9ð} ÿsèìƒÄ…öuŠC $tSè ƒÄŠ@¨t1À[^и[^ÃS‹\$€{t €K1À[Ѓ{t ÿs螃ĊC $tSèփĊ@¨t1À[ø[ЋT$€zt
€J1ÀАƒzt‹‹H+H‰È…Àu ÿrèHƒÄ¸АVS‹t$ €~t €N¸ÿÿÿÿ[^Ã~t‹‹P+P‰Ð…Àu ÿvèƒÄ‹‹S9SrS葱ÿÿƒÄƒøÿu ¸ÿÿÿÿë ‹C¶ÿCƒøÿu€N[^АVS‹t$ €~t €N¸ÿÿÿÿ[^Ã~t‹‹P+P‰Ð…Àu ÿv蘃ċ‹S9SrSè!±ÿÿƒÄƒøÿu ¸ÿÿÿÿ됐‹C¶ƒøÿu€N[^А‹D$‹@ÃS‹\$ŠD$ €{u¾ÀPÿ3è*¶ÿÿƒÄƒøÿuÆC‰Ø[АS‹\$€{uÿ3èF¶ÿÿƒÄƒøÿuÆC‰Ø[АS‹\$ŠD$ €{u¾ÀPÿ3èÚµÿÿƒÄƒøÿuÆC‰Ø[Аÿt$ÿt$èûƒÄАÿt$ÿt$èkƒÄАS‹\$‹D$ SÿЉ؃Ä[ЋD$ÿt$ÿЃÄА‹D$А‹D$Аÿt$ÿt$裃ÄАÿt$ÿt$菃ÄАÿt$ ÿt$ ÿt$ èoƒÄ Аÿt$ ÿt$ ÿt$ èWƒÄ Аÿt$ ÿt$ ÿt$ è?ƒÄ А¾D$Pÿt$ÿt$ÿt$葃ÄоD$Pÿt$ÿt$ÿt$èéƒÄоD$ Pÿt$ ÿt$ è=ƒÄ Ðÿt$ ÿt$ ÿt$ èSƒÄ АVS‹\$ ‹t$€{t €K1À[^Аƒ{t…öt‹‹P+P‰Ð9ð} ÿsèlƒÄ…öuŠC $tS蠃Ċ@¨t1À[^и[^ÃS‹\$€{t €K1À[Ѓ{t ÿsèƒÄŠC $tSèVƒÄŠ@¨t1À[ø[ЋT$€zt
€J1ÀАƒzt‹‹H+H‰È…Àu ÿrèȃĸАS‹D$‹‹S9SrSèC®ÿÿƒÄƒøÿu¸ÿÿÿÿ[ËC¶ÿC[ÐS‹\$€{t €K1ÀëQƒ{t‹‹P+P‰Ð…Àu ÿsè\ƒÄ¸…Àt(‹‹S9SrSèÜ­ÿÿƒÄƒøÿu¸ÿÿÿÿ[ЋC¶[øÿÿÿÿ[ЋD$‹@ÃS‹\$ŠD$ €{u¾ÀPÿ3èê²ÿÿƒÄƒøÿuÆC‰Ø[АS‹\$€{uÿ3è³ÿÿƒÄƒøÿuÆC‰Ø[Аÿt$ÿt$è;ƒÄАÿt$ ÿt$ ÿt$ èOƒÄ Аÿt$èoƒÄАÿt$ ÿt$ ÿt$ è×ƒÄ АS‹\$ŠD$ €{u¾ÀPÿ3èF²ÿÿƒÄƒøÿuÆC‰Ø[А‹D$€xt1ÀАƒxt ÿpè*ƒÄ¸ЋD$ö@
`t P脃ÄÃÿt$èƒÄА¾D$Pÿt$衃ÄÐÿt$ ÿt$ ÿt$ èƒÄ Аÿt$ ÿt$ ÿt$ èëƒÄ Аÿt$ ÿt$ ÿt$ èÓƒÄ Аÿt$ ÿt$ ÿt$ è[ƒÄ Аÿt$ÿt$苃ÄАÿt$ ÿt$ ÿt$ èŸƒÄ Аÿt$迃ÄАVS‹\$ ¾L$‹‹r9rr¶ÁPRèm­ÿÿƒÄë‹BˆÿB‰Ø[^А‹D$‹P €â€Ê‰P А‹D$‹P €â€Ê@‰P А‹D$‹P €â€Ê ‰P А‹D$Ç̔Æ@Ç@Æ@ Ç@ fÇ@H €Ç@Ç@ËD$‹T$ ‹L$‰Æ@Ç@Æ@ Ç@ fÇ@H €Ç@‰PÃVS‹\$ ‹t$ƒ{ |ƒ;t‹‹P8j¿B0P‹B4ÿЃÄK €Ç̔÷Æt Sèf@ƒÄ[^ÃS‹\$‹K9KrS螪ÿÿƒÄƒøÿu
ºÿÿÿÿë ‹C¶ÿCƒúÿt ¡ˆ’ŠP$uƉÐ[АWVS‹t$‹|$€~t€NëWƒ~t‹‹P+P‰Ð…Àu ÿv蜃ċ‹S9SrSè%ªÿÿƒÄƒøÿu ¸ÿÿÿÿë ‹C¶ÿCƒøÿu€N눉ð[^_ÃUWVS‹|$‹t$‹l$€t€Oë^€OëXƒt‹‹P+P‰Ð…Àu ÿwèƒÄ‹Nx/‹S9SrS蟩ÿÿƒÄƒøÿu¸ÿÿÿÿë ‹C¶ÿCƒøÿt¦9èuΉø[^_]АVS‹\$ ‹t$€{u<ƒ{t‹‹H+H‰È…Àu ÿs謃ċ‹P8Vÿt$¿B`P‹BdÿÐƒÄ 9ðt€K‰Ø[^АS‹\$‹‹P8jÿt$¿B(P‹B,ÿÐƒÄ ƒøÿu€K‰Ø[ÃS‹\$‹‹P8jÿt$ÿt$¿B P‹B$ÿЃÄƒøÿu€K‰Ø[ÃS‹\$‹‹P8jjj¿B P‹B$ÿЃÄƒøÿu€K[АS‹\$€{t €Kë>ƒ{t ÿsèփĊC $tSèƒÄŠ@¨uD$Pÿt$ÿ3èìƒÄ ‰Ø[ÐS‹\$€{t €Kë=ƒ{t ÿs肃ĊC $tS躃Ċ@¨uÿt$ÿt$ÿ3è™ƒÄ ‰Ø[АWVS‹t$‹|$€~t€Në_ƒ~t ÿvè*ƒÄŠF $tVèbƒÄŠ@¨u6‹‹S9SrS蜧ÿÿƒÄƒøÿu¸ÿÿÿÿë
‹C¶ÿCƒøÿu€N눉ð[^_ÃUWVS‹|$‹l$€t
€Oéːƒt ÿw誃ĊG $tWèâƒÄŠ@¨…ž‹‹K9KrSè§ÿÿƒÄƒøÿuºÿÿÿÿë
‹C¶ÿCƒúÿu€Oëj‹GÇG‰ÆˆÐˆEE‹K9KrSèÒ¦ÿÿƒÄƒøÿu
ºÿÿÿÿë ‹C¶ÿCƒúÿt¸¡ˆ’ŠP$uƒþt ˆÐˆEEN븀ORSèÝ«ÿÿƒÄÆE‰ø[^_]АUWVS‹|$€…Þƒt ÿwèÀƒÄŠG $tWèøƒÄŠ@¨…¶‹¾
1íSè{ûÿÿƒÄƒøÿ„£‹L$ǃø+tƒø-u‹L$ÇSèKûÿÿƒÄƒøÿ„s‹W öÂp…£ƒø0…°‹K9KrSèÐ¥ÿÿƒÄƒøÿu¸ÿÿÿÿë
‹C¶ÿCƒøÿu‹L$Ǹ[^_]АƒøxtƒøXu6¾‹K9KrSè¥ÿÿƒÄƒøÿu¸ÿÿÿÿë ‹C¶ÿCƒøÿ„Þë.PS襪ÿÿ¾¸0ƒÄ됐öÂ@t¾ë
ö t¾‹L$ǃøÿ„sÿÿÿƒø/~
ƒø9PÐë"ƒø@~ ƒøFPÉ됺çƒø`~ƒøfP©9ò|…ítVPSè+ªÿÿ¸ƒÄ[^_]АE‰ð‹L$¯Љ‹K9KrSè°¤ÿÿƒÄƒøÿu ¸ÿÿÿÿézÿÿÿ‹C¶ÿCéjÿÿÿ€O1À[^_]ЀO1À[^_]ЃìVS‹\$‹t$D$PD$PSèÛýÿÿƒÄ …Àtƒ|$t÷\$ f‹T$ f‰‰Ø[^ƒÄЃìVS‹\$‹t$D$PD$PSè›ýÿÿƒÄ …Àtƒ|$t÷\$ f‹T$ f‰‰Ø[^ƒÄЃìVS‹\$‹t$D$PD$PSè[ýÿÿƒÄ …Àtƒ|$t÷\$ ‹T$ ‰‰Ø[^ƒÄАƒìVS‹\$‹t$D$PD$PSèýÿÿƒÄ …Àtƒ|$t÷\$ ‹T$ ‰‰Ø[^ƒÄАƒìVS‹\$‹t$D$PD$PSèÛüÿÿƒÄ …Àtƒ|$t÷\$ ‹T$ ‰‰Ø[^ƒÄАƒìVS‹\$‹t$D$PD$PSè›üÿÿƒÄ …Àtƒ|$t÷\$ ‹T$ ‰‰Ø[^ƒÄА%lgS‹\$€{t €Kë=ƒ{t ÿsè2 ƒÄŠC $tSèj ƒÄŠ@¨uÿt$ h°MSèúÿÿƒÄ ‰Ø[А%gS‹\$€{t €Kë=ƒ{t ÿsèÚ ƒÄŠC $tSè ƒÄŠ@¨uÿt$ hNSè¹ùÿÿƒÄ ‰Ø[АWVS‹t$‹|$€~t钐€N鋐ƒ~t ÿvèv ƒÄŠF $tVè® ƒÄŠ@¨u`‹‹K9KrSèæ¡ÿÿƒÄƒøÿu
ºÿÿÿÿë ‹C¶ÿCƒúÿtš‹O9Or¶ÂPWèX£ÿÿƒÄ됐‹GˆÿG¶Âƒøÿu¨€N‰ð[^_Аƒì WVS‹|$ŠL$ ˆL$€…Öƒt ÿwèÊ
ƒÄ‹GÇGŠOˆL$1ö…À~pÿ‹ŠG $u3Nx0¾T$‹K9Kr¶ÂPS‰T$èÆ¢ÿÿƒÄ‹T$ ë ‹CˆÿCNyÕ¾T$‹K9Kr¶ÂPS蚢ÿÿƒÄë ‹CˆÿCŠG $t4Nx1¾T$‹K9Kr¶ÂPS‰T$èf¢ÿÿƒÄ‹T$ ë ‹CˆÿCNyÕöG
`t Wèy ƒÄ‰ø[^_ƒÄ Ð%lu%lo0%lX0X%lx0xƒì4UWVS‹\$LÇD$(P1í‹|$H‹G ¨`uShPD$4PèÜ·ÿÿƒÄ 醨 t,ShPD$4PèÀ·ÿÿƒÄ ‹L$Hƒy teÇD$(P½ëVöÄt'ShPD$4P菷ÿÿƒÄ ‹|$Hƒ t4ÇD$(Pë%Sh"PD$4Pèh·ÿÿƒÄ ‹L$Hƒy t
ÇD$(&P½D$,Pè̎ÿÿ‰D$(ƒÄ‹|$H‹GÇG‰ÆÇD$ ‹T$$ƒ|$PtBë"…Ût‹L$Hf‹A f%t
‹T$$BÇD$ ê9ò~ ÇD$ë)։t$‹|$H‹‹O ƒá‰L$ŠOˆL$ƒ|$t?ƒ|$t8‹t$Nx1¾T$‹{9{r¶ÂPS‰T$覠ÿÿƒÄ‹T$ë ‹CˆÿCNyՃ|$Pt‹K9Krj-됐‹CÆ-ë"ƒ|$ t‹{9{r
j+Sè] ÿÿƒÄë ‹CÆ+ÿC…ít‹C8Uÿt$,¿PXÚR‹@\ÿÐƒÄ ƒ|$u8‹t$Nx1¾T$‹K9Kr¶ÂPS‰T$è
 ÿÿƒÄ‹T$ë ‹CˆÿCNyՋS8ÿt$$D$0P¿BXØP‹B\ÿÐƒÄ ƒ|$u:‹t$Nx3¾T$‹{9{r¶ÂPS‰T$讟ÿÿƒÄ‹T$ë ‹CˆÿCNyՋL$HöA
`t ÿt$H躃Ä[^_]ƒÄ4АVS‹t$ ‹\$€~u+ƒ~t ÿvèƒÄ1À…Û} öF `u÷Û@PSVè$ýÿÿƒÄ ‰ð[^ÃVS‹t$ ‹\$€~u+ƒ~t ÿvèÚƒÄ1À…Û} öF `u÷Û@PSVèäüÿÿƒÄ ‰ð[^ÃS‹\$€{u ƒ{t ÿs蟃Äjÿt$Sè´üÿÿƒÄ ‰Ø[ÐS‹\$€{u ƒ{t ÿsèoƒÄjÿt$Sè„üÿÿƒÄ ‰Ø[ÐÙD$ƒìÝ$ÿt$ èƒÄ ÐU‰åì|WVS‹}€…}ƒt ÿwèƒÄDžœþÿÿ‹G f…À}ºfë(öÄtºeöÄtºE됐ºgöÄtºG·G¤þÿÿ‰˜þÿÿƅ¤þÿÿUQR…£þÿÿPf‹G f%•ÀÁà%€P·GPÿuÿu èÐáÿÿ‰…”þÿÿƒÄ €½£þÿÿt
Džœþÿÿ-‹˜þÿÿ€9uÿ…˜þÿÿ‹…”þÿÿƒÀƒ½œþÿÿt@Džþÿÿ‹WÇG9Ð})‰•þÿÿ‹ŠOˆŒþÿÿ‹O ƒá‰„þÿÿƒùtKƒ½„þÿÿtB‹µþÿÿNx9¾•Œþÿÿ‹K9Kr¶ÂPS‰•ˆþÿÿè ÿÿƒÄ‹•ˆþÿÿë ‹CˆÿCNyу½œþÿÿt*‹K9KrÿµœþÿÿSèìœÿÿƒÄ됐‹CŠœþÿÿˆÿCƒ½„þÿÿu@‹µþÿÿNx7¾•Œþÿÿ‹K9Kr¶ÂPS‰•ˆþÿÿ褜ÿÿƒÄ‹•ˆþÿÿë ‹CˆÿCNyыC8ÿµ”þÿÿÿµ˜þÿÿ¿PXÚR‹@\ÿÐƒÄ 1öë$‹K9Krj0SèXœÿÿƒÄë ‹CÆ0ÿCNy܃½„þÿÿuB‹µþÿÿNx9¾•Œþÿÿ‹K9Kr¶ÂPS‰•ˆþÿÿèœÿÿƒÄ‹•ˆþÿÿë ‹CˆÿCNyÑöG
`t Wè!ƒÄ‰ø¥xþÿÿ[^_ÉÃìUWVS‹l$€}…݃}t ÿuèyƒÄÿt$ è%‰ÿÿ‰ÇƒÄ‹EÇEŠMˆL$‹]1ö9ø~‰Æ)þŠE $u6Nx3¾T$‹K9Kr¶ÂPS‰T$èb›ÿÿƒÄ‹T$ë ‹CˆÿCNyՋS8Wÿt$$¿BXØP‹B\ÿÐƒÄ ŠE $t6Nx3¾T$‹K9Kr¶ÂPS‰T$è›ÿÿƒÄ‹T$ë ‹CˆÿCNyÕöE
`t Uè!ƒÄ‰è[^_]ƒÄÃ0x%xƒìS‹\$ €{u<ƒ{t ÿsè|ƒÄ‹T$‰T$D$PhhWÿ3è ÒÿÿƒÄ öC
`t SèŃĉØ[ƒÄАWVS‹|$‹t$€u~ƒt ÿwè%ƒÄ‹‹N9NrV讘ÿÿƒÄƒøÿu
ºÿÿÿÿë ‹F¶ÿFƒúÿt.‹K9Kr¶ÂPSè šÿÿƒÄ됐‹CˆÿC¶Âƒøÿu¨€OöG
`t Wè,ƒÄ‰ø[^_А‹D$Ç̔Æ@Ç@Æ@ Ç@ fÇ@H €Ç@А‹D$‹T$ ‹L$‰Æ@Ç@Æ@ Ç@ fÇ@H €‰PАVS‹\$ ‹t$ƒ{ |ƒ;t‹‹P8j¿B0P‹B4ÿЃÄK €Ç̔÷Æt Sè>-ƒÄ[^ÃS‹\$‹‹P8jÿt$¿B(P‹B,ÿÐƒÄ ƒøÿu€K‰Ø[ÃS‹\$‹‹P8jÿt$ÿt$¿B P‹B$ÿЃÄƒøÿu€K‰Ø[ÃS‹\$‹‹P8jjj¿B P‹B$ÿЃÄƒøÿu€K[АS‹\$€{u$ƒ{t ÿsèOƒÄD$Pÿt$ÿ3èüÏÿÿƒÄ ‰Ø[ÐS‹\$€{u#ƒ{t ÿsèƒÄÿt$ÿt$ÿ3èÉÏÿÿƒÄ ‰Ø[АS‹\$‹‹P8¿B8P‹B<ÿЃÄ…Àt€K‰Ø[АS‹\$‹‹H8jÿ¿QÐP‹AÿЉ؃Ä[ÐVS‹t$ €~t€Nëo€Nëgƒ~t‹‹H+H‰È…Àu ÿvè€ÿÿÿƒÄ‹‹K9KrSè–ÿÿƒÄƒøÿuºÿÿÿÿë
‹C¶ÿCƒúÿtª¡ˆ’ŠP$uÆRÿ6è&›ÿÿƒÄ‰ð[^АS‹\$‹‹J9Jr
jRèY—ÿÿƒÄë ‹BÆÿB‰Ø[АS‹\$‹‹J9Jr
j
Rè-—ÿÿƒÄë ‹BÆ
ÿBSèÿÿÿƒÄ[ÃVS‹\$ ‹t$€{u2ƒ{t ÿsè¶þÿÿƒÄ‹‹P8Vÿt$¿BXP‹B\ÿÐƒÄ 9ðt€K‰Ø[^ÐS‹\$f‹C f% t SèwþÿÿƒÄf‹C f%@th<”èø­ÿÿh„”èî­ÿÿƒÄ[ЋD$Ç̔Æ@Ç@Æ@ Ç@ fÇ@H €Ç@Ç@ËD$‹T$ ‹L$‰Æ@Ç@Æ@ Ç@ fÇ@H €‰PАVS‹\$ ‹t$ƒ{ |ƒ;t‹‹P8j¿B0P‹B4ÿЃÄK €Ç̔÷Æt SèÞ)ƒÄ[^ÃS‹\$D$Pÿt$ÿ3è;Íÿÿ‰ØƒÄ [ÃS‹\$€{t €K1ÀëIƒ{t ÿsèRýÿÿƒÄŠC $tSèŠýÿÿƒÄŠ@¨t1À븅ÀtD$Pÿt$ÿ3è[ƒÄ ‰Ø[ÃS‹\$ƒ{ |ƒ;tB‹‹P8j¿B0P‹B4ÿЃÄë*‹fƒ8}P芦ÿÿë;̔t‹@8¿P8R‹@<ÿЃÄK €Ç̔[А‹T$‹B ƒàƒ|$t€J Аƒb þАˆp‹T$‹D$ÇB8$“PRèڗÿÿƒÄАƒìVS‹\$‹t$ŠL$ˆL$ÇC€{uFƒ{t‹‹H+H‰È…Àu ÿsè*üÿÿƒÄj¾D$ PVÿt$ ÿ3èg‰Â‰SƒÄ…Ò~Fÿ9Âu€K‰Ø[^ƒÄÃìS‹\$ ŠT$ˆT$ÇC€{u=ƒ{t‹‹P+P‰Ð…Àu ÿsè»ûÿÿƒÄjÿ¾D$Pÿt$ÿt$ÿ3èõƒÄ…À€Kë‰C‰Ø[ƒÄАìUWVS‹œ$‹´$ ŠŒ$$ˆL$jÿ¾D$PhD$ PS衉ǃăÿÿu1À[^_]ÄА‹K9KrSè‘ÿÿƒÄƒøÿu
ºÿÿÿÿë ‹C¶ÿC‹.>ƒúÿt:¾D$9Ât1PVSèiÿÿÿ‰ÃƒÄ …ÛtTD$WPR言ÿÿƒÄ ‰Ø[^_]ÄË@Pès'‰ÃƒÄ…Û„oÿÿÿ‹Æ‰Ø)øT$WRPèj€ÿÿƒÄ ‰Ø[^_]ÄАƒìWVS‹\$‹|$ŠT$ ˆT$ €{t€Kërƒ{t‹‹P+P‰Ð…Àu ÿsèHúÿÿƒÄÇD$‹3¾D$ PD$PVè¢þÿÿ‰…Àt ‹T$‰Së
ÇCŠ$ƒÄ „Àt€Kƒ{u€K됐ÇCljØ[^_ƒÄА‹T$‹D$ÇB8$“PRè2•ÿÿƒÄАìˆUWVS‹œ$œ‹[8‰\$4‹Œ$¤‰L$0‹œ$ ‰\$,ÇD$ ÇD$ÇD$(ÇD$$L$8‰L$‹\$,¶3ÿD$,…ö„é
¡ˆ’Šp$tY‹Œ$œ‹Y9Yrÿ´$œèɏÿÿƒÄƒøÿu ¾ÿÿÿÿ됐‹Œ$œ‹A¶0ÿAƒþÿ„—
¡ˆ’Šp$t/ÿD$$멐ƒþ%…1í1ҋ\$,¶3ÿD$,ƒþx‡§ÿ$µXaVÿ´$ 觔ÿÿƒÄéKÿÿÿŒnàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàdàd ÇD$ÿÿÿÿ됐‹Œ$œ‹A¶‰D$ÿAƒ|$ÿ„ù
9t$… ÿD$$éýÿÿ€Êé}ýÿÿ€Êéuýÿÿ€Êémýÿÿ€ÊéeýÿÿD­lFÐéXýÿÿ¾ÇD$ðèÇD$ 鐐€Ê¾ÇD$°vÇD$ éû¾ÇD$°véސ€Ê€Îë^€Ê¾éϐ¾鐐ÿt$,„$œP‰T$èw
‰D$4‹T$€Ê ¾ƒÄ铐€Ê 1ö醐Ê¾ÇD$°vÇD$ ëgöÂ…÷ûÿÿöÂtƒD$0‹\$0‹Cüf‹L$$f‰éÙûÿÿƒD$0‹\$0‹Cü‹L$$‰éÁûÿÿ¡ˆ’Šp$t€Ê¾ÇD$ðèÇD$
‹œ$œ‹K9Kr%ÿ´$œ‰T$聋ÿÿƒÄ‹T$ƒøÿu ¸ÿÿÿÿ됐‹œ$œ‹C¶ƒøÿ„6 ö u}‹Œ$œ‹A¾‰D$ëZ‹Œ$œÿAÿD$$‹Y9Yr&ÿ´$œ‰T$è‹ÿÿƒÄ‹T$ƒøÿu
ÇD$ÿÿÿÿë‹Œ$œ‹A¶‰D$ƒ|$ÿ„Ä¡ˆ’‹\$ŠX$u˜ƒþ‡Çúÿÿÿ$µàeôe˜fÌgèhðk…íu½öÂt^1ö‹œ$œ‹K+K‰L$9é}/Î)ÍK‹L$4¿AØP‹\$8‹C ÿЃÄƒøÿuȅö„@됐$œit$$éCúÿÿUƒD$4‹\$4ÿsü‹L$<¿A`„$¤P‹\$@‹CdÿÐƒÄ …À„óéC…íu½ÿÿÿÿö„†ÇD$ëTÿD$‹œ$œÿCMtZ‹K9Krÿ´$œèˉÿÿƒÄƒøÿu¸ÿÿÿÿë
‹œ$œ‹C¶ƒøÿuƒ|$„됋Œ$œ‹A¾€¼˜u•ƒ|$„•éƒD$0‹\$0‹{ü‰|$ëZŠˆ‹œ$œÿCGMt]‹K9Krÿ´$œè:‰ÿÿƒÄƒøÿu
¸ÿÿÿÿ됐‹œ$œ‹C¶ƒøÿu9|$„ì됐‹Œ$œ‹Q¾€¼˜u‘‰û+\$‰\$„üÆÿD$(ëw…íu½ÿÿÿÿöÂtvÇD$ëFÿD$‹Œ$œÿAMtN‹Y9Yrÿ´$œ蛈ÿÿƒÄƒøÿu¸ÿÿÿÿë
‹Œ$œ‹A¶ƒøÿt‹œ$œ‹C¾¡ˆ’ŠP$t¡‹L$L$$éPøÿÿƒD$0‹\$0‹{ü‰|$‹Œ$œ‹qëTŠˆ‹Œ$œÿAGMtR‹Y9Yrÿ´$œèˆÿÿƒÄƒøÿu
¸ÿÿÿÿ됐‹Œ$œ‹A¶ƒøÿt‹œ$œ‹s¾‹ˆ’ŠB$tœÆ‰ø+D$D$$ÿD$(éº÷ÿÿMý\v½\EÊÀ|$8…í„4‹Œ$œ‹A¾0FՃøM‡ÿ$…,iÄj=kÄj=k=kdj„j„j„j„j„j„j„jœjœj=k=k=k=k=k=k=k¸j¸j¸j¸j¸j¸j=k=k=k=k=k=k=k=k=k=k=k=k=k=k=k=k=kÐj=k=k=k=k=k=k=k=k¸j¸j¸j¸j¸j¸j=k=k=k=k=k=k=k=k=k=k=k=k=k=k=k=k=kÐjƒ|$ u ÇD$ €ÎöÆtâ?ýÿÿëe‹\$ ¿](–‰\$ â?þÿÿëL‹L$ ¿ M(–‰L$ ƒùŽˆëݐƒ|$
~~ëӐöÂ@tt€â¿ëöÆthD$99Çu`ÇD$ €æþ‰óˆØˆG‹Œ$œÿA‹Y9Yr#ÿ´$œ‰T$蓅ÿÿƒÄ‹T$ƒøÿu¸ÿÿÿÿë
‹Œ$œ‹A¶ƒøÿtM…Ïýÿÿ„Ò}9|$ƒt¶GÿPé[¶wÿƒþxtƒþXuOVÿ´$ ‰T$è|ŠÿÿƒÄ‹T$öÂ…êÆÿt$ jÿt$ ‰T$ ‹\$(ÿÓ‰ÆƒÄ ‹T$öÂu öÂtƒD$0‹\$0‹Cüf‰0騐öÂtƒD$0‹L$0‹Aüë
ƒD$0‹\$0‹Cü‰0éMý\v½\EÊÀ|$8…턤‹Œ$œ‹A¾0FՃø:‡ˆÿ$…4l(mµm(m8mµm m m m m m m m m m mµmµmµmµmµmµmµmµmµmµmµmHmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmµmHm€â?ë;öÂ@„„€â¿ë*öÆtxâ¿þÿÿ됐‰Ð%€=u_‰Ð€äü‰Â€ÊÀ‰óˆØˆG‹Œ$œÿA‹Y9Yr#ÿ´$œ‰T$èƒÿÿƒÄ‹T$ƒøÿu¸ÿÿÿÿë
‹Œ$œ‹A¶ƒøÿtM…_þÿÿ„Ò}qöÆt*9|$ƒ÷O¶Pÿ´$ èˆÿÿƒÄ9|$ræéؐO¶7ƒþet!ƒþEtVÿ´$ ‰T$èí‡ÿÿO¶7ƒÄ‹T$Vÿ´$ ‰T$èчÿÿƒÄ‹T$öÂuCÆjÿt$‰T$èGƒÄ‹T$öÂtƒD$0‹\$0‹CüÝ됐ƒD$0‹L$0‹AüÙÿD$(‰ø+D$D$$éòÿÿ‹D$(…Àu¸ÿÿÿÿ[^_]ÄˆËD$([^_]ÄˆÐÿt$ÿ´$ è8‡ÿÿƒÄ‹D$([^_]ÄˆАWVS‹t$‹D$¶@ƒù^u »¶@ë1Ûºÿˆ2Jyú…ÉuH[^_п)߉ûˆ1¶@ƒú-t…ÒtÜë0ƒú]t'ë)¶ƒú]t9Ê}¹-ëѐ@Aˆ19Ñ|øëՐ[^_ÉÑ븋T$‹D$ÇB8$“PRè†ÿÿƒÄАÿÿÿÿÿÿïÿÿÿÿÿÿÿïƒìUWVS‹l$(‹|$,t$»D$PUè=ƒÄ…Àt
…ÿt‰…Àud¡ šƒøt
ƒø"tëE…ÿt‰/ÇD$ÇD$ ë*ƒ=\–~Ýxo€=`–+uÝØÝ€o됐ÙîÝ\$ÝD$[^_]ƒÄАT\됐·ƒÂþˆÁøˆFƒÆKƒûÿuéÝD$[^_]ƒÄÐS‹\$ƒ=8˜u1À[А94˜T¡4˜‹<˜·#…d–)ÉÙÓâÿ
8˜tP¹)ى
4˜ƒ<˜þ¡<˜·‹
4˜Óø#d– Âë!)4˜¡<˜·‹
4˜Óø‰Â#d–‰Ð[Ѓì UWVS‹l$ ‹5X–95P–v?€=`–+u
fÇE됐fÇE€‹L$$MþÿÿÿPjEPèKoÿÿ1ÀƒÄ [^_]ƒÄ А€=`–u;ƒ|$$ufÇEÿfÇEÿÿ됐fÇEÿfÇEÿÿfÇEÿÿfÇEÿÿ1À[^_]ƒÄ А€=`–Puƒ|$$ufÇE€fÇEë֐fÇEðë&€=`–Nu3ƒ|$$ufÇE€ÿfÇE뮐fÇEðÿfÇEfÇEfÇE뒐Ç4˜‹5X–‰5<˜¡P–ƒÀþ‹
X–)Á‰ÈÑø£8˜1ېjè1þÿÿƒÄ…ÀuCë‹5\–uX–‹P–ƒÂþ)ÐÑøÁà)؋T$(J¾‰ÑÓæ‰ò|þ‰ë€=`–+•À‰ÁfÁáf‰L$…ÿ„ƒÿÂŒ{ƒ=8˜uƒ<˜ÿ8˜Ç4˜ë*¡4˜@ƒø~ƒ4˜ñƒ<˜ÿ8˜ë£4˜÷߉|$‹T$$Áâ‹t$(D>‰×)ǃ|$$u
ƒ|$(uƒÇï¸+D$(9D$Œ¦‹L$ƒÁñ‰L$L$(‰L$f‹t$f‰3ƒÃ‹t$(T‹D$$Áà9Â|Ç š"¸[^_]ƒÄ Аƒ|$$u.ƒ|$(u'fǃÃfǃËL$‰L$ë
ƒD$ðfǃÃ|$ìƒ|$„ž¸+D$Pèšüÿÿ遐ƒ|$$u]ƒ|$(uVf‹t$f‰3ƒÃfǃÃ|$ufǃÃjè]üÿÿëGƒ|$u
fǃÃë<¸+D$Pè5üÿÿ됐‹D$(D$¹)Á‰ÈPèüÿÿf D$f‰ƒÃƒÄ‹t$$Du9Ãs‰D$jèñûÿÿf‰ƒÃƒÄ9\$wêjèÛûÿÿƒÄ…À„ôüÿÿƒÃþƒÿ~pÇD$‰ú‰Øf8ÿÿuƒÀþÿL$ƒÂðƒúêƒú‹L$·K#•d–9•d–„©üÿÿº9ë‚œüÿÿ·Âf‰ÁêƒÃþ…Ò„†üÿÿ9ësæé}üÿÿ·#½d–émüÿÿ‹t$(‹µd–÷Ѕø…*þÿÿ¹+L$(‰L$Qè ûÿÿ‰ú‹L$Óâf Ðf D$ƒÄf‹t$f‰3ƒÃƒ|$(uƒ|$$ufǃÃjèåúÿÿf‰ƒÃƒÄ‹L$$DM9Ãs‰ÇjèÅúÿÿf‰ƒÃƒÄ9ûrìjè±úÿÿƒÄ…Àt5ºƒÃþ9ër·Âf‰ÁêƒÃþ…Òt9ësêf‹D$f3Eyfeÿ1À[^_]ƒÄ А.ƒì‹T$‰$ÇP–$˜ÇT–ÇX–Ç\–Æ`–j jh˜èEjÿÿ‹P–ƒÂ
‰T–ƒÄ hP–hL–häuD$ PèRƒÄƒøt
ƒøtë#Ç š1ÀƒÄÃÇ š"1ÀƒÄÃj jÿt$èGúÿÿƒÄ ƒøuÇ$‹$ƒÄЃìUWVS‹|$8…ÿ|
ƒÿtƒÿ$~¿
‹\$0¾‹5ˆ’됐C¾ŠF$uõ€;„L€;-u ÆD$(ÿC됐€;+u ÆD$(C됐ÆD$(ƒÿu€;0u¾S¡’€<XuƒÃ…ÿu,€;0u"¾S¡’€<Xu ƒÃ¿ë¿ë¿
‰\$¸ÿÿÿÿ1Ò÷÷‰T$ ‰D$$ÇD$1öŠ ˆL$„Éto‹-ˆ’¶T$‰T$ŠDU$t€D$Ðë‹L$ŠDM$tE¡’ŠɈD$¶D$9ø}.9t$$ru9D$ s ÇD$ë ¯÷¶D$ÆCŠˆT$„Òu—9\$t=ƒ|$4t‹L$4‰ƒ|$tÇ š"¸ÿÿÿÿ[^_]ƒÄА¾D$(¯Æ[^_]ƒÄÃ|$4t
‹L$0‹T$4‰
1À[^_]ƒÄЃì UWVS‹T$ ‹|$(ŠL$,ˆL$‹J8‰L$‹l$$…ÿu¸ÿÿÿÿ[^_]ƒÄ ÐO‹Z+Z…Û.‹L$¿AÐP‹L$‹A ‰T$ÿЃÄ‹T$ƒøÿ„”‹Z+Z9û|‰ûS¾D$Pÿr‰T$èggÿÿ‰ÆƒÄ ‹T$…ötF‰ï+|$$‰ó+Zƒ|$0|
FGƒ|$0~CSÿrU‰T$è¼fÿÿƒÄ Æ+‹T$‰r;[^_]ƒÄ АSÿrU‰T$è’fÿÿƒÄ ‹T$ZÝ)ß…:ÿÿÿÆE‰è+D$$[^_]ƒÄ ËT$‹D$ÇB8$“PRèò{ÿÿƒÄА+-0@q£y O“
@@ð?U‰åƒì|WVS‹u‹6‰uŠ€û-t€û+u ˆ]°ÿEëÆE°+‹M€9nt€9Nu7‹u€~at€~Au(‹M€ynt€yNu‹uÆFÇF ‹‰N鵐‹u€>it €>I…·‹M€ynt
€yN…¤‹u€~ft
€~F…‘€}°+u ‹MÆAPë ‹uÆFN‹MÇA ‹1‰q‹M€yit€yIuG‹u€~nt€~Nu8‹M€yit€yIu)‹u€~tt€~Tu‹M€yyt€yYu ‹MƒÁë ‹MƒÁ‹u‰1ÀéCÇE¼ÇE¸ÇE´ÇE¬‹}Š„Û„Ր¾ÓRÿu ‰U„è¥cÿÿƒÄ‹U„…ÀuE„ÛtRÿuèŽcÿÿƒÄ…Àu1¾Ã‹ˆ’ŠB$t!ƒ}¬u€û0~ ÿE¼ÇE¬ëÿEGŠ„Ûu¢„Ût`¾ÃPÿu èFcÿÿƒÄ…ÀtMëD¾ÓRÿu‰U„è-cÿÿƒÄ‹U„…Àu1¡ˆ’ŠP$uƒ}¬uÇE¸ë@ÿE¸€û0~ÇE¬GŠ„Ûu¶ƒ}¸t$‹E¼E¸‹u€<00uÿM¸t‹E¼E¸‹M€<0tì„Ûtv¾ÃPÿuè¸bÿÿƒÄ…ÀtcGŠ„Ût¾ÃPhˆyèœbÿÿƒÄ…Àt ˆ]¨GŠëÆE¨+„Ût-‹5ˆ’‰uˆ¾Ó‹MˆŠQ$t‹u´¶DBЉE´GŠ„Ûu߀}¨-u÷]´‹M‰9‹U¼U¸ÇEÀ…Òu ‹uÇF ‹ƒÁþ‰NŠM°ˆNéy‹u‹F+ÑøH‰M¤HÝŒyPÚ $ƒÄÜ5”yÜœyƒìÙ<$f‹4$fÎ f‰t$Ùl$ƒìÛ$XÙ,$ƒÄ‰Ó9Ã~‰Ã‹E¼)ØE´Ý”ySÚ $ƒÄܤyƒìÙ<$f‹ $fÉ f‰L$Ùl$ƒìÛ$XÙ,$ƒÄ…À}ƒÀÁøƒÀ‰Eœ‰E EB$ü)ĉeˆRjÿuˆècÿÿ‹u‰u‰ßƒÄ …ÿtv‹M¾¡ˆ’ŠP$tR‹u ‹Mˆ\qþƒÂЉUŒ‹Uˆ9Ùw·€‹uŒFf‰Áø‰EŒƒÂ9Úväƒ}ŒtÇ š¸é?GÿEOu•ëÿMœ‹Mœ‹uˆfƒ|Nþuƒ}œé‹Mˆ‰M؋uœDqþ‰E܉EàÇEäÆEè+‹E¤‹M´Áé‰M˜t÷]´À‰Eˆ‰ÂƒÂƒÀ$ü)ĉã)ĉçRjSèbÿÿfÇÇEø‰]ì‰]ô‹uˆD3þ‰EðÆEü+‰}čt7þ‰uȋ
0‰M”ÇEä‚ƒ}˜tÇEôƒÄ ƒ}´t\}čuì‰uˆ‹]ƒÃ‹M´öÁt6‹u”¶‹M9Ã~ÇEÀÇE´ëWÿuˆSè’ÿuˆWè݃ÄÑ}´ƒÃƒ}´u¶ÿuEØPEìPèjŠM°‹uˆNƒÄ ‹EÀ¥xÿÿÿ[^_Éà ™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™™
õ(\Âõ(\Âõ(\Âõ(\Âõ(\Âõ(\Âõ(\Âõ(\d5Í;Nё\þCúíëÀ9#J{ƒ/L¦
F%ušž^)ËǺ¸'ôW]ÁÔàKí<_ZX`]OSOŸ®ÍJƒp?¿saÄó*áõ·V…³mBšf)„?éÖ`‹ûMMÌCóuaÚ
o"ö¥¬4Áoò†#Îx–g63
¨Æւ¼R`i;†÷™.eNQ«Gì3ï¬…[Am-î{t9òSšžSz¢þ‡
j¿dí8n헧Úôù?éO³}J”Fä<”i¾y*hûY>VPr^2>#èn>•. ™ßý8Mc>þ]ÒªY‘î·ZƒÕZJ3¦&éNqøµ×*ª}ƒ‹q+n‰ÿ`û¾W– 1ÛoŸZŒÅ7oÂi'µú23ÔøºUD¤~N†ÞXÉP 0LøtðÁrÃÔ½Hím?Ž9ï¸JuM²³å4åïw—Í}¡Å¨Ç¿‡¼&«jxMÎoôÎïÜ_÷S‰Äy‡¸!ewL¥ ãDö,Âs4‡C3ÛÒo•Ÿ~rEl{…×Q-H¡šu­=.3-Ç!=²-ãž XHÒÕÖñ
òÃé¾´Åâ¹0)ù‘ Þ¨|Ãë¹£(¶‹_d†a䈴cO\ŠI¶8Päâ8ÒÁÔ4cOêåó8ê<9± ¾ßúÊ^”ì@ãhø g&¬½RD7eECÐì1´ÚÏ5¬ÓÃ^à+íRASQ?Oƒ²ï\öó&«;t™ å?)§ˆ¸Î²­Æ½Å$Y¾d%0‚èúK‘ž¦_0ÔÖÙ%444+6\\ìÿÿÿ+`††ìÿÿÿ+Š°°ìÿÿÿ+´ØØìÿÿÿ+Þþþìÿÿÿ+€ € €ìÿÿÿ+,€8€8€ìÿÿÿ+N€h€h€Øÿÿÿ+€ĀĀ°ÿÿÿ+<<xÿÿÿ+z´´ÿÿÿ+444+^^^+ˆˆˆ+²²²+ÚÜÜ+€€€+"€*€*€+:€L€L€+j€Ž€Ž€+ƀ+>xxM+¶ðð·+WVS‹|$‹t$ŠOˆN‹G+‰ÃÑûy ‹ƒÁþ‰N[^_ËF+Ñø9ÃI})ØPj]ƒÀPèT\ÿÿƒÄ ]Pÿ7ÿ6è¤[ÿÿƒÄ ‹O ‰N ‹G+$þ‰F[^_А)ÍE]RPÿ6èm[ÿÿƒÄ ‹N‰N_ ‰^ [^_Аƒì$UWVS‹\$8€{-t€{+u‹T$<€z-t€z+t‹\$@ÆC[^_]ƒÄ$а-‹\$8ŠS‹\$<8Su°+‹T$@ˆB‹\$8‹C+Ñø‰D$0‹T$<‹B+Ñø‰D$,‹\$8‹S ‹\$<S ‰T$ ‹\$@‹C+Ñø‹T$0T$,‰T$()ЉD$$y
‹l$$)l$ ë1í1ÿÇD$ÇD$9|$(Œœ‰þ1ÿ1É9|$|W‹\$)ˉ\$9L$0|@‹T$,9Ó8ƒ|$|1‹\$8‹·H‰D$‹T$<‹‹\$·X¯D$‰D$ƉðÁèÇ·öA9L$}© t$u…í}…í|
‹T$@‹f‰4hEë
ÿD$$ÿD$ ÿD$‹\$(9\$Žfÿÿÿ…ÿtFƒ|$$~‹T$@‹f‰ j!hd‡jèzÿÿjÿèύÿÿœ*(š¢*虪*b¶* É*aÕ*ȘÞ*oê*ø˜ò*Vú* ¼œ(ÔðüBCD Üÿèý°ùˆDôôû8Ìø ó˜<€Œ¨Ðø ÐöØöÈôìõDô€ïxóÌø óìóxòüò lçlçÈôìõDôtõxó˜ó óìóxòüò„À­û”’ˆÀ­ûô“”’ˆÀ­û<””’€À­û”’ÿÿ„”Unknown error 000000000000000000Unknown error %d, È$ä#Èô,'DôØ&xóÌø óìóxòüò Ðö(ÈôìõDôˆ(xóÌø óìóxòüò


eEp˜–˜?ÿÿÿÿÿÿÿ?ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ?ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ?ÿÿÿÿÿÿÿˆ‡ü./lib/bison.simple 644 0 0 36030 5213513116 12323 0ustar rootroot/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
#line 3 "/usr/lib/bison.simple"

/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman

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 1, 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., 675 Mass Ave, Cambridge, MA 02139, USA. */


#ifndef alloca
#ifdef __GNUC__
#define alloca __builtin_alloca
#else /* not GNU C. */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
#include
#else /* not sparc */
#if defined (MSDOS) && !defined (__TURBOC__)
#include
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
#include
#pragma alloca
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
#endif /* not sparc. */
#endif /* not GNU C. */
#endif /* alloca not defined. */

/* 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. */

/* Note: there must be only one dollar sign in this file.
It is replaced by the list of actions, each action
as one case of the switch. */

#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY -2
#define YYEOF 0
#define YYACCEPT return(0)
#define YYABORT return(1)
#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

#ifndef YYPURE
#define YYLEX yylex()
#endif

#ifdef YYPURE
#ifdef YYLSP_NEEDED
#define YYLEX yylex(&yylval, &yylloc)
#else
#define YYLEX yylex(&yylval)
#endif
#endif

/* If nonreentrant, generate the variables here */

#ifndef YYPURE

int yychar; /* the lookahead symbol */
YYSTYPE yylval; /* the semantic value of the */
/* lookahead symbol */

#ifdef YYLSP_NEEDED
YYLTYPE yylloc; /* location data for the lookahead */
/* symbol */
#endif

int yynerrs; /* number of parse errors so far */
#endif /* not YYPURE */

#if YYDEBUG != 0
int yydebug; /* nonzero means print parse trace */
/* Since this is uninitialized, it does not stop multiple parsers
from coexisting. */
#endif

/* YYINITDEPTH indicates the initial size of the parser's stacks */

#ifndef YYINITDEPTH
#define YYINITDEPTH 200
#endif

/* YYMAXDEPTH is the maximum size the stacks can grow to
(effective only if the built-in stack extension method is used). */

#if YYMAXDEPTH == 0
#undef YYMAXDEPTH
#endif

#ifndef YYMAXDEPTH
#define YYMAXDEPTH 10000
#endif

#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
#define __yy_bcopy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT)
#else /* not GNU C or C++ */
#ifndef __cplusplus

/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
__yy_bcopy (from, to, count)
char *from;
char *to;
int count;
{
register char *f = from;
register char *t = to;
register int i = count;

while (i-- > 0)
*t++ = *f++;
}

#else /* __cplusplus */

/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
__yy_bcopy (char *from, char *to, int count)
{
register char *f = from;
register char *t = to;
register int i = count;

while (i-- > 0)
*t++ = *f++;
}

#endif
#endif

#line 169 "/usr/lib/bison.simple"
int
yyparse()
{
register int yystate;
register int yyn;
register short *yyssp;
register YYSTYPE *yyvsp;
int yyerrstatus; /* number of tokens to shift before error messages enabled */
int yychar1; /* lookahead token as an internal (translated) token number */

short yyssa[YYINITDEPTH]; /* the state stack */
YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */

short *yyss = yyssa; /* refer to the stacks thru separate pointers */
YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */

#ifdef YYLSP_NEEDED
YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
YYLTYPE *yyls = yylsa;
YYLTYPE *yylsp;

#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
#else
#define YYPOPSTACK (yyvsp--, yyssp--)
#endif

int yystacksize = YYINITDEPTH;

#ifdef YYPURE
int yychar;
YYSTYPE yylval;
int yynerrs;
#ifdef YYLSP_NEEDED
YYLTYPE yylloc;
#endif
#endif

YYSTYPE yyval; /* the variable used to return */
/* semantic values from the action */
/* routines */

int yylen;

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Starting parse\n");
#endif

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. */

yyssp = yyss - 1;
yyvsp = yyvs;
#ifdef YYLSP_NEEDED
yylsp = yyls;
#endif

/* Push a new state, which is found in yystate . */
/* In all cases, when you get here, the value and location stacks
have just been pushed. so pushing a state here evens the stacks. */
yynewstate:

*++yyssp = yystate;

if (yyssp >= yyss + yystacksize - 1)
{
/* 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;
#ifdef YYLSP_NEEDED
YYLTYPE *yyls1 = yyls;
#endif

/* Get the current used size of the three stacks, in elements. */
int size = yyssp - yyss + 1;

#ifdef yyoverflow
/* Each stack pointer address is followed by the size of
the data in use in that stack, in bytes. */
yyoverflow("parser stack overflow",
&yyss1, size * sizeof (*yyssp),
&yyvs1, size * sizeof (*yyvsp),
#ifdef YYLSP_NEEDED
&yyls1, size * sizeof (*yylsp),
#endif
&yystacksize);

yyss = yyss1; yyvs = yyvs1;
#ifdef YYLSP_NEEDED
yyls = yyls1;
#endif
#else /* no yyoverflow */
/* Extend the stack our own way. */
if (yystacksize >= YYMAXDEPTH)
{
yyerror("parser stack overflow");
return 2;
}
yystacksize *= 2;
if (yystacksize > YYMAXDEPTH)
yystacksize = YYMAXDEPTH;
yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
__yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
__yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
#ifdef YYLSP_NEEDED
yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
__yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
#endif
#endif /* no yyoverflow */

yyssp = yyss + size - 1;
yyvsp = yyvs + size - 1;
#ifdef YYLSP_NEEDED
yylsp = yyls + size - 1;
#endif

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Stack size increased to %d\n", yystacksize);
#endif

if (yyssp >= yyss + yystacksize - 1)
YYABORT;
}

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Entering state %d\n", yystate);
#endif

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)
{
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Reading a token: ");
#endif
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 */

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Now at end of input.\n");
#endif
}
else
{
yychar1 = YYTRANSLATE(yychar);

#if YYDEBUG != 0
if (yydebug)
{
fprintf (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
fprintf (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. */

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
#endif

/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;

*++yyvsp = yylval;
#ifdef YYLSP_NEEDED
*++yylsp = yylloc;
#endif

/* count tokens shifted since error; after three, turn off error status. */
if (yyerrstatus) yyerrstatus--;

yystate = yyn;
goto yynewstate;

/* Do the default action for the current state. */
yydefault:

yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;

/* Do a reduction. yyn is the number of a rule to reduce with. */
yyreduce:
yylen = yyr2[yyn];
yyval = yyvsp[1-yylen]; /* implement default value of the action */

#if YYDEBUG != 0
if (yydebug)
{
int i;

fprintf (stderr, "Reducing via rule %d (line %d), ",
yyn, yyrline[yyn]);

/* Print the symboles being reduced, and their result. */
for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
fprintf (stderr, "%s ", yytname[yyrhs[i]]);
fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
}
#endif

$ /* the action file gets copied in in place of this dollarsign */
#line 440 "/usr/lib/bison.simple"

yyvsp -= yylen;
yyssp -= yylen;
#ifdef YYLSP_NEEDED
yylsp -= yylen;
#endif

#if YYDEBUG != 0
if (yydebug)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif

*++yyvsp = yyval;

#ifdef YYLSP_NEEDED
yylsp++;
if (yylen == 0)
{
yylsp->first_line = yylloc.first_line;
yylsp->first_column = yylloc.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;
}
#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 */

if (! yyerrstatus)
/* If not already recovering from an error, report this error. */
{
++yynerrs;

#ifdef YYERROR_VERBOSE
yyn = yypact[yystate];

if (yyn > YYFLAG && yyn < YYLAST)
{
int size = 0;
char *msg;
int x, count;

count = 0;
for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
if (yycheck[x + yyn] == x)
size += strlen(yytname[x]) + 15, count++;
msg = (char *) malloc(size + 15);
if (msg != 0)
{
strcpy(msg, "parse error");

if (count < 5)
{
count = 0;
for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
if (yycheck[x + yyn] == x)
{
strcat(msg, count == 0 ? ", expecting `" : " or `");
strcat(msg, yytname[x]);
strcat(msg, "'");
count++;
}
}
yyerror(msg);
free(msg);
}
else
yyerror ("parse error; also virtual memory exceeded");
}
else
#endif /* YYERROR_VERBOSE */
yyerror("parse error");
}

yyerrlab1: /* here on error raised explicitly by an action */

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;

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
#endif

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. */

#if 0
/* This is wrong; only states that explicitly want error tokens
should shift them. */
yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
if (yyn) goto yydefault;
#endif

yyerrpop: /* pop the current state because it cannot handle the error token */

if (yyssp == yyss) YYABORT;
yyvsp--;
yystate = *--yyssp;
#ifdef YYLSP_NEEDED
yylsp--;
#endif

#if YYDEBUG != 0
if (yydebug)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "Error: state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif

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;

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Shifting error token, ");
#endif

*++yyvsp = yylval;
#ifdef YYLSP_NEEDED
*++yylsp = yylloc;
#endif

yystate = yyn;
goto yynewstate;
}
./lib/bison.hairy 644 0 0 14515 5213513116 12152 0ustar rootroot
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;
}

$
./man/man1/bison.1 644 0 0 11576 5213513116 12043 0ustar rootroot.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
] [
.B \-\-defines
] [
.B \-l
] [
.B \-\-no-lines
] [
.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 \-\-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.
For instance, a grammar description file named
.B parse.y
would produce the generated parser in a file named
.BR parse.tab.c ,
instead of
.IR yacc 's
.BR y.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
.TP
.B \-\-defines
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
.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
.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
Output a definition of the macro
.B YYDEBUG
into the parser file,
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
.IR bison .
.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
.PP
The long-named options can be introduced with `+' as well as `\-\-',
for compatibility with previous releases. Eventually support for `+'
will be removed, because it is incompatible with the POSIX.2 standard.
.SH FILES
/usr/local/lib/bison.simple simple parser
.br
/usr/local/lib/bison.hairy complicated parser
.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.''
... ha!
./info/bison.info-1 644 0 0 142657 5213513116 12345 0ustar rootrootInfo file bison.info, produced by Makeinfo, -*- Text -*- from input
file bison.texinfo.

This file documents the Bison parser generator.

Copyright (C) 1988, 1989, 1990 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License" and
"Conditions for Using Bison" are included exactly as in the original,
and provided that the entire resulting derived work is distributed
under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License", "Conditions for Using Bison" and this permission notice may
be included in translations approved by the Free Software Foundation
instead of in the original English.


File: bison.info, Node: Top, Next: Introduction, Prev: (DIR), Up: (DIR)

This manual documents version 1.16 of Bison.

* Menu:

* Introduction::
* Conditions::
* Copying:: The GNU General Public License says
how you can copy and share Bison

Tutorial sections:
* Concepts:: Basic concepts for understanding Bison.
* Examples:: Three simple explained examples of using Bison.

Reference sections:
* Grammar File:: Writing Bison declarations and rules.
* Interface:: C-language interface to the parser function `yyparse'.
* Algorithm:: How the Bison parser works at run-time.
* Error Recovery:: Writing rules for error recovery.
* Context Dependency::What to do if your language syntax is too
messy for Bison to handle straightforwardly.
* Debugging:: Debugging Bison parsers that parse wrong.
* Invocation:: How to run Bison (to produce the parser source file).
* Table of Symbols:: All the keywords of the Bison language are explained.
* Glossary:: Basic concepts are explained.
* Index:: Cross-references to the text.


File: bison.info, Node: Introduction, Next: Conditions, Prev: Top, Up: Top

Introduction
************

"Bison" is a general-purpose parser generator that converts a
grammar description for an LALR(1) context-free grammar into a C
program to parse that grammar. Once you are proficient with Bison,
you may use it to develop a wide range of language parsers, from those
used in simple desk calculators to complex programming languages.

Bison is upward compatible with Yacc: all properly-written Yacc
grammars ought to work with Bison with no change. Anyone familiar
with Yacc should be able to use Bison with little trouble. You need
to be fluent in C programming in order to use Bison or to understand
this manual.

We begin with tutorial chapters that explain the basic concepts of
using Bison and show three explained examples, each building on the
last. If you don't know Bison or Yacc, start by reading these
chapters. Reference chapters follow which describe specific aspects
of Bison in detail.

Bison was written primarily by Robert Corbett; Richard Stallman made
it Yacc-compatible. This edition corresponds to version 1.16 of Bison.


File: bison.info, Node: Conditions, Next: Copying, Prev: Introduction, Up: Top

Conditions for Using Bison
**************************

Bison grammars can be used only in programs that are free software.
This is in contrast to what happens with the GNU C compiler and the
other GNU programming tools.

The reason Bison is special is that the output of the Bison
utility--the Bison parser file--contains a verbatim copy of a sizable
piece of Bison, which is the code for the `yyparse' function. (The
actions from your grammar are inserted into this function at one
point, but the rest of the function is not changed.)

As a result, the Bison parser file is covered by the same copying
conditions that cover Bison itself and the rest of the GNU system: any
program containing it has to be distributed under the standard GNU
copying conditions.

Occasionally people who would like to use Bison to develop
proprietary programs complain about this.

We don't particularly sympathize with their complaints. The
purpose of the GNU project is to promote the right to share software
and the practice of sharing software; it is a means of changing
society. The people who complain are planning to be uncooperative
toward the rest of the world; why should they deserve our help in
doing so?

However, it's possible that a change in these conditions might
encourage computer companies to use and distribute the GNU system. If
so, then we might decide to change the terms on `yyparse' as a matter
of the strategy of promoting the right to share. Such a change would
be irrevocable. Since we stand by the copying permissions we have
announced, we cannot withdraw them once given.

We mustn't make an irrevocable change hastily. We have to wait
until there is a complete GNU system and there has been time to learn
how this issue affects its reception.


File: bison.info, Node: Copying, Next: Concepts, Prev: Conditions, Up: Top

GNU GENERAL PUBLIC LICENSE
**************************

Version 2, June 1991

Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA

Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

Preamble
========

The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.

When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.

We protect your rights with two steps: (1) copyright the software,
and (2) offer you this license which gives you legal permission to
copy, distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on,
we want its recipients to know that what they have is not the
original, so that any problems introduced by others will not reflect
on the original authors' reputations.

Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and
modification follow.

TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

1. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be
distributed under the terms of this General Public License. The
"Program", below, refers to any such program or work, and a "work
based on the Program" means either the Program or any derivative
work under copyright law: that is to say, a work containing the
Program or a portion of it, either verbatim or with modifications
and/or translated into another language. (Hereinafter,
translation is included without limitation in the term
"modification".) Each licensee is addressed as "you".

Activities other than copying, distribution and modification
are not covered by this License; they are outside its scope. The
act of running the Program is not restricted, and the output from
the Program is covered only if its contents constitute a work
based on the Program (independent of having been made by running
the Program). Whether that is true depends on what the Program
does.

2. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep
intact all the notices that refer to this License and to the
absence of any warranty; and give any other recipients of the
Program a copy of this License along with the Program.

You may charge a fee for the physical act of transferring a
copy, and you may at your option offer warranty protection in
exchange for a fee.

3. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

1. You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any
change.

2. You must cause any work that you distribute or publish, that
in whole or in part contains or is derived from the Program
or any part thereof, to be licensed as a whole at no charge
to all third parties under the terms of this License.

3. If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or
display an announcement including an appropriate copyright
notice and a notice that there is no warranty (or else,
saying that you provide a warranty) and that users may
redistribute the program under these conditions, and telling
the user how to view a copy of this License. (Exception: if
the Program itself is interactive but does not normally
print such an announcement, your work based on the Program
is not required to print an announcement.)

These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the
Program, and can be reasonably considered independent and
separate works in themselves, then this License, and its terms,
do not apply to those sections when you distribute them as
separate works. But when you distribute the same sections as
part of a whole which is a work based on the Program, the
distribution of the whole must be on the terms of this License,
whose permissions for other licensees extend to the entire whole,
and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or
contest your rights to work written entirely by you; rather, the
intent is to exercise the right to control the distribution of
derivative or collective works based on the Program.

In addition, mere aggregation of another work not based on the
Program with the Program (or with a work based on the Program) on
a volume of a storage or distribution medium does not bring the
other work under the scope of this License.

4. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the
terms of Sections 1 and 2 above provided that you also do one of
the following:

1. Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of
Sections 1 and 2 above on a medium customarily used for
software interchange; or,

2. Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than
your cost of physically performing source distribution, a
complete machine-readable copy of the corresponding source
code, to be distributed under the terms of Sections 1 and 2
above on a medium customarily used for software interchange;
or,

3. Accompany it with the information you received as to the
offer to distribute corresponding source code. (This
alternative is allowed only for noncommercial distribution
and only if you received the program in object code or
executable form with such an offer, in accord with
Subsection b above.)

The source code for a work means the preferred form of the
work for making modifications to it. For an executable work,
complete source code means all the source code for all modules it
contains, plus any associated interface definition files, plus
the scripts used to control compilation and installation of the
executable. However, as a special exception, the source code
distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system
on which the executable runs, unless that component itself
accompanies the executable.

If distribution of executable or object code is made by
offering access to copy from a designated place, then offering
equivalent access to copy the source code from the same place
counts as distribution of the source code, even though third
parties are not compelled to copy the source along with the
object code.

5. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this
License. However, parties who have received copies, or rights,
from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.

6. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify
or distribute the Program or its derivative works. These actions
are prohibited by law if you do not accept this License.
Therefore, by modifying or distributing the Program (or any work
based on the Program), you indicate your acceptance of this
License to do so, and all its terms and conditions for copying,
distributing or modifying the Program or works based on it.

7. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program
subject to these terms and conditions. You may not impose any
further restrictions on the recipients' exercise of the rights
granted herein. You are not responsible for enforcing compliance
by third parties to this License.

8. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent
issues), conditions are imposed on you (whether by court order,
agreement or otherwise) that contradict the conditions of this
License, they do not excuse you from the conditions of this
License. If you cannot distribute so as to satisfy
simultaneously your obligations under this License and any other
pertinent obligations, then as a consequence you may not
distribute the Program at all. For example, if a patent license
would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you,
then the only way you could satisfy both it and this License
would be to refrain entirely from distribution of the Program.

If any portion of this section is held invalid or
unenforceable under any particular circumstance, the balance of
the section is intended to apply and the section as a whole is
intended to apply in other circumstances.

It is not the purpose of this section to induce you to
infringe any patents or other property right claims or to contest
validity of any such claims; this section has the sole purpose of
protecting the integrity of the free software distribution
system, which is implemented by public license practices. Many
people have made generous contributions to the wide range of
software distributed through that system in reliance on
consistent application of that system; it is up to the
author/donor to decide if he or she is willing to distribute
software through any other system and a licensee cannot impose
that choice.

This section is intended to make thoroughly clear what is
believed to be a consequence of the rest of this License.

9. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces,
the original copyright holder who places the Program under this
License may add an explicit geographical distribution limitation
excluding those countries, so that distribution is permitted only
in or among countries not thus excluded. In such case, this
License incorporates the limitation as if written in the body of
this License.

10. The Free Software Foundation may publish revised and/or new
versions of the General Public License from time to time. Such
new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.

Each version is given a distinguishing version number. If the
Program specifies a version number of this License which applies
to it and "any later version", you have the option of following
the terms and conditions either of that version or of any later
version published by the Free Software Foundation. If the
Program does not specify a version number of this License, you
may choose any version ever published by the Free Software
Foundation.

11. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to
the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free
status of all derivatives of our free software and of promoting
the sharing and reuse of software generally.

NO WARRANTY

12. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE
LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT
NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE
QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
SERVICING, REPAIR OR CORRECTION.

13. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE
LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS
OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH
ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Programs
=============================================

If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these
terms.

To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

ONE LINE TO GIVE THE PROGRAM'S NAME AND A BRIEF IDEA OF WHAT IT DOES.
Copyright (C) 19YY NAME OF AUTHOR

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 of the License, 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., 675 Mass Ave, Cambridge, MA 02139, USA.

Also add information on how to contact you by electronic and paper
mail.

If the program is interactive, make it output a short notice like
this when it starts in an interactive mode:

Gnomovision version 69, Copyright (C) 19YY NAME OF AUTHOR
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the
appropriate parts of the General Public License. Of course, the
commands you use may be called something other than `show w' and `show
c'; they could even be mouse-clicks or menu items--whatever suits your
program.

You should also get your employer (if you work as a programmer) or
your school, if any, to sign a "copyright disclaimer" for the program,
if necessary. Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright
interest in the program `Gnomovision'
(which makes passes at compilers) written
by James Hacker.

SIGNATURE OF TY COON, 1 April 1989
Ty Coon, President of Vice

This General Public License does not permit incorporating your
program into proprietary programs. If your program is a subroutine
library, you may consider it more useful to permit linking proprietary
applications with the library. If this is what you want to do, use
the GNU Library General Public License instead of this License.


File: bison.info, Node: Concepts, Next: Examples, Prev: Copying, Up: Top

The Concepts of Bison
*********************

This chapter introduces many of the basic concepts without which the
details of Bison will not make sense. If you do not already know how
to use Bison or Yacc, we suggest you start by reading this chapter
carefully.

* Menu:

* Language and Grammar:: Languages and context-free grammars,
as mathematical ideas.
* Grammar in Bison:: How we represent grammars for Bison's sake.
* Semantic Values:: Each token or syntactic grouping can have
a semantic value (the value of an integer,
the name of an identifier, etc.).
* Semantic Actions:: Each rule can have an action containing C code.
* Bison Parser:: What are Bison's input and output,
how is the output used?
* Stages:: Stages in writing and running Bison grammars.
* Grammar Layout:: Overall structure of a Bison grammar file.


File: bison.info, Node: Language and Grammar, Next: Grammar in Bison, Prev: Concepts, Up: Concepts

Languages and Context-Free Grammars
===================================

In order for Bison to parse a language, it must be described by a
"context-free grammar". This means that you specify one or more
"syntactic groupings" and give rules for constructing them from their
parts. For example, in the C language, one kind of grouping is called
an `expression'. One rule for making an expression might be, "An
expression can be made of a minus sign and another expression".
Another would be, "An expression can be an integer". As you can see,
rules are often recursive, but there must be at least one rule which
leads out of the recursion.

The most common formal system for presenting such rules for humans
to read is "Backus-Naur Form" or "BNF", which was developed in order to
specify the language Algol 60. Any grammar expressed in BNF is a
context-free grammar. The input to Bison is essentially
machine-readable BNF.

Not all context-free languages can be handled by Bison, only those
that are LALR(1). In brief, this means that it must be possible to
tell how to parse any portion of an input string with just a single
token of look-ahead. Strictly speaking, that is a description of an
LR(1) grammar, and LALR(1) involves additional restrictions that are
hard to explain simply; but it is rare in actual practice to find an
LR(1) grammar that fails to be LALR(1). *Note Mysterious
Reduce/Reduce Conflicts: Mystery Conflicts, for more information on
this.

In the formal grammatical rules for a language, each kind of
syntactic unit or grouping is named by a "symbol". Those which are
built by grouping smaller constructs according to grammatical rules
are called "nonterminal symbols"; those which can't be subdivided are
called "terminal symbols" or "token types". We call a piece of input
corresponding to a single terminal symbol a "token", and a piece
corresponding to a single nonterminal symbol a "grouping".

We can use the C language as an example of what symbols, terminal
and nonterminal, mean. The tokens of C are identifiers, constants
(numeric and string), and the various keywords, arithmetic operators
and punctuation marks. So the terminal symbols of a grammar for C
include `identifier', `number', `string', plus one symbol for each
keyword, operator or punctuation mark: `if', `return', `const',
`static', `int', `char', `plus-sign', `open-brace', `close-brace',
`comma' and many more. (These tokens can be subdivided into
characters, but that is a matter of lexicography, not grammar.)

Here is a simple C function subdivided into tokens:

int /* keyword `int' */
square (x) /* identifier, open-paren, */
/* identifier, close-paren */
int x; /* keyword `int', identifier, semicolon */
{ /* open-brace */
return x * x; /* keyword `return', identifier, */
/* asterisk, identifier, semicolon */
} /* close-brace */

The syntactic groupings of C include the expression, the statement,
the declaration, and the function definition. These are represented
in the grammar of C by nonterminal symbols `expression', `statement',
`declaration' and `function definition'. The full grammar uses dozens
of additional language constructs, each with its own nonterminal
symbol, in order to express the meanings of these four. The example
above is a function definition; it contains one declaration, and one
statement. In the statement, each `x' is an expression and so is `x *
x'.

Each nonterminal symbol must have grammatical rules showing how it
is made out of simpler constructs. For example, one kind of C
statement is the `return' statement; this would be described with a
grammar rule which reads informally as follows:

A `statement' can be made of a `return' keyword, an `expression'
and a `semicolon'.

There would be many other rules for `statement', one for each kind of
statement in C.

One nonterminal symbol must be distinguished as the special one
which defines a complete utterance in the language. It is called the
"start symbol". In a compiler, this means a complete input program.
In the C language, the nonterminal symbol `sequence of definitions and
declarations' plays this role.

For example, `1 + 2' is a valid C expression--a valid part of a C
program--but it is not valid as an *entire* C program. In the
context-free grammar of C, this follows from the fact that
`expression' is not the start symbol.

The Bison parser reads a sequence of tokens as its input, and
groups the tokens using the grammar rules. If the input is valid, the
end result is that the entire token sequence reduces to a single
grouping whose symbol is the grammar's start symbol. If we use a
grammar for C, the entire input must be a `sequence of definitions and
declarations'. If not, the parser reports a syntax error.


File: bison.info, Node: Grammar in Bison, Next: Semantic Values, Prev: Language and Grammar, Up: Concepts

From Formal Rules to Bison Input
================================

A formal grammar is a mathematical construct. To define the
language for Bison, you must write a file expressing the grammar in
Bison syntax: a "Bison grammar" file. *Note Grammar File::.

A nonterminal symbol in the formal grammar is represented in Bison
input as an identifier, like an identifier in C. By convention, it
should be in lower case, such as `expr', `stmt' or `declaration'.

The Bison representation for a terminal symbol is also called a
"token type". Token types as well can be represented as C-like
identifiers. By convention, these identifiers should be upper case to
distinguish them from nonterminals: for example, `INTEGER',
`IDENTIFIER', `IF' or `RETURN'. A terminal symbol that stands for a
particular keyword in the language should be named after that keyword
converted to upper case. The terminal symbol `error' is reserved for
error recovery. *Note Symbols::.

A terminal symbol can also be represented as a character literal,
just like a C character constant. You should do this whenever a token
is just a single character (parenthesis, plus-sign, etc.): use that
same character in a literal as the terminal symbol for that token.

The grammar rules also have an expression in Bison syntax. For
example, here is the Bison rule for a C `return' statement. The
semicolon in quotes is a literal character token, representing part of
the C syntax for the statement; the naked semicolon, and the colon,
are Bison punctuation used in every rule.

stmt: RETURN expr ';'
;

*Note Rules::.


File: bison.info, Node: Semantic Values, Next: Semantic Actions, Prev: Grammar in Bison, Up: Concepts

Semantic Values
===============

A formal grammar selects tokens only by their classifications: for
example, if a rule mentions the terminal symbol `integer constant', it
means that *any* integer constant is grammatically valid in that
position. The precise value of the constant is irrelevant to how to
parse the input: if `x+4' is grammatical then `x+1' or `x+3989' is
equally grammatical.

But the precise value is very important for what the input means
once it is parsed. A compiler is useless if it fails to distinguish
between 4, 1 and 3989 as constants in the program! Therefore, each
token in a Bison grammar has both a token type and a "semantic value".
*Note Semantics::, for details.

The token type is a terminal symbol defined in the grammar, such as
`INTEGER', `IDENTIFIER' or `',''. It tells everything you need to
know to decide where the token may validly appear and how to group it
with other tokens. The grammar rules know nothing about tokens except
their types.

The semantic value has all the rest of the information about the
meaning of the token, such as the value of an integer, or the name of
an identifier. (A token such as `','' which is just punctuation
doesn't need to have any semantic value.)

For example, an input token might be classified as token type
`INTEGER' and have the semantic value 4. Another input token might
have the same token type `INTEGER' but value 3989. When a grammar
rule says that `INTEGER' is allowed, either of these tokens is
acceptable because each is an `INTEGER'. When the parser accepts the
token, it keeps track of the token's semantic value.

Each grouping can also have a semantic value as well as its
nonterminal symbol. For example, in a calculator, an expression
typically has a semantic value that is a number. In a compiler for a
programming language, an expression typically has a semantic value
that is a tree structure describing the meaning of the expression.


File: bison.info, Node: Semantic Actions, Next: Bison Parser, Prev: Semantic Values, Up: Concepts

Semantic Actions
================

In order to be useful, a program must do more than parse input; it
must also produce some output based on the input. In a Bison grammar,
a grammar rule can have an "action" made up of C statements. Each
time the parser recognizes a match for that rule, the action is
executed. *Note Actions::.

Most of the time, the purpose of an action is to compute the
semantic value of the whole construct from the semantic values of its
parts. For example, suppose we have a rule which says an expression
can be the sum of two expressions. When the parser recognizes such a
sum, each of the subexpressions has a semantic value which describes
how it was built up. The action for this rule should create a similar
sort of value for the newly recognized larger expression.

For example, here is a rule that says an expression can be the sum
of two subexpressions:

expr: expr '+' expr { $$ = $1 + $3; }
;

The action says how to produce the semantic value of the sum expression
from the values of the two subexpressions.


File: bison.info, Node: Bison Parser, Next: Stages, Prev: Semantic Actions, Up: Concepts

Bison Output: the Parser File
=============================

When you run Bison, you give it a Bison grammar file as input. The
output is a C source file that parses the language described by the
grammar. This file is called a "Bison parser". Keep in mind that the
Bison utility and the Bison parser are two distinct programs: the
Bison utility is a program whose output is the Bison parser that
becomes part of your program.

The job of the Bison parser is to group tokens into groupings
according to the grammar rules--for example, to build identifiers and
operators into expressions. As it does this, it runs the actions for
the grammar rules it uses.

The tokens come from a function called the "lexical analyzer" that
you must supply in some fashion (such as by writing it in C). The
Bison parser calls the lexical analyzer each time it wants a new
token. It doesn't know what is "inside" the tokens (though their
semantic values may reflect this). Typically the lexical analyzer
makes the tokens by parsing characters of text, but Bison does not
depend on this. *Note Lexical::.

The Bison parser file is C code which defines a function named
`yyparse' which implements that grammar. This function does not make
a complete C program: you must supply some additional functions. One
is the lexical analyzer. Another is an error-reporting function which
the parser calls to report an error. In addition, a complete C
program must start with a function called `main'; you have to provide
this, and arrange for it to call `yyparse' or the parser will never
run. *Note Interface::.

Aside from the token type names and the symbols in the actions you
write, all variable and function names used in the Bison parser file
begin with `yy' or `YY'. This includes interface functions such as
the lexical analyzer function `yylex', the error reporting function
`yyerror' and the parser function `yyparse' itself. This also
includes numerous identifiers used for internal purposes. Therefore,
you should avoid using C identifiers starting with `yy' or `YY' in the
Bison grammar file except for the ones defined in this manual.


File: bison.info, Node: Stages, Next: Grammar Layout, Prev: Bison Parser, Up: Concepts

Stages in Using Bison
=====================

The actual language-design process using Bison, from grammar
specification to a working compiler or interpreter, has these parts:

1. Formally specify the grammar in a form recognized by Bison (*note
Grammar File::.). For each grammatical rule in the language,
describe the action that is to be taken when an instance of that
rule is recognized. The action is described by a sequence of C
statements.

2. Write a lexical analyzer to process input and pass tokens to the
parser. The lexical analyzer may be written by hand in C (*note
Lexical::.). It could also be produced using Lex, but the use of
Lex is not discussed in this manual.

3. Write a controlling function that calls the Bison-produced parser.

4. Write error-reporting routines.

To turn this source code as written into a runnable program, you
must follow these steps:

1. Run Bison on the grammar to produce the parser.

2. Compile the code output by Bison, as well as any other source
files.

3. Link the object files to produce the finished product.


File: bison.info, Node: Grammar Layout, Prev: Stages, Up: Concepts

The Overall Layout of a Bison Grammar
=====================================

The input file for the Bison utility is a "Bison grammar file". The
general form of a Bison grammar file is as follows:

%{
C DECLARATIONS
%}

BISON DECLARATIONS

%%
GRAMMAR RULES
%%
ADDITIONAL C CODE

The `%%', `%{' and `%}' are punctuation that appears in every Bison
grammar file to separate the sections.

The C declarations may define types and variables used in the
actions. You can also use preprocessor commands to define macros used
there, and use `#include' to include header files that do any of these
things.

The Bison declarations declare the names of the terminal and
nonterminal symbols, and may also describe operator precedence and the
data types of semantic values of various symbols.

The grammar rules define how to construct each nonterminal symbol
from its parts.

The additional C code can contain any C code you want to use.
Often the definition of the lexical analyzer `yylex' goes here, plus
subroutines called by the actions in the grammar rules. In a simple
program, all the rest of the program can go here.


File: bison.info, Node: Examples, Next: Grammar File, Prev: Concepts, Up: Top

Examples
********

Now we show and explain three sample programs written using Bison: a
reverse polish notation calculator, an algebraic (infix) notation
calculator, and a multi-function calculator. All three have been
tested under BSD Unix 4.3; each produces a usable, though limited,
interactive desk-top calculator.

These examples are simple, but Bison grammars for real programming
languages are written the same way.

You can copy these examples out of the Info file and into a source
file to try them.

* Menu:

* RPN Calc:: Reverse polish notation calculator;
a first example with no operator precedence.
* Infix Calc:: Infix (algebraic) notation calculator.
Operator precedence is introduced.
* Simple Error Recovery:: Continuing after syntax errors.
* Multi-function Calc:: Calculator with memory and trig functions.
It uses multiple data-types for semantic values.
* Exercises:: Ideas for improving the multi-function calculator.


File: bison.info, Node: RPN Calc, Next: Infix Calc, Prev: Examples, Up: Examples

Reverse Polish Notation Calculator
==================================

The first example is that of a simple double-precision "reverse
polish notation" calculator (a calculator using postfix operators).
This example provides a good starting point, since operator precedence
is not an issue. The second example will illustrate how operator
precedence is handled.

The source code for this calculator is named `rpcalc.y'. The `.y'
extension is a convention used for Bison input files.

* Menu:

* Decls: Rpcalc Decls. Bison and C declarations for rpcalc.
* Rules: Rpcalc Rules. Grammar Rules for rpcalc, with explanation.
* Input: Rpcalc Input. Explaining the rules for `input'.
* Line: Rpcalc Line. Explaining the rules for `line'.
* Expr: Rpcalc Expr. Explaining the rules for `expr'.
* Lexer: Rpcalc Lexer. The lexical analyzer.
* Main: Rpcalc Main. The controlling function.
* Error: Rpcalc Error. The error reporting function.
* Gen: Rpcalc Gen. Running Bison on the grammar file.
* Comp: Rpcalc Compile. Run the C compiler on the output code.


File: bison.info, Node: Rpcalc Decls, Next: Rpcalc Rules, Prev: RPN calc, Up: RPN calc

Declarations for `rpcalc'
-------------------------

Here are the C and Bison declarations for the reverse polish
notation calculator. As in C, comments are placed between `/*...*/'.

/* Reverse polish notation calculator. */

%{
#define YYSTYPE double
#include
%}

%token NUM

%% /* Grammar rules and actions follow */

The C declarations section (*note C Declarations::.) contains two
preprocessor directives.

The `#define' directive defines the macro `YYSTYPE', thus
specifying the C data type for semantic values of both tokens and
groupings (*note Value Type::.). The Bison parser will use whatever
type `YYSTYPE' is defined as; if you don't define it, `int' is the
default. Because we specify `double', each token and each expression
has an associated value, which is a floating point number.

The `#include' directive is used to declare the exponentiation
function `pow'.

The second section, Bison declarations, provides information to
Bison about the token types (*note Bison Declarations::.). Each
terminal symbol that is not a single-character literal must be
declared here. (Single-character literals normally don't need to be
declared.) In this example, all the arithmetic operators are
designated by single-character literals, so the only terminal symbol
that needs to be declared is `NUM', the token type for numeric
constants.


File: bison.info, Node: Rpcalc Rules, Next: Rpcalc Input, Prev: Rpcalc Decls, Up: RPN Calc

Grammar Rules for `rpcalc'
--------------------------

Here are the grammar rules for the reverse polish notation
calculator.

input: /* empty */
| input line
;

line: '\n'
| exp '\n' { printf ("\t%.10g\n", $1); }
;

exp: NUM { $$ = $1; }
| exp exp '+' { $$ = $1 + $2; }
| exp exp '-' { $$ = $1 - $2; }
| exp exp '*' { $$ = $1 * $2; }
| exp exp '/' { $$ = $1 / $2; }
/* Exponentiation */
| exp exp '^' { $$ = pow ($1, $2); }
/* Unary minus */
| exp 'n' { $$ = -$1; }
;
%%

The groupings of the rpcalc "language" defined here are the
expression (given the name `exp'), the line of input (`line'), and the
complete input transcript (`input'). Each of these nonterminal
symbols has several alternate rules, joined by the `|' punctuator
which is read as "or". The following sections explain what these rules
mean.

The semantics of the language is determined by the actions taken
when a grouping is recognized. The actions are the C code that
appears inside braces. *Note Actions::.

You must specify these actions in C, but Bison provides the means
for passing semantic values between the rules. In each action, the
pseudo-variable `$$' stands for the semantic value for the grouping
that the rule is going to construct. Assigning a value to `$$' is the
main job of most actions. The semantic values of the components of the
rule are referred to as `$1', `$2', and so on.


File: bison.info, Node: Rpcalc Input, Next: Rpcalc Line, Prev: Rpcalc Rules, Up: RPN Calc

Explanation of `input'
......................

Consider the definition of `input':

input: /* empty */
| input line
;

This definition reads as follows: "A complete input is either an
empty string, or a complete input followed by an input line". Notice
that "complete input" is defined in terms of itself. This definition
is said to be "left recursive" since `input' appears always as the
leftmost symbol in the sequence. *Note Recursion::.

The first alternative is empty because there are no symbols between
the colon and the first `|'; this means that `input' can match an
empty string of input (no tokens). We write the rules this way
because it is legitimate to type `Ctrl-d' right after you start the
calculator. It's conventional to put an empty alternative first and
write the comment `/* empty */' in it.

The second alternate rule (`input line') handles all nontrivial
input. It means, "After reading any number of lines, read one more
line if possible." The left recursion makes this rule into a loop.
Since the first alternative matches empty input, the loop can be
executed zero or more times.

The parser function `yyparse' continues to process input until a
grammatical error is seen or the lexical analyzer says there are no
more input tokens; we will arrange for the latter to happen at end of
file.


File: bison.info, Node: Rpcalc Line, Next: Rpcalc Expr, Prev: Rpcalc Input, Up: RPN Calc

Explanation of `line'
.....................

Now consider the definition of `line':

line: '\n'
| exp '\n' { printf ("\t%.10g\n", $1); }
;

The first alternative is a token which is a newline character; this
means that rpcalc accepts a blank line (and ignores it, since there is
no action). The second alternative is an expression followed by a
newline. This is the alternative that makes rpcalc useful. The
semantic value of the `exp' grouping is the value of `$1' because the
`exp' in question is the first symbol in the alternative. The action
prints this value, which is the result of the computation the user
asked for.

This action is unusual because it does not assign a value to `$$'.
As a consequence, the semantic value associated with the `line' is
uninitialized (its value will be unpredictable). This would be a bug
if that value were ever used, but we don't use it: once rpcalc has
printed the value of the user's input line, that value is no longer
needed.


File: bison.info, Node: Rpcalc Expr, Next: Rpcalc Lexer, Prev: Rpcalc Line, Up: RPN Calc

Explanation of `expr'
.....................

The `exp' grouping has several rules, one for each kind of
expression. The first rule handles the simplest expressions: those
that are just numbers. The second handles an addition-expression,
which looks like two expressions followed by a plus-sign. The third
handles subtraction, and so on.

exp: NUM
| exp exp '+' { $$ = $1 + $2; }
| exp exp '-' { $$ = $1 - $2; }
...
;

We have used `|' to join all the rules for `exp', but we could
equally well have written them separately:

exp: NUM ;
exp: exp exp '+' { $$ = $1 + $2; } ;
exp: exp exp '-' { $$ = $1 - $2; } ;
...

Most of the rules have actions that compute the value of the
expression in terms of the value of its parts. For example, in the
rule for addition, `$1' refers to the first component `exp' and `$2'
refers to the second one. The third component, `'+'', has no
meaningful associated semantic value, but if it had one you could
refer to it as `$3'. When `yyparse' recognizes a sum expression using
this rule, the sum of the two subexpressions' values is produced as
the value of the entire expression. *Note Actions::.

You don't have to give an action for every rule. When a rule has no
action, Bison by default copies the value of `$1' into `$$'. This is
what happens in the first rule (the one that uses `NUM').

The formatting shown here is the recommended convention, but Bison
does not require it. You can add or change whitespace as much as you
wish. For example, this:

exp : NUM | exp exp '+' {$$ = $1 + $2; } | ...

means the same thing as this:

exp: NUM
| exp exp '+' { $$ = $1 + $2; }
| ...

The latter, however, is much more readable.

./info/bison.info-2 644 0 0 143325 5213513117 12340 0ustar rootrootInfo file bison.info, produced by Makeinfo, -*- Text -*- from input
file bison.texinfo.

This file documents the Bison parser generator.

Copyright (C) 1988, 1989, 1990 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License" and
"Conditions for Using Bison" are included exactly as in the original,
and provided that the entire resulting derived work is distributed
under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License", "Conditions for Using Bison" and this permission notice may
be included in translations approved by the Free Software Foundation
instead of in the original English.


File: bison.info, Node: Rpcalc Lexer, Next: Rpcalc Main, Prev: Rpcalc Expr, Up: RPN Calc

The `rpcalc' Lexical Analyzer
-----------------------------

The lexical analyzer's job is low-level parsing: converting
characters or sequences of characters into tokens. The Bison parser
gets its tokens by calling the lexical analyzer. *Note Lexical::.

Only a simple lexical analyzer is needed for the RPN calculator.
This lexical analyzer skips blanks and tabs, then reads in numbers as
`double' and returns them as `NUM' tokens. Any other character that
isn't part of a number is a separate token. Note that the token-code
for such a single-character token is the character itself.

The return value of the lexical analyzer function is a numeric code
which represents a token type. The same text used in Bison rules to
stand for this token type is also a C expression for the numeric code
for the type. This works in two ways. If the token type is a
character literal, then its numeric code is the ASCII code for that
character; you can use the same character literal in the lexical
analyzer to express the number. If the token type is an identifier,
that identifier is defined by Bison as a C macro whose definition is
the appropriate number. In this example, therefore, `NUM' becomes a
macro for `yylex' to use.

The semantic value of the token (if it has one) is stored into the
global variable `yylval', which is where the Bison parser will look
for it. (The C data type of `yylval' is `YYSTYPE', which was defined
at the beginning of the grammar; *note Rpcalc Decls::..)

A token type code of zero is returned if the end-of-file is
encountered. (Bison recognizes any nonpositive value as indicating
the end of the input.)

Here is the code for the lexical analyzer:

/* Lexical analyzer returns a double floating point
number on the stack and the token NUM, or the ASCII
character read if not a number. Skips all blanks
and tabs, returns 0 for EOF. */

#include

yylex ()
{
int c;

/* skip white space */
while ((c = getchar ()) == ' ' || c == '\t')
;
/* process numbers */
if (c == '.' || isdigit (c))
{
ungetc (c, stdin);
scanf ("%lf", &yylval);
return NUM;
}
/* return end-of-file */
if (c == EOF)
return 0;
/* return single chars */
return c;
}


File: bison.info, Node: Rpcalc Main, Next: Rpcalc Error, Prev: Rpcalc Lexer, Up: RPN Calc

The Controlling Function
------------------------

In keeping with the spirit of this example, the controlling
function is kept to the bare minimum. The only requirement is that it
call `yyparse' to start the process of parsing.

main ()
{
yyparse ();
}


File: bison.info, Node: Rpcalc Error, Next: Rpcalc Gen, Prev: Rpcalc Main, Up: RPN Calc

The Error Reporting Routine
---------------------------

When `yyparse' detects a syntax error, it calls the error reporting
function `yyerror' to print an error message (usually but not always
`"parse error"'). It is up to the programmer to supply `yyerror'
(*note Interface::.), so here is the definition we will use:

#include

yyerror (s) /* Called by yyparse on error */
char *s;
{
printf ("%s\n", s);
}

After `yyerror' returns, the Bison parser may recover from the error
and continue parsing if the grammar contains a suitable error rule
(*note Error Recovery::.). Otherwise, `yyparse' returns nonzero. We
have not written any error rules in this example, so any invalid input
will cause the calculator program to exit. This is not clean behavior
for a real calculator, but it is adequate in the first example.


File: bison.info, Node: Rpcalc Gen, Next: Rpcalc Compile, Prev: Rpcalc Error, Up: RPN Calc

Running Bison to Make the Parser
--------------------------------

Before running Bison to produce a parser, we need to decide how to
arrange all the source code in one or more source files. For such a
simple example, the easiest thing is to put everything in one file.
The definitions of `yylex', `yyerror' and `main' go at the end, in the
"additional C code" section of the file (*note Grammar Layout::.).

For a large project, you would probably have several source files,
and use `make' to arrange to recompile them.

With all the source in a single file, you use the following command
to convert it into a parser file:

bison FILE_NAME.y

In this example the file was called `rpcalc.y' (for "Reverse Polish
CALCulator"). Bison produces a file named `FILE_NAME.tab.c', removing
the `.y' from the original file name. The file output by Bison
contains the source code for `yyparse'. The additional functions in
the input file (`yylex', `yyerror' and `main') are copied verbatim to
the output.


File: bison.info, Node: Rpcalc Compile, Prev: Rpcalc Gen, Up: RPN Calc

Compiling the Parser File
-------------------------

Here is how to compile and run the parser file:

# List files in current directory.
% ls
rpcalc.tab.c rpcalc.y


# Compile the Bison parser.
# `-lm' tells compiler to search math library for `pow'.
% cc rpcalc.tab.c -lm -o rpcalc


# List files again.
% ls
rpcalc rpcalc.tab.c rpcalc.y

The file `rpcalc' now contains the executable code. Here is an
example session using `rpcalc'.

% rpcalc
4 9 +
13
3 7 + 3 4 5 *+-
-13
3 7 + 3 4 5 * + - n Note the unary minus, `n'
13
5 6 / 4 n +
-3.166666667
3 4 ^ Exponentiation
81
^D End-of-file indicator
%


File: bison.info, Node: Infix Calc, Next: Simple Error Recovery, Prev: RPN Calc, Up: Examples

Infix Notation Calculator: `calc'
=================================

We now modify rpcalc to handle infix operators instead of postfix.
Infix notation involves the concept of operator precedence and the
need for parentheses nested to arbitrary depth. Here is the Bison
code for `calc.y', an infix desk-top calculator.

/* Infix notation calculator--calc */

%{
#define YYSTYPE double
#include
%}

/* BISON Declarations */
%token NUM
%left '-' '+'
%left '*' '/'
%left NEG /* negation--unary minus */
%right '^' /* exponentiation */

/* Grammar follows */
%%
input: /* empty string */
| input line
;

line: '\n'
| exp '\n' { printf ("\t%.10g\n", $1); }
;

exp: NUM { $$ = $1; }
| exp '+' exp { $$ = $1 + $3; }
| exp '-' exp { $$ = $1 - $3; }
| exp '*' exp { $$ = $1 * $3; }
| exp '/' exp { $$ = $1 / $3; }
| '-' exp %prec NEG { $$ = -$2; }
| exp '^' exp { $$ = pow ($1, $3); }
| '(' exp ')' { $$ = $2; }
;
%%

The functions `yylex', `yyerror' and `main' can be the same as before.

There are two important new features shown in this code.

In the second section (Bison declarations), `%left' declares token
types and says they are left-associative operators. The declarations
`%left' and `%right' (right associativity) take the place of `%token'
which is used to declare a token type name without associativity.
(These tokens are single-character literals, which ordinarily don't
need to be declared. We declare them here to specify the
associativity.)

Operator precedence is determined by the line ordering of the
declarations; the higher the line number of the declaration (lower on
the page or screen), the higher the precedence. Hence, exponentiation
has the highest precedence, unary minus (`NEG') is next, followed by
`*' and `/', and so on. *Note Precedence::.

The other important new feature is the `%prec' in the grammar
section for the unary minus operator. The `%prec' simply instructs
Bison that the rule `| '-' exp' has the same precedence as `NEG'--in
this case the next-to-highest. *Note Contextual Precedence::.

Here is a sample run of `calc.y':

% calc
4 + 4.5 - (34/(8*3+-3))
6.880952381
-56 + 2
-54
3 ^ 2
9


File: bison.info, Node: Simple Error Recovery, Next: Multi-function Calc, Prev: Infix Calc, Up: Examples

Simple Error Recovery
=====================

Up to this point, this manual has not addressed the issue of "error
recovery"--how to continue parsing after the parser detects a syntax
error. All we have handled is error reporting with `yyerror'. Recall
that by default `yyparse' returns after calling `yyerror'. This means
that an erroneous input line causes the calculator program to exit.
Now we show how to rectify this deficiency.

The Bison language itself includes the reserved word `error', which
may be included in the grammar rules. In the example below it has
been added to one of the alternatives for `line':

line: '\n'
| exp '\n' { printf ("\t%.10g\n", $1); }
| error '\n' { yyerrok; }
;

This addition to the grammar allows for simple error recovery in
the event of a parse error. If an expression that cannot be evaluated
is read, the error will be recognized by the third rule for `line',
and parsing will continue. (The `yyerror' function is still called
upon to print its message as well.) The action executes the statement
`yyerrok', a macro defined automatically by Bison; its meaning is that
error recovery is complete (*note Error Recovery::.). Note the
difference between `yyerrok' and `yyerror'; neither one is a misprint.

This form of error recovery deals with syntax errors. There are
other kinds of errors; for example, division by zero, which raises an
exception signal that is normally fatal. A real calculator program
must handle this signal and use `longjmp' to return to `main' and
resume parsing input lines; it would also have to discard the rest of
the current line of input. We won't discuss this issue further
because it is not specific to Bison programs.


File: bison.info, Node: Multi-function Calc, Next: Exercises, Prev: Simple Error Recovery, Up: Examples

Multi-Function Calculator: `mfcalc'
===================================

Now that the basics of Bison have been discussed, it is time to
move on to a more advanced problem. The above calculators provided
only five functions, `+', `-', `*', `/' and `^'. It would be nice to
have a calculator that provides other mathematical functions such as
`sin', `cos', etc.

It is easy to add new operators to the infix calculator as long as
they are only single-character literals. The lexical analyzer `yylex'
passes back all non-number characters as tokens, so new grammar rules
suffice for adding a new operator. But we want something more
flexible: built-in functions whose syntax has this form:

FUNCTION_NAME (ARGUMENT)

At the same time, we will add memory to the calculator, by allowing you
to create named variables, store values in them, and use them later.
Here is a sample session with the multi-function calculator:

% acalc
pi = 3.141592653589
3.1415926536
sin(pi)
0.0000000000
alpha = beta1 = 2.3
2.3000000000
alpha
2.3000000000
ln(alpha)
0.8329091229
exp(ln(beta1))
2.3000000000
%

Note that multiple assignment and nested function calls are
permitted.

* Menu:

* Decl: Mfcalc Decl. Bison declarations for multi-function calculator.
* Rules: Mfcalc Rules. Grammar rules for the calculator.
* Symtab: Mfcalc Symtab. Symbol table management subroutines.


File: bison.info, Node: Mfcalc Decl, Next: Mfcalc Rules, Prev: Multi-function Calc, Up: Multi-function Calc

Declarations for `mfcalc'
-------------------------

Here are the C and Bison declarations for the multi-function
calculator.

%{
#include /* For math functions, cos(), sin(), etc. */
#include "calc.h" /* Contains definition of `symrec' */
%}
%union {
double val; /* For returning numbers. */
symrec *tptr; /* For returning symbol-table pointers */
}

%token NUM /* Simple double precision number */
%token VAR FNCT /* Variable and Function */
%type exp

%right '='
%left '-' '+'
%left '*' '/'
%left NEG /* Negation--unary minus */
%right '^' /* Exponentiation */

/* Grammar follows */

%%

The above grammar introduces only two new features of the Bison
language. These features allow semantic values to have various data
types (*note Multiple Types::.).

The `%union' declaration specifies the entire list of possible
types; this is instead of defining `YYSTYPE'. The allowable types are
now double-floats (for `exp' and `NUM') and pointers to entries in the
symbol table. *Note Union Decl::.

Since values can now have various types, it is necessary to
associate a type with each grammar symbol whose semantic value is
used. These symbols are `NUM', `VAR', `FNCT', and `exp'. Their
declarations are augmented with information about their data type
(placed between angle brackets).

The Bison construct `%type' is used for declaring nonterminal
symbols, just as `%token' is used for declaring token types. We have
not used `%type' before because nonterminal symbols are normally
declared implicitly by the rules that define them. But `exp' must be
declared explicitly so we can specify its value type. *Note Type
Decl::.


File: bison.info, Node: Mfcalc Rules, Next: Mfcalc Symtab, Prev: Mfcalc Decl, Up: Multi-function Calc

Grammar Rules for `mfcalc'
--------------------------

Here are the grammar rules for the multi-function calculator. Most
of them are copied directly from `calc'; three rules, those which
mention `VAR' or `FNCT', are new.

input: /* empty */
| input line
;

line:
'\n'
| exp '\n' { printf ("\t%.10g\n", $1); }
| error '\n' { yyerrok; }
;

exp: NUM { $$ = $1; }
| VAR { $$ = $1->value.var; }
| VAR '=' exp { $$ = $3; $1->value.var = $3; }
| FNCT '(' exp ')' { $$ = (*($1->value.fnctptr))($3); }
| exp '+' exp { $$ = $1 + $3; }
| exp '-' exp { $$ = $1 - $3; }
| exp '*' exp { $$ = $1 * $3; }
| exp '/' exp { $$ = $1 / $3; }
| '-' exp %prec NEG { $$ = -$2; }
| exp '^' exp { $$ = pow ($1, $3); }
| '(' exp ')' { $$ = $2; }
;
/* End of grammar */
%%


File: bison.info, Node: Mfcalc Symtab, Prev: Mfcalc Rules, Up: Multi-function Calc

The `mfcalc' Symbol Table
-------------------------

The multi-function calculator requires a symbol table to keep track
of the names and meanings of variables and functions. This doesn't
affect the grammar rules (except for the actions) or the Bison
declarations, but it requires some additional C functions for support.

The symbol table itself consists of a linked list of records. Its
definition, which is kept in the header `calc.h', is as follows. It
provides for either functions or variables to be placed in the table.

/* Data type for links in the chain of symbols. */
struct symrec
{
char *name; /* name of symbol */
int type; /* type of symbol: either VAR or FNCT */
union {
double var; /* value of a VAR */
double (*fnctptr)(); /* value of a FNCT */
} value;
struct symrec *next; /* link field */
};

typedef struct symrec symrec;

/* The symbol table: a chain of `struct symrec'. */
extern symrec *sym_table;

symrec *putsym ();
symrec *getsym ();

The new version of `main' includes a call to `init_table', a
function that initializes the symbol table. Here it is, and
`init_table' as well:

#include

main ()
{
init_table ();
yyparse ();
}

yyerror (s) /* Called by yyparse on error */
char *s;
{
printf ("%s\n", s);
}

struct init
{
char *fname;
double (*fnct)();
};

struct init arith_fncts[]
= {
"sin", sin,
"cos", cos,
"atan", atan,
"ln", log,
"exp", exp,
"sqrt", sqrt,
0, 0
};

/* The symbol table: a chain of `struct symrec'. */
symrec *sym_table = (symrec *)0;

init_table () /* puts arithmetic functions in table. */
{
int i;
symrec *ptr;
for (i = 0; arith_fncts[i].fname != 0; i++)
{
ptr = putsym (arith_fncts[i].fname, FNCT);
ptr->value.fnctptr = arith_fncts[i].fnct;
}
}

By simply editing the initialization list and adding the necessary
include files, you can add additional functions to the calculator.

Two important functions allow look-up and installation of symbols
in the symbol table. The function `putsym' is passed a name and the
type (`VAR' or `FNCT') of the object to be installed. The object is
linked to the front of the list, and a pointer to the object is
returned. The function `getsym' is passed the name of the symbol to
look up. If found, a pointer to that symbol is returned; otherwise
zero is returned.

symrec *
putsym (sym_name,sym_type)
char *sym_name;
int sym_type;
{
symrec *ptr;
ptr = (symrec *) malloc (sizeof (symrec));
ptr->name = (char *) malloc (strlen (sym_name) + 1);
strcpy (ptr->name,sym_name);
ptr->type = sym_type;
ptr->value.var = 0; /* set value to 0 even if fctn. */
ptr->next = (struct symrec *)sym_table;
sym_table = ptr;
return ptr;
}

symrec *
getsym (sym_name)
char *sym_name;
{
symrec *ptr;
for (ptr = sym_table; ptr != (symrec *) 0;
ptr = (symrec *)ptr->next)
if (strcmp (ptr->name,sym_name) == 0)
return ptr;
return 0;
}

The function `yylex' must now recognize variables, numeric values,
and the single-character arithmetic operators. Strings of alphanumeric
characters with a leading nondigit are recognized as either variables
or functions depending on what the symbol table says about them.

The string is passed to `getsym' for look up in the symbol table.
If the name appears in the table, a pointer to its location and its
type (`VAR' or `FNCT') is returned to `yyparse'. If it is not already
in the table, then it is installed as a `VAR' using `putsym'. Again,
a pointer and its type (which must be `VAR') is returned to `yyparse'.

No change is needed in the handling of numeric values and arithmetic
operators in `yylex'.

#include
yylex ()
{
int c;

/* Ignore whitespace, get first nonwhite character. */
while ((c = getchar ()) == ' ' || c == '\t');

if (c == EOF)
return 0;

/* Char starts a number => parse the number. */
if (c == '.' || isdigit (c))
{
ungetc (c, stdin);
scanf ("%lf", &yylval.val);
return NUM;
}

/* Char starts an identifier => read the name. */
if (isalpha (c))
{
symrec *s;
static char *symbuf = 0;
static int length = 0;
int i;

/* Initially make the buffer long enough
for a 40-character symbol name. */
if (length == 0)
length = 40, symbuf = (char *)malloc (length + 1);

i = 0;
do
{
/* If buffer is full, make it bigger. */
if (i == length)
{
length *= 2;
symbuf = (char *)realloc (symbuf, length + 1);
}
/* Add this character to the buffer. */
symbuf[i++] = c;
/* Get another character. */
c = getchar ();
}
while (c != EOF && isalnum (c));

ungetc (c, stdin);
symbuf[i] = '\0';

s = getsym (symbuf);
if (s == 0)
s = putsym (symbuf, VAR);
yylval.tptr = s;
return s->type;
}

/* Any other character is a token by itself. */
return c;
}

This program is both powerful and flexible. You may easily add new
functions, and it is a simple job to modify this code to install
predefined variables such as `pi' or `e' as well.


File: bison.info, Node: Exercises, Prev: Multi-function calc, Up: Examples

Exercises
=========

1. Add some new functions from `math.h' to the initialization list.

2. Add another array that contains constants and their values. Then
modify `init_table' to add these constants to the symbol table.
It will be easiest to give the constants type `VAR'.

3. Make the program report an error if the user refers to an
uninitialized variable in any way except to store a value in it.


File: bison.info, Node: Grammar File, Next: Interface, Prev: Examples, Up: Top

Bison Grammar Files
*******************

Bison takes as input a context-free grammar specification and
produces a C-language function that recognizes correct instances of
the grammar.

The Bison grammar input file conventionally has a name ending in
`.y'.

* Menu:

* Grammar Outline:: Overall layout of the grammar file.
* Symbols:: Terminal and nonterminal symbols.
* Rules:: How to write grammar rules.
* Recursion:: Writing recursive rules.
* Semantics:: Semantic values and actions.
* Declarations:: All kinds of Bison declarations are described here.
* Multiple Parsers:: Putting more than one Bison parser in one program.


File: bison.info, Node: Grammar Outline, Next: Symbols, Prev: Grammar File, Up: Grammar File

Outline of a Bison Grammar
==========================

A Bison grammar file has four main sections, shown here with the
appropriate delimiters:

%{
C DECLARATIONS
%}

BISON DECLARATIONS

%%
GRAMMAR RULES
%%

ADDITIONAL C CODE

Comments enclosed in `/* ... */' may appear in any of the sections.

* Menu:

* C Declarations:: Syntax and usage of the C declarations section.
* Bison Declarations:: Syntax and usage of the Bison declarations section.
* Grammar Rules:: Syntax and usage of the grammar rules section.
* C Code:: Syntax and usage of the additional C code section.


File: bison.info, Node: C Declarations, Next: Bison Declarations, Prev: Grammar Outline, Up: Grammar Outline

The C Declarations Section
--------------------------

The C DECLARATIONS section contains macro definitions and
declarations of functions and variables that are used in the actions
in the grammar rules. These are copied to the beginning of the parser
file so that they precede the definition of `yyparse'. You can use
`#include' to get the declarations from a header file. If you don't
need any C declarations, you may omit the `%{' and `%}' delimiters
that bracket this section.


File: bison.info, Node: Bison Declarations, Next: Grammar Rules, Prev: C Declarations, Up: Grammar Outline

The Bison Declarations Section
------------------------------

The BISON DECLARATIONS section contains declarations that define
terminal and nonterminal symbols, specify precedence, and so on. In
some simple grammars you may not need any declarations. *Note
Declarations::.


File: bison.info, Node: Grammar Rules, Next: C Code, Prev: Bison Declarations, Up: Grammar Outline

The Grammar Rules Section
-------------------------

The "grammar rules" section contains one or more Bison grammar
rules, and nothing else. *Note Rules::.

There must always be at least one grammar rule, and the first `%%'
(which precedes the grammar rules) may never be omitted even if it is
the first thing in the file.


File: bison.info, Node: C Code, Prev: Grammar Rules, Up: Grammar Outline

The Additional C Code Section
-----------------------------

The ADDITIONAL C CODE section is copied verbatim to the end of the
parser file, just as the C DECLARATIONS section is copied to the
beginning. This is the most convenient place to put anything that you
want to have in the parser file but which need not come before the
definition of `yyparse'. For example, the definitions of `yylex' and
`yyerror' often go here. *Note Interface::.

If the last section is empty, you may omit the `%%' that separates
it from the grammar rules.

The Bison parser itself contains many static variables whose names
start with `yy' and many macros whose names start with `YY'. It is a
good idea to avoid using any such names (except those documented in
this manual) in the additional C code section of the grammar file.


File: bison.info, Node: Symbols, Next: Rules, Prev: Grammar Outline, Up: Grammar File

Symbols, Terminal and Nonterminal
=================================

"Symbols" in Bison grammars represent the grammatical
classifications of the language.

A "terminal symbol" (also known as a "token type") represents a
class of syntactically equivalent tokens. You use the symbol in
grammar rules to mean that a token in that class is allowed. The
symbol is represented in the Bison parser by a numeric code, and the
`yylex' function returns a token type code to indicate what kind of
token has been read. You don't need to know what the code value is;
you can use the symbol to stand for it.

A "nonterminal symbol" stands for a class of syntactically
equivalent groupings. The symbol name is used in writing grammar
rules. By convention, it should be all lower case.

Symbol names can contain letters, digits (not at the beginning),
underscores and periods. Periods make sense only in nonterminals.

There are two ways of writing terminal symbols in the grammar:

* A "named token type" is written with an identifier, like an
identifier in C. By convention, it should be all upper case.
Each such name must be defined with a Bison declaration such as
`%token'. *Note Token Decl::.

* A "character token type" (or "literal token") is written in the
grammar using the same syntax used in C for character constants;
for example, `'+'' is a character token type. A character token
type doesn't need to be declared unless you need to specify its
semantic value data type (*note Value Type::.), associativity, or
precedence (*note Precedence::.).

By convention, a character token type is used only to represent a
token that consists of that particular character. Thus, the token
type `'+'' is used to represent the character `+' as a token.
Nothing enforces this convention, but if you depart from it, your
program will confuse other readers.

All the usual escape sequences used in character literals in C
can be used in Bison as well, but you must not use the null
character as a character literal because its ASCII code, zero, is
the code `yylex' returns for end-of-input (*note Calling
Convention::.).

How you choose to write a terminal symbol has no effect on its
grammatical meaning. That depends only on where it appears in rules
and on when the parser function returns that symbol.

The value returned by `yylex' is always one of the terminal symbols
(or 0 for end-of-input). Whichever way you write the token type in the
grammar rules, you write it the same way in the definition of `yylex'.
The numeric code for a character token type is simply the ASCII code
for the character, so `yylex' can use the identical character constant
to generate the requisite code. Each named token type becomes a C
macro in the parser file, so `yylex' can use the name to stand for the
code. (This is why periods don't make sense in terminal symbols.)
*Note Calling Convention::.

If `yylex' is defined in a separate file, you need to arrange for
the token-type macro definitions to be available there. Use the `-d'
option when you run Bison, so that it will write these macro
definitions into a separate header file `NAME.tab.h' which you can
include in the other source files that need it. *Note Invocation::.

The symbol `error' is a terminal symbol reserved for error recovery
(*note Error Recovery::.); you shouldn't use it for any other purpose.
In particular, `yylex' should never return this value.


File: bison.info, Node: Rules, Next: Recursion, Prev: Symbols, Up: Grammar File

Syntax of Grammar Rules
=======================

A Bison grammar rule has the following general form:

RESULT: COMPONENTS...
;

where RESULT is the nonterminal symbol that this rule describes and
COMPONENTS are various terminal and nonterminal symbols that are put
together by this rule (*note Symbols::.).

For example,

exp: exp '+' exp
;

says that two groupings of type `exp', with a `+' token in between,
can be combined into a larger grouping of type `exp'.

Whitespace in rules is significant only to separate symbols. You
can add extra whitespace as you wish.

Scattered among the components can be ACTIONS that determine the
semantics of the rule. An action looks like this:

{C STATEMENTS}

Usually there is only one action and it follows the components. *Note
Actions::.

Multiple rules for the same RESULT can be written separately or can
be joined with the vertical-bar character `|' as follows:

RESULT: RULE1-COMPONENTS...
| RULE2-COMPONENTS...
...
;

They are still considered distinct rules even when joined in this way.

If COMPONENTS in a rule is empty, it means that RESULT can match
the empty string. For example, here is how to define a
comma-separated sequence of zero or more `exp' groupings:

expseq: /* empty */
| expseq1
;


expseq1: exp
| expseq1 ',' exp
;

It is customary to write a comment `/* empty */' in each rule with no
components.


File: bison.info, Node: Recursion, Next: Semantics, Prev: Rules, Up: Grammar File

Recursive Rules
===============

A rule is called "recursive" when its RESULT nonterminal appears
also on its right hand side. Nearly all Bison grammars need to use
recursion, because that is the only way to define a sequence of any
number of somethings. Consider this recursive definition of a
comma-separated sequence of one or more expressions:

expseq1: exp
| expseq1 ',' exp
;

Since the recursive use of `expseq1' is the leftmost symbol in the
right hand side, we call this "left recursion". By contrast, here the
same construct is defined using "right recursion":

expseq1: exp
| exp ',' expseq1
;

Any kind of sequence can be defined using either left recursion or
right recursion, but you should always use left recursion, because it
can parse a sequence of any number of elements with bounded stack
space. Right recursion uses up space on the Bison stack in proportion
to the number of elements in the sequence, because all the elements
must be shifted onto the stack before the rule can be applied even
once. *Note The Algorithm of the Bison Parser: Algorithm, for further
explanation of this.

"Indirect" or "mutual" recursion occurs when the result of the rule
does not appear directly on its right hand side, but does appear in
rules for other nonterminals which do appear on its right hand side.

For example:

expr: primary
| primary '+' primary
;


primary: constant
| '(' expr ')'
;

defines two mutually-recursive nonterminals, since each refers to the
other.


File: bison.info, Node: Semantics, Next: Declarations, Prev: Recursion, Up: Grammar File

Defining Language Semantics
===========================

The grammar rules for a language determine only the syntax. The
semantics are determined by the semantic values associated with
various tokens and groupings, and by the actions taken when various
groupings are recognized.

For example, the calculator calculates properly because the value
associated with each expression is the proper number; it adds properly
because the action for the grouping `X + Y' is to add the numbers
associated with X and Y.

* Menu:

* Value Type:: Specifying one data type for all semantic values.
* Multiple Types:: Specifying several alternative data types.
* Actions:: An action is the semantic definition of a grammar rule.
* Action Types:: Specifying data types for actions to operate on.
* Mid-Rule Actions:: Most actions go at the end of a rule.
This says when, why and how to use the exceptional
action in the middle of a rule.


File: bison.info, Node: Value Type, Next: Multiple Types, Prev: Semantics, Up: Semantics

Data Types of Semantic Values
-----------------------------

In a simple program it may be sufficient to use the same data type
for the semantic values of all language constructs. This was true in
the RPN and infix calculator examples (*note RPN Calc::.).

Bison's default is to use type `int' for all semantic values. To
specify some other type, define `YYSTYPE' as a macro, like this:

#define YYSTYPE double

This macro definition must go in the C declarations section of the
grammar file (*note Grammar Outline::.).


File: bison.info, Node: Multiple Types, Next: Actions, Prev: Value Type, Up: Semantics

More Than One Value Type
------------------------

In most programs, you will need different data types for different
kinds of tokens and groupings. For example, a numeric constant may
need type `int' or `long', while a string constant needs type `char *',
and an identifier might need a pointer to an entry in the symbol table.

To use more than one data type for semantic values in one parser,
Bison requires you to do two things:

* Specify the entire collection of possible data types, with the
`%union' Bison declaration (*note Union Decl::.).

* Choose one of those types for each symbol (terminal or
nonterminal) for which semantic values are used. This is done
for tokens with the `%token' Bison declaration (*note Token
Decl::.) and for groupings with the `%type' Bison declaration
(*note Type Decl::.).


File: bison.info, Node: Actions, Next: Action Types, Prev: Multiple Types, Up: Semantics

Actions
-------

An action accompanies a syntactic rule and contains C code to be
executed each time an instance of that rule is recognized. The task
of most actions is to compute a semantic value for the grouping built
by the rule from the semantic values associated with tokens or smaller
groupings.

An action consists of C statements surrounded by braces, much like a
compound statement in C. It can be placed at any position in the
rule; it is executed at that position. Most rules have just one
action at the end of the rule, following all the components. Actions
in the middle of a rule are tricky and used only for special purposes
(*note Mid-Rule Actions::.).

The C code in an action can refer to the semantic values of the
components matched by the rule with the construct `$N', which stands
for the value of the Nth component. The semantic value for the
grouping being constructed is `$$'. (Bison translates both of these
constructs into array element references when it copies the actions
into the parser file.)

Here is a typical example:

exp: ...
| exp '+' exp
{ $$ = $1 + $3; }

This rule constructs an `exp' from two smaller `exp' groupings
connected by a plus-sign token. In the action, `$1' and `$3' refer to
the semantic values of the two component `exp' groupings, which are
the first and third symbols on the right hand side of the rule. The
sum is stored into `$$' so that it becomes the semantic value of the
addition-expression just recognized by the rule. If there were a
useful semantic value associated with the `+' token, it could be
referred to as `$2'.

`$N' with N zero or negative is allowed for reference to tokens and
groupings on the stack *before* those that match the current rule.
This is a very risky practice, and to use it reliably you must be
certain of the context in which the rule is applied. Here is a case
in which you can use this reliably:

foo: expr bar '+' expr { ... }
| expr bar '-' expr { ... }
;


bar: /* empty */
{ previous_expr = $0; }
;

As long as `bar' is used only in the fashion shown here, `$0'
always refers to the `expr' which precedes `bar' in the definition of
`foo'.


File: bison.info, Node: Action Types, Next: Mid-Rule Actions, Prev: Actions, Up: Semantics

Data Types of Values in Actions
-------------------------------

If you have chosen a single data type for semantic values, the `$$'
and `$N' constructs always have that data type.

If you have used `%union' to specify a variety of data types, then
you must declare a choice among these types for each terminal or
nonterminal symbol that can have a semantic value. Then each time you
use `$$' or `$N', its data type is determined by which symbol it
refers to in the rule. In this example,

exp: ...
| exp '+' exp
{ $$ = $1 + $3; }

`$1' and `$3' refer to instances of `exp', so they all have the data
type declared for the nonterminal symbol `exp'. If `$2' were used, it
would have the data type declared for the terminal symbol `'+'',
whatever that might be.

Alternatively, you can specify the data type when you refer to the
value, by inserting `' after the `$' at the beginning of the
reference. For example, if you have defined types as shown here:

%union {
int itype;
double dtype;
}

then you can write `$1' to refer to the first subunit of the
rule as an integer, or `$1' to refer to it as a double.


File: bison.info, Node: Mid-Rule Actions, Prev: Action Types, Up: Semantics

Actions in Mid-Rule
-------------------

Occasionally it is useful to put an action in the middle of a rule.
These actions are written just like usual end-of-rule actions, but they
are executed before the parser even recognizes the following
components.

A mid-rule action may refer to the components preceding it using
`$N', but it may not refer to subsequent components because it is run
before they are parsed.

The mid-rule action itself counts as one of the components of the
rule. This makes a difference when there is another action later in
the same rule (and usually there is another at the end): you have to
count the actions along with the symbols when working out which number
N to use in `$N'.

The mid-rule action can also have a semantic value. This can be set
within that action by an assignment to `$$', and can referred to by
actions later in the rule using `$N'. Since there is no symbol to
name the action, there is no way to declare a data type for the value
in advance, so you must use the `$<...>' construct to specify a data
type each time you refer to this value.

There is no way to set the value of the entire rule with a mid-rule
action, because assignments to `$$' do not have that effect. The only
way to set the value for the entire rule is with an ordinary action at
the end of the rule.

Here is an example from a hypothetical compiler, handling a `let'
statement that looks like `let (VARIABLE) STATEMENT' and serves to
create a variable named VARIABLE temporarily for the duration of
STATEMENT. To parse this construct, we must put VARIABLE into the
symbol table while STATEMENT is parsed, then remove it afterward.
Here is how it is done:

stmt: LET '(' var ')'
{ $$ = push_context ();
declare_variable ($3); }
stmt { $$ = $6;
pop_context ($5); }

As soon as `let (VARIABLE)' has been recognized, the first action is
run. It saves a copy of the current semantic context (the list of
accessible variables) as its semantic value, using alternative
`context' in the data-type union. Then it calls `declare_variable' to
add the new variable to that list. Once the first action is finished,
the embedded statement `stmt' can be parsed. Note that the mid-rule
action is component number 5, so the `stmt' is component number 6.

After the embedded statement is parsed, its semantic value becomes
the value of the entire `let'-statement. Then the semantic value from
the earlier action is used to restore the prior list of variables.
This removes the temporary `let'-variable from the list so that it
won't appear to exist while the rest of the program is parsed.

Taking action before a rule is completely recognized often leads to
conflicts since the parser must commit to a parse in order to execute
the action. For example, the following two rules, without mid-rule
actions, can coexist in a working parser because the parser can shift
the open-brace token and look at what follows before deciding whether
there is a declaration or not:

compound: '{' declarations statements '}'
| '{' statements '}'
;

But when we add a mid-rule action as follows, the rules become
nonfunctional:

compound: { prepare_for_local_variables (); }
'{' declarations statements '}'

| '{' statements '}'
;

Now the parser is forced to decide whether to run the mid-rule action
when it has read no farther than the open-brace. In other words, it
must commit to using one rule or the other, without sufficient
information to do it correctly. (The open-brace token is what is
called the "look-ahead" token at this time, since the parser is still
deciding what to do about it. *Note Look-Ahead::.)

You might think that you could correct the problem by putting
identical actions into the two rules, like this:

compound: { prepare_for_local_variables (); }
'{' declarations statements '}'
| { prepare_for_local_variables (); }
'{' statements '}'
;

But this does not help, because Bison does not realize that the two
actions are identical. (Bison never tries to understand the C code in
an action.)

If the grammar is such that a declaration can be distinguished from
a statement by the first token (which is true in C), then one solution
which does work is to put the action after the open-brace, like this:

compound: '{' { prepare_for_local_variables (); }
declarations statements '}'
| '{' statements '}'
;

Now the first token of the following declaration or statement, which
would in any case tell Bison which rule to use, can still do so.

Another solution is to bury the action inside a nonterminal symbol
which serves as a subroutine:

subroutine: /* empty */
{ prepare_for_local_variables (); }
;


compound: subroutine
'{' declarations statements '}'
| subroutine
'{' statements '}'
;

Now Bison can execute the action in the rule for `subroutine' without
deciding which rule for `compound' it will eventually use. Note that
the action is now at the end of its rule. Any mid-rule action can be
converted to an end-of-rule action in this way, and this is what Bison
actually does to implement mid-rule actions.


File: bison.info, Node: Declarations, Next: Multiple Parsers, Prev: Semantics, Up: Grammar File

Bison Declarations
==================

The "Bison declarations" section of a Bison grammar defines the
symbols used in formulating the grammar and the data types of semantic
values. *Note Symbols::.

All token type names (but not single-character literal tokens such
as `'+'' and `'*'') must be declared. Nonterminal symbols must be
declared if you need to specify which data type to use for the semantic
value (*note Multiple Types::.).

The first rule in the file also specifies the start symbol, by
default. If you want some other symbol to be the start symbol, you
must declare it explicitly (*note Language and Grammar::.).

* Menu:

* Token Decl:: Declaring terminal symbols.
* Precedence Decl:: Declaring terminals with precedence and associativity.
* Union Decl:: Declaring the set of all semantic value types.
* Type Decl:: Declaring the choice of type for a nonterminal symbol.
* Expect Decl:: Suppressing warnings about shift/reduce conflicts.
* Start Decl:: Specifying the start symbol.
* Pure Decl:: Requesting a reentrant parser.
* Decl Summary:: Table of all Bison declarations.


File: bison.info, Node: Token Decl, Next: Precedence Decl, Prev: Declarations, Up: Declarations

Token Type Names
----------------

The basic way to declare a token type name (terminal symbol) is as
follows:

%token NAME

Bison will convert this into a `#define' directive in the parser,
so that the function `yylex' (if it is in this file) can use the name
NAME to stand for this token type's code.

Alternatively you can use `%left', `%right', or `%nonassoc' instead
of `%token', if you wish to specify precedence. *Note Precedence
Decl::.

You can explicitly specify the numeric code for a token type by
appending an integer value in the field immediately following the
token name:

%token NUM 300

It is generally best, however, to let Bison choose the numeric codes
for all token types. Bison will automatically select codes that don't
conflict with each other or with ASCII characters.

In the event that the stack type is a union, you must augment the
`%token' or other token declaration to include the data type
alternative delimited by angle-brackets (*note Multiple Types::.).

For example:

%union { /* define stack type */
double val;
symrec *tptr;
}
%token NUM /* define token NUM and its type */


File: bison.info, Node: Precedence Decl, Next: Union Decl, Prev: Token Decl, Up: Declarations

Operator Precedence
-------------------

Use the `%left', `%right' or `%nonassoc' declaration to declare a
token and specify its precedence and associativity, all at once.
These are called "precedence declarations". *Note Precedence::, for
general information on operator precedence.

The syntax of a precedence declaration is the same as that of
`%token': either

%left SYMBOLS...

or

%left SYMBOLS...

And indeed any of these declarations serves the purposes of
`%token'. But in addition, they specify the associativity and
relative precedence for all the SYMBOLS:

* The associativity of an operator OP determines how repeated uses
of the operator nest: whether `X OP Y OP Z' is parsed by grouping
X with Y first or by grouping Y with Z first. `%left' specifies
left-associativity (grouping X with Y first) and `%right'
specifies right-associativity (grouping Y with Z first).
`%nonassoc' specifies no associativity, which means that `X OP Y
OP Z' is considered a syntax error.

* The precedence of an operator determines how it nests with other
operators. All the tokens declared in a single precedence
declaration have equal precedence and nest together according to
their associativity. When two tokens declared in different
precedence declarations associate, the one declared later has the
higher precedence and is grouped first.


File: bison.info, Node: Union Decl, Next: Type Decl, Prev: Precedence Decl, Up: Declarations

The Collection of Value Types
-----------------------------

The `%union' declaration specifies the entire collection of possible
data types for semantic values. The keyword `%union' is followed by a
pair of braces containing the same thing that goes inside a `union' in
C.

For example:

%union {
double val;
symrec *tptr;
}

This says that the two alternative types are `double' and `symrec *'.
They are given names `val' and `tptr'; these names are used in the
`%token' and `%type' declarations to pick one of the types for a
terminal or nonterminal symbol (*note Type Decl::.).

Note that, unlike making a `union' declaration in C, you do not
write a semicolon after the closing brace.

./info/bison.info-3 644 0 0 140175 5213513117 12341 0ustar rootrootInfo file bison.info, produced by Makeinfo, -*- Text -*- from input
file bison.texinfo.

This file documents the Bison parser generator.

Copyright (C) 1988, 1989, 1990 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License" and
"Conditions for Using Bison" are included exactly as in the original,
and provided that the entire resulting derived work is distributed
under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License", "Conditions for Using Bison" and this permission notice may
be included in translations approved by the Free Software Foundation
instead of in the original English.


File: bison.info, Node: Type Decl, Next: Expect Decl, Prev: Union Decl, Up: Declarations

Nonterminal Symbols
-------------------

When you use `%union' to specify multiple value types, you must
declare the value type of each nonterminal symbol for which values are
used. This is done with a `%type' declaration, like this:

%type NONTERMINAL...

Here NONTERMINAL is the name of a nonterminal symbol, and TYPE is the
name given in the `%union' to the alternative that you want (*note
Union Decl::.). You can give any number of nonterminal symbols in the
same `%type' declaration, if they have the same value type. Use
spaces to separate the symbol names.


File: bison.info, Node: Expect Decl, Next: Start Decl, Prev: Type Decl, Up: Declarations

Suppressing Conflict Warnings
-----------------------------

Bison normally warns if there are any conflicts in the grammar
(*note Shift/Reduce::.), but most real grammars have harmless
shift/reduce conflicts which are resolved in a predictable way and
would be difficult to eliminate. It is desirable to suppress the
warning about these conflicts unless the number of conflicts changes.
You can do this with the `%expect' declaration.

The declaration looks like this:

%expect N

Here N is a decimal integer. The declaration says there should be
no warning if there are N shift/reduce conflicts and no reduce/reduce
conflicts. The usual warning is given if there are either more or
fewer conflicts, or if there are any reduce/reduce conflicts.

In general, using `%expect' involves these steps:

* Compile your grammar without `%expect'. Use the `-v' option to
get a verbose list of where the conflicts occur. Bison will also
print the number of conflicts.

* Check each of the conflicts to make sure that Bison's default
resolution is what you really want. If not, rewrite the grammar
and go back to the beginning.

* Add an `%expect' declaration, copying the number N from the
number which Bison printed.

Now Bison will stop annoying you about the conflicts you have
checked, but it will warn you again if changes in the grammer result
in additional conflicts.


File: bison.info, Node: Start Decl, Next: Pure Decl, Prev: Expect Decl, Up: Declarations

The Start-Symbol
----------------

Bison assumes by default that the start symbol for the grammar is
the first nonterminal specified in the grammar specification section.
The programmer may override this restriction with the `%start'
declaration as follows:

%start SYMBOL


File: bison.info, Node: Pure Decl, Next: Decl Summary, Prev: Start Decl, Up: Declarations

A Pure (Reentrant) Parser
-------------------------

A "reentrant" program is one which does not alter in the course of
execution; in other words, it consists entirely of "pure" (read-only)
code. Reentrancy is important whenever asynchronous execution is
possible; for example, a nonreentrant program may not be safe to call
from a signal handler. In systems with multiple threads of control, a
nonreentrant program must be called only within interlocks.

The Bison parser is not normally a reentrant program, because it
uses statically allocated variables for communication with `yylex'.
These variables include `yylval' and `yylloc'.

The Bison declaration `%pure_parser' says that you want the parser
to be reentrant. It looks like this:

%pure_parser

The effect is that the two communication variables become local
variables in `yyparse', and a different calling convention is used for
the lexical analyzer function `yylex'. *Note Pure Calling::, for the
details of this. The variable `yynerrs' also becomes local in
`yyparse' (*note Error Reporting::.). The convention for calling
`yyparse' itself is unchanged.


File: bison.info, Node: Decl Summary, Prev: Pure Decl, Up: Declarations

Bison Declaration Summary
-------------------------

Here is a summary of all Bison declarations:

`%union'
Declare the collection of data types that semantic values may have
(*note Union Decl::.).

`%token'
Declare a terminal symbol (token type name) with no precedence or
associativity specified (*note Token Decl::.).

`%right'
Declare a terminal symbol (token type name) that is
right-associative (*note Precedence Decl::.).

`%left'
Declare a terminal symbol (token type name) that is
left-associative (*note Precedence Decl::.).

`%nonassoc'
Declare a terminal symbol (token type name) that is nonassociative
(using it in a way that would be associative is a syntax error)
(*note Precedence Decl::.).

`%type'
Declare the type of semantic values for a nonterminal symbol
(*note Type Decl::.).

`%start'
Specify the grammar's start symbol (*note Start Decl::.).

`%expect'
Declare the expected number of shift-reduce conflicts (*note
Expect Decl::.).

`%pure_parser'
Request a pure (reentrant) parser program (*note Pure Decl::.).


File: bison.info, Node: Multiple Parsers, Prev: Declarations, Up: Grammar File

Multiple Parsers in the Same Program
====================================

Most programs that use Bison parse only one language and therefore
contain only one Bison parser. But what if you want to parse more
than one language with the same program? Then you need to avoid a
name conflict between different definitions of `yyparse', `yylval',
and so on.

The easy way to do this is to use the option `-p PREFIX' (*note
Invocation::.). This renames the interface functions and variables of
the Bison parser to start with PREFIX instead of `yy'. You can use
this to give each parser distinct names that do not conflict.

The precise list of symbols renamed is `yyparse', `yylex',
`yyerror', `yylval', `yychar' and `yydebug'. For example, if you use
`-p c', the names become `cparse', `clex', and so on.

*All the other variables and macros associated with Bison are not
renamed.* These others are not global; there is no conflict if the same
name is used in different parsers. For example, `YYSTYPE' is not
renamed, but defining this in different ways in different parsers
causes no trouble (*note Value Type::.).

The `-p' option works by adding macro definitions to the beginning
of the parser source file, defining `yyparse' as `PREFIXparse', and so
on. This effectively substitutes one name for the other in the entire
parser file.


File: bison.info, Node: Interface, Next: Algorithm, Prev: Grammar File, Up: Top

Parser C-Language Interface
***************************

The Bison parser is actually a C function named `yyparse'. Here we
describe the interface conventions of `yyparse' and the other
functions that it needs to use.

Keep in mind that the parser uses many C identifiers starting with
`yy' and `YY' for internal purposes. If you use such an identifier
(aside from those in this manual) in an action or in additional C code
in the grammar file, you are likely to run into trouble.

* Menu:

* Parser Function:: How to call `yyparse' and what it returns.
* Lexical:: You must supply a function `yylex' which reads tokens.
* Error Reporting:: You must supply a function `yyerror'.
* Action Features:: Special features for use in actions.


File: bison.info, Node: Parser Function, Next: Lexical, Prev: Interface, Up: Interface

The Parser Function `yyparse'
=============================

You call the function `yyparse' to cause parsing to occur. This
function reads tokens, executes actions, and ultimately returns when it
encounters end-of-input or an unrecoverable syntax error. You can also
write an action which directs `yyparse' to return immediately without
reading further.

The value returned by `yyparse' is 0 if parsing was successful
(return is due to end-of-input).

The value is 1 if parsing failed (return is due to a syntax error).

In an action, you can cause immediate return from `yyparse' by using
these macros:

`YYACCEPT'
Return immediately with value 0 (to report success).

`YYABORT'
Return immediately with value 1 (to report failure).


File: bison.info, Node: Lexical, Next: Error Reporting, Prev: Parser Function, Up: Interface

The Lexical Analyzer Function `yylex'
=====================================

The "lexical analyzer" function, `yylex', recognizes tokens from
the input stream and returns them to the parser. Bison does not create
this function automatically; you must write it so that `yyparse' can
call it. The function is sometimes referred to as a lexical scanner.

In simple programs, `yylex' is often defined at the end of the Bison
grammar file. If `yylex' is defined in a separate source file, you
need to arrange for the token-type macro definitions to be available
there. To do this, use the `-d' option when you run Bison, so that it
will write these macro definitions into a separate header file
`NAME.tab.h' which you can include in the other source files that need
it. *Note Invocation::.

* Menu:

* Calling Convention:: How `yyparse' calls `yylex'.
* Token Values:: How `yylex' must return the semantic value
of the token it has read.
* Token Positions:: How `yylex' must return the text position
(line number, etc.) of the token, if the
actions want that.
* Pure Calling:: How the calling convention differs
in a pure parser (*note Pure Decl::.).


File: bison.info, Node: Calling Convention, Next: Token Values, Prev: Lexical, Up: Lexical

Calling Convention for `yylex'
------------------------------

The value that `yylex' returns must be the numeric code for the type
of token it has just found, or 0 for end-of-input.

When a token is referred to in the grammar rules by a name, that
name in the parser file becomes a C macro whose definition is the
proper numeric code for that token type. So `yylex' can use the name
to indicate that type. *Note Symbols::.

When a token is referred to in the grammar rules by a character
literal, the numeric code for that character is also the code for the
token type. So `yylex' can simply return that character code. The
null character must not be used this way, because its code is zero and
that is what signifies end-of-input.

Here is an example showing these things:

yylex ()
{
...
if (c == EOF) /* Detect end of file. */
return 0;
...
if (c == '+' || c == '-')
return c; /* Assume token type for `+' is '+'. */
...
return INT; /* Return the type of the token. */
...
}

This interface has been designed so that the output from the `lex'
utility can be used without change as the definition of `yylex'.


File: bison.info, Node: Token Values, Next: Token Positions, Prev: Calling Convention, Up: Lexical

Semantic Values of Tokens
-------------------------

In an ordinary (nonreentrant) parser, the semantic value of the
token must be stored into the global variable `yylval'. When you are
using just one data type for semantic values, `yylval' has that type.
Thus, if the type is `int' (the default), you might write this in
`yylex':

...
yylval = value; /* Put value onto Bison stack. */
return INT; /* Return the type of the token. */
...

When you are using multiple data types, `yylval''s type is a union
made from the `%union' declaration (*note Union Decl::.). So when you
store a token's value, you must use the proper member of the union.
If the `%union' declaration looks like this:

%union {
int intval;
double val;
symrec *tptr;
}

then the code in `yylex' might look like this:

...
yylval.intval = value; /* Put value onto Bison stack. */
return INT; /* Return the type of the token. */
...


File: bison.info, Node: Token Positions, Next: Pure Calling, Prev: Token Values, Up: Lexical

Textual Positions of Tokens
---------------------------

If you are using the `@N'-feature (*note Action Features::.) in
actions to keep track of the textual locations of tokens and groupings,
then you must provide this information in `yylex'. The function
`yyparse' expects to find the textual location of a token just parsed
in the global variable `yylloc'. So `yylex' must store the proper
data in that variable. The value of `yylloc' is a structure and you
need only initialize the members that are going to be used by the
actions. The four members are called `first_line', `first_column',
`last_line' and `last_column'. Note that the use of this feature
makes the parser noticeably slower.

The data type of `yylloc' has the name `YYLTYPE'.


File: bison.info, Node: Pure Calling, Prev: Token Positions, Up: Lexical

Calling for Pure Parsers
------------------------

When you use the Bison declaration `%pure_parser' to request a pure,
reentrant parser, the global communication variables `yylval' and
`yylloc' cannot be used. (*Note Pure Decl::.) In such parsers the
two global variables are replaced by pointers passed as arguments to
`yylex'. You must declare them as shown here, and pass the
information back by storing it through those pointers.

yylex (lvalp, llocp)
YYSTYPE *lvalp;
YYLTYPE *llocp;
{
...
*lvalp = value; /* Put value onto Bison stack. */
return INT; /* Return the type of the token. */
...
}

If the grammar file does not use the `@' constructs to refer to
textual positions, then the type `YYLTYPE' will not be defined. In
this case, omit the second argument; `yylex' will be called with only
one argument.


File: bison.info, Node: Error Reporting, Next: Action Features, Prev: Lexical, Up: Interface

The Error Reporting Function `yyerror'
======================================

The Bison parser detects a "parse error" or "syntax error" whenever
it reads a token which cannot satisfy any syntax rule. A action in
the grammar can also explicitly proclaim an error, using the macro
`YYERROR' (*note Action Features::.).

The Bison parser expects to report the error by calling an error
reporting function named `yyerror', which you must supply. It is
called by `yyparse' whenever a syntax error is found, and it receives
one argument. For a parse error, the string is always `"parse error"'.

The parser can detect one other kind of error: stack overflow. This
happens when the input contains constructions that are very deeply
nested. It isn't likely you will encounter this, since the Bison
parser extends its stack automatically up to a very large limit. But
if overflow happens, `yyparse' calls `yyerror' in the usual fashion,
except that the argument string is `"parser stack overflow"'.

The following definition suffices in simple programs:

yyerror (s)
char *s;
{

fprintf (stderr, "%s\n", s);
}

After `yyerror' returns to `yyparse', the latter will attempt error
recovery if you have written suitable error recovery grammar rules
(*note Error Recovery::.). If recovery is impossible, `yyparse' will
immediately return 1.

The variable `yynerrs' contains the number of syntax errors
encountered so far. Normally this variable is global; but if you
request a pure parser (*note Pure Decl::.) then it is a local variable
which only the actions can access.


File: bison.info, Node: Action Features, Prev: Error Reporting, Up: Interface

Special Features for Use in Actions
===================================

Here is a table of Bison constructs, variables and macros that are
useful in actions.

`$$'
Acts like a variable that contains the semantic value for the
grouping made by the current rule. *Note Actions::.

`$N'
Acts like a variable that contains the semantic value for the Nth
component of the current rule. *Note Actions::.

`$$'
Like `$$' but specifies alternative TYPEALT in the union
specified by the `%union' declaration. *Note Action Types::.

`$N'
Like `$N' but specifies alternative TYPEALT in the union
specified by the `%union' declaration. *Note Action Types::.

`YYABORT;'
Return immediately from `yyparse', indicating failure. *Note
Parser Function::.

`YYACCEPT;'
Return immediately from `yyparse', indicating success. *Note
Parser Function::.

`YYBACKUP (TOKEN, VALUE);'
Unshift a token. This macro is allowed only for rules that reduce
a single value, and only when there is no look-ahead token. It
installs a look-ahead token with token type TOKEN and semantic
value VALUE; then it discards the value that was going to be
reduced by this rule.

If the macro is used when it is not valid, such as when there is
a look-ahead token already, then it reports a syntax error with a
message `cannot back up' and performs ordinary error recovery.

In either case, the rest of the action is not executed.

`YYEMPTY'
Value stored in `yychar' when there is no look-ahead token.

`YYERROR;'
Cause an immediate syntax error. This statement initiates error
recovery just as if the parser itself had detected an error;
however, it does not call `yyerror', and does not print any
message. If you want to print an error message, call `yyerror'
explicitly before the `YYERROR;' statement. *Note Error
Recovery::.

`YYRECOVERING'
This macro stands for an expression that has the value 1 when the
parser is recovering from a syntax error, and 0 the rest of the
time. *Note Error Recovery::.

`yychar'
Variable containing the current look-ahead token. (In a pure
parser, this is actually a local variable within `yyparse'.)
When there is no look-ahead token, the value `YYEMPTY' is stored
in the variable. *Note Look-Ahead::.

`yyclearin;'
Discard the current look-ahead token. This is useful primarily in
error rules. *Note Error Recovery::.

`yyerrok;'
Resume generating error messages immediately for subsequent syntax
errors. This is useful primarily in error rules. *Note Error
Recovery::.

`@N'
Acts like a structure variable containing information on the line
numbers and column numbers of the Nth component of the current
rule. The structure has four members, like this:

struct {
int first_line, last_line;
int first_column, last_column;
};

Thus, to get the starting line number of the third component, use
`@3.first_line'.

In order for the members of this structure to contain valid
information, you must make `yylex' supply this information about
each token. If you need only certain members, then `yylex' need
only fill in those members.

The use of this feature makes the parser noticeably slower.


File: bison.info, Node: Algorithm, Next: Error Recovery, Prev: Interface, Up: Top

The Bison Parser Algorithm
**************************

As Bison reads tokens, it pushes them onto a stack along with their
semantic values. The stack is called the "parser stack". Pushing a
token is traditionally called "shifting".

For example, suppose the infix calculator has read `1 + 5 *', with a
`3' to come. The stack will have four elements, one for each token
that was shifted.

But the stack does not always have an element for each token read.
When the last N tokens and groupings shifted match the components of a
grammar rule, they can be combined according to that rule. This is
called "reduction". Those tokens and groupings are replaced on the
stack by a single grouping whose symbol is the result (left hand side)
of that rule. Running the rule's action is part of the process of
reduction, because this is what computes the semantic value of the
resulting grouping.

For example, if the infix calculator's parser stack contains this:

1 + 5 * 3

and the next input token is a newline character, then the last three
elements can be reduced to 15 via the rule:

expr: expr '*' expr;

Then the stack contains just these three elements:

1 + 15

At this point, another reduction can be made, resulting in the single
value 16. Then the newline token can be shifted.

The parser tries, by shifts and reductions, to reduce the entire
input down to a single grouping whose symbol is the grammar's
start-symbol (*note Language and Grammar::.).

This kind of parser is known in the literature as a bottom-up
parser.

* Menu:

* Look-Ahead:: Parser looks one token ahead when deciding what to do.
* Shift/Reduce:: Conflicts: when either shifting or reduction is valid.
* Precedence:: Operator precedence works by resolving conflicts.
* Contextual Precedence:: When an operator's precedence depends on context.
* Parser States:: The parser is a finite-state-machine with stack.
* Reduce/Reduce:: When two rules are applicable in the same situation.
* Mystery Conflicts:: Reduce/reduce conflicts that look unjustified.
* Stack Overflow:: What happens when stack gets full. How to avoid it.


File: bison.info, Node: Look-Ahead, Next: Shift/Reduce, Prev: Algorithm, Up: Algorithm

Look-Ahead Tokens
=================

The Bison parser does *not* always reduce immediately as soon as the
last N tokens and groupings match a rule. This is because such a
simple strategy is inadequate to handle most languages. Instead, when
a reduction is possible, the parser sometimes "looks ahead" at the next
token in order to decide what to do.

When a token is read, it is not immediately shifted; first it
becomes the "look-ahead token", which is not on the stack. Now the
parser can perform one or more reductions of tokens and groupings on
the stack, while the look-ahead token remains off to the side. When
no more reductions should take place, the look-ahead token is shifted
onto the stack. This does not mean that all possible reductions have
been done; depending on the token type of the look-ahead token, some
rules may choose to delay their application.

Here is a simple case where look-ahead is needed. These three
rules define expressions which contain binary addition operators and
postfix unary factorial operators (`!'), and allow parentheses for
grouping.

expr: term '+' expr
| term
;


term: '(' expr ')'
| term '!'
| NUMBER
;

Suppose that the tokens `1 + 2' have been read and shifted; what
should be done? If the following token is `)', then the first three
tokens must be reduced to form an `expr'. This is the only valid
course, because shifting the `)' would produce a sequence of symbols
`term ')'', and no rule allows this.

If the following token is `!', then it must be shifted immediately
so that `2 !' can be reduced to make a `term'. If instead the parser
were to reduce before shifting, `1 + 2' would become an `expr'. It
would then be impossible to shift the `!' because doing so would
produce on the stack the sequence of symbols `expr '!''. No rule
allows that sequence.

The current look-ahead token is stored in the variable `yychar'.
*Note Action Features::.


File: bison.info, Node: Shift/Reduce, Next: Precedence, Prev: Look-Ahead, Up: Algorithm

Shift/Reduce Conflicts
======================

Suppose we are parsing a language which has if-then and if-then-else
statements, with a pair of rules like this:

if_stmt:
IF expr THEN stmt
| IF expr THEN stmt ELSE stmt
;

(Here we assume that `IF', `THEN' and `ELSE' are terminal symbols for
specific keyword tokens.)

When the `ELSE' token is read and becomes the look-ahead token, the
contents of the stack (assuming the input is valid) are just right for
reduction by the first rule. But it is also legitimate to shift the
`ELSE', because that would lead to eventual reduction by the second
rule.

This situation, where either a shift or a reduction would be valid,
is called a "shift/reduce conflict". Bison is designed to resolve
these conflicts by choosing to shift, unless otherwise directed by
operator precedence declarations. To see the reason for this, let's
contrast it with the other alternative.

Since the parser prefers to shift the `ELSE', the result is to
attach the else-clause to the innermost if-statement, making these two
inputs equivalent:

if x then if y then win (); else lose;

if x then do; if y then win (); else lose; end;

But if the parser chose to reduce when possible rather than shift,
the result would be to attach the else-clause to the outermost
if-statement, making these two inputs equivalent:

if x then if y then win (); else lose;

if x then do; if y then win (); end; else lose;

The conflict exists because the grammar as written is ambiguous:
either parsing of the simple nested if-statement is legitimate. The
established convention is that these ambiguities are resolved by
attaching the else-clause to the innermost if-statement; this is what
Bison accomplishes by choosing to shift rather than reduce. (It would
ideally be cleaner to write an unambiguous grammar, but that is very
hard to do in this case.) This particular ambiguity was first
encountered in the specifications of Algol 60 and is called the
"dangling `else'" ambiguity.

To avoid warnings from Bison about predictable, legitimate
shift/reduce conflicts, use the `%expect N' declaration. There will
be no warning as long as the number of shift/reduce conflicts is
exactly N. *Note Expect Decl::.


File: bison.info, Node: Precedence, Next: Contextual Precedence, Prev: Shift/Reduce, Up: Algorithm

Operator Precedence
===================

Another situation where shift/reduce conflicts appear is in
arithmetic expressions. Here shifting is not always the preferred
resolution; the Bison declarations for operator precedence allow you
to specify when to shift and when to reduce.

* Menu:

* Why Precedence:: An example showing why precedence is needed.
* Using Precedence:: How to specify precedence in Bison grammars.
* Precedence Examples:: How these features are used in the previous example.
* How Precedence:: How they work.


File: bison.info, Node: Why Precedence, Next: Using Precedence, Prev: Precedence, Up: Precedence

When Precedence is Needed
-------------------------

Consider the following ambiguous grammar fragment (ambiguous
because the input `1 - 2 * 3' can be parsed in two different ways):

expr: expr '-' expr
| expr '*' expr
| expr '<' expr
| '(' expr ')'
...
;

Suppose the parser has seen the tokens `1', `-' and `2'; should it
reduce them via the rule for the addition operator? It depends on the
next token. Of course, if the next token is `)', we must reduce;
shifting is invalid because no single rule can reduce the token
sequence `- 2 )' or anything starting with that. But if the next
token is `*' or `<', we have a choice: either shifting or reduction
would allow the parse to complete, but with different results.

To decide which one Bison should do, we must consider the results.
If the next operator token OP is shifted, then it must be reduced
first in order to permit another opportunity to reduce the sum. The
result is (in effect) `1 - (2 OP 3)'. On the other hand, if the
subtraction is reduced before shifting OP, the result is
`(1 - 2) OP 3'. Clearly, then, the choice of shift or reduce should
depend on the relative precedence of the operators `-' and OP: `*'
should be shifted first, but not `<'.

What about input such as `1 - 2 - 5'; should this be `(1 - 2) - 5'
or should it be `1 - (2 - 5)'? For most operators we prefer the
former, which is called "left association". The latter alternative,
"right association", is desirable for assignment operators. The
choice of left or right association is a matter of whether the parser
chooses to shift or reduce when the stack contains `1 - 2' and the
look-ahead token is `-': shifting makes right-associativity.


File: bison.info, Node: Using Precedence, Next: Precedence Examples, Prev: Why Precedence, Up: Precedence

Specifying Operator Precedence
------------------------------

Bison allows you to specify these choices with the operator
precedence declarations `%left' and `%right'. Each such declaration
contains a list of tokens, which are operators whose precedence and
associativity is being declared. The `%left' declaration makes all
those operators left-associative and the `%right' declaration makes
them right-associative. A third alternative is `%nonassoc', which
declares that it is a syntax error to find the same operator twice "in
a row".

The relative precedence of different operators is controlled by the
order in which they are declared. The first `%left' or `%right'
declaration in the file declares the operators whose precedence is
lowest, the next such declaration declares the operators whose
precedence is a little higher, and so on.


File: bison.info, Node: Precedence Examples, Next: How Precedence, Prev: Using Precedence, Up: Precedence

Precedence Examples
-------------------

In our example, we would want the following declarations:

%left '<'
%left '-'
%left '*'

In a more complete example, which supports other operators as well,
we would declare them in groups of equal precedence. For example,
`'+'' is declared with `'-'':

%left '<' '>' '=' NE LE GE
%left '+' '-'
%left '*' '/'

(Here `NE' and so on stand for the operators for "not equal" and so
on. We assume that these tokens are more than one character long and
therefore are represented by names, not character literals.)


File: bison.info, Node: How Precedence, Prev: Precedence Examples, Up: Precedence

How Precedence Works
--------------------

The first effect of the precedence declarations is to assign
precedence levels to the terminal symbols declared. The second effect
is to assign precedence levels to certain rules: each rule gets its
precedence from the last terminal symbol mentioned in the components.
(You can also specify explicitly the precedence of a rule. *Note
Contextual Precedence::.)

Finally, the resolution of conflicts works by comparing the
precedence of the rule being considered with that of the look-ahead
token. If the token's precedence is higher, the choice is to shift.
If the rule's precedence is higher, the choice is to reduce. If they
have equal precedence, the choice is made based on the associativity
of that precedence level. The verbose output file made by `-v' (*note
Invocation::.) says how each conflict was resolved.

Not all rules and not all tokens have precedence. If either the
rule or the look-ahead token has no precedence, then the default is to
shift.


File: bison.info, Node: Contextual Precedence, Next: Parser States, Prev: Precedence, Up: Algorithm

Context-Dependent Precedence
============================

Often the precedence of an operator depends on the context. This
sounds outlandish at first, but it is really very common. For
example, a minus sign typically has a very high precedence as a unary
operator, and a somewhat lower precedence (lower than multiplication)
as a binary operator.

The Bison precedence declarations, `%left', `%right' and
`%nonassoc', can only be used once for a given token; so a token has
only one precedence declared in this way. For context-dependent
precedence, you need to use an additional mechanism: the `%prec'
modifier for rules.

The `%prec' modifier declares the precedence of a particular rule by
specifying a terminal symbol whose precedence should be used for that
rule. It's not necessary for that symbol to appear otherwise in the
rule. The modifier's syntax is:

%prec TERMINAL-SYMBOL

and it is written after the components of the rule. Its effect is to
assign the rule the precedence of TERMINAL-SYMBOL, overriding the
precedence that would be deduced for it in the ordinary way. The
altered rule precedence then affects how conflicts involving that rule
are resolved (*note Precedence::.).

Here is how `%prec' solves the problem of unary minus. First,
declare a precedence for a fictitious terminal symbol named `UMINUS'.
There are no tokens of this type, but the symbol serves to stand for
its precedence:

...
%left '+' '-'
%left '*'
%left UMINUS

Now the precedence of `UMINUS' can be used in specific rules:

exp: ...
| exp '-' exp
...
| '-' exp %prec UMINUS


File: bison.info, Node: Parser States, Next: Reduce/Reduce, Prev: Contextual Precedence, Up: Algorithm

Parser States
=============

The function `yyparse' is implemented using a finite-state machine.
The values pushed on the parser stack are not simply token type codes;
they represent the entire sequence of terminal and nonterminal symbols
at or near the top of the stack. The current state collects all the
information about previous input which is relevant to deciding what to
do next.

Each time a look-ahead token is read, the current parser state
together with the type of look-ahead token are looked up in a table.
This table entry can say, "Shift the look-ahead token." In this case,
it also specifies the new parser state, which is pushed onto the top
of the parser stack. Or it can say, "Reduce using rule number N."
This means that a certain of tokens or groupings are taken off the top
of the stack, and replaced by one grouping. In other words, that
number of states are popped from the stack, and one new state is
pushed.

There is one other alternative: the table can say that the
look-ahead token is erroneous in the current state. This causes error
processing to begin (*note Error Recovery::.).


File: bison.info, Node: Reduce/Reduce, Next: Mystery Conflicts, Prev: Parser States, Up: Algorithm

Reduce/Reduce Conflicts
=======================

A reduce/reduce conflict occurs if there are two or more rules that
apply to the same sequence of input. This usually indicates a serious
error in the grammar.

For example, here is an erroneous attempt to define a sequence of
zero or more `word' groupings.

sequence: /* empty */
{ printf ("empty sequence\n"); }
| word
{ printf ("single word %s\n", $1); }
| sequence word
{ printf ("added word %s\n", $2); }
;

The error is an ambiguity: there is more than one way to parse a single
`word' into a `sequence'. It could be reduced directly via the second
rule. Alternatively, nothing-at-all could be reduced into a
`sequence' via the first rule, and this could be combined with the
`word' using the third rule.

You might think that this is a distinction without a difference,
because it does not change whether any particular input is valid or
not. But it does affect which actions are run. One parsing order
runs the second rule's action; the other runs the first rule's action
and the third rule's action. In this example, the output of the
program changes.

Bison resolves a reduce/reduce conflict by choosing to use the rule
that appears first in the grammar, but it is very risky to rely on
this. Every reduce/reduce conflict must be studied and usually
eliminated. Here is the proper way to define `sequence':

sequence: /* empty */
{ printf ("empty sequence\n"); }
| sequence word
{ printf ("added word %s\n", $2); }
;

Here is another common error that yields a reduce/reduce conflict:

sequence: /* empty */
| sequence words
| sequence redirects
;

words: /* empty */
| words word
;

redirects:/* empty */
| redirects redirect
;

The intention here is to define a sequence which can contain either
`word' or `redirect' groupings. The individual definitions of
`sequence', `words' and `redirects' are error-free, but the three
together make a subtle ambiguity: even an empty input can be parsed in
infinitely many ways!

Consider: nothing-at-all could be a `words'. Or it could be two
`words' in a row, or three, or any number. It could equally well be a
`redirects', or two, or any number. Or it could be a `words' followed
by three `redirects' and another `words'. And so on.

Here are two ways to correct these rules. First, to make it a
single level of sequence:

sequence: /* empty */
| sequence word
| sequence redirect
;

Second, to prevent either a `words' or a `redirects' from being
empty:

sequence: /* empty */
| sequence words
| sequence redirects
;

words: word
| words word
;

redirects:redirect
| redirects redirect
;


File: bison.info, Node: Mystery Conflicts, Next: Stack Overflow, Prev: Reduce/Reduce, Up: Algorithm

Mysterious Reduce/Reduce Conflicts
==================================

Sometimes reduce/reduce conflicts can occur that don't look
warranted. Here is an example:

%token ID

%%
def: param_spec return_spec ','
;
param_spec:
type
| name_list ':' type
;
return_spec:
type
| name ':' type
;
type: ID
;
name: ID
;
name_list:
name
| name ',' name_list
;

It would seem that this grammar can be parsed with only a single
token of look-ahead: when a `param_spec' is being read, an `ID' is a
`name' if a comma or colon follows, or a `type' if another `ID'
follows. In other words, this grammar is LR(1).

However, Bison, like most parser generators, cannot actually handle
all LR(1) grammars. In this grammar, two contexts, that after an `ID'
at the beginning of a `param_spec' and likewise at the beginning of a
`return_spec', are similar enough that Bison assumes they are the
same. They appear similar because the same set of rules would be
active--the rule for reducing to a `name' and that for reducing to a
`type'. Bison is unable to determine at that stage of processing that
the rules would require different look-ahead tokens in the two
contexts, so it makes a single parser state for them both. Combining
the two contexts causes a conflict later. In parser terminology, this
occurrence means that the grammar is not LALR(1).

In general, it is better to fix deficiencies than to document them.
But this particular deficiency is intrinsically hard to fix; parser
generators that can handle LR(1) grammars are hard to write and tend to
produce parsers that are very large. In practice, Bison is more useful
as it is now.

When the problem arises, you can often fix it by identifying the two
parser states that are being confused, and adding something to make
them look distinct. In the above example, adding one rule to
`return_spec' as follows makes the problem go away:

%token BOGUS
...
%%
...
return_spec:
type
| name ':' type
/* This rule is never used. */
| ID BOGUS
;

This corrects the problem because it introduces the possibility of
an additional active rule in the context after the `ID' at the
beginning of `return_spec'. This rule is not active in the
corresponding context in a `param_spec', so the two contexts receive
distinct parser states. As long as the token `BOGUS' is never
generated by `yylex', the added rule cannot alter the way actual input
is parsed.

In this particular example, there is another way to solve the
problem: rewrite the rule for `return_spec' to use `ID' directly
instead of via `name'. This also causes the two confusing contexts to
have different sets of active rules, because the one for `return_spec'
activates the altered rule for `return_spec' rather than the one for
`name'.

param_spec:
type
| name_list ':' type
;
return_spec:
type
| ID ':' type
;


File: bison.info, Node: Stack Overflow, Prev: Mystery Conflicts, Up: Algorithm

Stack Overflow, and How to Avoid It
===================================

The Bison parser stack can overflow if too many tokens are shifted
and not reduced. When this happens, the parser function `yyparse'
returns a nonzero value, pausing only to call `yyerror' to report the
overflow.

By defining the macro `YYMAXDEPTH', you can control how deep the
parser stack can become before a stack overflow occurs. Define the
macro with a value that is an integer. This value is the maximum
number of tokens that can be shifted (and not reduced) before overflow.
It must be a constant expression whose value is known at compile time.

The stack space allowed is not necessarily allocated. If you
specify a large value for `YYMAXDEPTH', the parser actually allocates
a small stack at first, and then makes it bigger by stages as needed.
This increasing allocation happens automatically and silently.
Therefore, you do not need to make `YYMAXDEPTH' painfully small merely
to save space for ordinary inputs that do not need much stack.

The default value of `YYMAXDEPTH', if you do not define it, is
10000.

You can control how much stack is allocated initially by defining
the macro `YYINITDEPTH'. This value too must be a compile-time
constant integer. The default is 200.


File: bison.info, Node: Error Recovery, Next: Context Dependency, Prev: Algorithm, Up: Top

Error Recovery
**************

It is not usually acceptable to have a program terminate on a parse
error. For example, a compiler should recover sufficiently to parse
the rest of the input file and check it for errors; a calculator
should accept another expression.

In a simple interactive command parser where each input is one
line, it may be sufficient to allow `yyparse' to return 1 on error and
have the caller ignore the rest of the input line when that happens
(and then call `yyparse' again). But this is inadequate for a
compiler, because it forgets all the syntactic context leading up to
the error. A syntax error deep within a function in the compiler
input should not cause the compiler to treat the following line like
the beginning of a source file.

You can define how to recover from a syntax error by writing rules
to recognize the special token `error'. This is a terminal symbol that
is always defined (you need not declare it) and reserved for error
handling. The Bison parser generates an `error' token whenever a
syntax error happens; if you have provided a rule to recognize this
token in the current context, the parse can continue.

For example:

stmnts: /* empty string */
| stmnts '\n'
| stmnts exp '\n'
| stmnts error '\n'

The fourth rule in this example says that an error followed by a
newline makes a valid addition to any `stmnts'.

What happens if a syntax error occurs in the middle of an `exp'?
The error recovery rule, interpreted strictly, applies to the precise
sequence of a `stmnts', an `error' and a newline. If an error occurs
in the middle of an `exp', there will probably be some additional
tokens and subexpressions on the stack after the last `stmnts', and
there will be tokens to read before the next newline. So the rule is
not applicable in the ordinary way.

But Bison can force the situation to fit the rule, by discarding
part of the semantic context and part of the input. First it discards
states and objects from the stack until it gets back to a state in
which the `error' token is acceptable. (This means that the
subexpressions already parsed are discarded, back to the last complete
`stmnts'.) At this point the `error' token can be shifted. Then, if
the old look-ahead token is not acceptable to be shifted next, the
parser reads tokens and discards them until it finds a token which is
acceptable. In this example, Bison reads and discards input until the
next newline so that the fourth rule can apply.

The choice of error rules in the grammar is a choice of strategies
for error recovery. A simple and useful strategy is simply to skip
the rest of the current input line or current statement if an error is
detected:

stmnt: error ';' /* on error, skip until ';' is read */

It is also useful to recover to the matching close-delimiter of an
opening-delimiter that has already been parsed. Otherwise the
close-delimiter will probably appear to be unmatched, and generate
another, spurious error message:

primary: '(' expr ')'
| '(' error ')'
...
;

Error recovery strategies are necessarily guesses. When they guess
wrong, one syntax error often leads to another. In the above example,
the error recovery rule guesses that an error is due to bad input
within one `stmnt'. Suppose that instead a spurious semicolon is
inserted in the middle of a valid `stmnt'. After the error recovery
rule recovers from the first error, another syntax error will be found
straightaway, since the text following the spurious semicolon is also
an invalid `stmnt'.

To prevent an outpouring of error messages, the parser will output
no error message for another syntax error that happens shortly after
the first; only after three consecutive input tokens have been
successfully shifted will error messages resume.

Note that rules which accept the `error' token may have actions,
just as any other rules can.

You can make error messages resume immediately by using the macro
`yyerrok' in an action. If you do this in the error rule's action, no
error messages will be suppressed. This macro requires no arguments;
`yyerrok;' is a valid C statement.

The previous look-ahead token is reanalyzed immediately after an
error. If this is unacceptable, then the macro `yyclearin' may be
used to clear this token. Write the statement `yyclearin;' in the
error rule's action.

For example, suppose that on a parse error, an error handling
routine is called that advances the input stream to some point where
parsing should once again commence. The next symbol returned by the
lexical scanner is probably correct. The previous look-ahead token
ought to be discarded with `yyclearin;'.

The macro `YYRECOVERING' stands for an expression that has the
value 1 when the parser is recovering from a syntax error, and 0 the
rest of the time. A value of 1 indicates that error messages are
currently suppressed for new syntax errors.


File: bison.info, Node: Context Dependency, Next: Debugging, Prev: Error Recovery, Up: Top

Handling Context Dependencies
*****************************

The Bison paradigm is to parse tokens first, then group them into
larger syntactic units. In many languages, the meaning of a token is
affected by its context. Although this violates the Bison paradigm,
certain techniques (known as "kludges") may enable you to write Bison
parsers for such languages.

* Menu:

* Semantic Tokens:: Token parsing can depend on the semantic context.
* Lexical Tie-ins:: Token parsing can depend on the syntactic context.
* Tie-in Recovery:: Lexical tie-ins have implications for how
error recovery rules must be written.

(Actually, "kludge" means any technique that gets its job done but
is neither clean nor robust.)

./info/bison.info-4 644 0 0 110206 5213513117 12332 0ustar rootrootInfo file bison.info, produced by Makeinfo, -*- Text -*- from input
file bison.texinfo.

This file documents the Bison parser generator.

Copyright (C) 1988, 1989, 1990 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License" and
"Conditions for Using Bison" are included exactly as in the original,
and provided that the entire resulting derived work is distributed
under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License", "Conditions for Using Bison" and this permission notice may
be included in translations approved by the Free Software Foundation
instead of in the original English.


File: bison.info, Node: Semantic Tokens, Next: Lexical Tie-ins, Prev: Context Dependency, Up: Context Dependency

Semantic Info in Token Types
============================

The C language has a context dependency: the way an identifier is
used depends on what its current meaning is. For example, consider
this:

foo (x);

This looks like a function call statement, but if `foo' is a typedef
name, then this is actually a declaration of `x'. How can a Bison
parser for C decide how to parse this input?

The method used in GNU C is to have two different token types,
`IDENTIFIER' and `TYPENAME'. When `yylex' finds an identifier, it
looks up the current declaration of the identifier in order to decide
which token type to return: `TYPENAME' if the identifier is declared
as a typedef, `IDENTIFIER' otherwise.

The grammar rules can then express the context dependency by the
choice of token type to recognize. `IDENTIFIER' is accepted as an
expression, but `TYPENAME' is not. `TYPENAME' can start a
declaration, but `IDENTIFIER' cannot. In contexts where the meaning
of the identifier is *not* significant, such as in declarations that
can shadow a typedef name, either `TYPENAME' or `IDENTIFIER' is
accepted--there is one rule for each of the two token types.

This technique is simple to use if the decision of which kinds of
identifiers to allow is made at a place close to where the identifier
is parsed. But in C this is not always so: C allows a declaration to
redeclare a typedef name provided an explicit type has been specified
earlier:

typedef int foo, bar, lose;
static foo (bar); /* redeclare `bar' as static variable */
static int foo (lose); /* redeclare `foo' as function */

Unfortunately, the name being declared is separated from the
declaration construct itself by a complicated syntactic structure--the
"declarator".

As a result, the part of Bison parser for C needs to be duplicated,
with all the nonterminal names changed: once for parsing a declaration
in which a typedef name can be redefined, and once for parsing a
declaration in which that can't be done. Here is a part of the
duplication, with actions omitted for brevity:

initdcl:
declarator maybeasm '='
init
| declarator maybeasm
;

notype_initdcl:
notype_declarator maybeasm '='
init
| notype_declarator maybeasm
;

Here `initdcl' can redeclare a typedef name, but `notype_initdcl'
cannot. The distinction between `declarator' and `notype_declarator'
is the same sort of thing.

There is some similarity between this technique and a lexical tie-in
(described next), in that information which alters the lexical
analysis is changed during parsing by other parts of the program. The
difference is here the information is global, and is used for other
purposes in the program. A true lexical tie-in has a special-purpose
flag controlled by the syntactic context.


File: bison.info, Node: Lexical Tie-ins, Next: Tie-in Recovery, Prev: Semantic Tokens, Up: Context Dependency

Lexical Tie-ins
===============

One way to handle context-dependency is the "lexical tie-in": a flag
which is set by Bison actions, whose purpose is to alter the way
tokens are parsed.

For example, suppose we have a language vaguely like C, but with a
special construct `hex (HEX-EXPR)'. After the keyword `hex' comes an
expression in parentheses in which all integers are hexadecimal. In
particular, the token `a1b' must be treated as an integer rather than
as an identifier if it appears in that context. Here is how you can
do it:

%{
int hexflag;
%}
%%
...
expr: IDENTIFIER
| constant
| HEX '('
{ hexflag = 1; }
expr ')'
{ hexflag = 0;
$$ = $4; }
| expr '+' expr
{ $$ = make_sum ($1, $3); }
...
;

constant:
INTEGER
| STRING
;

Here we assume that `yylex' looks at the value of `hexflag'; when it
is nonzero, all integers are parsed in hexadecimal, and tokens starting
with letters are parsed as integers if possible.

The declaration of `hexflag' shown in the C declarations section of
the parser file is needed to make it accessible to the actions (*note
C Declarations::.). You must also write the code in `yylex' to obey
the flag.


File: bison.info, Node: Tie-in Recovery, Prev: Lexical Tie-ins, Up: Context Dependency

Lexical Tie-ins and Error Recovery
==================================

Lexical tie-ins make strict demands on any error recovery rules you
have. *Note Error Recovery::.

The reason for this is that the purpose of an error recovery rule
is to abort the parsing of one construct and resume in some larger
construct. For example, in C-like languages, a typical error recovery
rule is to skip tokens until the next semicolon, and then start a new
statement, like this:

stmt: expr ';'
| IF '(' expr ')' stmt { ... }
...
error ';'
{ hexflag = 0; }
;

If there is a syntax error in the middle of a `hex (EXPR)'
construct, this error rule will apply, and then the action for the
completed `hex (EXPR)' will never run. So `hexflag' would remain set
for the entire rest of the input, or until the next `hex' keyword,
causing identifiers to be misinterpreted as integers.

To avoid this problem the error recovery rule itself clears
`hexflag'.

There may also be an error recovery rule that works within
expressions. For example, there could be a rule which applies within
parentheses and skips to the close-parenthesis:

expr: ...
| '(' expr ')'
{ $$ = $2; }
| '(' error ')'
...

If this rule acts within the `hex' construct, it is not going to
abort that construct (since it applies to an inner level of
parentheses within the construct). Therefore, it should not clear the
flag: the rest of the `hex' construct should be parsed with the flag
still in effect.

What if there is an error recovery rule which might abort out of the
`hex' construct or might not, depending on circumstances? There is no
way you can write the action to determine whether a `hex' construct is
being aborted or not. So if you are using a lexical tie-in, you had
better make sure your error recovery rules are not of this kind. Each
rule must be such that you can be sure that it always will, or always
won't, have to clear the flag.


File: bison.info, Node: Debugging, Next: Invocation, Prev: Context Dependency, Up: Top

Debugging Your Parser
*********************

If a Bison grammar compiles properly but doesn't do what you want
when it runs, the `yydebug' parser-trace feature can help you figure
out why.

To enable compilation of trace facilities, you must define the macro
`YYDEBUG' when you compile the parser. You could use `-DYYDEBUG=1' as
a compiler option or you could put `#define YYDEBUG 1' in the C
declarations section of the grammar file (*note C Declarations::.).
Alternatively, use the `-t' option when you run Bison (*note
Invocation::.). We always define `YYDEBUG' so that debugging is
always possible.

The trace facility uses `stderr', so you must add
`#include ' to the C declarations section unless it is
already there.

Once you have compiled the program with trace facilities, the way to
request a trace is to store a nonzero value in the variable `yydebug'.
You can do this by making the C code do it (in `main', perhaps), or
you can alter the value with a C debugger.

Each step taken by the parser when `yydebug' is nonzero produces a
line or two of trace information, written on `stderr'. The trace
messages tell you these things:

* Each time the parser calls `yylex', what kind of token was read.

* Each time a token is shifted, the depth and complete contents of
the state stack (*note Parser States::.).

* Each time a rule is reduced, which rule it is, and the complete
contents of the state stack afterward.

To make sense of this information, it helps to refer to the listing
file produced by the Bison `-v' option (*note Invocation::.). This
file shows the meaning of each state in terms of positions in various
rules, and also what each state will do with each possible input
token. As you read the successive trace messages, you can see that
the parser is functioning according to its specification in the
listing file. Eventually you will arrive at the place where something
undesirable happens, and you will see which parts of the grammar are
to blame.

The parser file is a C program and you can use C debuggers on it,
but it's not easy to interpret what it is doing. The parser function
is a finite-state machine interpreter, and aside from the actions it
executes the same code over and over. Only the values of variables
show where in the grammar it is working.

The debugging information normally gives the token type of each
token read, but not its semantic value. You can optionally define a
macro named `YYPRINT' to provide a way to print the value. If you
define `YYPRINT', it should take three arguments. The parser will
pass a standard I/O stream, the numeric code for the token type, and
the token value (from `yylval').

Here is an example of `YYPRINT' suitable for the multi-function
calculator (*note Mfcalc Decl::.):

#define YYPRINT(file, type, value) yyprint (file, type, value)

static void
yyprint (file, type, value)
FILE *file;
int type;
YYSTYPE value;
{
if (type == VAR)
fprintf (file, " %s", value.tptr->name);
else if (type == NUM)
fprintf (file, " %d", value.val);
}


File: bison.info, Node: Invocation, Next: Table of Symbols, Prev: Debugging, Up: Top

Invoking Bison
**************

The usual way to invoke Bison is as follows:

bison INFILE

Here INFILE is the grammar file name, which usually ends in `.y'.
The parser file's name is made by replacing the `.y' with `.tab.c'.
Thus, the `bison foo.y' filename yields `foo.tab.c', and the `bison
hack/foo.y' filename yields `hack/foo.tab.c'.

Bison supports both traditional single-letter options and mnemonic
long option names. Long option names are indicated with `--' instead
of `-'. Abbreviations for option names are allowed as long as they
are unique. When a long option takes an argument, like
`--file-prefix', connect the option name and the argument with `='.

Here is a list of options that can be used with Bison, alphabetized
by short option. It is followed by a cross key alphabetized by long
option.

`-b FILE-PREFIX'
`--file-prefix=PREFIX'
Specify a prefix to use for all Bison output file names. The
names are chosen as if the input file were named `PREFIX.c'.

`-d'
`--defines'
Write an extra output file containing macro definitions for the
token type names defined in the grammar and the semantic value
type `YYSTYPE', as well as a few `extern' variable declarations.

If the parser output file is named `NAME.c' then this file is
named `NAME.h'.

This output file is essential if you wish to put the definition of
`yylex' in a separate source file, because `yylex' needs to be
able to refer to token type codes and the variable `yylval'.
*Note Token Values::.

`-l'
`--no-lines'
Don't put any `#line' preprocessor commands in the parser file.
Ordinarily 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.

`-o OUTFILE'
`--output-file=OUTFILE'
Specify the name OUTFILE for the parser file.

The other output files' names are constructed from OUTFILE as
described under the `-v' and `-d' switches.

`-p PREFIX'
`--name-prefix=PREFIX'
Rename the external symbols used in the parser so that they start
with PREFIX instead of `yy'. The precise list of symbols renamed
is `yyparse', `yylex', `yyerror', `yylval', `yychar' and
`yydebug'.

For example, if you use `-p c', the names become `cparse',
`clex', and so on.

*Note Multiple Parsers::.

`-t'
`--debug'
Output a definition of the macro `YYDEBUG' into the parser file,
so that the debugging facilities are compiled. *Note Debugging::.

`-v'
`--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.

This file also describes all the conflicts, both those resolved by
operator precedence and the unresolved ones.

The file's name is made by removing `.tab.c' or `.c' from the
parser output file name, and adding `.output' instead.

Therefore, if the input file is `foo.y', then the parser file is
called `foo.tab.c' by default. As a consequence, the verbose
output file is called `foo.output'.

`-V'
`--version'
Print the version number of Bison.

`-y'
`--yacc'
`--fixed-output-files'
Equivalent to `-o y.tab.c'; the parser output file is called
`y.tab.c', and the other outputs are called `y.output' and
`y.tab.h'. The purpose of this switch is to imitate Yacc's output
file name conventions. Thus, the following shell script can
substitute for Yacc:

bison -y $*

Options' Cross Key
==================

Here is a list of options, alphabetized by long option, to help you
find the corresponding short option.

--debug -t
--defines -d
--file-prefix=PREFIX -b FILE-PREFIX
--fixed-output-files --yacc -y
--name-prefix -p
--no-lines -l
--output-file=OUTFILE -o OUTFILE
--verbose -v
--version -V


File: bison.info, Node: Table of Symbols, Next: Glossary, Prev: Invocation, Up: Top

Bison Symbols
*************

`error'
A token name reserved for error recovery. This token may be used
in grammar rules so as to allow the Bison parser to recognize an
error in the grammar without halting the process. In effect, a
sentence containing an error may be recognized as valid. On a
parse error, the token `error' becomes the current look-ahead
token. Actions corresponding to `error' are then executed, and
the look-ahead token is reset to the token that originally caused
the violation. *Note Error Recovery::.

`YYABORT'
Macro to pretend that an unrecoverable syntax error has occurred,
by making `yyparse' return 1 immediately. The error reporting
function `yyerror' is not called. *Note Parser Function::.

`YYACCEPT'
Macro to pretend that a complete utterance of the language has
been read, by making `yyparse' return 0 immediately. *Note
Parser Function::.

`YYBACKUP'
Macro to discard a value from the parser stack and fake a
look-ahead token. *Note Action Features::.

`YYERROR'
Macro to pretend that a syntax error has just been detected: call
`yyerror' and then perform normal error recovery if possible
(*note Error Recovery::.), or (if recovery is impossible) make
`yyparse' return 1. *Note Error Recovery::.

`YYINITDEPTH'
Macro for specifying the initial size of the parser stack. *Note
Stack Overflow::.

`YYLTYPE'
Macro for the data type of `yylloc'; a structure with four
members. *Note Token Positions::.

`YYMAXDEPTH'
Macro for specifying the maximum size of the parser stack. *Note
Stack Overflow::.

`YYRECOVERING'
Macro whose value indicates whether the parser is recovering from
a syntax error. *Note Action Features::.

`YYSTYPE'
Macro for the data type of semantic values; `int' by default.
*Note Value Type::.

`yychar'
External integer variable that contains the integer value of the
current look-ahead token. (In a pure parser, it is a local
variable within `yyparse'.) Error-recovery rule actions may
examine this variable. *Note Action Features::.

`yyclearin'
Macro used in error-recovery rule actions. It clears the previous
look-ahead token. *Note Error Recovery::.

`yydebug'
External integer variable set to zero by default. If `yydebug'
is given a nonzero value, the parser will output information on
input symbols and parser action. *Note Debugging::.

`yyerrok'
Macro to cause parser to recover immediately to its normal mode
after a parse error. *Note Error Recovery::.

`yyerror'
User-supplied function to be called by `yyparse' on error. The
function receives one argument, a pointer to a character string
containing an error message. *Note Error Reporting::.

`yylex'
User-supplied lexical analyzer function, called with no arguments
to get the next token. *Note Lexical::.

`yylval'
External variable in which `yylex' should place the semantic
value associated with a token. (In a pure parser, it is a local
variable within `yyparse', and its address is passed to `yylex'.)
*Note Token Values::.

`yylloc'
External variable in which `yylex' should place the line and
column numbers associated with a token. (In a pure parser, it is
a local variable within `yyparse', and its address is passed to
`yylex'.) You can ignore this variable if you don't use the `@'
feature in the grammar actions. *Note Token Positions::.

`yynerrs'
Global variable which Bison increments each time there is a parse
error. (In a pure parser, it is a local variable within
`yyparse'.) *Note Error Reporting::.

`yyparse'
The parser function produced by Bison; call this function to start
parsing. *Note Parser Function::.

`%left'
Bison declaration to assign left associativity to token(s).
*Note Precedence Decl::.

`%nonassoc'
Bison declaration to assign nonassociativity to token(s). *Note
Precedence Decl::.

`%prec'
Bison declaration to assign a precedence to a specific rule.
*Note Contextual Precedence::.

`%pure_parser'
Bison declaration to request a pure (reentrant) parser. *Note
Pure Decl::.

`%right'
Bison declaration to assign right associativity to token(s).
*Note Precedence Decl::.

`%start'
Bison declaration to specify the start symbol. *Note Start
Decl::.

`%token'
Bison declaration to declare token(s) without specifying
precedence. *Note Token Decl::.

`%type'
Bison declaration to declare nonterminals. *Note Type Decl::.

`%union'
Bison declaration to specify several possible data types for
semantic values. *Note Union Decl::.

These are the punctuation and delimiters used in Bison input:

`%%'
Delimiter used to separate the grammar rule section from the
Bison declarations section or the additional C code section.
*Note Grammar Layout::.

`%{ %}'
All code listed between `%{' and `%}' is copied directly to the
output file uninterpreted. Such code forms the "C declarations"
section of the input file. *Note Grammar Outline::.

`/*...*/'
Comment delimiters, as in C.

`:'
Separates a rule's result from its components. *Note Rules::.

`;'
Terminates a rule. *Note Rules::.

`|'
Separates alternate rules for the same result nonterminal. *Note
Rules::.


File: bison.info, Node: Glossary, Next: Index, Prev: Table of Symbols, Up: top

Glossary
********

Backus-Naur Form (BNF)
Formal method of specifying context-free grammars. BNF was first
used in the `ALGOL-60' report, 1963. *Note Language and
Grammar::.

Context-free grammars
Grammars specified as rules that can be applied regardless of
context. Thus, if there is a rule which says that an integer can
be used as an expression, integers are allowed *anywhere* an
expression is permitted. *Note Language and Grammar::.

Dynamic allocation
Allocation of memory that occurs during execution, rather than at
compile time or on entry to a function.

Empty string
Analogous to the empty set in set theory, the empty string is a
character string of length zero.

Finite-state stack machine
A "machine" that has discrete states in which it is said to exist
at each instant in time. As input to the machine is processed,
the machine moves from state to state as specified by the logic
of the machine. In the case of the parser, the input is the
language being parsed, and the states correspond to various
stages in the grammar rules. *Note Algorithm::.

Grouping
A language construct that is (in general) grammatically divisible;
for example, `expression' or `declaration' in C. *Note Language
and Grammar::.

Infix operator
An arithmetic operator that is placed between the operands on
which it performs some operation.

Input stream
A continuous flow of data between devices or programs.

Language construct
One of the typical usage schemas of the language. For example,
one of the constructs of the C language is the `if' statement.
*Note Language and Grammar::.

Left associativity
Operators having left associativity are analyzed from left to
right: `a+b+c' first computes `a+b' and then combines with `c'.
*Note Precedence::.

Left recursion
A rule whose result symbol is also its first component symbol;
for example, `expseq1 : expseq1 ',' exp;'. *Note Recursion::.

Left-to-right parsing
Parsing a sentence of a language by analyzing it token by token
from left to right. *Note Algorithm::.

Lexical analyzer (scanner)
A function that reads an input stream and returns tokens one by
one. *Note Lexical::.

Lexical tie-in
A flag, set by actions in the grammar rules, which alters the way
tokens are parsed. *Note Lexical Tie-ins::.

Look-ahead token
A token already read but not yet shifted. *Note Look-Ahead::.

LALR(1)
The class of context-free grammars that Bison (like most other
parser generators) can handle; a subset of LR(1). *Note
Mysterious Reduce/Reduce Conflicts: Mystery Conflicts.

LR(1)
The class of context-free grammars in which at most one token of
look-ahead is needed to disambiguate the parsing of any piece of
input.

Nonterminal symbol
A grammar symbol standing for a grammatical construct that can be
expressed through rules in terms of smaller constructs; in other
words, a construct that is not a token. *Note Symbols::.

Parse error
An error encountered during parsing of an input stream due to
invalid syntax. *Note Error Recovery::.

Parser
A function that recognizes valid sentences of a language by
analyzing the syntax structure of a set of tokens passed to it
from a lexical analyzer.

Postfix operator
An arithmetic operator that is placed after the operands upon
which it performs some operation.

Reduction
Replacing a string of nonterminals and/or terminals with a single
nonterminal, according to a grammar rule. *Note Algorithm::.

Reentrant
A reentrant subprogram is a subprogram which can be in invoked any
number of times in parallel, without interference between the
various invocations. *Note Pure Decl::.

Reverse polish notation
A language in which all operators are postfix operators.

Right recursion
A rule whose result symbol is also its last component symbol; for
example, `expseq1: exp ',' expseq1;'. *Note Recursion::.

Semantics
In computer languages, the semantics are specified by the actions
taken for each instance of the language, i.e., the meaning of
each statement. *Note Semantics::.

Shift
A parser is said to shift when it makes the choice of analyzing
further input from the stream rather than reducing immediately
some already-recognized rule. *Note Algorithm::.

Single-character literal
A single character that is recognized and interpreted as is.
*Note Grammar in Bison::.

Start symbol
The nonterminal symbol that stands for a complete valid utterance
in the language being parsed. The start symbol is usually listed
as the first nonterminal symbol in a language specification.
*Note Start Decl::.

Symbol table
A data structure where symbol names and associated data are stored
during parsing to allow for recognition and use of existing
information in repeated uses of a symbol. *Note Multi-function
Calc::.

Token
A basic, grammatically indivisible unit of a language. The symbol
that describes a token in the grammar is a terminal symbol. The
input of the Bison parser is a stream of tokens which comes from
the lexical analyzer. *Note Symbols::.

Terminal symbol
A grammar symbol that has no rules in the grammar and therefore
is grammatically indivisible. The piece of text it represents is
a token. *Note Language and Grammar::.


File: bison.info, Node: Index, Prev: Glossary, Up: top

Index
*****

* Menu:

* $$: Actions.
* $N: Actions.
* %expect: Expect Decl.
* %left: Using Precedence.
* %nonassoc: Using Precedence.
* %prec: Contextual Precedence.
* %pure_parser: Pure Decl.
* %right: Using Precedence.
* %start: Start Decl.
* %token: Token Decl.
* %type: Type Decl.
* %union: Union Decl.
* @N: Action Features.
* calc: Infix Calc.
* else, dangling: Shift/Reduce.
* mfcalc: Multi-function Calc.
* rpcalc: RPN Calc.
* BNF: Language and Grammar.
* Backus-Naur form: Language and Grammar.
* Bison declaration summary: Decl Summary.
* Bison declarations: Declarations.
* Bison declarations (introduction): Bison Declarations.
* Bison grammar: Grammar in Bison.
* Bison invocation: Invocation.
* Bison parser: Bison Parser.
* Bison parser algorithm: Algorithm.
* Bison symbols, table of: Table of Symbols.
* Bison utility: Bison Parser.
* C code, section for additional: C Code.
* C declarations section: C Declarations.
* C-language interface: Interface.
* LALR(1): Mystery Conflicts.
* LR(1): Mystery Conflicts.
* YYABORT: Parser Function.
* YYACCEPT: Parser Function.
* YYBACKUP: Action Features.
* YYDEBUG: Debugging.
* YYEMPTY: Action Features.
* YYERROR: Action Features.
* YYINITDEPTH: Stack Overflow.
* YYLTYPE: Token Positions.
* YYMAXDEPTH: Stack Overflow.
* YYPRINT: Debugging.
* YYRECOVERING: Error Recovery.
* action: Actions.
* action data types: Action Types.
* action features summary: Action Features.
* actions in mid-rule: Mid-Rule Actions.
* actions, semantic: Semantic Actions.
* additional C code section: C Code.
* algorithm of parser: Algorithm.
* associativity: Why Precedence.
* calculator, infix notation: Infix Calc.
* calculator, multi-function: Multi-function Calc.
* calculator, simple: RPN Calc.
* character token: Symbols.
* compiling the parser: Rpcalc Compile.
* conflicts: Shift/Reduce.
* conflicts, reduce/reduce: Reduce/Reduce.
* conflicts, suppressing warnings of: Expect Decl.
* context-dependent precedence: Contextual Precedence.
* context-free grammar: Language and Grammar.
* controlling function: Rpcalc Main.
* dangling else: Shift/Reduce.
* data types in actions: Action Types.
* data types of semantic values: Value Type.
* debugging: Debugging.
* declaration summary: Decl Summary.
* declarations, Bison: Declarations.
* declarations, Bison (introduction): Bison Declarations.
* declarations, C: C Declarations.
* declaring operator precedence: Precedence Decl.
* declaring the start symbol: Start Decl.
* declaring token type names: Token Decl.
* declaring value types: Union Decl.
* declaring value types, nonterminals: Type Decl.
* defining language semantics: Semantics.
* error: Error Recovery.
* error recovery: Error Recovery.
* error recovery, simple: Simple Error Recovery.
* error reporting function: Error Reporting.
* error reporting routine: Rpcalc Error.
* examples, simple: Examples.
* exercises: Exercises.
* file format: Grammar Layout.
* finite-state machine: Parser States.
* formal grammar: Grammar in Bison.
* format of grammar file: Grammar Layout.
* glossary: Glossary.
* grammar file: Grammar Layout.
* grammar rule syntax: Rules.
* grammar rules section: Grammar Rules.
* grammar, Bison: Grammar in Bison.
* grammar, context-free: Language and Grammar.
* grouping, syntactic: Language and Grammar.
* infix notation calculator: Infix Calc.
* interface: Interface.
* introduction: Introduction.
* invoking Bison: Invocation.
* language semantics, defining: Semantics.
* layout of Bison grammar: Grammar Layout.
* left recursion: Recursion.
* lexical analyzer: Lexical.
* lexical analyzer, purpose: Bison Parser.
* lexical analyzer, writing: Rpcalc Lexer.
* lexical tie-in: Lexical Tie-ins.
* literal token: Symbols.
* look-ahead token: Look-Ahead.
* main function in simple example: Rpcalc Main.
* mid-rule actions: Mid-Rule Actions.
* multi-function calculator: Multi-function Calc.
* mutual recursion: Recursion.
* nonterminal symbol: Symbols.
* operator precedence: Precedence.
* operator precedence, declaring: Precedence Decl.
* options for invoking Bison: Invocation.
* overflow of parser stack: Stack Overflow.
* parse error: Error Reporting.
* parser: Bison Parser.
* parser stack: Algorithm.
* parser stack overflow: Stack Overflow.
* parser state: Parser States.
* polish notation calculator: RPN Calc.
* precedence declarations: Precedence Decl.
* precedence of operators: Precedence.
* precedence, context-dependent: Contextual Precedence.
* precedence, unary operator: Contextual Precedence.
* preventing warnings about conflicts: Expect Decl.
* pure parser: Pure Decl.
* recovery from errors: Error Recovery.
* recursive rule: Recursion.
* reduce/reduce conflict: Reduce/Reduce.
* reduction: Algorithm.
* reentrant parser: Pure Decl.
* reverse polish notation: RPN Calc.
* right recursion: Recursion.
* rule syntax: Rules.
* rules section for grammar: Grammar Rules.
* running Bison (introduction): Rpcalc Gen.
* semantic actions: Semantic Actions.
* semantic value: Semantic Values.
* semantic value type: Value Type.
* shift/reduce conflicts: Shift/Reduce.
* shifting: Algorithm.
* simple examples: Examples.
* single-character literal: Symbols.
* stack overflow: Stack Overflow.
* stack, parser: Algorithm.
* stages in using Bison: Stages.
* start symbol: Language and Grammar.
* start symbol, declaring: Start Decl.
* state (of parser): Parser States.
* summary, Bison declaration: Decl Summary.
* summary, action features: Action Features.
* suppressing conflict warnings: Expect Decl.
* symbol: Symbols.
* symbol table example: Mfcalc Symtab.
* symbols (abstract): Language and Grammar.
* symbols in Bison, table of: Table of Symbols.
* syntactic grouping: Language and Grammar.
* syntax error: Error Reporting.
* syntax of grammar rules: Rules.
* terminal symbol: Symbols.
* token: Language and Grammar.
* token type: Symbols.
* token type names, declaring: Token Decl.
* tracing the parser: Debugging.
* unary operator precedence: Contextual Precedence.
* using Bison: Stages.
* value type, semantic: Value Type.
* value types, declaring: Union Decl.
* value types, nonterminals, declaring: Type Decl.
* value, semantic: Semantic Values.
* warnings, preventing: Expect Decl.
* writing a lexical analyzer: Rpcalc Lexer.
* yychar: Look-Ahead.
* yyclearin: Error Recovery.
* yydebug: Debugging.
* yyerrok: Error Recovery.
* yyerror: Error Reporting.
* yylex: Lexical.
* yylloc: Token Positions.
* yylval: Token Values.
* yynerrs: Error Reporting.
* yyparse: Parser Function.
* |: Rules.


./info/bison 644 0 0 6715 5213513116 11207 0ustar rootrootInfo file bison.info, produced by Makeinfo, -*- Text -*- from input
file bison.texinfo.

This file documents the Bison parser generator.

Copyright (C) 1988, 1989, 1990 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License" and
"Conditions for Using Bison" are included exactly as in the original,
and provided that the entire resulting derived work is distributed
under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License", "Conditions for Using Bison" and this permission notice may
be included in translations approved by the Free Software Foundation
instead of in the original English.

Indirect:
bison.info-1: 1149
bison.info-2: 50605
bison.info-3: 100355
bison.info-4: 148481

Tag Table:
(Indirect)
Node: Top1151
Node: Introduction2317
Node: Conditions3484
Node: Copying5357
Node: Concepts24632
Node: Language and Grammar25701
Node: Grammar in Bison30737
Node: Semantic Values32473
Node: Semantic Actions34548
Node: Bison Parser35732
Node: Stages37979
Node: Grammar Layout39201
Node: Examples40458
Node: RPN Calc41625
Node: Rpcalc Decls42809
Node: Rpcalc Rules44328
Node: Rpcalc Input46069
Node: Rpcalc Line47533
Node: Rpcalc Expr48645
Node: Rpcalc Lexer50607
Node: Rpcalc Main53104
Node: Rpcalc Error53482
Node: Rpcalc Gen54460
Node: Rpcalc Compile55572
Node: Infix Calc56449
Node: Simple Error Recovery59111
Node: Multi-function Calc60999
Node: Mfcalc Decl62563
Node: Mfcalc Rules64543
Node: Mfcalc Symtab65923
Node: Exercises72165
Node: Grammar File72672
Node: Grammar Outline73447
Node: C Declarations74208
Node: Bison Declarations74812
Node: Grammar Rules75206
Node: C Code75643
Node: Symbols76546
Node: Rules80183
Node: Recursion81823
Node: Semantics83542
Node: Value Type84632
Node: Multiple Types85262
Node: Actions86209
Node: Action Types88590
Node: Mid-Rule Actions89893
Node: Declarations95445
Node: Token Decl96697
Node: Precedence Decl97997
Node: Union Decl99531
Node: Type Decl100357
Node: Expect Decl101034
Node: Start Decl102558
Node: Pure Decl102937
Node: Decl Summary104177
Node: Multiple Parsers105380
Node: Interface106821
Node: Parser Function107661
Node: Lexical108514
Node: Calling Convention109903
Node: Token Values111226
Node: Token Positions112342
Node: Pure Calling113200
Node: Error Reporting114176
Node: Action Features115900
Node: Algorithm119409
Node: Look-Ahead121680
Node: Shift/Reduce123797
Node: Precedence126207
Node: Why Precedence126863
Node: Using Precedence128738
Node: Precedence Examples129706
Node: How Precedence130408
Node: Contextual Precedence131517
Node: Parser States133290
Node: Reduce/Reduce134528
Node: Mystery Conflicts137727
Node: Stack Overflow141115
Node: Error Recovery142490
Node: Context Dependency147627
Node: Semantic Tokens148483
Node: Lexical Tie-ins151527
Node: Tie-in Recovery153049
Node: Debugging155221
Node: Invocation158494
Node: Table of Symbols162874
Node: Glossary168472
Node: Index174144

End Tag Table
./src/bison-1.18/COPYING 600 0 0 43076 5022247405 12554 0ustar rootroot GNU GENERAL PUBLIC LICENSE
Version 2, June 1991

Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

Preamble

The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.

When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.

We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and
modification follow.

GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.

b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.

c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,

b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,

c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.

9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

NO WARRANTY

11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

END OF TERMS AND CONDITIONS

Appendix: How to Apply These Terms to Your New Programs

If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.


Copyright (C) 19yy

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 of the License, 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., 675 Mass Ave, Cambridge, MA 02139, USA.

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.

, 1 April 1989
Ty Coon, President of Vice

This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
./src/bison-1.18/ChangeLog 600 0 14 66744 5201145132 13600 0ustar rootdaemonMon May 4 01:23:21 1992 Richard Stallman ([email protected])

* Version 1.18.

* getargs.c (getargs): Change '0' to 0 in case for long options.

Sun Apr 19 10:17:52 1992 Richard Stallman ([email protected])

* reader.c (packsymbols): Handle -p when declaring yylval.

Sat Apr 18 18:18:48 1992 Richard Stallman ([email protected])

* output.c (output_gram): Output #endif properly at end of decl.

Mon Mar 30 01:13:41 1992 Richard Stallman ([email protected])

* Version 1.17.

* Makefile.in (clean): Don't delete configuration files or TAGS.
(distclean): New target; do delete those.

Sat Mar 28 17:18:50 1992 Richard Stallman ([email protected])

* output.c (output_gram): Conditionalize yyprhs on YYDEBUG.

* LR0.c (augment_automaton): If copying sp->shifts to insert new
shift, handle case of inserting at end.

Sat Mar 21 23:25:47 1992 Richard Stallman ([email protected])

* lex.c (skip_white_space): Handle C++ comments.
* reader.c (copy_definition, parse_union_decl, copy_guard):
(copy_action): Likewise.

Sun Mar 8 01:22:21 1992 Richard Stallman ([email protected])

* bison.simple (YYPOPSTACK): Fix typo.

Sat Feb 29 03:53:06 1992 Richard Stallman ([email protected])

* Makefile.in (install): Install bison.info* files one by one.

Fri Feb 28 19:55:30 1992 David J. MacKenzie ([email protected])

* bison.1: Document long options as starting with `--', not `+'.

Sat Feb 1 00:08:09 1992 Richard Stallman ([email protected])

* getargs.c (getargs): Accept value 0 from getopt_long.

Thu Jan 30 23:39:15 1992 Richard Stallman ([email protected])

* Makefile.in (mostlyclean): Renamed from `clean'.
(clean): Renamed from 'distclean'. Dep on mostlyclean, not realclean.
(realclean): Dep on clean.

Mon Jan 27 21:59:19 1992 Richard Stallman ([email protected])

* bison.simple: Use malloc, not xmalloc, and handle failure explicitly.

Sun Jan 26 22:40:04 1992 Richard Stallman ([email protected])

* conflicts.c (total_conflicts): Delete unused arg to fprintf.

Tue Jan 21 23:17:44 1992 Richard Stallman ([email protected])

* Version 1.16.

Mon Jan 6 16:50:11 1992 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* Makefile (distclean): Depend on clean, not realclean. Don't rm TAGS.
(realclean): rm TAGS here.

* symtab.c (free_symtab): Don't free the type names.

Sun Dec 29 22:25:40 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* machine.h: MSDOS has 32-bit ints if __GO32__.

Wed Dec 25 22:09:07 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu)

* bison.simple [_AIX]: Indent `#pragma alloca', so old C compilers
don't choke on it.

Mon Dec 23 02:10:16 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* getopt.c, getopt1.c, getopt.h: Link them to standard source location.
* alloca.c: Likewise.
* Makefile.in (dist): Copy those files from current dir.

* getargs.c: Update usage message.

* LR0.c (augment_automaton): Put new shift in proper order.

Fri Dec 20 18:39:20 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* conflicts.c: Use memcpy if ANSI C library.

* closure.c (set_fderives): Delete redundant assignment to vrow.

* closure.c (print_firsts): Fix bounds and offset checking tags.

* closure.c (tags): Declare just once at start of file.

* LR0.c (allocate_itemsets): Eliminate unused var max.
(augment_automaton): Test sp is non-null.

* lalr.c (initialize_LA): Make the vectors at least 1 element long.

* reader.c (readgram): Remove separate YYSTYPE default for MSDOS.

Wed Dec 18 02:40:32 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* print.c (print_grammar): Don't print disabled rules.

Tue Dec 17 03:48:07 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* lex.c (lex): Parse hex escapes properly.
Handle \v when filling token_buffer.

* lex.c: Include new.h.
(token_buffer): Change to a pointer.
(init_lex): Allocate initial buffer.
(grow_token_buffer): New function.
(lex, parse_percent_token): Use that.

* reader.c (read_declarations): Call open_extra_files just once.
(parse_token_decl): Don't free previous typename value.
Don't increment nvars if symbol is already a nonterminal.
(parse_union_decl): Catch unmatched close-brace.
(parse_expect_decl): Null-terminate buffer.
(copy_guard): Set brace_flag for {, not for }.

* reader.c: Fix %% in calls to fatal.

* reader.c (token_buffer): Just one extern decl, at top level.
Declare as pointer.

* symtab.c (free_symtab): Free type_name fields. Free symtab itself.

Mon Nov 25 23:04:31 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* bison.simple: Handle alloca for AIX.

* Makefile.in (mandir): Compute default using manext.

Sat Nov 2 21:39:32 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu)

* Update all files to GPL version 2.

Fri Sep 6 01:51:36 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* bison.simple (__yy_bcopy): Use builtin if GCC version 2.

Mon Aug 26 22:09:12 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* reader.c (parse_assoc_decl): Error if same symbol gets two precs.

Mon Aug 26 16:42:09 1991 David J. MacKenzie (djm at pogo.gnu.ai.mit.edu)

* Makefile.in, configure: Only put $< in Makefile if using VPATH,
because older makes don't understand it.

Fri Aug 23 00:05:54 1991 David J. MacKenzie (djm at apple-gunkies)

* conflicts.c [_AIX]: #pragma alloca.
* reduce.c: Don't define TRUE and FALSE if already defined.

Mon Aug 12 22:49:58 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* Makefile.in: Add deps on system.h.
(install): Add some deps.

Fri Aug 2 12:19:20 1991 David J. MacKenzie (djm at apple-gunkies)

* Makefile.in (dist): Include texinfo.tex.

* configure: Create config.status. Remove it and Makefile if
interrupted while creating them.

Thu Aug 1 23:14:01 1991 David J. MacKenzie (djm at apple-gunkies)

* configure: Check for +srcdir etc. arg and look for
Makefile.in in that directory. Set VPATH if srcdir is not `.'.
* Makefile.in (prefix): Renamed from DESTDIR.

Wed Jul 31 21:29:47 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* print.c (print_grammar): Make output prettier. Break lines.

Tue Jul 30 22:38:01 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* print.c (print_grammar): New function.
(verbose): Call it instead of printing token names here.

Mon Jul 22 16:39:54 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* vmsgetargs.c (spec_name_prefix, spec_file_prefix): Define variables.

Wed Jul 10 01:38:25 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu)

* configure, Makefile.in: $(INSTALLPROG) -> $(INSTALL),
$(INSTALLTEXT) -> $(INSTALLDATA).

Tue Jul 9 00:53:58 1991 David J. MacKenzie (djm at wookumz.gnu.ai.mit.edu)

* bison.simple: Don't include malloc.h if __TURBOC__.

Sat Jul 6 15:18:12 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu)

* Replace Makefile with configure and Makefile.in.
Update README with current compilation instructions.

Mon Jul 1 23:12:20 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* reader.c (reader): Make the output define YYBISON.

Thu Jun 20 16:52:51 1991 David J. MacKenzie (djm at geech.gnu.ai.mit.edu)

* Makefile (MANDIR, MANEXT): Install man page in
/usr/local/man/man1/bison.1 by default, instead of
/usr/man/manl/bison.l, for consistency with other GNU programs.
* Makefile: Rename BINDIR et al. to lowercase to conform to
GNU coding standards.
(install): Make man page non-executable.

Fri May 31 23:22:13 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* Makefile (bison.info): New target.
(realclean): New target.

Thu May 2 16:36:19 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* bison.simple: Use YYPRINT to print a token, if it's defined.

Mon Apr 29 12:22:55 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* lalr.c (transpose): Rename R to R_arg.
(initialize_LA): Avoid shadowing variable j.

* reader.c (packsymbols): Avoid shadowing variable i.

* files.c: Declare exit and perror.

* machine.h: Define MAXSHORT and MINSHORT for the eta-10.

Tue Apr 2 20:49:12 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* allocate.c (mallocate): Always allocate at least one byte.

Tue Mar 19 22:17:19 1991 Richard Stallman (rms at mole.gnu.ai.mit.edu)

* Makefile (dist): Put alloca.c into distribution.

Wed Mar 6 17:45:42 1991 Richard Stallman (rms at mole.ai.mit.edu)

* print.c (print_actions): Nicer output for final states.

Thu Feb 21 20:39:53 1991 Richard Stallman (rms at mole.ai.mit.edu)

* output.c (output_rule_data): Break lines in yytline based on hpos.

Thu Feb 7 12:54:36 1991 Richard Stallman (rms at mole.ai.mit.edu)

* bison.simple (yyparse): Move decl of yylsa before use.

Tue Jan 15 23:41:33 1991 Richard Stallman (rms at mole.ai.mit.edu)

* Version 1.14.

* output.c (output_rule_data): Handle NULL in tags[i].

Fri Jan 11 17:27:24 1991 Richard Stallman (rms at mole.ai.mit.edu)

* bison.simple: On MSDOS, include malloc.h.

Sat Dec 29 19:59:55 1990 David J. MacKenzie (djm at wookumz.ai.mit.edu)

* files.c: Use `mallocate' instead of `xmalloc' so no extra decl is
needed.

Wed Dec 19 18:31:21 1990 Richard Stallman (rms at mole.ai.mit.edu)

* reader.c (readgram): Alternate YYSTYPE defn for MSDOS.
* files.c [MSDOS]: Declare xmalloc.

Thu Dec 13 12:45:54 1990 Richard Stallman (rms at mole.ai.mit.edu)

* output.c (output_rule_data): Put all symbols in yytname.

* bison.simple (yyparse): Delete extra fprintf arg
when printing a result of reduction.

Mon Dec 10 13:55:15 1990 Richard Stallman (rms at mole.ai.mit.edu)

* reader.c (packsymbols): Don't declare yylval if pure_parser.

Tue Oct 30 23:38:09 1990 Richard Stallman (rms at mole.ai.mit.edu)

* Version 1.12.

* LR0.c (augment_automaton): Fix bugs adding sp2 to chain of shifts.

Tue Oct 23 17:41:49 1990 Richard Stallman (rms at mole.ai.mit.edu)

* bison.simple: Don't define alloca if already defined.

Sun Oct 21 22:10:53 1990 Richard Stallman (rms at mole.ai.mit.edu)

* getopt.c: On VMS, use string.h.

* main.c (main): Return type int.

Mon Sep 10 16:59:01 1990 Richard Stallman (rms at mole.ai.mit.edu)

* output.c (output_headers): Output macro defs for -p.

* reader.c (readgram): Handle consecutive actions.

* getargs.c (getargs): Rename -a to -p.
* files.c (openfiles): Change names used for -b.

Mon Aug 27 00:30:15 1990 Richard Stallman (rms at mole.ai.mit.edu)

* reduce.c (reduce_grammar_tables): Don't map rlhs of disabled rule.

Sun Aug 26 13:43:32 1990 Richard Stallman (rms at mole.ai.mit.edu)

* closure.c (print_firsts, print_fderives): Use BITISSET to test bits.

Thu Aug 23 22:13:40 1990 Richard Stallman (rms at mole.ai.mit.edu)

* closure.c (print_firsts): vrowsize => varsetsize.
(print_fderives): rrowsize => rulesetsize.

Fri Aug 10 15:32:11 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* bison.simple (alloca): Don't define if already defined.
(__yy_bcopy): Alternate definition for C++.

Wed Jul 11 00:46:03 1990 David J. MacKenzie (djm at albert.ai.mit.edu)

* getargs.c (getargs): Mention +yacc in usage message.

Tue Jul 10 17:29:08 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (parse_token_decl, copy_action):
Set value_components_used if appropriate.
(readgram): Inhibit output of YYSTYPE definition in that case.

Sat Jun 30 13:47:57 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* output.c (output_parser): Define YYPURE if pure, and not otherwise.
Don't define YYIMPURE.
* bison.simple: Adjust conditionals accordingly.
* bison.simple (YYLEX): If locations not in use, don't pass &yylloc.

Thu Jun 28 12:32:21 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* getargs.c (longopts): Add `yacc'.

Thu Jun 28 00:40:21 1990 David J. MacKenzie (djm at apple-gunkies)

* getargs.c (getargs): Add long options.
* Makefile: Link with getopt1.o and add getopt1.c and getopt.h to
dist.

* Move version number and description back into version.c from
Makefile and getargs.c.
* Makefile (dist): Extract version number from version.c.

Tue Jun 26 13:16:35 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* output.c (output): Always call output_gram.
* bison.simple (yyparse): Print rhs and lhs symbols of reduction rule.

Thu Jun 21 00:15:40 1990 David J. MacKenzie (djm at albert.ai.mit.edu)

* main.c: New global var `program_name' to hold argv[0] for error
messages.
* allocate.c, files.c, getargs.c, reader.c: Use `program_name'
in messages instead of hardcoded "bison".

Wed Jun 20 23:38:34 1990 David J. MacKenzie (djm at albert.ai.mit.edu)

* Makefile: Specify Bison version here. Add rule to pass it to
version.c. Encode it in distribution directory and tar file names.
* version.c: Use version number from Makefile.
* getargs.c (getargs): Print additional text that used to be part of
version_string in version.c. Use -V instead of -version to print
Bison version info. Print a usage message and exit if given an
invalid option.

Tue Jun 19 01:15:18 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* bison.simple: Fix a #line.

* Makefile (INSTALL): New parameter.
(install): Use that.
(CFLAGS): Move definition to top.

Sun Jun 17 17:10:21 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (parse_type_decl): Ignore semicolon.
Remove excess % from error messages.

Sat Jun 16 19:15:48 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Version 1.11.

* Makefile (install): Ensure installed files readable.

Tue Jun 12 12:50:56 EDT 1990 Jay Fenlason ([email protected])

* getargs.c: Declare spec_file_prefix

* lex.c (lex): \a is '\007' instead of '007'

* reader.c: include machine.h

* files.h: Declare extern spec_name_prefix.

Trivial patch from Thorsten Ohl ([email protected])

Thu May 31 22:00:16 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Version 1.10.

* bison.simple (YYBACKUP, YYRECOVERING): New macros.
(YYINITDEPTH): This is what used to be YYMAXDEPTH.
(YYMAXDEPTH): This is what used to be YYMAXLIMIT.
If the value is 0, use the default instead.
(yyparse): Return 2 on stack overflow.

Wed May 30 21:09:07 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* bison.simple (YYERROR): Jump to new label; don't print error message.
(yyparse): Define label yyerrlab1.

Wed May 16 13:23:58 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* files.c (openfiles): Support -b.
* getargs.c (getargs): Likewise.

* reader.c (readgram): Error if too many symbols.

* lex.c (lex): Handle \a. Make error msgs more reliable.
* reader.c (read_declarations): Make error msgs more reliable.

Sun May 13 15:03:37 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Version 1.09.

* reduce.c (reduce_grammar_tables): Fix backward test.

Sat May 12 21:05:34 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Makefile (bison-dist.*): Rename targets and files to bison.*.
(bison.tar): Make tar file to unpack into subdirectory named `bison'.

Mon Apr 30 03:46:58 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reduce.c (reduce_grammar_tables): Set rlhs to -1 for useless rules.
* nullable.c (set_nullable): Ignore those rules.
* derives.c (set_derives): Likewise.

Mon Apr 23 15:16:09 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* bison.simple (yyparse): Mention rule number as well as line number.

Thu Mar 29 00:00:43 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* bison.simple (__yy_bcopy): New function.
(yyparse): Use that, not bcopy.

Wed Mar 28 15:23:51 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* print.c (print_actions): Don't alter i and j spuriously when errp==0.

Mon Mar 12 16:22:18 1990 Jim Kingdon (kingdon at pogo.ai.mit.edu)

* bison.simple [__GNUC__]: Use builtin_alloca.

Wed Mar 7 21:11:36 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Makefile (install): Use mergedir.awk to process bison.simple
for installation.

* bison.simple (yyparse): New feature to include possible valid
tokens in parse error message.

Sat Mar 3 14:10:56 1990 Richard Stallman (rms at geech)

* Version 1.08.

Mon Feb 26 16:32:21 1990 Jim Kingdon (kingdon at pogo.ai.mit.edu)

* print.c (print_actions)
conflicts.c (print_reductions): Change "shift %d" to
"shift, and go to state %d" and "reduce %d" to "reduce using rule %d"
and "goto %d" to "go to state %d".
print.c (print_core): Change "(%d)" to "(rule %d)".

Tue Feb 20 14:22:47 EST 1990 Jay Fenlason (hack @ wookumz.ai.mit.edu)

* bison.simple: Comment out unused yyresume: label.

Fri Feb 9 16:14:34 EST 1990 Jay Fenlason (hack @ wookumz.ai.mit.edu)

* bison.simple : surround all declarations and (remaining) uses of
yyls* and yylloc with #ifdef YYLSP_NEEDED This will significantly
cut down on stack usage, and gets rid of unused-variable msgs from
GCC.

Wed Jan 31 13:06:08 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* files.c (done) [VMS]: Don't delete files that weren't used.
[VMS]: Let user override XPFILE and XPFILE1.

Wed Jan 3 15:52:28 1990 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Version 1.07.

Sat Dec 16 15:50:21 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* gram.c (dummy): New function.

* reader.c (readgram): Detect error if two consec actions.

Wed Nov 15 02:06:08 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reduce.c (reduce_grammar_tables): Update rline like other tables.

* Makefile (install): Install the man page.

Sat Nov 11 03:21:58 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* output.c (output_rule_data): Write #if YYDEBUG around yyrline.

Wed Oct 18 13:07:55 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Version 1.06.

* vmsgetargs.c (getargs): Downcase specified output file name.

Fri Oct 13 17:48:14 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (readgram): Warn if there is no default to use for $$
and one is needed.

Fri Sep 29 12:51:53 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Version 1.05.

* vmsgetargs.h (getargs): Process outfile option.

Fri Sep 8 03:05:14 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Version 1.04.

* reader.c (parse_union_decl): Count newlines even in comments.

Wed Sep 6 22:03:19 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* files.c (openfiles): short_base_length was always == base_length.

Thu Aug 24 16:55:06 1989 Richard Stallman (rms at apple-gunkies.ai.mit.edu)

* Version 1.03.

* files.c (openfiles): Write output into same dir as input, by default.

Wed Aug 23 15:03:07 1989 Jay Fenlason (hack at gnu)

* Makefile: Include system.h in bison-dist.tar

Tue Aug 15 22:30:42 1989 Richard Stallman (rms at hobbes.ai.mit.edu)

* version 1.03.

* reader.c (reader): Output LTYPESTR to fdefines
only after reading the grammar.

Sun Aug 6 16:55:23 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (read_declarations): Put space before comment
to avoid bug in Green Hills C compiler.

Mon Jun 19 20:14:01 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* allocate.c (xmalloc): New function.

Fri Jun 16 23:59:40 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* build.com: Compile and link reduce.c.

Fri Jun 9 23:00:54 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reduce.c (reduce_grammar_tables): Adjust start_symbol when #s change.

Sat May 27 17:57:29 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (copy_definition, copy_guard): Don't object to \-newline
inside strings.

Mon May 22 12:30:59 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* files.c (openfiles): Alternate file names for MSDOS.
(open_extra_files): Likewise.
(done): On MSDOS, unlink temp files here, not in openfiles.

* machine.h (BITS_PER_WORD): 16 on MSDOS.
(MAXTABLE): Now defined in this file.

* system.h: New file includes system-dependent headers.
All relevant .c files include it.

Thu Apr 27 17:00:47 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* version.c: Version 1.01.

Tue Apr 18 12:46:05 1989 Randall Smith (randy at apple-gunkies.ai.mit.edu)

* conflicts.c (total_conflicts): Fixed typo in yacc style output;
mention conflicts if > 0.

Sat Apr 15 17:36:18 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (packsymbols): Start new symbols after 256.

Wed Apr 12 14:09:09 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (reader): Always assign code 256 to `error' token.
Always set `translations' to 1 so this code gets handled.
* bison.simple (YYERRCODE): Define it.

Tue Apr 11 19:26:32 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* conflicts.c: If GNU C, use builtin alloca.

* Makefile (install): Delete parser files before copying them.

Thu Mar 30 13:51:17 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* getargs.c (getargs): Turn off checking of name Bison was invoked by.

* Makefile (dist): Include ChangeLog in distrib.

Thu Mar 23 15:19:41 1989 Jay Fenlason (hack at apple-gunkies.ai.mit.edu)

* LR0.c closure.c conflicts.c derives.c files.c getargs.c lalr.c
lex.c main.c nullable.c output.c print.c reader.c reduce.c
symtab.c warshall.c: A first pass at getting gcc -Wall to shut up.
Mostly declared functions as void, etc.

* reduce.c moved 'extern int fixed_outfiles;' into print_notices()
where it belongs.

Wed Mar 1 12:33:28 1989 Randall Smith (randy at apple-gunkies.ai.mit.edu)

* types.h, symtab.h, state.h, new.h, machine.h, lex.h, gram.h,
files.h, closure.c, vmsgetargs.c, warshall.c, symtab.c, reduce.c,
reader.c, print.c, output.c, nullable.c, main.c, lex.c, lalr.c,
gram.c, getargs.c, files.c, derives.c, conflicts.c, allocate.c,
LR0.c, Makefile, bison.simple: Changed copyright notices to be in
accord with the new General Public License.
* COPYING: Made a link to the new copying file.

Wed Feb 22 06:18:20 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* new.h (FREE): Alternate definition for __STDC__ avoids error
if `free' returns void.

Tue Feb 21 15:03:34 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (read_declarations): Double a `%' in a format string.
(copy_definition, parse_start_decl, parse_token_decl): Likewise.
(parse_type_decl, parse_union_decl, copy_guard, readgram, get_type).
(copy_action): change a `fatal' to `fatals'.

* lalr.c (map_goto): Initial high-end of binary search was off by 1.

Sat Feb 18 08:49:57 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* bison.simple [sparc]: Include alloca.h.

Wed Feb 15 06:24:36 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (packsymbols): Write decl of yylval into .tab.h file.

Sat Jan 28 18:19:05 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* bison.simple: Avoid comments on `#line' lines.

* reader.c (LTYPESTR): Rearrange to avoid whitespace after \-newline.

Mon Jan 9 18:43:08 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* conflicts.c (total_conflicts): if -y, use output syntax POSIX wants.
* reduce.c (print_notices): likewise.

* lex.c (lex): Handle \v, and \x hex escapes.

* reader.c (reader): Merge output_ltype into here.
Don't output YYLTYPE definition to .tab.h file
unless the @ construct is used.

* bison.simple: Define YYERROR, YYABORT, YYACCEPT here.
* reader.c (output_ltype): Don't output them here.

* bison.simple: YYDEBUG now should be 0 or 1.
* output.c (output): For YYDEBUG, output conditional to define it
only if not previously defined.

Mon Jan 2 11:29:55 1989 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* bison.simple (yyparse) [YYPURE]: Add local yynerrs.
(yydebug): Declare global, but don't initialize, regardless of YYPURE.
(yyparse): Don't declare yydebug here.

Thu Dec 22 22:01:22 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reduce.c (print_notices): Typo in message.

Sun Dec 11 11:32:07 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* output.c (pack_table): Free only nonzero the elts of froms & tos.

Thu Dec 8 16:26:46 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* gram.c (rprecsym): New vector indicates the %prec symbol for a rule.
* reader.c (packgram): Allocate it and fill it in.
* reduce.c (inaccessable_symbols): Use it to set V1.
* reduce.c (print_results): Don't complain about useless token
if it's in V1.

Mon Dec 5 14:33:17 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* machine.h (RESETBIT, BITISSET): New macros.
(SETBIT, WORDSIZE): Change to use BITS_PER_WORD.

* reduce.c: New file, by David Bakin. Reduces the grammar.
* Makefile: Compile it, link it, put it in dist.

* main.c (main): Call reduce_grammar (in reduce.c).

Thu Nov 17 18:33:04 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* conflicts.c: Don't declare alloca if including alloca.h.

* bison.cld: Define qualifiers `nolines', `debug'.
* vmsgetargs.c (getargs): Handle them.

* output.c (output_program): Notice `nolinesflag'.

* output.c (output_parser): Simplify logic for -l and #line.
Avoid writing EOF char into output.

Wed Oct 12 18:00:03 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Implement `-l' option.
* getopt.c: Set flag `nolinesflag'.
* reader.c (copy_definition, parse_union_decl, copy_guard, copy_action)
Obey that flag; don't generate #line.
* output.c (output_parser): Discard #line's when copying the parser.

Mon Sep 12 16:33:17 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (copy_guard): Fix brace-counting for brace-surrounded guard.

Thu Sep 8 20:09:53 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* bison.simple: Correct number in #line command.
(yyparse): Call YYABORT instead of YYERROR, due to last change in
output_ltype.

Mon Sep 5 14:55:30 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* Makefile: New variable LIBS. Alternatives for USG.
* conflicts.c [USG]: Define bcopy.
* symtab.c [USG]: Include string.h instead of strings.h.

* conflicts.c [sparc]: Include alloca.h.

Tue Aug 2 08:38:38 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (parse_token_decl): Ignore commas.

Sat Jun 25 10:29:20 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* reader.c (output_ltype): Make YYERROR yacc-compatible (like YYFAIL).

Fri Jun 24 11:25:11 1988 Richard Stallman (rms at sugar-bombs.ai.mit.edu)

* getargs.c (getargs): -t sets debugflag.
Eliminate upper case duplicate options.
* output.c (output): If debugflag, output `#define YYDEBUG'.

Thu May 26 06:04:21 1988 Richard Stallman (rms at frosted-flakes.ai.mit.edu)

* allocate.c (mallocate): New name for `allocate' (which loses in VMS).
Calls changed in LR0.c, conflicts.c, symtab.c, new.h.

* getargs.c (getargs): If argv[0] is "yacc", set fixed_outfiles.

Tue May 17 12:15:30 1988 Richard Stallman (rms at frosted-flakes.ai.mit.edu)

* conflicts.c: Declare alloca.
* reader.c: Declare realloc.
* warshall.c (TC): Fix one arithmetic op that was omitted last time.

Thu May 5 14:36:03 1988 Richard Stallman (rms at frosted-flakes.ai.mit.edu)

* bison.simple: Conditionalize most refs to yylsp on YYLSP_NEEDED.
* reader.c (copy_guard, copy_action): Notice if `@' is used.
(reader): If it was, output `#define YYLSP_NEEDED'.

Mon Apr 18 04:54:32 1988 Richard Stallman (rms at rice-krispies.ai.mit.edu)

* bison.simple: New variable yynerr counts calls to yyerror.

* lex.c (lex, case '='): Update lineno when skipping a newline.

* reader.c (parse_expect_decl): ungetc the char that ends the number;
don't read any further. This handles multi-line comments right
and avoids incorrect lineno.

* reader.c: Delete duplicate decl of symval.

* warshall.c (RTC, TC): Cast ptrs to char *, not unsigned, for arith.

Local Variables:
mode: indented-text
left-margin: 8
fill-column: 76
version-control: never
End:
./src/bison-1.18/README 600 0 14 1147 5174462631 12667 0ustar rootdaemonThis directory contains the Bison parser generator.

See the file INSTALL for compilation and installation instructions.

It was once true that, when installing Bison on Sequent (or Pyramid?)
systems, you had to be in the Berkeley universe. This may no longer
be true; we have no way to tell.

On VMS, you will probably have to create Makefile from Makefile.in by
hand. Remember to do `SET COMMAND BISON' to install the data in
`BISON.CLD'.

Send bug reports to [email protected]. Please include the
version number from `bison --version', and a complete, self-contained
test case in each bug report.
./src/bison-1.18/README.linux 600 0 0 323 5213513401 13455 0ustar rootrootThis is bison 1.18
compiled with gcc 2.11c under Linux 0.96a + Linus' first patch
linked static

Source code is currently at prep.ai.mit.edu:/pub/gnu/bison-1.18.tar.Z

Thu Jun 4 22:19:19 1992, [email protected]


  3 Responses to “Category : Linux Files
Archive   : BISON118.ZIP
Filename : BISON11B.TAR

  1. Very nice! Thank you for this wonderful archive. I wonder why I found it only now. Long live the BBS file archives!

  2. This is so awesome! 😀 I’d be cool if you could download an entire archive of this at once, though.

  3. But one thing that puzzles me is the “mtswslnkmcjklsdlsbdmMICROSOFT” string. There is an article about it here. It is definitely worth a read: http://www.os2museum.com/wp/mtswslnk/