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.

Make the flatfunc in FuncMap optional.

Replace FuncMap by a Data.Map.

Derive Ord for HsFunction.

Implement resolvFunc.

This function looks for any used functions in the current module.

Add getFunc session accessor.

Add the current CoreModule to the session.

Replace printBind* by a Pretty instance.

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.