Idris2/tests/chez/chez022/usealloc.idr

%foreign "C:mkThing, libmkalloc"
prim__mkThing : PrimIO AnyPtr
%foreign "C:getStr, libmkalloc"
prim__getStr : GCAnyPtr -> PrimIO String
%foreign "C:freeThing, libmkalloc"
prim__freeThing : AnyPtr -> PrimIO ()

mkThing : IO AnyPtr
mkThing = primIO prim__mkThing

getThingStr : GCAnyPtr -> IO String
getThingStr t = primIO (prim__getStr t)

freeThing : AnyPtr -> IO ()
freeThing t = primIO (prim__freeThing t)

doThings : IO ()
doThings
     = do xp <- mkThing
          yp <- mkThing

          x <- onCollectAny xp (\p => do putStrLn "Free X"
                                         freeThing p)
          y <- onCollectAny yp (\p => do putStrLn "Free Y"
                                         freeThing p)

          putStrLn !(getThingStr x)
          putStrLn !(getThingStr y)

main : IO ()
main = do doThings
          putStrLn "Done"
Add finalisers to Chez back end This involves new primitives GCPtr and GCAnyPtr which are pointer types that have finalisers attached. The finalisers are run when the associated pointer goes out of scope. In the test, I am assuming that the GC will only be called once, right at the end. Otherwise, the output isn't guaranteed to be deterministic! Let's see how this assumption holds... This is currently Chez only. I think it'll be easy enough to add to the Racket and Gambit back ends too. 2020-06-08 22:30:34 +03:00			`%foreign "C:mkThing, libmkalloc"`
			`prim__mkThing : PrimIO AnyPtr`
			`%foreign "C:getStr, libmkalloc"`
			`prim__getStr : GCAnyPtr -> PrimIO String`
			`%foreign "C:freeThing, libmkalloc"`
			`prim__freeThing : AnyPtr -> PrimIO ()`

			`mkThing : IO AnyPtr`
			`mkThing = primIO prim__mkThing`

			`getThingStr : GCAnyPtr -> IO String`
			`getThingStr t = primIO (prim__getStr t)`

			`freeThing : AnyPtr -> IO ()`
			`freeThing t = primIO (prim__freeThing t)`

			`doThings : IO ()`
Remove trailing whitespaces and add trailing newlines 2021-01-16 10:03:45 +03:00			`doThings`
Add finalisers to Chez back end This involves new primitives GCPtr and GCAnyPtr which are pointer types that have finalisers attached. The finalisers are run when the associated pointer goes out of scope. In the test, I am assuming that the GC will only be called once, right at the end. Otherwise, the output isn't guaranteed to be deterministic! Let's see how this assumption holds... This is currently Chez only. I think it'll be easy enough to add to the Racket and Gambit back ends too. 2020-06-08 22:30:34 +03:00			`= do xp <- mkThing`
			`yp <- mkThing`

			`x <- onCollectAny xp (\p => do putStrLn "Free X"`
			`freeThing p)`
			`y <- onCollectAny yp (\p => do putStrLn "Free Y"`
			`freeThing p)`

			`putStrLn !(getThingStr x)`
			`putStrLn !(getThingStr y)`

			`main : IO ()`
			`main = do doThings`
			`putStrLn "Done"`