
    0 | module System.UV.Raw.File
    1 | 
    2 | import System.UV.Raw.Callback
    3 | import System.UV.Raw.Handle
    4 | import System.UV.Raw.Loop
    5 | import System.UV.Raw.Pointer
    6 | import System.UV.Raw.Req
    7 | import System.UV.Raw.Util
    8 | 
    9 | import public System.UV.Data.File
   10 | 
   11 | %default total
   12 | 
   13 | export
   14 | data UV_Timespec_T : Type where [external]
   15 | 
   16 | export
   17 | data Stat : Type where
   18 | 
   19 | export
   20 | data StatFs : Type where
   21 | 
   22 | export
   23 | data Dir : Type where
   24 | 
   25 | export
   26 | data Dirent : Type where
   27 | 
   28 | ||| Alias for a foreign callable code object
   29 | public export
   30 | 0 FsCB : Type
   31 | FsCB = AnyPtr
   32 | 
   33 | --------------------------------------------------------------------------------
   34 | -- FFI
   35 | --------------------------------------------------------------------------------
   36 | 
   37 | export %foreign (idris_uv "uv_get_st_dev")
   38 | st_dev : Ptr Stat -> Bits64
   39 | 
   40 | export %foreign (idris_uv "uv_get_st_mode")
   41 | st_mode : Ptr Stat -> Bits64
   42 | 
   43 | export %foreign (idris_uv "uv_get_st_nlink")
   44 | st_nlink : Ptr Stat -> Bits64
   45 | 
   46 | export %foreign (idris_uv "uv_get_st_uid")
   47 | st_uid : Ptr Stat -> Bits64
   48 | 
   49 | export %foreign (idris_uv "uv_get_st_gid")
   50 | st_gid : Ptr Stat -> Bits64
   51 | 
   52 | export %foreign (idris_uv "uv_get_st_rdev")
   53 | st_rdev : Ptr Stat -> Bits64
   54 | 
   55 | export %foreign (idris_uv "uv_get_st_ino")
   56 | st_ino : Ptr Stat -> Bits64
   57 | 
   58 | export %foreign (idris_uv "uv_get_st_size")
   59 | st_size : Ptr Stat -> Bits64
   60 | 
   61 | export %foreign (idris_uv "uv_get_st_blksize")
   62 | st_blksize : Ptr Stat -> Bits64
   63 | 
   64 | export %foreign (idris_uv "uv_get_st_blocks")
   65 | st_blocks : Ptr Stat -> Bits64
   66 | 
   67 | export %foreign (idris_uv "uv_get_st_flags")
   68 | st_flags : Ptr Stat -> Bits64
   69 | 
   70 | export %foreign (idris_uv "uv_get_st_gen")
   71 | st_gen : Ptr Stat -> Bits64
   72 | 
   73 | export %foreign (idris_uv "uv_get_st_atim")
   74 | st_atim : Ptr Stat -> UV_Timespec_T
   75 | 
   76 | export %foreign (idris_uv "uv_get_st_mtim")
   77 | st_mtim : Ptr Stat -> UV_Timespec_T
   78 | 
   79 | export %foreign (idris_uv "uv_get_st_ctim")
   80 | st_ctim : Ptr Stat -> UV_Timespec_T
   81 | 
   82 | export %foreign (idris_uv "uv_get_st_birthtim")
   83 | st_birthtim : Ptr Stat -> UV_Timespec_T
   84 | 
   85 | export %foreign (idris_uv "uv_get_f_type")
   86 | f_type : Ptr StatFs -> Bits64
   87 | 
   88 | export %foreign (idris_uv "uv_get_f_bsize")
   89 | f_bsize : Ptr StatFs -> Bits64
   90 | 
   91 | export %foreign (idris_uv "uv_get_f_blocks")
   92 | f_blocks : Ptr StatFs -> Bits64
   93 | 
   94 | export %foreign (idris_uv "uv_get_f_bfree")
   95 | f_bfree : Ptr StatFs -> Bits64
   96 | 
   97 | export %foreign (idris_uv "uv_get_f_bavail")
   98 | f_bavail : Ptr StatFs -> Bits64
   99 | 
  100 | export %foreign (idris_uv "uv_get_f_files")
  101 | f_files : Ptr StatFs -> Bits64
  102 | 
  103 | export %foreign (idris_uv "uv_get_f_ffree")
  104 | f_ffree : Ptr StatFs -> Bits64
  105 | 
  106 | export %foreign (idris_uv "uv_get_tv_sec")
  107 | tv_sec : UV_Timespec_T -> Int64
  108 | 
  109 | export %foreign (idris_uv "uv_get_tv_nsec")
  110 | tv_nsec : UV_Timespec_T -> Int64
  111 | 
  112 | export %foreign (idris_uv "uv_fs_get_result")
  113 | prim__uv_fs_get_result : Ptr Fs -> PrimIO Int32
  114 | 
  115 | %foreign (idris_uv "uv_fs_get_ptr")
  116 | prim__uv_fs_get_ptr : Ptr Fs -> PrimIO AnyPtr
  117 | 
  118 | %foreign (idris_uv "uv_fs_get_path")
  119 | prim__uv_fs_get_path : Ptr Fs -> PrimIO (Ptr Char)
  120 | 
  121 | %foreign (idris_uv "uv_fs_get_statbuf")
  122 | prim__uv_fs_get_statbuf : Ptr Fs -> PrimIO (Ptr Stat)
  123 | 
  124 | %foreign (idris_uv "uv_fs_get_dirent_name")
  125 | prim__uv_fs_get_dirent_name : Ptr Dirent -> PrimIO (Ptr Char)
  126 | 
  127 | %foreign (idris_uv "uv_fs_get_dirent_type")
  128 | prim__uv_fs_get_dirent_type : Ptr Dirent -> PrimIO Int32
  129 | 
  130 | %foreign (idris_uv "uv_fs_req_cleanup")
  131 | prim__uv_fs_req_cleanup : Ptr Fs -> PrimIO ()
  132 | 
  133 | %foreign (idris_uv "uv_fs_unlink")
  134 | prim__uv_fs_unlink :
  135 |      Ptr Loop
  136 |   -> Ptr Fs
  137 |   -> String
  138 |   -> AnyPtr
  139 |   -> PrimIO Int32
  140 | 
  141 | %foreign (idris_uv "uv_fs_mkdir")
  142 | prim__uv_fs_mkdir :
  143 |      Ptr Loop
  144 |   -> Ptr Fs
  145 |   -> String
  146 |   -> (mode : Int32)
  147 |   -> AnyPtr
  148 |   -> PrimIO Int32
  149 | 
  150 | %foreign (idris_uv "uv_fs_mkdtemp")
  151 | prim__uv_fs_mkdtemp :
  152 |      Ptr Loop
  153 |   -> Ptr Fs
  154 |   -> (tpl : String)
  155 |   -> AnyPtr
  156 |   -> PrimIO Int32
  157 | 
  158 | %foreign (idris_uv "uv_fs_mkstemp")
  159 | prim__uv_fs_mkstemp :
  160 |      Ptr Loop
  161 |   -> Ptr Fs
  162 |   -> (tpl : String)
  163 |   -> AnyPtr
  164 |   -> PrimIO Int32
  165 | 
  166 | %foreign (idris_uv "uv_fs_rmdir")
  167 | prim__uv_fs_rmdir :
  168 |      Ptr Loop
  169 |   -> Ptr Fs
  170 |   -> (path : String)
  171 |   -> AnyPtr
  172 |   -> PrimIO Int32
  173 | 
  174 | %foreign (idris_uv "uv_fs_opendir")
  175 | prim__uv_fs_opendir :
  176 |      Ptr Loop
  177 |   -> Ptr Fs
  178 |   -> (path : String)
  179 |   -> AnyPtr
  180 |   -> PrimIO Int32
  181 | 
  182 | %foreign (idris_uv "uv_fs_closedir")
  183 | prim__uv_fs_closedir :
  184 |      Ptr Loop
  185 |   -> Ptr Fs
  186 |   -> (dir : Ptr Dir)
  187 |   -> AnyPtr
  188 |   -> PrimIO Int32
  189 | 
  190 | %foreign (idris_uv "uv_fs_readdir")
  191 | prim__uv_fs_readdir :
  192 |      Ptr Loop
  193 |   -> Ptr Fs
  194 |   -> (dir : Ptr Dir)
  195 |   -> AnyPtr
  196 |   -> PrimIO Int32
  197 | 
  198 | %foreign (idris_uv "uv_fs_scandir")
  199 | prim__uv_fs_scandir :
  200 |      Ptr Loop
  201 |   -> Ptr Fs
  202 |   -> (path : String)
  203 |   -> (flags : Int32)
  204 |   -> AnyPtr
  205 |   -> PrimIO Int32
  206 | 
  207 | %foreign (idris_uv "uv_fs_scandir_next")
  208 | prim__uv_fs_scandir_next : Ptr Fs -> Ptr Dirent -> PrimIO Int32
  209 | 
  210 | %foreign (idris_uv "uv_dirents")
  211 | prim__uv_dirents : Ptr Dir -> PrimIO (Ptr Dirent)
  212 | 
  213 | %foreign (idris_uv "uv_nentries")
  214 | prim__uv_nentries : Ptr Dir -> PrimIO Bits32
  215 | 
  216 | %foreign (idris_uv "uv_fs_stat")
  217 | prim__uv_fs_stat :
  218 |      Ptr Loop
  219 |   -> Ptr Fs
  220 |   -> (path : String)
  221 |   -> AnyPtr
  222 |   -> PrimIO Int32
  223 | 
  224 | %foreign (idris_uv "uv_fs_fstat")
  225 | prim__uv_fs_fstat :
  226 |      Ptr Loop
  227 |   -> Ptr Fs
  228 |   -> (file : Int32)
  229 |   -> AnyPtr
  230 |   -> PrimIO Int32
  231 | 
  232 | %foreign (idris_uv "uv_fs_lstat")
  233 | prim__uv_fs_lstat :
  234 |      Ptr Loop
  235 |   -> Ptr Fs
  236 |   -> (path : String)
  237 |   -> AnyPtr
  238 |   -> PrimIO Int32
  239 | 
  240 | %foreign (idris_uv "uv_fs_statfs")
  241 | prim__uv_fs_statfs :
  242 |      Ptr Loop
  243 |   -> Ptr Fs
  244 |   -> (path : String)
  245 |   -> AnyPtr
  246 |   -> PrimIO Int32
  247 | 
  248 | %foreign (idris_uv "uv_fs_open")
  249 | prim__uv_fs_open :
  250 |      Ptr Loop
  251 |   -> Ptr Fs
  252 |   -> String
  253 |   -> (flags,mode : Bits32)
  254 |   -> (cb : AnyPtr)
  255 |   -> PrimIO Int32
  256 | 
  257 | %foreign (idris_uv "idris_uv_fs_read")
  258 | prim__uv_fs_read :
  259 |      Ptr Loop
  260 |   -> Ptr Fs
  261 |   -> (file   : Int32)
  262 |   -> (buf    : Ptr Bits8)
  263 |   -> (size   : Bits32)
  264 |   -> (offset : Int64)
  265 |   -> (cb     : AnyPtr)
  266 |   -> PrimIO Int32
  267 | 
  268 | %foreign (idris_uv "idris_uv_fs_write")
  269 | prim__uv_fs_write :
  270 |      Ptr Loop
  271 |   -> Ptr Fs
  272 |   -> (file   : Int32)
  273 |   -> (buf    : Ptr Bits8)
  274 |   -> (size   : Bits32)
  275 |   -> (offset : Int64)
  276 |   -> (cb     : AnyPtr)
  277 |   -> PrimIO Int32
  278 | 
  279 | %foreign (idris_uv "uv_fs_close")
  280 | prim__uv_fs_close :
  281 |      Ptr Loop
  282 |   -> Ptr Fs
  283 |   -> (file : Int32)
  284 |   -> (cb   : AnyPtr)
  285 |   -> PrimIO Int32
  286 | 
  287 | %foreign (idris_uv "uv_fs_rename")
  288 | prim__uv_fs_rename :
  289 |      Ptr Loop
  290 |   -> Ptr Fs
  291 |   -> (path, newpath : String)
  292 |   -> (cb   : AnyPtr)
  293 |   -> PrimIO Int32
  294 | 
  295 | %foreign (idris_uv "uv_fs_fsync")
  296 | prim__uv_fs_fsync :
  297 |      Ptr Loop
  298 |   -> Ptr Fs
  299 |   -> (file : Int32)
  300 |   -> (cb   : AnyPtr)
  301 |   -> PrimIO Int32
  302 | 
  303 | %foreign (idris_uv "uv_fs_fdatasync")
  304 | prim__uv_fs_fdatasync :
  305 |      Ptr Loop
  306 |   -> Ptr Fs
  307 |   -> (file : Int32)
  308 |   -> (cb   : AnyPtr)
  309 |   -> PrimIO Int32
  310 | 
  311 | %foreign (idris_uv "uv_fs_fdatasync")
  312 | prim__uv_fs_ftruncate :
  313 |      Ptr Loop
  314 |   -> Ptr Fs
  315 |   -> (file : Int32)
  316 |   -> (offset : Int64)
  317 |   -> (cb   : AnyPtr)
  318 |   -> PrimIO Int32
  319 | 
  320 | %foreign (idris_uv "uv_fs_fdatasync")
  321 | prim__uv_fs_copyfile :
  322 |      Ptr Loop
  323 |   -> Ptr Fs
  324 |   -> (path, newpath : String)
  325 |   -> (flags : Int32)
  326 |   -> (cb   : AnyPtr)
  327 |   -> PrimIO Int32
  328 | 
  329 | %foreign (idris_uv "uv_fs_sendfile")
  330 | prim__uv_fs_sendfile :
  331 |      Ptr Loop
  332 |   -> Ptr Fs
  333 |   -> (outFile, inFile : Int32)
  334 |   -> (offset : Int64)
  335 |   -> (length : Bits32)
  336 |   -> (cb   : AnyPtr)
  337 |   -> PrimIO Int32
  338 | 
  339 | %foreign (idris_uv "uv_fs_access")
  340 | prim__uv_fs_access :
  341 |      Ptr Loop
  342 |   -> Ptr Fs
  343 |   -> (path : String)
  344 |   -> (mode : Int32)
  345 |   -> (cb   : AnyPtr)
  346 |   -> PrimIO Int32
  347 | 
  348 | %foreign (idris_uv "uv_fs_chmod")
  349 | prim__uv_fs_chmod :
  350 |      Ptr Loop
  351 |   -> Ptr Fs
  352 |   -> (path : String)
  353 |   -> (mode : Int32)
  354 |   -> (cb   : AnyPtr)
  355 |   -> PrimIO Int32
  356 | 
  357 | %foreign (idris_uv "uv_fs_fchmod")
  358 | prim__uv_fs_fchmod :
  359 |      Ptr Loop
  360 |   -> Ptr Fs
  361 |   -> (file : Int32)
  362 |   -> (mode : Int32)
  363 |   -> (cb   : AnyPtr)
  364 |   -> PrimIO Int32
  365 | 
  366 | %foreign (idris_uv "uv_fs_utime")
  367 | prim__uv_fs_utime :
  368 |      Ptr Loop
  369 |   -> Ptr Fs
  370 |   -> (path : String)
  371 |   -> (atime, mtime : Double)
  372 |   -> (cb   : AnyPtr)
  373 |   -> PrimIO Int32
  374 | 
  375 | %foreign (idris_uv "uv_fs_futime")
  376 | prim__uv_fs_futime :
  377 |      Ptr Loop
  378 |   -> Ptr Fs
  379 |   -> (file : Int32)
  380 |   -> (atime, mtime : Double)
  381 |   -> (cb   : AnyPtr)
  382 |   -> PrimIO Int32
  383 | 
  384 | %foreign (idris_uv "uv_fs_lutime")
  385 | prim__uv_fs_lutime :
  386 |      Ptr Loop
  387 |   -> Ptr Fs
  388 |   -> (path : String)
  389 |   -> (atime, mtime : Double)
  390 |   -> (cb   : AnyPtr)
  391 |   -> PrimIO Int32
  392 | 
  393 | %foreign (idris_uv "uv_fs_link")
  394 | prim__uv_fs_link :
  395 |      Ptr Loop
  396 |   -> Ptr Fs
  397 |   -> (path, newpath : String)
  398 |   -> (cb   : AnyPtr)
  399 |   -> PrimIO Int32
  400 | 
  401 | %foreign (idris_uv "uv_fs_symlink")
  402 | prim__uv_fs_symlink :
  403 |      Ptr Loop
  404 |   -> Ptr Fs
  405 |   -> (path, newpath : String)
  406 |   -> (flags : Int32)
  407 |   -> (cb   : AnyPtr)
  408 |   -> PrimIO Int32
  409 | 
  410 | %foreign (idris_uv "uv_fs_readlink")
  411 | prim__uv_fs_readlink :
  412 |      Ptr Loop
  413 |   -> Ptr Fs
  414 |   -> (path : String)
  415 |   -> (cb   : AnyPtr)
  416 |   -> PrimIO Int32
  417 | 
  418 | %foreign (idris_uv "uv_fs_realpath")
  419 | prim__uv_fs_realpath :
  420 |      Ptr Loop
  421 |   -> Ptr Fs
  422 |   -> (path : String)
  423 |   -> (cb   : AnyPtr)
  424 |   -> PrimIO Int32
  425 | 
  426 | %foreign (idris_uv "uv_fs_chown")
  427 | prim__uv_fs_chown :
  428 |      Ptr Loop
  429 |   -> Ptr Fs
  430 |   -> (path : String)
  431 |   -> (uid, gid : Int32)
  432 |   -> (cb   : AnyPtr)
  433 |   -> PrimIO Int32
  434 | 
  435 | %foreign (idris_uv "uv_fs_fchown")
  436 | prim__uv_fs_fchown :
  437 |      Ptr Loop
  438 |   -> Ptr Fs
  439 |   -> (file : String)
  440 |   -> (uid, gid : Int32)
  441 |   -> (cb   : AnyPtr)
  442 |   -> PrimIO Int32
  443 | 
  444 | %foreign (idris_uv "uv_fs_lchown")
  445 | prim__uv_fs_lchown :
  446 |      Ptr Loop
  447 |   -> Ptr Fs
  448 |   -> (path : String)
  449 |   -> (uid, gid : Int32)
  450 |   -> (cb   : AnyPtr)
  451 |   -> PrimIO Int32
  452 | 
  453 | --------------------------------------------------------------------------------
  454 | -- API
  455 | --------------------------------------------------------------------------------
  456 | 
  457 | export %inline
  458 | uv_fs_req_cleanup : HasIO io => Ptr Fs -> io ()
  459 | uv_fs_req_cleanup fp = primIO $ prim__uv_fs_req_cleanup fp
  460 | 
  461 | parameters {auto has : HasIO io}
  462 | 
  463 |   localCB : (Ptr Fs -> IO ()) -> io FsCB
  464 |   localCB f =
  465 |     ptrCB $ \p => do
  466 |       f p
  467 |       uv_fs_req_cleanup p
  468 |       freeReq p
  469 | 
  470 |   ||| Synchronously run a file system request.
  471 |   export
  472 |   sync : (Ptr Fs -> FsCB -> io a) -> io a
  473 |   sync f = do
  474 |     fs <- mallocPtr Fs
  475 |     res <- f fs prim__getNullAnyPtr
  476 |     freePtr fs
  477 |     pure res
  478 | 
  479 |   ||| Asynchronously run a file system request.
  480 |   export
  481 |   async : (Ptr Fs -> FsCB -> io a) -> (Ptr Fs -> IO ()) -> io a
  482 |   async f cb = do
  483 |     fscb <- localCB cb
  484 |     p    <- mallocPtr Fs
  485 |     uv_req_set_data p fscb
  486 |     f p fscb
  487 | 
  488 |   ||| Asynchronously run a file system request without running a
  489 |   ||| a custom callback.
  490 |   export %inline
  491 |   async' : (Ptr Fs -> FsCB -> io a) -> io a
  492 |   async' f = async f (\_ => pure ())
  493 | 
  494 |   ||| Returns the result code received after a file operation.
  495 |   export %inline
  496 |   uv_fs_get_result : Ptr Fs -> io Int32
  497 |   uv_fs_get_result p = primIO $ prim__uv_fs_get_result p
  498 | 
  499 |   ||| Returns the result of `uv_fs_readlink` and `uv_fs_realpath`
  500 |   export %inline
  501 |   uv_fs_get_ptr : Ptr Fs -> io AnyPtr
  502 |   uv_fs_get_ptr p = primIO $ prim__uv_fs_get_ptr p
  503 | 
  504 |   ||| Path affecting the request
  505 |   export %inline
  506 |   uv_fs_get_path : Ptr Fs -> io (Ptr Char)
  507 |   uv_fs_get_path p = primIO (prim__uv_fs_get_path p)
  508 | 
  509 |   ||| Returns the result of `uv_fs_stat` and other stat requests.
  510 |   export %inline
  511 |   uv_fs_get_statbuf : Ptr Fs -> io (Ptr Stat)
  512 |   uv_fs_get_statbuf p = primIO $ prim__uv_fs_get_statbuf p
  513 | 
  514 |   ||| Equivalent to unlink(2).
  515 |   export %inline
  516 |   uv_fs_unlink : Ptr Loop -> Ptr Fs -> String -> FsCB -> io Int32
  517 |   uv_fs_unlink loop fs path cb =
  518 |     primIO $ prim__uv_fs_unlink loop fs path cb
  519 | 
  520 |   ||| Equivalent to mkdir(2).
  521 |   export %inline
  522 |   uv_fs_mkdir :
  523 |        Ptr Loop
  524 |     -> String
  525 |     -> (mode : Int32)
  526 |     -> Ptr Fs
  527 |     -> FsCB
  528 |     -> io Int32
  529 |   uv_fs_mkdir loop path mode fs cb =
  530 |     primIO $ prim__uv_fs_mkdir loop fs path mode cb
  531 | 
  532 |   ||| Equivalent to mkdtemp(3). The result can be found as a null
  533 |   ||| terminated string at req->path.
  534 |   export %inline
  535 |   uv_fs_mkdtemp :
  536 |        Ptr Loop
  537 |     -> (tpl : String)
  538 |     -> Ptr Fs
  539 |     -> FsCB
  540 |     -> io Int32
  541 |   uv_fs_mkdtemp loop tpl fs cb =
  542 |     primIO $ prim__uv_fs_mkdtemp loop fs tpl cb
  543 | 
  544 |   ||| Equivalent to mkstemp(3). The result can be found as a null
  545 |   ||| terminated string at req->path.
  546 |   export %inline
  547 |   uv_fs_mkstemp :
  548 |        Ptr Loop
  549 |     -> (tpl : String)
  550 |     -> Ptr Fs
  551 |     -> FsCB
  552 |     -> io Int32
  553 |   uv_fs_mkstemp loop tpl fs cb =
  554 |     primIO $ prim__uv_fs_mkstemp loop fs tpl cb
  555 | 
  556 |   ||| Equivalent to rmdir(2).
  557 |   export %inline
  558 |   uv_fs_rmdir :
  559 |        Ptr Loop
  560 |     -> (path : String)
  561 |     -> Ptr Fs
  562 |     -> FsCB
  563 |     -> io Int32
  564 |   uv_fs_rmdir loop path fs cb =
  565 |     primIO $ prim__uv_fs_rmdir loop fs path cb
  566 | 
  567 |   ||| Opens path as a directory stream. On success,
  568 |   ||| a uv_dir_t is allocated and returned via req->ptr.
  569 |   ||| This memory is not freed by uv_fs_req_cleanup(), although req->ptr
  570 |   ||| is set to NULL. The allocated memory must be  freed  by
  571 |   ||| calling uv_fs_closedir(). On failure, no memory is allocated.
  572 |   |||
  573 |   ||| The contents of the directory can be iterated over by passing the
  574 |   ||| resulting uv_dir_t to uv_fs_readdir().
  575 |   export %inline
  576 |   uv_fs_opendir :
  577 |        Ptr Loop
  578 |     -> (path : String)
  579 |     -> Ptr Fs
  580 |     -> FsCB
  581 |     -> io Int32
  582 |   uv_fs_opendir loop path fs cb =
  583 |     primIO $ prim__uv_fs_opendir loop fs path cb
  584 | 
  585 |   ||| Closes the directory stream represented by dir and frees the
  586 |   ||| memory allocated by `uv_fs_opendir`.
  587 |   export %inline
  588 |   uv_fs_closedir :
  589 |        Ptr Loop
  590 |     -> (dir : Ptr Dir)
  591 |     -> Ptr Fs
  592 |     -> FsCB
  593 |     -> io Int32
  594 |   uv_fs_closedir loop dir fs cb =
  595 |     primIO $ prim__uv_fs_closedir loop fs dir cb
  596 | 
  597 |   ||| Iterates  over  the directory stream, dir, returned by a
  598 |   ||| successful `uv_fs_opendir` call. Prior to invoking `uv_fs_readdir`,
  599 |   ||| the caller must set dir->dirents and dir->nentries,
  600 |   ||| representing the array of uv_dirent_t ele‐
  601 |   ||| ments used to hold the read directory entries and its size.
  602 |   |||
  603 |   ||| On success, the result is an integer >= 0 representing the number
  604 |   ||| of entries read from the stream.
  605 |   ||| NOTE:
  606 |   |||    On success this function allocates memory that must be
  607 |   |||    freed using `uv_fs_req_cleanup`. `uv_fs_req_cleanup` must
  608 |   |||    be called before closing the directory with `uv_fs_closedir`.
  609 |   export %inline
  610 |   uv_fs_readdir :
  611 |        Ptr Loop
  612 |     -> (dir : Ptr Dir)
  613 |     -> Ptr Fs
  614 |     -> FsCB
  615 |     -> io Int32
  616 |   uv_fs_readdir loop dir fs cb =
  617 |     primIO $ prim__uv_fs_readdir loop fs dir cb
  618 | 
  619 |   ||| Equivalent to scandir(3), with a slightly different API.
  620 |   ||| Once the callback for the request is called, the user can use
  621 |   ||| `uv_fs_scandir_next` to get ent populated with the next
  622 |   ||| directory entry data. When there are no more
  623 |   ||| entries UV_EOF will be returned.
  624 |   |||
  625 |   ||| NOTE:
  626 |   |||    Unlike scandir(3), this function does not return the "." and ".." entries.
  627 |   |||
  628 |   ||| NOTE:
  629 |   |||    On Linux, getting the type of an entry is only supported
  630 |   |||    by some file systems (btrfs, ext2, ext3 and ext4 at the time of this writing),
  631 |   |||    check the getdents(2) man page.
  632 |   export %inline
  633 |   uv_fs_scandir :
  634 |        Ptr Loop
  635 |     -> (path : String)
  636 |     -> (mode : Int32)
  637 |     -> Ptr Fs
  638 |     -> FsCB
  639 |     -> io Int32
  640 |   uv_fs_scandir loop path mode fs cb =
  641 |     primIO $ prim__uv_fs_scandir loop fs path mode cb
  642 | 
  643 |   ||| See `uv_fs_scandir`.
  644 |   export %inline
  645 |   uv_fs_scandir_next : Ptr Fs -> Ptr Dirent -> io Int32
  646 |   uv_fs_scandir_next fs ptr = primIO $ prim__uv_fs_scandir_next fs ptr
  647 | 
  648 |   export %inline
  649 |   uv_dirents : Ptr Dir -> io (Ptr Dirent)
  650 |   uv_dirents dir = primIO $ prim__uv_dirents dir
  651 | 
  652 |   export %inline
  653 |   uv_nentries : Ptr Dir -> io Bits32
  654 |   uv_nentries dir = primIO $ prim__uv_nentries dir
  655 | 
  656 |   export %inline
  657 |   uv_fs_get_dirent_name : Ptr Dirent -> io (Ptr Char)
  658 |   uv_fs_get_dirent_name ptr = primIO $ prim__uv_fs_get_dirent_name ptr
  659 | 
  660 |   export %inline
  661 |   uv_fs_get_dirent_type : Ptr Dirent -> io Int32
  662 |   uv_fs_get_dirent_type ptr = primIO $ prim__uv_fs_get_dirent_type ptr
  663 | 
  664 |   ||| Asynchronously closes a file and releases the file handle.
  665 |   |||
  666 |   ||| Once the file is closed, the given `IO` action is invoked.
  667 |   export %inline
  668 |   uv_fs_close : Ptr Loop -> Int32 -> Ptr Fs -> FsCB -> io Int32
  669 |   uv_fs_close l h fs cb = do
  670 |     primIO $ prim__uv_fs_close l fs h cb
  671 | 
  672 |   ||| Asynchronously opens a file, invoking the given callback once
  673 |   ||| the file is ready.
  674 |   export %inline
  675 |   uv_fs_open :
  676 |        Ptr Loop
  677 |     -> String
  678 |     -> (flags : Bits32)
  679 |     -> (mode  : Bits32)
  680 |     -> Ptr Fs
  681 |     -> FsCB
  682 |     -> io Int32
  683 |   uv_fs_open l path fs m ptr cb =
  684 |     primIO $ prim__uv_fs_open l ptr path fs m cb
  685 | 
  686 |   ||| Reads data from a file into the given buffer and invokes
  687 |   ||| the callback function once the data is ready.
  688 |   |||
  689 |   ||| This is a faithful binding to `uv_fs_read`. What you typically want is
  690 |   ||| to decide on the return value stored in the `Ptr Fs` you get to figure
  691 |   ||| out what to do next. For that, there is `fsRead` as a more convenient
  692 |   ||| version.
  693 |   export %inline
  694 |   uv_fs_read :
  695 |        Ptr Loop
  696 |     -> (file   : Int32)
  697 |     -> (buf    : Ptr Bits8)
  698 |     -> (size   : Bits32)
  699 |     -> (offset : Int64)
  700 |     -> Ptr Fs
  701 |     -> (cb     : FsCB)
  702 |     -> io Int32
  703 |   uv_fs_read l h buf size offset f cb =
  704 |     primIO $ prim__uv_fs_read l f h buf size offset cb
  705 | 
  706 |   ||| Writes data from the given buffer to a file and invokes
  707 |   ||| the callback function once the data is ready.
  708 |   export
  709 |   uv_fs_write :
  710 |        Ptr Loop
  711 |     -> (file   : Int32)
  712 |     -> (buf    : Ptr Bits8)
  713 |     -> (size   : Bits32)
  714 |     -> (offset : Int64)
  715 |     -> (p      : Ptr Fs)
  716 |     -> (cb     : FsCB)
  717 |     -> io Int32
  718 |   uv_fs_write l h buf size offset p cb =
  719 |     primIO $ prim__uv_fs_write l p h buf size offset cb
  720 | 
  721 |   export %inline
  722 |   uv_fs_stat :
  723 |        Ptr Loop
  724 |     -> (path : String)
  725 |     -> Ptr Fs
  726 |     -> FsCB
  727 |     -> io Int32
  728 |   uv_fs_stat loop path fs cb =
  729 |     primIO $ prim__uv_fs_stat loop fs path cb
  730 | 
  731 |   export %inline
  732 |   uv_fs_fstat :
  733 |        Ptr Loop
  734 |     -> (file : Int32)
  735 |     -> Ptr Fs
  736 |     -> FsCB
  737 |     -> io Int32
  738 |   uv_fs_fstat loop file fs cb =
  739 |     primIO $ prim__uv_fs_fstat loop fs file cb
  740 | 
  741 |   export %inline
  742 |   uv_fs_lstat :
  743 |        Ptr Loop
  744 |     -> (path : String)
  745 |     -> Ptr Fs
  746 |     -> FsCB
  747 |     -> io Int32
  748 |   uv_fs_lstat loop path fs cb =
  749 |     primIO $ prim__uv_fs_lstat loop fs path cb
  750 | 
  751 |   ||| Equivalent to statfs(2). On success, a
  752 |   ||| `uv_statfs_t` is allocated and returned via req->ptr.
  753 |   ||| This memory is freed by `uv_fs_req_cleanup`.
  754 |   ||| NOTE:
  755 |   |||    Any fields in the resulting uv_statfs_t that are not
  756 |   |||    supported by the underlying operating system are set to zero.
  757 |   export %inline
  758 |   uv_fs_statfs :
  759 |        Ptr Loop
  760 |     -> (path : String)
  761 |     -> Ptr Fs
  762 |     -> FsCB
  763 |     -> io Int32
  764 |   uv_fs_statfs loop path fs cb =
  765 |     primIO $ prim__uv_fs_statfs loop fs path cb
  766 | 
  767 |   ||| Equivalent to rename(2).
  768 |   export %inline
  769 |   uv_fs_rename :
  770 |        Ptr Loop
  771 |     -> (path, newpath : String)
  772 |     -> Ptr Fs
  773 |     -> (cb   : FsCB)
  774 |     -> io Int32
  775 |   uv_fs_rename loop path newpath fs cb =
  776 |     primIO $ prim__uv_fs_rename loop fs path newpath cb
  777 | 
  778 |   ||| Equivalent to fsync(2).
  779 |   |||
  780 |   ||| NOTE:
  781 |   |||    For AIX, uv_fs_fsync returns UV_EBADF on file
  782 |   |||    descriptors referencing non regular files.
  783 |   export %inline
  784 |   uv_fs_fsync :
  785 |        Ptr Loop
  786 |     -> (file : Int32)
  787 |     -> Ptr Fs
  788 |     -> (cb   : FsCB)
  789 |     -> io Int32
  790 |   uv_fs_fsync loop file fs cb =
  791 |     primIO $ prim__uv_fs_fsync loop fs file cb
  792 | 
  793 |   ||| Equivalent to fdatasync(2).
  794 |   export %inline
  795 |   uv_fs_fdatasync :
  796 |        Ptr Loop
  797 |     -> (file : Int32)
  798 |     -> Ptr Fs
  799 |     -> (cb   : FsCB)
  800 |     -> io Int32
  801 |   uv_fs_fdatasync loop file fs cb =
  802 |     primIO $ prim__uv_fs_fdatasync loop fs file cb
  803 | 
  804 |   ||| Equivalent to ftruncate(2).
  805 |   export %inline
  806 |   uv_fs_ftruncate :
  807 |        Ptr Loop
  808 |     -> (file : Int32)
  809 |     -> (offset : Int64)
  810 |     -> Ptr Fs
  811 |     -> (cb   : FsCB)
  812 |     -> io Int32
  813 |   uv_fs_ftruncate loop file offset fs cb =
  814 |     primIO $ prim__uv_fs_ftruncate loop fs file offset cb
  815 | 
  816 |   ||| Copies a file from path to new_path.
  817 |   ||| Supported flags are described below.
  818 |   |||
  819 |   ||| • UV_FS_COPYFILE_EXCL: If present, `uv_fs_copyfile` will fail
  820 |   |||   with UV_EEXIST if the destination path already exists.
  821 |   |||   The default behavior is to overwrite the destination if it exists.
  822 |   |||
  823 |   ||| • UV_FS_COPYFILE_FICLONE: If present, `uv_fs_copyfile` will
  824 |   |||   attempt to create a copy-on-write reflink. If the underlying
  825 |   |||   platform does not support copy-on-write, or an error occurs
  826 |   |||   while attempting to use copy-on-write,
  827 |   |||   a fallback copy mechanism based on uv_fs_sendfile() is used.
  828 |   |||
  829 |   ||| • UV_FS_COPYFILE_FICLONE_FORCE: If present, `uv_fs_copyfile`
  830 |   |||   will attempt to create a copy-on-write reflink. If the
  831 |   |||   underlying platform does not support  copy-on-write, or an error
  832 |   |||   occurs while attempting to use copy-on-write, then an error is returned.
  833 |   |||
  834 |   ||| WARNING:
  835 |   |||    If  the destination path is created, but an error occurs while copying
  836 |   |||    the data, then the destination path is removed. There is a brief
  837 |   |||    window of time between closing and removing the file where
  838 |   |||    another process could access the file.
  839 |   export %inline
  840 |   uv_fs_copyfile :
  841 |        Ptr Loop
  842 |     -> (path, newpath : String)
  843 |     -> (flags : Int32)
  844 |     -> Ptr Fs
  845 |     -> (cb   : FsCB)
  846 |     -> io Int32
  847 |   uv_fs_copyfile loop path newpath flags fs cb =
  848 |     primIO $ prim__uv_fs_copyfile loop fs path newpath flags cb
  849 | 
  850 |   ||| Limited equivalent to sendfile(2).
  851 |   export %inline
  852 |   uv_fs_sendfile :
  853 |        Ptr Loop
  854 |     -> (outFile, inFile : Int32)
  855 |     -> (offset : Int64)
  856 |     -> (length : Bits32)
  857 |     -> Ptr Fs
  858 |     -> (cb   : FsCB)
  859 |     -> io Int32
  860 |   uv_fs_sendfile loop o i offset l fs cb =
  861 |     primIO $ prim__uv_fs_sendfile loop fs o i offset l cb
  862 | 
  863 |   ||| Equivalent to access(2) on Unix. Windows uses GetFileAttributesW().
  864 |   export %inline
  865 |   uv_fs_access :
  866 |        Ptr Loop
  867 |     -> (path : String)
  868 |     -> (mode : Int32)
  869 |     -> Ptr Fs
  870 |     -> (cb   : FsCB)
  871 |     -> io Int32
  872 |   uv_fs_access loop path mode fs cb =
  873 |     primIO $ prim__uv_fs_access loop fs path mode cb
  874 | 
  875 |   ||| Equivalent to chmod(2) respectively.
  876 |   export %inline
  877 |   uv_fs_chmod :
  878 |        Ptr Loop
  879 |     -> (path : String)
  880 |     -> (mode : Int32)
  881 |     -> Ptr Fs
  882 |     -> (cb   : FsCB)
  883 |     -> io Int32
  884 |   uv_fs_chmod loop path mode fs cb =
  885 |     primIO $ prim__uv_fs_chmod loop fs path mode cb
  886 | 
  887 |   ||| Equivalent to fchmod(2) respectively.
  888 |   export %inline
  889 |   uv_fs_fchmod :
  890 |        Ptr Loop
  891 |     -> (file : Int32)
  892 |     -> (mode : Int32)
  893 |     -> Ptr Fs
  894 |     -> (cb   : FsCB)
  895 |     -> io Int32
  896 |   uv_fs_fchmod loop file mode fs cb =
  897 |     primIO $ prim__uv_fs_fchmod loop fs file mode cb
  898 | 
  899 |   ||| Equivalent to utime(2).
  900 |   export %inline
  901 |   uv_fs_utime :
  902 |        Ptr Loop
  903 |     -> (path : String)
  904 |     -> (atime, mtime : Double)
  905 |     -> Ptr Fs
  906 |     -> (cb   : FsCB)
  907 |     -> io Int32
  908 |   uv_fs_utime loop path atime mtime fs cb =
  909 |     primIO $ prim__uv_fs_utime loop fs path atime mtime cb
  910 | 
  911 |   ||| Equivalent to futime(2).
  912 |   export %inline
  913 |   uv_fs_futime :
  914 |        Ptr Loop
  915 |     -> (file : Int32)
  916 |     -> (atime, mtime : Double)
  917 |     -> Ptr Fs
  918 |     -> (cb   : FsCB)
  919 |     -> io Int32
  920 |   uv_fs_futime loop file atime mtime fs cb =
  921 |     primIO $ prim__uv_fs_futime loop fs file atime mtime cb
  922 | 
  923 |   ||| Equivalent to lutime(2).
  924 |   export %inline
  925 |   uv_fs_lutime :
  926 |        Ptr Loop
  927 |     -> (path : String)
  928 |     -> (atime, mtime : Double)
  929 |     -> Ptr Fs
  930 |     -> (cb   : FsCB)
  931 |     -> io Int32
  932 |   uv_fs_lutime loop path atime mtime fs cb =
  933 |     primIO $ prim__uv_fs_lutime loop fs path atime mtime cb
  934 | 
  935 |   ||| Equivalent to link(2).
  936 |   export %inline
  937 |   uv_fs_link :
  938 |        Ptr Loop
  939 |     -> (path, newpath : String)
  940 |     -> Ptr Fs
  941 |     -> (cb   : FsCB)
  942 |     -> io Int32
  943 |   uv_fs_link loop path newpath fs cb =
  944 |     primIO $ prim__uv_fs_link loop fs path newpath cb
  945 | 
  946 |   ||| Equivalent to symlink(2).
  947 |   |||
  948 |   ||| NOTE:
  949 |   |||    On Windows the flags parameter can be specified to control
  950 |   |||    how the symlink will be created:
  951 |   |||
  952 |   |||    • UV_FS_SYMLINK_DIR: indicates that path points to a directory.
  953 |   |||
  954 |   |||    • UV_FS_SYMLINK_JUNCTION: request that the symlink is
  955 |   |||      created using junction points.
  956 |   export %inline
  957 |   uv_fs_symlink :
  958 |        Ptr Loop
  959 |     -> (path, newpath : String)
  960 |     -> (flags : Int32)
  961 |     -> Ptr Fs
  962 |     -> (cb   : FsCB)
  963 |     -> io Int32
  964 |   uv_fs_symlink loop path newpath flags fs cb =
  965 |     primIO $ prim__uv_fs_symlink loop fs path newpath flags cb
  966 | 
  967 |   ||| Equivalent to readlink(2).  The resulting string is stored in req->ptr.
  968 |   export %inline
  969 |   uv_fs_readlink :
  970 |        Ptr Loop
  971 |     -> (path : String)
  972 |     -> Ptr Fs
  973 |     -> (cb   : FsCB)
  974 |     -> io Int32
  975 |   uv_fs_readlink loop path fs cb =
  976 |     primIO $ prim__uv_fs_readlink loop fs path cb
  977 | 
  978 |   ||| Equivalent to realpath(3) on Unix. Windows uses
  979 |   ||| GetFinalPathNameByHandle. The resulting string is stored in req->ptr.
  980 |   |||
  981 |   ||| WARNING:
  982 |   |||    This function has certain platform-specific caveats that
  983 |   |||    were discovered when used in Node.
  984 |   |||
  985 |   |||    • macOS and other BSDs: this function will fail with UV_ELOOP if
  986 |   |||      more than 32 symlinks are found while resolving the given path.
  987 |   |||      This limit is hardcoded and cannot be sidestepped.
  988 |   |||
  989 |   |||    • Windows: while this function works in the common case,
  990 |   |||      there are a number of corner cases where it doesn't:
  991 |   |||
  992 |   |||      • Paths in ramdisk volumes created by tools which sidestep the
  993 |   |||        Volume Manager (such as ImDisk) cannot be resolved.
  994 |   |||
  995 |   |||      • Inconsistent casing when using drive letters.
  996 |   |||
  997 |   |||      • Resolved path bypasses subst'd drives.
  998 |   |||
  999 |   |||    While this function can still be used, it's not recommended
 1000 |   |||    if scenarios such as the above need to be supported.
 1001 |   export %inline
 1002 |   uv_fs_realpath :
 1003 |        Ptr Loop
 1004 |     -> (path : String)
 1005 |     -> Ptr Fs
 1006 |     -> (cb   : FsCB)
 1007 |     -> io Int32
 1008 |   uv_fs_realpath loop path fs cb =
 1009 |     primIO $ prim__uv_fs_realpath loop fs path cb
 1010 | 
 1011 |   ||| Equivalent to chown(2).
 1012 |   export %inline
 1013 |   uv_fs_chown :
 1014 |        Ptr Loop
 1015 |     -> (path : String)
 1016 |     -> (uid, gid : Int32)
 1017 |     -> Ptr Fs
 1018 |     -> (cb   : FsCB)
 1019 |     -> io Int32
 1020 |   uv_fs_chown loop path uid gid fs cb =
 1021 |     primIO $ prim__uv_fs_chown loop fs path uid gid cb
 1022 | 
 1023 |   ||| Equivalent to fchown(2).
 1024 |   export %inline
 1025 |   uv_fs_fchown :
 1026 |        Ptr Loop
 1027 |     -> (file : String)
 1028 |     -> (uid, gid : Int32)
 1029 |     -> Ptr Fs
 1030 |     -> (cb   : FsCB)
 1031 |     -> io Int32
 1032 |   uv_fs_fchown loop file uid gid fs cb =
 1033 |     primIO $ prim__uv_fs_lchown loop fs file uid gid cb
 1034 | 
 1035 |   ||| Equivalent to lchown(2).
 1036 |   export %inline
 1037 |   uv_fs_lchown :
 1038 |        Ptr Loop
 1039 |     -> (path : String)
 1040 |     -> (uid, gid : Int32)
 1041 |     -> Ptr Fs
 1042 |     -> (cb   : FsCB)
 1043 |     -> io Int32
 1044 |   uv_fs_lchown loop path uid gid fs cb =
 1045 |     primIO $ prim__uv_fs_lchown loop fs path uid gid cb
 1046 |