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.

Map output ports as well as input ports.

Generate input port names from the argument types.

This replaces the hardcoded list of input port names which was used for
testing before.

Add .gitignore file.

Intial import of some haskell programs.

Contains the following files:
 * Adders.hs     - Some Haskell modelling of hardware adders.
 * Alu.hs        - A haskell model of an (extremely) simple cpu.
 * Bits.hs       - Stuff relating to a basic "Bit" datatype.
 * Inverter.hs   - A haskell model of an inverter.
 * Parser.hs     - A simple haskell parser using Language.Haskell libraries.
 * Shifter.hs    - A haskell model of an interactive xor-shifter.
 * Sim.hs        - Some utilities to run hardware models.
 * Translator.hs - A basic program that uses GHC to read Haskell code and
                   translates it into VHDL. This code is still very preliminary.