Fix the trace output of normalized functions.

Before, it would output the un-normalized version.

Filtering out state arguments is no longer needed.

Since State types generate empty VHDL types now, they will be filtered out
automatically.

Generate the empty type for State types.

Allow explicit empty VHDL types using Maybe.

The VHDL type generating functions can now return "Nothing" to mean that an
empty type would be generated. There are still some spots (builtin
functions mostly) that should handle this more gracefully, but it works
for now. Only single-constructor zero-argument algebraic types generate
the empty type currently, e.g. ().

Don't generate input ports for State arguments.

Don't generate VHDL for state packing.

Add TypedThing class, and generalize hasStateType with it.

Add letremoveunused transformation.

This transformation removes all unused let bindings.

Add changeif normalization helper function.

Add expr_uses_binders predicate.

Add {is,has}StateType predicates.

Let mkTupleShow support empty tuples.

Remove the unused "stateful" argument fomr makeVHDL*.

State will be explicitely specified in the Haskell sources, so no reason
anymore to pass the statefulness of a function around.

Merge branch 'master' of git://github.com/christiaanb/clash into cλash

* 'master' of git://github.com/christiaanb/clash:
  Fix builtin functions (!),take and RangedWord

Conflicts:
cλash/CLasH/VHDL/Generate.hs

Restructure the "finder" functions.

Previously, there were three different functions for the top entity,
initial state and test input. Now, there is just a single one, which
guarantees that these things are properly linked together. This should no
also support generating multiple entities at the same time (though there
is no top level interface for this yet).

This change also makes the testbench generation optional. A bunch of
functions were moved from Utils to GhcTools, to prevent a dependency loop.

Add catMaybesM and concatM helper functions.

Use the right id for the testbench architecture.

Fix builtin functions (!),take and RangedWord

Fix testbench again.

The testbench code has also been moved to a separate module.

Split of part of getNormalized into normalizeExpr.

Add unzipM helper function.

Slightly simplify getEntity.

Move around some helper functions.

This moves some stuff from NormalizeTools and NormalizeTypes into the
(new) BinderTools and TranslatorTypes. This also puts most of these
function in the TranslatorSession instead of the TransformMonad.

Remove compatability aliases for the old sessions.

Make vhdl generation and normalization lazy.

Previously, first all function would be (recursively) normalized, and then
VHDL would be generated. Now, functions are normalized when needed, and
recursion is done while generating VHDL (so we know exactly which
components we are instantiating).

This disables the testbench and TFVec constructor for now, I'll fix that
in the next commits.

This also moves some code around, to prevent loops between Generate and
VHDL (again...).

The VHDLSession and NormalizeSession have been removed, and replaced with
the (previously unused) TranslatorSession. There are a few backward
compatibility aliases in place, so the next commit will probably remove
these and do a bunch of trivial replaces all over the code.

Put a comment on UniqSupply generation back.

Merge branch 'master' of git://github.com/christiaanb/clash into cλash

* 'master' of git://github.com/christiaanb/clash:
  TFVec builtin should now completely work
  Clean up imports in Generate.hs
  Use createDirectoryIfMissing to create the vhdl directory, as it can create the parent directories too
  Reflect API changes of clash in clash-nolibdir
  Bring back listBind(ings) in Utils.hs by reorganising Translator.hs and GhcTools.hs
  Fix a few comments so Haddock will complete
  Further clean up Translator.hs (almost done now)
  Cleanup Translator.hs
  Fail again when we find a global function
  Partially fixed TFVec builtin function. Still needs to be verified

TFVec builtin should now completely work

Clean up imports in Generate.hs

Use createDirectoryIfMissing to create the vhdl directory, as it can create the parent directories too

Reflect API changes of clash in clash-nolibdir

Bring back listBind(ings) in Utils.hs by reorganising Translator.hs and GhcTools.hs

Fix a few comments so Haddock will complete

Further clean up Translator.hs (almost done now)

Cleanup Translator.hs

Can be reduced in size even more by parameterizing the findcore functions
to work for both strings and annotations

Fail again when we find a global function

Was only disabled to fix the builtin TFVec function

Partially fixed TFVec builtin function. Still needs to be verified

Merge casevalsimpl and casewild into casesimpl.

Both transformations had a very similar structure, which are now merged.

Fix a small bug in the case wildening.

This bug could be triggered when the scrutinee was a datatype containing a
non-representable value. This is probably not translatable, but handle it
properly anyway.

Prevent conflicts with inlinenonrep in normalization.

This is a followup on
ebdc2024d7cf71: Let inlinefun inline everything non-representable.
which make inlinefun more general. A few other normalizations tried to
prevent loops with inline fun, but now work correctly for the (new)
inlinenonrep.

Merge branch 'master' of git://github.com/christiaanb/clash into cλash

* 'master' of git://github.com/christiaanb/clash:
  Quick hack implementation of FSVec literals, needs to be fixed
  We need the latest vhdl package
  We now make a show function for all default datatypes.
  Add automated testbench generation according to supplied test input

Conflicts:
cλash/CLasH/Translator.hs

Quick hack implementation of FSVec literals, needs to be fixed

We need the latest vhdl package

We now make a show function for all default datatypes.

We need to figure out how to show custom datatypes in VHDL, for that
we will need a string representation for each constructor.

Add automated testbench generation according to supplied test input

Will not compile in VHDL yet as we need to implement the VHDL show method first

Show type of binder in listBinding.

Make listBind use listBinding.

Extend CoreShow for TyCons.

This still does not completely show TyCons, since they are quite complex,
but at least distinguishes the various constructors and some useful info.

Remove NoGenerics pragma, as the ghc bug 3391 is now fixed

Add a clash wrapper that fills in the libdir from GHC.Paths

Also add NoGenerics pragma to the other types.hs files

Fix core show

Currently Generics support is broken in combination with deriveAccessors

Add licence to top directory

Removed need for GHC.Paths, some functions however require a top libdir

Update .cabal file so that a default build is expected to be in the GHC tree

Make sure clash is build using stage2 ghc when build in ghc build tree

Changed name of cabal file so it will work in the GHC build tree

Changed build-depends to only those libraries required to build clash

tfvec, tfp and th-lift-ng are however required to translate any haskell
file to VHDL. They will be included in the clash package

We now support Annotations to indicate top-level entity and initial state

No need for Main.hs now that clash is a library

Adepted the modules to their new structure

Moved clash to it's own library directory, and started on library structure

Moved to new GHC API (6.11). Also use vhdl package for the VHDL AST

Remove the (now unused) is_wild predicate.

Don't create selector cases for unused binders.

Previously, no selector cases were created for wild binders, using the
hacky is_wild predicate. Now, this checks the free variables of the case
value instead.

Merge git://github.com/darchon/clash into cλash

* git://github.com/darchon/clash:
  Added resize function

Added resize function

Remove some unused code.

Use noSrcSpan instead of a dummy SrcSpan.

Simplify eitherCoreOrExprArgs.

Pulled 'varToVHDLExpr' into the TypeSession monad

No longer any need to explicitly load module interface in 'toCore'

We have to HscEnv from the original HaskellToCore compilation step
that already includes all the module interfaces we need.

Merge branch 'cλash' of git.stderr.nl/matthijs/projects/master-project

* 'cλash' of http://git.stderr.nl/matthijs/projects/master-project:
  Generate proper VHDL for top level bindings with no arguments.
  Use is_local_var for limiting appsimpl and letsimpl.
  Add newline at the end of file.
  Add is_local_var predicate.
  Santize comment dashes position.
  Normalize all used global binders.

Generate proper VHDL for top level bindings with no arguments.

Previously, a = b bindings would always generate an unconditional
assignment. Now, they use genApplication to generate VHDL, and
genApplications knows how to generate unconditional assignments when b is
a local identifier, and a component instantiation when b is a top level
binder.

Use is_local_var for limiting appsimpl and letsimpl.

Previously, appsimple and letsimpl would refrain from simplifying any Var
expression, since they are already simple. Now, they only refrain from
simplifying local variables, so references to top-level bindings will
still be simplified. This enables proper normalization of top level
bindings without arguments.

Add newline at the end of file.

Add is_local_var predicate.

Only save normalized tfp integers in the tfp-cache

Use HscEnv from initial HsToCore transformation when translating tfp to int

Santize comment dashes position.

This allows us to comment some lines in and out without having to remember
the exact position of the comment dashes (to prevent unneeded changes in
git).

Normalize all used global binders.

Previously, only function-typed binders were normalized (not necessarily
limited to global ones!).

Great speed-up in type generation

Now just normalize tfp ints that are used as keys for the type map
Before these were translated to integers.

Save a map caches tfp ints, and their correspding integer literal

Correctly handle negate for unsigned integers

Partly fixed implementation for integer literals.

But it still needs alot of fixing

VERY Ad-hoc support of literals.

Current implementation will probably fail in a lot of places

Added support for SizedInts and cleaned up some function related to SizedWords

Started adding numeric operations

Caching converted tfp integers to speedup translation

Updated cabal file to reflect change in TFVec, and the need for the filepath library

Merge branch 'cλash' of git.stderr.nl/matthijs/projects/master-project

* 'cλash' of http://git.stderr.nl/matthijs/projects/master-project:
  Let inlinefun inline everything non-representable.
  Unify typeprop and funprop into argprop.
  Extract only representable arguments.
  Add predicates for testing representability of types.

Made Bit an instance of Lift so it can be used in vectorTH

vectorTH works now, but you will need the latest version of TFVec

Let inlinefun inline everything non-representable.

This changes its name to inlinenonrep and makes it inline everything that
is not representable (which helps in particular for dictionary
construction expressions...).

I've not yet changed the conditions in various other transforms, so if
something silly would happen like having a dictionary as the value or
scrutinee of a case of let expression, things might go into an infinite
loop.

Also, since HTypes are generated very often now, things are really
starting to slow down...

Unify typeprop and funprop into argprop.

This also generalizes the conditions a bit by propagating anything that is
not representable.

Extract only representable arguments.

Previously, anything but types and functions was extracted. This
definition is slightly more general, but it should not matter for the
programs we work with.

Add predicates for testing representability of types.

These predicates try to build a VHDL type from a Core Type, to see if it
will be representable in hardware.

Let mkHType also return errors using Either.

Merge git://github.com/darchon/clash into cλash

* git://github.com/darchon/clash:
  Keys for typemap can now deal with vector lengths based on type operators

Conflicts:
Generate.hs
VHDLTools.hs

Put a TypeState in TransformState.

This will allow transforms to test if a Type is representable in VHDL.

Split off the type related VHDLState variables.

These are now put in a substate of VHDLState, named TypeState. This allows
a TypeState to be put into TransformState later on as well.