Fix release builds

.bash-completion

@@ -0,0 +1,14 @@
+_ghcup()
+{
+    local CMDLINE
+    local IFS=$'\n'
+    CMDLINE=(--bash-completion-index $COMP_CWORD)
+
+    for arg in ${COMP_WORDS[@]}; do
+        CMDLINE=(${CMDLINE[@]} --bash-completion-word $arg)
+    done
+
+    COMPREPLY=( $(ghcup "${CMDLINE[@]}") )
+}
+
+complete -o filenames -F _ghcup ghcup

.gitlab-ci.yml

@@ -57,7 +57,7 @@ variables:
   script:
     - ./.gitlab/script/ghcup_version.sh
   variables:
-    JSON_VERSION: "0.0.1"
+    JSON_VERSION: "0.0.2"
 
 .test_ghcup_version:linux:
   extends:
@@ -161,7 +161,7 @@ release:linux:32bit:
   before_script:
     - ./.gitlab/before_script/linux/alpine/install_deps.sh
   variables:
-    ARTIFACT: "x86_64-linux-ghcup"
+    ARTIFACT: "i386-linux-ghcup"
     GHC_VERSION: "8.8.3"
     CABAL_VERSION: "3.2.0.0"
 

.gitlab/script/ghcup_release.sh

@@ -15,6 +15,8 @@ ecabal update
 
 if [ "${OS}" = "LINUX" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -fcurl --ghc-options='-split-sections -optl-static'
+elif [ "${OS}" = "FREEBSD" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} -fcurl --ghc-options='-split-sections'
 else
 	ecabal build -w ghc-${GHC_VERSION} -fcurl
 fi

README.md

@@ -68,6 +68,12 @@ handles your haskell packages and can demand that [a specific version](https://c
 For man pages to work you need [man-db](http://man-db.nongnu.org/) as your `man` provider, then issue `man ghc`. Manpages only work for the currently set ghc.
 `MANPATH` may be required to be unset.
 
+### Bash-completion
+
+Depending on your distro and setup, install `.bash-completion` from this repo
+as e.g. `/etc/bash_completion.d/ghcup` and make sure your bashrc sources the
+startup script (`/usr/share/bash-completion/bash_completion` on some distros).
+
 ## Design goals
 
 1. simplicity

app/ghcup-gen/Main.hs

@@ -10,10 +10,10 @@
 
 module Main where
 
+import           GHCup.Data.GHCupInfo
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Logger
-import           GHCupInfo
 
 import           Data.Aeson                     ( eitherDecode, encode )
 import           Data.Aeson.Encode.Pretty

app/ghcup-gen/Validate.hs

@@ -27,9 +27,12 @@ import           Haskus.Utils.Variant.Excepts
 import           Optics
 import           System.Exit
 import           System.IO
+import           Text.ParserCombinators.ReadP
 
 import qualified Data.ByteString               as B
 import qualified Data.Map.Strict               as M
+import qualified Data.Text                     as T
+import qualified Data.Version                  as V
 
 
 data ValidationError = InternalError String
@@ -61,8 +64,9 @@ validate dls = do
         forM_ (M.toList $ _viArch vi) $ \(arch, pspecs) -> do
           checkHasRequiredPlatforms t v arch (M.keys pspecs)
 
-    checkGHCisSemver
+    checkGHCVerIsValid
     forM_ (M.toList dls) $ \(t, _) -> checkMandatoryTags t
+    _ <- checkGHCHasBaseVersion
 
     -- exit
     e <- liftIO $ readIORef ref
@@ -105,16 +109,19 @@ validate dls = do
         lift $ $(logError) [i|Tags not unique for #{tool}: #{xs}|]
         addError
    where
-    isUniqueTag Latest      = True
+    isUniqueTag Latest         = True
-    isUniqueTag Recommended = True
+    isUniqueTag Recommended    = True
+    isUniqueTag (Base       _) = False
+    isUniqueTag (UnknownTag _) = False
 
-  checkGHCisSemver = do
+  checkGHCVerIsValid = do
     let ghcVers = toListOf (ix GHC % to M.keys % folded) dls
-    forM_ ghcVers $ \v -> case semver (prettyVer v) of
+    forM_ ghcVers $ \v ->
-      Left _ -> do
+      case [ x | (x,"") <- readP_to_S V.parseVersion (T.unpack . prettyVer $ v) ] of
-        lift $ $(logError) [i|GHC version #{v} is not valid semver|]
+        [_] -> pure ()
-        addError
+        _   -> do
-      Right _ -> pure ()
+          lift $ $(logError) [i|GHC version #{v} is not valid |]
+          addError
 
   -- a tool must have at least one of each mandatory tags
   checkMandatoryTags tool = do
@@ -125,6 +132,17 @@ validate dls = do
         addError
       True -> pure ()
 
+  -- all GHC versions must have a base tag
+  checkGHCHasBaseVersion = do
+    let allTags = M.toList $ availableToolVersions dls GHC
+    forM allTags $ \(ver, tags) -> case any isBase tags of
+      False -> do
+        lift $ $(logError) [i|Base tag missing from GHC ver #{ver}|]
+        addError
+      True -> pure ()
+
+  isBase (Base _) = True
+  isBase _        = False
 
 validateTarballs :: ( Monad m
                     , MonadLogger m
@@ -161,7 +179,7 @@ validateTarballs dls = do
 
  where
   downloadAll dli = do
-    let settings = Settings True False
+    let settings = Settings True False Never
     let runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
                                            , colorOutter  = B.hPut stderr
                                            , rawOutter    = (\_ -> pure ())

app/ghcup/Main.hs

@@ -19,6 +19,7 @@ import           GHCup.Types
 import           GHCup.Utils
 import           GHCup.Utils.File
 import           GHCup.Utils.Logger
+import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 import           GHCup.Version
 
@@ -32,11 +33,12 @@ import           Data.Bifunctor
 import           Data.Char
 import           Data.Either
 import           Data.Functor
-import           Data.List                      ( intercalate )
+import           Data.List                      ( intercalate, sort )
+import           Data.List.NonEmpty             (NonEmpty ((:|)))
 import           Data.Maybe
 import           Data.String.Interpolate
 import           Data.Text                      ( Text )
-import           Data.Versions
+import           Data.Versions           hiding ( str )
 import           Data.Void
 import           GHC.IO.Encoding
 import           Haskus.Utils.Variant.Excepts
@@ -73,6 +75,7 @@ data Options = Options
   , optCache     :: Bool
   , optUrlSource :: Maybe URI
   , optNoVerify  :: Bool
+  , optKeepDirs  :: KeepDirs
   -- commands
   , optCommand   :: Command
   }
@@ -89,9 +92,13 @@ data Command
   | ToolRequirements
   | ChangeLog ChangeLogOptions
 
-data ToolVersion = ToolVersion Version
+data ToolVersion = ToolVersion GHCTargetVersion -- target is ignored for cabal
                  | ToolTag Tag
 
+prettyToolVer :: ToolVersion -> String
+prettyToolVer (ToolVersion v') = T.unpack $ prettyTVer v'
+prettyToolVer (ToolTag t) = show t
+
 
 data InstallOptions = InstallOptions
   { instVer      :: Maybe ToolVersion
@@ -103,20 +110,31 @@ data SetGHCOptions = SetGHCOptions
   }
 
 data ListOptions = ListOptions
-  { lTool     :: Maybe Tool
+  { lTool      :: Maybe Tool
-  , lCriteria :: Maybe ListCriteria
+  , lCriteria  :: Maybe ListCriteria
+  , lRawFormat :: Bool
   }
 
 data RmOptions = RmOptions
-  { ghcVer :: Version
+  { ghcVer :: GHCTargetVersion
   }
 
 
-data CompileCommand = CompileGHC CompileOptions
+data CompileCommand = CompileGHC GHCCompileOptions
-                    | CompileCabal CompileOptions
+                    | CompileCabal CabalCompileOptions
 
 
-data CompileOptions = CompileOptions
+data GHCCompileOptions = GHCCompileOptions
+  { targetVer    :: Version
+  , bootstrapGhc :: Either Version (Path Abs)
+  , jobs         :: Maybe Int
+  , buildConfig  :: Maybe (Path Abs)
+  , patchDir     :: Maybe (Path Abs)
+  , crossTarget  :: Maybe Text
+  , addConfArgs  :: [Text]
+  }
+
+data CabalCompileOptions = CabalCompileOptions
   { targetVer    :: Version
   , bootstrapGhc :: Either Version (Path Abs)
   , jobs         :: Maybe Int
@@ -158,6 +176,14 @@ opts =
           (short 'n' <> long "no-verify" <> help
             "Skip tarball checksum verification"
           )
+    <*> option
+          (eitherReader keepOnParser)
+          (  long "keep"
+          <> metavar "<always|errors|never>"
+          <> help
+               "Keep build directories?"
+          <> value Never
+          )
     <*> com
  where
   parseUri s' =
@@ -309,6 +335,9 @@ listOpts =
             )
           )
         )
+    <*> switch
+          (short 'r' <> long "raw-format" <> help "More machine-parsable format"
+          )
 
 rmOpts :: Parser RmOptions
 rmOpts = RmOptions <$> versionArgument
@@ -341,7 +370,7 @@ compileP = subparser
       "ghc"
       (   CompileGHC
       <$> (info
-            (compileOpts <**> helper)
+            (ghcCompileOpts <**> helper)
             (  progDesc "Compile GHC from source"
             <> footerDoc (Just $ text compileFooter)
             )
@@ -351,7 +380,7 @@ compileP = subparser
        "cabal"
        (   CompileCabal
        <$> (info
-             (compileOpts <**> helper)
+             (cabalCompileOpts <**> helper)
              (  progDesc "Compile Cabal from source"
              <> footerDoc (Just $ text compileCabalFooter)
              )
@@ -364,9 +393,19 @@ compileP = subparser
   a self-contained "~/.ghcup/ghc/<ghcver>" directory
   and symlinks the ghc binaries to "~/.ghcup/bin/<binary>-<ghcver>".
 
+  This also allows building a cross-compiler. Consult the documentation
+  first: <https://gitlab.haskell.org/ghc/ghc/-/wikis/building/cross-compiling#configuring-the-build>
+
+ENV variables:
+  Various toolchain variables will be passed onto the ghc build system,
+  such as: CC, LD, OBJDUMP, NM, AR, RANLIB.
+
 Examples:
   ghcup compile ghc -j 4 -v 8.4.2 -b 8.2.2
-  ghcup compile ghc -j 4 -v 8.4.2 -b /usr/bin/ghc-8.2.2|]
+  # specify path to bootstrap ghc
+  ghcup compile ghc -j 4 -v 8.4.2 -b /usr/bin/ghc-8.2.2
+  # build cross compiler
+  ghcup compile ghc -j 4 -v 8.4.2 -b 8.2.2 -x armv7-unknown-linux-gnueabihf --config $(pwd)/build.mk -- --enable-unregisterised|]
   compileCabalFooter = [i|Discussion:
   Compiles and installs the specified Cabal version
   into "~/.ghcup/bin".
@@ -376,10 +415,24 @@ Examples:
   ghcup compile cabal -j 4 -v 3.2.0.0 -b /usr/bin/ghc-8.6.5|]
 
 
+ghcCompileOpts :: Parser GHCCompileOptions
+ghcCompileOpts =
+  (\CabalCompileOptions {..} crossTarget addConfArgs -> GHCCompileOptions { .. }
+    )
+    <$> cabalCompileOpts
+    <*> (optional
+          (option
+            str
+            (short 'x' <> long "cross-target" <> metavar "CROSS_TARGET" <> help
+              "Build cross-compiler for this platform"
+            )
+          )
+        )
+    <*> many (argument str (metavar "CONFIGURE_ARGS" <> help "Additional arguments to configure, prefix with '-- ' (longopts)"))
 
-compileOpts :: Parser CompileOptions
+cabalCompileOpts :: Parser CabalCompileOptions
-compileOpts =
+cabalCompileOpts =
-  CompileOptions
+  CabalCompileOptions
     <$> (option
           (eitherReader
             (bimap (const "Not a valid version") id . version . T.pack)
@@ -454,12 +507,12 @@ toolVersionArgument =
   argument (eitherReader toolVersionEither) (metavar "VERSION|TAG")
 
 
-versionArgument :: Parser Version
+versionArgument :: Parser GHCTargetVersion
-versionArgument = argument (eitherReader versionEither) (metavar "VERSION")
+versionArgument = argument (eitherReader tVersionEither) (metavar "VERSION")
 
-versionParser :: Parser Version
+versionParser :: Parser GHCTargetVersion
 versionParser = option
-  (eitherReader versionEither)
+  (eitherReader tVersionEither)
   (short 'v' <> long "version" <> metavar "VERSION" <> help "The target version"
   )
 
@@ -467,18 +520,20 @@ tagEither :: String -> Either String Tag
 tagEither s' = case fmap toLower s' of
   "recommended" -> Right Recommended
   "latest"      -> Right Latest
+  ('b':'a':'s':'e':'-':ver') -> case pvp (T.pack ver') of
+                                  Right x -> Right (Base x)
+                                  Left  _ -> Left [i|Invalid PVP version for base #{ver'}|]
   other         -> Left ([i|Unknown tag #{other}|])
 
-versionEither :: String -> Either String Version
+
-versionEither s' =
+tVersionEither :: String -> Either String GHCTargetVersion
-  -- 'version' is a bit too lax and will parse typoed tags
+tVersionEither =
-                   case readMaybe ((: []) . head $ s') :: Maybe Int of
+  bimap (const "Not a valid version") id . MP.parse ghcTargetVerP "" . T.pack
-  Just _  -> bimap (const "Not a valid version") id . version . T.pack $ s'
+
-  Nothing -> Left "Not a valid version"
 
 toolVersionEither :: String -> Either String ToolVersion
 toolVersionEither s' =
-  bimap id ToolTag (tagEither s') <|> bimap id ToolVersion (versionEither s')
+  bimap id ToolTag (tagEither s') <|> bimap id ToolVersion (tVersionEither s')
 
 
 toolParser :: String -> Either String Tool
@@ -495,6 +550,14 @@ criteriaParser s' | t == T.pack "installed" = Right ListInstalled
   where t = T.toLower (T.pack s')
 
 
+keepOnParser :: String -> Either String KeepDirs
+keepOnParser s' | t == T.pack "always" = Right Always
+                | t == T.pack "errors" = Right Errors
+                | t == T.pack "never"  = Right Never
+                | otherwise            = Left ("Unknown keep value: " <> s')
+  where t = T.toLower (T.pack s')
+
+
 platformParser :: String -> Either String PlatformRequest
 platformParser s' = case MP.parse (platformP <* MP.eof) "" (T.pack s') of
   Right r -> pure r
@@ -554,24 +617,14 @@ platformParser s' = case MP.parse (platformP <* MP.eof) "" (T.pack s') of
         MP.setInput rest
         pure v
 
-  choice' []       = fail "Empty list"
-  choice' [x     ] = x
-  choice' (x : xs) = MP.try x <|> choice' xs
 
-  parseUntil :: MP.Parsec Void Text Text -> MP.Parsec Void Text Text
-  parseUntil p = do
-    (MP.try (MP.lookAhead p) $> mempty)
-      <|> (do
-            c  <- T.singleton <$> MP.anySingle
-            c2 <- parseUntil p
-            pure (c `mappend` c2)
-          )
 
 
 toSettings :: Options -> Settings
 toSettings Options {..} =
   let cache    = optCache
       noVerify = optNoVerify
+      keepDirs = optKeepDirs
   in  Settings { .. }
 
 
@@ -624,21 +677,31 @@ main = do
         <> help "Show the numeric version (for use in scripts)"
         <> hidden
         )
+  let listCommands = infoOption
+        "install set rm install-cabal list upgrade compile debug-info tool-requirements changelog"
+        (  long "list-commands"
+        <> help "List available commands for shell completion"
+        <> internal
+        )
 
   let main_footer = [i|Discussion:
   ghcup installs the Glasgow Haskell Compiler from the official
   release channels, enabling you to easily switch between different
-  versions.
+  versions. It maintains a self-contained ~/.ghcup directory.
+
+ENV variables:
+  * TMPDIR: where ghcup does the work (unpacking, building, ...)
+  * GHCUP_INSTALL_BASE_PREFIX: the base of ghcup (default: $HOME)
 
 Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
   customExecParser
       (prefs showHelpOnError)
-      (info (opts <**> helper <**> versionHelp <**> numericVersionHelp)
+      (info (opts <**> helper <**> versionHelp <**> numericVersionHelp <**> listCommands)
             (footerDoc (Just $ text main_footer))
       )
     >>= \opt@Options {..} -> do
-          let settings = toSettings opt
+          let settings@Settings{..} = toSettings opt
 
           -- create ~/.ghcup dir
           ghcdir <- ghcupBaseDir
@@ -765,7 +828,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
             Install (InstallOptions {..}) ->
               (runInstTool $ do
                   v <- liftE $ fromVersion dls instVer GHC
-                  liftE $ installGHCBin dls v instPlatform
+                  liftE $ installGHCBin dls (_tvVersion v) instPlatform -- FIXME: ugly sharing of tool version
                 )
                 >>= \case
                       VRight _ -> do
@@ -776,10 +839,18 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                           [i|GHC ver #{prettyVer v} already installed|]
                         pure ExitSuccess
                       VLeft (V (BuildFailed tmpdir e)) -> do
-                        runLogger
+                        case keepDirs of
-                          ($(logError) [i|Build failed with #{e}
+                          Never -> runLogger ($(logError) [i|Build failed with #{e}|])
-Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues.|]
+                          _ -> runLogger ($(logError) [i|Build failed with #{e}
-                          )
+Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues.
+Make sure to clean up #{tmpdir} afterwards.|])
+                        pure $ ExitFailure 3
+                      VLeft (V NoDownload) -> do
+
+                        runLogger $ do
+                          case instVer of
+                            Just iver -> $(logError) [i|No available GHC version for #{prettyToolVer iver}|]
+                            Nothing -> $(logError) [i|No available recommended GHC version|]
                         pure $ ExitFailure 3
                       VLeft e -> do
                         runLogger $ do
@@ -789,7 +860,7 @@ Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues
             InstallCabal (InstallOptions {..}) ->
               (runInstTool $ do
                   v <- liftE $ fromVersion dls instVer Cabal
-                  liftE $ installCabalBin dls v instPlatform
+                  liftE $ installCabalBin dls (_tvVersion v) instPlatform -- FIXME: ugly sharing of tool version
                 )
                 >>= \case
                       VRight _ -> do
@@ -799,6 +870,13 @@ Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues
                         runLogger $ $(logWarn)
                           [i|Cabal ver #{prettyVer v} already installed|]
                         pure ExitSuccess
+                      VLeft (V NoDownload) -> do
+
+                        runLogger $ do
+                          case instVer of
+                            Just iver -> $(logError) [i|No available Cabal version for #{prettyToolVer iver}|]
+                            Nothing -> $(logError) [i|No available recommended Cabal version|]
+                        pure $ ExitFailure 4
                       VLeft e -> do
                         runLogger $ do
                           $(logError) [i|#{e}|]
@@ -811,10 +889,10 @@ Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues
                   liftE $ setGHC v SetGHCOnly
                 )
                 >>= \case
-                      VRight v -> do
+                      VRight (GHCTargetVersion{..}) -> do
                         runLogger
                           $ $(logInfo)
-                              [i|GHC #{prettyVer v} successfully set as default version|]
+                              [i|GHC #{prettyVer _tvVersion} successfully set as default version#{maybe "" (" for cross target " <>) _tvTarget}|]
                         pure ExitSuccess
                       VLeft e -> do
                         runLogger ($(logError) [i|#{e}|])
@@ -827,7 +905,7 @@ Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues
                 )
                 >>= \case
                       VRight r -> do
-                        liftIO $ printListResult r
+                        liftIO $ printListResult lRawFormat r
                         pure ExitSuccess
                       VLeft e -> do
                         runLogger ($(logError) [i|#{e}|])
@@ -854,13 +932,14 @@ Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues
                         runLogger ($(logError) [i|#{e}|])
                         pure $ ExitFailure 8
 
-            Compile (CompileGHC CompileOptions {..}) ->
+            Compile (CompileGHC GHCCompileOptions {..}) ->
               (runCompileGHC $ liftE $ compileGHC dls
-                                                  targetVer
+                                                  (GHCTargetVersion crossTarget targetVer)
                                                   bootstrapGhc
                                                   jobs
                                                   buildConfig
                                                   patchDir
+                                                  addConfArgs
                 )
                 >>= \case
                       VRight _ -> do
@@ -872,17 +951,18 @@ Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues
                           [i|GHC ver #{prettyVer v} already installed|]
                         pure ExitSuccess
                       VLeft (V (BuildFailed tmpdir e)) -> do
-                        runLogger
+                        case keepDirs of
-                          ($(logError) [i|Build failed with #{e}
+                          Never -> runLogger ($(logError) [i|Build failed with #{e}
+Check the logs at ~/.ghcup/logs|])
+                          _ -> runLogger ($(logError) [i|Build failed with #{e}
 Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues.
-Make sure to clean up #{tmpdir} afterwards.|]
+Make sure to clean up #{tmpdir} afterwards.|])
-                          )
                         pure $ ExitFailure 9
                       VLeft e -> do
                         runLogger ($(logError) [i|#{e}|])
                         pure $ ExitFailure 9
 
-            Compile (CompileCabal CompileOptions {..}) ->
+            Compile (CompileCabal CabalCompileOptions {..}) ->
               (runCompileCabal $ do
                   liftE $ compileCabal dls targetVer bootstrapGhc jobs patchDir
                 )
@@ -894,10 +974,11 @@ Make sure to clean up #{tmpdir} afterwards.|]
                           )
                         pure ExitSuccess
                       VLeft (V (BuildFailed tmpdir e)) -> do
-                        runLogger
+                        case keepDirs of
-                          ($(logError) [i|Build failed with #{e}
+                          Never -> runLogger ($(logError) [i|Build failed with #{e}|])
-Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues.|]
+                          _ -> runLogger ($(logError) [i|Build failed with #{e}
-                          )
+Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues.
+Make sure to clean up #{tmpdir} afterwards.|])
                         pure $ ExitFailure 10
                       VLeft e -> do
                         runLogger ($(logError) [i|#{e}|])
@@ -952,7 +1033,7 @@ Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues
                   ver' = maybe
                     (Right Latest)
                     (\case
-                      ToolVersion tv -> Left tv
+                      ToolVersion tv -> Left (_tvVersion tv) -- FIXME: ugly sharing of ToolVersion
                       ToolTag     t  -> Right t
                     )
                     clToolVer
@@ -989,47 +1070,73 @@ fromVersion :: Monad m
             => GHCupDownloads
             -> Maybe ToolVersion
             -> Tool
-            -> Excepts '[TagNotFound] m Version
+            -> Excepts '[TagNotFound] m GHCTargetVersion
 fromVersion av Nothing tool =
-  getRecommended av tool ?? TagNotFound Recommended tool
+  mkTVer <$> getRecommended av tool ?? TagNotFound Recommended tool
-fromVersion _ (Just (ToolVersion v)) _ = pure v
+fromVersion av (Just (ToolVersion v)) _ = do
+  case pvp $ prettyVer (_tvVersion v) of
+    Left _ -> pure v
+    Right (PVP (major' :|[minor'])) ->
+      case getLatestGHCFor (fromIntegral major') (fromIntegral minor') av of
+        Just v' -> pure $ GHCTargetVersion (_tvTarget v) v'
+        Nothing -> pure v
+    Right _ -> pure v
 fromVersion av (Just (ToolTag Latest)) tool =
-  getLatest av tool ?? TagNotFound Latest tool
+  mkTVer <$> getLatest av tool ?? TagNotFound Latest tool
 fromVersion av (Just (ToolTag Recommended)) tool =
-  getRecommended av tool ?? TagNotFound Recommended tool
+  mkTVer <$> getRecommended av tool ?? TagNotFound Recommended tool
+fromVersion av (Just (ToolTag (Base pvp''))) GHC =
+  mkTVer <$> getLatestBaseVersion av pvp'' ?? TagNotFound (Base pvp'') GHC
+fromVersion _ (Just (ToolTag t')) tool =
+  throwE $ TagNotFound t' tool
 
 
-printListResult :: [ListResult] -> IO ()
+printListResult :: Bool -> [ListResult] -> IO ()
-printListResult lr = do
+printListResult raw lr = do
   -- https://gitlab.haskell.org/ghc/ghc/issues/8118
   setLocaleEncoding utf8
 
   let
     formatted =
       gridString
-          [ column expand left def def
+          (  (if raw then [] else [column expand left def def])
-          , column expand left def def
+          ++ [ column expand left def def
-          , column expand left def def
+             , column expand left def def
-          , column expand left def def
+             , column expand left def def
-          , column expand left def def
+             , column expand left def def
-          ]
+             ]
+          )
+        . (\x -> if raw
+            then x
+            else [color Green "", "Tool", "Version", "Tags", "Notes"] : x
+          )
         $ fmap
             (\ListResult {..} ->
-              [ if
+              let marks = if
-                | lSet       -> (color Green "✔✔")
+                    | lSet       -> (color Green "✔✔")
-                | lInstalled -> (color Green "✓")
+                    | lInstalled -> (color Green "✓")
-                | otherwise  -> (color Red "✗")
+                    | otherwise  -> (color Red "✗")
-              , fmap toLower . show $ lTool
+              in  (if raw then [] else [marks])
-              , T.unpack . prettyVer $ lVer
+                    ++ [ fmap toLower . show $ lTool
-              , intercalate "," $ ((fmap . fmap) toLower . fmap show $ lTag)
+                       , case lCross of
-              , intercalate "," $
+                           Nothing -> T.unpack . prettyVer $ lVer
-                (if fromSrc then [color Blue "compiled"] else mempty)
+                           Just c  -> T.unpack (c <> "-" <> prettyVer lVer)
-                ++ (if lStray then [color Blue "stray"] else mempty)
+                       , intercalate "," $ (fmap printTag $ sort lTag)
-              ]
+                       , intercalate ","
+                       $  (if fromSrc then [color' Blue "compiled"] else mempty)
+                       ++ (if lStray then [color' Blue "stray"] else mempty)
+                       ]
             )
             lr
   putStrLn $ formatted
-
+ where
+  printTag Recommended        = color' Green "recommended"
+  printTag Latest             = color' Yellow "latest"
+  printTag (Base pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
+  printTag (UnknownTag t    ) = t
+  color' = case raw of
+    True  -> flip const
+    False -> color
 
 checkForUpdates :: (MonadThrow m, MonadIO m, MonadFail m, MonadLogger m)
                 => GHCupDownloads

ghcup.cabal

@@ -41,9 +41,6 @@ common ascii-string
 common async
   build-depends: async >=0.8
 
-common attoparsec
-  build-depends: attoparsec >=0.13
-
 common base
   build-depends: base >=4.12 && <5
 
@@ -230,7 +227,6 @@ library
     , aeson
     , ascii-string
     , async
-    , attoparsec
     , binary
     , bytestring
     , bz2
@@ -248,6 +244,7 @@ library
     , hpath-posix
     , language-bash
     , lzma
+    , megaparsec
     , monad-logger
     , mtl
     , optics
@@ -279,6 +276,9 @@ library
 
   exposed-modules:
     GHCup
+    GHCup.Data.GHCupDownloads
+    GHCup.Data.GHCupInfo
+    GHCup.Data.ToolRequirements
     GHCup.Download
     GHCup.Download.Utils
     GHCup.Errors
@@ -292,6 +292,7 @@ library
     GHCup.Utils.Dirs
     GHCup.Utils.File
     GHCup.Utils.Logger
+    GHCup.Utils.MegaParsec
     GHCup.Utils.Prelude
     GHCup.Utils.String.QQ
     GHCup.Utils.Version.QQ
@@ -372,9 +373,6 @@ executable ghcup-gen
   --
   main-is:          Main.hs
   other-modules:
-    GHCupDownloads
-    GHCupInfo
-    ToolRequirements
     Validate
 
   -- other-extensions:

lib/GHCup.hs

@@ -41,6 +41,7 @@ import           Data.ByteString                ( ByteString )
 import           Data.List
 import           Data.Maybe
 import           Data.String.Interpolate
+import           Data.Text                      ( Text )
 import           Data.Versions
 import           Data.Word8
 import           GHC.IO.Exception
@@ -53,11 +54,14 @@ import           Prelude                 hiding ( abs
                                                 , writeFile
                                                 )
 import           System.IO.Error
+import           System.Posix.Env.ByteString    ( getEnvironment )
 import           System.Posix.FilePath          ( getSearchPath )
 import           System.Posix.Files.ByteString
 
 import qualified Data.ByteString               as B
+import qualified Data.ByteString.Lazy          as BL
 import qualified Data.Map.Strict               as Map
+import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
 
 
@@ -94,45 +98,34 @@ installGHCBin :: ( MonadFail m
                    m
                    ()
 installGHCBin bDls ver mpfReq = do
+  let tver = (mkTVer ver)
   lift $ $(logDebug) [i|Requested to install GHC with #{ver}|]
-  whenM (liftIO $ toolAlreadyInstalled GHC ver)
+  whenM (liftIO $ ghcInstalled tver)
     $ (throwE $ AlreadyInstalled GHC ver)
-  Settings {..} <- lift ask
+  Settings {..}                <- lift ask
   pfreq@(PlatformRequest {..}) <- maybe (liftE $ platformRequest) pure mpfReq
 
   -- download (or use cached version)
-  dlinfo        <- lE $ getDownloadInfo GHC ver pfreq bDls
+  dlinfo                       <- lE $ getDownloadInfo GHC ver pfreq bDls
-  dl            <- liftE $ downloadCached dlinfo Nothing
+  dl                           <- liftE $ downloadCached dlinfo Nothing
 
   -- unpack
-  tmpUnpack     <- lift mkGhcupTmpDir
+  tmpUnpack                    <- lift mkGhcupTmpDir
   liftE $ unpackToDir tmpUnpack dl
   void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
 
   -- prepare paths
-  ghcdir <- liftIO $ ghcupGHCDir ver
+  ghcdir <- liftIO $ ghcupGHCDir tver
 
   -- the subdir of the archive where we do the work
   let workdir = maybe tmpUnpack (tmpUnpack </>) (view dlSubdir dlinfo)
 
-  -- Be careful about cleanup. We must catch both pure exceptions
+  liftE $ runBuildAction tmpUnpack (Just ghcdir) (installGHC' workdir ghcdir)
-  -- as well as async ones.
-  flip onException
-       (liftIO $ hideError doesNotExistErrorType $ deleteDirRecursive ghcdir)
-    $ catchAllE
-        (\es -> do
-          liftIO (hideError doesNotExistErrorType $ deleteDirRecursive ghcdir)
-            >> throwE (BuildFailed workdir es)
-        )
-    $ installGHC' workdir ghcdir
 
-  -- only clean up dir if the build succeeded
+  liftE $ postGHCInstall tver
-  liftIO $ deleteDirRecursive tmpUnpack
-
-  liftE $ postGHCInstall ver
 
  where
-    -- | Install an unpacked GHC distribution. This only deals with the GHC build system and nothing else.
+  -- | Install an unpacked GHC distribution. This only deals with the GHC build system and nothing else.
   installGHC' :: (MonadLogger m, MonadIO m)
               => Path Abs      -- ^ Path to the unpacked GHC bindist (where the configure script resides)
               -> Path Abs      -- ^ Path to install to
@@ -173,15 +166,15 @@ installCabalBin :: ( MonadMask m
                      ()
 installCabalBin bDls ver mpfReq = do
   lift $ $(logDebug) [i|Requested to install cabal version #{ver}|]
-  Settings {..} <- lift ask
+  Settings {..}                <- lift ask
   pfreq@(PlatformRequest {..}) <- maybe (liftE $ platformRequest) pure mpfReq
 
   -- download (or use cached version)
-  dlinfo        <- lE $ getDownloadInfo Cabal ver pfreq bDls
+  dlinfo                       <- lE $ getDownloadInfo Cabal ver pfreq bDls
-  dl            <- liftE $ downloadCached dlinfo Nothing
+  dl                           <- liftE $ downloadCached dlinfo Nothing
 
   -- unpack
-  tmpUnpack     <- lift withGHCupTmpDir
+  tmpUnpack                    <- lift withGHCupTmpDir
   liftE $ unpackToDir tmpUnpack dl
   void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
 
@@ -195,7 +188,7 @@ installCabalBin bDls ver mpfReq = do
   pure ()
 
  where
-    -- | Install an unpacked cabal distribution.
+  -- | Install an unpacked cabal distribution.
   installCabal' :: (MonadLogger m, MonadCatch m, MonadIO m)
                 => Path Abs      -- ^ Path to the unpacked cabal bindist (where the executable resides)
                 -> Path Abs      -- ^ Path to install to
@@ -227,11 +220,11 @@ installCabalBin bDls ver mpfReq = do
 -- Additionally creates a ~/.ghcup/share -> ~/.ghcup/ghc/<ver>/share symlink
 -- for `SetGHCOnly` constructor.
 setGHC :: (MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
-       => Version
+       => GHCTargetVersion
        -> SetGHC
-       -> Excepts '[NotInstalled] m Version
+       -> Excepts '[NotInstalled] m GHCTargetVersion
 setGHC ver sghc = do
-  let verBS = verToBS ver
+  let verBS = verToBS (_tvVersion ver)
   ghcdir <- liftIO $ ghcupGHCDir ver
 
   -- symlink destination
@@ -241,7 +234,7 @@ setGHC ver sghc = do
   -- first delete the old symlinks (this fixes compatibility issues
   -- with old ghcup)
   case sghc of
-    SetGHCOnly -> liftE $ rmPlain ver
+    SetGHCOnly -> liftE $ rmPlain (_tvTarget ver)
     SetGHC_XY  -> lift $ rmMajorSymlinks ver
     SetGHC_XYZ -> lift $ rmMinorSymlinks ver
 
@@ -251,9 +244,8 @@ setGHC ver sghc = do
     targetFile <- case sghc of
       SetGHCOnly -> pure file
       SetGHC_XY  -> do
-        major' <-
+        major' <- (\(mj, mi) -> E.encodeUtf8 $ intToText mj <> "." <> intToText mi)
-          (\(mj, mi) -> E.encodeUtf8 $ intToText mj <> "." <> intToText mi)
+                     <$> getMajorMinorV (_tvVersion ver)
-            <$> getGHCMajor ver
         parseRel (toFilePath file <> B.singleton _hyphen <> major')
       SetGHC_XYZ -> parseRel (toFilePath file <> B.singleton _hyphen <> verBS)
 
@@ -264,7 +256,7 @@ setGHC ver sghc = do
     liftIO $ createSymlink fullF destL
 
   -- create symlink for share dir
-  lift $ symlinkShareDir ghcdir verBS
+  when (isNothing . _tvTarget $ ver) $ lift $ symlinkShareDir ghcdir verBS
 
   pure ver
 
@@ -304,6 +296,7 @@ data ListCriteria = ListInstalled
 data ListResult = ListResult
   { lTool      :: Tool
   , lVer       :: Version
+  , lCross     :: Maybe Text -- ^ currently only for GHC
   , lTag       :: [Tag]
   , lInstalled :: Bool
   , lSet       :: Bool -- ^ currently active version
@@ -321,7 +314,7 @@ availableToolVersions av tool = view
 
 -- | List all versions from the download info, as well as stray
 -- versions.
-listVersions :: (MonadLogger m, MonadIO m)
+listVersions :: (MonadThrow m, MonadLogger m, MonadIO m)
              => GHCupDownloads
              -> Maybe Tool
              -> Maybe ListCriteria
@@ -345,44 +338,58 @@ listVersions av lt criteria = case lt of
     pure (ghcvers <> cabalvers <> ghcupvers)
 
  where
-  strayGHCs :: (MonadLogger m, MonadIO m)
+  strayGHCs :: (MonadThrow m, MonadLogger m, MonadIO m)
             => Map.Map Version [Tag]
             -> m [ListResult]
   strayGHCs avTools = do
-    ghcdir <- liftIO $ ghcupGHCBaseDir
+    ghcs <- getInstalledGHCs
-    fs     <- liftIO $ getDirsFiles' ghcdir
+    fmap catMaybes $ forM ghcs $ \case
-    fmap catMaybes $ forM fs $ \(toFilePath -> f) -> do
+      Right tver@GHCTargetVersion{ _tvTarget = Nothing, .. } -> do
-      case version . decUTF8Safe $ f of
+        case Map.lookup _tvVersion avTools of
-        Right v' -> do
+          Just _  -> pure Nothing
-          case Map.lookup v' avTools of
+          Nothing -> do
-            Just _  -> pure Nothing
+            lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet Nothing
-            Nothing -> do
+            fromSrc <- liftIO $ ghcSrcInstalled tver
-              lSet    <- fmap (maybe False (== v')) $ ghcSet
+            pure $ Just $ ListResult
-              fromSrc <- liftIO $ ghcSrcInstalled v'
+              { lTool      = GHC
-              pure $ Just $ ListResult
+              , lVer       = _tvVersion
-                { lTool      = GHC
+              , lCross     = Nothing
-                , lVer       = v'
+              , lTag       = []
-                , lTag       = []
+              , lInstalled = True
-                , lInstalled = True
+              , lStray     = maybe True (const False) (Map.lookup _tvVersion avTools)
-                , lStray     = maybe True (const False) (Map.lookup v' avTools)
+              , ..
-                , ..
+              }
-                }
+      Right tver@GHCTargetVersion{ .. } -> do
-        Left e -> do
+        lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet _tvTarget
-          $(logWarn)
+        fromSrc <- liftIO $ ghcSrcInstalled tver
-            [i|Could not parse version of stray directory #{toFilePath ghcdir}/#{f}: #{e}|]
+        pure $ Just $ ListResult
-          pure Nothing
+          { lTool      = GHC
+          , lVer       = _tvVersion
+          , lCross     = _tvTarget
+          , lTag       = []
+          , lInstalled = True
+          , lStray     = True -- NOTE: cross currently cannot be installed via bindist
+          , ..
+          }
+      Left e -> do
+        $(logWarn)
+          [i|Could not parse version of stray directory #{toFilePath e}|]
+        pure Nothing
 
+  -- NOTE: this are not cross ones, because no bindists
   toListResult :: Tool -> (Version, [Tag]) -> IO ListResult
   toListResult t (v, tags) = case t of
     GHC -> do
-      lSet       <- fmap (maybe False (== v)) $ ghcSet
+      let tver = mkTVer v
-      lInstalled <- ghcInstalled v
+      lSet       <- fmap (maybe False (\(GHCTargetVersion _ v') -> v' == v)) $ ghcSet Nothing
-      fromSrc    <- ghcSrcInstalled v
+      lInstalled <- ghcInstalled tver
-      pure ListResult { lVer = v, lTag = tags, lTool = t, lStray = False, .. }
+      fromSrc    <- ghcSrcInstalled tver
+      pure ListResult { lVer = v, lCross = Nothing , lTag = tags, lTool = t, lStray = False, .. }
     Cabal -> do
       lSet <- fmap (== v) $ cabalSet
       let lInstalled = lSet
       pure ListResult { lVer    = v
+                      , lCross  = Nothing
                       , lTag    = tags
                       , lTool   = t
                       , fromSrc = False
@@ -394,6 +401,7 @@ listVersions av lt criteria = case lt of
       let lInstalled = lSet
       pure ListResult { lVer    = v
                       , lTag    = tags
+                      , lCross  = Nothing
                       , lTool   = t
                       , fromSrc = False
                       , lStray  = False
@@ -416,10 +424,10 @@ listVersions av lt criteria = case lt of
 
 -- | This function may throw and crash in various ways.
 rmGHCVer :: (MonadThrow m, MonadLogger m, MonadIO m, MonadFail m)
-         => Version
+         => GHCTargetVersion
          -> Excepts '[NotInstalled] m ()
 rmGHCVer ver = do
-  isSetGHC <- fmap (maybe False (== ver)) $ ghcSet
+  isSetGHC <- fmap (maybe False (== ver)) $ ghcSet (_tvTarget ver)
   dir      <- liftIO $ ghcupGHCDir ver
   let d' = toFilePath dir
   exists <- liftIO $ doesDirectoryExist dir
@@ -430,7 +438,7 @@ rmGHCVer ver = do
       -- this isn't atomic, order matters
       when isSetGHC $ do
         lift $ $(logInfo) [i|Removing ghc symlinks|]
-        liftE $ rmPlain ver
+        liftE $ rmPlain (_tvTarget ver)
 
       lift $ $(logInfo) [i|Removing directory recursively: #{d'}|]
       liftIO $ deleteDirRecursive dir
@@ -442,15 +450,15 @@ rmGHCVer ver = do
       -- first remove
       lift $ rmMajorSymlinks ver
       -- then fix them (e.g. with an earlier version)
-      (mj, mi) <- getGHCMajor ver
+      (mj, mi) <- getMajorMinorV (_tvVersion ver)
-      getGHCForMajor mj mi >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
+      getGHCForMajor mj mi (_tvTarget ver) >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
 
       liftIO
         $   ghcupBaseDir
         >>= hideError doesNotExistErrorType
         .   deleteFile
         .   (</> [rel|share|])
-    else throwE (NotInstalled GHC ver)
+    else throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer))
 
 
 
@@ -491,11 +499,12 @@ compileGHC :: ( MonadMask m
               , MonadFail m
               )
            => GHCupDownloads
-           -> Version                    -- ^ version to install
+           -> GHCTargetVersion           -- ^ version to install
            -> Either Version (Path Abs)  -- ^ version to bootstrap with
            -> Maybe Int                  -- ^ jobs
            -> Maybe (Path Abs)           -- ^ build config
-           -> Maybe (Path Abs)
+           -> Maybe (Path Abs)           -- ^ patch directory
+           -> [Text]                     -- ^ additional args to ./configure
            -> Excepts
                 '[ AlreadyInstalled
                  , BuildFailed
@@ -512,13 +521,15 @@ compileGHC :: ( MonadMask m
                  ]
                 m
                 ()
-compileGHC dls tver bstrap jobs mbuildConfig patchdir = do
+compileGHC dls tver bstrap jobs mbuildConfig patchdir aargs = do
   lift $ $(logDebug) [i|Requested to compile: #{tver} with #{bstrap}|]
-  whenM (liftIO $ toolAlreadyInstalled GHC tver)
+  whenM (liftIO $ ghcInstalled tver)
-        (throwE $ AlreadyInstalled GHC tver)
+        (throwE $ AlreadyInstalled GHC (tver ^. tvVersion))
 
   -- download source tarball
-  dlInfo    <- preview (ix GHC % ix tver % viSourceDL % _Just) dls ?? NoDownload
+  dlInfo <-
+    preview (ix GHC % ix (tver ^. tvVersion) % viSourceDL % _Just) dls
+      ?? NoDownload
   dl        <- liftE $ downloadCached dlInfo Nothing
 
   -- unpack
@@ -533,32 +544,29 @@ compileGHC dls tver bstrap jobs mbuildConfig patchdir = do
   let workdir = maybe id (flip (</>)) (view dlSubdir dlInfo) $ tmpUnpack
   ghcdir <- liftIO $ ghcupGHCDir tver
 
-  -- Be careful about cleanup. We must catch both pure exceptions
+  liftE $ runBuildAction
-  -- as well as async ones.
+    tmpUnpack
-  flip onException
+    (Just ghcdir)
-       (liftIO $ hideError doesNotExistErrorType $ deleteDirRecursive ghcdir)
+    (compile bghc ghcdir workdir >> markSrcBuilt ghcdir workdir)
-    $ catchAllE
-        (\es ->
-          liftIO (hideError doesNotExistErrorType $ deleteDirRecursive ghcdir)
-            >> throwE (BuildFailed workdir es)
-        )
-    $ compile bghc ghcdir workdir
-  markSrcBuilt ghcdir workdir
-
-  -- only clean up dir if the build succeeded
-  liftIO $ deleteDirRecursive tmpUnpack
 
   reThrowAll GHCupSetError $ postGHCInstall tver
   pure ()
 
  where
-  defaultConf = [s|
+  defaultConf = case _tvTarget tver of
+                  Nothing -> [s|
 V=0
 BUILD_MAN = NO
 BUILD_SPHINX_HTML = NO
 BUILD_SPHINX_PDF = NO
-HADDOCK_DOCS = YES
+HADDOCK_DOCS = YES|]
-GhcWithLlvmCodeGen = YES|]
+                  Just _ -> [s|
+V=0
+BUILD_MAN = NO
+BUILD_SPHINX_HTML = NO
+BUILD_SPHINX_PDF = NO
+HADDOCK_DOCS = NO
+Stage1Only = YES|]
 
   compile :: (MonadCatch m, MonadLogger m, MonadIO m)
           => Either (Path Rel) (Path Abs)
@@ -566,6 +574,7 @@ GhcWithLlvmCodeGen = YES|]
           -> Path Abs
           -> Excepts
                '[ FileDoesNotExistError
+                , InvalidBuildConfig
                 , PatchFailed
                 , ProcessError
                 , NotFoundInPATH
@@ -574,14 +583,14 @@ GhcWithLlvmCodeGen = YES|]
                ()
   compile bghc ghcdir workdir = do
     lift $ $(logInfo) [i|configuring build|]
+    liftE $ checkBuildConfig
 
     forM_ patchdir $ \dir -> liftE $ applyPatches dir workdir
 
-    -- force ld.bfd for build (others seem to misbehave, like lld from FreeBSD)
+    cEnv <- liftIO $ getEnvironment
-    newEnv <- addToCurrentEnv [("LD", "ld.bfd")]
 
     if
-      | tver >= [vver|8.8.0|] -> do
+      | (_tvVersion tver) >= [vver|8.8.0|] -> do
         bghcPath <- case bghc of
           Right ghc' -> pure ghc'
           Left  bver -> do
@@ -590,20 +599,32 @@ GhcWithLlvmCodeGen = YES|]
         lEM $ liftIO $ execLogged
           "./configure"
           False
-          ["--prefix=" <> toFilePath ghcdir]
+          (  ["--prefix=" <> toFilePath ghcdir]
+          ++ (maybe mempty
+                    (\x -> ["--target=" <> E.encodeUtf8 x])
+                    (_tvTarget tver)
+             )
+          ++ fmap E.encodeUtf8 aargs
+          )
           [rel|ghc-conf|]
           (Just workdir)
-          (Just (("GHC", toFilePath bghcPath) : newEnv))
+          (Just (("GHC", toFilePath bghcPath) : cEnv))
       | otherwise -> do
         lEM $ liftIO $ execLogged
           "./configure"
           False
-          [ "--prefix=" <> toFilePath ghcdir
+          (  [ "--prefix=" <> toFilePath ghcdir
-          , "--with-ghc=" <> either toFilePath toFilePath bghc
+             , "--with-ghc=" <> either toFilePath toFilePath bghc
-          ]
+             ]
+          ++ (maybe mempty
+                    (\x -> ["--target=" <> E.encodeUtf8 x])
+                    (_tvTarget tver)
+             )
+          ++ fmap E.encodeUtf8 aargs
+          )
           [rel|ghc-conf|]
           (Just workdir)
-          (Just newEnv)
+          (Just cEnv)
 
     case mbuildConfig of
       Just bc -> liftIOException
@@ -626,6 +647,30 @@ GhcWithLlvmCodeGen = YES|]
 
   build_mk workdir = workdir </> [rel|mk/build.mk|]
 
+  checkBuildConfig :: (MonadCatch m, MonadIO m)
+                   => Excepts
+                        '[FileDoesNotExistError , InvalidBuildConfig]
+                        m
+                        ()
+  checkBuildConfig = do
+    c <- case mbuildConfig of
+      Just bc -> do
+        BL.toStrict <$> liftIOException doesNotExistErrorType
+                                        (FileDoesNotExistError $ toFilePath bc)
+                                        (liftIO $ readFile bc)
+      Nothing -> pure defaultConf
+    let lines' = fmap T.strip . T.lines $ decUTF8Safe c
+
+   -- for cross, we need Stage1Only
+    case _tvTarget tver of
+      Just _ -> when (not $ elem "Stage1Only = YES" lines') $ throwE
+        (InvalidBuildConfig
+          [s|Cross compiling needs to be a Stage1 build, add "Stage1Only = YES" to your config!|]
+        )
+      Nothing -> pure ()
+
+
+
 
 compileCabal :: ( MonadReader Settings m
                 , MonadResource m
@@ -666,7 +711,11 @@ compileCabal dls tver bghc jobs patchdir = do
 
   let workdir = maybe id (flip (</>)) (view dlSubdir dlInfo) $ tmpUnpack
 
-  reThrowAll (BuildFailed workdir) $ compile workdir
+
+  liftE $ runBuildAction
+    tmpUnpack
+    Nothing
+    (compile workdir)
 
   -- only clean up dir if the build succeeded
   liftIO $ deleteDirRecursive tmpUnpack
@@ -781,12 +830,12 @@ upgradeGHCup dls mtarget force = do
 -- | Creates ghc-x.y.z and ghc-x.y symlinks. This is used for
 -- both installing from source and bindist.
 postGHCInstall :: (MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
-               => Version
+               => GHCTargetVersion
                -> Excepts '[NotInstalled] m ()
-postGHCInstall ver = do
+postGHCInstall ver@GHCTargetVersion{..} = do
   void $ liftE $ setGHC ver SetGHC_XYZ
 
   -- Create ghc-x.y symlinks. This may not be the current
   -- version, create it regardless.
-  (mj, mi) <- liftIO $ getGHCMajor ver
+  (mj, mi) <- getMajorMinorV _tvVersion
-  getGHCForMajor mj mi >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
+  getGHCForMajor mj mi _tvTarget >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)

lib/GHCup/Data/GHCupDownloads.hs

@@ -2,7 +2,7 @@
 {-# LANGUAGE QuasiQuotes       #-}
 
 
-module GHCupDownloads where
+module GHCup.Data.GHCupDownloads where
 
 import           GHCup.Types
 import           GHCup.Utils.Version.QQ
@@ -951,6 +951,24 @@ cabal_3000_64_darwin = DownloadInfo
   Nothing
   "d4857e068560515e4cbb0e8ca124c370e07892f2a28804d87152834e5fe2b845"
 
+cabal_3000_64_freebsd :: DownloadInfo
+cabal_3000_64_freebsd = DownloadInfo
+  [uri|https://hasufell.de/d/d3e215db133e4fcaa61e/files/?p=/cabal-install-3.0.0.0-x86_64-portbld-freebsd.tar.xz&dl=1|]
+  Nothing
+  "d97b6469ed612a1367ad1032d0722469ee5277668879694d7d4336233b937516"
+
+cabal_3000_32_alpine :: DownloadInfo
+cabal_3000_32_alpine = DownloadInfo
+  [uri|https://hasufell.de/d/d3e215db133e4fcaa61e/files/?p=/cabal-install-3.0.0.0-i386-alpine-linux-musl.tar.xz&dl=1|]
+  Nothing
+  "a4191cd5a645b00e6a9c53abe6f3cb91fe700de7d7c520c9cb36ce8ec5c9919a"
+
+cabal_3000_64_alpine :: DownloadInfo
+cabal_3000_64_alpine = DownloadInfo
+  [uri|https://hasufell.de/d/d3e215db133e4fcaa61e/files/?p=/cabal-install-3.0.0.0-x86_64-alpine-linux-musl.tar.xz&dl=1|]
+  Nothing
+  "7b35e5986aba4a40fc37141cbde26612bfc916e95a2d2ff35a413612d8c7cd3a"
+
 
 
     ---------------------
@@ -976,6 +994,24 @@ cabal_3200_64_darwin = DownloadInfo
   Nothing
   "9197c17d2ece0f934f5b33e323cfcaf486e4681952687bc3d249488ce3cbe0e9"
 
+cabal_3200_64_freebsd :: DownloadInfo
+cabal_3200_64_freebsd = DownloadInfo
+  [uri|https://hasufell.de/d/d3e215db133e4fcaa61e/files/?p=/cabal-install-3.2.0.0-x86_64-portbld-freebsd.tar.xz&dl=1|]
+  Nothing
+  "e4dc00ab7fef51354e7624dd03e49c6bb684887fc95acb9b33bc52f357a5ef8c"
+
+cabal_3200_32_alpine :: DownloadInfo
+cabal_3200_32_alpine = DownloadInfo
+  [uri|https://hasufell.de/d/d3e215db133e4fcaa61e/files/?p=/cabal-install-3.2.0.0-i386-alpine-linux-musl.tar.xz&dl=1|]
+  Nothing
+  "4aaa52fbc337ae1ef855a2aa2808186580b21ec36883aafec7473e7d899bc5ec"
+
+cabal_3200_64_alpine :: DownloadInfo
+cabal_3200_64_alpine = DownloadInfo
+  [uri|https://hasufell.de/d/d3e215db133e4fcaa61e/files/?p=/cabal-install-3.2.0.0-x86_64-alpine-linux-musl.tar.xz&dl=1|]
+  Nothing
+  "c1f3c21a5307cea8d2a0bd9a2eab9f56f3dd90e947ae64e231f909024980992b"
+
 
 
 
@@ -1026,7 +1062,7 @@ ghcupDownloads = M.fromList
     , M.fromList
       [ ( [vver|7.10.3|]
         , VersionInfo
-            []
+            [Base [pver|4.8.2.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/7.10.3/docs/html/users_guide/release-7-10-1.html|]
             )
@@ -1072,7 +1108,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.0.2|]
         , VersionInfo
-            []
+            [Base [pver|4.9.1.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.0.2/docs/html/users_guide/8.0.1-notes.html|]
             )
@@ -1118,7 +1154,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.2.2|]
         , VersionInfo
-            []
+            [Base [pver|4.10.1.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.2.2/docs/html/users_guide/8.2.2-notes.html|]
             )
@@ -1170,7 +1206,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.4.1|]
         , VersionInfo
-            []
+            [Base [pver|4.11.0.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.4.1/docs/html/users_guide/8.4.1-notes.html|]
             )
@@ -1209,7 +1245,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.4.2|]
         , VersionInfo
-            []
+            [Base [pver|4.11.1.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.4.2/docs/html/users_guide/8.4.2-notes.html|]
             )
@@ -1259,7 +1295,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.4.3|]
         , VersionInfo
-            []
+            [Base [pver|4.11.1.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.4.3/docs/html/users_guide/8.4.3-notes.html|]
             )
@@ -1308,7 +1344,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.4.4|]
         , VersionInfo
-            []
+            [Base [pver|4.11.1.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.4.4/docs/html/users_guide/8.4.4-notes.html|]
             )
@@ -1362,7 +1398,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.6.1|]
         , VersionInfo
-            []
+            [Base [pver|4.12.0.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.6.1/docs/html/users_guide/8.6.1-notes.html|]
             )
@@ -1412,7 +1448,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.6.2|]
         , VersionInfo
-            []
+            [Base [pver|4.12.0.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.6.2/docs/html/users_guide/8.6.2-notes.html|]
             )
@@ -1456,7 +1492,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.6.3|]
         , VersionInfo
-            []
+            [Base [pver|4.12.0.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.6.3/docs/html/users_guide/8.6.3-notes.html|]
             )
@@ -1510,7 +1546,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.6.4|]
         , VersionInfo
-            []
+            [Base [pver|4.12.0.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.6.4/docs/html/users_guide/8.6.4-notes.html|]
             )
@@ -1559,7 +1595,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.6.5|]
         , VersionInfo
-            []
+            [Base [pver|4.12.0.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.6.5/docs/html/users_guide/8.6.5-notes.html|]
             )
@@ -1612,7 +1648,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.8.1|]
         , VersionInfo
-            []
+            [Base [pver|4.13.0.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.8.1/docs/html/users_guide/8.8.1-notes.html|]
             )
@@ -1665,7 +1701,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.8.2|]
         , VersionInfo
-            []
+            [Base [pver|4.13.0.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.8.2/docs/html/users_guide/8.8.2-notes.html|]
             )
@@ -1718,7 +1754,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.8.3|]
         , VersionInfo
-            [Recommended]
+            [Recommended, Base [pver|4.13.0.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.8.3/docs/html/users_guide/8.8.3-notes.html|]
             )
@@ -1771,7 +1807,7 @@ ghcupDownloads = M.fromList
         )
       , ( [vver|8.10.1|]
         , VersionInfo
-            [Latest]
+            [Latest, Base [pver|4.14.0.0|]]
             (Just
               [uri|https://downloads.haskell.org/ghc/8.10.1/docs/html/users_guide/8.10.1-notes.html|]
             )
@@ -1889,7 +1925,9 @@ ghcupDownloads = M.fromList
                   [ ( Linux UnknownLinux
                     , M.fromList [(Nothing, cabal_3000_64_linux)]
                     )
-                  , (Darwin, M.fromList [(Nothing, cabal_3000_64_darwin)])
+                  , (Linux Alpine, M.fromList [(Nothing, cabal_3000_64_alpine)])
+                  , (Darwin      , M.fromList [(Nothing, cabal_3000_64_darwin)])
+                  , (FreeBSD, M.fromList [(Nothing, cabal_3000_64_freebsd)])
                   ]
                 )
               , ( A_32
@@ -1897,6 +1935,7 @@ ghcupDownloads = M.fromList
                   [ ( Linux UnknownLinux
                     , M.fromList [(Nothing, cabal_3000_32_linux)]
                     )
+                  , (Linux Alpine, M.fromList [(Nothing, cabal_3000_32_alpine)])
                   ]
                 )
               ]
@@ -1918,7 +1957,9 @@ ghcupDownloads = M.fromList
                   [ ( Linux UnknownLinux
                     , M.fromList [(Nothing, cabal_3200_64_linux)]
                     )
-                  , (Darwin, M.fromList [(Nothing, cabal_3200_64_darwin)])
+                  , (Linux Alpine, M.fromList [(Nothing, cabal_3200_64_alpine)])
+                  , (Darwin      , M.fromList [(Nothing, cabal_3200_64_darwin)])
+                  , (FreeBSD, M.fromList [(Nothing, cabal_3200_64_freebsd)])
                   ]
                 )
               , ( A_32
@@ -1926,6 +1967,7 @@ ghcupDownloads = M.fromList
                   [ ( Linux UnknownLinux
                     , M.fromList [(Nothing, cabal_3200_32_linux)]
                     )
+                  , (Linux Alpine, M.fromList [(Nothing, cabal_3200_32_alpine)])
                   ]
                 )
               ]

lib/GHCup/Data/GHCupInfo.hs

@@ -1,7 +1,7 @@
-module GHCupInfo where
+module GHCup.Data.GHCupInfo where
 
-import           GHCupDownloads
+import           GHCup.Data.GHCupDownloads
-import           ToolRequirements
+import           GHCup.Data.ToolRequirements
 import           GHCup.Types
 
 

lib/GHCup/Data/ToolRequirements.hs

@@ -1,7 +1,7 @@
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE QuasiQuotes       #-}
 
-module ToolRequirements where
+module GHCup.Data.ToolRequirements where
 
 import           GHCup.Types
 import           GHCup.Utils.String.QQ

lib/GHCup/Errors.hs

@@ -64,7 +64,7 @@ data AlreadyInstalled = AlreadyInstalled Tool Version
 
 -- | The tool is not installed. Some operations rely on a tool
 -- to be installed (such as setting the current GHC version).
-data NotInstalled = NotInstalled Tool Version
+data NotInstalled = NotInstalled Tool Text
   deriving Show
 
 -- | An executable was expected to be in PATH, but was not found.
@@ -104,6 +104,9 @@ data PatchFailed = PatchFailed
 data NoToolRequirements = NoToolRequirements
   deriving Show
 
+data InvalidBuildConfig = InvalidBuildConfig Text
+  deriving Show
+
 
     -------------------------
     --[ High-level errors ]--

lib/GHCup/Types.hs

@@ -1,4 +1,5 @@
-{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE DeriveGeneric     #-}
+{-# LANGUAGE OverloadedStrings #-}
 
 module GHCup.Types where
 
@@ -81,7 +82,9 @@ data VersionInfo = VersionInfo
 -- | A tag. These are currently attached to a version of a tool.
 data Tag = Latest
          | Recommended
-         deriving (Ord, Eq, Show)
+         | Base PVP
+         | UnknownTag String  -- ^ used for upwardscompat
+         deriving (Ord, Eq, Show) -- FIXME: manual JSON instance
 
 
 data Architecture = A_64
@@ -140,10 +143,17 @@ data URLSource = GHCupURL
 data Settings = Settings
   { cache    :: Bool
   , noVerify :: Bool
+  , keepDirs :: KeepDirs
   }
   deriving Show
 
 
+data KeepDirs = Always
+              | Errors
+              | Never
+  deriving (Eq, Show, Ord)
+
+
 data DebugInfo = DebugInfo
   { diBaseDir  :: Path Abs
   , diBinDir   :: Path Abs
@@ -173,3 +183,23 @@ data PlatformRequest = PlatformRequest
   , _rVersion  :: Maybe Versioning
   }
   deriving (Eq, Show)
+
+
+-- | A GHC identified by the target platform triple
+-- and the version.
+data GHCTargetVersion = GHCTargetVersion
+  { _tvTarget  :: Maybe Text
+  , _tvVersion :: Version
+  }
+  deriving (Ord, Eq, Show)
+
+
+mkTVer :: Version -> GHCTargetVersion
+mkTVer = GHCTargetVersion Nothing
+
+
+-- | Assembles a path of the form: <target-triple>-<version>
+prettyTVer :: GHCTargetVersion -> Text
+prettyTVer (GHCTargetVersion (Just t) v') = t <> "-" <> prettyVer v'
+prettyTVer (GHCTargetVersion Nothing  v') = prettyVer v'
+

lib/GHCup/Types/JSON.hs

@@ -37,11 +37,24 @@ deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VSep
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VUnit
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VersionInfo
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tag
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
 
+instance ToJSON Tag where
+  toJSON Latest             = String "Latest"
+  toJSON Recommended        = String "Recommended"
+  toJSON (Base       pvp'') = String ("base-" <> prettyPVP pvp'')
+  toJSON (UnknownTag x    ) = String (T.pack x)
+
+instance FromJSON Tag where
+  parseJSON = withText "Tag" $ \t -> case T.unpack t of
+    "Latest"                             -> pure Latest
+    "Recommended"                        -> pure Recommended
+    ('b' : 'a' : 's' : 'e' : '-' : ver') -> case pvp (T.pack ver') of
+      Right x -> pure $ Base x
+      Left  e -> fail . show $ e
+    x -> pure (UnknownTag x)
 
 instance ToJSON URI where
   toJSON = toJSON . decUTF8Safe . serializeURIRef'
@@ -143,6 +156,14 @@ instance FromJSONKey Version where
     Right x -> pure x
     Left  e -> fail $ "Failure in Version (FromJSONKey)" <> show e
 
+instance ToJSON PVP where
+  toJSON = toJSON . prettyPVP
+
+instance FromJSON PVP where
+  parseJSON = withText "PVP" $ \t -> case pvp t of
+    Right x -> pure x
+    Left  e -> fail $ "Failure in PVP (FromJSON)" <> show e
+
 instance ToJSONKey Tool where
   toJSONKey = genericToJSONKey defaultJSONKeyOptions
 

lib/GHCup/Types/Optics.hs

@@ -19,6 +19,8 @@ makeLenses ''DownloadInfo
 makeLenses ''Tag
 makeLenses ''VersionInfo
 
+makeLenses ''GHCTargetVersion
+
 makeLenses ''GHCupInfo
 
 uriSchemeL' :: Lens' (URIRef Absolute) Scheme

lib/GHCup/Utils.hs

@@ -4,6 +4,7 @@
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE ViewPatterns          #-}
 
 
 module GHCup.Utils
@@ -19,7 +20,9 @@ import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.File
+import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
+import           GHCup.Utils.String.QQ
 
 import           Control.Applicative
 import           Control.Exception.Safe
@@ -29,11 +32,12 @@ import           Control.Monad.Fail             ( MonadFail )
 #endif
 import           Control.Monad.Logger
 import           Control.Monad.Reader
-import           Data.Attoparsec.ByteString
 import           Data.ByteString                ( ByteString )
+import           Data.Either
 import           Data.List
 import           Data.Maybe
 import           Data.String.Interpolate
+import           Data.Text                      ( Text )
 import           Data.Versions
 import           Data.Word8
 import           GHC.IO.Exception
@@ -51,6 +55,7 @@ import           System.Posix.FilePath          ( getSearchPath
                                                 , takeFileName
                                                 )
 import           System.Posix.Files.ByteString  ( readSymbolicLink )
+import           Text.Regex.Posix
 import           URI.ByteString
 
 import qualified Codec.Archive.Tar             as Tar
@@ -60,7 +65,7 @@ import qualified Codec.Compression.Lzma        as Lzma
 import qualified Data.ByteString               as B
 import qualified Data.Map.Strict               as Map
 import qualified Data.Text.Encoding            as E
-
+import qualified Text.Megaparsec               as MP
 
 
 
@@ -73,64 +78,69 @@ import qualified Data.Text.Encoding            as E
 
 -- | The symlink destination of a ghc tool.
 ghcLinkDestination :: ByteString -- ^ the tool, such as 'ghc', 'haddock' etc.
-                   -> Version
+                   -> GHCTargetVersion
                    -> ByteString
-ghcLinkDestination tool ver = "../ghc/" <> verToBS ver <> "/bin/" <> tool
+ghcLinkDestination tool ver =
-
+  "../ghc/" <> E.encodeUtf8 (prettyTVer ver) <> "/bin/" <> tool
-
--- | Extract the version part of the result of `ghcLinkDestination`.
-ghcLinkVersion :: MonadThrow m => ByteString -> m Version
-ghcLinkVersion = either (throwM . ParseError) pure . parseOnly parser
- where
-  parser    = string "../ghc/" *> verParser <* string "/bin/ghc"
-  verParser = many1' (notWord8 _slash) >>= \t ->
-    case
-        version (decUTF8Safe $ B.pack t)
-      of
-        Left  e -> fail $ show e
-        Right r -> pure r
 
 
 -- e.g. ghc-8.6.5
-rmMinorSymlinks :: (MonadIO m, MonadLogger m) => Version -> m ()
+rmMinorSymlinks :: (MonadIO m, MonadLogger m) => GHCTargetVersion -> m ()
-rmMinorSymlinks ver = do
+rmMinorSymlinks GHCTargetVersion {..} = do
   bindir <- liftIO $ ghcupBinDir
-  files  <- liftIO $ getDirsFiles' bindir
+
-  let myfiles =
+  files  <- liftIO $ findFiles'
-        filter (\x -> ("-" <> verToBS ver) `B.isSuffixOf` toFilePath x) files
+    bindir
-  forM_ myfiles $ \f -> do
+    (  maybe mempty (\x -> MP.chunk (x <> "-")) _tvTarget
+    *> parseUntil1 (MP.chunk $ prettyVer _tvVersion)
+    *> (MP.chunk $ prettyVer _tvVersion)
+    *> MP.eof
+    )
+
+  forM_ files $ \f -> do
     let fullF = (bindir </> f)
     $(logDebug) [i|rm -f #{toFilePath fullF}|]
     liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
 
--- E.g. ghc, if this version is the set one.
+
--- This reads `ghcupGHCDir`.
+-- Removes the set ghc version for the given target, if any.
 rmPlain :: (MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
-        => Version
+  => Maybe Text -- ^ target
         -> Excepts '[NotInstalled] m ()
-rmPlain ver = do
+rmPlain target = do
-  files  <- liftE $ ghcToolFiles ver
+  mtv <- ghcSet target
-  bindir <- liftIO $ ghcupBinDir
+  forM_ mtv $ \tv -> do
-  forM_ files $ \f -> do
+    files  <- liftE $ ghcToolFiles tv
-    let fullF = (bindir </> f)
+    bindir <- liftIO $ ghcupBinDir
-    lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
+    forM_ files $ \f -> do
-    liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
+      let fullF = (bindir </> f)
-  -- old ghcup
+      lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
-  let hdc_file = (bindir </> [rel|haddock-ghc|])
+      liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
-  lift $ $(logDebug) [i|rm -f #{toFilePath hdc_file}|]
+    -- old ghcup
-  liftIO $ hideError doesNotExistErrorType $ deleteFile hdc_file
+    let hdc_file = (bindir </> [rel|haddock-ghc|])
+    lift $ $(logDebug) [i|rm -f #{toFilePath hdc_file}|]
+    liftIO $ hideError doesNotExistErrorType $ deleteFile hdc_file
+
 
 -- e.g. ghc-8.6
-rmMajorSymlinks :: (MonadLogger m, MonadIO m) => Version -> m ()
+rmMajorSymlinks :: (MonadThrow m, MonadLogger m, MonadIO m)
-rmMajorSymlinks ver = do
+                => GHCTargetVersion
-  (mj, mi) <- liftIO $ getGHCMajor ver
+                -> m ()
-  let v' = E.encodeUtf8 $ intToText mj <> "." <> intToText mi
+rmMajorSymlinks GHCTargetVersion {..} = do
+  (mj, mi) <- getMajorMinorV _tvVersion
+  let v' = intToText mj <> "." <> intToText mi
 
   bindir <- liftIO ghcupBinDir
 
-  files  <- liftIO $ getDirsFiles' bindir
+  files  <- liftIO $ findFiles'
-  let myfiles = filter (\x -> ("-" <> v') `B.isSuffixOf` toFilePath x) files
+    bindir
-  forM_ myfiles $ \f -> do
+    (  maybe mempty (\x -> MP.chunk (x <> "-")) _tvTarget
+    *> parseUntil1 (MP.chunk v')
+    *> MP.chunk v'
+    *> MP.eof
+    )
+
+  forM_ files $ \f -> do
     let fullF = (bindir </> f)
     $(logDebug) [i|rm -f #{toFilePath fullF}|]
     liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
@@ -143,33 +153,60 @@ rmMajorSymlinks ver = do
     -----------------------------------
 
 
-toolAlreadyInstalled :: Tool -> Version -> IO Bool
+ghcInstalled :: GHCTargetVersion -> IO Bool
-toolAlreadyInstalled tool ver = case tool of
-  GHC   -> ghcInstalled ver
-  Cabal -> cabalInstalled ver
-  GHCup -> pure True
-
-
-ghcInstalled :: Version -> IO Bool
 ghcInstalled ver = do
   ghcdir <- ghcupGHCDir ver
   doesDirectoryExist ghcdir
 
 
-ghcSrcInstalled :: Version -> IO Bool
+ghcSrcInstalled :: GHCTargetVersion -> IO Bool
 ghcSrcInstalled ver = do
   ghcdir <- ghcupGHCDir ver
   doesFileExist (ghcdir </> ghcUpSrcBuiltFile)
 
 
-ghcSet :: (MonadIO m) => m (Maybe Version)
+ghcSet :: (MonadThrow m, MonadIO m)
-ghcSet = do
+       => Maybe Text   -- ^ the target of the GHC version, if any
-  ghcBin <- (</> [rel|ghc|]) <$> liftIO ghcupBinDir
+                       --  (e.g. armv7-unknown-linux-gnueabihf)
+       -> m (Maybe GHCTargetVersion)
+ghcSet mtarget = do
+  ghc    <- parseRel $ E.encodeUtf8 (maybe "ghc" (<> "-ghc") mtarget)
+  ghcBin <- (</> ghc) <$> liftIO ghcupBinDir
 
   -- link destination is of the form ../ghc/<ver>/bin/ghc
   liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ do
     link <- readSymbolicLink $ toFilePath ghcBin
     Just <$> ghcLinkVersion link
+ where
+  ghcLinkVersion :: MonadThrow m => ByteString -> m GHCTargetVersion
+  ghcLinkVersion bs = do
+    t <- throwEither $ E.decodeUtf8' bs
+    throwEither $ MP.parse parser "" t
+   where
+    parser =
+      MP.chunk "../ghc/"
+        *> (do
+             r    <- parseUntil1 (MP.chunk "/")
+             rest <- MP.getInput
+             MP.setInput r
+             x <- ghcTargetVerP
+             MP.setInput rest
+             pure x
+           )
+        <* MP.chunk "/bin/"
+        <* ghcTargetBinP "ghc"
+        <* MP.eof
+
+
+-- | Get all installed GHCs by reading ~/.ghcup/ghc/<dir>.
+-- If a dir cannot be parsed, returns left.
+getInstalledGHCs :: MonadIO m => m [Either (Path Rel) GHCTargetVersion]
+getInstalledGHCs = do
+  ghcdir <- liftIO $ ghcupGHCBaseDir
+  fs     <- liftIO $ hideErrorDef [NoSuchThing] [] $ getDirsFiles' ghcdir
+  forM fs $ \f -> case parseGHCupGHCDir f of
+    Right r -> pure $ Right r
+    Left  _ -> pure $ Left f
 
 
 cabalInstalled :: Version -> IO Bool
@@ -193,33 +230,49 @@ cabalSet = do
     -----------------------------------------
 
 
--- | We assume GHC is in semver format. I hope it is.
+getMajorMinorV :: MonadThrow m => Version -> m (Int, Int)
-getGHCMajor :: MonadThrow m => Version -> m (Int, Int)
+getMajorMinorV Version {..} = case _vChunks of
-getGHCMajor ver = do
+  ([Digits x] : [Digits y] : _) -> pure (fromIntegral x, fromIntegral y)
-  SemVer {..} <- throwEither (semver $ prettyVer ver)
+  _ -> throwM $ ParseError "Could not parse X.Y from version"
-  pure (fromIntegral _svMajor, fromIntegral _svMinor)
+
+
+matchMajor :: Version -> Int -> Int -> Bool
+matchMajor v' major' minor' = case getMajorMinorV v' of
+  Just (x, y) -> x == major' && y == minor'
+  Nothing     -> False
 
 
 -- | Get the latest installed full GHC version that satisfies X.Y.
 -- This reads `ghcupGHCBaseDir`.
 getGHCForMajor :: (MonadIO m, MonadThrow m)
-               => Int -- ^ major version component
+               => Int        -- ^ major version component
-               -> Int -- ^ minor version component
+               -> Int        -- ^ minor version component
-               -> m (Maybe Version)
+               -> Maybe Text -- ^ the target triple
-getGHCForMajor major' minor' = do
+               -> m (Maybe GHCTargetVersion)
-  p       <- liftIO $ ghcupGHCBaseDir
+getGHCForMajor major' minor' mt = do
-  ghcs    <- liftIO $ getDirsFiles' p
+  ghcs <- rights <$> getInstalledGHCs
-  semvers <- forM ghcs $ \ghc ->
+
-    throwEither . semver =<< (throwEither . E.decodeUtf8' . toFilePath $ ghc)
+  pure
-  mapM (throwEither . version)
-    . fmap prettySemVer
     . lastMay
-    . sort
+    . sortBy (\x y -> compare (_tvVersion x) (_tvVersion y))
     . filter
-        (\SemVer {..} ->
+        (\GHCTargetVersion {..} ->
-          fromIntegral _svMajor == major' && fromIntegral _svMinor == minor'
+          _tvTarget == mt && matchMajor _tvVersion major' minor'
         )
-    $ semvers
+    $ ghcs
+
+
+-- | Get the latest available ghc for X.Y major version.
+getLatestGHCFor :: Int -- ^ major version component
+                -> Int -- ^ minor version component
+                -> GHCupDownloads
+                -> Maybe Version
+getLatestGHCFor major' minor' dls = do
+  join
+    . fmap (lastMay . filter (\v -> matchMajor v major' minor'))
+    . preview (ix GHC % to Map.keys)
+    $ dls
+
 
 
 
@@ -265,7 +318,8 @@ unpackToDir dest av = do
 
 -- | Get the tool version that has this tag. If multiple have it,
 -- picks the greatest version.
-getTagged :: Tag -> AffineFold (Map.Map Version VersionInfo) (Version, VersionInfo)
+getTagged :: Tag
+          -> AffineFold (Map.Map Version VersionInfo) (Version, VersionInfo)
 getTagged tag =
   ( to (Map.filter (\VersionInfo {..} -> elem tag _viTags))
   % to Map.toDescList
@@ -279,6 +333,12 @@ getRecommended :: GHCupDownloads -> Tool -> Maybe Version
 getRecommended av tool = headOf (ix tool % getTagged Recommended % to fst) $ av
 
 
+-- | Gets the latest GHC with a given base version.
+getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe Version
+getLatestBaseVersion av pvpVer =
+  headOf (ix GHC % getTagged (Base pvpVer) % to fst) av
+
+
 
     -----------------------
     --[ Settings Getter ]--
@@ -302,12 +362,12 @@ urlBaseName = parseRel . snd . B.breakEnd (== _slash) . urlDecode False
 
 
 -- Get tool files from '~/.ghcup/bin/ghc/<ver>/bin/*'
--- while ignoring *-<ver> symlinks.
+-- while ignoring *-<ver> symlinks and accounting for cross triple prefix.
 --
 -- Returns unversioned relative files, e.g.:
 --   ["hsc2hs","haddock","hpc","runhaskell","ghc","ghc-pkg","ghci","runghc","hp2ps"]
 ghcToolFiles :: (MonadThrow m, MonadFail m, MonadIO m)
-             => Version
+             => GHCTargetVersion
              -> Excepts '[NotInstalled] m [Path Rel]
 ghcToolFiles ver = do
   ghcdir <- liftIO $ ghcupGHCDir ver
@@ -315,18 +375,28 @@ ghcToolFiles ver = do
 
   -- fail if ghc is not installed
   whenM (fmap not $ liftIO $ doesDirectoryExist ghcdir)
-        (throwE (NotInstalled GHC ver))
+        (throwE (NotInstalled GHC (prettyTVer ver)))
 
-  files         <- liftIO $ getDirsFiles' bindir
+  files    <- liftIO $ getDirsFiles' bindir
   -- figure out the <ver> suffix, because this might not be `Version` for
   -- alpha/rc releases, but x.y.a.somedate.
+
+  -- for cross, this won't be "ghc", but e.g.
+  -- "armv7-unknown-linux-gnueabihf-ghc"
+  [ghcbin] <- liftIO $ findFiles
+    bindir
+    (makeRegexOpts compExtended
+                   execBlank
+                   ([s|^([a-zA-Z0-9_-]*[a-zA-Z0-9_]-)?ghc$|] :: ByteString)
+    )
+
   (Just symver) <-
-    (B.stripPrefix "ghc-" . takeFileName)
+    (B.stripPrefix (toFilePath ghcbin <> "-") . takeFileName)
-      <$> (liftIO $ readSymbolicLink $ toFilePath (bindir </> [rel|ghc|]))
+      <$> (liftIO $ readSymbolicLink $ toFilePath (bindir </> ghcbin))
   when (B.null symver)
        (throwIO $ userError $ "Fatal: ghc symlink target is broken")
 
-  pure $ filter (\x -> not $ symver `B.isSuffixOf` toFilePath x) files
+  pure . filter (\x -> not $ symver `B.isSuffixOf` toFilePath x) $ files
 
 
 -- | This file, when residing in ~/.ghcup/ghc/<ver>/ signals that
@@ -377,10 +447,42 @@ darwinNotarization _ _ = pure $ Right ()
 getChangeLog :: GHCupDownloads -> Tool -> Either Version Tag -> Maybe URI
 getChangeLog dls tool (Left v') =
   preview (ix tool % ix v' % viChangeLog % _Just) dls
-getChangeLog dls tool (Right tag) = preview
+getChangeLog dls tool (Right tag) =
-  ( ix tool
+  preview (ix tool % getTagged tag % to snd % viChangeLog % _Just) dls
-  % getTagged tag
+
-  % to snd
+
-  % viChangeLog
+-- | Execute a build action while potentially cleaning up:
-  % _Just
+--
-  ) dls
+--   1. the build directory, depending on the KeepDirs setting
+--   2. the install destination, depending on whether the build failed
+runBuildAction :: (Show (V e), MonadReader Settings m, MonadIO m, MonadMask m)
+               => Path Abs          -- ^ build directory
+               -> Maybe (Path Abs)  -- ^ install location (e.g. for GHC)
+               -> Excepts e m ()
+               -> Excepts '[BuildFailed] m ()
+runBuildAction bdir instdir action = do
+  Settings {..} <- lift ask
+  flip
+      onException
+      (do
+        forM_ instdir $ \dir ->
+          liftIO $ hideError doesNotExistErrorType $ deleteDirRecursive dir
+        when (keepDirs == Never)
+          $ liftIO
+          $ hideError doesNotExistErrorType
+          $ deleteDirRecursive bdir
+      )
+    $ catchAllE
+        (\es -> do
+          forM_ instdir $ \dir ->
+            liftIO $ hideError doesNotExistErrorType $ deleteDirRecursive dir
+          when (keepDirs == Never)
+            $ liftIO
+            $ hideError doesNotExistErrorType
+            $ deleteDirRecursive bdir
+          throwE (BuildFailed bdir es)
+        )
+    $ action
+
+  when (keepDirs == Never || keepDirs == Errors) $ liftIO $ deleteDirRecursive
+    bdir

lib/GHCup/Utils/Dirs.hs

@@ -1,10 +1,13 @@
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE ViewPatterns          #-}
 
 module GHCup.Utils.Dirs where
 
 
+import           GHCup.Types
 import           GHCup.Types.JSON               ( )
+import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 
 import           Control.Applicative
@@ -13,7 +16,6 @@ import           Control.Monad
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
 import           Data.Maybe
-import           Data.Versions
 import           HPath
 import           HPath.IO
 import           Optics
@@ -27,8 +29,10 @@ import           System.Posix.Env.ByteString    ( getEnv
 import           System.Posix.Temp.ByteString   ( mkdtemp )
 
 import qualified Data.ByteString.UTF8          as UTF8
+import qualified Data.Text.Encoding            as E
 import qualified System.Posix.FilePath         as FP
 import qualified System.Posix.User             as PU
+import qualified Text.Megaparsec               as MP
 
 
 
@@ -37,6 +41,7 @@ import qualified System.Posix.User             as PU
     -------------------------
 
 
+-- | ~/.ghcup by default
 ghcupBaseDir :: IO (Path Abs)
 ghcupBaseDir = do
   bdir <- getEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
@@ -44,16 +49,30 @@ ghcupBaseDir = do
     Nothing -> liftIO getHomeDirectory
   pure (bdir </> [rel|.ghcup|])
 
+
+-- | ~/.ghcup/ghc by default.
 ghcupGHCBaseDir :: IO (Path Abs)
 ghcupGHCBaseDir = ghcupBaseDir <&> (</> [rel|ghc|])
 
-ghcupGHCDir :: Version -> IO (Path Abs)
+
+-- | Gets '~/.ghcup/ghc/<ghcupGHCDir>'.
+-- The dir may be of the form
+--   * armv7-unknown-linux-gnueabihf-8.8.3
+--   * 8.8.4
+ghcupGHCDir :: GHCTargetVersion -> IO (Path Abs)
 ghcupGHCDir ver = do
   ghcbasedir <- ghcupGHCBaseDir
-  verdir     <- parseRel (verToBS ver)
+  verdir     <- parseRel $ E.encodeUtf8 (prettyTVer ver)
   pure (ghcbasedir </> verdir)
 
 
+-- | See 'ghcupToolParser'.
+parseGHCupGHCDir :: MonadThrow m => Path Rel -> m GHCTargetVersion
+parseGHCupGHCDir (toFilePath -> f) = do
+  fp <- throwEither $ E.decodeUtf8' f
+  throwEither $ MP.parse ghcTargetVerP "" fp
+
+
 ghcupBinDir :: IO (Path Abs)
 ghcupBinDir = ghcupBaseDir <&> (</> [rel|bin|])
 

lib/GHCup/Utils/File.hs

@@ -18,6 +18,8 @@ import           Data.Foldable
 import           Data.Functor
 import           Data.IORef
 import           Data.Maybe
+import           Data.Text                      ( Text )
+import           Data.Void
 import           GHC.Foreign                    ( peekCStringLen )
 import           GHC.IO.Encoding                ( getLocaleEncoding )
 import           GHC.IO.Exception
@@ -39,10 +41,12 @@ import "unix"    System.Posix.IO.ByteString
                                          hiding ( openFd )
 import           System.Posix.Process           ( ProcessStatus(..) )
 import           System.Posix.Types
+import           Text.Regex.Posix
 
 
 import qualified Control.Exception             as EX
 import qualified Data.Text                     as T
+import qualified Data.Text.Encoding            as E
 import qualified System.Posix.Process.ByteString
                                                as SPPB
 import           Streamly.External.Posix.DirStream
@@ -51,12 +55,14 @@ import qualified Streamly.Internal.Memory.ArrayStream
 import qualified Streamly.FileSystem.Handle    as FH
 import qualified Streamly.Internal.Data.Unfold as SU
 import qualified Streamly.Prelude              as S
+import qualified Text.Megaparsec               as MP
 import qualified Data.ByteString               as BS
 import qualified Data.ByteString.Lazy          as L
 import qualified "unix-bytestring" System.Posix.IO.ByteString
                                                as SPIB
 
 
+
 -- | Bool signals whether the regions should be cleaned.
 data StopThread = StopThread Bool
   deriving Show
@@ -199,6 +205,7 @@ execLogged exe spath args lfile chdir env = do
     lineAction ref rs bs' = do
       modifyIORef' ref (swapRegs bs')
       regs <- readIORef ref
+      void $ SPIB.fdWrite fileFd (bs' <> "\n")
       forM (zip regs rs) $ \(bs, r) -> do
         setConsoleRegion r $ do
           w <- consoleWidth
@@ -210,8 +217,6 @@ execLogged exe spath args lfile chdir env = do
             . trim w
             . (\b -> "[ " <> toFilePath lfile <> " ] " <> b)
             $ bs
-        SPIB.fdWrite fileFd (bs <> "\n")
-
 
     swapRegs bs regs | length regs < size = regs ++ [bs]
                      | otherwise          = tail regs ++ [bs]
@@ -380,3 +385,27 @@ searchPath paths needle = go paths
     if p == toFilePath needle
       then isExecutable (basedir </> needle)
       else pure False
+
+
+findFiles :: Path Abs -> Regex -> IO [Path Rel]
+findFiles path regex = do
+  dirStream <- openDirStream (toFilePath path)
+  f         <-
+    (fmap . fmap) snd
+    . S.toList
+    . S.filter (\(_, p) -> match regex p)
+    $ dirContentsStream dirStream
+  pure $ join $ fmap parseRel f
+
+
+findFiles' :: Path Abs -> MP.Parsec Void Text () -> IO [Path Rel]
+findFiles' path parser = do
+  dirStream <- openDirStream (toFilePath path)
+  f         <-
+    (fmap . fmap) snd
+    . S.toList
+    . S.filter (\(_, p) -> case E.decodeUtf8' p of
+                             Left _ -> False
+                             Right p' -> isJust $ MP.parseMaybe parser p')
+    $ dirContentsStream dirStream
+  pure $ join $ fmap parseRel f

lib/GHCup/Utils/MegaParsec.hs

@@ -0,0 +1,87 @@
+{-# LANGUAGE CPP                  #-}
+{-# LANGUAGE OverloadedStrings    #-}
+
+module GHCup.Utils.MegaParsec where
+
+import           GHCup.Types
+
+import           Control.Applicative
+import           Control.Monad
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Data.Functor
+import           Data.Maybe
+import           Data.Text                      ( Text )
+import           Data.Versions
+import           Data.Void
+
+import qualified Data.Text                     as T
+import qualified Text.Megaparsec               as MP
+
+
+choice' :: (MonadFail f, MP.MonadParsec e s f) => [f a] -> f a
+choice' []       = fail "Empty list"
+choice' [x     ] = x
+choice' (x : xs) = MP.try x <|> choice' xs
+
+
+parseUntil :: MP.Parsec Void Text a -> MP.Parsec Void Text Text
+parseUntil p = do
+  (MP.try (MP.lookAhead p) $> mempty)
+    <|> (do
+          c  <- T.singleton <$> MP.anySingle
+          c2 <- parseUntil p
+          pure (c `mappend` c2)
+        )
+
+parseUntil1 :: MP.Parsec Void Text a -> MP.Parsec Void Text Text
+parseUntil1 p = do
+  i1 <- MP.getOffset
+  t <- parseUntil p
+  i2 <- MP.getOffset
+  if i1 == i2 then fail "empty parse" else pure t
+
+
+
+-- | Parses e.g.
+--   * armv7-unknown-linux-gnueabihf-ghc
+--   * armv7-unknown-linux-gnueabihf-ghci
+ghcTargetBinP :: Text -> MP.Parsec Void Text (Maybe Text, Text)
+ghcTargetBinP t =
+  (,)
+    <$> (   MP.try
+            (Just <$> (parseUntil1 (MP.chunk "-" *> MP.chunk t)) <* MP.chunk "-"
+            )
+        <|> (flip const Nothing <$> mempty)
+        )
+    <*> (MP.chunk t <* MP.eof)
+
+
+-- | Extracts target triple and version from e.g.
+--   * armv7-unknown-linux-gnueabihf-8.8.3
+--   * armv7-unknown-linux-gnueabihf-8.8.3
+ghcTargetVerP :: MP.Parsec Void Text GHCTargetVersion
+ghcTargetVerP =
+  (\x y -> GHCTargetVersion x y)
+    <$> (MP.try (Just <$> (parseUntil1 (MP.chunk "-" *> verP)) <* MP.chunk "-")
+        <|> (flip const Nothing <$> mempty)
+        )
+    <*> (version' <* MP.eof)
+ where
+  verP :: MP.Parsec Void Text Text
+  verP = do
+    v <- version'
+    let startsWithDigists =
+          and
+            . take 3
+            . join
+            . (fmap . fmap)
+                (\case
+                  (Digits _) -> True
+                  (Str    _) -> False
+                )
+            $ (_vChunks v)
+    if startsWithDigists && not (isJust (_vEpoch v))
+      then pure $ prettyVer v
+      else fail "Oh"

lib/GHCup/Utils/Prelude.hs

@@ -218,6 +218,12 @@ throwEither a = case a of
   Right r -> pure r
 
 
+throwEither' :: (Exception a, MonadThrow m) => a -> Either x b -> m b
+throwEither' e eth = case eth of
+  Left  _ -> throwM e
+  Right r -> pure r
+
+
 verToBS :: Version -> ByteString
 verToBS = E.encodeUtf8 . prettyVer
 

lib/GHCup/Version.hs

@@ -13,7 +13,7 @@ import qualified Data.Text                     as T
 
 -- | This reflects the API version of the JSON.
 ghcupURL :: URI
-ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.1.json|]
+ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.2.json|]
 
 ghcUpVer :: PVP
 ghcUpVer = [pver|0.1.4|]