| | 1 | #! /usr/bin/perl -w |
| | 2 | |
| | 3 | # Copyright (C) 2006, 2008 Free Software Foundation, Inc. |
| | 4 | # |
| | 5 | # This file is part of Bison, the GNU Compiler Compiler. |
| | 6 | # |
| | 7 | # This program is free software: you can redistribute it and/or modify |
| | 8 | # it under the terms of the GNU General Public License as published by |
| | 9 | # the Free Software Foundation, either version 3 of the License, or |
| | 10 | # (at your option) any later version. |
| | 11 | # |
| | 12 | # This program is distributed in the hope that it will be useful, |
| | 13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| | 14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| | 15 | # GNU General Public License for more details. |
| | 16 | # |
| | 17 | # You should have received a copy of the GNU General Public License |
| | 18 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
| | 19 | |
| | 20 | =head1 NAME |
| | 21 | |
| | 22 | bench.pl - bench marks for Bison parsers. |
| | 23 | |
| | 24 | =head1 SYNOPSIS |
| | 25 | |
| | 26 | ./bench.pl [OPTIONS]... DIRECTIVES |
| | 27 | |
| | 28 | =head1 DIRECTIVES |
| | 29 | |
| | 30 | Specify the set of benches to run. The following grammar defines the |
| | 31 | I<directives>: |
| | 32 | |
| | 33 | directives ::= |
| | 34 | directives | directives -- Alternation |
| | 35 | | directives & directives -- Concatenation |
| | 36 | | [ directives> ] -- Optional |
| | 37 | | ( directives> ) -- Parentheses |
| | 38 | | #d NAME[=VALUE] -- %code { #define NAME [VALUE] } |
| | 39 | | %d NAME[=VALUE] -- %define NAME ["VALUE"] |
| | 40 | | %s skeleton -- %skeleton "skeleton" |
| | 41 | | directive |
| | 42 | |
| | 43 | Parentheses only group to override precedence. For instance: |
| | 44 | |
| | 45 | [ %debug ] & [ %error-verbose ] & [ %define variant ] |
| | 46 | |
| | 47 | will generate eight different cases. |
| | 48 | |
| | 49 | =head1 OPTIONS |
| | 50 | |
| | 51 | =over 4 |
| | 52 | |
| | 53 | =item B<-b>, B<--bench> |
| | 54 | |
| | 55 | Predefined benches, that is, combimation between a grammar and a I<directives> |
| | 56 | request. |
| | 57 | |
| | 58 | =over 4 |
| | 59 | |
| | 60 | =item I<fusion> |
| | 61 | |
| | 62 | Test F<lalr1.cc> with three stacks against F<lalr1-fusion.cc> which |
| | 63 | uses a single one. |
| | 64 | |
| | 65 | =item I<push> |
| | 66 | |
| | 67 | Test the push parser vs. the pull interface. Use the C parser. |
| | 68 | |
| | 69 | =item I<variant> |
| | 70 | |
| | 71 | Test the use of variants instead of union in the C++ parser. |
| | 72 | |
| | 73 | =back |
| | 74 | |
| | 75 | =item B<-c>, B<--cflags>=I<flags> |
| | 76 | |
| | 77 | Flags to pass to the C or C++ compiler. Defaults to -O2. |
| | 78 | |
| | 79 | =item B<-d>, B<--directive>=I<directives> |
| | 80 | |
| | 81 | Add a set of Bison directives to bench against each other. |
| | 82 | |
| | 83 | =item B<-g>, B<--grammar>=I<grammar> |
| | 84 | |
| | 85 | Select the base I<grammar> to use. Defaults to I<calc>. |
| | 86 | |
| | 87 | =over 4 |
| | 88 | |
| | 89 | =item I<calc> |
| | 90 | |
| | 91 | Traditional calculator. |
| | 92 | |
| | 93 | =item I<list> |
| | 94 | |
| | 95 | C++ grammar that uses std::string and std::list. Can be used with |
| | 96 | or without %define variant. |
| | 97 | |
| | 98 | =item I<triangular> |
| | 99 | |
| | 100 | Artificial grammar with very long rules. |
| | 101 | |
| | 102 | =back |
| | 103 | |
| | 104 | =item B<-h>, B<--help> |
| | 105 | |
| | 106 | Display this message and exit succesfully. The more verbose, the more |
| | 107 | details. |
| | 108 | |
| | 109 | =item B<-i>, B<--iterations>=I<integer> |
| | 110 | |
| | 111 | Say how many times a single test of the bench must be run. If |
| | 112 | negative, specify the minimum number of CPU seconds to run. Defaults |
| | 113 | to -1. |
| | 114 | |
| | 115 | =item B<-q>, B<--quiet> |
| | 116 | |
| | 117 | Decrease the verbosity level (defaults to 1). |
| | 118 | |
| | 119 | =item B<-v>, B<--verbose> |
| | 120 | |
| | 121 | Raise the verbosity level (defaults to 1). |
| | 122 | |
| | 123 | =back |
| | 124 | |
| | 125 | =cut |
| | 126 | |
| | 127 | use strict; |
| | 128 | use IO::File; |
| | 129 | |
| | 130 | ################################################################## |
| | 131 | |
| | 132 | =head1 VARIABLES |
| | 133 | |
| | 134 | =over 4 |
| | 135 | |
| | 136 | =item C<@bench> |
| | 137 | |
| | 138 | The list of benches to run. |
| | 139 | |
| | 140 | =item C<$bison> |
| | 141 | |
| | 142 | The Bison program to use to compile the grammar. |
| | 143 | |
| | 144 | =item C<$cc> |
| | 145 | |
| | 146 | The C compiler. |
| | 147 | |
| | 148 | =item C<$cxx> |
| | 149 | |
| | 150 | The C++ compiler. |
| | 151 | |
| | 152 | =item C<$cflags> |
| | 153 | |
| | 154 | Compiler flags (C or C++). |
| | 155 | |
| | 156 | =item C<@directive> |
| | 157 | |
| | 158 | A list of directive sets to measure against each other. |
| | 159 | |
| | 160 | =item C<$iterations> |
| | 161 | |
| | 162 | The number of times the parser is run for a bench. |
| | 163 | |
| | 164 | =item C<$verbose> |
| | 165 | |
| | 166 | Verbosity level. |
| | 167 | |
| | 168 | =back |
| | 169 | |
| | 170 | =cut |
| | 171 | |
| | 172 | my $bench; |
| | 173 | my $bison = $ENV{'BISON'} || '@abs_top_builddir@/tests/bison'; |
| | 174 | my $cc = $ENV{'CC'} || 'gcc'; |
| | 175 | my $cxx = $ENV{'CXX'} || 'g++'; |
| | 176 | my $cflags = '-O2'; |
| | 177 | my @directive = (); |
| | 178 | my $grammar = 'calc'; |
| | 179 | my $iterations = -1; |
| | 180 | my $verbose = 1; |
| | 181 | |
| | 182 | =head1 FUNCTIONS |
| | 183 | |
| | 184 | =over 4 |
| | 185 | |
| | 186 | =item C<verbose($level, $message)> |
| | 187 | |
| | 188 | Report the C<$message> is C<$level> E<lt>= C<$verbose>. |
| | 189 | |
| | 190 | =cut |
| | 191 | |
| | 192 | sub verbose($$) |
| | 193 | { |
| | 194 | my ($level, $message) = @_; |
| | 195 | print STDERR $message |
| | 196 | if $level <= $verbose; |
| | 197 | } |
| | 198 | |
| | 199 | |
| | 200 | ###################################################################### |
| | 201 | |
| | 202 | =item C<directives($bench, @directive)> |
| | 203 | |
| | 204 | Format the list of directives for Bison for bench named C<$bench>. |
| | 205 | |
| | 206 | =cut |
| | 207 | |
| | 208 | sub directives($@) |
| | 209 | { |
| | 210 | my ($bench, @directive) = @_; |
| | 211 | my $res = "/* Directives for bench `$bench'. */\n"; |
| | 212 | $res .= join ("\n", @directive) . "\n"; |
| | 213 | $res .= "/* End of directives for bench `$bench'. */\n"; |
| | 214 | return $res; |
| | 215 | } |
| | 216 | |
| | 217 | ###################################################################### |
| | 218 | |
| | 219 | =item C<generate_grammar_triangular ($base, $max, @directive)> |
| | 220 | |
| | 221 | Create a large triangular grammar which looks like : |
| | 222 | |
| | 223 | input: |
| | 224 | exp { if ($1 != 0) abort (); $$ = $1; } |
| | 225 | | input exp { if ($2 != $1 + 1) abort (); $$ = $2; } |
| | 226 | ; |
| | 227 | |
| | 228 | exp: |
| | 229 | END { $$ = 0; } |
| | 230 | | "1" END { $$ = 1; } |
| | 231 | | "1" "2" END { $$ = 2; } |
| | 232 | | "1" "2" "3" END { $$ = 3; } |
| | 233 | | "1" "2" "3" "4" END { $$ = 4; } |
| | 234 | | "1" "2" "3" "4" "5" END { $$ = 5; } |
| | 235 | ; |
| | 236 | |
| | 237 | C<$base> is the base name for the file to create (F<$base.y>). |
| | 238 | C<$max> is the number of such rules (here, 5). You may pass |
| | 239 | additional Bison C<@directive>. |
| | 240 | |
| | 241 | The created parser is self contained: it includes its scanner, and |
| | 242 | source of input. |
| | 243 | =cut |
| | 244 | |
| | 245 | sub generate_grammar_triangular ($$@) |
| | 246 | { |
| | 247 | my ($base, $max, @directive) = @_; |
| | 248 | my $directives = directives ($base, @directive); |
| | 249 | |
| | 250 | my $out = new IO::File ">$base.y" |
| | 251 | or die; |
| | 252 | print $out <<EOF; |
| | 253 | %error-verbose |
| | 254 | %debug |
| | 255 | %{ |
| | 256 | #include <stdio.h> |
| | 257 | #include <stdlib.h> |
| | 258 | |
| | 259 | static int yylex (void); |
| | 260 | static void yyerror (const char *msg); |
| | 261 | %} |
| | 262 | $directives |
| | 263 | %union |
| | 264 | { |
| | 265 | int val; |
| | 266 | }; |
| | 267 | |
| | 268 | %token END "end" |
| | 269 | %type <val> exp input |
| | 270 | EOF |
| | 271 | |
| | 272 | for my $size (1 .. $max) |
| | 273 | { |
| | 274 | print $out "%token t$size $size \"$size\"\n"; |
| | 275 | }; |
| | 276 | |
| | 277 | print $out <<EOF; |
| | 278 | %% |
| | 279 | input: |
| | 280 | exp { if (\$1 != 0) abort (); \$\$ = \$1; } |
| | 281 | | input exp { if (\$2 != \$1 + 1) abort (); \$\$ = \$2; } |
| | 282 | ; |
| | 283 | |
| | 284 | exp: |
| | 285 | END |
| | 286 | { \$\$ = 0; } |
| | 287 | EOF |
| | 288 | |
| | 289 | for my $size (1 .. $max) |
| | 290 | { |
| | 291 | use Text::Wrap; |
| | 292 | print $out wrap ("| ", " ", |
| | 293 | (map { "\"$_\"" } (1 .. $size)), |
| | 294 | " END \n"), |
| | 295 | " { \$\$ = $size; }\n"; |
| | 296 | }; |
| | 297 | print $out ";\n"; |
| | 298 | |
| | 299 | print $out <<EOF; |
| | 300 | %% |
| | 301 | static int |
| | 302 | yylex (void) |
| | 303 | { |
| | 304 | static int inner = 1; |
| | 305 | static int outer = 0; |
| | 306 | if (outer > $max) |
| | 307 | return 0; |
| | 308 | else if (inner > outer) |
| | 309 | { |
| | 310 | inner = 1; |
| | 311 | ++outer; |
| | 312 | return END; |
| | 313 | } |
| | 314 | return inner++; |
| | 315 | } |
| | 316 | |
| | 317 | static void |
| | 318 | yyerror (const char *msg) |
| | 319 | { |
| | 320 | fprintf (stderr, "%s\\n", msg); |
| | 321 | } |
| | 322 | |
| | 323 | int |
| | 324 | main (void) |
| | 325 | { |
| | 326 | yydebug = !!getenv ("YYDEBUG"); |
| | 327 | return yyparse (); |
| | 328 | } |
| | 329 | EOF |
| | 330 | } |
| | 331 | |
| | 332 | ################################################################## |
| | 333 | |
| | 334 | =item C<calc_input ($base, $max)> |
| | 335 | |
| | 336 | Generate the input file F<$base.input> for the calc parser. The input |
| | 337 | is composed of two expressions. The first one is using left recursion |
| | 338 | only and consumes no stack. The second one requires a deep stack. |
| | 339 | These two expressions are repeated C<$max> times in the output file. |
| | 340 | |
| | 341 | =cut |
| | 342 | |
| | 343 | sub calc_input ($$) |
| | 344 | { |
| | 345 | my ($base, $max) = @_; |
| | 346 | my $out = new IO::File ">$base.input" |
| | 347 | or die; |
| | 348 | foreach (1 .. $max) |
| | 349 | { |
| | 350 | print $out "0+1+2+3+4+5+6+7+8+9+10+11+12+13+14+15+16+17+18+19+20+21+22+23+24+25+26+27+28+29+30+31+32+33+34+35+36+37+38+39+40+41+42+43+44+45+46+47+48+49+50+51+52+53+54+55+56+57+58+59+60+61+62+63+64+65+66+67+68+69+70+71+72+73+74+75+76+77+78+79+80+81+82+83+84+85+86+87+88+89+90+91+92+93+94+95+96+97+98+99\n"; |
| | 351 | print $out "1+1*(2+2*(3+3*(4+4*(5+5*(6+6*(7+7*(8+8*(9+9*(10+10*(11+11*(12+12*(13+13*(14+14*(15+15*(16+16*(17+17*(18+18*(19+19*(20+20*(21+21*(22+22*(23+23*(24+24*(25+25*(26+26*(27+27*(28+28*(29+29*(30+30*(31+31*(32+32*(33+33*(34+34*(35+35*(36+36*(37+37*(38+38*(39+39*(40+40*(41+41*(42+42*(43+43*(44+44*(45+45*(46+46*(47+47*(48+48*(49+49*(50+50*(51+51*(52+52*(53+53*(54+54*(55+55*(56+56*(57+57*(58+58*(59+59*(60+60*(61+61*(62+62*(63+63*(64+64*(65+65*(66+66*(67+67*(68+68*(69+69*(70+70*(71+71*(72+72*(73+73*(74+74*(75+75*(76+76*(77+77*(78+78*(79+79*(80+80*(81+81*(82+82*(83+83*(84+84*(85+85*(86+86*(87+87*(88+88*(89+89*(90+90*(91+91*(92+92*(93+93*(94+94*(95+95*(96+96*(97+97*(98+98*(99+99*(100+100*(101+101*(102+102*(103+103*(104+104*(105+105*(106+106*(107+107*(108+108*(109+109*(110+110*(111+111*(112+112*(113+113*(114+114*(115+115*(116+116*(117+117*(118+118*(119+119*(120+120*(121+121*(122+122*(123+123*(124+124*(125+125*(126+126*(127+127*(128+128*(129+129*(130+130*(131+131*(132+132*(133+133*(134+134*(135+135*(136+136*(137+137*(138+138*(139+139*(140+140*(141+141*(142+142*(143+143*(144+144*(145+145*(146+146*(147+147*(148+148*(149+149*(150+150*(151+151*(152+152*(153+153*(154+154*(155+155*(156+156*(157+157*(158+158*(159+159*(160+160*(161+161*(162+162*(163+163*(164+164*(165+165*(166+166*(167+167*(168+168*(169+169*(170+170*(171+171*(172+172*(173+173*(174+174*(175+175*(176+176*(177+177*(178+178*(179+179*(180+180*(181+181*(182+182*(183+183*(184+184*(185+185*(186+186*(187+187*(188+188*(189+189*(190+190*(191+191*(192+192*(193+193*(194+194*(195+195*(196+196*(197+197*(198+198*(199+199*(200+200*(201+201*(202+202*(203+203*(204+204*(205+205*(206+206*(207+207*(208+208*(209+209*(210+210*(211+211*(212+212*(213+213*(214+214*(215+215*(216+216*(217+217*(218+218*(219+219*(220+220*(221+221*(222+222*(223+223*(224+224*(225+225*(226+226*(227+227*(228+228*(229+229*(230+230*(231+231*(232+232*(233+233*(234+234*(235+235*(236+236*(237+237*(238+238*(239+239*(240+240*(241+241*(242+242*(243+243*(244+244*(245+245*(246+246*(247+247*(248+248*(249+249*(250+250*(251+251*(252+252*(253+253*(254+254*(255+255*(256+256*(257+257*(258+258*(259+259*(260+260*(261+261*(262+262*(263+263*(264+264*(265+265*(266+266*(267+267*(268+268*(269+269*(270+270*(271+271*(272+272*(273+273*(274+274*(275+275*(276+276*(277+277*(278+278*(279+279*(280+280*(281+281*(282+282*(283+283*(284+284*(285+285*(286+286*(287+287*(288+288*(289+289*(290+290*(291+291*(292+292*(293+293*(294+294*(295+295*(296+296*(297+297*(298+298*(299+299*(300+300*(301+301*(302+302*(303+303*(304+304*(305+305*(306+306*(307+307*(308+308*(309+309*(310+310*(311+311*(312+312*(313+313*(314+314*(315+315*(316+316*(317+317*(318+318*(319+319*(320+320*(321+321*(322+322*(323+323*(324+324*(325+325*(326+326*(327+327*(328+328*(329+329*(330+330*(331+331*(332+332*(333+333*(334+334*(335+335*(336+336*(337+337*(338+338*(339+339*(340+340*(341+341*(342+342*(343+343*(344+344*(345+345*(346+346*(347+347*(348+348*(349+349*(350+350*(351+351*(352+352*(353+353*(354+354*(355+355*(356+356*(357+357*(358+358*(359+359*(360+360*(361+361*(362+362*(363+363*(364+364*(365+365*(366+366*(367+367*(368+368*(369+369*(370+370*(371+371*(372+372*(373+373*(374+374*(375+375*(376+376*(377+377*(378+378*(379+379*(380+380*(381+381*(382+382*(383+383*(384+384*(385+385*(386+386*(387+387*(388+388*(389+389*(390+390*(391+391*(392+392*(393+393*(394+394*(395+395*(396+396*(397+397*(398+398*(399+399*(400+400*(401+401*(402+402*(403+403*(404+404*(405+405*(406+406*(407+407*(408+408*(409+409*(410+410*(411+411*(412+412*(413+413*(414+414*(415+415*(416+416*(417+417*(418+418*(419+419*(420+420*(421+421*(422+422*(423+423*(424+424*(425+425*(426+426*(427+427*(428+428*(429+429*(430+430*(431+431*(432+432*(433+433*(434+434*(435+435*(436+436*(437+437*(438+438*(439+439*(440+440*(441+441*(442+442*(443+443*(444+444*(445+445*(446+446*(447+447*(448+448*(449+449*(450+450*(451+451*(452+452*(453+453*(454+454*(455+455*(456+456*(457+457*(458+458*(459+459*(460+460*(461+461*(462+462*(463+463*(464+464*(465+465*(466+466*(467+467*(468+468*(469+469*(470+470*(471+471*(472+472*(473+473*(474+474*(475+475*(476+476*(477+477*(478+478*(479+479*(480+480*(481+481*(482+482*(483+483*(484+484*(485+485*(486+486*(487+487*(488+488*(489+489*(490+490*(491+491*(492+492*(493+493*(494+494*(495+495*(496+496*(497+497*(498+498*(499+499*(500+500*(501+501*(502+502*(503+503*(504+504*(505+505*(506+506*(507+507*(508+508*(509+509*(510+510*(511+511*(512+512*(513+513*(514+514*(515+515*(516+516*(517+517*(518+518*(519+519*(520+520*(521+521*(522+522*(523+523*(524+524*(525+525*(526+526*(527+527*(528+528*(529+529*(530+530*(531+531*(532+532*(533+533*(534+534*(535+535*(536+536*(537+537*(538+538*(539+539*(540+540*(541+541*(542+542*(543+543*(544+544*(545+545*(546+546*(547+547*(548+548*(549+549*(550+550*(551+551*(552+552*(553+553*(554+554*(555+555*(556+556*(557+557*(558+558*(559+559*(560+560*(561+561*(562+562*(563+563*(564+564*(565+565*(566+566*(567+567*(568+568*(569+569*(570+570*(571+571*(572+572*(573+573*(574+574*(575+575*(576+576*(577+577*(578+578*(579+579*(580+580*(581+581*(582+582*(583+583*(584+584*(585+585*(586+586*(587+587*(588+588*(589+589*(590+590*(591+591*(592+592*(593+593*(594+594*(595+595*(596+596*(597+597*(598+598*(599+599*(600+600*(601+601*(602+602*(603+603*(604+604*(605+605*(606+606*(607+607*(608+608*(609+609*(610+610*(611+611*(612+612*(613+613*(614+614*(615+615*(616+616*(617+617*(618+618*(619+619*(620+620*(621+621*(622+622*(623+623*(624+624*(625+625*(626+626*(627+627*(628+628*(629+629*(630+630*(631+631*(632+632*(633+633*(634+634*(635+635*(636+636*(637+637*(638+638*(639+639*(640+640*(641+641*(642+642*(643+643*(644+644*(645+645*(646+646*(647+647*(648+648*(649+649*(650+650*(651+651*(652+652*(653+653*(654+654*(655+655*(656+656*(657+657*(658+658*(659+659*(660+660*(661+661*(662+662*(663+663*(664+664*(665+665*(666+666*(667+667*(668+668*(669+669*(670+670*(671+671*(672+672*(673+673*(674+674*(675+675*(676+676*(677+677*(678+678*(679+679*(680+680*(681+681*(682+682*(683+683*(684+684*(685+685*(686+686*(687+687*(688+688*(689+689*(690+690*(691+691*(692+692*(693+693*(694+694*(695+695*(696+696*(697+697*(698+698*(699+699*(700+700*(701+701*(702+702*(703+703*(704+704*(705+705*(706+706*(707+707*(708+708*(709+709*(710+710*(711+711*(712+712*(713+713*(714+714*(715+715*(716+716*(717+717*(718+718*(719+719*(720+720*(721+721*(722+722*(723+723*(724+724*(725+725*(726+726*(727+727*(728+728*(729+729*(730+730*(731+731*(732+732*(733+733*(734+734*(735+735*(736+736*(737+737*(738+738*(739+739*(740+740*(741+741*(742+742*(743+743*(744+744*(745+745*(746+746*(747+747*(748+748*(749+749*(750+750*(751+751*(752+752*(753+753*(754+754*(755+755*(756+756*(757+757*(758+758*(759+759*(760+760*(761+761*(762+762*(763+763*(764+764*(765+765*(766+766*(767+767*(768+768*(769+769*(770+770*(771+771*(772+772*(773+773*(774+774*(775+775*(776+776*(777+777*(778+778*(779+779*(780+780*(781+781*(782+782*(783+783*(784+784*(785+785*(786+786*(787+787*(788+788*(789+789*(790+790*(791+791*(792+792*(793+793*(794+794*(795+795*(796+796*(797+797*(798+798*(799+799*(800+800*(801+801*(802+802*(803+803*(804+804*(805+805*(806+806*(807+807*(808+808*(809+809*(810+810*(811+811*(812+812*(813+813*(814+814*(815+815*(816+816*(817+817*(818+818*(819+819*(820+820*(821+821*(822+822*(823+823*(824+824*(825+825*(826+826*(827+827*(828+828*(829+829*(830+830*(831+831*(832+832*(833+833*(834+834*(835+835*(836+836*(837+837*(838+838*(839+839*(840+840*(841+841*(842+842*(843+843*(844+844*(845+845*(846+846*(847+847*(848+848*(849+849*(850+850*(851+851*(852+852*(853+853*(854+854*(855+855*(856+856*(857+857*(858+858*(859+859*(860+860*(861+861*(862+862*(863+863*(864+864*(865+865*(866+866*(867+867*(868+868*(869+869*(870+870*(871+871*(872+872*(873+873*(874+874*(875+875*(876+876*(877+877*(878+878*(879+879*(880+880*(881+881*(882+882*(883+883*(884+884*(885+885*(886+886*(887+887*(888+888*(889+889*(890+890*(891+891*(892+892*(893+893*(894+894*(895+895*(896+896*(897+897*(898+898*(899+899*(900+900*(901+901*(902+902*(903+903*(904+904*(905+905*(906+906*(907+907*(908+908*(909+909*(910+910*(911+911*(912+912*(913+913*(914+914*(915+915*(916+916*(917+917*(918+918*(919+919*(920+920*(921+921*(922+922*(923+923*(924+924*(925+925*(926+926*(927+927*(928+928*(929+929*(930+930*(931+931*(932+932*(933+933*(934+934*(935+935*(936+936*(937+937*(938+938*(939+939*(940+940*(941+941*(942+942*(943+943*(944+944*(945+945*(946+946*(947+947*(948+948*(949+949*(950+950*(951+951*(952+952*(953+953*(954+954*(955+955*(956+956*(957+957*(958+958*(959+959*(960+960*(961+961*(962+962*(963+963*(964+964*(965+965*(966+966*(967+967*(968+968*(969+969*(970+970*(971+971*(972+972*(973+973*(974+974*(975+975*(976+976*(977+977*(978+978*(979+979*(980+980*(981+981*(982+982*(983+983*(984+984*(985+985*(986+986*(987+987*(988+988*(989+989*(990+990*(991+991*(992+992*(993+993*(994+994*(995+995*(996+996*(997+997*(998+998*(999+999*(1000+1000*(1001))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))\n"; |
| | 352 | } |
| | 353 | } |
| | 354 | |
| | 355 | ################################################################## |
| | 356 | |
| | 357 | =item C<generate_grammar_calc ($base, $max, @directive)> |
| | 358 | |
| | 359 | Generate a Bison file F<$base.y> for a calculator parser in C. Pass |
| | 360 | the additional Bison C<@directive>. C<$max> is ignored, but left to |
| | 361 | have the same interface as C<triangular_grammar>. |
| | 362 | |
| | 363 | =cut |
| | 364 | |
| | 365 | sub generate_grammar_calc ($$@) |
| | 366 | { |
| | 367 | my ($base, $max, @directive) = @_; |
| | 368 | my $directives = directives ($base, @directive); |
| | 369 | |
| | 370 | # Putting this request here is stupid, since the input will be |
| | 371 | # generated each time we generate a grammar. |
| | 372 | calc_input ('calc', 200); |
| | 373 | |
| | 374 | my $out = new IO::File ">$base.y" |
| | 375 | or die; |
| | 376 | print $out <<EOF; |
| | 377 | %{ |
| | 378 | #include <stdio.h> |
| | 379 | |
| | 380 | #include <stdlib.h> |
| | 381 | #include <string.h> |
| | 382 | #include <ctype.h> |
| | 383 | #define USE(Var) |
| | 384 | |
| | 385 | /* Exercise pre-prologue dependency to %union. */ |
| | 386 | typedef int semantic_value; |
| | 387 | |
| | 388 | static semantic_value global_result = 0; |
| | 389 | static int global_count = 0; |
| | 390 | %} |
| | 391 | |
| | 392 | $directives |
| | 393 | %error-verbose |
| | 394 | /* Exercise %union. */ |
| | 395 | %union |
| | 396 | { |
| | 397 | semantic_value ival; |
| | 398 | }; |
| | 399 | |
| | 400 | %{ |
| | 401 | static int power (int base, int exponent); |
| | 402 | /* yyerror receives the location if: |
| | 403 | - %location & %pure & %glr |
| | 404 | - %location & %pure & %yacc & %parse-param. */ |
| | 405 | static void yyerror (const char *s); |
| | 406 | #if YYPURE |
| | 407 | static int yylex (YYSTYPE* yylvalp); |
| | 408 | #else |
| | 409 | static int yylex (void); |
| | 410 | #endif |
| | 411 | %} |
| | 412 | |
| | 413 | /* Bison Declarations */ |
| | 414 | %token CALC_EOF 0 "end of input" |
| | 415 | %token <ival> NUM "number" |
| | 416 | %type <ival> exp |
| | 417 | |
| | 418 | %nonassoc '=' /* comparison */ |
| | 419 | %left '-' '+' |
| | 420 | %left '*' '/' |
| | 421 | %left NEG /* negation--unary minus */ |
| | 422 | %right '^' /* exponentiation */ |
| | 423 | |
| | 424 | /* Grammar follows */ |
| | 425 | %% |
| | 426 | input: |
| | 427 | line |
| | 428 | | input line |
| | 429 | ; |
| | 430 | |
| | 431 | line: |
| | 432 | '\\n' |
| | 433 | | exp '\\n' { USE (\$1); } |
| | 434 | ; |
| | 435 | |
| | 436 | exp: |
| | 437 | NUM { \$\$ = \$1; } |
| | 438 | | exp '=' exp |
| | 439 | { |
| | 440 | if (\$1 != \$3) |
| | 441 | fprintf (stderr, "calc: error: %d != %d\\n", \$1, \$3); |
| | 442 | \$\$ = \$1; |
| | 443 | } |
| | 444 | | exp '+' exp { \$\$ = \$1 + \$3; } |
| | 445 | | exp '-' exp { \$\$ = \$1 - \$3; } |
| | 446 | | exp '*' exp { \$\$ = \$1 * \$3; } |
| | 447 | | exp '/' exp { \$\$ = \$1 / \$3; } |
| | 448 | | '-' exp %prec NEG { \$\$ = -\$2; } |
| | 449 | | exp '^' exp { \$\$ = power (\$1, \$3); } |
| | 450 | | '(' exp ')' { \$\$ = \$2; } |
| | 451 | | '(' error ')' { \$\$ = 1111; } |
| | 452 | | '!' { \$\$ = 0; YYERROR; } |
| | 453 | | '-' error { \$\$ = 0; YYERROR; } |
| | 454 | ; |
| | 455 | %% |
| | 456 | /* The input. */ |
| | 457 | static FILE *input; |
| | 458 | |
| | 459 | static void |
| | 460 | yyerror (const char *s) |
| | 461 | { |
| | 462 | fprintf (stderr, "%s\\n", s); |
| | 463 | } |
| | 464 | |
| | 465 | static int |
| | 466 | get_char (void) |
| | 467 | { |
| | 468 | return getc (input); |
| | 469 | } |
| | 470 | |
| | 471 | |
| | 472 | static void |
| | 473 | unget_char ( int c) |
| | 474 | { |
| | 475 | ungetc (c, input); |
| | 476 | } |
| | 477 | |
| | 478 | static int |
| | 479 | read_signed_integer (void) |
| | 480 | { |
| | 481 | int c = get_char (); |
| | 482 | int sign = 1; |
| | 483 | int n = 0; |
| | 484 | |
| | 485 | if (c == '-') |
| | 486 | { |
| | 487 | c = get_char (); |
| | 488 | sign = -1; |
| | 489 | } |
| | 490 | |
| | 491 | while (isdigit (c)) |
| | 492 | { |
| | 493 | n = 10 * n + (c - '0'); |
| | 494 | c = get_char (); |
| | 495 | } |
| | 496 | |
| | 497 | unget_char (c); |
| | 498 | |
| | 499 | return sign * n; |
| | 500 | } |
| | 501 | |
| | 502 | static int |
| | 503 | #if YYPURE |
| | 504 | # define yylval (*yylvalp) |
| | 505 | yylex (YYSTYPE* yylvalp) |
| | 506 | #else |
| | 507 | yylex (void) |
| | 508 | #endif |
| | 509 | { |
| | 510 | int c; |
| | 511 | |
| | 512 | /* Skip white space. */ |
| | 513 | while ((c = get_char ()) == ' ' || c == '\t') |
| | 514 | continue; |
| | 515 | |
| | 516 | /* process numbers */ |
| | 517 | if (c == '.' || isdigit (c)) |
| | 518 | { |
| | 519 | unget_char ( c); |
| | 520 | yylval.ival = read_signed_integer (); |
| | 521 | return NUM; |
| | 522 | } |
| | 523 | |
| | 524 | /* Return end-of-file. */ |
| | 525 | if (c == EOF) |
| | 526 | return CALC_EOF; |
| | 527 | |
| | 528 | /* Return single chars. */ |
| | 529 | return c; |
| | 530 | } |
| | 531 | |
| | 532 | static int |
| | 533 | power (int base, int exponent) |
| | 534 | { |
| | 535 | int res = 1; |
| | 536 | if (exponent < 0) |
| | 537 | exit (3); |
| | 538 | for (/* Niente */; exponent; --exponent) |
| | 539 | res *= base; |
| | 540 | return res; |
| | 541 | } |
| | 542 | |
| | 543 | |
| | 544 | int |
| | 545 | main (int argc, const char **argv) |
| | 546 | { |
| | 547 | semantic_value result = 0; |
| | 548 | int count = 0; |
| | 549 | int status; |
| | 550 | |
| | 551 | input = fopen ("calc.input", "r"); |
| | 552 | if (!input) |
| | 553 | { |
| | 554 | perror ("calc.input"); |
| | 555 | return 3; |
| | 556 | } |
| | 557 | |
| | 558 | status = yyparse (); |
| | 559 | if (global_result != result) |
| | 560 | abort (); |
| | 561 | if (global_count != count) |
| | 562 | abort (); |
| | 563 | |
| | 564 | return status; |
| | 565 | } |
| | 566 | EOF |
| | 567 | } |
| | 568 | |
| | 569 | ################################################################## |
| | 570 | |
| | 571 | =item C<generate_grammar_list ($base, $max, @directive)> |
| | 572 | |
| | 573 | Generate a Bison file F<$base.y> for a C++ parser that uses C++ |
| | 574 | objects (std::string, std::list). Tailored for using %define variant. |
| | 575 | |
| | 576 | =cut |
| | 577 | |
| | 578 | sub generate_grammar_list ($$@) |
| | 579 | { |
| | 580 | my ($base, $max, @directive) = @_; |
| | 581 | my $directives = directives ($base, @directive); |
| | 582 | my $variant = grep { /%define "?variant"?/ } @directive; |
| | 583 | my $out = new IO::File ">$base.y" |
| | 584 | or die; |
| | 585 | print $out <<EOF; |
| | 586 | %language "C++" |
| | 587 | %defines |
| | 588 | $directives |
| | 589 | |
| | 590 | %code requires // *.h |
| | 591 | { |
| | 592 | #include <string> |
| | 593 | } |
| | 594 | |
| | 595 | %code // *.c |
| | 596 | { |
| | 597 | #include <algorithm> |
| | 598 | #include <iostream> |
| | 599 | #include <sstream> |
| | 600 | |
| | 601 | // Prototype of the yylex function providing subsequent tokens. |
| | 602 | static yy::parser::token_type yylex(yy::parser::semantic_type* yylval); |
| | 603 | |
| | 604 | #define STAGE_MAX ($max * 10) // max = $max |
| | 605 | |
| | 606 | #define USE_VARIANTS $variant |
| | 607 | #if USE_VARIANTS |
| | 608 | # define IF_VARIANTS(True, False) True |
| | 609 | #else |
| | 610 | # define IF_VARIANTS(True, False) False |
| | 611 | #endif |
| | 612 | |
| | 613 | #ifdef ONE_STAGE_BUILD |
| | 614 | # define IF_ONE_STAGE_BUILD(True, False) True |
| | 615 | #else |
| | 616 | # define IF_ONE_STAGE_BUILD(True, False) False |
| | 617 | #endif |
| | 618 | } |
| | 619 | EOF |
| | 620 | |
| | 621 | if ($variant) |
| | 622 | { |
| | 623 | print $out <<'EOF'; |
| | 624 | %token <std::string> TEXT |
| | 625 | %token <int> NUMBER |
| | 626 | %printer { std::cerr << "Number: " << $$; } <int> |
| | 627 | %printer { std::cerr << "Text: " << $$; } <std::string> |
| | 628 | %token END_OF_FILE 0 |
| | 629 | %type <std::string> text result |
| | 630 | |
| | 631 | %% |
| | 632 | result: |
| | 633 | text { /* Throw away the result. */ } |
| | 634 | ; |
| | 635 | |
| | 636 | text: |
| | 637 | /* nothing */ { /* This will generate an empty string */ } |
| | 638 | | text TEXT { std::swap ($$, $2); } |
| | 639 | | text NUMBER { |
| | 640 | std::ostringstream ss; |
| | 641 | ss << ' ' << $2; |
| | 642 | $$ = ss.str(); |
| | 643 | } |
| | 644 | ; |
| | 645 | EOF |
| | 646 | } |
| | 647 | else |
| | 648 | { |
| | 649 | # Not using Bison variants. |
| | 650 | print $out <<'EOF'; |
| | 651 | %union {int ival; std::string* sval;} |
| | 652 | %token <sval> TEXT |
| | 653 | %token <ival> NUMBER |
| | 654 | %printer { std::cerr << "Number: " << $$; } <ival> |
| | 655 | %printer { std::cerr << "Text: " << *$$; } <sval> |
| | 656 | %token END_OF_FILE 0 |
| | 657 | %type <sval> text result |
| | 658 | |
| | 659 | %% |
| | 660 | result: |
| | 661 | text { delete $1; } |
| | 662 | ; |
| | 663 | |
| | 664 | text: |
| | 665 | /* nothing */ { $$ = new std::string; } |
| | 666 | | text TEXT { delete $1; $$ = $2; } |
| | 667 | | text NUMBER { |
| | 668 | delete $1; |
| | 669 | std::ostringstream ss; |
| | 670 | ss << ' ' << $2; |
| | 671 | $$ = new std::string (ss.str()); |
| | 672 | } |
| | 673 | ; |
| | 674 | EOF |
| | 675 | } |
| | 676 | |
| | 677 | print $out <<'EOF'; |
| | 678 | %% |
| | 679 | static |
| | 680 | yy::parser::token_type |
| | 681 | yylex(yy::parser::semantic_type* yylval) |
| | 682 | { |
| | 683 | static int stage = -1; |
| | 684 | ++stage; |
| | 685 | if (stage == STAGE_MAX) |
| | 686 | return yy::parser::token::END_OF_FILE; |
| | 687 | else if (stage % 2) |
| | 688 | { |
| | 689 | #if USE_VARIANTS |
| | 690 | # ifdef ONE_STAGE_BUILD |
| | 691 | yylval->build(stage); |
| | 692 | # else |
| | 693 | yylval->build<int>() = stage; |
| | 694 | # endif |
| | 695 | #else |
| | 696 | yylval->ival = stage; |
| | 697 | #endif |
| | 698 | return yy::parser::token::NUMBER; |
| | 699 | } |
| | 700 | else |
| | 701 | { |
| | 702 | #if USE_VARIANTS |
| | 703 | # ifdef ONE_STAGE_BUILD |
| | 704 | yylval->build(std::string("A string.")); |
| | 705 | # else |
| | 706 | yylval->build<std::string>() = std::string("A string."); |
| | 707 | # endif |
| | 708 | #else |
| | 709 | yylval->sval = new std::string("A string."); |
| | 710 | #endif |
| | 711 | return yy::parser::token::TEXT; |
| | 712 | } |
| | 713 | abort(); |
| | 714 | } |
| | 715 | |
| | 716 | // Mandatory error function |
| | 717 | void |
| | 718 | yy::parser::error(const yy::parser::location_type& yylloc, |
| | 719 | const std::string& message) |
| | 720 | { |
| | 721 | std::cerr << yylloc << ": " << message << std::endl; |
| | 722 | } |
| | 723 | |
| | 724 | int main(int argc, char *argv[]) |
| | 725 | { |
| | 726 | yy::parser p; |
| | 727 | #if YYDEBUG |
| | 728 | p.set_debug_level(!!getenv("YYDEBUG")); |
| | 729 | #endif |
| | 730 | p.parse(); |
| | 731 | return 0; |
| | 732 | } |
| | 733 | EOF |
| | 734 | } |
| | 735 | |
| | 736 | ################################################################## |
| | 737 | |
| | 738 | =item C<generate_grammar ($name, $base, @directive)> |
| | 739 | |
| | 740 | Generate F<$base.y> by calling C<&generate_grammar_$name>. |
| | 741 | |
| | 742 | =cut |
| | 743 | |
| | 744 | sub generate_grammar ($$@) |
| | 745 | { |
| | 746 | my ($name, $base, @directive) = @_; |
| | 747 | verbose 3, "Generating $base.y\n"; |
| | 748 | my %generator = |
| | 749 | ( |
| | 750 | "calc" => \&generate_grammar_calc, |
| | 751 | "list" => \&generate_grammar_list, |
| | 752 | "triangular" => \&generate_grammar_triangular, |
| | 753 | ); |
| | 754 | &{$generator{$name}}($base, 200, @directive); |
| | 755 | } |
| | 756 | |
| | 757 | ################################################################## |
| | 758 | |
| | 759 | =item C<run ($command)> |
| | 760 | |
| | 761 | Run, possibly verbosely, the shell C<$command>. |
| | 762 | |
| | 763 | =cut |
| | 764 | |
| | 765 | sub run ($) |
| | 766 | { |
| | 767 | my ($command) = @_; |
| | 768 | verbose 3, "$command\n"; |
| | 769 | system ("$command") == 0 |
| | 770 | or die "$command failed"; |
| | 771 | } |
| | 772 | |
| | 773 | ################################################################## |
| | 774 | |
| | 775 | =item C<compile ($base)> |
| | 776 | |
| | 777 | Compile C<$base.y> to an executable C, Using the C or C++ compiler |
| | 778 | depending on the %language specification in C<$base.y>. |
| | 779 | |
| | 780 | =cut |
| | 781 | |
| | 782 | sub compile ($) |
| | 783 | { |
| | 784 | my ($base) = @_; |
| | 785 | my $language = `sed -ne '/%language "\\(.*\\)"/{s//\\1/;p;q;}' $base.y`; |
| | 786 | chomp $language; |
| | 787 | |
| | 788 | my $compiler = $language eq 'C++' ? $cxx : $cc; |
| | 789 | |
| | 790 | run "$bison $base.y -o $base.c"; |
| | 791 | run "$compiler -o $base $cflags $base.c"; |
| | 792 | } |
| | 793 | |
| | 794 | ###################################################################### |
| | 795 | |
| | 796 | =item C<bench ($grammar, @token)> |
| | 797 | |
| | 798 | Generate benches for the C<$grammar> and the directive specification |
| | 799 | given in the list of C<@token>. |
| | 800 | |
| | 801 | =cut |
| | 802 | |
| | 803 | sub bench ($@) |
| | 804 | { |
| | 805 | my ($grammar, @token) = @_; |
| | 806 | use Benchmark qw (:all :hireswallclock); |
| | 807 | |
| | 808 | my @directive = parse (@token); |
| | 809 | |
| | 810 | # Set up the benches as expected by timethese. |
| | 811 | my %bench; |
| | 812 | # A counter of directive sets. |
| | 813 | my $count = 1; |
| | 814 | for my $d (@directive) |
| | 815 | { |
| | 816 | $bench{$count} = $d; |
| | 817 | printf " %2d. %s\n", $count, join (' ', split ("\n", $d)); |
| | 818 | $count++; |
| | 819 | }; |
| | 820 | |
| | 821 | # For each bench, capture the size. |
| | 822 | my %size; |
| | 823 | |
| | 824 | while (my ($name, $directives) = each %bench) |
| | 825 | { |
| | 826 | generate_grammar ($grammar, $name, $directives); |
| | 827 | # Compile the executable. |
| | 828 | compile ($name); |
| | 829 | $bench{$name} = "system ('./$name');"; |
| | 830 | chop($size{$name} = `wc -c <$name`); |
| | 831 | } |
| | 832 | |
| | 833 | # Run the benches. |
| | 834 | # |
| | 835 | # STYLE can be any of 'all', 'none', 'noc', 'nop' or 'auto'. 'all' |
| | 836 | # shows each of the 5 times available ('wallclock' time, user time, |
| | 837 | # system time, user time of children, and system time of |
| | 838 | # children). 'noc' shows all except the two children times. 'nop' |
| | 839 | # shows only wallclock and the two children times. 'auto' (the |
| | 840 | # default) will act as 'all' unless the children times are both |
| | 841 | # zero, in which case it acts as 'noc'. 'none' prevents output. |
| | 842 | verbose 3, "Running the benches for $grammar\n"; |
| | 843 | my $res = timethese ($iterations, \%bench, 'nop'); |
| | 844 | |
| | 845 | # Output the speed result. |
| | 846 | cmpthese ($res, 'nop'); |
| | 847 | |
| | 848 | # Display the sizes. |
| | 849 | print "Sizes (decreasing):\n"; |
| | 850 | my $width = 10; |
| | 851 | for my $bench (keys %size) |
| | 852 | { |
| | 853 | $width = length $bench |
| | 854 | if $width < length $bench; |
| | 855 | } |
| | 856 | # Benches sorted by decreasing size. |
| | 857 | my @benches_per_size = sort {$size{$b} <=> $size{$a}} keys %size; |
| | 858 | for my $bench (@benches_per_size) |
| | 859 | { |
| | 860 | printf "%${width}s: %5.2fkB\n", $bench, $size{$bench} / 1024; |
| | 861 | } |
| | 862 | } |
| | 863 | |
| | 864 | ###################################################################### |
| | 865 | |
| | 866 | =item C<bench_push_parser ()> |
| | 867 | |
| | 868 | Bench the C push parser against the pull parser, pure and impure |
| | 869 | interfaces. |
| | 870 | |
| | 871 | =cut |
| | 872 | |
| | 873 | sub bench_push_parser () |
| | 874 | { |
| | 875 | bench ('calc', |
| | 876 | qw( |
| | 877 | [ %d api.pure ] |
| | 878 | & |
| | 879 | [ %d api.push_pull=both ] |
| | 880 | )); |
| | 881 | } |
| | 882 | |
| | 883 | ###################################################################### |
| | 884 | |
| | 885 | =item C<bench_variant_parser ()> |
| | 886 | |
| | 887 | Bench the C++ lalr1.cc parser using Boost.Variants or %union. |
| | 888 | |
| | 889 | =cut |
| | 890 | |
| | 891 | sub bench_variant_parser () |
| | 892 | { |
| | 893 | bench ('list', |
| | 894 | qw( |
| | 895 | [ %debug ] |
| | 896 | & |
| | 897 | [ %d variant |
| | 898 | & |
| | 899 | [ #d VARIANT_DESTROY ] |
| | 900 | & |
| | 901 | [ #d ONE_STAGE_BUILD ] |
| | 902 | ] |
| | 903 | ) |
| | 904 | ); |
| | 905 | } |
| | 906 | |
| | 907 | ###################################################################### |
| | 908 | |
| | 909 | =item C<bench_fusion_parser ()> |
| | 910 | |
| | 911 | Bench the C++ lalr1.cc parser using Boost.Variants or %union. |
| | 912 | |
| | 913 | =cut |
| | 914 | |
| | 915 | sub bench_fusion_parser () |
| | 916 | { |
| | 917 | bench ('list', |
| | 918 | qw( |
| | 919 | %s lalr1-split.cc |
| | 920 | | |
| | 921 | %s lalr1.cc |
| | 922 | ) |
| | 923 | ); |
| | 924 | } |
| | 925 | |
| | 926 | ############################################################################ |
| | 927 | |
| | 928 | sub help ($) |
| | 929 | { |
| | 930 | my ($verbose) = @_; |
| | 931 | use Pod::Usage; |
| | 932 | # See <URL:http://perldoc.perl.org/pod2man.html#NOTES>. |
| | 933 | pod2usage( { -message => "Bench Bison parsers", |
| | 934 | -exitval => 0, |
| | 935 | -verbose => $verbose, |
| | 936 | -output => \*STDOUT }); |
| | 937 | } |
| | 938 | |
| | 939 | ###################################################################### |
| | 940 | |
| | 941 | # The end of the directives to parse. |
| | 942 | my $eod = "end of directives"; |
| | 943 | # The list of tokens parsed by the following functions. |
| | 944 | my @token; |
| | 945 | |
| | 946 | # eat ($EXPECTED) |
| | 947 | # --------------- |
| | 948 | # Check that the current token is $EXPECTED, and move to the next. |
| | 949 | sub eat ($) |
| | 950 | { |
| | 951 | my ($expected) = @_; |
| | 952 | die "expected $expected, unexpected: $token[0] (@token)\n" |
| | 953 | unless $token[0] eq $expected; |
| | 954 | shift @token; |
| | 955 | } |
| | 956 | |
| | 957 | # Parse directive specifications: |
| | 958 | # expr: term (| term)* |
| | 959 | # term: fact (& fact)* |
| | 960 | # fact: ( expr ) | [ expr ] | dirs |
| | 961 | # dirs: %s SKELETON | #d NAME[=VALUE] | %d NAME[=VALUE] | directive |
| | 962 | sub parse (@) |
| | 963 | { |
| | 964 | @token = (@_, $eod); |
| | 965 | verbose 3, "Parsing: @token\n"; |
| | 966 | my @res = parse_expr (); |
| | 967 | eat ($eod); |
| | 968 | return @res; |
| | 969 | } |
| | 970 | |
| | 971 | sub parse_expr () |
| | 972 | { |
| | 973 | my @res = parse_term (); |
| | 974 | while ($token[0] eq '|') |
| | 975 | { |
| | 976 | eat ('|'); |
| | 977 | # Alternation. |
| | 978 | push @res, parse_term (); |
| | 979 | } |
| | 980 | return @res; |
| | 981 | } |
| | 982 | |
| | 983 | sub parse_term () |
| | 984 | { |
| | 985 | my @res = parse_fact (); |
| | 986 | while ($token[0] eq '&') |
| | 987 | { |
| | 988 | eat ('&'); |
| | 989 | # Cartesian product. |
| | 990 | my @lhs = @res; |
| | 991 | @res = (); |
| | 992 | for my $rhs (parse_fact ()) |
| | 993 | { |
| | 994 | for my $lhs (@lhs) |
| | 995 | { |
| | 996 | push @res, "$lhs\n$rhs"; |
| | 997 | } |
| | 998 | } |
| | 999 | } |
| | 1000 | return @res; |
| | 1001 | } |
| | 1002 | |
| | 1003 | sub parse_fact () |
| | 1004 | { |
| | 1005 | my @res; |
| | 1006 | die "unexpected end of expression" |
| | 1007 | unless defined $token[0]; |
| | 1008 | |
| | 1009 | if ($token[0] eq '(') |
| | 1010 | { |
| | 1011 | eat ('('); |
| | 1012 | @res = parse_expr (); |
| | 1013 | eat (')'); |
| | 1014 | } |
| | 1015 | elsif ($token[0] eq '[') |
| | 1016 | { |
| | 1017 | eat ('['); |
| | 1018 | @res = (parse_expr (), ''); |
| | 1019 | eat (']'); |
| | 1020 | } |
| | 1021 | else |
| | 1022 | { |
| | 1023 | @res = parse_dirs (); |
| | 1024 | } |
| | 1025 | return @res; |
| | 1026 | } |
| | 1027 | |
| | 1028 | sub parse_dirs () |
| | 1029 | { |
| | 1030 | my @res; |
| | 1031 | die "unexpected end of expression" |
| | 1032 | unless defined $token[0]; |
| | 1033 | |
| | 1034 | if ($token[0] eq '#d') |
| | 1035 | { |
| | 1036 | eat ('#d'); |
| | 1037 | $token[0] =~ s/(.*?)=(.*)/$1 $2/; |
| | 1038 | @res = ("%code {\n#define $token[0]\n}"); |
| | 1039 | shift @token; |
| | 1040 | } |
| | 1041 | elsif ($token[0] eq '%d') |
| | 1042 | { |
| | 1043 | shift @token; |
| | 1044 | $token[0] =~ s/(.*?)=(.*)/$1 "$2"/; |
| | 1045 | @res = ("%define $token[0]"); |
| | 1046 | shift @token; |
| | 1047 | } |
| | 1048 | elsif ($token[0] eq '%s') |
| | 1049 | { |
| | 1050 | shift @token; |
| | 1051 | @res = ("%skeleton \"$token[0]\""); |
| | 1052 | shift @token; |
| | 1053 | } |
| | 1054 | else |
| | 1055 | { |
| | 1056 | @res = $token[0]; |
| | 1057 | shift @token; |
| | 1058 | } |
| | 1059 | |
| | 1060 | return @res; |
| | 1061 | } |
| | 1062 | |
| | 1063 | ###################################################################### |
| | 1064 | |
| | 1065 | sub getopt () |
| | 1066 | { |
| | 1067 | use Getopt::Long; |
| | 1068 | my %option = ( |
| | 1069 | "b|bench=s" => \$bench, |
| | 1070 | "c|cflags=s" => \$cflags, |
| | 1071 | "d|directive=s" => \@directive, |
| | 1072 | "g|grammar=s" => \$grammar, |
| | 1073 | "h|help" => sub { help ($verbose) }, |
| | 1074 | "i|iterations=i" => \$iterations, |
| | 1075 | "q|quiet" => sub { --$verbose }, |
| | 1076 | "v|verbose" => sub { ++$verbose }, |
| | 1077 | ); |
| | 1078 | Getopt::Long::Configure ("bundling", "pass_through"); |
| | 1079 | GetOptions (%option) |
| | 1080 | or exit 1; |
| | 1081 | } |
| | 1082 | |
| | 1083 | ###################################################################### |
| | 1084 | |
| | 1085 | getopt; |
| | 1086 | |
| | 1087 | # Create the directory we work in. |
| | 1088 | mkdir "benches" or die "cannot create benches" |
| | 1089 | unless -d "benches"; |
| | 1090 | my $count = 1; |
| | 1091 | ++$count |
| | 1092 | while -d "benches/$count"; |
| | 1093 | my $dir = "benches/$count"; |
| | 1094 | mkdir $dir |
| | 1095 | or die "cannot create $dir"; |
| | 1096 | chdir $dir |
| | 1097 | or die "cannot chdir $dir"; |
| | 1098 | |
| | 1099 | # The following message is tailored to please Emacs' compilation-mode. |
| | 1100 | verbose 1, "Entering directory `$dir'\n"; |
| | 1101 | verbose 1, "Using bison=$bison.\n"; |
| | 1102 | verbose 2, "Using cc=$cc.\n"; |
| | 1103 | verbose 2, "Using cxx=$cxx.\n"; |
| | 1104 | verbose 2, "Using cflags=$cflags.\n"; |
| | 1105 | verbose 2, "Grammar: $grammar\n"; |
| | 1106 | |
| | 1107 | |
| | 1108 | # Support -b: predefined benches. |
| | 1109 | my %bench = |
| | 1110 | ( |
| | 1111 | "fusion" => \&bench_fusion_parser, |
| | 1112 | "push" => \&bench_push_parser, |
| | 1113 | "variant" => \&bench_variant_parser, |
| | 1114 | ); |
| | 1115 | |
| | 1116 | if (defined $bench) |
| | 1117 | { |
| | 1118 | die "invalid argument for --bench: $bench" |
| | 1119 | unless defined $bench{$bench}; |
| | 1120 | &{$bench{$bench}}(); |
| | 1121 | exit 0; |
| | 1122 | } |
| | 1123 | else |
| | 1124 | { |
| | 1125 | # Launch the bench marking. |
| | 1126 | bench ($grammar, @ARGV); |
| | 1127 | } |
| | 1128 | |
| | 1129 | ### Setup "GNU" style for perl-mode and cperl-mode. |
| | 1130 | ## Local Variables: |
| | 1131 | ## perl-indent-level: 2 |
| | 1132 | ## perl-continued-statement-offset: 2 |
| | 1133 | ## perl-continued-brace-offset: 0 |
| | 1134 | ## perl-brace-offset: 0 |
| | 1135 | ## perl-brace-imaginary-offset: 0 |
| | 1136 | ## perl-label-offset: -2 |
| | 1137 | ## cperl-indent-level: 2 |
| | 1138 | ## cperl-brace-offset: 0 |
| | 1139 | ## cperl-continued-brace-offset: 0 |
| | 1140 | ## cperl-label-offset: -2 |
| | 1141 | ## cperl-extra-newline-before-brace: t |
| | 1142 | ## cperl-merge-trailing-else: nil |
| | 1143 | ## cperl-continued-statement-offset: 2 |
| | 1144 | ## End: |
projects / bison.git / blame_incremental