summaryrefslogtreecommitdiff
path: root/regex-tdfa.cabal
blob: 452e23dc769ee3dfd255e19624b732b3ef9dad3a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
cabal-version:          1.12
name:                   regex-tdfa
version:                1.3.2.2
x-revision:             1

build-Type:             Simple
license:                BSD3
license-file:           LICENSE
copyright:              Copyright (c) 2007-2009, Christopher Kuklewicz
author:                 Christopher Kuklewicz
maintainer:             Andreas Abel
homepage:               https://wiki.haskell.org/Regular_expressions
bug-reports:            https://github.com/haskell-hvr/regex-tdfa/issues

category:               Text
synopsis:               Pure Haskell Tagged DFA Backend for "Text.Regex" (regex-base)
description:
  This package provides a pure Haskell \"Tagged\" DFA regex engine for <//hackage.haskell.org/package/regex-base regex-base>. This implementation was inspired by the algorithm (and Master's thesis) behind the regular expression library known as <https://github.com/laurikari/tre/ TRE or libtre>.
  .
  Please consult the "Text.Regex.TDFA" module for API documentation including a tutorial with usage examples;
  see also <https://wiki.haskell.org/Regular_expressions> for general information about regular expression support in Haskell.

extra-source-files:
  CHANGELOG.md
  README.md
  test/cases/*.txt

tested-with:
  GHC == 9.8.0
  GHC == 9.6.2
  GHC == 9.4.5
  GHC == 9.2.8
  GHC == 9.0.2
  GHC == 8.10.7
  GHC == 8.8.4
  GHC == 8.6.5
  GHC == 8.4.4
  GHC == 8.2.2
  GHC == 8.0.2
  GHC == 7.10.3
  GHC == 7.8.4
  GHC == 7.6.3
  GHC == 7.4.2

source-repository head
  type:                git
  location:            https://github.com/haskell-hvr/regex-tdfa.git

source-repository this
  type:                git
  location:            https://github.com/haskell-hvr/regex-tdfa.git
  tag:                 v1.3.2.2-r1

flag force-O2
  default: False
  manual: True
  description:
    Force building @regex-tdfa@ with \"@ghc-options: -O2@\".
    .
    __NOTE__: This flag is mostly provided for legacy use-cases. Nowadays you can conveniently control optimization levels on a per-package granularity via @cabal.project@ files; see <https://cabal.readthedocs.io/en/latest/nix-local-build.html#configuring-builds-with-cabal-project cabal's user-guide> for more details.

flag doctest
  default: True
  manual: False
  description:
    Include test-suite doctest.

library
  hs-source-dirs:       lib

  exposed-modules:      Data.IntMap.CharMap2
                        Data.IntMap.EnumMap2
                        Data.IntSet.EnumSet2
                        Text.Regex.TDFA
                        Text.Regex.TDFA.ByteString
                        Text.Regex.TDFA.ByteString.Lazy
                        Text.Regex.TDFA.Common
                        Text.Regex.TDFA.CorePattern
                        Text.Regex.TDFA.IntArrTrieSet
                        Text.Regex.TDFA.NewDFA.Engine
                        Text.Regex.TDFA.NewDFA.Engine_FA
                        Text.Regex.TDFA.NewDFA.Engine_NC
                        Text.Regex.TDFA.NewDFA.Engine_NC_FA
                        Text.Regex.TDFA.NewDFA.Tester
                        Text.Regex.TDFA.NewDFA.Uncons
                        Text.Regex.TDFA.NewDFA.MakeTest
                        Text.Regex.TDFA.Pattern
                        Text.Regex.TDFA.ReadRegex
                        Text.Regex.TDFA.Sequence
                        Text.Regex.TDFA.String
                        Text.Regex.TDFA.TDFA
                        Text.Regex.TDFA.TNFA
                        Text.Regex.TDFA.Text
                        Text.Regex.TDFA.Text.Lazy

  other-modules:        Paths_regex_tdfa

  -- Support Semigroup instances uniformly
  --
  -- See also
  --  https://prime.haskell.org/wiki/Libraries/Proposals/SemigroupMonoid#RecommendedVariant
  --
  -- NB: This is the same logic `parsec.cabal` uses, so this doesn't
  -- add any new dependency that isn't already incurred by
  -- `regex-tdfa`'s transitive deps
  if !impl(ghc >= 8.0)
    build-depends:      fail               == 4.9.*
                      , semigroups         == 0.18.* || == 0.19.*
  build-depends:        array              >= 0.4    && < 0.6
                      , base               >= 4.5    && < 5
                      , bytestring         >= 0.9.2  && < 0.13
                      , containers         >= 0.4.2  && < 0.7
                      , mtl                >= 2.1.3  && < 2.4
                      , parsec             == 3.1.*
                      , regex-base         == 0.94.*
                      , text               >= 1.2.3  && < 2.2

  default-language:     Haskell2010
  default-extensions:   BangPatterns
                        ExistentialQuantification
                        FlexibleContexts
                        FlexibleInstances
                        ForeignFunctionInterface
                        FunctionalDependencies
                        MagicHash
                        MultiParamTypeClasses
                        NondecreasingIndentation
                        RecursiveDo
                        ScopedTypeVariables
                        TypeOperators
                        TypeSynonymInstances
                        UnboxedTuples
                        UnliftedFFITypes
  other-extensions:     CPP

  ghc-options:          -Wall -funbox-strict-fields -fspec-constr-count=10 -fno-warn-orphans

  if impl(ghc >= 8.0)
    ghc-options:        -Wcompat

  if flag(force-O2)
    ghc-options:        -O2


test-suite regex-tdfa-unittest
  type:                 exitcode-stdio-1.0

  hs-source-dirs:       test
  main-is:              Main.hs

  -- intra-package dependency
  build-depends:        regex-tdfa

  -- dependencies whose version constraints are inherited via intra-package 'regex-tdfa' dependency
  if !impl(ghc >= 8.0)
    build-depends:      fail
                      , semigroups
  build-depends:        array
                      , base
                      , bytestring
                      , containers
                      , filepath
                      , mtl
                      , regex-base
                      , text

  -- component-specific dependencies not inherited via 'regex-tdfa'
                      , directory          >= 1.1.0  && < 1.4
                      , filepath           >= 1.3.0  && < 1.5
                      , utf8-string        >= 1.0.1  && < 1.1

  default-language:     Haskell2010
  default-extensions:   FlexibleInstances
                        FlexibleContexts
                        Rank2Types
  other-extensions:     GeneralizedNewtypeDeriving

  ghc-options:          -Wall -funbox-strict-fields

  if impl(ghc >= 8.0)
    ghc-options:        -Wcompat

  if flag(force-O2)
    ghc-options:        -O2

test-suite doctest
  type:           exitcode-stdio-1.0
  hs-source-dirs: test
  main-is:        DocTestMain.hs

  build-depends:
      base
    , regex-tdfa
    , doctest-parallel >= 0.2.2
        -- doctest-parallel-0.2.2 is the first to filter out autogen-modules

  default-language:     Haskell2010

  if !flag(doctest)
    buildable: False