etc/bench.pl.in

   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 $lex_symbol = grep { /%define "?lex_symbol"?/ } @directive;
 584   my $out = new IO::File ">$base.y"
 585     or die;
 586   print $out <<EOF;
 587 %language "C++"
 588 %defines
 589 %locations
 590 $directives
 591
 592 %code requires // *.h
 593 {
 594 #include <string>
 595 }
 596
 597 %code // *.c
 598 {
 599 #include <algorithm>
 600 #include <iostream>
 601 #include <sstream>
 602
 603 #define STAGE_MAX    ($max * 10) // max = $max
 604
 605 #define USE_LEX_SYMBOL $lex_symbol
 606 #define USE_VARIANTS $variant
 607
 608   // Prototype of the yylex function providing subsequent tokens.
 609   static
 610 #if USE_LEX_SYMBOL
 611   yy::parser::symbol_type yylex();
 612 #else
 613   yy::parser::token_type yylex(yy::parser::semantic_type* yylval,
 614                                yy::parser::location_type* yylloc);
 615 #endif
 616
 617   // Conversion to string.
 618   template <typename T>
 619     inline
 620     std::string
 621     string_cast (const T& t)
 622   {
 623     std::ostringstream o;
 624     o << t;
 625     return o.str ();
 626   }
 627 }
 628
 629 %token END_OF_FILE 0
 630 EOF
 631
 632   if ($variant)
 633     {
 634       print $out <<'EOF';
 635 %token <std::string> TEXT
 636 %token <int> NUMBER
 637 %printer { std::cerr << "Number: " << $$; } <int>
 638 %printer { std::cerr << "Text: " << $$; } <std::string>
 639 %type <std::string> text result
 640
 641 %%
 642 result:
 643   text                  { /* Throw away the result. */ }
 644 ;
 645
 646 text:
 647   /* nothing */         { /* This will generate an empty string */ }
 648 | text TEXT             { std::swap ($$, $2); }
 649 | text NUMBER           { $$ = string_cast($2); }
 650 ;
 651 EOF
 652     }
 653   else
 654     {
 655       # Not using Bison variants.
 656       print $out <<'EOF';
 657 %union {int ival; std::string* sval;}
 658 %token <sval> TEXT
 659 %token <ival> NUMBER
 660 %printer { std::cerr << "Number: " << $$; } <ival>
 661 %printer { std::cerr << "Text: " << *$$; } <sval>
 662 %type <sval> text result
 663
 664 %%
 665 result:
 666   text                  { delete $1; }
 667 ;
 668
 669 text:
 670   /* nothing */         { $$ = new std::string; }
 671 | text TEXT             { delete $1; $$ = $2; }
 672 | text NUMBER           { delete $1; $$ = new std::string (string_cast ($2)); }
 673 ;
 674 EOF
 675     }
 676
 677   print $out <<'EOF';
 678 %%
 679 #
 680
 681 static
 682 #if USE_LEX_SYMBOL
 683 yy::parser::symbol_type yylex()
 684 #else
 685 yy::parser::token_type yylex(yy::parser::semantic_type* yylval,
 686                              yy::parser::location_type* yylloc)
 687 #endif
 688 {
 689   typedef yy::parser::token token;
 690   static int stage = -1;
 691   ++stage;
 692   if (stage == STAGE_MAX)
 693     {
 694 #if USE_LEX_SYMBOL
 695       return yy::parser::make_symbol <token::END_OF_FILE> (yy::location());
 696 #else
 697       *yylloc = yy::location ();
 698       return token::END_OF_FILE;
 699 #endif
 700     }
 701   else if (stage % 2)
 702     {
 703 #if USE_LEX_SYMBOL
 704       return yy::parser::make_symbol <token::NUMBER> (stage, yy::location());
 705 #elif defined ONE_STAGE_BUILD
 706       yylval->build(stage);
 707       *yylloc = yy::location ();
 708       return token::NUMBER;
 709 #elif USE_VARIANTS
 710       yylval->build<int>() = stage;
 711       *yylloc = yy::location ();
 712       return token::NUMBER;
 713 #else
 714       yylval->ival = stage;
 715       *yylloc = yy::location ();
 716       return token::NUMBER;
 717 #endif
 718     }
 719   else
 720     {
 721 #if USE_LEX_SYMBOL
 722       return yy::parser::make_symbol <token::TEXT> ("A string.", yy::location());
 723 #elif defined ONE_STAGE_BUILD
 724       yylval->build(std::string("A string."));
 725       *yylloc = yy::location ();
 726       return token::TEXT;
 727 #elif USE_VARIANTS
 728       yylval->build<std::string>() = std::string("A string.");
 729       *yylloc = yy::location ();
 730       return token::TEXT;
 731 #else
 732       yylval->sval = new std::string("A string.");
 733       *yylloc = yy::location ();
 734       return token::TEXT;
 735 #endif
 736     }
 737   abort();
 738 }
 739
 740 // Mandatory error function
 741 void
 742 yy::parser::error(const yy::parser::location_type& yylloc,
 743                   const std::string& message)
 744 {
 745   std::cerr << yylloc << ": " << message << std::endl;
 746 }
 747
 748 int main(int argc, char *argv[])
 749 {
 750   yy::parser p;
 751 #if YYDEBUG
 752   p.set_debug_level(!!getenv("YYDEBUG"));
 753 #endif
 754   p.parse();
 755   return 0;
 756 }
 757 EOF
 758 }
 759
 760 ##################################################################
 761
 762 =item C<generate_grammar ($name, $base, @directive)>
 763
 764 Generate F<$base.y> by calling C<&generate_grammar_$name>.
 765
 766 =cut
 767
 768 sub generate_grammar ($$@)
 769 {
 770   my ($name, $base, @directive) = @_;
 771   verbose 3, "Generating $base.y\n";
 772   my %generator =
 773     (
 774       "calc"       => \&generate_grammar_calc,
 775       "list"       => \&generate_grammar_list,
 776       "triangular" => \&generate_grammar_triangular,
 777     );
 778   &{$generator{$name}}($base, 200, @directive);
 779 }
 780
 781 ##################################################################
 782
 783 =item C<run ($command)>
 784
 785 Run, possibly verbosely, the shell C<$command>.
 786
 787 =cut
 788
 789 sub run ($)
 790 {
 791   my ($command) = @_;
 792   verbose 3, "$command\n";
 793   system ("$command") == 0
 794     or die "$command failed";
 795 }
 796
 797 ##################################################################
 798
 799 =item C<compile ($base)>
 800
 801 Compile C<$base.y> to an executable C, Using the C or C++ compiler
 802 depending on the %language specification in C<$base.y>.
 803
 804 =cut
 805
 806 sub compile ($)
 807 {
 808   my ($base) = @_;
 809   my $language = `sed -ne '/%language "\\(.*\\)"/{s//\\1/;p;q;}' $base.y`;
 810   chomp $language;
 811
 812   my $compiler = $language eq 'C++' ? $cxx : $cc;
 813
 814   run "$bison $base.y -o $base.c";
 815   run "$compiler -o $base $cflags $base.c";
 816 }
 817
 818 ######################################################################
 819
 820 =item C<bench ($grammar, @token)>
 821
 822 Generate benches for the C<$grammar> and the directive specification
 823 given in the list of C<@token>.
 824
 825 =cut
 826
 827 sub bench ($@)
 828 {
 829   my ($grammar, @token) = @_;
 830   use Benchmark qw (:all :hireswallclock);
 831
 832   my @directive = parse (@token);
 833
 834   # Set up the benches as expected by timethese.
 835   my %bench;
 836   # A counter of directive sets.
 837   my $count = 1;
 838   for my $d (@directive)
 839     {
 840       $bench{$count} = $d;
 841       printf " %2d. %s\n", $count, join (' ', split ("\n", $d));
 842       $count++;
 843     };
 844
 845   # For each bench, capture the size.
 846   my %size;
 847
 848   while (my ($name, $directives) = each %bench)
 849     {
 850       generate_grammar ($grammar, $name, $directives);
 851       # Compile the executable.
 852       compile ($name);
 853       $bench{$name} = "system ('./$name');";
 854       chop($size{$name} = `wc -c <$name`);
 855     }
 856
 857   # Run the benches.
 858   #
 859   # STYLE can be any of 'all', 'none', 'noc', 'nop' or 'auto'.  'all'
 860   # shows each of the 5 times available ('wallclock' time, user time,
 861   # system time, user time of children, and system time of
 862   # children). 'noc' shows all except the two children times. 'nop'
 863   # shows only wallclock and the two children times.  'auto' (the
 864   # default) will act as 'all' unless the children times are both
 865   # zero, in which case it acts as 'noc'.  'none' prevents output.
 866   verbose 3, "Running the benches for $grammar\n";
 867   my $res = timethese ($iterations, \%bench, 'nop');
 868
 869   # Output the speed result.
 870   cmpthese ($res, 'nop');
 871
 872   # Display the sizes.
 873   print "Sizes (decreasing):\n";
 874   my $width = 10;
 875   for my $bench (keys %size)
 876     {
 877       $width = length $bench
 878         if $width < length $bench;
 879     }
 880   # Benches sorted by decreasing size.
 881   my @benches_per_size = sort {$size{$b} <=> $size{$a}} keys %size;
 882   for my $bench (@benches_per_size)
 883     {
 884       printf "%${width}s: %5.2fkB\n", $bench, $size{$bench} / 1024;
 885     }
 886 }
 887
 888 ######################################################################
 889
 890 =item C<bench_push_parser ()>
 891
 892 Bench the C push parser against the pull parser, pure and impure
 893 interfaces.
 894
 895 =cut
 896
 897 sub bench_push_parser ()
 898 {
 899   bench ('calc',
 900          qw(
 901             [ %d api.pure ]
 902             &
 903             [ %d api.push_pull=both ]
 904          ));
 905 }
 906
 907 ######################################################################
 908
 909 =item C<bench_variant_parser ()>
 910
 911 Bench the C++ lalr1.cc parser using variants or %union.
 912
 913 =cut
 914
 915 sub bench_variant_parser ()
 916 {
 917   bench ('list',
 918          qw(
 919             [
 920               %d variant
 921               &
 922               [ #d ONE_STAGE_BUILD | %d lex_symbol ]
 923             ]
 924          )
 925     );
 926 }
 927
 928 ######################################################################
 929
 930 =item C<bench_fusion_parser ()>
 931
 932 Bench the C++ lalr1.cc parser using Boost.Variants or %union.
 933
 934 =cut
 935
 936 sub bench_fusion_parser ()
 937 {
 938   bench ('list',
 939          qw(
 940              %s lalr1-split.cc
 941            |
 942              %s lalr1.cc
 943          )
 944     );
 945 }
 946
 947 ############################################################################
 948
 949 sub help ($)
 950 {
 951   my ($verbose) = @_;
 952   use Pod::Usage;
 953   # See <URL:http://perldoc.perl.org/pod2man.html#NOTES>.
 954   pod2usage( { -message => "Bench Bison parsers",
 955                -exitval => 0,
 956                -verbose => $verbose,
 957                -output  => \*STDOUT });
 958 }
 959
 960 ######################################################################
 961
 962 # The end of the directives to parse.
 963 my $eod = "end of directives";
 964 # The list of tokens parsed by the following functions.
 965 my @token;
 966
 967 # eat ($EXPECTED)
 968 # ---------------
 969 # Check that the current token is $EXPECTED, and move to the next.
 970 sub eat ($)
 971 {
 972   my ($expected) = @_;
 973   die "expected $expected, unexpected: $token[0] (@token)\n"
 974     unless $token[0] eq $expected;
 975   shift @token;
 976 }
 977
 978 # Parse directive specifications:
 979 #   expr: term (| term)*
 980 #   term: fact (& fact)*
 981 #   fact: ( expr ) | [ expr ] | dirs
 982 #   dirs: %s SKELETON | #d NAME[=VALUE] | %d NAME[=VALUE] | directive
 983 sub parse (@)
 984 {
 985   @token = (@_, $eod);
 986   verbose 3, "Parsing: @token\n";
 987   my @res = parse_expr ();
 988   eat ($eod);
 989   return @res;
 990 }
 991
 992 sub parse_expr ()
 993 {
 994   my @res = parse_term ();
 995   while ($token[0] eq '|')
 996     {
 997       eat ('|');
 998       # Alternation.
 999       push @res, parse_term ();
1000     }
1001   return @res;
1002 }
1003
1004 sub parse_term ()
1005 {
1006   my @res = parse_fact ();
1007   while ($token[0] eq '&')
1008     {
1009       eat ('&');
1010       # Cartesian product.
1011       my @lhs = @res;
1012       @res = ();
1013       for my $rhs (parse_fact ())
1014         {
1015           for my $lhs (@lhs)
1016             {
1017               push @res, $lhs . ($lhs && $rhs ? "\n" : "") . $rhs;
1018             }
1019         }
1020     }
1021   return @res;
1022 }
1023
1024 sub parse_fact ()
1025 {
1026   my @res;
1027   die "unexpected end of expression"
1028     unless defined $token[0];
1029
1030   if ($token[0] eq '(')
1031     {
1032       eat ('(');
1033       @res = parse_expr ();
1034       eat (')');
1035     }
1036   elsif ($token[0] eq '[')
1037     {
1038       eat ('[');
1039       @res = (parse_expr (), '');
1040       eat (']');
1041     }
1042   else
1043     {
1044       @res = parse_dirs ();
1045     }
1046   return @res;
1047 }
1048
1049 sub parse_dirs ()
1050 {
1051   my @res;
1052   die "unexpected end of expression"
1053     unless defined $token[0];
1054
1055   if ($token[0] eq '#d')
1056     {
1057       eat ('#d');
1058       $token[0] =~ s/(.*?)=(.*)/$1 $2/;
1059       @res = ("%code {\n#define $token[0]\n}");
1060       shift @token;
1061     }
1062   elsif ($token[0] eq '%d')
1063     {
1064       shift @token;
1065       $token[0] =~ s/(.*?)=(.*)/$1 "$2"/;
1066       @res = ("%define $token[0]");
1067       shift @token;
1068     }
1069   elsif ($token[0] eq '%s')
1070     {
1071       shift @token;
1072       @res = ("%skeleton \"$token[0]\"");
1073       shift @token;
1074     }
1075   else
1076     {
1077       @res = $token[0];
1078       shift @token;
1079     }
1080
1081   return @res;
1082 }
1083
1084 ######################################################################
1085
1086 sub getopt ()
1087 {
1088   use Getopt::Long;
1089   my %option = (
1090     "b|bench=s"      => \$bench,
1091     "c|cflags=s"     => \$cflags,
1092     "d|directive=s"  => \@directive,
1093     "g|grammar=s"    => \$grammar,
1094     "h|help"         => sub { help ($verbose) },
1095     "i|iterations=i" => \$iterations,
1096     "q|quiet"        => sub { --$verbose },
1097     "v|verbose"      => sub { ++$verbose },
1098     );
1099   Getopt::Long::Configure ("bundling", "pass_through");
1100   GetOptions (%option)
1101     or exit 1;
1102 }
1103
1104 ######################################################################
1105
1106 getopt;
1107
1108 # Create the directory we work in.
1109 mkdir "benches" or die "cannot create benches"
1110   unless -d "benches";
1111 my $count = 1;
1112 ++$count
1113   while -d "benches/$count";
1114 my $dir = "benches/$count";
1115 mkdir $dir
1116   or die "cannot create $dir";
1117 chdir $dir
1118   or die "cannot chdir $dir";
1119
1120 # The following message is tailored to please Emacs' compilation-mode.
1121 verbose 1, "Entering directory `$dir'\n";
1122 verbose 1, "Using bison=$bison.\n";
1123 verbose 2, "Using cc=$cc.\n";
1124 verbose 2, "Using cxx=$cxx.\n";
1125 verbose 2, "Using cflags=$cflags.\n";
1126 verbose 2, "Grammar: $grammar\n";
1127
1128
1129 # Support -b: predefined benches.
1130 my %bench =
1131   (
1132    "fusion"   => \&bench_fusion_parser,
1133    "push"     => \&bench_push_parser,
1134    "variant"  => \&bench_variant_parser,
1135   );
1136
1137 if (defined $bench)
1138 {
1139   die "invalid argument for --bench: $bench"
1140     unless defined $bench{$bench};
1141   &{$bench{$bench}}();
1142   exit 0;
1143 }
1144 else
1145 {
1146   # Launch the bench marking.
1147   bench ($grammar, @ARGV);
1148 }
1149
1150 ### Setup "GNU" style for perl-mode and cperl-mode.
1151 ## Local Variables:
1152 ## perl-indent-level: 2
1153 ## perl-continued-statement-offset: 2
1154 ## perl-continued-brace-offset: 0
1155 ## perl-brace-offset: 0
1156 ## perl-brace-imaginary-offset: 0
1157 ## perl-label-offset: -2
1158 ## cperl-indent-level: 2
1159 ## cperl-brace-offset: 0
1160 ## cperl-continued-brace-offset: 0
1161 ## cperl-label-offset: -2
1162 ## cperl-extra-newline-before-brace: t
1163 ## cperl-merge-trailing-else: nil
1164 ## cperl-continued-statement-offset: 2
1165 ## End: