runtime/parrot/library/PGE/Dumper.pir

   1 =head1 TITLE
   2
   3 PGE::Dumper - various methods for displaying PGE structures
   4
   5 =cut
   6
   7 .sub __onload
   8 .end
   9
  10 .namespace [ "PGE::Match" ]
  11
  12 =head2 C<PGE::Match> Methods
  13
  14 =over 4
  15
  16 =item C<__dump(PMC dumper, STR label)>
  17
  18 This method enables Data::Dumper to work on Match objects.
  19
  20 =cut
  21
  22 .sub "__dump" :method
  23     .param pmc dumper
  24     .param string label
  25     .local string indent, subindent
  26     .local pmc iter, val
  27     .local string key
  28     .local pmc hash, array
  29     .local int hascapts
  30
  31     (subindent, indent) = dumper."newIndent"()
  32     print "=> "
  33     $S0 = self
  34     dumper."genericString"("", $S0)
  35     print " @ "
  36     $I0 = self.from()
  37     print $I0
  38     hascapts = 0
  39     hash = self.'hash'()
  40     if_null hash, dump_array
  41     iter = new 'Iterator', hash
  42   dump_hash_1:
  43     unless iter goto dump_array
  44     if hascapts goto dump_hash_2
  45     print " {"
  46     hascapts = 1
  47   dump_hash_2:
  48     print "\n"
  49     print subindent
  50     key = shift iter
  51     val = hash[key]
  52     print "<"
  53     print key
  54     print "> => "
  55     dumper."dump"(label, val)
  56     goto dump_hash_1
  57   dump_array:
  58     array = self.'list'()
  59     if_null array, dump_end
  60     $I1 = elements array
  61     $I0 = 0
  62   dump_array_1:
  63     if $I0 >= $I1 goto dump_end
  64     if hascapts goto dump_array_2
  65     print " {"
  66     hascapts = 1
  67   dump_array_2:
  68     print "\n"
  69     print subindent
  70     val = array[$I0]
  71     print "["
  72     print $I0
  73     print "] => "
  74     dumper."dump"(label, val)
  75     inc $I0
  76     goto dump_array_1
  77   dump_end:
  78     unless hascapts goto end
  79     print "\n"
  80     print indent
  81     print "}"
  82   end:
  83     dumper."deleteIndent"()
  84 .end
  85
  86 =item C<dump_str()>
  87
  88 An alternate dump output for a Match object and all of its subcaptures.
  89
  90 =cut
  91
  92 .sub "dump_str" :method
  93     .param string prefix       :optional           # name of match variable
  94     .param int has_prefix      :opt_flag
  95     .param string b1           :optional           # bracket open
  96     .param int has_b1          :opt_flag
  97     .param string b2           :optional           # bracket close
  98     .param int has_b2          :opt_flag
  99
 100     .local pmc capt
 101     .local int spi, spc
 102     .local pmc iter
 103     .local string prefix1, prefix2
 104
 105     if has_b2 goto start
 106     b2 = "]"
 107     if has_b1 goto start
 108     b1 = "["
 109   start:
 110     .local string out
 111     out = concat prefix, ':'
 112     unless self goto subpats
 113     out .= ' <'
 114     $S0 = self
 115     out .= $S0
 116     out .= ' @ '
 117     $S0 = self.'from'()
 118     out .= $S0
 119     out .= '> '
 120
 121   subpats:
 122     $I0 = self
 123     $S0 = $I0
 124     out .= $S0
 125     out .= "\n"
 126     capt = self.'list'()
 127     if_null capt, subrules
 128     spi = 0
 129     spc = elements capt
 130   subpats_1:
 131     unless spi < spc goto subrules
 132     prefix1 = concat prefix, b1
 133     $S0 = spi
 134     concat prefix1, $S0
 135     concat prefix1, b2
 136     $I0 = defined capt[spi]
 137     unless $I0 goto subpats_2
 138     $P0 = capt[spi]
 139     bsr dumper
 140   subpats_2:
 141     inc spi
 142     goto subpats_1
 143
 144   subrules:
 145     capt = self.'hash'()
 146     if_null capt, end
 147     iter = new 'Iterator', capt
 148   subrules_1:
 149     unless iter goto end
 150     $S0 = shift iter
 151     prefix1 = concat prefix, '<'
 152     concat prefix1, $S0
 153     concat prefix1, ">"
 154     $I0 = defined capt[$S0]
 155     unless $I0 goto subrules_1
 156     $P0 = capt[$S0]
 157     bsr dumper
 158     goto subrules_1
 159
 160   dumper:
 161     $I0 = isa $P0, 'PGE::Match'
 162     unless $I0 goto dumper_0
 163     $S0 = $P0.'dump_str'(prefix1, b1, b2)
 164     out .= $S0
 165     ret
 166   dumper_0:
 167     $I0 = does $P0, 'array'
 168     unless $I0 goto dumper_3
 169     $I0 = 0
 170     $I1 = elements $P0
 171   dumper_1:
 172     if $I0 >= $I1 goto dumper_2
 173     $P1 = $P0[$I0]
 174     prefix2 = concat prefix1, b1
 175     $S0 = $I0
 176     concat prefix2, $S0
 177     concat prefix2, b2
 178     $S0 = $P1.'dump_str'(prefix2, b1, b2)
 179     out .= $S0
 180     inc $I0
 181     goto dumper_1
 182   dumper_2:
 183     ret
 184   dumper_3:
 185     out .= prefix1
 186     out .= ': '
 187     $S0 = $P0
 188     out .= $S0
 189     out .= "\n"
 190     ret
 191
 192   end:
 193     .return (out)
 194 .end
 195
 196
 197 =item C<dump()>
 198
 199 An alternate dump output for a Match object and all of its subcaptures.
 200 Simply calls C<dump_str()> above and prints the results.
 201
 202 =cut
 203
 204 .sub "dump" :method
 205     .param string prefix       :optional           # name of match variable
 206     .param int has_prefix      :opt_flag
 207     .param string b1           :optional           # bracket open
 208     .param int has_b1          :opt_flag
 209     .param string b2           :optional           # bracket close
 210     .param int has_b2          :opt_flag
 211
 212     .local pmc capt
 213     .local int spi, spc
 214     .local pmc iter
 215     .local string prefix1, prefix2
 216
 217     if has_b2 goto start
 218     b2 = "]"
 219     if has_b1 goto start
 220     b1 = "["
 221   start:
 222     $S0 = self.'dump_str'(prefix, b1, b2)
 223     print $S0
 224     .return ()
 225 .end
 226
 227
 228 =back
 229
 230 =head2 C<PGE::Exp> methods
 231
 232 These methods print out a PGE expression tree.  They may be
 233 obsoleted in favor of a Data::Dumper method.
 234
 235 =cut
 236
 237 .namespace [ "PGE::Exp" ]
 238
 239 .sub "dumpindent" :method
 240     .param int indent
 241     $S0 = repeat ' ', indent
 242     print $S0
 243     .return ()
 244 .end
 245
 246 .sub "dump" :method
 247     .param int indent
 248     self."dumpindent"(indent)
 249     print "EXP (abstract) "
 250     $S0 = self."quant"()
 251     print $S0
 252     print "\n"
 253     .return ()
 254 .end
 255
 256 .namespace [ "PGE::Exp::Start" ]
 257
 258 .sub dump :method
 259     .param int indent
 260     .local pmc exp1
 261     $S0 = self["firstchars"]
 262     print "firstchars: "
 263     print $S0
 264     print "\n"
 265     exp1 = self["exp1"]
 266     exp1."dump"(0)
 267     .return ()
 268 .end
 269
 270 .namespace [ "PGE::Exp::End" ]
 271
 272 .sub dump :method
 273     .param int indent
 274     self."dumpindent"(indent)
 275     print "End\n"
 276     .return ()
 277 .end
 278
 279 .namespace [ "PGE::Exp::Literal" ]
 280
 281 .sub "dump" :method
 282     .param int indent
 283     .local pmc literal
 284     literal = self["literal"]
 285     self."dumpindent"(indent)
 286     print "LITERAL <<"
 287     print literal
 288     print ">> "
 289     $S0 = self."quant"()
 290     print $S0
 291     print "\n"
 292     .return ()
 293 .end
 294
 295 .namespace [ "PGE::Exp::Scalar" ]
 296
 297 .sub "dump" :method
 298     .param int indent
 299     .local pmc cname
 300     cname = self["cname"]
 301     self."dumpindent"(indent)
 302     print "BACKREF <<"
 303     print cname
 304     print ">> "
 305     $S0 = self."quant"()
 306     print $S0
 307     print "\n"
 308     .return ()
 309 .end
 310
 311 .namespace [ "PGE::Exp::Dot" ]
 312
 313 .sub "dump" :method
 314     .param int indent
 315     self."dumpindent"(indent)
 316     print "DOT "
 317     $S0 = self."quant"()
 318     print $S0
 319     print "\n"
 320     .return ()
 321 .end
 322
 323 .namespace [ "PGE::Exp::CharClass" ]
 324
 325 .sub dump :method
 326     .param int indent
 327     self."dumpindent"(indent)
 328     print "CharClass "
 329     $S0 = self["charmatch"]
 330     print $S0
 331     print " <<"
 332     $S0 = self["charclass"]
 333     print $S0
 334     print ">> "
 335     $S0 = self."quant"()
 336     print $S0
 337     print "\n"
 338     .return ()
 339 .end
 340
 341 .namespace [ "PGE::Exp::WS" ]
 342
 343 .sub "dump" :method
 344     .param int indent
 345     self."dumpindent"(indent)
 346     print "<?ws> "
 347     $S0 = self."quant"()
 348     print $S0
 349     print "\n"
 350     .return ()
 351 .end
 352
 353 .namespace [ "PGE::Exp::Anchor" ]
 354
 355 .sub "dump" :method
 356     .param int indent
 357     .local string token
 358     self."dumpindent"(indent)
 359     print "ANCHOR "
 360     token = self["token"]
 361     print token
 362     print "\n"
 363     .return ()
 364 .end
 365
 366
 367 .namespace [ "PGE::Exp::Concat" ]
 368
 369 .sub "dump" :method
 370     .param int indent
 371     $P0 = self["exp1"]
 372     $P0."dump"(indent)
 373     $P0 = self["exp2"]
 374     $P0."dump"(indent)
 375     .return ()
 376 .end
 377
 378 .namespace [ "PGE::Exp::Alt" ]
 379
 380 .sub "dump" :method
 381     .param int indent
 382     .local int offset
 383     .local pmc exp
 384
 385     exp = self["exp1"]
 386     $I1 = indent
 387     $I0 = isa exp, "PGE::Exp::Alt"
 388     if $I0 goto print_exp1
 389     $I1 += 4
 390   print_exp1:
 391     exp."dump"($I1)
 392     self."dumpindent"(indent)
 393     print "ALT\n"
 394     exp = self["exp2"]
 395     $I1 = indent
 396     $I0 = isa exp, "PGE::Exp::Alt"
 397     if $I0 goto print_exp2
 398     $I1 += 4
 399   print_exp2:
 400     exp."dump"($I1)
 401     .return ()
 402 .end
 403
 404
 405 .namespace [ "PGE::Exp::Group" ]
 406
 407 .sub "dump" :method
 408     .param int indent
 409     .local int offset
 410     .local pmc exp
 411     .local int subp
 412
 413     self."dumpindent"(indent)
 414     print "GROUP "
 415     $S0 = self."quant"()
 416     print $S0
 417     $I0 = exists self["rname"]
 418     unless $I0 goto dump_0
 419     print " subrule '"
 420     $S0 = self["rname"]
 421     print $S0
 422     print "'"
 423   dump_0:
 424     $I0 = exists self["cname"]
 425     unless $I0 goto dump_1
 426     print " capture as '"
 427     $S0 = self["cname"]
 428     print $S0
 429     print "'"
 430   dump_1:
 431     $I0 = self["isarray"]
 432     unless $I0 goto dump_2
 433     print " isarray"
 434   dump_2:
 435     $I0 = self["cscope"]
 436     unless $I0 goto dump_3
 437     print " cscope"
 438   dump_3:
 439     print "\n"
 440     exp = self["exp1"]
 441     indent += 4
 442     exp."dump"(indent)
 443     .return ()
 444 .end
 445
 446 .namespace [ "PGE::OPTable" ]
 447
 448 =head2 C<PGE::OPTable> Methods
 449
 450 =over 4
 451
 452 =item C<__dump(PMC dumper, STR label)>
 453
 454 This method enables Data::Dumper to work on PGE::OPTable objects.
 455
 456 =cut
 457
 458 .sub "__dump" :method
 459     .param pmc dumper
 460     .param string label
 461     .local string indent, subindent
 462     .local pmc iter, val
 463     .local string key
 464     .local pmc hash, array
 465
 466     (subindent, indent) = dumper."newIndent"()
 467     print " {"
 468     hash = self
 469     if_null hash, dump_rest
 470     iter = new 'Iterator', hash
 471   dump_hash:
 472     unless iter goto dump_rest
 473     print "\n"
 474     print subindent
 475     key = shift iter
 476     val = hash[key]
 477     print "<"
 478     print key
 479     print "> => "
 480     dumper."dump"(label, val)
 481     goto dump_hash
 482   dump_rest:
 483     print "\n"
 484     $P0 = getattribute self, '%!key'
 485     print subindent
 486     dumper."dump"(label, $P0)
 487     print "\n"
 488     $P0 = getattribute self, '%!klen'
 489     print subindent
 490     dumper."dump"(label, $P0)
 491     print indent
 492     print "}\n"
 493     dumper."deleteIndent"()
 494 .end
 495
 496 =back
 497
 498 =cut
 499
 500 # Local Variables:
 501 #   mode: pir
 502 #   fill-column: 100
 503 # End:
 504 # vim: expandtab shiftwidth=4 ft=pir: