etc/bench.pl.in

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