Add Pretty instance for VHDLSession.

Greatly clean up Translator.

Translator now uses Flatten to flatten a function, but does not do
anything after that point yet. Some code is moved from Translator to the
new modules VHDL and TranslatorTypes, but a lot of other code is removed
(since it was duplicated in Flatten, or will be redone in VHDL).

Give stateless a type signature.

This ensures that any function that stateless is inlined into doesn't
become polymorph.

Add pretty printing functions for FlatFunction.

These pretty printing functions are based on Text.PrettyPrint.HughesPJ and
the related Text.PrettyPrint.HughesPJClass from the prettyclass package.

Learn flattenExpr about single alt Case expressions.

Learn flattenExpr about Let expressions.

Learn flattenExpr about building tuples.

Learn flattenExpr to flatten normal applications.

Add useAsPort and useAsState functions.

For this, HsValueMap is made Traversable and a PassState type to wrap a
function was added as well.

Add defMapTouseMap function.

Make HsValueMap an instance of Functor.

Learn flattenExpr about function application.

This only distinguishes tuple construction, other data constructor
application and other function applications, but does not actually flatten
any of these yet.

Make flattenExpr return signal definitions for arguments.

This makes the "wire" example be flattened properly.

Learn flattenExpr about Var expressions.

Learn flattenExpr about Lambda expressions.

Add a BindMap argument to flattenExpr.

Add accessor methods for FlattenState.

Add flattenFunction and flattenExpr.

This does not add any actual implementation for flattenExpr, just an empty
function.

This also duplicates the HsValueMap type from Translator, to prevent
dependency loops when testing.

Add a new module "Flatten".

Only contains data structures so far, but this module will also contain
code for translaten Core to FlatFunctions.

Let Translator.hs export everything.

Name the module in Translator.hs Translator.

The module was previously called Main.

Remove the export list from the Alu module.

This means to export all functions in the module. Previously, it seems
that the alu function was inlined everywhere and thus dropped from the
function list.

Make the arguments of the alu function curried.

Remove the empty state of the alu function.

Create a VHDL proc for each state variable.

This also requires that every entity has a clk inport. This should be
limited to stateful entities only later on.

Generate a list of state, signal pairs as a side effect of generating signal assignments.

Match input and output state using ints.

Use a better name for binders in a lambda expression.

Previously, all signals resulting from a lambda expression were named
"xxx". Now, the actual binder name is included and the name is made
unique.

Improve error message.

Let mkIfaceSigDecs and createSignalAssignments handle Unused values.

Add a D-Flip flop hardware model.

Make state values unused in a SignalNameMap.

Extract mkPort and mkState to the top level.

This also changes their names to useAsPort and useAsState resp.

Print the final session after the output.

Allow variables to be bound to complex expressions.

Previously, variables (in let expressions for example) could only be bound
to single values. This enables them to be bound to for example tuples as
well.

Find state arguments / results in top level functions.

This does not actually handle or propagate state yet.

Add a full_adder version with stateful interface.

The state itself is still empty, this uses the (yank-pasted) stateless
function from Sim.hs to reuse the existing full_adder.

Make a proper HsFunction for top-level functions.

Restructure mkVHDL and getArchitecture a bit.

There is now a expandBind which makes the function signature and adds it
to the session, calls getEntity and getArchitecture and merges the
results.

Create proper HsFunctions for function application.

To keep things working, we also give the builtin functions a proper
HSFunction, since they are the only ones applied up until now.

Index the list of functions with information about argument usage in addition to the function name.

This will allow some sort of function overloading later on. In particular,
it will allow the VHDL interface and implementation of a function be
different depending on how and where the function is called, but still use
the same VHDL entity where the invocations are the same.

The extra information is not yet used or filled in, this will come next.

Introduce a new type HsValueMap.

This type generalized SignalNameMap (which remains as a type alias for
now), but can map a haskell value to any value.

Make tuple construction handling more portable.

Remove the getInstantiations function.

It was no longer used and replaced by expandExpr.

