I have added two helper functions, but since they are used in contexts that are already specific to C++CSP (i.e. the channel-ends have the ">>" and "<<" operators applied to them) I have not added them to the dictionary of functions.
This patch allows C++CSP to actually use the direction of channels to pass around channel-ends rather than channel pointers, just as C++CSP was designed for.
Neil spotted that I'd broken the C++CSP backend with these changes, and I
wasn't very happy with what I'd done anyway, so this is take 2. Now there's a
separate pass that runs before GenerateC which builds a set of functions used
in PARs.
The types have been added to the AST. Beyond the obvious trivial changes (extra cases in functions, etc), the only
significant change was that isSafeConversion needed to be changed. I took the opportunity to totally rewrite the
function into a graph-like mechanism rather than just using a list. To demonstrate its correctness I also wrote an
exhaustive test for it.
The compiler itself is under the GPLv2+; the support code that gets built into
user programs is under the LGPLv2+. This matches the existing practice for the
KRoC project.
(As with Occade, I've used the new GPLv3-style license header in the source
files, though, since that avoids having to update the FSF's postal address.)
I have added my favourite compiler option "-fwarn-unused-binds" to the Makefile. I've then changed GenerateCPPCSP to have one explicit export, and the
combination of the two would spot any future mistakes like not including the genAlt function in then GenOps structure (see previous patch). This
new warning option already spots one problem with GenerateC, and I have a feeling it will also be useful in future.
It was my own fault of - I changed the genVariable' function in GenerateCPPCSP but forgot to move it out of the "taken verbatim from GenerateC" function,
so Adam removed it during the tidy-up. I've reinstated it from the old version - I need the ".access()" part for accessing individual array elements.
... and update GenerateCPPCSP to do so. This works by having a structure of
operations (GenOps) through which all the recursive calls go, and having
GenerateCPPCSP replace only the operations that it wants to override.
Previously the arrays used the Blitz++ library, but this was not totally satisfactory. I have therefore resorted (after looking at many different
libraries) to using std::vector (which could perhaps be boost::array instead) coupled with a roll-my-own "array view" class (tockArrayView) that
easily allows all the functionality that we need from arrays (slicing, indexing, copying, unknown dimensions,retyping,reshaping). I have also
had to introduce a nasty little wrapper class tockBool, because vector<bool> is a specialisation that totally breaks things. If I do move to
boost::array, I will be able to remove tockBool.
C++CSP backend has been added. It consists of a support header file and one new Haskell module: GenerateCPPCSP
The module is largely based on GenerateC, changed as needed.
There is a large section at the bottom of the file with verbatim copy-and-paste from GenerateC,
due to wanting the same functionality, but for calls to use my C++CSP generation not the C generation --
hence I cannot simply import those functions.
The backend can generate code for cgtests 0 through 16 (incl) that will compile as valid C++. The majority of the
tests pass when run (some do segfault, admittedly). However some arrays still need more testing/work, particularly:
- timers
- array slices
- retyping
The tock_support_cppcsp.h header makes use of tock_support.h, but I had to add a few #ifnders to the latter
file so that I can use it with C++CSP and block out some of the CIF stuff.
