Cabal-version:        2.2
Name:                 clash-lib
Version:              1.5.0
Synopsis:             Clash: a functional hardware description language - As a library
Description:
  Clash is a functional hardware description language that borrows both its
  syntax and semantics from the functional programming language Haskell. The
  Clash compiler transforms these high-level descriptions to low-level
  synthesizable VHDL, Verilog, or SystemVerilog.
  .
  Features of Clash:
  .
  * Strongly typed, but with a very high degree of type inference, enabling both
    safe and fast prototyping using concise descriptions.
  .
  * Interactive REPL: load your designs in an interpreter and easily test all
    your component without needing to setup a test bench.
  .
  * Higher-order functions, with type inference, result in designs that are
    fully parametric by default.
  .
  * Synchronous sequential circuit design based on streams of values, called
    @Signal@s, lead to natural descriptions of feedback loops.
  .
  * Support for multiple clock domains, with type safe clock domain crossing.
  .
  .
  This package provides:
  .
  * The CoreHW internal language: SystemF + Letrec + Case-decomposition
  .
  * The normalisation process that brings CoreHW in a normal form that can be
  converted to a netlist
  .
  * Blackbox/Primitive Handling
  .
  .
  Front-ends (for: parsing, typecheck, etc.) are provided by separate packages:
  .
  * <https://hackage.haskell.org/package/clash-ghc GHC/Haskell Frontend>
  .
  * <https://github.com/christiaanb/Idris-dev Idris Frontend>
  .
  .
  Prelude library: <https://hackage.haskell.org/package/clash-prelude>
Homepage:             https://clash-lang.org/
bug-reports:          https://github.com/clash-lang/clash-compiler/issues
License:              BSD-2-Clause
License-file:         LICENSE
Author:               The Clash Authors
Maintainer:           QBayLogic B.V. <devops@qbaylogic.com>
Copyright:            Copyright © 2012-2016, University of Twente,
                                  2016-2019, Myrtle Software Ltd,
                                  2017-2019, QBayLogic B.V., Google Inc.
Category:             Hardware
Build-type:           Simple

Extra-source-files:
  README.md,
  CHANGELOG.md,
  src/ClashDebug.h