Write the resulting vhdl to file.

Replace - with _ in VHDL ids.

Set VHDL types based on Haskell Types.

Only the Bit type is supported so far.

Store the type of a signal in a SignalNameMap.

Note that the type is still always filled with vhdl_bit_ty, but this moves
this hardcoding from two seperate places to one place (where we can remove
it next).

Make SignalNameMap always map VHDLId's.

Previously, the SignalNameMap had a type argument to specify the
idenitifier type, which helped in transitioning from String to VHDLId but
is not longer used now.

Generate entities in addition to architectures.

Store the VHDLId of a function in HWFunction.

Give Adders a mainIO to to interactive simulation.

Add a a new function "stateless".

This function converts a stateless circuit into a stateful one (with an
empty state), so it can be simulated.

Add a stateless circuit type.

Rename the Circuit type to SCircuit (for stateful)

Rename a bunch of type variables.

Store the RegisterBankState in a algbraic data type.

Show input on each simulation step.

Print the binds we're about to translate.

Implement full_adder in terms of half_adder.

Allow multiple functions to be translated in the same session.

Swap argument order on findBind.

Learn expandExpr how to handle Let expressions.

Make full_adder simpler.

Improve error message for createSignalAssignments.

Learn ExpandExpr how to handle simple case expressions.

Add a base case to splitTupleConstructorArgs.

Apparently we've never tried to find the end of the returned list before :-)

Learn expandExpr how to handle tuple construction.

Add a duplication hardware model.

Implement expandArgs in terms of expandExpr.

This makes expandArgs a lot more general.

Add a double invertor model.

Learn expandExpr how to expand Application.

Let expandExpr error out on unsupported expressions.

Add an invertor hardware model.

Rework the VHDL generation to be more bottom up.

The new function expandExpr does something similar to getInstantiations
(and is used instead of it now), but follows a more bottom up approach,
generating new signals as needed and only connecting these signals to
ports at the very end. This allows for more general handling of nested
expressions and will probably make things less complex.

For now, this means that the Translator can only translate the trivial
"wire" hardware model, more support coming up.

This also means that we're using VHDLId's in almost all SignalNameMaps
now, which reduced the conversion from String.

Add a trivial "wire" hardware model.

Rename PortNameMap to SignalNameMap and make it a dependent type.

Move around some functionality.

This moves some code from getPortMapEntry into a new function expandArgs,
and also prepares for generating signal declarations in addition to
component instantiations.

Reorder and comment things a bit.

Use uniqueName to make component instantiations unique.

Add a uniqueName function.

This function appends a unique number to names to make the names unique.

Add some comments.

Use spaces instead of tabs.

Put getInstantiations in the State monad.

Put getArchitecture inside the State monad.

Make the state monad calling code more pretty.

Run mkHWFunction and addFunc in a State monad.

This uses a state consisting of a VHDLSession. The invocation of these
functions is a bit ugly now, that will be cleaned up next.

Derive Show for the data types we define.

Remove the Args constructor, just use a list instead.

Look up the port names in the session when generating an architecture.

Generate a HWFunction for the function that is being generated.

Lookup input port names for instantiations in the session.

This replaces the previously hardcoded portnames.

Make getPortMapEntry accept a PortNameMap.

Pass around a session variable.

This session variable stores a list of available functions and a number
for generating unique names. So far, the session is only used to lookup
output port names and is read only (ie, not returned from functions).

Use ForSyDe.Backend.VHDL modules to generate VHDL.

The current code is still a bit hacky, but no longer contains hardcoded
VHDL and instead builds a VHDL AST which is then printed by modules from
ForSyDe.

Note that this uses internal ForSyDe modules. ForSyDe was modified to
expose these internal modules.

Remove the entity generation code.

Handle tuple constructors in expressions.

This enables a hardware model to have multiple output ports, using a tuple
type. The code is still a bit hacky and only works for two-tuples.

Let the Adders module export everything.

Add a haskell model for a half adder.

Add an error message.