Changeset 6432

Timestamp:

08/23/05 23:42:59 (3 years ago)

Author:

iblech

Message:

* Pugs.AST.Scope: Reorder the declarations of the various scope types -- SLet

and STemp do something to *existing* variables. Accidentally, this causes
temp.t to pass on normal Pugs!

* Pugs.Lexer, Pugs.Compile: Acommodate for that change.
* PIL2JS: temp! let!

• PIL: All JS functions have a block_leave_hooks array now, containing native JS functions to be called at block exit.
• PIL::PPad uses this variable to implement the (possible) variable restoration needed for temp and let.

* t/var/let.t, t/var/temp.t: Should "temp @array[$index]" work? I think so, but

Pugs doesn't even parse that. Added appropriate tests in a =pod block.
BTW, let.t passes 7/7, temp.t passes 22/22 (with TODO tests).

Files:

• perl5/PIL2JS/lib/PIL.pm (modified) (1 diff)
• perl5/PIL2JS/lib/PIL/PPad.pm (modified) (2 diffs)
• src/Pugs/AST/Scope.hs (modified) (1 diff)
• src/Pugs/Compile.hs (modified) (1 diff)
• src/Pugs/Lexer.hs (modified) (1 diff)
• t/var/let.t (modified) (2 diffs)
• t/var/temp.t (modified) (1 diff)

perl5/PIL2JS/lib/PIL.pm

@@ -115 +115 @@
   return sprintf <<EOF, $name, $restores, $lvalue ? "" : "new PIL2JS.Box.ReadOnly(", $lvalue ? "" : ")" }
 var __returncc = args.pop();
+var block_leave_hooks = [];
 var %s = function (retval) {
+  for(var i = 0; i < block_leave_hooks.length; i++) {
+    block_leave_hooks[i](retval);
+  }
+
   PIL2JS_callchain.pop(); PIL2JS_subpads.pop();
   %s;

perl5/PIL2JS/lib/PIL/PPad.pm

@@ -9 +9 @@
 
   die unless keys %$self == 3;
-  die unless $self->{pScope} eq "SMy";
+  # A SOur should never reach use (SOurs are compiled into __init_ subs).
+  die if     $self->{pScope} eq "SOur";
   die unless ref $self->{pSyms} eq "ARRAY";
   die unless $self->{pStmts}->isa("PIL::PStmts");
 
-  if($PIL::IN_SUBLIKE) {
+  # Skip creating a new sub-pad if
+  #   a) we're in a subroutine (in this case, we use JS' lexicals) or
+  #   b) we're compiling a SLet, STemp, or SState (which all use an existing
+  #      variable).
+  if($PIL::IN_SUBLIKE or $self->{pScope} =~ /^(SLet|STemp|SState)$/) {
     return bless {
       pScope => $self->{pScope},
-      pSyms  => [map {{ fixed => $_->[0], user => $_->[0] }} @{ $self->{pSyms} }],
+      pSyms  => [map {{ fixed => PIL::lookup_var($_->[0]), user => $_->[0] }} @{ $self->{pSyms} }],
       pStmts => $self->{pStmts}->fixup,
     } => "PIL::PPad";
@@ -52 +57 @@
   return
     join("; ", map {
-      sprintf "%s%s = %s; pad[%s] = %s",
-        $PIL::IN_SUBLIKE ? "var " : "",
+      my ($jsname, $qname, $undef) = (
         PIL::name_mangle($_->{fixed}),
+        PIL::doublequote($_->{user}),
         PIL::undef_of($_->{fixed}),
-        PIL::doublequote($_->{user}),
-        PIL::name_mangle($_->{fixed});
+      );
+
+      if($self->{pScope} eq "SMy") {
+        "$decl$jsname = $undef; pad[$qname] = $jsname";
+      } elsif($self->{pScope} eq "STemp") {
+        PIL::fail("Can't use temp variable declarator outside a sub-scope!")
+          unless $PIL::IN_SUBLIKE;
+        <<EOF;
+(function () {
+  var backup = $jsname.FETCH();
+  block_leave_hooks.push(function () {
+    $jsname.STORE(new PIL2JS.Box.Constant(backup));
+  });
+})()
+EOF
+      } elsif($self->{pScope} eq "SLet") {
+        PIL::fail("Can't use temp variable declarator outside a sub-scope!")
+          unless $PIL::IN_SUBLIKE;
+        <<EOF;
+(function () {
+  var backup = $jsname.FETCH();
+  block_leave_hooks.push(function (retval) {
+    if(!PIL2JS.cps2normal(
+      _26main_3a_3aprefix_3a_3f.FETCH(),
+      [PIL2JS.Context.ItemAny, retval]
+    ).FETCH())
+      $jsname.STORE(new PIL2JS.Box.Constant(backup));
+  });
+})()
+EOF
+      } else {
+        die;
+      }
     } @{ $self->{pSyms} }) .
     ";\n" .

src/Pugs/AST/Scope.hs

@@ -7 +7 @@
 -- | The scope of a variable declaration.
 data Scope = SState  -- ^ Persistent across calls
+           | SLet    -- ^ Hypotheticalised (reverted upon failure)
+           | STemp   -- ^ Temporary (reverted at scope exit)
            | SMy     -- ^ Lexical
            | SOur    -- ^ Package
-           | SLet    -- ^ Hypotheticalised (reverted upon failure)
-           | STemp   -- ^ Temporary (reverted at scope exit)
            | SGlobal -- ^ Global
     deriving (Show, Eq, Ord, Enum)

src/Pugs/Compile.hs

@@ -142 +142 @@
     compile (Stmts (Pad SOur _ exp) rest) = do
         compile $ mergeStmts exp rest
-    compile (Stmts (Pad _ pad exp) rest) = do
+    compile (Stmts (Pad scope pad exp) rest) = do
         expC    <- compile $ mergeStmts exp rest
         padC    <- compile $ padToList pad
-        return $ PPad SMy ((map fst $ padToList pad) `zip` padC) expC
+        return $ PPad scope ((map fst $ padToList pad) `zip` padC) expC
     compile exp = compileStmts exp
 

src/Pugs/Lexer.hs

@@ -279 +279 @@
 ruleScopeName :: RuleParser String
 ruleScopeName = choice . map symbol . map (map toLower) . map (tail . show)
-    $ [SState .. STemp]
+    $ [SState .. SOur]
 
 postSpace :: GenParser Char st a -> GenParser Char st a

t/var/let.t

@@ -33 +33 @@
 
 # Test that let() restores the variable at scope exit, not at subroutine
-# entry.
+# entry.  (This might be a possibly bug.)
 {
   my $a     = 42;
@@ -45 +45 @@
   is $a, 23, "let() should not restore the variable, as our block exited succesfully (2)";
 }
+
+=pod
+
+Should these work? (They don't even parse currently.)
+
+{
+  my @array = (0, 1, 2);
+  {
+    let @array[1] = 42;
+    is @array[1], 42, "let() changed our array element";
+    0;
+  }
+  is @array[1], 1, "let() restored our array element";
+}
+
+=cut

t/var/temp.t

@@ -37 +37 @@
   is $pkgvar, 42, "temp() restored the package variable (3-2)", :todo<bug>;
 }
+
+=pod
+
+Should these work? (They don't even parse currently.)
+
+{
+  my @array = (0, 1, 2);
+  {
+    temp @array[1] = 42;
+    is @array[1], 42, "temp() changed our array element";
+  }
+  is @array[1], 1, "temp() restored our array element";
+}
+
+=cut
 
 # Block TEMP{}