diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,20 @@ # Changelog for the [`clash-ghc`](http://hackage.haskell.org/package/clash-ghc) package -## 0.7.2 *April 25th 2017* +## 0.99 *March 31st 2018* +* New features: + * Support for `clash-prelude-0.99`: + * Explicit clock and reset arguments + * Overhaul of `TopEntity` annotations + * Hierarchies with multiple synthesisable boundaries by allowing more than one + function in scope to have a `Synthesize` annotation. + * Local caching of functions with a `Synthesize` annotation + * `Bit` type is mapped to a HDL scalar type (e.g. `std_logic` in VHDL) + * Improved name preservation + * Zero-bit values are filtered out of the generated HDL + * Improved compile-time computation +* Many bug fixes + +## 0.7.2 * New features: * Sum-of-product types: unused bits now "don't-care" [#212](https://github.com/clash-lang/clash-compiler/commit/fabf745793491ce3baf84ef0066b4ccf0753d503) * Fixes bugs: diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,5 +1,6 @@ Copyright (c) 2012-2016, University of Twente, - 2017, QBayLogic + 2016-2017, Myrtle Software Ltd, + 2017 , QBayLogic, Google Inc. All rights reserved. Redistribution and use in source and binary forms, with or without diff --git a/cbits/PosixSource.h b/cbits/PosixSource.h --- a/cbits/PosixSource.h +++ b/cbits/PosixSource.h @@ -11,32 +11,44 @@ #include -#if defined(freebsd_HOST_OS) || defined(dragonfly_HOST_OS) +/* We aim for C99 so we need to define following two defines in a consistent way + with what POSIX/XOPEN provide for C99. Some OSes are particularly picky about + the right versions defined here, e.g. Solaris + We also settle on lowest version of POSIX/XOPEN needed for proper C99 support + here which is POSIX.1-2001 compilation and Open Group Technical Standard, + Issue 6 (XPG6). XPG6 itself is a result of the merge of X/Open and POSIX + specification. It is also referred as IEEE Std. 1003.1-2001 or ISO/IEC + 9945:2002 or UNIX 03 and SUSv3. + Please also see trac ticket #11757 for more information about switch + to C99/C11. + + However, the use of `strnlen`, which is strictly speaking only available in + IEEE Std 1003.1-2008 (XPG7), requires lifting the bounds, to be able to + compile ghc on systems that are strict about enforcing the standard, e.g. + Apples mobile platforms. + + Oracle's Solaris 11 supports only up to XPG6, hence the ifdef. + */ + +#if defined(solaris2_HOST_OS) #define _POSIX_C_SOURCE 200112L #define _XOPEN_SOURCE 600 #else -#define _POSIX_SOURCE 1 -#define _POSIX_C_SOURCE 199506L -#define _XOPEN_SOURCE 500 -// FreeBSD takes a different approach to _ISOC99_SOURCE: on FreeBSD it -// means "I want *just* C99 things", whereas on GNU libc and Solaris -// it means "I also want C99 things". -// -// On both GNU libc and FreeBSD, _ISOC99_SOURCE is implied by -// _XOPEN_SOURCE==600, but on Solaris it is an error to omit it. -#define _ISOC99_SOURCE -// Defining __USE_MINGW_ANSI_STDIO is the most portable way to tell -// mingw that we want to use the standard %lld style format specifiers, -// rather than the Windows %I64d style -#define __USE_MINGW_ANSI_STDIO 1 +#define _POSIX_C_SOURCE 200809L +#define _XOPEN_SOURCE 700 #endif -#if defined(darwin_HOST_OS) -/* If we don't define this the including sysctl breaks with things like - /usr/include/bsm/audit.h:224:0: - error: syntax error before 'u_char' -*/ -#define _DARWIN_C_SOURCE 1 +#if defined(mingw32_HOST_OS) +/* Without this gcc will warn about %ull and the like since some msvcrt versions + do not support them. See + https://sourceforge.net/p/mingw-w64/mailman/message/28557333/ + + Note that this is implied by _POSIX_C_SOURCE in the msys2 toolchain that we + now use. However, we retain this explicit #define to preserve the ability to + bootstrap GHC with compilers still using msys (e.g. GHC 7.10.1 and 7.10.2). + This can be removed in for GHC 8.4. See #12951. + */ +#define __USE_MINGW_ANSI_STDIO 1 #endif #endif /* POSIXSOURCE_H */ diff --git a/cbits/hschooks.c b/cbits/hschooks.c --- a/cbits/hschooks.c +++ b/cbits/hschooks.c @@ -5,11 +5,18 @@ */ #include "PosixSource.h" + +/* + * This should be linked against Rts.h from the compiler which is compiling us. + * For instance, if we are compiling this file to produce the stage1 compiler, + * we should use Rts.h from stage0. + */ #include "Rts.h" #include "HsFFI.h" #include +#include #ifdef HAVE_UNISTD_H #include @@ -33,7 +40,7 @@ // This helps particularly with large compiles, but didn't work // very well with earlier GHCs because it caused large amounts of // fragmentation. See rts/sm/BlockAlloc.c:allocLargeChunk(). - RtsFlags.GcFlags.heapSizeSuggestionAuto = rtsTrue; + RtsFlags.GcFlags.heapSizeSuggestionAuto = true; RtsFlags.GcFlags.maxStkSize = 512*1024*1024 / sizeof(W_); @@ -47,6 +54,8 @@ void StackOverflowHook (StgWord stack_size) /* in bytes */ { - fprintf(stderr, "GHC stack-space overflow: current limit is %zu bytes.\nUse the `-K' option to increase it.\n", (size_t)stack_size); + fprintf(stderr, + "GHC stack-space overflow: current limit is %zu bytes.\n" + "Use the `-K' option to increase it.\n", + (size_t) stack_size); } - diff --git a/clash-ghc.cabal b/clash-ghc.cabal --- a/clash-ghc.cabal +++ b/clash-ghc.cabal @@ -1,5 +1,5 @@ Name: clash-ghc -Version: 0.7.2 +Version: 0.99 Synopsis: CAES Language for Synchronous Hardware Description: CλaSH (pronounced ‘clash’) is a functional hardware description language that @@ -36,16 +36,18 @@ License-file: LICENSE Author: Christiaan Baaij Maintainer: Christiaan Baaij -Copyright: Copyright © 2012-2016, University of Twente, 2017 QBayLogic +Copyright: Copyright © 2012-2016, University of Twente, + 2016-2017, Myrtle Software Ltd, + 2017 , QBayLogic, Google Inc. Category: Hardware Build-type: Simple Extra-source-files: README.md, CHANGELOG.md, LICENSE_GHC, - cbits/PosixSource.h, - src-bin/CLaSH/GHCi/HsVersions.h + src-bin/Clash/GHCi/HsVersions.h + src-bin-841/Clash/GHCi/HsVersions.h Cabal-version: >=1.10 @@ -54,21 +56,25 @@ location: https://github.com/clash-lang/clash-compiler.git executable clash - default-language: Haskell2010 Main-Is: src-ghc/Batch.hs Build-Depends: base, clash-ghc - GHC-Options: -Wall + GHC-Options: -Wall -dynamic + extra-libraries: pthread default-language: Haskell2010 executable clashi - default-language: Haskell2010 Main-Is: src-ghc/Interactive.hs Build-Depends: base, clash-ghc - GHC-Options: -Wall + GHC-Options: -Wall -dynamic + extra-libraries: pthread default-language: Haskell2010 library - HS-Source-Dirs: src-ghc src-bin + HS-Source-Dirs: src-ghc + if impl(ghc >= 8.4.1) + HS-Source-Dirs: src-bin-841 + else + HS-Source-Dirs: src-bin default-language: Haskell2010 GHC-Options: -Wall -fno-warn-name-shadowing @@ -91,36 +97,36 @@ Build-Depends: array >= 0.4 && < 0.6, base >= 4.3.1.0 && < 5, - bifunctors >= 4.1.1 && < 5.5, + bifunctors >= 4.1.1 && < 5.6, bytestring >= 0.9 && < 0.11, containers >= 0.5.4.0 && < 0.6, directory >= 1.2 && < 1.4, filepath >= 1.3 && < 1.5, - ghc >= 8.0.1 && < 8.2, + ghc >= 8.2.0 && < 8.6, process >= 1.2 && < 1.7, hashable >= 1.1.2.3 && < 1.3, haskeline >= 0.7.0.3 && < 0.8, - lens >= 4.0.5 && < 4.16, + lens >= 4.0.5 && < 4.17, mtl >= 2.1.1 && < 2.3, text >= 0.11.3.1 && < 1.3, transformers >= 0.4.2 && < 0.6, unbound-generics >= 0.1 && < 0.4, unordered-containers >= 0.2.1.0 && < 0.3, - clash-lib >= 0.7.1 && < 0.8, - clash-systemverilog >= 0.7.2 && < 0.8, - clash-vhdl >= 0.7.2 && < 0.8, - clash-verilog >= 0.7.2 && < 0.8, - clash-prelude >= 0.11.2 && < 0.12, + clash-lib >= 0.7.1 && < 1.0, + clash-prelude >= 0.11.2 && < 1.0, + concurrent-supply >= 0.1.7 && < 0.2, ghc-typelits-extra >= 0.1.3 && < 0.3, - ghc-typelits-knownnat >= 0.1.2 && < 0.3, + ghc-typelits-knownnat >= 0.1.2 && < 0.5, ghc-typelits-natnormalise >= 0.4.3 && < 0.6, deepseq >= 1.3.0.2 && < 1.5, - time >= 1.4.0.1 && < 1.9, - ghc-boot >= 8.0.1 && < 8.2, - ghci >= 8.0.1 && < 8.2, - uniplate >= 1.6.12 && < 1.8 + ghc-boot >= 8.0.2 && < 8.6, + ghc-prim >= 0.3.1.0 && < 0.6, + ghci >= 8.2.0 && < 8.6, + uniplate >= 1.6.12 && < 1.8, + reflection >= 2.1.2 && < 3.0, + integer-gmp >= 1.0.1.0 && < 2.0 if os(windows) Build-Depends: Win32 >= 2.3.1 && < 2.6 @@ -130,17 +136,17 @@ Include-dirs: cbits C-Sources: cbits/hschooks.c - Exposed-Modules: CLaSH.Main - Other-Modules: CLaSH.GHCi.UI - CLaSH.GHCi.UI.Info - CLaSH.GHCi.UI.Monad - CLaSH.GHCi.UI.Tags + Exposed-Modules: Clash.Main + Other-Modules: Clash.GHCi.UI + Clash.GHCi.UI.Info + Clash.GHCi.UI.Monad + Clash.GHCi.UI.Tags - CLaSH.GHC.CLaSHFlags - CLaSH.GHC.Evaluator - CLaSH.GHC.GenerateBindings - CLaSH.GHC.GHC2Core - CLaSH.GHC.LoadInterfaceFiles - CLaSH.GHC.LoadModules - CLaSH.GHC.NetlistTypes + Clash.GHC.ClashFlags + Clash.GHC.Evaluator + Clash.GHC.GenerateBindings + Clash.GHC.GHC2Core + Clash.GHC.LoadInterfaceFiles + Clash.GHC.LoadModules + Clash.GHC.NetlistTypes Paths_clash_ghc diff --git a/src-bin-841/Clash/GHCi/HsVersions.h b/src-bin-841/Clash/GHCi/HsVersions.h new file mode 100644 --- /dev/null +++ b/src-bin-841/Clash/GHCi/HsVersions.h @@ -0,0 +1,65 @@ +#pragma once + +#if 0 + +IMPORTANT! If you put extra tabs/spaces in these macro definitions, +you will screw up the layout where they are used in case expressions! + +(This is cpp-dependent, of course) + +#endif + +/* Useful in the headers that we share with the RTS */ +#define COMPILING_GHC 1 + +/* Pull in all the platform defines for this build (foo_TARGET_ARCH etc.) */ +/* #include "ghc_boot_platform.h" */ + +/* Pull in the autoconf defines (HAVE_FOO), but don't include + * ghcconfig.h, because that will include ghcplatform.h which has the + * wrong platform settings for the compiler (it has the platform + * settings for the target plat instead). */ +/* #include "ghcautoconf.h" */ + +#define GLOBAL_VAR(name,value,ty) \ +{-# NOINLINE name #-}; \ +name :: IORef (ty); \ +name = Util.global (value); + +#define GLOBAL_VAR_M(name,value,ty) \ +{-# NOINLINE name #-}; \ +name :: IORef (ty); \ +name = Util.globalM (value); + + +#define SHARED_GLOBAL_VAR(name,accessor,saccessor,value,ty) \ +{-# NOINLINE name #-}; \ +name :: IORef (ty); \ +name = Util.sharedGlobal (value) (accessor); \ +foreign import ccall unsafe saccessor \ + accessor :: Ptr (IORef a) -> IO (Ptr (IORef a)); + +#define SHARED_GLOBAL_VAR_M(name,accessor,saccessor,value,ty) \ +{-# NOINLINE name #-}; \ +name :: IORef (ty); \ +name = Util.sharedGlobalM (value) (accessor); \ +foreign import ccall unsafe saccessor \ + accessor :: Ptr (IORef a) -> IO (Ptr (IORef a)); + + +#define ASSERT(e) if debugIsOn && not (e) then (assertPanic __FILE__ __LINE__) else +#define ASSERT2(e,msg) if debugIsOn && not (e) then (assertPprPanic __FILE__ __LINE__ (msg)) else +#define WARN( e, msg ) (warnPprTrace (e) __FILE__ __LINE__ (msg)) $ + +-- Examples: Assuming flagSet :: String -> m Bool +-- +-- do { c <- getChar; MASSERT( isUpper c ); ... } +-- do { c <- getChar; MASSERT2( isUpper c, text "Bad" ); ... } +-- do { str <- getStr; ASSERTM( flagSet str ); .. } +-- do { str <- getStr; ASSERTM2( flagSet str, text "Bad" ); .. } +-- do { str <- getStr; WARNM2( flagSet str, text "Flag is set" ); .. } +#define MASSERT(e) ASSERT(e) return () +#define MASSERT2(e,msg) ASSERT2(e,msg) return () +#define ASSERTM(e) do { bool <- e; MASSERT(bool) } +#define ASSERTM2(e,msg) do { bool <- e; MASSERT2(bool,msg) } +#define WARNM2(e,msg) do { bool <- e; WARN(bool, msg) return () } diff --git a/src-bin-841/Clash/GHCi/UI.hs b/src-bin-841/Clash/GHCi/UI.hs new file mode 100644 --- /dev/null +++ b/src-bin-841/Clash/GHCi/UI.hs @@ -0,0 +1,3901 @@ +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE CPP #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE MagicHash #-} +{-# LANGUAGE MultiWayIf #-} +{-# LANGUAGE NondecreasingIndentation #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE TupleSections #-} +{-# LANGUAGE ViewPatterns #-} + +{-# OPTIONS -fno-cse #-} +-- -fno-cse is needed for GLOBAL_VAR's to behave properly + +----------------------------------------------------------------------------- +-- +-- GHC Interactive User Interface +-- +-- (c) The GHC Team 2005-2006 +-- +----------------------------------------------------------------------------- + +module Clash.GHCi.UI ( + interactiveUI, + GhciSettings(..), + defaultGhciSettings, + ghciCommands, + ghciWelcomeMsg, + makeHDL + ) where + +#include "HsVersions.h" + +-- GHCi +import qualified Clash.GHCi.UI.Monad as GhciMonad ( args, runStmt, runDecls ) +import Clash.GHCi.UI.Monad hiding ( args, runStmt, runDecls ) +import Clash.GHCi.UI.Tags +import Clash.GHCi.UI.Info +import Debugger + +-- The GHC interface +import GHCi +import GHCi.RemoteTypes +import GHCi.BreakArray +import DynFlags +import ErrUtils hiding (traceCmd) +import Finder +import GhcMonad ( modifySession ) +import qualified GHC +import GHC ( LoadHowMuch(..), Target(..), TargetId(..), InteractiveImport(..), + TyThing(..), Phase, BreakIndex, Resume, SingleStep, Ghc, + getModuleGraph, handleSourceError ) +import HsImpExp +import HsSyn +import HscTypes ( tyThingParent_maybe, handleFlagWarnings, getSafeMode, hsc_IC, + setInteractivePrintName, hsc_dflags, msObjFilePath ) +import Module +import Name +import Packages ( trusted, getPackageDetails, getInstalledPackageDetails, + listVisibleModuleNames, pprFlag ) +import IfaceSyn ( showToHeader ) +import PprTyThing +import PrelNames +import RdrName ( getGRE_NameQualifier_maybes, getRdrName ) +import SrcLoc +import qualified Lexer + +import StringBuffer +import Outputable hiding ( printForUser, printForUserPartWay ) + +-- Other random utilities +import BasicTypes hiding ( isTopLevel ) +import Digraph +import Encoding +import FastString +import Linker +import Maybes ( orElse, expectJust ) +import NameSet +import Panic hiding ( showException ) +import Util +import qualified GHC.LanguageExtensions as LangExt + +-- Haskell Libraries +import System.Console.Haskeline as Haskeline + +import Control.Applicative hiding (empty) +import Control.DeepSeq (deepseq) +import Control.Monad as Monad +import Control.Monad.IO.Class +import Control.Monad.Trans.Class +import Control.Monad.Trans.Except + +import Data.Array +import qualified Data.ByteString.Char8 as BS +import Data.Char +import Data.Function +import Data.IORef ( IORef, modifyIORef, newIORef, readIORef, writeIORef ) +import Data.List ( find, group, intercalate, intersperse, isPrefixOf, nub, + partition, sort, sortBy ) +import qualified Data.Set as S +import Data.Maybe +import qualified Data.Map as M +import Data.Time.LocalTime ( getZonedTime ) +import Data.Time.Format ( formatTime, defaultTimeLocale ) +import Data.Version ( showVersion ) +import Prelude hiding ((<>)) + +import Exception hiding (catch) +import Foreign hiding (void) +import GHC.Stack hiding (SrcLoc(..)) + +import System.Directory +import System.Environment +import System.Exit ( exitWith, ExitCode(..) ) +import System.FilePath +import System.Info +import System.IO +import System.IO.Error +import System.IO.Unsafe ( unsafePerformIO ) +import System.Process +import Text.Printf +import Text.Read ( readMaybe ) +import Text.Read.Lex (isSymbolChar) + +import Unsafe.Coerce + +#if !defined(mingw32_HOST_OS) +import System.Posix hiding ( getEnv ) +#else +import qualified System.Win32 +#endif + +import GHC.IO.Exception ( IOErrorType(InvalidArgument) ) +import GHC.IO.Handle ( hFlushAll ) +import GHC.TopHandler ( topHandler ) + +-- clash additions +import qualified Clash.Backend +import Clash.Backend.SystemVerilog (SystemVerilogState) +import Clash.Backend.VHDL (VHDLState) +import Clash.Backend.Verilog (VerilogState) +import qualified Clash.Driver +import Clash.Driver.Types (ClashOpts(..)) +import Clash.GHC.Evaluator +import Clash.GHC.GenerateBindings +import Clash.GHC.NetlistTypes +import Clash.Netlist.BlackBox.Types (HdlSyn) +import Clash.Util (clashLibVersion) +import qualified Data.Time.Clock as Clock +import qualified Paths_clash_ghc + +----------------------------------------------------------------------------- + +data GhciSettings = GhciSettings { + availableCommands :: [Command], + shortHelpText :: String, + fullHelpText :: String, + defPrompt :: PromptFunction, + defPromptCont :: PromptFunction + } + +defaultGhciSettings :: IORef ClashOpts -> GhciSettings +defaultGhciSettings opts = + GhciSettings { + availableCommands = ghciCommands opts, + shortHelpText = defShortHelpText, + defPrompt = default_prompt, + defPromptCont = default_prompt_cont, + fullHelpText = defFullHelpText + } + +ghciWelcomeMsg :: String +ghciWelcomeMsg = "CLaSHi, version " ++ Data.Version.showVersion Paths_clash_ghc.version ++ + " (using clash-lib, version " ++ Data.Version.showVersion clashLibVersion ++ + "):\nhttp://www.clash-lang.org/ :? for help" + +ghciCommands :: IORef ClashOpts -> [Command] +ghciCommands opts = map mkCmd [ + -- Hugs users are accustomed to :e, so make sure it doesn't overlap + ("?", keepGoing help, noCompletion), + ("add", keepGoingPaths addModule, completeFilename), + ("abandon", keepGoing abandonCmd, noCompletion), + ("break", keepGoing breakCmd, completeIdentifier), + ("back", keepGoing backCmd, noCompletion), + ("browse", keepGoing' (browseCmd False), completeModule), + ("browse!", keepGoing' (browseCmd True), completeModule), + ("cd", keepGoing' changeDirectory, completeFilename), + ("check", keepGoing' checkModule, completeHomeModule), + ("continue", keepGoing continueCmd, noCompletion), + ("cmd", keepGoing cmdCmd, completeExpression), + ("ctags", keepGoing createCTagsWithLineNumbersCmd, completeFilename), + ("ctags!", keepGoing createCTagsWithRegExesCmd, completeFilename), + ("def", keepGoing (defineMacro False), completeExpression), + ("def!", keepGoing (defineMacro True), completeExpression), + ("delete", keepGoing deleteCmd, noCompletion), + ("edit", keepGoing' editFile, completeFilename), + ("etags", keepGoing createETagsFileCmd, completeFilename), + ("force", keepGoing forceCmd, completeExpression), + ("forward", keepGoing forwardCmd, noCompletion), + ("help", keepGoing help, noCompletion), + ("history", keepGoing historyCmd, noCompletion), + ("info", keepGoing' (info False), completeIdentifier), + ("info!", keepGoing' (info True), completeIdentifier), + ("issafe", keepGoing' isSafeCmd, completeModule), + ("kind", keepGoing' (kindOfType False), completeIdentifier), + ("kind!", keepGoing' (kindOfType True), completeIdentifier), + ("load", keepGoingPaths loadModule_, completeHomeModuleOrFile), + ("load!", keepGoingPaths loadModuleDefer, completeHomeModuleOrFile), + ("list", keepGoing' listCmd, noCompletion), + ("module", keepGoing moduleCmd, completeSetModule), + ("main", keepGoing runMain, completeFilename), + ("print", keepGoing printCmd, completeExpression), + ("quit", quit, noCompletion), + ("reload", keepGoing' reloadModule, noCompletion), + ("reload!", keepGoing' reloadModuleDefer, noCompletion), + ("run", keepGoing runRun, completeFilename), + ("script", keepGoing' scriptCmd, completeFilename), + ("set", keepGoing setCmd, completeSetOptions), + ("seti", keepGoing setiCmd, completeSeti), + ("show", keepGoing showCmd, completeShowOptions), + ("showi", keepGoing showiCmd, completeShowiOptions), + ("sprint", keepGoing sprintCmd, completeExpression), + ("step", keepGoing stepCmd, completeIdentifier), + ("steplocal", keepGoing stepLocalCmd, completeIdentifier), + ("stepmodule",keepGoing stepModuleCmd, completeIdentifier), + ("type", keepGoing' typeOfExpr, completeExpression), + ("trace", keepGoing traceCmd, completeExpression), + ("unadd", keepGoingPaths unAddModule, completeFilename), + ("undef", keepGoing undefineMacro, completeMacro), + ("unset", keepGoing unsetOptions, completeSetOptions), + ("where", keepGoing whereCmd, noCompletion), + ("vhdl", keepGoingPaths (makeVHDL opts), completeHomeModuleOrFile), + ("verilog", keepGoingPaths (makeVerilog opts), completeHomeModuleOrFile), + ("systemverilog", keepGoingPaths (makeSystemVerilog opts), completeHomeModuleOrFile) + ] ++ map mkCmdHidden [ -- hidden commands + ("all-types", keepGoing' allTypesCmd), + ("complete", keepGoing completeCmd), + ("loc-at", keepGoing' locAtCmd), + ("type-at", keepGoing' typeAtCmd), + ("uses", keepGoing' usesCmd) + ] + where + mkCmd (n,a,c) = Command { cmdName = n + , cmdAction = a + , cmdHidden = False + , cmdCompletionFunc = c + } + + mkCmdHidden (n,a) = Command { cmdName = n + , cmdAction = a + , cmdHidden = True + , cmdCompletionFunc = noCompletion + } + +-- We initialize readline (in the interactiveUI function) to use +-- word_break_chars as the default set of completion word break characters. +-- This can be overridden for a particular command (for example, filename +-- expansion shouldn't consider '/' to be a word break) by setting the third +-- entry in the Command tuple above. +-- +-- NOTE: in order for us to override the default correctly, any custom entry +-- must be a SUBSET of word_break_chars. +word_break_chars :: String +word_break_chars = spaces ++ specials ++ symbols + +symbols, specials, spaces :: String +symbols = "!#$%&*+/<=>?@\\^|-~" +specials = "(),;[]`{}" +spaces = " \t\n" + +flagWordBreakChars :: String +flagWordBreakChars = " \t\n" + + +keepGoing :: (String -> GHCi ()) -> (String -> InputT GHCi Bool) +keepGoing a str = keepGoing' (lift . a) str + +keepGoing' :: Monad m => (String -> m ()) -> String -> m Bool +keepGoing' a str = a str >> return False + +keepGoingPaths :: ([FilePath] -> InputT GHCi ()) -> (String -> InputT GHCi Bool) +keepGoingPaths a str + = do case toArgs str of + Left err -> liftIO $ hPutStrLn stderr err + Right args -> a args + return False + +defShortHelpText :: String +defShortHelpText = "use :? for help.\n" + +defFullHelpText :: String +defFullHelpText = + " Commands available from the prompt:\n" ++ + "\n" ++ + " evaluate/run \n" ++ + " : repeat last command\n" ++ + " :{\\n ..lines.. \\n:}\\n multiline command\n" ++ + " :add [*] ... add module(s) to the current target set\n" ++ + " :browse[!] [[*]] display the names defined by module \n" ++ + " (!: more details; *: all top-level names)\n" ++ + " :cd change directory to \n" ++ + " :cmd run the commands returned by ::IO String\n" ++ + " :complete [] list completions for partial input string\n" ++ + " :ctags[!] [] create tags file for Vi (default: \"tags\")\n" ++ + " (!: use regex instead of line number)\n" ++ + " :def define command : (later defined command has\n" ++ + " precedence, :: is always a builtin command)\n" ++ + " :edit edit file\n" ++ + " :edit edit last module\n" ++ + " :etags [] create tags file for Emacs (default: \"TAGS\")\n" ++ + " :help, :? display this list of commands\n" ++ + " :info[!] [ ...] display information about the given names\n" ++ + " (!: do not filter instances)\n" ++ + " :issafe [] display safe haskell information of module \n" ++ + " :kind[!] show the kind of \n" ++ + " (!: also print the normalised type)\n" ++ + " :load[!] [*] ... load module(s) and their dependents\n" ++ + " (!: defer type errors)\n" ++ + " :main [ ...] run the main function with the given arguments\n" ++ + " :module [+/-] [*] ... set the context for expression evaluation\n" ++ + " :quit exit GHCi\n" ++ + " :reload[!] reload the current module set\n" ++ + " (!: defer type errors)\n" ++ + " :run function [ ...] run the function with the given arguments\n" ++ + " :script run the script \n" ++ + " :type show the type of \n" ++ + " :type +d show the type of , defaulting type variables\n" ++ + " :type +v show the type of , with its specified tyvars\n" ++ + " :unadd ... remove module(s) from the current target set\n" ++ + " :undef undefine user-defined command :\n" ++ + " :! run the shell command \n" ++ + " :vhdl synthesize currently loaded module to vhdl\n" ++ + " :vhdl [] synthesize specified modules/files to vhdl\n" ++ + " :verilog synthesize currently loaded module to verilog\n" ++ + " :verilog [] synthesize specified modules/files to verilog\n" ++ + " :systemverilog synthesize currently loaded module to systemverilog\n" ++ + " :systemverilog [] synthesize specified modules/files to systemverilog\n" ++ + "\n" ++ + " -- Commands for debugging:\n" ++ + "\n" ++ + " :abandon at a breakpoint, abandon current computation\n" ++ + " :back [] go back in the history N steps (after :trace)\n" ++ + " :break [] [] set a breakpoint at the specified location\n" ++ + " :break set a breakpoint on the specified function\n" ++ + " :continue resume after a breakpoint\n" ++ + " :delete delete the specified breakpoint\n" ++ + " :delete * delete all breakpoints\n" ++ + " :force print , forcing unevaluated parts\n" ++ + " :forward [] go forward in the history N step s(after :back)\n" ++ + " :history [] after :trace, show the execution history\n" ++ + " :list show the source code around current breakpoint\n" ++ + " :list show the source code for \n" ++ + " :list [] show the source code around line number \n" ++ + " :print [ ...] show a value without forcing its computation\n" ++ + " :sprint [ ...] simplified version of :print\n" ++ + " :step single-step after stopping at a breakpoint\n"++ + " :step single-step into \n"++ + " :steplocal single-step within the current top-level binding\n"++ + " :stepmodule single-step restricted to the current module\n"++ + " :trace trace after stopping at a breakpoint\n"++ + " :trace evaluate with tracing on (see :history)\n"++ + + "\n" ++ + " -- Commands for changing settings:\n" ++ + "\n" ++ + " :set