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.

Make listBind also show the type of the bind.

Derive Show for more types.

In particular, this derives Show for all Outputable types, which requires
some ugly language pragma's (UndecidableTypes...). However, now HsExpr as
well as Type should be decently showable.

Delete unused Parser.hs.

Add a TODO.

Remove a few stale TODOs.

Import the ieee library into the generated types package.

Filter out dots from generated type id's.

Put vhdl_ty in the (new) TypeState Monad.

This ensures that vhdl_ty can create new types when needed.

Output a package containing all type declarations.

Since there is nothing that registers new types yet, this outputs just an
empty session for now.

Add support for builtin functions again.

Redo the global (state) structure of the translator.

This gives the VHDL module its own state and moves the Entity for each
function into that state. The AST.EntityDec and AST.ArchBody are no longer
stored in the state, but simply returned directly.

The State class used is changed from the one from the mtl library to the
one from the transformers library, since that one integrates nicely with
the data-accessors library. This integration (together with the
simplification of the states) pretty much removes the need for all
manually defined accessor function.

This change breaks support for builtin functions (hwxor, hwnot, etc.),
which will be fixed in a subsequent commit. Also, custom types are not
longer output right now, but there is infrastructure in place to do better
type collection.

Rename VHDLState to TranslatorState.

Use Data.Accessor for FuncData.

Data.Accessor allows for (automatically) defining accessor functions for
reading and writing record fields. This is a field test to see if it's
useful.

Remove createArchitecture from the VHDLState Monad.

Remove mkConcSm from the VHDLState monad.

Remove nameFlatFunction from the VHDLState monad.

Make createEntity preserve the Entity on builtin functions.

Add a getFuncMap accessor for VHDLState.

Derive Show for a bunch of types.

Move the Show deriving for Core types to a new CoreShow module.

Remove the dontcare function from Bits.

Remove createEntity from the VHDLState monad.

Remove getDesignFiles from the VHDLState monad.

This also does some related cleanup.

Strip adjacent underscores from VHDLIds.

Provide preliminary support for list types.

Lot's of TODO's are left...

Add some hardware models using vectors (FSVec).

Fix propagateState removing all non-FApp SigDefs.

Map the clk port on stateful function applications.

Don't inline alu.

Remove support for DontCare.

Fill in propagateState.

Remove the now obsolete getOwnStates.

Add some predicates and accessors to FlattenTypes.

Let VHDL use SignalInfo instead of HsFunction for generating states.

This makes sure that any signals that will be marked SigSubState
won't get an extra state variable.

Add initial (dummy) propagateState function.

The propagateState function will propagate the state variables down to
called functions whenever possible. For now, it just leaves functions
unchanged.

Add vim modeline.

Add a is_FApp predicate.

Never inline the half_adder function.

Add StandalonDeriving language option to Pretty.

Don't add duplicate name hints.

Put VHDL files for each design in a separate directory.

Allow for generating VHDL for stateless functions.

Previously, the top level function needed to be stateful always. Now, the
makeVHDL function has a Bool argument to specify statefulness.

Add some newlines in the output.

Make exec have a single binding.

This prevents two separate invocations of register_bank, which leads to
having a separate register bank for reading and writing.

Add a two-port mux hardware model.

Write each VHDL entity to a seperate file.

Let the exec function output something.

Support construction of empty tuples.

Print the list of signals sorted by id.

Also allow uppercase letters and a period in VHDL ids.

Add name hints to various signals generated.

Strip invalid characters from VHDL identifiers.

Use the name hints in signal name construction.

Do the naming of a signal in named function instead of a lambda.

Allow name hints to be set for a signal.

Enable the DontCare value for Bit again.

This is still not completely fool-proof, improvements will follow.

Print the Defs list sorted.

Make register_bank work, with a bunch of changes.

Add special casing for the "fst", "snd", "patError" and "==" functions.

Add literal and equality tests to the SignalExpr type.

Allow data constructors to be used in expression, when they have a
corresponding literal in VHDL.

Allow full expressions to be scrutinized instead of just variables.

Perhaps more...