Changeset 106818


Ignore:
Timestamp:
Jun 8, 2013, 11:25:32 PM (4 years ago)
Author:
cal@…
Message:

haskell platform: update to 2013.2.0.0

Since this updates ghc, every haskell port needs to be revbumped. In order to
avoid a huge monster commit and due to the number of revbumps required I will
do this as time permits.

This change also renames all ports provided by the platform to hs-$pkgname
instead of hs-platform-$pkgname. We should rather have one well-maintained and
high-quality release rather than two conflicting and hardly interoperable
versions. This change will break all ports that currently depend on
a haskell-platform-$pkgname port.

This change also merges all ports provided by the haskell platform (except for
GHC) into a single Portfile using subports. This should simplify further
updates of the platform.

Location:
trunk/dports
Files:
1 deleted
37 edited
2 copied

Legend:

Unmodified
Added
Removed
  • trunk/dports/_resources/port1.0/group/haskellplatform-2.0.tcl

    r106705 r106818  
    3131#
    3232# Usage:
    33 # PortGroup                 haskell-platform 1.0
     33# PortGroup                 haskell-platform 2.0
    3434# haskellplatform.setup     haskell_package version [register_scripts]
    3535# where haskell_package is the name of the package (eg, digest), version is the
     
    4646    global homepage prefix configure.cmd configure.cc destroot worksrcpath name master_sites
    4747
    48     name                hs-platform-[string tolower ${package}]
     48        # don't set name, that will prevent using this in subports
    4949    version             ${version}
    5050    categories          devel haskell
     
    7272            system "cd ${worksrcpath} && ${configure.cmd} Setup register --gen-script"
    7373            system "cd ${worksrcpath} && ${configure.cmd} Setup unregister --gen-script"
    74             xinstall -m 755 -d ${destroot}${prefix}/libexec/${name}
     74            xinstall -m 755 -d ${destroot}${prefix}/libexec/${subport}
    7575            xinstall -m 755 -W ${worksrcpath} register.sh unregister.sh \
    76                 ${destroot}${prefix}/libexec/${name}
     76                ${destroot}${prefix}/libexec/${subport}
    7777        }
    78         post-activate {
    79             system "${prefix}/libexec/${name}/register.sh"
     78                post-activate {
     79            system "${prefix}/libexec/${subport}/register.sh"
    8080        }
    8181        pre-deactivate {
    82             system "${prefix}/libexec/${name}/unregister.sh"
     82            system "${prefix}/libexec/${subport}/unregister.sh"
    8383        }
    8484        }
     
    8787    livecheck.type      none
    8888}
    89 
  • trunk/dports/devel/haskell-platform/Portfile

    r100372 r106818  
    55
    66name            haskell-platform
    7 version         2012.4.0.0
    8 categories      devel haskell
    9 maintainers     cal openmaintainer
    10 description     \
    11     The Haskell Platform is the easiest way to get started with programming \
    12     Haskell. It comes with all you need to get up and running. Think of it as \
    13     \"Haskell: batteries included\".
    14 long_description \
    15     The Haskell Platform is a comprehensive, robust development environment for \
    16     programming in Haskell. For new users the platform makes it trivial to get \
    17     up and running with a full Haskell development environment. For experienced \
    18     developers, the platform provides a comprehensive, standard base for \
    19     commercial and open source Haskell development that maximises \
    20     interoperability and stability of your code.
    21 
    22 platforms       darwin
    23 homepage        http://hackage.haskell.org/platform/
    24 master_sites    ${homepage}
    25 license         Permissive
    26 
    27 depends_run     port:ghc \
    28                 port:hs-platform-alex \
    29                 port:hs-platform-async \
    30                 port:hs-platform-cabal \
    31                 port:hs-platform-cgi \
    32                 port:hs-platform-fgl \
    33                 port:hs-platform-glut \
    34                 port:hs-platform-happy \
    35                 port:hs-platform-haskell-src \
    36                 port:hs-platform-html \
    37                 port:hs-platform-http \
    38                 port:hs-platform-hunit \
    39                 port:hs-platform-mtl \
    40                 port:hs-platform-network \
    41                 port:hs-platform-opengl \
    42                 port:hs-platform-parallel \
    43                 port:hs-platform-parsec \
    44                 port:hs-platform-quickcheck \
    45                 port:hs-platform-random \
    46                 port:hs-platform-regex-base \
    47                 port:hs-platform-regex-compat \
    48                 port:hs-platform-regex-posix \
    49                 port:hs-platform-split \
    50                 port:hs-platform-stm \
    51                 port:hs-platform-syb \
    52                 port:hs-platform-text \
    53                 port:hs-platform-transformers \
    54                 port:hs-platform-vector \
    55                 port:hs-platform-xhtml \
    56                 port:hs-platform-zlib
    57 
    58 fetch {}
    59 checksum {}
    60 extract {}
    61 configure {}
    62 build {}
    63 destroot {
    64     xinstall -d ${destroot}${prefix}/share/doc/${name}
    65     system "echo ${long_description} > ${destroot}${prefix}/share/doc/${name}/README.txt"
    66 }
    67 
    68 use_configure       no
    69 universal_variant   no
    70 
    71 livecheck.type      regex
    72 livecheck.url       ${homepage}
    73 livecheck.regex     "Current release: <a href=\"changelog.html\">(\\d+\\.\\d\\.\\d\\.\\d)</a>"
     7
     8if {$subport == $name} {
     9    version         2013.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    uplevel 1 "
     61        subport hs-[string tolower ${pkgname}] {
     62            PortGroup               haskellplatform 2.0
     63            haskellplatform.setup   ${pkgname} ${pkgversion}
     64            revision                ${pkgrevision}
     65
     66            # Make sure to check this for every port!
     67            license                 BSD
     68            maintainers             cal openmaintainer
     69            platforms               darwin
     70
     71            pre-activate {
     72                # deactivate hs-platform versions of these ports; they are outdated.
     73                # deactivate hack added 2013-06-06
     74                if {!\[catch {set installed \[lindex \[registry_active hs-platform-[string tolower ${pkgname}]] 0]}]} {
     75                    registry_deactivate_composite hs-platform-[string tolower ${pkgname}] \"\" \[list ports_nodepcheck 1]
     76                }
     77            }
     78
     79            ${block}
     80        }
     81
     82        if {\${subport} == \${name}} {
     83            depends_run-append  port:hs-${pkgname}
     84        }
     85    "
     86}
     87
     88##
     89# Helper proc for tools and programs in the Haskell Platform. This behaves
     90# exactly like \c haskell_platform_port, with the execption of passing "no" as
     91# third argument to \c haskellplatform.setup of the haskellplatform PortGroup.
     92#
     93# @param[in] pkgname     the name of the haskell package, case-sensitive
     94# @param[in] pkgversion  the version to be packaged in haskell platform
     95# @param[in] pkgrevision the current revision of the port in MacPorts
     96# @param[in] block       a block of code to be executed in the subport, optional
     97proc haskell_platform_tool {pkgname pkgversion pkgrevision {block {}}} {
     98    uplevel 1 "
     99        subport hs-[string tolower ${pkgname}] {
     100            PortGroup               haskellplatform 2.0
     101            haskellplatform.setup   ${pkgname} ${pkgversion} no
     102            revision                ${pkgrevision}
     103
     104            # Make sure to check this for every port!
     105            license                 BSD
     106            maintainers             cal openmaintainer
     107            platforms               darwin
     108
     109            pre-activate {
     110                # deactivate hs-platform versions of these ports; they are outdated.
     111                # deactivate hack added 2013-06-06
     112                if {!\[catch {set installed \[lindex \[registry_active hs-platform-[string tolower ${pkgname}]] 0]}]} {
     113                    registry_deactivate_composite hs-platform-[string tolower ${pkgname}] \"\" \[list ports_nodepcheck 1]
     114                }
     115            }
     116
     117            ${block}
     118        }
     119
     120        if {\${subport} == \${name}} {
     121            depends_run-append  port:hs-${pkgname}
     122        }
     123    "
     124}
     125
     126
     127#################################
     128# Additional Platform Libraries #
     129#################################
     130
     131haskell_platform_port async 2.0.1.4 0 {
     132    checksums               rmd160  8a28038e3193ee6de2212afb42f25fc444a2ef1d \
     133                            sha256  41ddfe012d98f3ef101651fb529753bca5bb4c804f03f9cfafc5d0cbe50224c2
     134
     135    depends_lib-append      port:hs-stm
     136
     137    description             Run IO operations asynchronously and wait for their results
     138    long_description        \
     139        This package provides a higher-level interface over threads, in which an \
     140        Async a is a concurrent thread that will eventually deliver a value of type \
     141        a. The package provides ways to create Async computations, wait for their \
     142        results, and cancel them. \
     143        Using Async is safer than using threads in two ways:\n\
     144        - When waiting for a thread to return a result, if the thread dies with an \
     145        exception then the caller must either re-throw the exception (wait) or \
     146        handle it (waitCatch)\; the exception cannot be ignored.\n\
     147        - The API makes it possible to build a tree of threads that are \
     148        automatically killed when their parent dies (see withAsync).
     149}
     150
     151haskell_platform_port attoparsec 0.10.4.0 0 {
     152    checksums               rmd160  1fc9845e60fb0cddc9ffa8838c446b3046cd3522 \
     153                            sha256  b6b84e0dbd1c3beec1dedea578ac2f4d62afbe66b383582b7b3349406866d346
     154
     155    depends_lib-append      port:hs-text
     156
     157    description             Fast combinator parsing for bytestrings and text
     158    long_description        \
     159        A fast parser combinator library, aimed particularly at dealing \
     160        efficiently with network protocols and complicated text/binary file \
     161        formats.
     162}
     163
     164haskell_platform_port case-insensitive 1.0.0.1 0 {
     165    checksums               rmd160  890cc0d0c3d8e0470956f7bce2da70c3adf8e90c \
     166                            sha256  b58f62516779580a41cdc67a979c509125adf139b8f50d415495f58d4b42e8fa
     167
     168    depends_lib-append      port:hs-hashable \
     169                            port:hs-text
     170
     171    description             Case insensitive string comparison
     172    long_description        \
     173        The module Data.CaseInsensitive provides the CI type constructor which \
     174        can be parameterised by a string-like type like: String, ByteString, \
     175        Text, etc.. Comparisons of values of the resulting type will be \
     176        insensitive to cases.
     177}
     178
     179haskell_platform_port cgi 3001.1.7.5 0 {
     180    checksums               rmd160  76823f125e750f648d967f833a5c6a11814d8b56 \
     181                            sha256  5126e2eaa53cd5de59572981c00aedae5790882afda67545228eb29fe76faffd
     182
     183    depends_lib-append      port:hs-mtl \
     184                            port:hs-parsec \
     185                            port:hs-network \
     186                            port:hs-xhtml
     187
     188    description             A library for writing CGI programs
     189    long_description        This is a Haskell library for writing CGI programs.
     190}
     191
     192haskell_platform_port fgl 5.4.2.4 2 {
     193    checksums               rmd160  e2b9e0d1d43e69b250719a34c6de9344b38264bf \
     194                            sha256  ce98ccb83e2d271a7b3266426a0762a0e902252f07ec09b7bef50c67d0110266
     195
     196    depends_lib-append      port:hs-mtl
     197
     198    description             Martin Erwig's Functional Graph Library
     199    long_description        ${description}
     200}
     201
     202haskell_platform_port GLUT 2.4.0.0 0 {
     203    checksums               rmd160  b1f4449f2bacbbbf51ffd5146c1f7ccafd6d0348 \
     204                            sha256  100df2d724dfad26b0c8d47b17d4cef9dcbc12a75cce7a096046c27485b4cbbc
     205
     206    depends_lib-append      port:hs-opengl
     207
     208    description             A binding for the OpenGL Utility Toolkit
     209    long_description        \
     210        A Haskell binding for the OpenGL Utility Toolkit, a window system \
     211        independent toolkit for writing OpenGL programs.
     212}
     213
     214haskell_platform_port GLURaw 1.3.0.0 0 {
     215    checksums               rmd160  2aa60cb5a779ee858a9e1bcadfe3b2bfccfbd167 \
     216                            sha256  e03905710043eb2e9878e5fc75f969c4f120321bc6a7709cde3a9890be3c08ea
     217
     218    depends_lib-append      port:hs-openglraw
     219
     220    description             A raw binding for the OpenGL graphics system
     221    long_description        \
     222        GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL utility library. \
     223        It is basically a 1:1 mapping of GLU's C API, intended as a basis for \
     224        a nicer interface.
     225}
     226
     227haskell_platform_port hashable 1.1.2.5 0 {
     228    checksums               rmd160  93b4faee93a046445458e9f9c67820b458242aac \
     229                            sha256  3fb5d430c9289ebada4991a76fd78f028aaaf17957dc666ddc7b89c98a54713d
     230
     231    depends_lib-append      port:hs-text
     232
     233    description             A class for types that can be converted to a hash value
     234    long_description        \
     235        This package defines a class, Hashable, for types that can be converted \
     236        to a hash value. This class exists for the benefit of hashing-based \
     237        data structures. The package provides instances for basic types and \
     238        a way to combine hash values.
     239}
     240
     241haskell_platform_port haskell-src 1.0.1.5 2 {
     242    checksums               rmd160  32a53bab9f1e150565cbed0c926816e4089dd966 \
     243                            sha256  9f3726902247cc955d085997254bb58c16cc337ee83de5ccfb17dcbcb488c3ab
     244
     245    depends_lib-append      port:hs-syb
     246
     247    description             Support for manipulating Haskell source code
     248    long_description        \
     249        The haskell-src package provides support for manipulating Haskell \
     250        source code. The package provides a lexer, parser and pretty-printer, \
     251        and a definition of a Haskell abstract syntax tree (AST). Common uses \
     252        of this package are to parse or generate Haskell 98 code.
     253}
     254
     255haskell_platform_port html 1.0.1.2 3 {
     256    checksums               rmd160  55d95a42c297c9c4b0b0c3bbd077a5ed59e48878 \
     257                            sha256  0c35495ea33d65e69c69bc7441ec8e1af69fbb43433c2aa3406c0a13a3ab3061
     258
     259    description             HTML combinator library
     260    long_description        \
     261        This package contains a combinator library for constructing HTML documents.
     262}
     263
     264haskell_platform_port HTTP 4000.2.8 0 {
     265    checksums               rmd160  844041fdfb257c19cf35be24976925bc9c0c43c6 \
     266                            sha256  086a2aa771a31845b190e2f9651ab4d8e85116aa463de5bc5e0204c1e5e70c5c
     267
     268    depends_lib-append      port:hs-network \
     269                            port:hs-mtl \
     270                            port:hs-parsec
     271
     272    description             A library for client-side HTTP
     273    long_description        \
     274        The HTTP package supports client-side web programming in Haskell. It \
     275        lets you set up HTTP connections, transmitting requests and processing \
     276        the responses coming back, all from within the comforts of Haskell. \
     277        It's dependent on the network package to operate, but other than that, \
     278        the implementation is all written in Haskell.
     279}
     280
     281haskell_platform_port HUnit 1.2.5.2 0 {
     282    checksums               rmd160  f6ac9ac12c152609174ea80a3a0c694210c81594 \
     283                            sha256  0af5ad34dba27de48b94ce6d5f7ee3aa6af6183bdc4a3967b811e28520369a41
     284
     285    description             A unit testing framework for Haskell
     286    long_description        \
     287        HUnit is a unit testing framework for Haskell, inspired by the JUnit \
     288        tool for Java, see: http://www.junit.org.
     289}
     290
     291haskell_platform_port mtl 2.1.2 2 {
     292    checksums               rmd160  aa5c576c124b602a605cf3931ac42c1c1eb27cda \
     293                            sha256  8c775764333420a4391823f9cb9b640306a262552280ea9bbdd2ca11194a8bef
     294
     295    depends_lib-append      port:hs-transformers
     296
     297    description             Monad classes, using functional dependencies
     298    long_description        \
     299        Monad classes using functional dependencies, with instances for various \
     300        monad transformers, inspired by the paper Functional Programming with \
     301        Overloading and Higher-Order Polymorphism, by Mark P Jones, in Advanced \
     302        School of Functional Programming, 1995
     303}
     304
     305haskell_platform_port network 2.4.1.2 1 {
     306    checksums               rmd160  27461d006ac9580d55a0f1377774c1ac9c20a024 \
     307                            sha256  b04dc56542428bc92f11263f500b3ad82e6a0787805601472d59af7e769bfe38
     308
     309    depends_lib-append      port:hs-parsec
     310
     311    description             Low-level networking interface
     312    long_description        ${description}
     313}
     314
     315haskell_platform_port OpenGL 2.8.0.0 0 {
     316    checksums               rmd160  3be0a47aea270ce184da50007dd729814ef99aaa \
     317                            sha256  ce753d8db75b5096e030422765193c4975779b42bfffa467408a40d8c43965f1
     318
     319    depends_lib-append      port:hs-gluraw \
     320                            port:hs-openglraw
     321
     322    description             A binding for the OpenGL graphics system
     323    long_description        \
     324        A Haskell binding for the OpenGL graphics system (GL, version 3.2) and \
     325        its accompanying utility library (GLU, version 1.3).
     326}
     327
     328haskell_platform_port OpenGLRaw 1.3.0.0 0 {
     329    checksums               rmd160  09c08ce9f45acdabdef46e397e72814f5a86e71b \
     330                            sha256  6228ca9ac967350fcb6abac25b8027660ad8599914a60ef0fd10919a6d2cd745
     331
     332    description             A raw binding for the OpenGL graphics system
     333    long_description        \
     334        OpenGLRaw is a raw Haskell binding for the OpenGL 3.2 graphics system \
     335        and lots of OpenGL extensions. It is basically a 1:1 mapping of \
     336        OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw \
     337        offers access to all necessary functions, tokens and types plus \
     338        a general facility for loading extension entries. The module hierarchy \
     339        closely mirrors the naming structure of the OpenGL extensions, making \
     340        it easy to find the right module to import. All API entries are loaded \
     341        dynamically, so no special C header files are needed for building this \
     342        package. If an API entry is not found at runtime, a userError is \
     343        thrown.
     344}
     345
     346haskell_platform_port parallel 3.2.0.3 1 {
     347    checksums               rmd160  a358225292a80bb4223e6ea2f6e0d502e41cab02 \
     348                            sha256  163a40ef3c6258c623abe690a9837c9de2bf7fe87d3fac7d0758229d7efb6dcd
     349
     350    description             Parallel programming library
     351    long_description        This package provides a library for parallel programming.
     352}
     353
     354haskell_platform_port parsec 3.1.3 3 {
     355    checksums               rmd160  b1b407b27f5642142bfa619b31abd7a8cafe11ce \
     356                            sha256  9f14bb4da77eb9b0e4dbe8112559ed49409b0af8e9aef5d08941dd97e37fc4a8
     357
     358    depends_lib-append      port:hs-mtl \
     359                            port:hs-text
     360
     361    description             Monadic parser combinators
     362    long_description        \
     363        Parsec is designed from scratch as an industrial-strength parser \
     364        library. It is simple, safe, well documented (on the package homepage), \
     365        has extensive libraries and good error messages, and is also fast. It \
     366        is defined as a monad transformer that can be stacked on arbitrary \
     367        monads, and it is also parametric in the input stream type.
     368}
     369
     370haskell_platform_port QuickCheck 2.6 0 {
     371    checksums               rmd160  94bab2dcefdd7a6eddd5af7211db1babf39e0df8 \
     372                            sha256  8001c00a1892714d914e5007ba72cdd428c1ea4c6b8418c6cb5e7809753d970d
     373
     374    depends_lib-append      port:hs-random
     375
     376    description             Automatic testing of Haskell programs
     377    long_description        \
     378        QuickCheck is a library for random testing of program properties. The \
     379        programmer provides a specification of the program, in the form of \
     380        properties which functions should satisfy, and QuickCheck then tests \
     381        that the properties hold in a large number of randomly generated cases.
     382}
     383
     384haskell_platform_port random 1.0.1.1 2 {
     385    checksums               rmd160  a13a4d7fefd15611cf863f11caf212efede320c3 \
     386                            sha256  df7c3b405de0ac27a2ee8fdc8dad87cb42e8eac01fef53861e43bc47c8111559
     387         
     388    description             random number library
     389    long_description        \
     390        This package provides a basic random number generation library, including \
     391        the ability to split random number generators.
     392}
     393
     394haskell_platform_port regex-base 0.93.2 2 {
     395    checksums               rmd160  c009e193dd453666c7c3b585a25f3a8add7ec6b6 \
     396                            sha256  20dc5713a16f3d5e2e6d056b4beb9cfdc4368cd09fd56f47414c847705243278
     397
     398    depends_lib-append      port:hs-mtl
     399
     400    description             Replaces/Enhances Text.Regex
     401    long_description        Interface API for regex-posix,pcre,parsec,tdfa,dfa
     402}
     403
     404haskell_platform_port regex-compat 0.95.1 2 {
     405    checksums               rmd160  b2fe02ca3c4e9027b2d433c8a265b19a85c8bd17 \
     406                            sha256  d57cb1a5a4d66753b18eaa37a1621246f660472243b001894f970037548d953b
     407
     408    depends_lib-append      port:hs-regex-base \
     409                            port:hs-regex-posix
     410
     411    description             Replaces/Enhances Text.Regex
     412    long_description        One module layer over regex-posix to replace Text.Regex
     413}
     414
     415haskell_platform_port regex-posix 0.95.2 1 {
     416    checksums               rmd160  7ee59eb760bb8c0c7fe17e17d90eb0623b9fd5bb \
     417                            sha256  56019921cd4a4c9682b81ec614236fea816ba8ed8785a1640cd66d8b24fc703e
     418
     419    depends_lib-append      port:hs-regex-base
     420
     421    description             Replaces/Enhances Text.Regex
     422    long_description        The posix regex backend for regex-base
     423}
     424
     425haskell_platform_port split 0.2.2 0 {
     426    checksums               rmd160  7d4fe221283836386807f0e73a90df1255061f6f \
     427                            sha256  f9cf9e571357f227aed5be9a78f5bbf78ef55c99df2edf7fdc659acc1f904375
     428
     429    description             Combinator library for splitting lists.
     430    long_description        \
     431        A collection of various methods for splitting lists into parts, akin to \
     432        the "split" function found in several mainstream languages.
     433}
     434
     435haskell_platform_port stm 2.4.2 0 {
     436    checksums               rmd160  7d49257f7e2de7cf18e02dc3ceeb4619d7980dd8 \
     437                            sha256  c8ee3cd64c266133902619cfff2d04e5f66206f91dbce8dd1182037fbe4858db
     438
     439    description             Software Transactional Memory
     440    long_description        A modular composable concurrency abstraction.
     441}
     442
     443haskell_platform_port syb 0.4.0 0 {
     444    checksums               rmd160  7814875c994d34b0dd11e378c3d16e009a843d4d \
     445                            sha256  f201089aa7e74b6cbca7fc73a259596b2a9628e31a9b54e801844ad68447bff3
     446
     447    description             Scrap Your Boilerplate
     448    long_description        \
     449        This package contains the generics system described in the Scrap Your \
     450        Boilerplate papers (see \
     451        http://www.cs.uu.nl/wiki/GenericProgramming/SYB). It defines the Data \
     452        class of types permitting folding and unfolding of constructor \
     453        applications, instances of this class for primitive types, and \
     454        a variety of traversals.
     455}
     456
     457haskell_platform_port text 0.11.3.1 0 {
     458    checksums               rmd160  544b6be80db9432dd4c149f81a2c0603e2e67205 \
     459                            sha256  76aad4a647cad7099b5a693eb9a4bc5263f7751392d8d1f87b14c78e2069559f
     460
     461    description             An efficient packed Unicode text type
     462    long_description        \
     463        An efficient packed, immutable Unicode text type (both strict and lazy), \
     464        with a powerful loop fusion optimization framework.
     465}
     466
     467haskell_platform_port transformers 0.3.0.0 2 {
     468    checksums               rmd160  110bd7eb44609d8db44d85f8367db323576545dc \
     469                            sha256  e5aa0c1ec97ad98c389e78f59aca25ab028980a7068a3e585e39564662739591
     470
     471     description            Concrete functor and monad transformers
     472     long_description       \
     473        A portable library of functor and monad transformers, inspired by the \
     474        paper \"Functional Programming with Overloading and Higher-Order \
     475        Polymorphism\", by Mark P Jones, in Advanced School of Functional \
     476        Programming, 1995 \
     477        (http://web.cecs.pdx.edu/~mpj/pubs/springschool.html).
     478}
     479
     480haskell_platform_port unordered-containers 0.2.3.0 1 {
     481    checksums               rmd160  91b7d7c2138de34b3b690efe294d90022e04d8b3 \
     482                            sha256  edb6a442ef9fcf4ce59f66871d51df5c012345fce95970127e75b62e5396efef
     483
     484    depends_lib-append      port:hs-hashable
     485
     486    description             Efficient hashing-based container types
     487    long_description        \
     488        Efficient hashing-based container types. The containers have been \
     489        optimized for performance critical use, both in terms of large data \
     490        quantities and high speed.
     491}
     492
     493haskell_platform_port vector 0.10.0.1 1 {
     494    checksums               rmd160  e00adaf6b4a9634df2feb1a805f4adf51d1870ae \
     495                            sha256  ece945058b01a77c5fff31e89bbea76ac619677041c41286a2da5e8b515508af
     496
     497    depends_lib-append      port:hs-primitive
     498
     499    description             Efficient Arrays
     500    long_description        \
     501        An efficient implementation of Int-indexed arrays (both mutable and \
     502        immutable), with a powerful loop optimisation framework.
     503}
     504
     505haskell_platform_port xhtml 3000.2.1 2 {
     506    checksums               rmd160  72e1095df0a8111ea696749d219df4ea78da1b4f \
     507                            sha256  33020782170c1c083bc59fc3bfcb72cec2db223e02d1181c07ae23b9fa7fdcd8
     508
     509    description             An XHTML combinator library
     510    long_description        \
     511        This package provides combinators for producing XHTML 1.0, including the \
     512        Strict, Transitional and Frameset variants.
     513}
     514
     515haskell_platform_port zlib 0.5.4.1 1 {
     516    checksums               rmd160  9ed49e79e239604958a9c385cca75747fafc2713 \
     517                            sha256  cca365e4c52c90be41a5754943134da5ce6c60bb52fa00c128fd118e0505a550
     518
     519    depends_lib-append      port:zlib
     520
     521    description             Compression and decompression in the gzip and zlib formats
     522    long_description        \
     523        This package provides a pure interface for compressing and \
     524        decompressing streams of data represented as lazy ByteStrings. It uses \
     525        the zlib C library so it has high performance. It supports the \"zlib\", \
     526        \"gzip\" and \"raw\" compression formats.
     527}
     528
     529######################
     530# Programs and Tools #
     531######################
     532
     533haskell_platform_tool cabal-install 1.16.0.2 0 {
     534    checksums               rmd160  2e19f5086cbf7f4ea9c17bf804ec6da886cd2f51 \
     535                            sha256  66dfacc9f33e668e56904072cadb8a36bd9d6522ba5464c6a36a5de7e65c5698
     536
     537    depends_lib-append      port:hs-http \
     538                            port:hs-mtl \
     539                            port:hs-network \
     540                            port:hs-random \
     541                            port:hs-zlib
     542
     543    description             The command-line interface for Cabal and Hackage
     544    long_description        \
     545        The 'cabal' command-line program simplifies the process of managing Haskell \
     546        software by automating the fetching, configuration, compilation and \
     547        installation of Haskell libraries and programs.
     548}
     549
     550haskell_platform_tool alex 3.0.5 0 {
     551    checksums               rmd160  3f543c6af966f6200f84f408022d62beaefb875f \
     552                            sha256  c3326417a0538e355e5ad1871ab931b9c8145391e8b2ff79668eb643d9b99659
     553
     554    depends_lib-append      port:hs-quickcheck
     555
     556    description             A lexical analyser generator for Haskell
     557    long_description        \
     558        Alex is a tool for generating lexical analysers in Haskell, given \
     559        a description of the tokens to be recognised in the form of regular \
     560        expressions. It is similar to the tool lex or flex for C/C++.
     561}
     562
     563haskell_platform_tool happy 1.18.10 1 {
     564    checksums               rmd160  3c113721ccacbe33bfbc25287bfe9bf74cc365f7 \
     565                            sha256  c1c920f77906740252e261e2baec5b7519e584344d6080aa5a9cc0b677b9064b
     566
     567    depends_lib-append      port:hs-mtl
     568    description             \
     569        Happy is a parser generator system for Haskell, similar to the tool `yacc' \
     570        for C. Like `yacc', it takes a file containing an annotated BNF \
     571        specification of a grammar and produces a Haskell module containing \
     572        a parser for the grammar.
     573    long_description        ${description} \
     574        Happy is flexible: you can have several Happy parsers in the same program, \
     575        and several entry points to a single grammar. Happy can work in conjunction \
     576        with a lexical analyser supplied by the user (either hand-written or \
     577        generated by another program), or it can parse a stream of characters \
     578        directly (but this isn't practical in most cases).
     579}
  • trunk/dports/devel/hs-cabal/Portfile

    r97011 r106818  
    44PortSystem          1.0
    55
    6 # hs-cabal installs an executable, not a library, so PortGroup haskell
    7 # is inappropriate.
    8 
    96name                hs-cabal
    10 set canonicalname   cabal-install
    117version             0.14.0
     8license             Permissive
    129categories          devel haskell
    13 maintainers         gwright
    14 platforms           darwin
    15 license             BSD
    16 description         User interface to Haskell's Cabal build system.
    17 long_description    \
    18     The 'cabal' command-line program simplifies the process of managing \
    19     Haskell software by automating the fetching, configuration, \
    20     compilation and installation of Haskell libraries and programs.
    21 
    22 homepage            http://www.haskell.org/cabal
    23 master_sites        http://hackage.haskell.org/packages/archive/${canonicalname}/${version}
    24 distname            ${canonicalname}-${version}
    25 
    26 checksums           sha256  f4f2b50269ff59d67b5f3d82d50f7706b6bad1117295a7c81f32bbe72add5bd8 \
    27                     rmd160  a0e1e0f0d189abbb984d968f8650280632027769
    28 
    29 universal_variant   no
    30 
    31 depends_lib         port:hs-zlib \
    32                     port:hs-HTTP \
    33                     port:hs-random
    34 
    35 configure {
    36     system -W ${worksrcpath} "runhaskell Setup configure -v --ghc --prefix=${prefix} --with-gcc=${configure.cc} --program-suffix=\"-${version}\""
    37 }
    38 
    39 build {
    40     system -W ${worksrcpath} "runhaskell Setup build -v"
    41 }
    42 
    43 destroot {
    44     system -W ${worksrcpath} "runhaskell Setup copy -v --destdir=${destroot}"
    45 }
     10replaced_by         hs-cabal-install
     11PortGroup           obsolete 1.0
  • trunk/dports/devel/hs-crypto/Portfile

    r104492 r106818  
     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
    12# $Id$
    23
    3 PortSystem 1.0
     4PortSystem          1.0
     5PortGroup           haskell 1.0
    46
    5 PortGroup       haskell 1.0
    6 haskell.setup   Crypto 4.2.5.1
    7 name            hs-Crypto
    8 maintainers     nomaintainer
    9 platforms       darwin
     7haskell.setup       Crypto 4.2.5.1
     8checksums           rmd160  adcbd51eb0656427a5e794fc2946dcbdd7e6ebe5 \
     9                    sha256  6ad5e0533d0aaaf2f30049d166881a845cc190780798661815da9b4914a0af66
     10
     11maintainers         nomaintainer
     12platforms           darwin
    1013license             Permissive
    1114
    12 description     The Haskell Cryptographic Library.
    13 long_description        \
    14                 The Haskell Cryptographic Library collects together     \
    15                 existing Haskell cryptographic functions into one       \
    16                 cabalized package, together with HUnit tests,           \
    17                 QuickCheck property tests, examples showing how to      \
    18                 interwork with other cryptographic implementations      \
    19                 and examples showing how to handle other ASN.1 definitions.
     15description         Collects together existing Haskell cryptographic functions into a package
     16long_description    \
     17    DES, Blowfish, AES, TEA, SHA1, MD5, RSA, BubbleBabble, Hexdump, Support for \
     18    Word128, Word192 and Word256 and Beyond, PKCS5 Padding, Various Encryption \
     19    Modes e.g. Cipher Block Chaining all in one package, with HUnit and \
     20    QuickCheck tests, and examples.
    2021
    21 checksums       rmd160  adcbd51eb0656427a5e794fc2946dcbdd7e6ebe5 \
    22                 sha256  6ad5e0533d0aaaf2f30049d166881a845cc190780798661815da9b4914a0af66
    23 
    24 depends_lib-append      port:hs-platform-HUnit          \
    25                         port:hs-QuickCheck
     22depends_lib-append  port:hs-hunit \
     23                    port:hs-quickcheck
  • trunk/dports/devel/hs-platform-alex/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   alex 3.0.2 no
    8 checksums               rmd160  d564c8bc61a0b8839ac618370a8b27f78c4912cf \
    9                         sha256  997e33342c3c6e0edfff862f051fc286bd661f442d09d1bc02cd6e9d22083164
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 depends_lib-append      port:hs-platform-quickcheck
    16 
    17 description             \
    18     Alex is a tool for generating lexical analysers in Haskell, given \
    19     a description of the tokens to be recognised in the form of regular \
    20     expressions. It is similar to the tool lex or flex for C/C++.
    21 long_description        ${description}
     6name                    hs-platform-alex
     7version                 3.0.2
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-alex
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-async/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   async 2.0.1.3
    8 checksums               rmd160  249b3d7e38cd770249868bcff22bf6add1f12fbf \
    9                         sha256  70d681084aca826c84d722320fc5d67ac6294802afbb13f8b5e8eac2bbc972e5
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 depends_lib-append      port:hs-platform-stm
    16 
    17 description             \
    18    This package provides a higher-level interface over threads, in which an \
    19    Async a is a concurrent thread that will eventually deliver a value of type \
    20    a. The package provides ways to create Async computations, wait for their \
    21    results, and cancel them.
    22 long_description        ${description} \
    23     Using Async is safer than using threads in two ways:\n\
    24     - When waiting for a thread to return a result, if the thread dies with an \
    25     exception then the caller must either re-throw the exception (wait) or \
    26     handle it (waitCatch)\; the exception cannot be ignored.\n\
    27     - The API makes it possible to build a tree of threads that are \
    28     automatically killed when their parent dies (see withAsync).
     6name                    hs-platform-async
     7version                 2.0.1.3
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-async
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-cabal/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   cabal-install 0.14.0 no
     6name                    hs-platform-cabal
     7version                 0.14.0
    88revision                1
    9 name                    hs-platform-cabal
    10 checksums               rmd160  a0e1e0f0d189abbb984d968f8650280632027769 \
    11                         sha256  f4f2b50269ff59d67b5f3d82d50f7706b6bad1117295a7c81f32bbe72add5bd8
    12 
    13 license                 BSD
    14 maintainers             cal openmaintainer
    15 platforms               darwin
    16 
    17 depends_lib-append      port:hs-platform-http \
    18                         port:hs-platform-mtl \
    19                         port:hs-platform-network \
    20                         port:hs-platform-random \
    21                         port:hs-platform-zlib
    22 
    23 description             \
    24     The 'cabal' command-line program simplifies the process of managing Haskell \
    25     software by automating the fetching, configuration, compilation and \
    26     installation of Haskell libraries and programs.
    27 long_description        ${description}
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-cabal-install
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-cgi/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   cgi 3001.1.7.4
     6name                    hs-platform-cgi
     7version                 3001.1.7.4
    88revision                1
    9 checksums               rmd160  a3df4f40c3e7cad6f1a22b7bd090e39968ffc241 \
    10                         sha256  6de5da8be4bb8323a864761bbb604ca8c1cdc9048bf33990f91e7ed948a331ba
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 depends_lib-append      port:hs-platform-mtl \
    17                         port:hs-platform-parsec \
    18                         port:hs-platform-network \
    19                         port:hs-platform-xhtml
    20 
    21 description             This is a Haskell library for writing CGI programs.
    22 long_description        ${description}
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-cgi
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-fgl/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    6 
    7 haskellplatform.setup   fgl 5.4.2.4
     5name                    hs-platform-fgl
     6version                 5.4.2.4
    87revision                1
    9 checksums               rmd160  e2b9e0d1d43e69b250719a34c6de9344b38264bf \
    10                         sha256  ce98ccb83e2d271a7b3266426a0762a0e902252f07ec09b7bef50c67d0110266
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 depends_lib-append      port:hs-platform-mtl
    17 
    18 description
    19 long_description
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-fgl
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-ghc/Portfile

    r100372 r106818  
    1111
    1212categories              devel lang haskell
    13 license                 BSD
     13license                 Permissive
  • trunk/dports/devel/hs-platform-glut/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   GLUT 2.1.2.1
     6name                    hs-platform-glut
     7version                 2.1.2.1
    88revision                1
    9 checksums               rmd160  f9d207c21bd7c6971efc53c0f9dd01f8426752c1 \
    10                         sha256  0230bfacbfb85c126f1fba45fcd8d02f20da9ee19180b5ada698224362d17264
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 depends_lib-append      port:hs-platform-opengl
    17 
    18 description             A Haskell binding for the OpenGL Utility Toolkit, a window system independent toolkit for writing OpenGL programs.
    19 long_description        ${description}
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-glut
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-happy/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   happy 1.18.10 no
    8 checksums               rmd160  3c113721ccacbe33bfbc25287bfe9bf74cc365f7 \
    9                         sha256  c1c920f77906740252e261e2baec5b7519e584344d6080aa5a9cc0b677b9064b
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 depends_lib-append      port:hs-platform-mtl
    16 
    17 description             \
    18     Happy is a parser generator system for Haskell, similar to the tool `yacc' \
    19     for C. Like `yacc', it takes a file containing an annotated BNF \
    20     specification of a grammar and produces a Haskell module containing \
    21     a parser for the grammar.
    22 long_description        ${description} \
    23     Happy is flexible: you can have several Happy parsers in the same program, \
    24     and several entry points to a single grammar. Happy can work in conjunction \
    25     with a lexical analyser supplied by the user (either hand-written or \
    26     generated by another program), or it can parse a stream of characters \
    27     directly (but this isn't practical in most cases).
     6name                    hs-platform-happy
     7version                 1.18.10
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-happy
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-haskell-src/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   haskell-src 1.0.1.5
     6name                    hs-platform-haskell-src
     7version                 1.0.1.5
    88revision                1
    9 checksums               rmd160  32a53bab9f1e150565cbed0c926816e4089dd966 \
    10                         sha256  9f3726902247cc955d085997254bb58c16cc337ee83de5ccfb17dcbcb488c3ab
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 depends_lib-append      port:hs-platform-syb
    17 
    18 description             \
    19     The haskell-src package provides support for manipulating Haskell source \
    20     code. The package provides a lexer, parser and pretty-printer, and \
    21     a definition of a Haskell abstract syntax tree (AST). Common uses of this \
    22     package are to parse or generate Haskell 98 code.
    23 long_description        ${description}
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-haskell-src
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-html/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   html 1.0.1.2
     6name                    hs-platform-html
     7version                 1.0.1.2
    88revision                2
    9 checksums               rmd160  55d95a42c297c9c4b0b0c3bbd077a5ed59e48878 \
    10                         sha256  0c35495ea33d65e69c69bc7441ec8e1af69fbb43433c2aa3406c0a13a3ab3061
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 description             \
    17     This package contains a combinator library for constructing HTML documents.
    18 long_description        ${description}
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-html
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-http/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   HTTP 4000.2.5
    8 checksums               rmd160  9eb67b257d3dea7e69450f0f932567af044e9260 \
    9                         sha256  67dd0e6b5b97657dcef8d906d329f73243b75b33ffeb90454783b0e9e70f320e
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 depends_lib-append      port:hs-platform-network \
    16                         port:hs-platform-mtl \
    17                         port:hs-platform-parsec
    18 
    19 description             \
    20     The HTTP package supports client-side web programming in Haskell. It lets \
    21     you set up HTTP connections, transmitting requests and processing the \
    22     responses coming back, all from within the comforts of Haskell. It's \
    23     dependent on the network package to operate, but other than that, the \
    24     implementation is all written in Haskell.
    25 long_description        ${description} \
    26     A basic API for issuing single HTTP requests + receiving responses is \
    27     provided. On top of that, a session-level abstraction is also on offer (the \
    28     BrowserAction monad): it taking care of handling the management of \
    29     persistent connections, proxies, state (cookies) and authentication \
    30     credentials required to handle multi-step interactions with a web server. \
    31     \
    32     The representation of the bytes flowing across is extensible via the use of \
    33     a type class, letting you pick the representation of requests and responses \
    34     that best fits your use. Some pre-packaged, common instances are provided \
    35     for you (ByteString, String.)
     6name                    hs-platform-http
     7version                 4000.2.5
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-http
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-hunit/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   HUnit 1.2.5.1
    8 checksums               rmd160  9b65d39d50740465c8623612ab52da848e382dc2 \
    9                         sha256  bc0c15d20ee7cedf35fadcaf9cc15b5c2b4ce2df9d80e61bfcdd65ef1ef64471
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 description             \
    16     HUnit is a unit testing framework for Haskell, inspired by the JUnit tool \
    17     for Java, see: http://www.junit.org.
    18 long_description        ${description}
     6name                    hs-platform-hunit
     7version                 1.2.5.1
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-hunit
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-mtl/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   mtl 2.1.2
    8 checksums               rmd160  aa5c576c124b602a605cf3931ac42c1c1eb27cda \
    9                         sha256  8c775764333420a4391823f9cb9b640306a262552280ea9bbdd2ca11194a8bef
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 depends_lib-append      port:hs-platform-transformers
    16 
    17 description             \
    18     Monad classes using functional dependencies, with instances for various \
    19     monad transformers, inspired by the paper Functional Programming with \
    20     Overloading and Higher-Order Polymorphism, by Mark P Jones, in Advanced \
    21     School of Functional Programming, 1995
    22 long_description        ${description}
     6name                    hs-platform-mtl
     7version                 2.1.2
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-mtl
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-network/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   network 2.3.1.0
    8 checksums               rmd160  8a633ab9c8c2b7c66dd7ff903f5dbd2cd51623ee \
    9                         sha256  d47c7fd9d08575acf9ff76661f9e6c0abf7fcf1280972d419f84b142272fe2ba
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 depends_lib-append      port:hs-platform-parsec
    16 
    17 description             Low-level networking interface
    18 long_description        ${description}
     6name                    hs-platform-network
     7version                 2.3.1.0
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-network
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-opengl/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   OpenGL 2.2.3.1
     6name                    hs-platform-opengl
     7version                 2.2.3.1
    88revision                1
    9 checksums               rmd160  659311f405866b77b0ff74aa3708e71431a3372c \
    10                         sha256  9f8425e36994f6602b66059490d00f5f7d7d59dbb97185c2054c5673688885ee
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 description             \
    17     A Haskell binding for the OpenGL graphics system (GL, version 3.2) and its \
    18     accompanying utility library (GLU, version 1.3).
    19 long_description        ${description} \
    20     OpenGL is the industry's most widely used and supported 2D and 3D graphics \
    21     application programming interface (API), incorporating a broad set of \
    22     rendering, texture mapping, special effects, and other powerful \
    23     visualization functions.
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-opengl
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-parallel/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   parallel 3.2.0.3
    8 checksums               rmd160  a358225292a80bb4223e6ea2f6e0d502e41cab02 \
    9                         sha256  163a40ef3c6258c623abe690a9837c9de2bf7fe87d3fac7d0758229d7efb6dcd
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 description             This package provides a library for parallel programming.
    16 long_description        ${description}
     6name                    hs-platform-parallel
     7version                 3.2.0.3
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-parallel
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-parsec/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   parsec 3.1.3
    8 checksums               rmd160  b1b407b27f5642142bfa619b31abd7a8cafe11ce \
    9                         sha256  9f14bb4da77eb9b0e4dbe8112559ed49409b0af8e9aef5d08941dd97e37fc4a8
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 depends_lib-append      port:hs-platform-mtl \
    16                         port:hs-platform-text
    17 
    18 description             \
    19     Parsec is designed from scratch as an industrial-strength parser library. \
    20     It is simple, safe, well documented (on the package homepage), has \
    21     extensive libraries and good error messages, and is also fast. It is \
    22     defined as a monad transformer that can be stacked on arbitrary monads, \
    23     and it is also parametric in the input stream type.
    24 long_description        ${description}
     6name                    hs-platform-parsec
     7version                 3.1.3
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-parsec
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-primitive/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   primitive 0.5.0.1
    8 checksums               rmd160  45b06610b6ea740bb96e8ed7c390ed0710bc8c6b \
    9                         sha256  526c9d4d06b7b379cb1aaffeffbb30bef810e771f29617ef6d0d99df711f4313
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 description             \
    16     This package provides various primitive memory-related operations.
    17 long_description        ${description}
     6name                    hs-platform-primitive
     7version                 0.5.0.1
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-primitive
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-quickcheck/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   QuickCheck 2.5.1.1
    8 checksums               rmd160  e543e2c5f9c7257a01c31abd0a0f4787fd3c372d \
    9                         sha256  98492011a2e546eccf2b747a990e82a726d68af9822f9d2d620cd1232aacc2b9
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 depends_lib-append      port:hs-platform-random
    16 
    17 description             \
    18     QuickCheck is a library for random testing of program properties.
    19 long_description        ${description} \
    20     The programmer provides a specification of the program, in the form of \
    21     properties which functions should satisfy, and QuickCheck then tests that \
    22     the properties hold in a large number of randomly generated cases. \
    23     \
    24     Specifications are expressed in Haskell, using combinators defined in the \
    25     QuickCheck library. QuickCheck provides combinators to define properties, \
    26     observe the distribution of test data, and define test data generators.
     6name                    hs-platform-quickcheck
     7version                 2.5.1.1
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-quickcheck
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-random/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   random 1.0.1.1
     6name                    hs-platform-random
     7version                 1.0.1.1
    88revision                1
    9 checksums               rmd160  a13a4d7fefd15611cf863f11caf212efede320c3 \
    10                         sha256  df7c3b405de0ac27a2ee8fdc8dad87cb42e8eac01fef53861e43bc47c8111559
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 description             \
    17     This package provides a basic random number generation library, including \
    18     the ability to split random number generators.
    19 long_description        ${description}
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-random
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-regex-base/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   regex-base 0.93.2
     6name                    hs-platform-regex-base
     7version                 0.93.2
    88revision                1
    9 checksums               rmd160  c009e193dd453666c7c3b585a25f3a8add7ec6b6 \
    10                         sha256  20dc5713a16f3d5e2e6d056b4beb9cfdc4368cd09fd56f47414c847705243278
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 depends_lib-append      port:hs-platform-mtl
    17 
    18 description             Interface API for regex-posix,pcre,parsec,tdfa,dfa
    19 long_description        ${description}
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-regex-base
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-regex-compat/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   regex-compat 0.95.1
     6name                    hs-platform-regex-compat
     7version                 0.95.1
    88revision                1
    9 checksums               rmd160  b2fe02ca3c4e9027b2d433c8a265b19a85c8bd17 \
    10                         sha256  d57cb1a5a4d66753b18eaa37a1621246f660472243b001894f970037548d953b
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 depends_lib-append      port:hs-platform-regex-base \
    17                         port:hs-platform-regex-posix
    18 
    19 description             One module layer over regex-posix to replace Text.Regex
    20 long_description        ${description}
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-regex-compat
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-regex-posix/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   regex-posix 0.95.2
    8 checksums               rmd160  7ee59eb760bb8c0c7fe17e17d90eb0623b9fd5bb \
    9                         sha256  56019921cd4a4c9682b81ec614236fea816ba8ed8785a1640cd66d8b24fc703e
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 depends_lib-append      port:hs-platform-regex-base
    16 
    17 description             The posix regex backend for regex-base
    18 long_description        ${description}
     6name                    hs-platform-regex-posix
     7version                 0.95.2
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-regex-posix
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-split/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   split 0.2.1.1
    8 checksums               rmd160  9a8fc68b99d5db069aa0974445c0a650c0b5e944 \
    9                         sha256  bf36c149a6613fc6be78ec170ae98a696aae887b82434a1439da10e47823f7ff
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 description             \
    16     A collection of various methods for splitting lists into parts, akin to the \
    17     "split" function found in several mainstream languages.
    18 long_description        ${description} \
    19    Here is its tale:\n\
    20    Once upon a time the standard Data.List module held no function for splitting \
    21    a list into parts according to a delimiter. Many a brave lambda-knight strove \
    22    to add such a function, but their striving was in vain, for Lo, the Supreme \
    23    Council fell to bickering amongst themselves what was to be the essential \
    24    nature of the One True Function which could cleave a list in twain (or \
    25    thrain, or any required number of parts).\n\
    26    And thus came to pass the split package, comprising divers functions for \
    27    splitting a list asunder, each according to its nature. And the Supreme \
    28    Council had no longer any grounds for argument, for the favored method of \
    29    each was contained therein.\n\
    30    To get started, see the Data.List.Split module.
     6name                    hs-platform-split
     7version                 0.2.1.1
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-split
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-stm/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   stm 2.4
    8 checksums               rmd160  72e4ae310553edeb57b3f55aa7e2920d7f79a75f \
    9                         sha256  d495f0c70a958e749cb6fe51db57ba358312066c5c498cce5516db2de0f7d48d
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 description             A modular composable concurrency abstraction.
    16 long_description        ${description}
     6name                    hs-platform-stm
     7version                 2.4
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-stm
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-syb/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   syb 0.3.7
    8 checksums               rmd160  e8d80346a305efcdc5d5cb461b9ed415a6afde3e \
    9                         sha256  59f4058a8182a472c0e0e35f8aca836470a5785d3dcd01e3d44bb188c850da73
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 description             \
    16     This package contains the generics system described in the Scrap Your \
    17     Boilerplate papers (see http://www.cs.uu.nl/wiki/GenericProgramming/SYB). \
    18     It defines the Data class of types permitting folding and unfolding of \
    19     constructor applications, instances of this class for primitive types, and \
    20     a variety of traversals.
    21 long_description        ${description}
     6name                    hs-platform-syb
     7version                 0.3.7
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-syb
  • trunk/dports/devel/hs-platform-text/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   text 0.11.2.3
    8 checksums               rmd160  903c347739e0f81c87d1c5eb164da525a8764d1a \
    9                         sha256  352737b045a42635f1017473179297ab562d53513ab3a4b965f38514171e344b
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 description             \
    16     An efficient packed, immutable Unicode text type (both strict and lazy), \
    17     with a powerful loop fusion optimization framework.
    18 long_description        ${description}
     6name                    hs-platform-text
     7version                 0.11.2.3
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-text
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-transformers/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   transformers 0.3.0.0
     6name                    hs-platform-transformers
     7version                 0.3.0.0
    88revision                1
    9 checksums               rmd160  110bd7eb44609d8db44d85f8367db323576545dc \
    10                         sha256  e5aa0c1ec97ad98c389e78f59aca25ab028980a7068a3e585e39564662739591
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 description             \
    17     A portable library of functor and monad transformers, inspired by the paper \
    18     Functional Programming with Overloading and Higher-Order Polymorphism, by \
    19     Mark P Jones, in Advanced School of Functional Programming, 1995
    20 long_description        ${description} \
    21     This package contains:\n\
    22      - the monad transformer class (in Control.Monad.Trans.Class)\n\
    23      - concrete functor and monad transformers, each with associated operations \
    24        and functions to lift operations associated with other transformers.\n\
    25     It can be used on its own in portable Haskell code, or with the monad \
    26     classes in the mtl or monads-tf packages, which automatically lift \
    27     operations introduced by monad transformers through other transformers.
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-transformers
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-vector/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   vector 0.10.0.1
    8 checksums               rmd160  e00adaf6b4a9634df2feb1a805f4adf51d1870ae \
    9                         sha256  ece945058b01a77c5fff31e89bbea76ac619677041c41286a2da5e8b515508af
    10 
    11 depends_lib-append      port:hs-platform-primitive
    12 
    13 license                 BSD
    14 maintainers             cal openmaintainer
    15 platforms               darwin
    16 
    17 description             \
    18     An efficient implementation of Int-indexed arrays (both mutable and \
    19     immutable), with a powerful loop optimisation framework.
    20 long_description        ${description}
     6name                    hs-platform-vector
     7version                 0.10.0.1
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-vector
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-xhtml/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   xhtml 3000.2.1
     6name                    hs-platform-xhtml
     7version                 3000.2.1
    88revision                1
    9 checksums               rmd160  72e1095df0a8111ea696749d219df4ea78da1b4f \
    10                         sha256  33020782170c1c083bc59fc3bfcb72cec2db223e02d1181c07ae23b9fa7fdcd8
    11 
    12 license                 BSD
    13 maintainers             cal openmaintainer
    14 platforms               darwin
    15 
    16 description             \
    17     This package provides combinators for producing XHTML 1.0, including the \
    18     Strict, Transitional and Frameset variants.
    19 long_description        ${description}
     9license                 Permissive
     10categories              devel haskell
     11replaced_by             hs-xhtml
     12PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-platform-zlib/Portfile

    r100372 r106818  
    33
    44PortSystem              1.0
    5 PortGroup               haskellplatform 1.0
    65
    7 haskellplatform.setup   zlib 0.5.4.0
    8 checksums               rmd160  9394913265e9250d867e4355ce5b7e59279abfa0 \
    9                         sha256  61771a451a23a26954d8f9f0d5c5b63f633fd3f272c9ab70a2ebe78532270ca2
    10 
    11 license                 BSD
    12 maintainers             cal openmaintainer
    13 platforms               darwin
    14 
    15 depends_lib-append      port:zlib
    16 
    17 description             \
    18     This package provides a pure interface for compressing and decompressing \
    19     streams of data represented as lazy ByteStrings. It uses the zlib C library \
    20     so it has high performance. It supports the \"zlib\", \"gzip\" and \"raw\" \
    21     compression formats.
    22 long_description        ${description} \
    23     It provides a convenient high level API suitable for most tasks and for the \
    24     few cases where more control is needed it provides access to the full zlib \
    25     feature set.
     6name                    hs-platform-zlib
     7version                 0.5.4.0
     8license                 Permissive
     9categories              devel haskell
     10replaced_by             hs-zlib
     11PortGroup               obsolete 1.0
  • trunk/dports/devel/hs-primitive/Portfile

    r104471 r106818  
     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
    12# $Id$
    23
    3 PortSystem 1.0
     4PortSystem          1.0
    45PortGroup           haskell 1.0
    56
    6 haskell.setup       primitive 0.2.1
    7 revision            1
     7haskell.setup       primitive 0.5.0.1
     8checksums           rmd160  45b06610b6ea740bb96e8ed7c390ed0710bc8c6b \
     9                    sha256  526c9d4d06b7b379cb1aaffeffbb30bef810e771f29617ef6d0d99df711f4313
     10
    811license             BSD
    9 maintainers         nomaintainer
    10 description         Wrappers for primitive operations
    11 long_description \
    12         This package provides wrappers for primitive array operations   \
    13         from GHC.Prim.
     12maintainers         cal openmaintainer
     13
     14description         Primitive memory-related operations
     15long_description    This package provides various primitive memory-related operations.
    1416
    1517platforms           darwin
    16 
    17 checksums       md5     ed1b3e55366634242c0083ea5879bc16 \
    18                 sha1    297e5b01c479dbe1411a529baff6cad3c8ab6748 \
    19                 rmd160  e6c2f6dc0386daab0522f50105382d6b3fec1668
  • trunk/dports/lang/ghc/Portfile

    r105233 r106818  
    66name                ghc
    77set canonicalname   ghc
    8 version             7.4.2
    9 revision            1
     8version             7.6.3
    109categories          lang haskell
    1110maintainers         gmail.com:kitchen.andy cal openmaintainer
     
    3736                ${canonicalname}-${version}-testsuite${extract.suffix}
    3837
    39 checksums       ghc-7.4.2-src.tar.bz2 \
    40                 rmd160  c1caf17de353d3f805966ea64235a8341a8e071e \
    41                 sha256  f2ee1289a33cc70539287129841acc7eaf16112bb60c59b5a6ee91887bfd836d \
    42                 ghc-7.4.2-testsuite.tar.bz2 \
    43                 rmd160  6ff2a50d2165baa540da8a486d30fab47dfdbd0d \
    44                 sha256  227fee370e84892e4316f611c8cae0ad24d58d594d0b49f7960caf05b4f85332
     38checksums       ghc-7.6.3-src.tar.bz2 \
     39                rmd160  82a673ed38b7cf9a59afeb01057625fc761a822b \
     40                sha256  bd43823d31f6b5d0b2ca7b74151a8f98336ab0800be85f45bb591c9c26aac998 \
     41                ghc-7.6.3-testsuite.tar.bz2 \
     42                rmd160  e1d7536b1b0799a6c069eb89be41ceb56692b68d \
     43                sha256  870d8f50a1b569b0f93d0c7c6b80225280841988f1d779aafe847bcf02d76256
    4544
    4645depends_build   port:ghc-bootstrap \
     
    5150                port:libiconv
    5251
    53 patchfiles      patch-configure-disable-docbook-ps-and-pdf.diff \
    54                 ghc7040.patch
    55                 # see http://hackage.haskell.org/trac/ghc/ticket/7040
     52patchfiles      patch-configure-disable-docbook-ps-and-pdf.diff
    5653
    5754
     
    6360
    6461variant gcc43 conflicts gcc44 gcc45 gcc46 gcc47 description {Compile with gcc 4.3} {
    65     configure.compiler macports-gcc-4.3
    66     depends_lib-append port:gcc43
     62    configure.compiler      macports-gcc-4.3
     63    depends_lib-append      port:gcc43
     64    configure.args-append   --with-gcc=${configure.cc}
    6765}
    6866
    6967variant gcc44 conflicts gcc43 gcc45 gcc46 gcc47 description {Compile with gcc 4.4} {
    70     configure.compiler macports-gcc-4.4
    71     depends_lib-append port:gcc44
     68    configure.compiler      macports-gcc-4.4
     69    depends_lib-append      port:gcc44
     70    configure.args-append   --with-gcc=${configure.cc}
    7271}
    7372
    7473variant gcc45 conflicts gcc43 gcc44 gcc46 gcc47 description {Compile with gcc 4.5} {
    75     configure.compiler macports-gcc-4.5
    76     depends_lib-append port:gcc45
     74    configure.compiler      macports-gcc-4.5
     75    depends_lib-append      port:gcc45
     76    configure.args-append   --with-gcc=${configure.cc}
    7777}
    7878
    7979variant gcc46 conflicts gcc43 gcc44 gcc45 gcc47 description {Compile with gcc 4.6} {
    80     configure.compiler macports-gcc-4.6
    81     depends_lib-append port:gcc46
     80    configure.compiler      macports-gcc-4.6
     81    depends_lib-append      port:gcc46
     82    configure.args-append   --with-gcc=${configure.cc}
    8283}
    8384
    8485variant gcc47 conflicts gcc43 gcc44 gcc45 gcc46  description {Compile with gcc 4.7} {
    85     configure.compiler macports-gcc-4.7
    86     depends_lib-append port:gcc47
     86    configure.compiler      macports-gcc-4.7
     87    depends_lib-append      port:gcc47
     88    configure.args-append   --with-gcc=${configure.cc}
    8789}
    8890
  • trunk/dports/lang/ghc/files/patch-configure-disable-docbook-ps-and-pdf.diff

    r96883 r106818  
    1 --- configure.orig      2012-06-30 00:18:22.000000000 +0200
    2 +++ configure   2012-06-30 00:19:19.000000000 +0200
    3 @@ -10401,6 +10401,8 @@
     1--- configure.orig      2013-04-19 00:47:00.000000000 +0200
     2+++ configure   2013-06-05 21:52:52.000000000 +0200
     3@@ -10983,6 +10983,8 @@
    44     BUILD_DOCBOOK_PS=YES
    55     BUILD_DOCBOOK_PDF=YES
Note: See TracChangeset for help on using the changeset viewer.