Remove the old builtin function support.

Its now replaced by a new structure, no longer needing external VHDL
files.

Filter non-value variables for built-in functions

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

Add error message to mkConcSm for unsupported expressions.

Previously, there was only a cryptic message from ghc, now it also
mentions the unsupported expression.

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

* 'cλash' of http://git.stderr.nl/matthijs/projects/master-project:
  Check parameter counts in mkConcSm instead of the actual generate functions.
  Make the hw functions builtin operators instead of components.
  Fix typo.

Added support for vectors with arbitrary element types

Fix definition of hwor builtin operator.

Check parameter counts in mkConcSm instead of the actual generate functions.

Make the hw functions builtin operators instead of components.

Fix typo.

Added subtype declarations to TypeMap, removed SubtypeMap.

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

* 'cλash' of http://git.stderr.nl/matthijs/projects/master-project: (32 commits)
  Support application of dataconstructors.
  Make mkAssign support assigning to a VHDLName as well.
  Split off record field selection AST construction.
  Only try to generate builtin functions for global binders.
  Never try to normalize global binders.
  Split off assignment generating code.
  Support single-alt selector case expressions.
  Add pprString convenience method.
  Support single-constructor algebraic types.
  Move type registration out of construct_vhdl_ty.
  Split off the VHDL type generating code.
  Actually use the introduced let from a few commits back...
  Error out when normalizing polymorphic functions.
  Add an empty let before starting normalization.
  Add and use a mkFunction utility function.
  Make beta reduction of Case expressions work for type arguments.
  Add function propagation transform.
  Improve debug output timing.
  Don't propagate types with free tyvars.
  Add is_applicable predicate.
  ...

Conflicts:
VHDL.hs

Support application of dataconstructors.

This allows one to create algebraic datatypes (and thus, tuples).

Make mkAssign support assigning to a VHDLName as well.

Previously, assignments could only have a CoreBndr as destination.

Split off record field selection AST construction.

Only try to generate builtin functions for global binders.

Since builtin functions will always come from elsewhere, these will
always be global. Functions for which we can generate components, on the
other hand, will always be local.

Never try to normalize global binders.

