X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Frts%2FRtsAPI.c;h=651a497fdfb07a5edd7313c449b055fb9f132436;hb=22f5f69672b91d3538366660948c9e40a9c67f02;hp=2722bf447decf319c7236b0312256388ae4f6f6a;hpb=af13609607da81e7837a7c7c598de82452363ab5;p=ghc-hetmet.git

diff --git a/ghc/rts/RtsAPI.c b/ghc/rts/RtsAPI.c
index 2722bf4..651a497 100644
--- a/ghc/rts/RtsAPI.c
+++ b/ghc/rts/RtsAPI.c
@@ -1,5 +1,5 @@
 /* ----------------------------------------------------------------------------
- * $Id: RtsAPI.c,v 1.39 2003/01/25 15:54:49 wolfgang Exp $
+ * $Id: RtsAPI.c,v 1.46 2003/09/21 22:20:56 wolfgang Exp $
  *
  * (c) The GHC Team, 1998-2001
  *
@@ -21,6 +21,8 @@
 
 #include <stdlib.h>
 
+static Capability *rtsApiCapability = NULL;
+
 /* ----------------------------------------------------------------------------
    Building Haskell objects from C datatypes.
    ------------------------------------------------------------------------- */
@@ -29,7 +31,7 @@ rts_mkChar (HsChar c)
 {
   StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, Czh_con_info, CCS_SYSTEM);
-  p->payload[0]  = (StgClosure *)(StgChar)c;
+  p->payload[0]  = (StgClosure *)(StgWord)(StgChar)c;
   return p;
 }
 
@@ -170,7 +172,15 @@ rts_mkPtr (HsPtr a)
   return p;
 }
 
-#ifdef COMPILER /* GHC has em, Hugs doesn't */
+HaskellObj
+rts_mkFunPtr (HsFunPtr a)
+{
+  StgClosure *p = (StgClosure *)allocate(sizeofW(StgHeader)+1);
+  SET_HDR(p, FunPtr_con_info, CCS_SYSTEM);
+  p->payload[0]  = (StgClosure *)a;
+  return p;
+}
+
 HaskellObj
 rts_mkBool (HsBool b)
 {
@@ -186,7 +196,6 @@ rts_mkString (char *s)
 {
   return rts_apply((StgClosure *)unpackCString_closure, rts_mkPtr(s));
 }
-#endif /* COMPILER */
 
 HaskellObj
 rts_apply (HaskellObj f, HaskellObj arg)
@@ -251,7 +260,7 @@ rts_getInt32 (HaskellObj p)
     // See comment above:
     // ASSERT(p->header.info == I32zh_con_info ||
     //        p->header.info == I32zh_static_info);
-    return (HsInt32)(p->payload[0]);
+    return (HsInt32)(HsInt)(p->payload[0]);
 }
 
 HsInt64
@@ -297,7 +306,7 @@ rts_getWord32 (HaskellObj p)
     // See comment above:
     // ASSERT(p->header.info == W32zh_con_info ||
     //        p->header.info == W32zh_static_info);
-    return (HsWord32)(p->payload[0]);
+    return (HsWord32)(HsWord)(p->payload[0]);
 }
 
 
@@ -348,7 +357,15 @@ rts_getPtr (HaskellObj p)
     return (void *)(p->payload[0]);
 }
 
-#ifdef COMPILER /* GHC has em, Hugs doesn't */
+HsFunPtr
+rts_getFunPtr (HaskellObj p)
+{
+    // See comment above:
+    // ASSERT(p->header.info == FunPtr_con_info ||
+    //        p->header.info == FunPtr_static_info);
+    return (void *)(p->payload[0]);
+}
+
 HsBool
 rts_getBool (HaskellObj p)
 {
@@ -360,7 +377,6 @@ rts_getBool (HaskellObj p)
     barf("rts_getBool: not a Bool");
   }
 }
-#endif /* COMPILER */
 
 /* ----------------------------------------------------------------------------
    Evaluating Haskell expressions
@@ -371,7 +387,7 @@ rts_eval (HaskellObj p, /*out*/HaskellObj *ret)
     StgTSO *tso;
 
     tso = createGenThread(RtsFlags.GcFlags.initialStkSize, p);
-    return scheduleWaitThread(tso,ret);
+    return scheduleWaitThread(tso,ret,rtsApiCapability);
 }
 
 SchedulerStatus
