3 # Copyright (c) 1996 Malcolm Beattie
5 # You may distribute under the terms of either the GNU General Public
6 # License or the Artistic License, as specified in the README file.
10 our $VERSION = '1.00';
14 @EXPORT_OK = qw(set_callback T_UNKNOWN T_DOUBLE T_INT VALID_UNSIGNED
15 VALID_INT VALID_DOUBLE VALID_SV REGISTER TEMPORARY);
16 %EXPORT_TAGS = (types => [qw(T_UNKNOWN T_DOUBLE T_INT)],
17 flags => [qw(VALID_INT VALID_DOUBLE VALID_SV
18 VALID_UNSIGNED REGISTER TEMPORARY)]);
22 use B qw(class SVf_IOK SVf_NOK SVf_IVisUV);
25 sub T_UNKNOWN () { 0 }
28 sub T_SPECIAL () { 3 }
31 sub VALID_INT () { 0x01 }
32 sub VALID_UNSIGNED () { 0x02 }
33 sub VALID_DOUBLE () { 0x04 }
34 sub VALID_SV () { 0x08 }
35 sub REGISTER () { 0x10 } # no implicit write-back when calling subs
36 sub TEMPORARY () { 0x20 } # no implicit write-back needed at all
37 sub SAVE_INT () { 0x40 } #if int part needs to be saved at all
38 sub SAVE_DOUBLE () { 0x80 } #if double part needs to be saved at all
42 # Callback for runtime code generation
44 my $runtime_callback = sub { confess "set_callback not yet called" };
45 sub set_callback (&) { $runtime_callback = shift }
46 sub runtime { &$runtime_callback(@_) }
52 sub write_back { confess "stack object does not implement write_back" }
54 sub invalidate { shift->{flags} &= ~(VALID_INT |VALID_UNSIGNED | VALID_DOUBLE) }
58 if (!($obj->{flags} & VALID_SV)) {
60 $obj->{flags} |= VALID_SV;
67 if (!($obj->{flags} & VALID_INT)) {
69 $obj->{flags} |= VALID_INT|SAVE_INT;
76 if (!($obj->{flags} & VALID_DOUBLE)) {
78 $obj->{flags} |= VALID_DOUBLE|SAVE_DOUBLE;
85 return $obj->{type} == T_INT ? $obj->as_int : $obj->as_double;
90 if ($obj->{flags} & VALID_INT ){
93 if ($obj->{flags} & VALID_DOUBLE ){
96 return sprintf("(SvTRUE(%s))", $obj->as_sv) ;
104 my $type = $obj->{type};
105 my $flags = $obj->{flags};
107 if ($type == T_UNKNOWN) {
109 } elsif ($type == T_INT) {
111 } elsif ($type == T_DOUBLE) {
114 $type = "(illegal type $type)";
116 push(@flags, "VALID_INT") if $flags & VALID_INT;
117 push(@flags, "VALID_DOUBLE") if $flags & VALID_DOUBLE;
118 push(@flags, "VALID_SV") if $flags & VALID_SV;
119 push(@flags, "REGISTER") if $flags & REGISTER;
120 push(@flags, "TEMPORARY") if $flags & TEMPORARY;
121 @flags = ("none") unless @flags;
122 return sprintf("%s type=$type flags=%s sv=$obj->{sv}",
123 class($obj), join("|", @flags));
128 my $type = $obj->{type};
129 my $flags = $obj->{flags};
130 if ($type == T_INT || $flags & VALID_INT) {
132 } elsif ($type == T_DOUBLE || $flags & VALID_DOUBLE) {
140 # Caller needs to ensure that set_int, set_double,
141 # set_numeric and set_sv are only invoked on legal lvalues.
144 my ($obj, $expr,$unsigned) = @_;
145 runtime("$obj->{iv} = $expr;");
146 $obj->{flags} &= ~(VALID_SV | VALID_DOUBLE);
147 $obj->{flags} |= VALID_INT|SAVE_INT;
148 $obj->{flags} |= VALID_UNSIGNED if $unsigned;
152 my ($obj, $expr) = @_;
153 runtime("$obj->{nv} = $expr;");
154 $obj->{flags} &= ~(VALID_SV | VALID_INT);
155 $obj->{flags} |= VALID_DOUBLE|SAVE_DOUBLE;
159 my ($obj, $expr) = @_;
160 if ($obj->{type} == T_INT) {
161 $obj->set_int($expr);
163 $obj->set_double($expr);
168 my ($obj, $expr) = @_;
169 runtime("SvSetSV($obj->{sv}, $expr);");
171 $obj->{flags} |= VALID_SV;
178 @B::Stackobj::Padsv::ISA = 'B::Stackobj';
179 sub B::Stackobj::Padsv::new {
180 my ($class, $type, $extra_flags, $ix, $iname, $dname) = @_;
181 $extra_flags |= SAVE_INT if $extra_flags & VALID_INT;
182 $extra_flags |= SAVE_DOUBLE if $extra_flags & VALID_DOUBLE;
185 flags => VALID_SV | $extra_flags,
186 sv => "PL_curpad[$ix]",
192 sub B::Stackobj::Padsv::load_int {
194 if ($obj->{flags} & VALID_DOUBLE) {
195 runtime("$obj->{iv} = $obj->{nv};");
197 runtime("$obj->{iv} = SvIV($obj->{sv});");
199 $obj->{flags} |= VALID_INT|SAVE_INT;
202 sub B::Stackobj::Padsv::load_double {
205 runtime("$obj->{nv} = SvNV($obj->{sv});");
206 $obj->{flags} |= VALID_DOUBLE|SAVE_DOUBLE;
208 sub B::Stackobj::Padsv::save_int {
210 return $obj->{flags} & SAVE_INT;
213 sub B::Stackobj::Padsv::save_double {
215 return $obj->{flags} & SAVE_DOUBLE;
218 sub B::Stackobj::Padsv::write_back {
220 my $flags = $obj->{flags};
221 return if $flags & VALID_SV;
222 if ($flags & VALID_INT) {
223 if ($flags & VALID_UNSIGNED ){
224 runtime("sv_setuv($obj->{sv}, $obj->{iv});");
226 runtime("sv_setiv($obj->{sv}, $obj->{iv});");
228 } elsif ($flags & VALID_DOUBLE) {
229 runtime("sv_setnv($obj->{sv}, $obj->{nv});");
231 confess "write_back failed for lexical @{[$obj->peek]}\n";
233 $obj->{flags} |= VALID_SV;
240 @B::Stackobj::Const::ISA = 'B::Stackobj';
241 sub B::Stackobj::Const::new {
242 my ($class, $sv) = @_;
245 sv => $sv # holds the SV object until write_back happens
247 if ( ref($sv) eq "B::SPECIAL" ){
248 $obj->{type}= T_SPECIAL;
250 my $svflags = $sv->FLAGS;
251 if ($svflags & SVf_IOK) {
252 $obj->{flags} = VALID_INT|VALID_DOUBLE;
253 $obj->{type} = T_INT;
254 if ($svflags & SVf_IVisUV){
255 $obj->{flags} |= VALID_UNSIGNED;
256 $obj->{nv} = $obj->{iv} = $sv->UVX;
258 $obj->{nv} = $obj->{iv} = $sv->IV;
260 } elsif ($svflags & SVf_NOK) {
261 $obj->{flags} = VALID_INT|VALID_DOUBLE;
262 $obj->{type} = T_DOUBLE;
263 $obj->{iv} = $obj->{nv} = $sv->NV;
265 $obj->{type} = T_UNKNOWN;
271 sub B::Stackobj::Const::write_back {
273 return if $obj->{flags} & VALID_SV;
274 # Save the SV object and replace $obj->{sv} by its C source code name
275 $obj->{sv} = $obj->{sv}->save;
276 $obj->{flags} |= VALID_SV|VALID_INT|VALID_DOUBLE;
279 sub B::Stackobj::Const::load_int {
281 if (ref($obj->{sv}) eq "B::RV"){
282 $obj->{iv} = int($obj->{sv}->RV->PV);
284 $obj->{iv} = int($obj->{sv}->PV);
286 $obj->{flags} |= VALID_INT;
289 sub B::Stackobj::Const::load_double {
291 if (ref($obj->{sv}) eq "B::RV"){
292 $obj->{nv} = $obj->{sv}->RV->PV + 0.0;
294 $obj->{nv} = $obj->{sv}->PV + 0.0;
296 $obj->{flags} |= VALID_DOUBLE;
299 sub B::Stackobj::Const::invalidate {}
305 @B::Stackobj::Bool::ISA = 'B::Stackobj';
306 sub B::Stackobj::Bool::new {
307 my ($class, $preg) = @_;
310 flags => VALID_INT|VALID_DOUBLE,
313 preg => $preg # this holds our ref to the pseudo-reg
318 sub B::Stackobj::Bool::write_back {
320 return if $obj->{flags} & VALID_SV;
321 $obj->{sv} = "($obj->{iv} ? &PL_sv_yes : &PL_sv_no)";
322 $obj->{flags} |= VALID_SV;
325 # XXX Might want to handle as_double/set_double/load_double?
327 sub B::Stackobj::Bool::invalidate {}
335 B::Stackobj - Helper module for CC backend
347 Malcolm Beattie, C<mbeattie@sable.ox.ac.uk>