These should mostly (always?) be functions imported from elsewhere (for
which we won't have a value) or dataconstructors.

Split off assignment generating code.

Previously, there was some duplicate AST building code for assignments in
mkConcSm. This is not split of into mkAssign, mkUncondAssign and
mkCondAssign.

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

* 'cλash' of http://git.stderr.nl/matthijs/projects/master-project:
  Recursively normalize binds.

Support single-alt selector case expressions.

Add pprString convenience method.

This method can convert any Outputable to a string.

Support single-constructor algebraic types.

These will generate a VHDL record, with one field for each argument.

Move type registration out of construct_vhdl_ty.

construct_vhdl_ty now only creates the type and does not register it in
the session. Additionally, we save only the TypeDef in the session instead
of the TypeDec, since the latter contains the VHDLId which we also store
separately. This means we'll create the TypeDecs later, when outputint the
types VHDL package.

Split off the VHDL type generating code.

Previously, the vhdl_ty function did builtin type lookups, cached custom
types and creating new custom types. Now, the latter is moved into the new
function create_vhdl_ty.

Actually use the introduced let from a few commits back...

Error out when normalizing polymorphic functions.

Add an empty let before starting normalization.

This ensures that every expression will always contain a let at the top
level, since none of the transforms will remove the last let (lets are
only merged when two are nested).

Add and use a mkFunction utility function.

This function creates a new function with a given body and adds it to the
TransformMonad state. The function is named after an existing binder, but
with a new Unique.

Make beta reduction of Case expressions work for type arguments.

Previously, splitFunTy was used, which assumes a function type, while a
type argument is applied to a forall type instead of a function type.
Using applyTypeToArg handles all this for us.

Add function propagation transform.

This transform propagates arguments that have a function type into (a copy
of) the function that's applied to them.

Improve debug output timing.

The Before: line is now really printed before the transform, so also when
the transform fails.

Don't propagate types with free tyvars.

Any free type variables in a type argument wouldn't be in scope in the new
function. Eventually, beta reducation and applicable inlining should make
sure that all type variables are resolved.

Add is_applicable predicate.

This predicate should have been committed a few commits before.

Add has_free_tyvars predicate.

Fix compile error three commits back.

Let inlinefun also apply polymorphic values.

This generalizes inline fun to inline anything that still needs to be
applied to something to become a simple value.

Add getGlobalBinders accessor.

Add functions for creating and referencing type variables.

These functions work for both type variables as well as normal variables,
allowing the code that uses them to work with both.

Make substitute work for type variables as well.

Change the debug output of applyboth a bit.

Add is_poly and is_var predicates.

Make is_fun also work properly for Type CoreExprs.

Previously, this would generate some debug output from exprType, which
isn't properly defined for Type expressions.

Remove two old debug traces.

Add type propagation transform.

This transform propagates type arguments passed to functions into (a copy
of) the called function, effectively removing all type arguments. This is
the first cross-function transformation pass.

Add cloneVar function to clone a Var.

Recursively normalize binds.

This allows for functions to use other (user-defined) functions, which
will then also get VHDL generated. Also restructures some code to make
this possible. In particular, the TranslatorState is now no longer used
(but not yet removed).

Added support for (!) function

Added support for RangedWords

Adders.hs explicityly uses Prelude lists function. TFVec function are the default

Added main function to Main module

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

* 'cλash' of http://git.stderr.nl/matthijs/projects/master-project:
  Add another higher order testcase, highordtest2.
  Support VHDL generation for two-alternative cases.

Conflicts:
Translator.hs

Added function calls

Add another higher order testcase, highordtest2.

This testcase can be succesfully normalized and translated to VHDL.

Support VHDL generation for two-alternative cases.

This does not support single alternatives statements yet, and will never
support more than two alternatives. Only supports case statements on Bit
and Bool types for now.

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

* 'cλash' of http://git.stderr.nl/matthijs/projects/master-project:
  Use highordtest in main, since that can now be normalized.
  Add a (fairly complete) set of transforms.
  Add is_lam and is_fun predicates.
  Add a inlinebind helper function.
  Add a substitute helper function.
  Print the type in the transform debug output.
  Add infrastructure for running core to core transformations.
  Add a higher order testcase.
  Add is_wild function to check for wild binders.
  Generate VHDL from Core instead of flat functions.

Conflicts:
Translator.hs
VHDL.hs

Started adding builtin functions

Cabalized clash

Added global vector function generation

Use highordtest in main, since that can now be normalized.

Add a (fairly complete) set of transforms.

These transforms should normalize most core programs, though this was not
confirmed yet. Also, they do not use any cross-function transforming.

Add is_lam and is_fun predicates.

Add a inlinebind helper function.

This function can create a transformation that will inline some bindings
in a let expression, based on a condition function passed in.

Add a substitute helper function.

This function performs a number of substitutions on a CoreExpr, by using
the CoreSubst module.

Print the type in the transform debug output.

Add infrastructure for running core to core transformations.

This does not add any actual transformations, just the supporting
functions and functions to run the transformations.

Add a higher order testcase.

This testcase is taken from my report and uses some higher order
constructs.

Add is_wild function to check for wild binders.

Generate VHDL from Core instead of flat functions.

This bypasses all of the Flatten functionality for now and generates VHDL
directly. The generation only works on very simple Core programs, that are
already in normal form. An example of such a program is the inv function
in Adders.hs.

For now, all state generation is broken again. Support for ValueMaps has
mostly been removed, since in the future tuples will be translated to
records in VHDL instead of being flattened.

Make listBind support recursive bindings.

This allows listBind to process non-simplified Core modules.

Update the hardware models a bit.

Support binding the scrutinee of a Case expression.

Derive Show CoreSyn.Note.

Let VHDL generate a typecast for SizedWord literals.

Generate VHDL typecasts for literals when needed.

Put mkConcSm inside the VHDLState monad.

This will allow us to acces the TypeMap for typed literals.

Add a Type to a Literal SignalExpr.

The Type is still unused, but will be used for making the VHDL backend add
a typecast (since the actual VHDL name for the type is not known
earlier).

Generalize VHDL type creation for SizedWord and FSVec.

A word has a width, not a length.

Properly save state propagated flat functions.

Previously, the propagated state was not properly saved, resulting in
stateful functions being defined, while stateless versions were
instantiated.

Make the Alu example use 4-bit SizedWord as data.

Since we have no operations on words yet, the alu itself is reduced to a
simple multiplexer for now.

Add (non-working) support for SizedWord literals.

The VHDL produced by this commit does not compile due to type
incompatibility, some thought is needed here.

Translate the SizedWord type to a VHDL vector.

Move eval_type_level_int to CoreTools.

Import the Types.Data.Num module in eval_tfp_int.

This makes eval_tfp_int actually work, since now the proper instances are
in scope.

Add a [ModuleName] parameter to toCore.

This allows callers to put any number of modules into scope before
translating to Core. Previously, functions and values could be
automatically imported by using their qualified name, but now also
instances can be used from modules that would not be imported otherwise.

Fix compilation of CoreTools.

Add an importModule function.

This function allows us to import a module inside the TcRn monad and
properly handles (family) instances. This is needed for working with the
tfp package.

Allow references to global values without arguments.

These references are treated as function applications without arguments.

Move some code out of the flattenExpr to global scope.

Add sized_word_len, which gets the length from a SizedWord type.

Add the new CoreTools module.

This module will contain functions to work with specific constructs
represented as Core expressions and types (i.e., it knows about how
certain libraries are structured and uses functions from there).

For now, this contains a single function to translate (the Core
representation of) a type level int from the tfp package to a real Int.

Add a runTcM utility function.

Derive Show for HsBinds.

Use basic identifiers for builtins.

Make Map.Map an instance of Pretty.

Use extended VHDL identifiers where possible.

Extended VHDL identifiers support a lot more differen characters, so can
preserve the source identifiers a lot better.

Use the actual FSVec length to create VHDL vectors.

Ignore .swp files.

Add the new HsTools module.

This module provides a number of functions to work with HsExprs, CoreExprs
and various types.

Add the new GhcTools module.

This module provides a number of functions to work with GHC and the Ghc
monad.

Cleanup imports and add a vim modeline.