{-# LINE 1 "libraries/ghc-internal/src/GHC/Internal/System/Environment/ExecutablePath.hsc" #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE CPP #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  GHC.Internal.System.Environment.ExecutablePath
-- Copyright   :  (c) The University of Glasgow 2001
-- License     :  BSD-style (see the file libraries/base/LICENSE)
--
-- Maintainer  :  libraries@haskell.org
-- Stability   :  provisional
-- Portability :  portable
--
-- Function to retrieve the absolute filepath of the current executable.
--
-- @since base-4.6.0.0
-----------------------------------------------------------------------------

module GHC.Internal.System.Environment.ExecutablePath
  ( getExecutablePath
  , executablePath
  ) where

#if defined(javascript_HOST_ARCH)

import GHC.Internal.Base
import GHC.Internal.IO (FilePath)

getExecutablePath :: IO FilePath
getExecutablePath = return "a.jsexe"

executablePath :: Maybe (IO (Maybe FilePath))
executablePath = Nothing

#else

-- The imports are purposely kept completely disjoint to prevent edits
-- to one OS implementation from breaking another.

import GHC.Internal.Base
import GHC.Internal.IO (FilePath)
import GHC.Internal.Real

{-# LINE 72 "libraries/ghc-internal/src/GHC/Internal/System/Environment/ExecutablePath.hsc" #-}
import GHC.Internal.Control.Exception (catch, throw)
import GHC.Internal.Data.Functor
import GHC.Internal.Foreign.C.Types
import GHC.Internal.Foreign.C.Error
import GHC.Internal.Foreign.Marshal.Alloc
import GHC.Internal.Foreign.Marshal.Array
import GHC.Internal.Foreign.Ptr
import GHC.Internal.Foreign.Storable
import GHC.Internal.System.IO.Error (isDoesNotExistError)
import GHC.Internal.System.Posix.Internals



{-# LINE 106 "libraries/ghc-internal/src/GHC/Internal/System/Environment/ExecutablePath.hsc" #-}

-- The exported function is defined outside any if-guard to make sure
-- every OS implements it with the same type.

-- | Returns the absolute pathname of the current executable,
-- or @argv[0]@ if the operating system does not provide a reliable
-- way query the current executable.
--
-- Note that for scripts and interactive sessions, this is the path to
-- the interpreter (e.g. ghci.)
--
-- Since base 4.11.0.0, 'getExecutablePath' resolves symlinks on Windows.
-- If an executable is launched through a symlink, 'getExecutablePath'
-- returns the absolute path of the original executable.
--
-- If the executable has been deleted, behaviour is ill-defined and
-- varies by operating system.  See 'executablePath' for a more
-- reliable way to query the current executable.
--
-- @since base-4.6.0.0
getExecutablePath :: IO FilePath

-- | Get an action to query the absolute pathname of the current executable.
--
-- If the operating system provides a reliable way to determine the current
-- executable, return the query action, otherwise return @Nothing@.  The action
-- is defined on FreeBSD, Linux, MacOS, NetBSD, Solaris, and Windows.
--
-- Even where the query action is defined, there may be situations where no
-- result is available, e.g. if the executable file was deleted while the
-- program is running.  Therefore the result of the query action is a @Maybe
-- FilePath@.
--
-- Note that for scripts and interactive sessions, the result is the path to
-- the interpreter (e.g. ghci.)
--
-- Note also that while most operating systems return @Nothing@ if the
-- executable file was deleted/unlinked, some (including NetBSD) return the
-- original path.
--
-- @since base-4.17.0.0
executablePath :: Maybe (IO (Maybe FilePath))


--------------------------------------------------------------------------------
-- Mac OS X


{-# LINE 248 "libraries/ghc-internal/src/GHC/Internal/System/Environment/ExecutablePath.hsc" #-}

foreign import ccall unsafe "sysctl"
  c_sysctl
    :: Ptr CInt   -- MIB
    -> CUInt      -- MIB size
    -> Ptr CChar  -- old / current value buffer
    -> Ptr CSize  -- old / current value buffer size
    -> Ptr CChar  -- new value
    -> CSize      -- new value size
    -> IO CInt    -- result

getExecutablePath = do
  withArrayLen mib $ \n mibPtr -> do
    let mibLen = fromIntegral n
    alloca $ \bufSizePtr -> do
      status <- c_sysctl mibPtr mibLen nullPtr bufSizePtr nullPtr 0
      case status of
        0 -> do
          reqBufSize <- fromIntegral <$> peek bufSizePtr
          allocaBytes reqBufSize $ \buf -> do
            newStatus <- c_sysctl mibPtr mibLen buf bufSizePtr nullPtr 0
            case newStatus of
              0 -> peekFilePath buf
              _ -> barf
        _ -> barf
  where
    barf = throwErrno "getExecutablePath"
    mib =

{-# LINE 277 "libraries/ghc-internal/src/GHC/Internal/System/Environment/ExecutablePath.hsc" #-}
      [ (1)
{-# LINE 278 "libraries/ghc-internal/src/GHC/Internal/System/Environment/ExecutablePath.hsc" #-}
      , (14)
{-# LINE 279 "libraries/ghc-internal/src/GHC/Internal/System/Environment/ExecutablePath.hsc" #-}
      , (12)
{-# LINE 280 "libraries/ghc-internal/src/GHC/Internal/System/Environment/ExecutablePath.hsc" #-}
      , -1   -- current process
      ]

{-# LINE 289 "libraries/ghc-internal/src/GHC/Internal/System/Environment/ExecutablePath.hsc" #-}

executablePath = Just (fmap Just getExecutablePath `catch` f)
  where
  -- The sysctl fails with errno ENOENT when executable has been deleted;
  -- see https://gitlab.haskell.org/ghc/ghc/-/issues/12377#note_321346.
  f e | isDoesNotExistError e = pure Nothing

  -- As far as I know, ENOENT is the only kind of failure that should be
  -- expected and handled.  Re-throw other errors.
      | otherwise             = throw e


--------------------------------------------------------------------------------
-- Windows


{-# LINE 417 "libraries/ghc-internal/src/GHC/Internal/System/Environment/ExecutablePath.hsc" #-}

#endif