Copyright for haskell-attoparsec source package in Yangtze V1.0

Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: haskell-attoparsec
Source: 
#
# Please double check copyright with the licensecheck(1) command.

Files:     README.markdown
           Setup.lhs
           attoparsec.cabal
           benchmarks/Aeson.hs
           benchmarks/Benchmarks.hs
           benchmarks/Common.hs
           benchmarks/Genome.hs
           benchmarks/HeadersByteString.hs
           benchmarks/HeadersByteString/Atto.hs
           benchmarks/HeadersText.hs
           benchmarks/Links.hs
           benchmarks/Makefile
           benchmarks/Numbers.hs
           benchmarks/Sets.hs
           benchmarks/Warp.hs
           benchmarks/http-request.txt
           benchmarks/http-response.txt
           benchmarks/json-data/example.json
           benchmarks/json-data/geometry.json
           benchmarks/json-data/integers.json
           benchmarks/json-data/jp10.json
           benchmarks/json-data/jp100.json
           benchmarks/json-data/jp50.json
           benchmarks/json-data/numbers.json
           benchmarks/json-data/twitter1.json
           benchmarks/json-data/twitter10.json
           benchmarks/json-data/twitter100.json
           benchmarks/json-data/twitter20.json
           benchmarks/json-data/twitter50.json
           benchmarks/med.txt.bz2
           benchmarks/warp-3.0.1.1/Network/Wai/Handler/Warp/RequestHeader.hs
           changelog.md
           examples/Atto_RFC2616.hs
           examples/Makefile
           examples/Parsec_RFC2616.hs
           examples/RFC2616.hs
           examples/rfc2616.c
           internal/Data/Attoparsec/Internal/Compat.hs
           internal/Data/Attoparsec/Internal/Fhthagn.hs
           tests/QC.hs
           tests/QC/Buffer.hs
           tests/QC/ByteString.hs
           tests/QC/Combinator.hs
           tests/QC/Common.hs
           tests/QC/Rechunked.hs
           tests/QC/Simple.hs
           tests/QC/Text.hs
           tests/QC/Text/FastSet.hs
           tests/QC/Text/Regressions.hs
Copyright: __NO_COPYRIGHT_NOR_LICENSE__
License:   __NO_COPYRIGHT_NOR_LICENSE__

Files:     Data/Attoparsec/Internal.hs
           Data/Attoparsec/Internal/Types.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient parser combinators, loosely based on the Parsec
 library.

Files:     tests/QC/IPv6/Internal.hs
           tests/QC/IPv6/Types.hs
Copyright: 2011-2015 :  Copyright © Michel Boucey
License:   __UNKNOWN__
 License     :  BSD-Style
 Maintainer  :  michel.boucey@gmail.com
 .
 Dealing with IPv6 address text representations, canonization and manipulations.

Files:     benchmarks/TextFastSet.hs
           internal/Data/Attoparsec/Text/FastSet.hs
Copyright: 2007-2015 :  Felipe Lessa 2010, Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Fast set membership tests for 'Char' values. We test for
 membership using a hashtable implemented with Robin Hood
 collision resolution. The set representation is unboxed,
 and the characters and hashes interleaved, for efficiency.

Files:     Data/Attoparsec/ByteString/Char8.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient, character-oriented combinator parsing for
 'B.ByteString' strings, loosely based on the Parsec library.

Files:     Data/Attoparsec/Combinator.hs
Copyright: 2007-2015 :  Daan Leijen 1999-2001, Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Useful parser combinators, similar to those provided by Parsec.

Files:     Data/Attoparsec/Number.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 This module is deprecated, and both the module and 'Number' type
 will be removed in the next major release.  Use the
  scientific> package
 and the 'Data.Scientific.Scientific' type instead.
 .
 A simple number type, useful for parsing both exact and inexact
 quantities without losing much precision.

Files:     Data/Attoparsec/ByteString.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient combinator parsing for 'B.ByteString' strings,
 loosely based on the Parsec library.

Files:     Data/Attoparsec/Types.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient parser combinators for strings, loosely based on
 the Parsec library.

Files:     Data/Attoparsec/Text/Internal.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient parser combinators for 'Text' strings, loosely
 based on the Parsec library.

Files:     Data/Attoparsec/ByteString/Lazy.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient combinator parsing that can consume lazy
 'ByteString' strings, loosely based on the Parsec library.
 .
 This is essentially the same code as in the 'Data.Attoparsec'
 module, only with a 'parse' function that can consume a lazy
 'ByteString' incrementally, and a 'Result' type that does not allow
 more input to be fed in.  Think of this as suitable for use with a
 lazily read file, e.g. via 'L.readFile' or 'L.hGetContents'.
 .
 /Note:/ The various parser functions and combinators such as
 'string' still expect /strict/ 'B.ByteString' parameters, and
 return strict 'B.ByteString' results.  Behind the scenes, strict
 'B.ByteString' values are still used internally to store parser
 input and manipulate it efficiently.

Files:     internal/Data/Attoparsec/ByteString/FastSet.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Fast set membership tests for 'Word8' and 8-bit 'Char' values.  The
 set representation is unboxed for efficiency.  For small sets, we
 test for membership using a binary search.  For larger sets, we use
 a lookup table.

Files:     Data/Attoparsec/Lazy.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient combinator parsing for lazy 'ByteString'
 strings, loosely based on the Parsec library.
 .
 This is essentially the same code as in the 'Data.Attoparsec'
 module, only with a 'parse' function that can consume a lazy
 'ByteString' incrementally, and a 'Result' type that does not allow
 more input to be fed in.  Think of this as suitable for use with a
 lazily read file, e.g. via 'L.readFile' or 'L.hGetContents'.
 .
 Behind the scenes, strict 'B.ByteString' values are still used
 internally to store parser input and manipulate it efficiently.
 High-performance parsers such as 'string' still expect strict
 'B.ByteString' parameters.

Files:     Data/Attoparsec/ByteString/Internal.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient parser combinators for 'ByteString' strings,
 loosely based on the Parsec library.

Files:     benchmarks/warp-3.0.1.1/Network/Wai/Handler/Warp/ReadInt.hs
Copyright: : Erik de Castro Lopo 
License:   __UNKNOWN__
 License       : BSD3

Files:     Data/Attoparsec/Text/Lazy.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient combinator parsing that can consume lazy 'Text'
 strings, loosely based on the Parsec library.
 .
 This is essentially the same code as in the 'Data.Attoparsec.Text'
 module, only with a 'parse' function that can consume a lazy
 'Text' incrementally, and a 'Result' type that does not allow
 more input to be fed in.  Think of this as suitable for use with a
 lazily read file, e.g. via 'L.readFile' or 'L.hGetContents'.
 .
 /Note:/ The various parser functions and combinators such as
 'string' still expect /strict/ 'T.Text' parameters, and return
 strict 'T.Text' results.  Behind the scenes, strict 'T.Text' values
 are still used internally to store parser input and manipulate it
 efficiently.

Files:     Data/Attoparsec.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient combinator parsing for
 'Data.ByteString.ByteString' strings, loosely based on the Parsec
 library.
 .
 This module is deprecated. Use "Data.Attoparsec.ByteString"
 instead.

Files:     internal/Data/Attoparsec/Text/Buffer.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 An immutable buffer that supports cheap appends.
 .
 A Buffer is divided into an immutable read-only zone, followed by a
 mutable area that we've preallocated, but not yet written to.
 .
 We overallocate at the end of a Buffer so that we can cheaply
 append.  Since a user of an existing Buffer cannot see past the end
 of its immutable zone into the data that will change during an
 append, this is safe.
 .
 Once we run out of space at the end of a Buffer, we do the usual
 doubling of the buffer size.

Files:     Data/Attoparsec/Zepto.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 A tiny, highly specialized combinator parser for 'B.ByteString'
 strings.
 .
 While the main attoparsec module generally performs well, this
 module is particularly fast for simple non-recursive loops that
 should not normally result in failed parses.
 .
 /Warning/: on more complex inputs involving recursion or failure,
 parsers based on this module may be as much as /ten times slower/
 than regular attoparsec! You should /only/ use this module when you
 have benchmarks that prove that its use speeds your code up.

Files:     Data/Attoparsec/Text.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient combinator parsing for 'Text' strings,
 loosely based on the Parsec library.

Files:     Data/Attoparsec/Char8.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 Simple, efficient, character-oriented combinator parsing for
 'Data.ByteString.ByteString' strings, loosely based on the Parsec
 library.
 .
 This module is deprecated. Use "Data.Attoparsec.ByteString.Char8"
 instead.

Files:     internal/Data/Attoparsec/ByteString/Buffer.hs
Copyright: 2007-2015 :  Bryan O'Sullivan
License:   __UNKNOWN__
 License     :  BSD3
 .
 An "immutable" buffer that supports cheap appends.
 .
 A Buffer is divided into an immutable read-only zone, followed by a
 mutable area that we've preallocated, but not yet written to.
 .
 We overallocate at the end of a Buffer so that we can cheaply
 append.  Since a user of an existing Buffer cannot see past the end
 of its immutable zone into the data that will change during an
 append, this is safe.
 .
 Once we run out of space at the end of a Buffer, we do the usual
 doubling of the buffer size.
 .
 The fact of having a mutable buffer really helps with performance,
 but it does have a consequence: if someone misuses the Partial API
 that attoparsec uses by calling the same continuation repeatedly
 (which never makes sense in practice), they could overwrite data.
 .
 Since the API *looks* pure, it should *act* pure, too, so we use
 two generation counters (one mutable, one immutable) to track the
 number of appends to a mutable buffer. If the counters ever get out
 of sync, someone is appending twice to a mutable buffer, so we
 duplicate the entire buffer in order to preserve the immutability
 of its older self.
 .
 While we could go a step further and gain protection against API
 abuse on a multicore system, by use of an atomic increment
 instruction to bump the mutable generation counter, that would be
 very expensive, and feels like it would also be in the realm of the
 ridiculous.  Clients should never call a continuation more than
 once; we lack a linear type system that could enforce this; and
 there's only so far we should go to accommodate broken uses.

#----------------------------------------------------------------------------
# Files marked as NO_LICENSE_TEXT_FOUND may be covered by the following
# license/copyright files.

#----------------------------------------------------------------------------
# License file: LICENSE
 Copyright (c) Lennart Kolmodin
 .
 All rights reserved.
 .
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:
 .
 1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
 .
 2. Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
 .
 3. Neither the name of the author nor the names of his contributors
    may be used to endorse or promote products derived from this software
    without specific prior written permission.
 .
 THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.