    {- OPTIONS_GHC -fno-warn-unused-imports -}
    -----------------------------------------------------------------------------
    -- |
    --
    -- Module      :  Text.Regex.Posix
    -- Copyright   :  (c) Chris Kuklewicz 2006
    -- License     :  BSD-style (see the file LICENSE)
    --
    -- Maintainer  :  libraries@haskell.org, textregexlazy@personal.mightyreason.com
    -- Stability   :  experimental
    -- Portability :  non-portable (regex-base needs MPTC+FD)
    --
    -- Module that provides the Regex backend that wraps the c posix regex api.
    -- This is the backend being used by the regex-compat package to replace
    -- Text.Regex
    --
    -- The "Text.Regex.Posix" module provides a backend for regular
    -- expressions. If you import this along with other backends, then
    -- you should do so with qualified imports, perhaps renamed for
    -- convenience.
    --
    -- If the '=~' and '=~~' functions are too high level, you can use the
    -- compile, regexec, and execute functions from importing either
    -- "Text.Regex.Posix.String" or "Text.Regex.Posix.ByteString".  If you
    -- want to use a low-level 'Foreign.C.CString' interface to the library,
    -- then import "Text.Regex.Posix.Wrap" and use the wrap* functions.
    --
    -- This module is only efficient with 'Data.ByteString.ByteString' only
    -- if it is null terminated, i.e. @(Bytestring.last bs)==0@.  Otherwise the
    -- library must make a temporary copy of the 'Data.ByteString.ByteString'
    -- and append the NUL byte.
    --
    -- A 'String' will be converted into a 'Foreign.C.CString' for processing.
    -- Doing this repeatedly will be very inefficient.
    --
    -- Note that the posix library works with single byte characters, and
    -- does not understand Unicode.  If you need Unicode support you will
    -- have to use a different backend.
    --
    -- When offsets are reported for subexpression captures, a subexpression
    -- that did not match anything (as opposed to matching an empty string)
    -- will have its offset set to the 'unusedRegOffset' value, which is (-1).
    --
    -- Benchmarking shows the default regex library on many platforms is very
    -- inefficient.  You might increase performace by an order of magnitude
    -- by obtaining libpcre and regex-pcre or libtre and regex-tre.  If you
    -- do not need the captured substrings then you can also get great
    -- performance from regex-dfa.  If you do need the capture substrings
    -- then you may be able to use regex-parsec to improve performance.
    -----------------------------------------------------------------------------

    module Text.Regex.Posix(getVersion_Text_Regex_Posix
     ,module Text.Regex.Base
      -- ** Wrap, for '=~' and '=~~', types and constants
     ,module Text.Regex.Posix.Wrap) where

    import Text.Regex.Posix.Wrap(Regex, CompOption(CompOption),
      ExecOption(ExecOption), (=~), (=~~),
      unusedRegOffset,
      compBlank, compExtended, compIgnoreCase, compNoSub, compNewline,
      execBlank, execNotBOL, execNotEOL)
    import Text.Regex.Posix.String()
    import Text.Regex.Posix.Sequence()
    import Text.Regex.Posix.ByteString()
    import Text.Regex.Posix.ByteString.Lazy()
    import Data.Version(Version(..))
    import Text.Regex.Base

    getVersion_Text_Regex_Posix :: Version
    getVersion_Text_Regex_Posix =
      Version { versionBranch = [0,94,4]  -- Keep in sync with regex-posix.cabal
              , versionTags = ["unstable"]
              }