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...

Let zipValueMapsWith show the trees in the error.

Use tuples instead of a ADT for the register bank state.

We can't translate ADT's yet, but tuples work.

Add space in error message.

Make listBind also show a pretty printed output.

Further reduce main and add a makeVHDL function.

Support multiple alternative case expressions.

Currently, only Bit expressions can be scrutinized.

This also enhances the SigDefs to support expressions (only comparison
with a literal currently) in unconditional definitions.

Add stateful alu (with empty state).

Add a simple four-bit shift register model.

This model is already translatable to VHDL.

Use a different approach for marking SigUses.

This approach iterates the use and signal maps once, instead of twice for
both ports and state.

This also ensures that a signal has at most a single use, a signal is
duplicated otherwise.

This commit makes the dff hardware model synthesize again.

Add setSignalInfo accessor for FlattenState.

Generate VHDL for UncondDefs.

Add a getSignalInfo accessor.

Add a listBind function to show the Core for a bind.

This function is meant to be used from the ghci console.

Split out the large main function a bit.

This greatly reduces the amount of code running inside the Ghc monad.

Remove the DontCare value from the Bit type.

For now this will complicate the translator, so we'll see about DontCare
again when we're ready for it.

Derive and use show instead of ppr to display Exprs.

This shows the actual data structures used in an expression more clearly,
without hiding details like ppr does.

Fix comment indent.

Generalize FApp and CondDef into SigDef and add UncondDef.

Add a type alias StateId for state numbers.

Remove type parameterisation of SignalMap.

Don't generate ports for non-port signals.

This allows an entry in a VHDLSignalmap to be empty, which allows for
arguments and results that do not expand into a port, such as state.

Generate VHDL signals for internal signals and state.

Add predicates for SigUse.

Mark all signals as ports or states when appropriate.

Additionally, this differentiates between input and output ports and old
and new state.

Always import IEEE.std_logic_1164 in the generated VHDL.

Move the DesignFile creation to VHDL.

Add clk port on any stateful entity.

Create state procs for state signals.

Mark port signals as such during flattening.

Improve the pretty output of the signal list.

Make the pretty output more pretty.

This prevents an unwanted wrap in the output.

Reduce genSignals to a single line using Traversable.

Store a use for each signal in a flattened function.

This allows us to differentiate between ports, signals and states more
easily (which is already possible but not so easy right now) and allows
us to differentiate between own state and substate later on.

Currently, all signals are marked as SigInternal.

Add port maps to component instantiations.

Make application names unique.

Add Entities for builtin functions.

Let mkCompInsSm look up the actual VHDL entity id.

Previously, it would always instantiate "foo". This also adds another
entity id field to the "Entity" type, since builtin function don't have a
VHDL EntityDec, but do need an id.

Put mkCompInsSm in the VHDLState monad.

Make modFuncs work with stateful functions.

This allows createArchitecture and createEntity to access the current
session.

Generalize some session modification functions.

Generate dummy component instantiations for each architecture.

We don't have a session available, so we can't lookup or generate any
names yet. Also, the portmaps are not implemented yet.

Move some pretty printing code around.

Use less general names as labels some fields.

Generate a VHDL architecture for each function.

The architecture contains signal declarations, but no instantiations yet.

Add port declarations to the VHDL entities.

Put a TypeMark in a VHDLSignalmap.

Rename fields of SignalInfo.

Store the Haskell Type in SignalInfo.

Add the VHDLTypes module

This file should have been added a few commits back already...

Extract entities from the session and return them in the design file.

Generate VHDL entity declarations.

These declarations are still without ports and with a name that might not
be unique, though.

Create an entity for each function.

The entity does not yet contain the actual VHDL entity, but does contain
the argument / result to port name map.

Store signals in a map.

This turns the list of Signals into a list of (sigid, SignalInfo), which
enables lookup by id.

Name signals in a function after flattening it.

Add a modFunc function to edit a function in the session.

Remove NamedFlatFunction again.

We'll use another way to represent names in FlatFunctions.

Allow a FlatFunction to be named as well as unnamed.

Fill the signal list in FlatFunction.

Add a list of used signals to FlatFunction.

Remove the distinction between SignalDef and SignalUse.

Now everywhere SignalDef and SignalUse was used before, the sigid is used
directly.

Make FlatFunction parameterized with the signal id type.

This allows us to define a NamedFlatFunction later on where the signals
have names.

Move around a bunch of types.

Now most types are defined in a separate module, making it easier to
prevent circular dependencies.

Add more builtin functions.

Only force a stateful interface for top level functions.

Add facilities for builtin functions.

Add a setFlatFunc function.

This function allows for associating a FlatFunction with a HsFunction in
the current session.