@@ -380,7 +396,7 @@ rts_eval_ (HaskellObj p, unsigned int stack_size, /*out*/HaskellObj *ret)
     StgTSO *tso;
     
     tso = createGenThread(stack_size, p);
-    return scheduleWaitThread(tso,ret);
+    return scheduleWaitThread(tso,ret,rtsApiCapability);
 }
 
 /*
@@ -393,22 +409,7 @@ rts_evalIO (HaskellObj p, /*out*/HaskellObj *ret)
     StgTSO* tso; 
     
     tso = createStrictIOThread(RtsFlags.GcFlags.initialStkSize, p);
-    return scheduleWaitThread(tso,ret);
-}
-
-/*
- * Identical to rts_evalIO(), but won't create a new task/OS thread
- * to evaluate the Haskell thread. Used by main() only. Hack.
- */
- 
-SchedulerStatus
-rts_mainEvalIO(HaskellObj p, /*out*/HaskellObj *ret)
-{
-    StgTSO* tso;
-    
-    tso = createStrictIOThread(RtsFlags.GcFlags.initialStkSize, p);
-    scheduleThread(tso);
-    return waitThread(tso, ret);
+    return scheduleWaitThread(tso,ret,rtsApiCapability);
 }
 
 /*
@@ -426,9 +427,9 @@ rts_evalStableIO (HsStablePtr s, /*out*/HsStablePtr *ret)
     
     p = (StgClosure *)deRefStablePtr(s);
     tso = createStrictIOThread(RtsFlags.GcFlags.initialStkSize, p);
-    stat = scheduleWaitThread(tso,&r);
+    stat = scheduleWaitThread(tso,&r,rtsApiCapability);
 
-    if (stat == Success) {
+    if (stat == Success && ret != NULL) {
 	ASSERT(r != NULL);
 	*ret = getStablePtr((StgPtr)r);
     }
@@ -440,12 +441,21 @@ rts_evalStableIO (HsStablePtr s, /*out*/HsStablePtr *ret)
  * Like rts_evalIO(), but doesn't force the action's result.
  */
 SchedulerStatus
-rts_evalLazyIO (HaskellObj p, unsigned int stack_size, /*out*/HaskellObj *ret)
+rts_evalLazyIO (HaskellObj p, /*out*/HaskellObj *ret)
+{
+    StgTSO *tso;
+
+    tso = createIOThread(RtsFlags.GcFlags.initialStkSize, p);
+    return scheduleWaitThread(tso,ret,rtsApiCapability);
+}
+
+SchedulerStatus
+rts_evalLazyIO_ (HaskellObj p, unsigned int stack_size, /*out*/HaskellObj *ret)
 {
     StgTSO *tso;
 
     tso = createIOThread(stack_size, p);
-    return scheduleWaitThread(tso,ret);
+    return scheduleWaitThread(tso,ret,rtsApiCapability);
 }
 
 /* Convenience function for decoding the returned status. */
@@ -468,33 +478,31 @@ rts_checkSchedStatus ( char* site, SchedulerStatus rc )
     }
 }
 
-#ifdef RTS_SUPPORTS_THREADS
 void
 rts_lock()
 {
-	Capability *cap;
+#ifdef RTS_SUPPORTS_THREADS
 	ACQUIRE_LOCK(&sched_mutex);
 	
 		// we request to get the capability immediately, in order to
 		// a) stop other threads from using allocate()
 		// b) wake the current worker thread from awaitEvent()
 		//       (so that a thread started by rts_eval* will start immediately)
-	grabReturnCapability(&sched_mutex,&cap);
-	
-		// now that we have the capability, we don't need it anymore
-		// (other threads will continue to run as soon as we release the sched_mutex)
-	releaseCapability(cap);
+	grabReturnCapability(&sched_mutex,&rtsApiCapability);
 	
 		// In the RTS hasn't been entered yet,
 		// start a RTS task.
 		// If there is already a task available (waiting for the work capability),
 		// this will do nothing.
 	startSchedulerTask();
+#endif
 }
 
 void
 rts_unlock()
 {
+#ifdef RTS_SUPPORTS_THREADS
+	rtsApiCapability = NULL;
 	RELEASE_LOCK(&sched_mutex);
-}
 #endif
+}