- jhc - Haskell.org

darcs patch: Support concurrent (and 2 more)
by kiwamu＠debian.or.jp 05 Nov '13

05 Nov '13

3 patches for repository http://repetae.net/repos/jhc: Tue Nov 5 17:40:09 JST 2013 kiwamu(a)debian.or.jp * Support concurrent The long patch to support concurrent. The concurrent mean concurrent GC, forkOS, running some context same time. The patch chooses some thread type, -fnothread or -fpthread or -fcustomthread. Default is -fpthread. If choose -fcustomthread, you should implement thread backend on application side. Tue Nov 5 17:55:08 JST 2013 kiwamu(a)debian.or.jp * Pass rts/test with concurrent Tue Nov 5 17:56:39 JST 2013 kiwamu(a)debian.or.jp * Selftest with Test.Framework.TH

1 0

ANNOUNCE: Ajhc Haskell Compiler 0.8.0.9 Release
by Kiwamu Okabe 26 Oct '13

26 Oct '13

We are happy to announce Ajhc 0.8.0.9. This version is a point release to fix some BUGs, and support Android NDK platform. You can get Ajhc using "cabal install ajhc" command. The usage is found at Ajhc's project web site http://ajhc.metasepi.org/. The source code at https://github.com/ajhc/ajhc. Welcome sending any bugs or your ideas to https://github.com/ajhc/ajhc/issues. ## Support new platforms ### Android NDK http://developer.android.com/tools/sdk/ndk/index.html The demo movie at http://www.youtube.com/watch?v=n6cepTfnFoo. The touchable cube application is written with Haskell and compiled by Ajhc. In the demo, the application is breaked by ndk-gdb debugger when running GC. You could watch the demo source code at \url{https://github.com/ajhc/demo-android-ndk}. ## Other changes * Experimental support Mac OS X to compile Ajhc and use it. * Start to run buid test for Mac OS X on Travis CI. https://travis-ci.org/ajhc/ajhc/builds/12218394 * Depend on derive package. But near future use DrIFT again. For Haskell 98 compliant. https://github.com/ajhc/ajhc/issues/47 * Fix the bugs forgetting to clear memory. Enjoy! :) - - - Metasepi team

1 0

[BUG] A pointer used by program is sweeped by GC
by Kiwamu Okabe 15 Oct '13

15 Oct '13

Hi, jhc hackers. A team member, mzp, found following error while developing Ajhc. A pointer used by program is sweeped by GC · Issue #51 · ajhc/ajhc https://github.com/ajhc/ajhc/issues/51 I think the error occurs also on jhc. But I do not understand jgc's GC root policy, then can't fix it. Someone has any idea to fix it? Best regards, -- Kiwamu Okabe

1 0

Fwd: darcs patch: No use haskell98 (and 3 more)
by Kiwamu Okabe 24 Sep '13

24 Sep '13

Forwarding. ---------- Forwarded message ---------- From: <kiwamu(a)debian.or.jp> Date: Fri, Sep 13, 2013 at 5:09 PM Subject: darcs patch: No use haskell98 (and 3 more) To: Darcs Patch DrIFT <john(a)repetae.net> 4 patches for repository http://repetae.net/repos/DrIFT: Thu Mar 28 14:42:41 JST 2013 kiwamu(a)debian.or.jp * No use haskell98 Thu Mar 28 14:46:52 JST 2013 kiwamu(a)debian.or.jp * Cabalize DrIFT. Thu Mar 28 21:59:35 JST 2013 kiwamu(a)debian.or.jp * Build Haskell pacakge (cabal) with the command "make cabal-install". Fri Sep 13 17:08:13 JST 2013 kiwamu(a)debian.or.jp * Change haskell package name, version name as library to be depended by other package. [No use haskell98 kiwamu(a)debian.or.jp**20130328054241 Ignore-this: 76849fb71f3f26260434c8fcc5da7976 ] { hunk ./configure.ac 19 GHC=$HC GHCFLAGS= -GHC_CHECK_MODULE([System],[],[],[],[HCFLAGS="$HCFLAGS -hide-all-packages -package haskell98"]) +GHC_CHECK_MODULE([System.IO],[],[],[],[HCFLAGS="$HCFLAGS -hide-all-packages"]) AC_PROG_INSTALL AC_PATH_PROGS(SH, sh) hunk ./src/ChaseImports.hs 27 import DataP import CommandP import ParseLib2 -import System -import List +import System.Environment +import Data.List import qualified Unlit hunk ./src/ChaseImports.hs 30 -import Monad +import Control.Monad import GenUtil try x = catch (x >>= return . Right) (return . Left) hunk ./src/DataP.lhs 13 >where >import ParseLib2 ->import Char ->import List ->import Monad - +>import Data.Char +>import Data.List >data Statement = DataStmt | NewTypeStmt deriving (Eq,Show) >data Data = D { name :: Name, -- type name hunk ./src/DrIFT.hs 10 import DataP import GenUtil import GetOpt -import Char -import IO hiding(try) -import List (partition,isSuffixOf,sort, groupBy, sortBy) -import Monad(unless) +import Data.List (partition,isSuffixOf,sort, groupBy, sortBy) +import Control.Monad(unless) import PreludData(preludeData) import Pretty import RuleUtils (commentLine,texts) hunk ./src/DrIFT.hs 18 import RuleUtils(Rule,Tag) import Version import qualified Rules(rules) -import qualified System +import System.IO +import System.Environment +import Data.Char data Op = OpList | OpDerive | OpVersion hunk ./src/DrIFT.hs 81 header = "Usage: DrIFT [OPTION...] file" main = do - argv <- System.getArgs + argv <- getArgs (env,n) <- case (getOpt Permute options argv) of (as,n,[]) -> return (foldr ($) env as ,n) (_,_,errs) -> putErrDie (concat errs ++ usageInfo header options) hunk ./src/GenUtil.hs 42 -- ** Simple deconstruction fromLeft,fromRight,fsts,snds,splitEither,rights,lefts, -- ** System routines - exitSuccess, System.exitFailure, epoch, lookupEnv,endOfTime, + exitSuccess, exitFailure, epoch, lookupEnv,endOfTime, -- ** Random routines repMaybe, liftT2, liftT3, liftT4, hunk ./src/GenUtil.hs 94 UniqueProducer(..) ) where -import Char(isAlphaNum, isSpace, toLower, ord) -import List(group,sort) -import List(intersperse, sortBy, groupBy) -import Monad -import qualified IO -import qualified System -import Random(StdGen, newStdGen, Random(randomR)) -import Time +import System.Time +import System.IO +import System.IO.Error +import System.Exit(exitFailure, exitWith, ExitCode(..)) +import System.Environment +import Control.Monad(join, liftM, MonadPlus, mzero) +import System.Random(StdGen, newStdGen, Random(randomR)) +import Data.Char(isAlphaNum, isSpace, toLower, ord) +import Data.List(group,sort) +import Data.List(intersperse, sortBy, groupBy) +-- import Random(StdGen, newStdGen, Random(randomR)) {-# SPECIALIZE snub :: [String] -> [String] #-} {-# SPECIALIZE snub :: [Int] -> [Int] #-} hunk ./src/GenUtil.hs 133 -- | write string to standard error putErr :: String -> IO () -putErr = IO.hPutStr IO.stderr +putErr = System.IO.hPutStr System.IO.stderr -- | write string and newline to standard error putErrLn :: String -> IO () hunk ./src/GenUtil.hs 143 -- | write string and newline to standard error, -- then exit program with failure. putErrDie :: String -> IO a -putErrDie s = putErrLn s >> System.exitFailure +putErrDie s = putErrLn s >> exitFailure -- | exit program successfully. 'exitFailure' is hunk ./src/GenUtil.hs 149 -- also exported from System. exitSuccess :: IO a -exitSuccess = System.exitWith System.ExitSuccess +exitSuccess = exitWith ExitSuccess {-# INLINE fromRight #-} hunk ./src/GenUtil.hs 387 -- | looks up an enviornment variable and returns it in a 'MonadPlus' rather -- than raising an exception if the variable is not set. lookupEnv :: MonadPlus m => String -> IO (m String) -lookupEnv s = catch (fmap return $ System.getEnv s) (\e -> if IO.isDoesNotExistError e then return mzero else ioError e) +lookupEnv s = catch (fmap return $ getEnv s) (\e -> if isDoesNotExistError e then return mzero else ioError e) {-# SPECIALIZE fmapLeft :: (a -> c) -> [(Either a b)] -> [(Either c b)] #-} fmapLeft :: Functor f => (a -> c) -> f (Either a b) -> f (Either c b) hunk ./src/GenUtil.hs 501 -- arguments are given, read stdin. getArgContents = do - as <- System.getArgs + as <- getArgs let f "-" = getContents f fn = readFile fn cs <- mapM f as hunk ./src/GetOpt.hs 24 ArgOrder(..), OptDescr(..), ArgDescr(..), usageInfo, getOpt ) where -import List(isPrefixOf) +import Data.List(isPrefixOf) data ArgOrder a -- what to do with options following non-options: = RequireOrder -- no option processing after first non-option hunk ./src/ParseLib2.hs 34 many1_offside,many_offside,off, opt, skipUntil, skipUntilOff,skipUntilParse,skipNest) where -import Char -import Monad +import Data.Char +import Control.Monad infixr 5 +++ hunk ./src/Rules/Arbitrary.hs 3 module Rules.Arbitrary(rules) where -import List +import Data.List import RuleUtils rules = [ hunk ./src/Rules/Binary.hs 3 module Rules.Binary(rules) where -import List (nub,intersperse) +import Data.List (nub,intersperse) import RuleUtils rules = [ hunk ./src/Rules/BitsBinary.hs 4 -- stub module to add your own rules. module Rules.BitsBinary(rules) where -import List (nub,intersperse) +import Data.List (nub,intersperse) import RuleUtils -- useful to have a look at this too rules = [ hunk ./src/Rules/FunctorM.hs 4 -- stub module to add your own rules. module Rules.FunctorM (rules) where -import List +import Data.List import RuleUtils rules = [ hunk ./src/Rules/Generic.hs 6 -- import StandardRules import RuleUtils -import List(intersperse) +import Data.List(intersperse) rules :: [RuleDef] hunk ./src/Rules/GhcBinary.hs 4 -- stub module to add your own rules. module Rules.GhcBinary (rules) where -import List (nub,intersperse) +import Data.List (nub,intersperse) import RuleUtils -- useful to have a look at this too rules = [ hunk ./src/Rules/Monoid.hs 4 -- stub module to add your own rules. module Rules.Monoid (rules) where -import List import RuleUtils rules = [ hunk ./src/Rules/Standard.hs 4 module Rules.Standard(rules) where import RuleUtils -import List +import Data.List import GenUtil hunk ./src/Rules/Utility.hs 3 module Rules.Utility(rules) where import RuleUtils -import List import GenUtil rules :: [RuleDef] hunk ./src/Rules/Xml.hs 4 -- expanded from stub module to add new rules. module Rules.Xml(rules) where -import List (nub,sortBy) +import Data.List (nub,sortBy) import RuleUtils -- useful to have a look at this too rules :: [RuleDef] hunk ./src/Unlit.hs 7 -- "Report on the Programming Language Haskell", -- version 1.2, appendix C. - -import Char +import Data.Char data Classified = Program String | Blank | Comment | Include Int String | Pre String } [Cabalize DrIFT. kiwamu(a)debian.or.jp**20130328054652 Ignore-this: 58f7a821c63d8f12da83d2726352771c ] { addfile ./DrIFT-cabalized.cabal hunk ./DrIFT-cabalized.cabal 1 +name: DrIFT-cabalized +version: 2.2.3.3 +synopsis: Program to derive type class instances +description: DrIFT is a type sensitive preprocessor for Haskell. It extracts type declarations + and directives from modules. The directives cause rules to be fired on the parsed + type declarations, generating new code which is then appended to the bottom of the input + file. The rules are expressed as Haskell code, and it is intended that the user can add new + rules as required. + . + DrIFT automates instance derivation for classes that aren't supported by the standard compilers. + In addition, instances can be produced in seperate modules to that containing the type declaration. + This allows instances to be derived for a type after the original module has been compiled. + As a bonus, simple utility functions can also be produced from a type. + . + This package was cabalized by gwern <gwern0(a)gmail.com>. +category: Data Structures +license: BSD3 +license-file: LICENSE +-- For contributors & what they did, see AUTHORS +author: Noel Winstanley, John Meacham <john(a)repetae.net> +maintainer: <gwern0(a)gmail.com>, Kiwamu Okabe <kiwamu(a)debian.or.jp> +homepage: http://repetae.net/computer/haskell/DrIFT/ + +Cabal-Version: >= 1.6 +build-type: Simple +data-files: AUTHORS, Changelog, README, README.old, code/README.txt, docs/drift.texi, docs/drift.info, + example/README, example/TestTerm.out.correct +extra-source-files: + code/GhcBinary.hs, code/FunctorM.hs, example/TestTerm.hs, example/BTree.hs, example/Foo.lhs, + example/Xref.hs, example/Artifical.hs, example/Example.hs + +source-repository head + type: git + location: https://github.com/ajhc/drift.git + +executable DrIFT-cabalized + build-depends: base, random, old-time + main-is: DrIFT.hs + hs-source-dirs: src, ./ + other-modules: CommandP, Version, GenUtil, Rules, Rules.Binary, + Rules.GhcBinary, Rules.Arbitrary, + Rules.Monoid, Rules.BitsBinary, Rules.Xml, + Rules.Utility, Rules.Generic, Rules.Standard, + Rules.FunctorM, PreludData, ParseLib2, + DataP, ChaseImports, Pretty, RuleUtils, + Unlit, GetOpt + ghc-options: -Wall + +executable DrIFT-cabalized-ghc + build-depends: base, process + main-is: drift-ghc.hs + ghc-options: -Wall addfile ./drift-ghc.hs hunk ./drift-ghc.hs 1 +import Data.List (isInfixOf) +import System.Cmd (rawSystem) +import System.Environment (getArgs) +import System.Exit (ExitCode(ExitSuccess)) +import Paths_DrIFT_cabalized (getBinDir) hunk ./drift-ghc.hs 7 +main :: IO ExitCode +main = do args <- getArgs + case args of + (a:b:c:[]) -> conditional a b c + _ -> error "This is a driver script allowing DrIFT to be used seamlessly with ghc.\n \ + \ in order to use it, pass '-pgmF drift-ghc -F' to ghc when compiling your programs." + +conditional :: FilePath -> FilePath -> FilePath -> IO ExitCode +conditional orgnl inf outf = do prefix <- getBinDir + infile <- readFile inf + if "{-!" `isInfixOf` infile then do putStrLn (prefix ++ "DriFT-cabalized " ++ + inf ++ " -o " ++ outf) + rawSystem inf ["-o", outf] + else do writeFile outf ("{-# LINE 1 \"" ++ orgnl ++ " #-}") + readFile inf >>= appendFile outf + return ExitSuccess +{- GHC docs say: "-pgmF cmd + Use cmd as the pre-processor (with -F only). +Use -pgmF cmd to select the program to use as the preprocessor. +When invoked, the cmd pre-processor is given at least three arguments on its command-line: +1. the first argument is the name of the original source file, +2. the second is the name of the file holding the input +3. third is the name of the file where cmd should write its output to." -} } [Build Haskell pacakge (cabal) with the command "make cabal-install". kiwamu(a)debian.or.jp**20130328125935 Ignore-this: 918ff70482a3aa96ef83983e6a69e0b8 ] { hunk ./Makefile.am 45 make -C $(PUBLISH_DIR) || true +src/Rules.hs: + make -C src Rules.hs + +cabal-install: src/Rules.hs docs/drift.info + cabal install + +cabal-dist: src/Rules.hs docs/drift.info + runhaskell Setup.hs sdist rpm: depend $(PACKAGE_NAME).spec dist cp $(PACKAGE_NAME)-$(VERSION).tar.gz $(HOME)/var/rpm/SOURCES/ addfile ./Setup.hs hunk ./Setup.hs 1 +module Main (main) where + +import Distribution.Simple + +main :: IO () +main = defaultMainWithHooks defaultUserHooks } [Change haskell package name, version name as library to be depended by other package. kiwamu(a)debian.or.jp**20130913080813 Ignore-this: c836346d41f5207f9e6a1a33708b3349 ] { hunk ./Changelog 1 +DrIFT-2.3.0: + * Publish DrIFT in HackageDB. + * Get less warning message. + + DrIFT-2.2.2: * redid build model, collect deriving rules automatically. hunk ./DrIFT-cabalized.cabal 1 -name: DrIFT-cabalized -version: 2.2.3.3 -synopsis: Program to derive type class instances -description: DrIFT is a type sensitive preprocessor for Haskell. It extracts type declarations - and directives from modules. The directives cause rules to be fired on the parsed - type declarations, generating new code which is then appended to the bottom of the input - file. The rules are expressed as Haskell code, and it is intended that the user can add new - rules as required. - . - DrIFT automates instance derivation for classes that aren't supported by the standard compilers. - In addition, instances can be produced in seperate modules to that containing the type declaration. - This allows instances to be derived for a type after the original module has been compiled. - As a bonus, simple utility functions can also be produced from a type. - . - This package was cabalized by gwern <gwern0(a)gmail.com>. -category: Data Structures -license: BSD3 -license-file: LICENSE --- For contributors & what they did, see AUTHORS -author: Noel Winstanley, John Meacham <john(a)repetae.net> -maintainer: <gwern0(a)gmail.com>, Kiwamu Okabe <kiwamu(a)debian.or.jp> -homepage: http://repetae.net/computer/haskell/DrIFT/ - -Cabal-Version: >= 1.6 -build-type: Simple -data-files: AUTHORS, Changelog, README, README.old, code/README.txt, docs/drift.texi, docs/drift.info, - example/README, example/TestTerm.out.correct -extra-source-files: - code/GhcBinary.hs, code/FunctorM.hs, example/TestTerm.hs, example/BTree.hs, example/Foo.lhs, - example/Xref.hs, example/Artifical.hs, example/Example.hs - -source-repository head - type: git - location: https://github.com/ajhc/drift.git - -executable DrIFT-cabalized - build-depends: base, random, old-time - main-is: DrIFT.hs - hs-source-dirs: src, ./ - other-modules: CommandP, Version, GenUtil, Rules, Rules.Binary, - Rules.GhcBinary, Rules.Arbitrary, - Rules.Monoid, Rules.BitsBinary, Rules.Xml, - Rules.Utility, Rules.Generic, Rules.Standard, - Rules.FunctorM, PreludData, ParseLib2, - DataP, ChaseImports, Pretty, RuleUtils, - Unlit, GetOpt - ghc-options: -Wall - -executable DrIFT-cabalized-ghc - build-depends: base, process - main-is: drift-ghc.hs - ghc-options: -Wall rmfile ./DrIFT-cabalized.cabal addfile ./DrIFT.cabal.in hunk ./DrIFT.cabal.in 1 +name: DrIFT +version: @VERSION@ +synopsis: Program to derive type class instances +description: Today Data.Derive <http://hackage.haskell.org/package/derive> is good another solution for DrFIT. + See the User Manual <http://community.haskell.org/~ndm/darcs/derive/derive.htm>. + . + DrIFT is a type sensitive preprocessor for Haskell. It extracts type declarations + and directives from modules. The directives cause rules to be fired on the parsed + type declarations, generating new code which is then appended to the bottom of the input + file. The rules are expressed as Haskell code, and it is intended that the user can add new + rules as required. + . + DrIFT automates instance derivation for classes that aren't supported by the standard compilers. + In addition, instances can be produced in seperate modules to that containing the type declaration. + This allows instances to be derived for a type after the original module has been compiled. + As a bonus, simple utility functions can also be produced from a type. + . + This package was cabalized by gwern <gwern0(a)gmail.com>. +category: Data Structures +license: BSD3 +license-file: LICENSE +-- For contributors & what they did, see AUTHORS +author: Noel Winstanley, John Meacham <john(a)repetae.net> +maintainer: gwern <gwern0(a)gmail.com>, Metasepi team <metasepi(a)gmail.com> +homepage: http://repetae.net/computer/haskell/DrIFT/ + +Cabal-Version: >= 1.8 +build-type: Simple +data-files: AUTHORS, Changelog, README.md, README.old, code/README.txt, docs/drift.texi, docs/drift.info, + example/README, example/TestTerm.out.correct +extra-source-files: + code/GhcBinary.hs, code/FunctorM.hs, example/TestTerm.hs, example/BTree.hs, example/Foo.lhs, + example/Xref.hs, example/Artifical.hs, example/Example.hs + +source-repository head + type: git + location: https://github.com/ajhc/drift.git + +library + hs-source-dirs: src + build-depends: base >= 4.0 && < 5 + exposed-modules: DrIFT.Version + ghc-options: -Wall -fno-warn-name-shadowing -fno-warn-unused-binds -fno-warn-unused-matches -fno-warn-unused-do-bind -fno-warn-missing-signatures + +executable DrIFT + build-depends: base >= 4.0 && < 5, random, old-time, DrIFT + main-is: DrIFT.hs + hs-source-dirs: src + other-modules: CommandP, GenUtil, Rules, Rules.Binary, + Rules.GhcBinary, Rules.Arbitrary, + Rules.Monoid, Rules.BitsBinary, Rules.Xml, + Rules.Utility, Rules.Generic, Rules.Standard, + Rules.FunctorM, PreludData, ParseLib2, + DataP, ChaseImports, Pretty, RuleUtils, + Unlit, GetOpt + ghc-options: -Wall -fno-warn-name-shadowing -fno-warn-unused-binds -fno-warn-unused-matches -fno-warn-unused-do-bind -fno-warn-missing-signatures + +executable drift-ghc + build-depends: base >= 4.0 && < 5, process + main-is: drift-ghc.hs + ghc-options: -Wall -fno-warn-name-shadowing -fno-warn-unused-binds -fno-warn-unused-matches -fno-warn-unused-do-bind -fno-warn-missing-signatures hunk ./Makefile.am 16 Changelog README.old drift-ghc.in code \ code/FunctorM.hs code/GhcBinary.hs code/README.txt \ ac-macros/acincludepackage.m4 LICENSE docs/drift.html \ - DrIFT.spec + DrIFT.spec DrIFT-cabalized.cabal bin_SCRIPTS = drift-ghc hunk ./configure.ac 1 -AC_INIT([DrIFT],[2.2.3],john(a)repetae.net, [DrIFT]) +AC_INIT([DrIFT],[2.4.1],john(a)repetae.net, [DrIFT]) AC_CONFIG_SRCDIR(src/DrIFT.hs) AC_CONFIG_MACRO_DIR(ac-macros) AC_CONFIG_AUX_DIR(ac-macros) hunk ./configure.ac 32 Makefile src/Makefile example/Makefile - src/Version.hs + src/DrIFT/Version.hs DrIFT.spec drift-ghc hunk ./configure.ac 36 + DrIFT.cabal ) hunk ./drift-ghc.hs 5 import System.Cmd (rawSystem) import System.Environment (getArgs) import System.Exit (ExitCode(ExitSuccess)) -import Paths_DrIFT_cabalized (getBinDir) +import Paths_DrIFT (getBinDir) main :: IO ExitCode main = do args <- getArgs hunk ./src/ChaseImports.hs 33 import Control.Monad import GenUtil -try x = catch (x >>= return . Right) (return . Left) +try x = iocatch (x >>= return . Right) (return . Left) --- Split up input --------------------------------------------------------- splitString :: String -> String -> (String,String) adddir ./src/DrIFT hunk ./src/DrIFT.hs 16 import Pretty import RuleUtils (commentLine,texts) import RuleUtils(Rule,Tag) -import Version +import DrIFT.Version import qualified Rules(rules) import System.IO import System.Environment hunk ./src/DrIFT.hs 36 } +env :: Env env = Env { envVerbose = False, envOutput = Nothing, hunk ./src/DrIFT.hs 49 } +getOutput :: Env -> IO Handle getOutput e = maybe (return stdout) (\fn -> openFile fn WriteMode) (envOutput e) options :: [OptDescr (Env -> Env)] hunk ./src/DrIFT.hs 65 , Option ['i'] ["ignore"] (NoArg (\e->e{envIgnoreDirectives = True})) "ignore directives in file. useful with -g" ] +setArg :: String -> Env -> Env setArg x e = e {envArgs = (n, tail rest):(envArgs e)} where (n,rest) = span (/= ':') x hunk ./src/DrIFT.hs 68 +addGlobalRule :: Tag -> Env -> Env addGlobalRule x e = e {envGlobalRules = x:(envGlobalRules e)} hunk ./src/DrIFT.hs 78 fstEq (a,_) (b,_) = a == b fstOrd (a,_) (b,_) = compare a b +doList :: IO () doList = do let rn = categorize [(c,(n,h)) | (n,_,c,h,_) <- Rules.rules] putStrLn $ unlines $ buildTableLL $ concat [ (c ++ ":","") : (map (\(a,b) -> (" " ++ a, b)) $ sort xs)| (c,xs)<- rn] hunk ./src/DrIFT.hs 84 +header :: String header = "Usage: DrIFT [OPTION...] file" hunk ./src/DrIFT.hs 86 +main :: IO () main = do argv <- getArgs (env,n) <- case (getOpt Permute options argv) of hunk ./src/DrIFT.hs 101 +derive :: Env -> FilePath -> IO () derive env fname = do let findent xs = f (lines xs) where f (x:xs) = let (w,n) = span isSpace x in case n of hunk ./src/DrIFT.hs 126 hFlush handle +addGlobals :: Env -> [([Tag], Data)] -> [([Tag], Data)] addGlobals env tds = (envGlobalRules env,Directive):concatMap f tds where f x | not (envIgnoreDirectives env) = [x] f (_,Directive) = [] hunk ./src/DrIFT.hs 134 f (_,d) = [([],d)] +rules :: [(String, Data -> Doc)] rules = map (\(a,b,_,_,_) -> (a,b)) Rules.rules -- codeRender doc = fullRender PageMode 80 1 doc "" -- now obsolete hunk ./src/DrIFT.hs 137 +vsep :: [Doc] -> Doc vsep = vcat . map ($$ (text "")) hunk ./src/DrIFT.hs 139 +sepDoc :: Doc sepDoc = commentLine . text $ " Imported from other files :-" backup :: FilePath -> FilePath hunk ./src/DrIFT.hs 166 find :: Tag -> [Rule] -> (Data -> Doc) find t r = case filter ((==t) . fst) $ r of [] -> const (commentLine warning) - (x:xs) -> snd x + (x:_) -> snd x where warning = hsep . texts $ ["Warning : Rule",t,"not found."] addfile ./src/DrIFT/Version.hs.in hunk ./src/DrIFT/Version.hs.in 1 +module DrIFT.Version(package, version, fullName) where + +package :: String +package = "@PACKAGE@" + +version :: String +version = "@VERSION@" + +fullName :: String +fullName = package ++ "-" ++ version hunk ./src/GenUtil.hs 89 readsM, split, tokens, + iocatch, -- * Classes UniqueProducer(..) hunk ./src/GenUtil.hs 97 import System.Time import System.IO -import System.IO.Error +import System.IO.Error(isDoesNotExistError) +import Control.Exception import System.Exit(exitFailure, exitWith, ExitCode(..)) hunk ./src/GenUtil.hs 100 -import System.Environment +import System.Environment(getArgs, getEnv) import Control.Monad(join, liftM, MonadPlus, mzero) hunk ./src/GenUtil.hs 102 +import Prelude hiding (catch) import System.Random(StdGen, newStdGen, Random(randomR)) import Data.Char(isAlphaNum, isSpace, toLower, ord) import Data.List(group,sort) hunk ./src/GenUtil.hs 112 {-# SPECIALIZE snub :: [String] -> [String] #-} {-# SPECIALIZE snub :: [Int] -> [Int] #-} +-- | catch function only for IOException +iocatch :: IO a -> (IOException -> IO a) -> IO a +iocatch = catch + -- | sorted nub of list, much more efficient than nub, but doesnt preserve ordering. snub :: Ord a => [a] -> [a] snub = map head . group . sort hunk ./src/GenUtil.hs 220 snds :: [(a,b)] -> [b] snds = map snd -{-# INLINE repeatM #-} {-# SPECIALIZE repeatM :: IO a -> IO [a] #-} repeatM :: Monad m => m a -> m [a] repeatM x = sequence $ repeat x hunk ./src/GenUtil.hs 224 -{-# INLINE repeatM_ #-} {-# SPECIALIZE repeatM_ :: IO a -> IO () #-} repeatM_ :: Monad m => m a -> m () repeatM_ x = sequence_ $ repeat x hunk ./src/GenUtil.hs 228 -{-# INLINE replicateM #-} {-# SPECIALIZE replicateM :: Int -> IO a -> IO [a] #-} replicateM :: Monad m => Int -> m a -> m [a] replicateM n x = sequence $ replicate n x hunk ./src/GenUtil.hs 232 -{-# INLINE replicateM_ #-} {-# SPECIALIZE replicateM_ :: Int -> IO a -> IO () #-} replicateM_ :: Monad m => Int -> m a -> m () replicateM_ n x = sequence_ $ replicate n x hunk ./src/GenUtil.hs 293 lefts xs = [x | Left x <- xs] ioM :: Monad m => IO a -> IO (m a) -ioM action = catch (fmap return action) (\e -> return (fail (show e))) +ioM action = iocatch (fmap return action) (\e -> return (fail (show e))) ioMp :: MonadPlus m => IO a -> IO (m a) hunk ./src/GenUtil.hs 296 -ioMp action = catch (fmap return action) (\_ -> return mzero) +ioMp action = iocatch (fmap return action) (\_ -> return mzero) -- | reformat a string to not be wider than a given width, breaking it up -- between words. hunk ./src/GenUtil.hs 390 -- | looks up an enviornment variable and returns it in a 'MonadPlus' rather -- than raising an exception if the variable is not set. lookupEnv :: MonadPlus m => String -> IO (m String) -lookupEnv s = catch (fmap return $ getEnv s) (\e -> if isDoesNotExistError e then return mzero else ioError e) +lookupEnv s = iocatch (fmap return $ getEnv s) (\e -> if isDoesNotExistError e then return mzero else ioError e) {-# SPECIALIZE fmapLeft :: (a -> c) -> [(Either a b)] -> [(Either c b)] #-} fmapLeft :: Functor f => (a -> c) -> f (Either a b) -> f (Either c b) hunk ./src/Makefile.am 10 bin_PROGRAMS = DrIFT DrIFT_SOURCES = ${RULES} ChaseImports.hs CommandP.hs DataP.lhs DrIFT.hs GetOpt.hs \ - Unlit.hs ParseLib2.hs PreludData.hs Pretty.lhs RuleUtils.hs Version.hs GenUtil.hs + Unlit.hs ParseLib2.hs PreludData.hs Pretty.lhs RuleUtils.hs GenUtil.hs # DrIFT_static_SOURCES = $(DrIFT_SOURCES) # DrIFT_static_LINK = $(DrIFT_LINK) -static -optl-static -ldl hunk ./src/Makefile.am 31 # COMPILE = $(HC) $(HCFLAGS) # all: DrIFT -DrIFT: $(DrIFT_SOURCES) $(nodist_DrIFT_SOURCES) +DrIFT$(EXEEXT): $(DrIFT_SOURCES) $(nodist_DrIFT_SOURCES) $(HC) $(HCFLAGS) -i. -i@srcdir@ -hidir . -odir . -o $@ --make @srcdir@/DrIFT.hs #.hs.o: hunk ./src/Rules/Binary.hs 3 module Rules.Binary(rules) where -import Data.List (nub,intersperse) +-- import Data.List (nub,intersperse) import RuleUtils rules = [ hunk ./src/Rules/BitsBinary.hs 4 -- stub module to add your own rules. module Rules.BitsBinary(rules) where -import Data.List (nub,intersperse) +import Data.List (intersperse) import RuleUtils -- useful to have a look at this too rules = [ hunk ./src/Rules/Utility.hs 3 module Rules.Utility(rules) where import RuleUtils -import GenUtil +-- import GenUtil rules :: [RuleDef] rules = [("Query",queryGen, "Utility", "provide a QueryFoo class with 'is', 'has', 'from', and 'get' routines", Nothing) ] hunk ./src/Version.hs.in 1 -module Version(package, version, fullName) where - -package = "@PACKAGE@" - -version = "@VERSION@" - - -fullName = package ++ "-" ++ version rmfile ./src/Version.hs.in } -- Kiwamu Okabe

1 0

darcs patch: Use cpphs, because gcc-4.8.1's cpp has e... (and 1 more)
by kiwamu＠debian.or.jp 19 Sep '13

19 Sep '13

2 patches for repository http://repetae.net/repos/jhc: Fri Sep 20 00:12:49 JST 2013 kiwamu(a)debian.or.jp * Use cpphs, because gcc-4.8.1's cpp has error. Fri Sep 20 00:13:44 JST 2013 kiwamu(a)debian.or.jp * Better NAIVEGC and new SAVING_MALLOC_HEAP flag.

1 0

ANNOUNCE: Ajhc Haskell Compiler 0.8.0.8 Release
by Kiwamu Okabe 02 Sep '13

02 Sep '13

We are happy to announce Ajhc 0.8.0.8. This version is a point release to fix some BUGs, and support new platforms. You can get Ajhc using "cabal install ajhc" command. The usage is found at Ajhc's project web site http://ajhc.metasepi.org/. The source code at https://github.com/ajhc/ajhc/tags. Welcome sending any bugs or your ideas to https://github.com/ajhc/ajhc/issues. ## Support new platforms ### mbed http://mbed.org/ The mbed platform is a single-board microcontroller using ARM Cortex-M3 CPU. It has only 32kB RAM for application. >From this release, Ajhc support mbed and Text LCD device driver. You can find the demo source code at https://github.com/ajhc/demo-cortex-m3, and watch the demo movie at http://www.youtube.com/watch?v=fOsjEfNmTkY. ### ChibiOS/RT http://www.chibios.org/ The ChibiOS/RT is embedded real time OS. >From this release, Ajhc can compile Haskell application running on ChibiOS/RT. The application is able to use forkOS API with ChibiOS/RT's thread. You will find the demo source code at https://github.com/metasepi/chibios-arafura. ## Other changes * Use cpphs command for C preprocessor. * Don't insert (void) cast for function call. * Add --targetsini option to specify the targets.ini file. * Data.Bits support CInt. * Retry download when some error occured on getting tar ball from Hackage DB. * Fix BUGs * Don't increment megablock count, when re-use the megablock in free list. * Fix IORef compile BUG. Enjoy! :) - - - Metasepi team

1 0

Re: [jhc] [Haskell-cafe] ANNOUNCE: Ajhc Haskell Compiler 0.8.0.7 Release
by Kiwamu Okabe 09 Jul '13

09 Jul '13

Hi Jeremy. On Tue, Jul 9, 2013 at 3:30 AM, Jeremy Shaw <jeremy(a)n-heptane.com> wrote: > Any plans on supporting the popular Raspberry Pi platform? I poked at the > source code a bit, but I didn't even know where to begin. I think you can do it already, if you have cross GCC for Raspberry Pi. http://ajhc.metasepi.org/manual.html#crosscompilation Best regards, -- Kiwamu Okabe

1 0

ANNOUNCE: Ajhc Haskell Compiler 0.8.0.7 Release
by Kiwamu Okabe 06 Jul '13

06 Jul '13

We are happy to announce Ajhc 0.8.0.7. You can program interrupt handler with Haskell language on this release. But not yet collect (big) patch sets, the changes will be merged to jhc. You can get Ajhc using "cabal install ajhc" command. The usage is found at Ajhc's project web site http://ajhc.metasepi.org/. The source code at https://github.com/ajhc/ajhc/tags. Welcome sending any bugs or your ideas to https://github.com/ajhc/ajhc/issues. ## An example of interrupt handler written with Haskell <https://github.com/ajhc/demo-cortex-m3/tree/master/stm32f3-discovery> The demo for Cortex-M4 has main context and intrrupt context. The main context waits time expire with polling counter. <https://github.com/ajhc/demo-cortex-m3/blob/master/stm32f3-discovery/hs_src…> The interrupt context is called from clock exception, and decrement counter. <https://github.com/ajhc/demo-cortex-m3/blob/master/stm32f3-discovery/hs_src…> ## Other changes * Guard StablePtr critical section. * Add _JHC_JGC_SAVING_MALLOC_HEAP option for getting smaller malloc heap. * Link forkIO to forkOS. Enjoy! :) - - - Metasepi team

