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