compilers/pct/src/POST/Node.pir

   1 =head1 NAME
   2
   3 POST - Parrot opcode syntax tree
   4
   5 =head1 DESCRIPTION
   6
   7 This file implements the various opcode syntax tree nodes
   8 for compiling programs in Parrot.
   9
  10 =cut
  11
  12 .namespace [ 'POST' ]
  13
  14 .sub '__onload' :load :init
  15     .local pmc p6meta, base
  16
  17     ##  create POST classes
  18     p6meta = new 'P6metaclass'
  19     base = p6meta.'new_class'('POST::Node', 'parent'=>'PCT::Node')
  20     p6meta.'new_class'('POST::Op', 'parent'=>base)
  21     p6meta.'new_class'('POST::Ops', 'parent'=>base)
  22     p6meta.'new_class'('POST::Label', 'parent'=>base)
  23     p6meta.'new_class'('POST::Sub', 'parent'=>base)
  24
  25     $P0 = new 'ResizableStringArray'
  26     $P0[0] = "    .param pmc %0"
  27     $P0[1] = "    .param pmc %0 :optional\n    .param int has_%0 :opt_flag"
  28     $P0[2] = "    .param pmc %0 :slurpy"
  29     $P0[4] = "    .param pmc %0 :named(%1)"
  30     $P0[5] = "    .param pmc %0 :optional :named(%1)\n    .param int has_%0 :opt_flag"
  31     $P0[6] = "    .param pmc %0 :slurpy :named"
  32     set_hll_global ['POST::Sub'], '%!paramfmt', $P0
  33     .return ()
  34 .end
  35
  36
  37 =head1 POST Node types
  38
  39 =head2 POST::Node
  40
  41 C<POST::Node> is the base class for all POST nodes.  It's derived from class
  42 C<PCT::Node> (see F<compilers/pct/src/PCT/Node.pir>).
  43
  44 =over 4
  45
  46 =item result([value])
  47
  48 Get/set
  49
  50 =cut
  51
  52 .namespace [ 'POST::Node' ]
  53
  54 =item result([value])
  55
  56 Get or set the result value of this node.  If the result value
  57 is set to another POST node, then that node's result is used
  58 as the result of the current node.
  59
  60 =cut
  61
  62 .sub 'result' :method
  63     .param pmc value           :optional
  64     .param int has_value       :opt_flag
  65
  66     if has_value == 1 goto set_value
  67     value = self['result']
  68     if null value goto result_null
  69     $I0 = isa value, 'POST::Node'
  70     if $I0 goto result_node
  71     .return (value)
  72   result_node:
  73     .return value.'result'()
  74   result_null:
  75     .return ('')
  76   set_value:
  77     self['result'] = value
  78     .return (value)
  79 .end
  80
  81
  82 =item get_string()   # vtable method
  83
  84 Returns the result of the current node as a string.
  85
  86 =cut
  87
  88 .sub 'get_string' :vtable :method
  89     $S0 = self.'result'()
  90     .return ($S0)
  91 .end
  92
  93
  94 =item push_pirop(pirop [,arglist :slurpy] [,adverbs :slurpy :named])
  95
  96 Shortcut for creating and adding a new POST::Op node with opcode
  97 C<pirop> and any supplied arguments or options.  Returns the
  98 newly created node.
  99
 100 =cut
 101
 102 .sub 'push_pirop' :method
 103     .param pmc pirop
 104     .param pmc arglist         :slurpy
 105     .param pmc adverbs         :slurpy :named
 106     adverbs['pirop'] = pirop
 107     $P0 = get_hll_global ['POST'], 'Op'
 108     $P1 = $P0.'new'(arglist :flat, adverbs :flat :named)
 109     self.'push'($P1)
 110     .return ($P1)
 111 .end
 112
 113
 114 =item escape(str)
 115
 116 Return C<str> as a PIR constant string.
 117
 118 =cut
 119
 120 .sub 'escape' :method
 121     .param string str
 122     $P0 = new 'CodeString'
 123     str = $P0.'escape'(str)
 124     .return (str)
 125 .end
 126
 127 =back
 128
 129 =head2 POST::Op
 130
 131 C<POST::Op> nodes represents any PIR opcodes.
 132
 133 =over 4
 134
 135 =item pirop([opcode])
 136
 137 Get/set the opcode type for this node.
 138
 139 =cut
 140
 141 .namespace [ 'POST::Op' ]
 142
 143 .sub 'pirop' :method
 144     .param pmc value           :optional
 145     .param int has_value       :opt_flag
 146     .return self.'attr'('pirop', value, has_value)
 147 .end
 148
 149 .sub 'inline' :method
 150     .param pmc value           :optional
 151     .param int has_value       :opt_flag
 152     .return self.'attr'('inline', value, has_value)
 153 .end
 154
 155
 156 .namespace [ 'POST::Label' ]
 157
 158 .sub 'result' :method
 159     .param pmc value           :optional
 160     .param int has_value       :opt_flag
 161     if has_value goto set_value
 162     value = self['result']
 163     unless null value goto end
 164     .local string name
 165     name = self.'name'()
 166     value = self.'unique'(name)
 167   set_value:
 168     self['result'] = value
 169   end:
 170     .return (value)
 171 .end
 172
 173
 174 .namespace [ 'POST::Sub' ]
 175
 176 .sub 'blocktype' :method
 177     .param pmc value           :optional
 178     .param int has_value       :opt_flag
 179     .return self.'attr'('blocktype', value, has_value)
 180 .end
 181
 182
 183 .sub 'namespace' :method
 184     .param pmc value           :optional
 185     .param int has_value       :opt_flag
 186     .return self.'attr'('namespace', value, has_value)
 187 .end
 188
 189
 190 .sub 'outer' :method
 191     .param pmc value           :optional
 192     .param int has_value       :opt_flag
 193     .return self.'attr'('outer', value, has_value)
 194 .end
 195
 196
 197 .sub 'lexid' :method
 198     .param pmc value           :optional
 199     .param int has_value       :opt_flag
 200     .return self.'attr'('lexid', value, has_value)
 201 .end
 202
 203
 204 .sub 'pirflags' :method
 205     .param pmc value           :optional
 206     .param int has_value       :opt_flag
 207     .return self.'attr'('pirflags', value, has_value)
 208 .end
 209
 210
 211 .sub 'compiler' :method
 212     .param pmc value           :optional
 213     .param int has_value       :opt_flag
 214     .return self.'attr'('compiler', value, has_value)
 215 .end
 216
 217
 218 .sub 'compiler_args' :method
 219     .param pmc value           :optional
 220     .param int has_value       :opt_flag
 221     .return self.'attr'('compiler_args', value, has_value)
 222 .end
 223
 224
 225 .sub 'add_param' :method
 226     .param pmc pname
 227     .param pmc adverbs         :slurpy :named
 228
 229     .local int optional, slurpy
 230     .local string named
 231     optional = adverbs['optional']
 232     slurpy = adverbs['slurpy']
 233     named = adverbs['named']
 234
 235     .local int paramseq
 236     paramseq = isne optional, 0
 237     unless slurpy goto slurpy_done
 238     paramseq += 2
 239   slurpy_done:
 240     unless named goto named_done
 241     paramseq += 4
 242   named_done:
 243
 244     .local pmc paramlist
 245     paramlist = self['paramlist']
 246     unless null paramlist goto have_paramlist
 247     paramlist = new 'ResizablePMCArray'
 248     self['paramlist'] = paramlist
 249   have_paramlist:
 250
 251     .local pmc code
 252     code = paramlist[paramseq]
 253     unless null code goto have_code
 254     code = new 'CodeString'
 255     paramlist[paramseq] = code
 256   have_code:
 257
 258     .local pmc paramfmt
 259     paramfmt = get_hll_global ['POST::Sub'], '%!paramfmt'
 260     $S0 = paramfmt[paramseq]
 261     named = code.'escape'(named)
 262     code.'emit'($S0, pname, named)
 263
 264     .return ()
 265 .end
 266
 267 =back
 268
 269 =head1 AUTHOR
 270
 271 Patrick Michaud <pmichaud@pobox.com> is the author and maintainer.
 272 Please send patches and suggestions to the Parrot porters or
 273 Perl 6 compilers mailing lists.
 274
 275 =head1 HISTORY
 276
 277 2007-11-21  Significant refactor as part of Parrot Compiler Toolkit
 278
 279 =head1 COPYRIGHT
 280
 281 Copyright (C) 2006-2008, The Perl Foundation.
 282
 283 =cut
 284
 285 # Local Variables:
 286 #   mode: pir
 287 #   fill-column: 100
 288 # End:
 289 # vim: expandtab shiftwidth=4 ft=pir: