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 - perform benches on Bison parsers.
  23
  24 =head1 SYNOPSIS
  25
  26   ./bench.pl
  27
  28 =head1 OPTIONS
  29
  30 =over 4
  31
  32 =item B<-b>, B<--bench>=I<bench-name>
  33
  34 Specify the set of benches to run.  I<bench-name> should be one of:
  35
  36 =over 4
  37
  38 =item I<fusion>
  39
  40 Test F<lalr1.cc> with three stacks against F<lalr1-fusion.cc> which
  41 uses a single one.
  42
  43 =item I<push>
  44
  45 Test the push parser vs. the pull interface.  Use the C parser.
  46
  47 =item I<variant>
  48
  49 Test the use of variants instead of union in the C++ parser.
  50
  51 =back
  52
  53 =item B<-c>, B<--cflags>=I<flags>
  54
  55 Flags to pass to the C or C++ compiler.
  56
  57 =item B<-i>, B<--iterations>=I<integer>
  58
  59 Say how many times a single test of the bench must be run.  If
  60 negative, specify the minimum number of CPU seconds to run.  Defaults
  61 to -3.
  62
  63 =item B<-v>, B<--verbose>
  64
  65 Raise the verbosity level.  Currently only affects B<--help>.
  66
  67 =back
  68
  69 =cut
  70
  71 use IO::File;
  72
  73 ##################################################################
  74
  75 =head1 VARIABLES
  76
  77 =over 4
  78
  79 =item C<$bison>
  80
  81 The Bison program to use to compile the grammar.
  82
  83 =item C<$cc>
  84
  85 The C compiler.
  86
  87 =item C<$cxx>
  88
  89 The C++ compiler.
  90
  91 =item C<$cflags>
  92
  93 Compiler flags (C or C++).
  94
  95 =item C<$iterations>
  96
  97 The number of times the parser is run for a bench.
  98
  99 =item C<$verbose>
 100
 101 Verbosity level.
 102
 103 =back
 104
 105 =cut
 106
 107 my $bison = $ENV{'BISON'} || '@abs_top_builddir@/tests/bison';
 108 my $cc = $ENV{'CC'} || 'gcc';
 109 my $cxx = $ENV{'CXX'} || 'g++';
 110 my $cflags = '';
 111 my $iterations = -3;
 112 my $verbose = 0;
 113
 114 =head1 FUNCTIONS
 115
 116 =over 4
 117
 118 =item C<verbose($level, $message)>
 119
 120 Report the C<$message> is C<$level> E<lt>= C<$verbose>.
 121
 122 =cut
 123
 124 sub verbose($$)
 125 {
 126   my ($level, $message) = @_;
 127   print STDERR $message
 128     if $level <= $verbose;
 129 }
 130
 131 =item C<directives($bench, @directive)>
 132
 133 Format the list of directives for Bison for bench named C<$bench>.
 134
 135 The special fake C<%variant> directive requests the use of
 136 Boost.Variants instead of a regular union.  So don't pass it, it is
 137 not a valid directive.
 138
 139 =cut
 140
 141 sub directives($@)
 142 {
 143   my ($bench, @directive) = @_;
 144   my $res = "/* Directives for bench `$bench'. */\n";
 145   for my $d (@directive)
 146     {
 147       $res .= $d . "\n"
 148         unless $d eq '%variant';
 149     }
 150   $res .= "/* End of directives for bench `$bench'. */\n";
 151   return $res;
 152 }
 153
 154 =item C<triangular_grammar ($base, $max, @directive)>
 155
 156 Create a large triangular grammar which looks like :
 157
 158   input:
 159     exp        { if ($1 != 0) abort (); $$ = $1; }
 160   | input exp  { if ($2 != $1 + 1) abort (); $$ = $2; }
 161   ;
 162
 163   exp:
 164     END                         { $$ = 0; }
 165   | "1"  END                    { $$ = 1; }
 166   | "1" "2"  END                { $$ = 2; }
 167   | "1" "2" "3"  END            { $$ = 3; }
 168   | "1" "2" "3" "4"  END        { $$ = 4; }
 169   | "1" "2" "3" "4" "5"  END    { $$ = 5; }
 170   ;
 171
 172 C<$base> is the base name for the file to create (F<$base.y>).
 173 C<$max> is the number of such rules (here, 5).  You may pass
 174 additional Bison C<@directive>.
 175
 176 The created parser is self contained: it includes its scanner, and
 177 source of input.
 178 =cut
 179
 180 sub triangular_grammar ($$$)
 181 {
 182   my ($base, $max, @directive) = @_;
 183   my $directives = directives ($base, @directive);
 184
 185   my $out = new IO::File ">$base.y"
 186     or die;
 187   print $out <<EOF;
 188 %error-verbose
 189 %debug
 190 %{
 191 #include <stdio.h>
 192 #include <stdlib.h>
 193
 194 static int yylex (void);
 195 static void yyerror (const char *msg);
 196 %}
 197 $directives
 198 %union
 199 {
 200   int val;
 201 };
 202
 203 %token END "end"
 204 %type <val> exp input
 205 EOF
 206
 207   for my $size (1 .. $max)
 208     {
 209       print $out "%token t$size $size \"$size\"\n";
 210     };
 211
 212 print $out <<EOF;
 213 %%
 214 input:
 215   exp        { if (\$1 != 0) abort (); \$\$ = \$1; }
 216 | input exp  { if (\$2 != \$1 + 1) abort (); \$\$ = \$2; }
 217 ;
 218
 219 exp:
 220   END
 221     { \$\$ = 0; }
 222 EOF
 223
 224 for my $size (1 .. $max)
 225   {
 226     use Text::Wrap;
 227     print $out wrap ("| ", "   ",
 228                      (map { "\"$_\"" } (1 .. $size)),
 229                      " END \n"),
 230                "    { \$\$ = $size; }\n";
 231   };
 232 print $out ";\n";
 233
 234 print $out <<EOF;
 235 %%
 236 static int
 237 yylex (void)
 238 {
 239   static int inner = 1;
 240   static int outer = 0;
 241   if (outer > $max)
 242     return 0;
 243   else if (inner > outer)
 244     {
 245       inner = 1;
 246       ++outer;
 247       return END;
 248     }
 249   return inner++;
 250 }
 251
 252 static void
 253 yyerror (const char *msg)
 254 {
 255   fprintf (stderr, "%s\\n", msg);
 256 }
 257
 258 int
 259 main (void)
 260 {
 261   yydebug = !!getenv ("YYDEBUG");
 262   return yyparse ();
 263 }
 264 EOF
 265 }
 266
 267 ##################################################################
 268
 269 =item C<calc_input ($base, $max)>
 270
 271 Generate the input file F<$base.input> for the calc parser.  The input
 272 is composed of two expressions.  The first one is using left recursion
 273 only and consumes no stack.  The second one requires a deep stack.
 274 These two expressions are repeated C<$max> times in the output file.
 275
 276 =cut
 277
 278 sub calc_input ($$)
 279 {
 280   my ($base, $max) = @_;
 281   my $out = new IO::File ">$base.input"
 282     or die;
 283   foreach (1 .. $max)
 284     {
 285       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";
 286       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";
 287     }
 288 }
 289
 290 ##################################################################
 291 =item C<calc_grammar ($base, $max, @directive)>
 292
 293 Generate a Bison file F<$base.y> for a calculator parser in C.  Pass
 294 the additional Bison C<@directive>.  C<$max> is ignored, but left to
 295 have the same interface as C<triangular_grammar>.
 296
 297 =cut
 298
 299 sub calc_grammar ($$$)
 300 {
 301   my ($base, $max, @directive) = @_;
 302   my $directives = directives ($base, @directive);
 303
 304   my $out = new IO::File ">$base.y"
 305     or die;
 306   print $out <<EOF;
 307 %{
 308 #include <stdio.h>
 309
 310 #include <stdlib.h>
 311 #include <string.h>
 312 #include <ctype.h>
 313 #define USE(Var)
 314
 315 /* Exercise pre-prologue dependency to %union.  */
 316 typedef int semantic_value;
 317
 318 static semantic_value global_result = 0;
 319 static int global_count = 0;
 320 %}
 321
 322 $directives
 323 %error-verbose
 324 /* Exercise %union. */
 325 %union
 326 {
 327   semantic_value ival;
 328 };
 329
 330 %{
 331 static int power (int base, int exponent);
 332 /* yyerror receives the location if:
 333    - %location & %pure & %glr
 334    - %location & %pure & %yacc & %parse-param. */
 335 static void yyerror (const char *s);
 336 #if YYPURE
 337 static int yylex (YYSTYPE* yylvalp);
 338 #else
 339 static int yylex (void);
 340 #endif
 341 %}
 342
 343 /* Bison Declarations */
 344 %token CALC_EOF 0 "end of input"
 345 %token <ival> NUM "number"
 346 %type  <ival> exp
 347
 348 %nonassoc '=' /* comparison            */
 349 %left '-' '+'
 350 %left '*' '/'
 351 %left NEG     /* negation--unary minus */
 352 %right '^'    /* exponentiation        */
 353
 354 /* Grammar follows */
 355 %%
 356 input:
 357   line
 358 | input line
 359 ;
 360
 361 line:
 362   '\\n'
 363 | exp '\\n'           { USE (\$1); }
 364 ;
 365
 366 exp:
 367   NUM                { \$\$ = \$1;             }
 368 | exp '=' exp
 369   {
 370     if (\$1 != \$3)
 371       fprintf (stderr, "calc: error: %d != %d\\n", \$1, \$3);
 372     \$\$ = \$1;
 373   }
 374 | exp '+' exp        { \$\$ = \$1 + \$3;        }
 375 | exp '-' exp        { \$\$ = \$1 - \$3;        }
 376 | exp '*' exp        { \$\$ = \$1 * \$3;        }
 377 | exp '/' exp        { \$\$ = \$1 / \$3;        }
 378 | '-' exp  %prec NEG { \$\$ = -\$2;            }
 379 | exp '^' exp        { \$\$ = power (\$1, \$3); }
 380 | '(' exp ')'        { \$\$ = \$2;             }
 381 | '(' error ')'      { \$\$ = 1111;           }
 382 | '!'                { \$\$ = 0; YYERROR;     }
 383 | '-' error          { \$\$ = 0; YYERROR;     }
 384 ;
 385 %%
 386 /* The input.  */
 387 static FILE *input;
 388
 389 static void
 390 yyerror (const char *s)
 391 {
 392   fprintf (stderr, "%s\\n", s);
 393 }
 394
 395 static int
 396 get_char (void)
 397 {
 398   return getc (input);
 399 }
 400
 401
 402 static void
 403 unget_char ( int c)
 404 {
 405   ungetc (c, input);
 406 }
 407
 408 static int
 409 read_signed_integer (void)
 410 {
 411   int c = get_char ();
 412   int sign = 1;
 413   int n = 0;
 414
 415   if (c == '-')
 416     {
 417       c = get_char ();
 418       sign = -1;
 419     }
 420
 421   while (isdigit (c))
 422     {
 423       n = 10 * n + (c - '0');
 424       c = get_char ();
 425     }
 426
 427   unget_char (c);
 428
 429   return sign * n;
 430 }
 431
 432 static int
 433 #if YYPURE
 434 # define yylval (*yylvalp)
 435 yylex (YYSTYPE* yylvalp)
 436 #else
 437 yylex (void)
 438 #endif
 439 {
 440   int c;
 441
 442   /* Skip white space.  */
 443   while ((c = get_char ()) == ' ' || c == '\t')
 444     continue;
 445
 446   /* process numbers   */
 447   if (c == '.' || isdigit (c))
 448     {
 449       unget_char ( c);
 450       yylval.ival = read_signed_integer ();
 451       return NUM;
 452     }
 453
 454   /* Return end-of-file.  */
 455   if (c == EOF)
 456     return CALC_EOF;
 457
 458   /* Return single chars. */
 459   return c;
 460 }
 461
 462 static int
 463 power (int base, int exponent)
 464 {
 465   int res = 1;
 466   if (exponent < 0)
 467     exit (3);
 468   for (/* Niente */; exponent; --exponent)
 469     res *= base;
 470   return res;
 471 }
 472
 473
 474 int
 475 main (int argc, const char **argv)
 476 {
 477   semantic_value result = 0;
 478   int count = 0;
 479   int status;
 480
 481   input = fopen ("calc.input", "r");
 482   if (!input)
 483     {
 484       perror ("calc.input");
 485       return 3;
 486     }
 487
 488   status = yyparse ();
 489   if (global_result != result)
 490     abort ();
 491   if (global_count != count)
 492     abort ();
 493
 494   return status;
 495 }
 496 EOF
 497 }
 498
 499 ##################################################################
 500
 501 =item C<variant_grammar ($base, $max, @directive)>
 502
 503 Generate a Bison file F<$base.y> that uses, or not, the Boost.Variants
 504 depending on the C<@directive>.
 505
 506 =cut
 507
 508 sub variant_grammar ($$$)
 509 {
 510   my ($base, $max, @directive) = @_;
 511   my $directives = directives ($base, @directive);
 512   my $variant = grep { $_ eq '%variant' } @directive;
 513
 514   my $out = new IO::File ">$base.y"
 515     or die;
 516   print $out <<EOF;
 517 %language "C++"
 518 %defines
 519 $directives
 520
 521 %code requires // variant.h
 522 {
 523 #include <string>
 524 }
 525
 526 %code // variant.c
 527 {
 528 #include <algorithm>
 529 #include <iostream>
 530 #include <sstream>
 531
 532 // Prototype of the yylex function providing subsequent tokens.
 533 static yy::parser::token_type yylex(yy::parser::semantic_type* yylval);
 534
 535 #define STAGE_MAX    ($max * 10)
 536 #define USE_VARIANTS $variant
 537 #if USE_VARIANTS
 538 # define IF_VARIANTS(True, False) True
 539 #else
 540 # define IF_VARIANTS(True, False) False
 541 #endif
 542 }
 543 EOF
 544
 545   if ($variant)
 546     {
 547       print $out <<'EOF';
 548 %code variant {int,std::string}
 549 %token <std::string> TEXT
 550 %token <int> NUMBER
 551 %printer { std::cerr << "Number: " << $$; } <int>
 552 %printer { std::cerr << "Text: " << $$; } <std::string>
 553 %token END_OF_FILE 0
 554 %type <std::string> text result
 555
 556 %%
 557 result:
 558   text                  { /* Throw away the result. */ }
 559 ;
 560
 561 text:
 562   /* nothing */         { /* This will generate an empty string */ }
 563 | text TEXT             { std::swap($$,$1); $$.append($2); }
 564 | text NUMBER           {
 565                           std::swap($$,$1);
 566                           std::ostringstream ss;
 567                           ss << ' ' << $2;
 568                           $$.append(ss.str());
 569                          }
 570 ;
 571 EOF
 572     }
 573   else
 574     {
 575       # Not using Boost variants.
 576       print $out <<'EOF';
 577 %union {int ival; std::string* sval;}
 578 %token <sval> TEXT
 579 %token <ival> NUMBER
 580 %printer { std::cerr << "Number: " << $$; } <ival>
 581 %printer { std::cerr << "Text: " << *$$; } <sval>
 582 %token END_OF_FILE 0
 583 %type <sval> text result
 584
 585 %%
 586 result:
 587   text                  { delete $1; }
 588 ;
 589
 590 text:
 591   /* nothing */         { $$ = new std::string; }
 592 | text TEXT             { $$->append(*$2); delete $2; }
 593 | text NUMBER           {
 594                           std::ostringstream ss;
 595                           ss << ' ' << $2;
 596                           $$->append(ss.str());
 597                          }
 598 ;
 599 EOF
 600     }
 601
 602   print $out <<'EOF';
 603 %%
 604 static
 605 yy::parser::token_type
 606 yylex(yy::parser::semantic_type* yylval)
 607 {
 608   static int stage = -1;
 609   ++stage;
 610   if (stage == STAGE_MAX)
 611     return yy::parser::token::END_OF_FILE;
 612   else if (stage % 2)
 613     {
 614       IF_VARIANTS(yylval->build<int>(), yylval->ival) = stage;
 615       return yy::parser::token::NUMBER;
 616     }
 617   else
 618     {
 619       IF_VARIANTS(yylval->build<std::string>() =, yylval->sval = new) std::string("A string.");
 620       return yy::parser::token::TEXT;
 621     }
 622   abort();
 623 }
 624
 625 // Mandatory error function
 626 void
 627 yy::parser::error(const yy::parser::location_type& yylloc,
 628                   const std::string& message)
 629 {
 630   std::cerr << yylloc << ": " << message << std::endl;
 631 }
 632
 633 int main(int argc, char *argv[])
 634 {
 635   yy::parser p;
 636 #if YYDEBUG
 637   p.set_debug_level(!!getenv("YYDEBUG"));
 638 #endif
 639   p.parse();
 640   return 0;
 641 }
 642 EOF
 643 }
 644
 645 ##################################################################
 646
 647 =item C<compile ($base)>
 648
 649 Compile C<$base.y> to an executable C, Using the C or C++ compiler
 650 depending on the %language specification in C<$base.y>.
 651
 652 =cut
 653
 654 sub compile ($)
 655 {
 656   my ($base) = @_;
 657   my $language = `sed -ne '/%language "\\(.*\\)"/{s//\\1/;p;q;}' $base.y`;
 658   chomp $language;
 659
 660   my $compiler = $language eq 'C++' ? $cxx : $cc;
 661
 662   system ("$bison $base.y -o $base.c") == 0
 663     or die;
 664   system ("$compiler -o $base $cflags $base.c") == 0
 665     or die;
 666 }
 667
 668 =item C<bench_grammar ($gram, %bench)>
 669
 670 Generate benches for C<$gram>.  C<$gram> should be C<calc> or
 671 C<triangle>.  C<%bench> is a hash of the form:
 672
 673   $name => @directive
 674
 675 where C<$name> is the name of the bench, and C<@directive> are the
 676 Bison directive to use for this bench.  All the benches are compared
 677 against each other, repeated 50 times.
 678
 679 =cut
 680
 681 sub bench_grammar ($%)
 682 {
 683   my ($gram, %test) = @_;
 684
 685   use Benchmark qw (:all :hireswallclock);
 686
 687   # Set up the benches as expected by timethese.
 688   my %bench;
 689   # For each bench, capture the size.
 690   my %size;
 691   while (my ($name, $directives) = each %test)
 692     {
 693       verbose 1, "Generating $name\n";
 694       # Call the Bison input file generator.
 695       my $generator = "$gram" . "_grammar";
 696       &$generator ($name, 200, @$directives);
 697       # Compile the executable.
 698       compile ($name);
 699       $bench{$name} = "system ('./$name');";
 700       chop($size{$name} = `wc -c <$name`);
 701     }
 702
 703   # Run the benches.
 704   #
 705   # STYLE can be any of 'all', 'none', 'noc', 'nop' or 'auto'.  'all'
 706   # shows each of the 5 times available ('wallclock' time, user time,
 707   # system time, user time of children, and system time of
 708   # children). 'noc' shows all except the two children times. 'nop'
 709   # shows only wallclock and the two children times.  'auto' (the
 710   # default) will act as 'all' unless the children times are both
 711   # zero, in which case it acts as 'noc'.  'none' prevents output.
 712   verbose 1, "Running the benches for $gram\n";
 713   my $res = timethese ($iterations, \%bench, 'nop');
 714
 715   # Output the speed result.
 716   cmpthese ($res, 'nop');
 717
 718   # Display the sizes.
 719   print "Sizes:\n";
 720   my $width = 10;
 721   for my $bench (keys %size)
 722     {
 723       $width = length $bench
 724         if $width < length $bench;
 725     }
 726   for my $bench (keys %size)
 727     {
 728       printf "%${width}s: %5dkB\n", $bench, int ($size{$bench} / 1024);
 729     }
 730 }
 731
 732
 733 =item C<bench_push_parser ()>
 734
 735 Bench the C push parser against the pull parser, pure and impure
 736 interfaces.
 737
 738 =cut
 739
 740 sub bench_push_parser ()
 741 {
 742   calc_input ('calc', 200);
 743   bench_grammar
 744     ('calc',
 745      (
 746       "pull-impure" => [],
 747       "pull-pure"   => ['%define api.pure'],
 748       "push-impure" => ['%define api.push_pull "both"'],
 749       "push-pure"   => ['%define api.push_pull "both"', '%define api.pure'],
 750      )
 751     );
 752 }
 753
 754 =item C<bench_variant_parser ()>
 755
 756 Bench the C++ lalr1.cc parser using Boost.Variants or %union.
 757
 758 =cut
 759
 760 sub bench_variant_parser ()
 761 {
 762   bench_grammar
 763     ('variant',
 764      (
 765       "f-union"         => ['%skeleton "lalr1-fusion.cc"'],
 766       "f-uni-deb"   => ['%skeleton "lalr1-fusion.cc"', '%debug'],
 767       "f-var"       => ['%skeleton "lalr1-fusion.cc"', '%variant'],
 768       "f-var-deb" => ['%skeleton "lalr1-fusion.cc"', '%debug', '%variant'],
 769       "f-var-dtr"       => ['%skeleton "lalr1-fusion.cc"', '%variant', "%code {\n#define VARIANT_DESTROY\n}"],
 770       "f-var-deb-dtr" => ['%skeleton "lalr1-fusion.cc"', '%debug', '%variant', "%code {\n#define VARIANT_DESTROY\n}"],
 771      )
 772     );
 773 }
 774
 775 =item C<bench_fusion_parser ()>
 776
 777 Bench the C++ lalr1.cc parser using Boost.Variants or %union.
 778
 779 =cut
 780
 781 sub bench_fusion_parser ()
 782 {
 783   bench_grammar
 784     ('variant',
 785      (
 786       "split"         => [],
 787       "fused"         => ['%skeleton "lalr1-fusion.cc"'],
 788      )
 789     );
 790 }
 791
 792 ############################################################################
 793
 794 sub help ($)
 795 {
 796   my ($verbose) = @_;
 797   use Pod::Usage;
 798   # See <URL:http://perldoc.perl.org/pod2man.html#NOTES>.
 799   pod2usage( { -message => "Bench Bison parsers",
 800                -exitval => 0,
 801                -verbose => $verbose,
 802                -output  => \*STDOUT });
 803 }
 804
 805 sub getopt ()
 806 {
 807   use Getopt::Long;
 808   %option = (
 809     "b|bench=s"      => \$bench,
 810     "c|cflags=s"     => \$cflags,
 811     "h|help"         => sub { help ($verbose) },
 812     "i|iterations=i" => \$iterations,
 813     "v|verbose"      => sub { ++$verbose },
 814     );
 815   Getopt::Long::Configure ("bundling", "pass_through");
 816   GetOptions (%option)
 817     or exit 1;
 818 }
 819
 820 ######################################################################
 821
 822 getopt;
 823 verbose 1, "Using bison=$bison.\n";
 824 verbose 1, "Using cc=$cc.\n";
 825 verbose 1, "Using cxx=$cxx.\n";
 826 verbose 1, "Using cflags=$cflags.\n";
 827
 828 bench_fusion_parser()  if $bench eq "fusion";
 829 bench_push_parser()    if $bench eq "push";
 830 bench_variant_parser() if $bench eq "variant";
 831
 832 ### Setup "GNU" style for perl-mode and cperl-mode.
 833 ## Local Variables:
 834 ## perl-indent-level: 2
 835 ## perl-continued-statement-offset: 2
 836 ## perl-continued-brace-offset: 0
 837 ## perl-brace-offset: 0
 838 ## perl-brace-imaginary-offset: 0
 839 ## perl-label-offset: -2
 840 ## cperl-indent-level: 2
 841 ## cperl-brace-offset: 0
 842 ## cperl-continued-brace-offset: 0
 843 ## cperl-label-offset: -2
 844 ## cperl-extra-newline-before-brace: t
 845 ## cperl-merge-trailing-else: nil
 846 ## cperl-continued-statement-offset: 2
 847 ## End: