source: trunk/dports/devel/haskell-platform/Portfile

Last change on this file was 131981, checked in by cal@…, 3 years ago

haskell world: revbump everything (including ghc)

  • Clean up remnants left in GHC's package directory that may be left over from previous installations. See for example #46611, which has a log of all the superfluous files left on the buildbots, which should be cleaned up by this.
  • Modify portgroups to register configuration files in $prefix/lib/ghc-7.8.3/package.conf.d/ directly before calling ghc-pkg recache rather than using activation and deactivation scripts that indirectly create these files to avoid the same mess in the future. This way, the state in the package cache directory will always represent the same state MacPorts expects.
  • Simplify and clean up some of the portgroups, especially related to variable substitution in pre-/post-activation hooks.
  • Avoid duplicating most of the code in the haskellplatform 2.0 portgroup and just refer back to the haskell 1.0 portgroup instead.
  • Apply the hook variable substitution cleanup to the local helper functions in the haskell-platform Portfile.

This change

  • should finally fix #46611 and #42082 and all the weird little misconfigurations that would occasionally occur on users' machines
  • adds helpful debugging information (ghc-pkg list, ghc-pkg check) to the main.log in the configure phase.
  • breaks manual installation of haskell packages (e.g. using cabal) in the system directory, because the ghc Portfile will clean out everything that isn't owned by a port in the package cache directory. If this affects you, be advised that you should not be putting stuff MacPorts doesn't know about in MacPorts' prefix. Instead, please use user installations of these packages.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 23.9 KB
Line 
1# -*- coding: utf-8; mode: tcl; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- vim:fenc=utf-8:ft=tcl:et:sw=4:ts=4:sts=4
2# $Id: Portfile 131981 2015-01-22 19:34:32Z ryandesign@macports.org $
3
4PortSystem      1.0
5
6name            haskell-platform
7
8if {$subport == $name} {
9    version         2014.2.0.0
10    categories      devel haskell
11    maintainers     cal openmaintainer
12    description     \
13        The Haskell Platform is the easiest way to get started with programming \
14        Haskell. It comes with all you need to get up and running. Think of it as \
15        \"Haskell: batteries included\".
16    long_description \
17        The Haskell Platform is a comprehensive, robust development environment for \
18        programming in Haskell. For new users the platform makes it trivial to get \
19        up and running with a full Haskell development environment. For experienced \
20        developers, the platform provides a comprehensive, standard base for \
21        commercial and open source Haskell development that maximises \
22        interoperability and stability of your code.
23
24    platforms       darwin
25    homepage        http://hackage.haskell.org/platform/
26    master_sites    ${homepage}
27    license         Permissive
28
29    depends_run     port:ghc
30
31    fetch {}
32    checksum {}
33    extract {}
34    configure {}
35    build {}
36    destroot {
37        xinstall -d ${destroot}${prefix}/share/doc/${name}
38        system "echo ${long_description} > ${destroot}${prefix}/share/doc/${name}/README.txt"
39    }
40
41    use_configure       no
42    universal_variant   no
43
44    livecheck.type      regex
45    livecheck.url       ${homepage}
46    livecheck.regex     "Current release: <a href=\"changelog.html\">(\\d+\\.\\d\\.\\d\\.\\d)</a>"
47}
48
49##
50# Helper proc containing the defaults for the haskell platform ports following
51# after this block. Modeled after the subport mechanism in base, it creates
52# a subport for each given port and executes Portfile code in the context of
53# the newly created subport.
54#
55# @param[in] pkgname     the name of the haskell package, case-sensitive
56# @param[in] pkgversion  the version to be packaged in haskell platform
57# @param[in] pkgrevision the current revision of the port in MacPorts
58# @param[in] block       a block of code to be executed in the subport, optional
59proc haskell_platform_port {pkgname pkgversion pkgrevision {block {}}} {
60    # To see what this little bit of magic does, replace "uplevel 1" with
61    # "ui_warn".
62    uplevel 1 [subst {
63        subport hs-[string tolower ${pkgname}] {
64            PortGroup               haskellplatform 2.0
65            haskellplatform.setup   [list ${pkgname}] [list ${pkgversion}]
66            revision                [list ${pkgrevision}]
67
68            # Make sure to check this for every port!
69            license                 BSD
70            maintainers             cal openmaintainer
71            platforms               darwin
72
73            ${block}
74        }
75
76        # Add a dependency from haskell-platform -> hs-[string tolower $pkgname]
77        if [list {$subport eq $name}] {
78            depends_run-append  port:hs-[string tolower ${pkgname}]
79        }
80    }]
81}
82
83##
84# Helper proc for tools and programs in the Haskell Platform. This behaves
85# exactly like \c haskell_platform_port, with the exception of passing "no" as
86# third argument to \c haskellplatform.setup of the haskellplatform PortGroup.
87#
88# @param[in] pkgname     the name of the haskell package, case-sensitive
89# @param[in] pkgversion  the version to be packaged in haskell platform
90# @param[in] pkgrevision the current revision of the port in MacPorts
91# @param[in] block       a block of code to be executed in the subport, optional
92proc haskell_platform_tool {pkgname pkgversion pkgrevision {block {}}} {
93    # To see what this little bit of magic does, replace "uplevel 1" with
94    # "ui_warn".
95    uplevel 1 [subst {
96        subport hs-[string tolower ${pkgname}] {
97            PortGroup               haskellplatform 2.0
98            haskellplatform.setup   [list ${pkgname}] [list ${pkgversion}] no
99            revision                [list ${pkgrevision}]
100
101            # Make sure to check this for every port!
102            license                 BSD
103            maintainers             cal openmaintainer
104            platforms               darwin
105
106            ${block}
107        }
108
109        # Add a dependency from haskell-platform -> hs-[string tolower $pkgname]
110        if [list {$subport eq $name}] {
111            depends_run-append  port:hs-[string tolower ${pkgname}]
112        }
113    }]
114}
115
116
117#################################
118# Additional Platform Libraries #
119#################################
120
121haskell_platform_port async 2.0.1.5 1 {
122    checksums               rmd160  0ec360bc373c4ca0b3c7617ec611f2414804e9cd \
123                            sha256  cd13ac558f4f63e567100805770648e89307a3210852b17038c9be4fcc3aa83c
124
125    depends_lib-append      port:hs-stm
126
127    description             Run IO operations asynchronously and wait for their results
128    long_description        \
129        This package provides a higher-level interface over threads, in which an \
130        Async a is a concurrent thread that will eventually deliver a value of type \
131        a. The package provides ways to create Async computations, wait for their \
132        results, and cancel them. \
133        Using Async is safer than using threads in two ways:\n\
134        - When waiting for a thread to return a result, if the thread dies with an \
135        exception then the caller must either re-throw the exception (wait) or \
136        handle it (waitCatch)\; the exception cannot be ignored.\n\
137        - The API makes it possible to build a tree of threads that are \
138        automatically killed when their parent dies (see withAsync).
139}
140
141haskell_platform_port attoparsec 0.10.4.0 4 {
142    checksums               rmd160  1fc9845e60fb0cddc9ffa8838c446b3046cd3522 \
143                            sha256  b6b84e0dbd1c3beec1dedea578ac2f4d62afbe66b383582b7b3349406866d346
144
145    depends_lib-append      port:hs-text
146
147    description             Fast combinator parsing for bytestrings and text
148    long_description        \
149        A fast parser combinator library, aimed particularly at dealing \
150        efficiently with network protocols and complicated text/binary file \
151        formats.
152}
153
154haskell_platform_port case-insensitive 1.1.0.3 1 {
155    checksums               rmd160  351ebf0ae84c4c580b910dbd3ed0828b309874c7 \
156                            sha256  7b255fe63155d53ab84b248ab5ba9306fd4bec47a6198e3275cf9cb41c4d263b
157
158    depends_lib-append      port:hs-hashable \
159                            port:hs-text
160
161    description             Case insensitive string comparison
162    long_description        \
163        The module Data.CaseInsensitive provides the CI type constructor which \
164        can be parameterised by a string-like type like: String, ByteString, \
165        Text, etc.. Comparisons of values of the resulting type will be \
166        insensitive to cases.
167}
168
169haskell_platform_port fgl 5.5.0.1 1 {
170    checksums               rmd160  c6c1f89db51d8d3ce6687dab13109c7f40c9c10c \
171                            sha256  aa61664ba38db3e54124b702b1ee92a72a569c981b759e48cfb567078b038763
172
173    depends_lib-append      port:hs-mtl
174
175    description             Martin Erwig's Functional Graph Library
176    long_description        ${description}
177}
178
179haskell_platform_port GLUT 2.5.1.1 1 {
180    checksums               rmd160  b6e4bad4109307a614c3ba93aa1f3f8857ae45dc \
181                            sha256  4a8177e154ead5a7bcc110f8fe408f9cf720783dde024ac1936cd95b659b2d59
182
183    depends_lib-append      port:hs-opengl
184
185    description             A binding for the OpenGL Utility Toolkit
186    long_description        \
187        A Haskell binding for the OpenGL Utility Toolkit, a window system \
188        independent toolkit for writing OpenGL programs.
189}
190
191haskell_platform_port GLURaw 1.4.0.1 1 {
192    checksums               rmd160  1fa7a906c6f99d9540b200de038a2a734e576cea \
193                            sha256  9655644beb54ff8fac68f2e0fd8a8e9a1e8409272e2e4c963ccce9bcd60e0ecc
194
195    depends_lib-append      port:hs-openglraw
196
197    description             A raw binding for the OpenGL graphics system
198    long_description        \
199        GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL utility library. \
200        It is basically a 1:1 mapping of GLU's C API, intended as a basis for \
201        a nicer interface.
202}
203
204haskell_platform_port hashable 1.2.2.0 1 {
205    checksums               rmd160  33f9040f2afcb93d6475d8872aef4c164a4cff5e \
206                            sha256  033a90b0369af59bf922d0c2af8d73a18432b46b0a47607f436d38f873a88e21
207
208    depends_lib-append      port:hs-text
209
210    description             A class for types that can be converted to a hash value
211    long_description        \
212        This package defines a class, Hashable, for types that can be converted \
213        to a hash value. This class exists for the benefit of hashing-based \
214        data structures. The package provides instances for basic types and \
215        a way to combine hash values.
216}
217
218haskell_platform_port haskell-src 1.0.1.6 1 {
219    checksums               rmd160  649a0f9f116cb90f03411a9e8d53b17409c38134 \
220                            sha256  c7c556366025d9895d1110ecfa30a29e29d7d0a8cb447716fe601e4ff5da4cef
221
222    depends_lib-append      port:hs-syb
223
224    description             Support for manipulating Haskell source code
225    long_description        \
226        The haskell-src package provides support for manipulating Haskell \
227        source code. The package provides a lexer, parser and pretty-printer, \
228        and a definition of a Haskell abstract syntax tree (AST). Common uses \
229        of this package are to parse or generate Haskell 98 code.
230}
231
232haskell_platform_port html 1.0.1.2 6 {
233    checksums               rmd160  55d95a42c297c9c4b0b0c3bbd077a5ed59e48878 \
234                            sha256  0c35495ea33d65e69c69bc7441ec8e1af69fbb43433c2aa3406c0a13a3ab3061
235
236    description             HTML combinator library
237    long_description        \
238        This package contains a combinator library for constructing HTML documents.
239}
240
241haskell_platform_port HTTP 4000.2.10 1 {
242    checksums               rmd160  b1e3a1aec27c3e09fe1f93f93ab717cc4e576504 \
243                            sha256  efde6d9f2e8cd7b72068579f0a75449703c0fa7aee76dfc0f3af175295a127d1
244
245    depends_lib-append      port:hs-network \
246                            port:hs-mtl \
247                            port:hs-parsec
248
249    description             A library for client-side HTTP
250    long_description        \
251        The HTTP package supports client-side web programming in Haskell. It \
252        lets you set up HTTP connections, transmitting requests and processing \
253        the responses coming back, all from within the comforts of Haskell. \
254        It's dependent on the network package to operate, but other than that, \
255        the implementation is all written in Haskell.
256}
257
258haskell_platform_port HUnit 1.2.5.2 3 {
259    checksums               rmd160  f6ac9ac12c152609174ea80a3a0c694210c81594 \
260                            sha256  0af5ad34dba27de48b94ce6d5f7ee3aa6af6183bdc4a3967b811e28520369a41
261
262    description             A unit testing framework for Haskell
263    long_description        \
264        HUnit is a unit testing framework for Haskell, inspired by the JUnit \
265        tool for Java, see: http://www.junit.org.
266}
267
268haskell_platform_port mtl 2.1.3.1 1 {
269    checksums               rmd160  f6432fb7e64d66eff69f02ccca9fc30ac5dce502 \
270                            sha256  77af766957fb49361fe63446f272a698bddb13398669edc363022e5c2517f6f6
271
272    description             Monad classes, using functional dependencies
273    long_description        \
274        Monad classes using functional dependencies, with instances for various \
275        monad transformers, inspired by the paper Functional Programming with \
276        Overloading and Higher-Order Polymorphism, by Mark P Jones, in Advanced \
277        School of Functional Programming, 1995
278}
279
280haskell_platform_port network 2.4.2.3 1 {
281    checksums               rmd160  38f20be22e51a902a00416bad1e63480316e8348 \
282                            sha256  801b9c652dae626bf4a96175162b1290e7fe7ff20d802d62434d5ae1d363c16d
283
284    depends_lib-append      port:hs-parsec
285
286    description             Low-level networking interface
287    long_description        ${description}
288}
289
290haskell_platform_port OpenGL 2.9.2.0 1 {
291    checksums               rmd160  b238630bd16d37485c58835a643d965ac6c61ef2 \
292                            sha256  1758f6cacc9ea8f0d410fd0abc1a19f2a50dffdb62736d66d4e62b20619545e9
293
294    depends_lib-append      port:hs-gluraw \
295                            port:hs-openglraw \
296                            port:hs-text
297
298    description             A binding for the OpenGL graphics system
299    long_description        \
300        A Haskell binding for the OpenGL graphics system (GL, version 4.4) and \
301        its accompanying utility library (GLU, version 1.3).
302}
303
304haskell_platform_port OpenGLRaw 1.5.0.0 1 {
305    checksums               rmd160  6ede61cb59090ede7d3ec1df41311a8e14496080 \
306                            sha256  852aa5229722269d70daed3c04b95e9dc7b7013efd62ebc4f2873a81768b9a12
307
308    description             A raw binding for the OpenGL graphics system
309    long_description        \
310        OpenGLRaw is a raw Haskell binding for the OpenGL 3.2 graphics system \
311        and lots of OpenGL extensions. It is basically a 1:1 mapping of \
312        OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw \
313        offers access to all necessary functions, tokens and types plus \
314        a general facility for loading extension entries. The module hierarchy \
315        closely mirrors the naming structure of the OpenGL extensions, making \
316        it easy to find the right module to import. All API entries are loaded \
317        dynamically, so no special C header files are needed for building this \
318        package. If an API entry is not found at runtime, a userError is \
319        thrown.
320}
321
322haskell_platform_port parallel 3.2.0.4 1 {
323    checksums               rmd160  4bc31de0b3dd63ca8d24c967f32a2ee40f0a2d64 \
324                            sha256  8cdb637fc04e4dd62f9deb0fe3c191b8068526009960f297f54dc9cf5616146d
325
326    description             Parallel programming library
327    long_description        This package provides a library for parallel programming.
328}
329
330haskell_platform_port parsec 3.1.5 1 {
331    checksums               rmd160  4d27dffd266c38cc3266ea17b792e00f180b3968 \
332                            sha256  c572245d72bc3aff3491ce4f89215fcaa1e01c5e7b280d4c105a87db31793cb8
333
334    depends_lib-append      port:hs-mtl \
335                            port:hs-text
336
337    description             Monadic parser combinators
338    long_description        \
339        Parsec is designed from scratch as an industrial-strength parser \
340        library. It is simple, safe, well documented (on the package homepage), \
341        has extensive libraries and good error messages, and is also fast. It \
342        is defined as a monad transformer that can be stacked on arbitrary \
343        monads, and it is also parametric in the input stream type.
344}
345
346haskell_platform_port primitive 0.5.2.1 1 {
347    checksums               rmd160  b456047baa641acc897a871cc2212f9f3a2c576f \
348                            sha256  0e516b81c2ef2c96d47dc40561663cc2cbfece0f135948e77e9b53025ff1c3ee
349
350    description             Primitive memory-related operations
351    long_description        This package provides various primitive memory-related operations.
352}
353
354haskell_platform_port QuickCheck 2.6 3 {
355    checksums               rmd160  94bab2dcefdd7a6eddd5af7211db1babf39e0df8 \
356                            sha256  8001c00a1892714d914e5007ba72cdd428c1ea4c6b8418c6cb5e7809753d970d
357
358    depends_lib-append      port:hs-random
359
360    description             Automatic testing of Haskell programs
361    long_description        \
362        QuickCheck is a library for random testing of program properties. The \
363        programmer provides a specification of the program, in the form of \
364        properties which functions should satisfy, and QuickCheck then tests \
365        that the properties hold in a large number of randomly generated cases.
366}
367
368haskell_platform_port random 1.0.1.1 5 {
369    checksums               rmd160  a13a4d7fefd15611cf863f11caf212efede320c3 \
370                            sha256  df7c3b405de0ac27a2ee8fdc8dad87cb42e8eac01fef53861e43bc47c8111559
371
372    description             random number library
373    long_description        \
374        This package provides a basic random number generation library, including \
375        the ability to split random number generators.
376}
377
378haskell_platform_port regex-base 0.93.2 5 {
379    checksums               rmd160  c009e193dd453666c7c3b585a25f3a8add7ec6b6 \
380                            sha256  20dc5713a16f3d5e2e6d056b4beb9cfdc4368cd09fd56f47414c847705243278
381
382    depends_lib-append      port:hs-mtl
383
384    description             Replaces/Enhances Text.Regex
385    long_description        Interface API for regex-posix,pcre,parsec,tdfa,dfa
386}
387
388haskell_platform_port regex-compat 0.95.1 5 {
389    checksums               rmd160  b2fe02ca3c4e9027b2d433c8a265b19a85c8bd17 \
390                            sha256  d57cb1a5a4d66753b18eaa37a1621246f660472243b001894f970037548d953b
391
392    depends_lib-append      port:hs-regex-base \
393                            port:hs-regex-posix
394
395    description             Replaces/Enhances Text.Regex
396    long_description        One module layer over regex-posix to replace Text.Regex
397}
398
399haskell_platform_port regex-posix 0.95.2 4 {
400    checksums               rmd160  7ee59eb760bb8c0c7fe17e17d90eb0623b9fd5bb \
401                            sha256  56019921cd4a4c9682b81ec614236fea816ba8ed8785a1640cd66d8b24fc703e
402
403    depends_lib-append      port:hs-regex-base
404
405    description             Replaces/Enhances Text.Regex
406    long_description        The posix regex backend for regex-base
407}
408
409haskell_platform_port split 0.2.2 3 {
410    checksums               rmd160  7d4fe221283836386807f0e73a90df1255061f6f \
411                            sha256  f9cf9e571357f227aed5be9a78f5bbf78ef55c99df2edf7fdc659acc1f904375
412
413    description             Combinator library for splitting lists.
414    long_description        \
415        A collection of various methods for splitting lists into parts, akin to \
416        the "split" function found in several mainstream languages.
417}
418
419haskell_platform_port stm 2.4.2 3 {
420    checksums               rmd160  7d49257f7e2de7cf18e02dc3ceeb4619d7980dd8 \
421                            sha256  c8ee3cd64c266133902619cfff2d04e5f66206f91dbce8dd1182037fbe4858db
422
423    description             Software Transactional Memory
424    long_description        A modular composable concurrency abstraction.
425}
426
427haskell_platform_port syb 0.4.1 1 {
428    checksums               rmd160  4ed2329f3c915adb91fb5b1f6b3735e219d1fdd6 \
429                            sha256  aa32cb3d9a0cbcfb24ac1c5d567886e8908dd017fd009ffd446bff86732670d2
430
431    description             Scrap Your Boilerplate
432    long_description        \
433        This package contains the generics system described in the Scrap Your \
434        Boilerplate papers (see \
435        http://www.cs.uu.nl/wiki/GenericProgramming/SYB). It defines the Data \
436        class of types permitting folding and unfolding of constructor \
437        applications, instances of this class for primitive types, and \
438        a variety of traversals.
439}
440
441haskell_platform_port text 1.1.0.0 1 {
442    checksums               rmd160  b57efc9cbf277cd914a9e148129e42ae861771b8 \
443                            sha256  80f1ada824f0e3886bb49dc7fd128707ca1a34e06bbf4419873b1677c4d7ba92
444
445    description             An efficient packed Unicode text type
446    long_description        \
447        An efficient packed, immutable Unicode text type (both strict and lazy), \
448        with a powerful loop fusion optimization framework.
449}
450
451haskell_platform_port unordered-containers 0.2.4.0 1 {
452    checksums               rmd160  0d62b6b8f95e65890e07934413cd1377ed1e85e5 \
453                            sha256  34eaeb0c96d84169aca7085cf21f89bedb4bdb4de2ac78358a087faeea93cdf4
454
455    depends_lib-append      port:hs-hashable
456
457    description             Efficient hashing-based container types
458    long_description        \
459        Efficient hashing-based container types. The containers have been \
460        optimized for performance critical use, both in terms of large data \
461        quantities and high speed.
462}
463
464haskell_platform_port vector 0.10.9.1 1 {
465    checksums               rmd160  885ba057a05219ae6a35170539c68996d2074668 \
466                            sha256  205656e9741aad406e427e988dbf1665bf5dbdf3e9d574e309c274be4e06bde5
467
468    depends_lib-append      port:hs-primitive
469
470    description             Efficient Arrays
471    long_description        \
472        An efficient implementation of Int-indexed arrays (both mutable and \
473        immutable), with a powerful loop optimisation framework.
474}
475
476haskell_platform_port zlib 0.5.4.1 4 {
477    checksums               rmd160  9ed49e79e239604958a9c385cca75747fafc2713 \
478                            sha256  cca365e4c52c90be41a5754943134da5ce6c60bb52fa00c128fd118e0505a550
479
480    depends_lib-append      port:zlib
481
482    description             Compression and decompression in the gzip and zlib formats
483    long_description        \
484        This package provides a pure interface for compressing and \
485        decompressing streams of data represented as lazy ByteStrings. It uses \
486        the zlib C library so it has high performance. It supports the \"zlib\", \
487        \"gzip\" and \"raw\" compression formats.
488}
489
490######################
491# Programs and Tools #
492######################
493
494haskell_platform_tool cabal-install 1.18.0.5 1 {
495    checksums               rmd160  f07279510e03678ad5e3720d9e01707681f874ea \
496                            sha256  477df8ef73916e8bc23c727280a1700939131a3e2809a057668c883b0b521782
497
498    depends_lib-append      port:hs-http \
499                            port:hs-mtl \
500                            port:hs-network \
501                            port:hs-random \
502                            port:hs-stm \
503                            port:hs-zlib
504
505    description             The command-line interface for Cabal and Hackage
506    long_description        \
507        The 'cabal' command-line program simplifies the process of managing Haskell \
508        software by automating the fetching, configuration, compilation and \
509        installation of Haskell libraries and programs.
510}
511
512haskell_platform_tool alex 3.1.3 1 {
513    checksums               rmd160  2325ccfc770264c517d2dfa38cece9376d4e252d \
514                            sha256  8d41a6e72a016155f00c846f7146ab4b27fe9640668a4b592d6a9b856f970a92
515
516    depends_lib-append      port:hs-quickcheck
517
518    description             A tool for generating lexical analysers in Haskell
519    long_description        \
520        Alex is a tool for generating lexical analysers in Haskell. It takes \
521        a description of tokens based on regular expressions and generates \
522        a Haskell module containing code for scanning text efficiently. It is \
523        similar to the tool lex or flex for C/C++.
524}
525
526haskell_platform_tool happy 1.19.4 1 {
527    checksums               rmd160  8ec09c4743d85ae493354e49df07f0ee423267cf \
528                            sha256  6be499f66c61f8c48cbbbcb70515eb8e62c2bfa08adcc8c9474e7ae343a6936d
529
530    depends_lib-append      port:hs-mtl
531    description             A parser generator for Haskell
532    long_description        \
533        Happy is a parser generator for Haskell. Given a grammar specification \
534        in BNF, Happy generates Haskell code to parse the grammar. Happy works \
535        in a similar way to the yacc tool for C.
536}
537
538haskell_platform_tool hscolour 1.20.3 1 {
539    checksums               rmd160  2d875ecdb910a5955a5ec049935a74c60edbc4cc \
540                            sha256  3adb816fba3ecdf9f1ee5fb23feb0611b0762f7e8c2a282c2def5cc2f5483d96
541
542    license                 GPL-2+
543
544    description             Colourise Haskell code
545    long_description        \
546        hscolour is a small Haskell script to colourise Haskell code. It \
547        currently has six output formats: ANSI terminal codes (optionally \
548        XTerm-256colour codes), HTML 3.2 with font tags, HTML 4.01 with CSS, \
549        HTML 4.01 with CSS and mouseover annotations, XHTML 1.0 with inline CSS \
550        styling, LaTeX, and mIRC chat codes.
551}
Note: See TracBrowser for help on using the repository browser.