Data-files:
  prims/common/*.primitives.yaml,
  prims/commonverilog/*.primitives.yaml,
  prims/verilog/*.primitives.yaml,
  prims/systemverilog/*.primitives.yaml,
  prims/vhdl/*.primitives.yaml

source-repository head
  type: git
  location: https://github.com/clash-lang/clash-compiler.git
  subdir: clash-lib

flag debug
   description:
     Build a debug compiler
   default: False
   manual: True

flag unittests
  description:
    You can disable testing with unittests using `-f-unittests`.
  default: True
  manual: True

common common-options
  default-language:   Haskell2010
  default-extensions: BangPatterns
                      BinaryLiterals
                      DataKinds
                      DefaultSignatures
                      DeriveDataTypeable
                      DeriveFoldable
                      DeriveFunctor
                      DeriveGeneric
                      DeriveLift
                      DeriveTraversable
                      DerivingStrategies
                      InstanceSigs
                      KindSignatures
                      NoStarIsType
                      ScopedTypeVariables
                      StandaloneDeriving
                      TupleSections
                      TypeApplications
                      TypeOperators
                      ViewPatterns

Library
  import:             common-options
  HS-Source-Dirs:     src

  ghc-options:        -Wall -Wcompat
  CPP-Options:        -DCABAL

  other-extensions:   CPP
                      DeriveAnyClass
                      FlexibleContexts
                      FlexibleInstances
                      GeneralizedNewtypeDeriving
                      LambdaCase
                      MultiParamTypeClasses
                      OverloadedStrings
                      RankNTypes
                      RecordWildCards
                      TemplateHaskell

  Build-depends:      aeson                   >= 0.6.2.0  && < 2.1,
                      aeson-pretty            >= 0.8      && < 0.9,
                      ansi-terminal           >= 0.8.0.0  && < 0.12,
                      array,
                      async                   >= 2.2.0    && < 2.3,
                      attoparsec              >= 0.10.4.0 && < 0.15,
                      base                    >= 4.11     && < 5,
                      base16-bytestring       >= 0.1.1    && < 1.1,
                      binary                  >= 0.8.5    && < 0.11,
                      bytestring              >= 0.10.0.2 && < 0.12,
                      clash-prelude           == 1.5.0,
                      concurrent-supply       >= 0.1.7    && < 0.2,
                      containers              >= 0.5.0.0  && < 0.7,
                      cryptohash-sha256       >= 0.11     && < 0.12,
                      data-binary-ieee754     >= 0.4.4    && < 0.6,
                      data-default            >= 0.7      && < 0.8,
                      deepseq                 >= 1.3.0.2  && < 1.5,
                      dlist                   >= 0.8      && < 1.1,
                      directory               >= 1.2.0.1  && < 1.4,
                      exceptions              >= 0.8.3    && < 0.11.0,
                      extra                   >= 1.6.17   && < 1.8,
                      filepath                >= 1.3.0.1  && < 1.5,
                      ghc                     >= 8.6.0    && < 9.1,
                      ghc-boot-th,
                      hashable                >= 1.2.1.0  && < 1.5,
                      haskell-src-meta        >= 0.8      && < 0.9,
                      hint                    >= 0.7      && < 0.10,
                      interpolate             >= 0.2.0    && < 1.0,
                      lens                    >= 4.10     && < 5.1.0,
                      mtl                     >= 2.1.2    && < 2.3,
                      ordered-containers      >= 0.2      && < 0.3,
                      prettyprinter           >= 1.2.0.1  && < 1.8,
                      pretty-show             >= 1.9      && < 2.0,
                      primitive               >= 0.5.0.1  && < 1.0,
                      template-haskell        >= 2.8.0.0  && < 2.18,
                      temporary               >= 1.2.1    && < 1.4,
                      terminal-size           >= 0.3      && < 0.4,
                      text                    >= 1.2.2    && < 2.1,
                      time                    >= 1.4.0.1  && < 1.14,
                      transformers            >= 0.5.2.0  && < 0.7,
                      trifecta                >= 1.7.1.1  && < 2.2,
                      vector                  >= 0.11     && < 1.0,
                      vector-binary-instances >= 0.2.3.5  && < 0.3,
                      unordered-containers    >= 0.2.3.3  && < 0.3,
                      yaml                    >= 0.11     && < 0.12,

  if impl(ghc >= 9.0.0)
    build-depends:     ghc-bignum >=1.0 && <1.3
  else
    build-depends:     integer-gmp >=1.0 && <1.1

  Autogen-Modules:    Paths_clash_lib

  Exposed-modules:    Clash.Annotations.BitRepresentation.ClashLib

                      Clash.Backend
                      Clash.Backend.SystemVerilog
                      Clash.Backend.Verilog
                      Clash.Backend.VHDL

                      Clash.Core.DataCon
                      Clash.Core.EqSolver
                      Clash.Core.Evaluator.Types
                      Clash.Core.FreeVars
                      Clash.Core.HasType
                      Clash.Core.HasFreeVars
                      Clash.Core.Literal
                      Clash.Core.Name
                      Clash.Core.PartialEval
                      Clash.Core.PartialEval.AsTerm
                      Clash.Core.PartialEval.Monad
                      Clash.Core.PartialEval.NormalForm
                      Clash.Core.Pretty
                      Clash.Core.Subst
                      Clash.Core.Term
                      Clash.Core.TermInfo
                      Clash.Core.TermLiteral
                      Clash.Core.TermLiteral.TH
                      Clash.Core.TyCon
                      Clash.Core.Type
                      Clash.Core.TysPrim
                      Clash.Core.Util
                      Clash.Core.Var
                      Clash.Core.VarEnv

                      Clash.Debug

                      Clash.Driver
                      Clash.Driver.Manifest
                      Clash.Driver.Types

                      Clash.Edalize.Edam

                      Clash.Netlist
                      Clash.Netlist.BlackBox
                      Clash.Netlist.BlackBox.Parser
                      Clash.Netlist.BlackBox.Types
                      Clash.Netlist.BlackBox.Util
                      Clash.Netlist.Id
                      Clash.Netlist.Id.Common
                      Clash.Netlist.Id.Internal
                      Clash.Netlist.Id.SystemVerilog
                      Clash.Netlist.Id.Verilog
                      Clash.Netlist.Id.VHDL
                      Clash.Netlist.Types
                      Clash.Netlist.Util

                      Clash.Normalize
                      Clash.Normalize.PrimitiveReductions
                      Clash.Normalize.Primitives
                      Clash.Normalize.Strategy
                      Clash.Normalize.Transformations
                      Clash.Normalize.Transformations.ANF
                      Clash.Normalize.Transformations.Case
                      Clash.Normalize.Transformations.Cast
                      Clash.Normalize.Transformations.DEC
                      Clash.Normalize.Transformations.EtaExpand
                      Clash.Normalize.Transformations.Inline
                      Clash.Normalize.Transformations.Letrec
                      Clash.Normalize.Transformations.MultiPrim
                      Clash.Normalize.Transformations.Reduce
                      Clash.Normalize.Transformations.SeparateArgs
                      Clash.Normalize.Transformations.Specialize
                      Clash.Normalize.Transformations.XOptimize
                      Clash.Normalize.Types
                      Clash.Normalize.Util

                      Clash.Primitives.DSL
                      Clash.Primitives.Types
                      Clash.Primitives.Util

                      Clash.Primitives.GHC.Int
                      Clash.Primitives.GHC.Literal
                      Clash.Primitives.GHC.Word
                      Clash.Primitives.Intel.ClockGen
                      Clash.Primitives.Sized.ToInteger
                      Clash.Primitives.Sized.Signed
                      Clash.Primitives.Sized.Vector
                      Clash.Primitives.Verification

                      Clash.Rewrite.Combinators
                      Clash.Rewrite.Types
                      Clash.Rewrite.Util
                      Clash.Rewrite.WorkFree

                      Clash.Unique
                      Clash.Util
                      Clash.Util.Eq
                      Clash.Util.Graph
                      Clash.Util.Interpolate
                      Clash.Pretty

                      Clash.Verification.Pretty

                      -- Used in v16-upgrade-primitives to decode our non-standard
                      -- JSON primitive files.
                      Data.Aeson.Extra

                      -- Used in clash-cores
                      Data.Text.Prettyprint.Doc.Extra

  Other-Modules:      Clash.Annotations.TopEntity.Extra
                      Data.IntMap.Extra
                      Data.List.Extra
                      Data.Map.Ordered.Extra
                      Data.Monoid.Extra
                      Data.Primitive.ByteArray.Extra
                      Data.Set.Ordered.Extra
                      Data.Text.Extra
                      GHC.BasicTypes.Extra
                      GHC.SrcLoc.Extra
                      Paths_clash_lib

  if flag(debug)
    cpp-options:      -DDEBUG

executable v16-upgrade-primitives
  Main-Is:            tools/v16-upgrade-primitives.hs
  Build-Depends:
    base,
    aeson,
    deepseq,
    yaml,
    bytestring,
    clash-lib,
    containers,
    directory,
    stringsearch,
    Glob
  GHC-Options:        -Wall -Wcompat
  default-language:   Haskell2010

test-suite unittests
  import:           common-options
  type:             exitcode-stdio-1.0
  default-language: Haskell2010
  main-is:          unittests.hs
  ghc-options:      -Wall -Wcompat -threaded -with-rtsopts=-N
  hs-source-dirs:   tests

  if !flag(unittests)
    buildable: False
  else
    build-depends:
      clash-prelude,
      clash-lib,

      ghc-typelits-knownnat,

      aeson,
      aeson-pretty,
      base,
      base16-bytestring,
      bytestring,
      containers,
      concurrent-supply,
      data-default,
      deepseq,
      haskell-src-exts,
      ghc,
      lens,
      pretty-show,
      quickcheck-text,
      tasty         >= 1.2      && < 1.5,
      tasty-hunit,
      tasty-quickcheck,
      template-haskell,
      text,
      transformers,
      unordered-containers

  Other-Modules: Clash.Tests.Core.FreeVars
                 Clash.Tests.Core.Subst
                 Clash.Tests.Driver.Manifest
                 Clash.Tests.Netlist.Id
                 Clash.Tests.Util.Interpolate
                 Clash.Tests.Normalize.Transformations

                 Test.Clash.Rewrite