1 0

ANNOUNCE: Ajhc 0.8.0.6 Release
by Kiwamu Okabe 19 Jun '13

19 Jun '13

We are happy to announce Ajhc 0.8.0.6. Major change on the release is supporting THREAD. Yeah! You can get Ajhc using "cabal install ajhc" command. Ajhc's project web site is found at http://ajhc.metasepi.org/. You find the source code at https://github.com/ajhc/ajhc/tags. Welcome sending any bugs or your ideas to https://github.com/ajhc/ajhc/issues. ## Good news * You can use forkOS interface on Ajhc. * Your program runs on pthread with compiling -fpthread option. See below. $ cat Main.hs import Control.Monad import Control.Concurrent main :: IO () main = do l <- putStrLn "Type some string and enter." >> getLine forkOS $ (forever $ putChar '*') forkOS $ (forever $ putStr l) forever $ putChar '.' $ ajhc -fpthread Main.hs $ ./hs.out ## Bad news * Ajhc guards critical section only for the runtime. * Example: StablePtr isn't guarded with lock. * Ajhc's thread can't share any objects without Ptr type. * And you may find funny pthread bugs. Please send us the report! ## Other changes * No more depend on DrIFT. * Add _JHC_JGC_LIMITED_NUM_GC_STACK flag to set number of limited gc_stack entries. * Add _JHC_JGC_FIXED_MEGABLOCK flag to set number of limited megablock entries. * Add compile flags -fcustomthread -fpthread -fnothread. * You can implement your own thread API for Ajhc, if you choose -fcustomthread. Enjoy! ;) - - - Metasepi team

1 0

ANNOUNCE: Ajhc 0.8.0.5 Release
by Kiwamu Okabe 07 Jun '13

07 Jun '13

We are happy to announce Ajhc 0.8.0.5. Major change on this release is supporting haddock. You can see Ajhc's internal using web browser. Ajhc's project web site is found at http://ajhc.metasepi.org/. You can get the source code from https://github.com/ajhc/ajhc/tags. ## Changes * Support haddock. You can read haddock on http://hackage.haskell.org/package/ajhc, hopefully. * Split library from Ajhc program. * Better NAIVEGC. * Add arity "arena" to all functions compiled by Ajhc. For supporting reentrant in future. * Run SelfTest and rtstest on travis-ci. * Add jahm command to download file from Hackage DB, because sometime perl script occurs error. Enjoy. :) - - - Metasepi team

1 0