Changeset 15579 for src/Pugs/Parser

Timestamp:

03/11/07 03:13:07 (21 months ago)

Author:

audreyt

Message:

* Pugs.Parser.*: Properly support signature-affected

categories even in the middle of subroutine parsing:

my sub f ($x) { # named unary

f 1 + 2; # parsed as (f 1) + 2

} # at end of scope, resolve the inner &f

# into the PadEntry? itself

Location:

src/Pugs/Parser

Files:

• Export.hs (modified) (1 diff)
• Operator.hs (modified) (5 diffs)

src/Pugs/Parser/Export.hs

@@ -25 +25 @@
                         VCode sub | isMulti sub -> ('&':)
                         _                       -> id
-                    mkExp   = Syn ":=" [_Var name, Val val]
-                    mkSym   = _Sym scope (mkMulti name) mkExp
+                    mkSym   = _Sym scope (mkMulti name) (Val val) Noop
                 doExport scope mkSym
             case scope of

src/Pugs/Parser/Operator.hs

@@ -136 +136 @@
         | otherwise                 = Ann Parens (Syn "," [inner])
     forceParens (Ann x inner)       = Ann x (forceParens inner)
-    forceParens (Sym x y inner)     = Sym x y (forceParens inner)
+    forceParens (Sym x y init inner)= Sym x y init (forceParens inner)
     forceParens (Pad x y inner)     = Pad x y (forceParens inner)
     forceParens exp                 = exp
@@ -170 +170 @@
     let funs = catMaybes $! inlinePerformSTM $! do
         glob <- readTVar $ envGlobal env
-        let syms  = padToList (filterPad cur glob)
+        let vars  = padToList (filterPad cur glob)
                     ++ padToList (filterPad cur (envLexical env))
             pkg   = envPackage env
             cur var@MkVar{ v_sigil = SCode } = inScope pkg var
+            cur var@MkVar{ v_sigil = SCodeMulti } = inScope pkg var
             cur _ = False
-            vars  = concat [ map (\(_, tvar) -> (var, tvar)) tvars
-                           | (var, tvars) <- syms
-                           ]
         mapM (uncurry filterFun) vars
     return (length funs `seq` funs)
 
 {-# NOINLINE _RefToFunction #-}
-_RefToFunction :: H.HashTable (TVar VRef) (Maybe CurrentFunction)
-_RefToFunction = unsafePerformIO (H.new (==) hashTVar)
-
-hashTVar :: TVar VRef -> Int32
-hashTVar x = I32# (unsafeCoerce# x)
-
-filterFun :: Var -> TVar VRef -> STM (Maybe CurrentFunction)
-filterFun var tvar = var `seq` do
-    res <- unsafeIOToSTM (H.lookup _RefToFunction tvar)
+_RefToFunction :: H.HashTable PadEntry (Maybe CurrentFunction)
+_RefToFunction = unsafePerformIO (H.new (==) hashPadEntry)
+
+hashPadEntry :: PadEntry -> Int32
+hashPadEntry EntryConstant{ pe_value = v }  = I32# (unsafeCoerce# v)
+hashPadEntry x                              = I32# (unsafeCoerce# (pe_store x))
+
+-- hashTVar :: TVar VRef -> Int32
+-- hashTVar x = I32# (unsafeCoerce# x)
+
+filterFun :: Var -> PadEntry -> STM (Maybe CurrentFunction)
+filterFun var entry = var `seq` do
+    res <- unsafeIOToSTM (H.lookup _RefToFunction entry)
     case res of
         Just rv -> return rv
         Nothing -> do
-            ref <- readTVar tvar
+            ref <- readPadEntry entry
             case ref of
                 MkRef (ICode cv)
@@ -200 +202 @@
                         let rv = MkCurrentFunction var (code_assoc cv) (code_params cv)
                             res = seq rv (Just rv)
-                        unsafeIOToSTM (H.insert _RefToFunction tvar res)
+                        unsafeIOToSTM (H.insert _RefToFunction entry res)
                         return res
                 MkRef (IScalar sv)
@@ -207 +209 @@
                         let rv = MkCurrentFunction var (code_assoc cv) (code_params cv)
                             res = seq rv (Just rv)
-                        unsafeIOToSTM (H.insert _RefToFunction tvar res)
+                        unsafeIOToSTM (H.insert _RefToFunction entry res)
                         return res
                 _ -> do
-                    unsafeIOToSTM (H.insert _RefToFunction tvar Nothing)
+                    unsafeIOToSTM (H.insert _RefToFunction entry Nothing)
                     return Nothing
 
@@ -394 +396 @@
         _ -> con (sigil ++ name) [x,y]
 
+_STATE_START_RUN :: Var
+_STATE_START_RUN = cast "$?STATE_START_RUN"
+
 declAssignHack :: Exp -> Exp
 declAssignHack exp@(Syn "=" [lhs, _])
     | isDecl SState lhs = 
         let pad = unsafePerformSTM $! do
-                state_first_run <- newTVar =<< (fmap scalarRef $! newTVar (VInt 0))
-                state_fresh     <- newTVar False
-                return $! mkPad [(cast "$?STATE_START_RUN", [(state_fresh, state_first_run)])] in
+                proto           <- fmap scalarRef $! newTVar (VInt 0)
+                state_first_run <- newTVar proto
+                return $! mkPad [(_STATE_START_RUN, EntryStatic{ pe_type = mkType "Scalar", pe_value = proto, pe_store = state_first_run})] in
         Syn "block"
             [ Pad SState pad $!
                 Syn "if"
-                    [ App (_Var "&postfix:++") Nothing [_Var "$?STATE_START_RUN"]
+                    [ App (_Var "&postfix:++") Nothing [Var _STATE_START_RUN]
                     , lhs
                     , exp