Sound.Bala

Copperbox revision 79.

Quite a big update to Bala. The directory structure has been reorganized and the Midi and Base libraries have been extended.

Sound.Bala

Copperbox revisions 77 & 78.

The sound modules are now under a project named Bala (/libs/sound/Sound/Bala).
Check-in 77 left a few files in the wrong place - these were moved with check-in 78.

Temp: JSON

Copperbox revision 76.

I have added a JSON parser in temp/JSON.hs. JSON seems like a good candidate for a Humdrum-like notation to use with the sound tools.

Sound: ABC

Copperbox revision 75.

Minor updates to the Abc library - the `L`field (field-default-length) had the wrong length type.

I now have a test harness - the parser runs for the simplest of files, but the pretty printer generates ill-formed output.

Sound: ABC

Copperbox revision 74.

Updated the Abc parser and datatypes. The parser is now written with the applicative combinators. The datatypes have been made a bit more uniform, although this has only been done for the `data` definitions and not the `type` synonyms.

Added a pretty printing module and a top-level module.

Sound: ABC

Copperbox revision 73.

Renamed the `midifile` directory to `sound` and added a new sub-directory `Abc`, with a parser for Abc notation. This parser is a rough prototype at the moment.

Midi Lib

Copperbox revision 72.

Updated the file MidiWrite.hs so that it uses the changes to the the Midi datatypes (these changes should have gone in with yesterday's check-in - revision 71).

Added a demo - DemoTrack.hs - that outputs a scale using MidiWrite.

Midi Lib

Copperbox revision 71.

Replaced the Midi file library with a new version. The new version has error handling - undoubtedly a big plus. It is still a quite rough at the edges as I'm working out how much to use the combinators from Control.Applicative and how much to use my own combinators.

C Front End

(aka Frown: c2hs parser)

Copperbox revision 70.

The declaration printer (CDeclr) wasn't printing qualifiers for array declarations, it now does. I've also removed the previous pretty-print combinator libraries as they are no longer used.

Frown: c2hs parser

Copperbox revision 69.

Phew! The new pretty printer is now working properly, so I've update the C printer to use it. There is still quite a bit of work to do on the both parts, but I think I am generally happy with both of them.

Frown: c2hs parser

Copperbox revision 68.

I have added another `empty biased` pretty printer - this one is based on Control.Applicative and is very much a work-in-progress.

Last weekend, I attempted to add layout styles to the C pretty printer using the monadic pretty printer. However the monadic interface wasn't as usable as I had imagined; the new applicative version will hopefully overcome some of its predecessors shortcomings.

Frown: c2hs parser

Copperbox revision 67.

Added a reader monad interface to the pretty printer as per Language.Haskell.Pretty.

This will allow the pretty printer to have different indent and bracing styles.

Frown: c2hs parser

Copperbox revision 66.

Cosmetic updates to the pretty printers again. But I wanted to get a working version committed now as the next step is to try a reader monad version that can handle indent preferences, etc.

Midi Lib

Copperbox revision 65.

Added SysEx and system-specific meta event to the event types.

The midiRead function has problems reading 'in the wild' midi files, so the next step would seem to be to add error handling so I can track where it is going wrong.

Midi Lib

Copperbox revision 64.

Minor tidy up of Midi Lib. Removed field labels from the data types as they were wasting identifiers.

Midi Lib

Copperbox revision 63.

Added a library to read and write Midi files - quality is 'rough' but it does write and read the test file.

Needs Data.Binary from Hackage.

Applicative Packrat Parser

Copperbox revision 62.

Added the usual combinators (satisfy, char, anyChar, manyof aka many, manyone, literal) to the packrat parser.

PS. I rather suspect I am not handling the recursion properly and the parses backtrack when they shouldn't. This makes them plain backtracking parsers rather packrat parsers.

Applicative Packrat Parser

Copperbox revision 61.

Updated the packrat parser so that it parses the example given in Bryan Ford's ICFP'02 paper.

Applicative Packrat Parser

Copperbox revision 60

Added an parser in the packrat style that uses Control.Applicative.

Hopefully the parser is genuinely a packrat parser (that's to say it memoizes results properly rather than uses backtracking), but I'm not sure it is fully lazy. The code is only an experiment so it might get deleted from the repository head at some point, but the nice thing about version control is that it will live on. (Forever?)

Frown: c2hs parser

Copperbox revision 59

Adding the new 'empty biased' pretty printer (show have gone in at revision 58).

Copperbox revision 58

New plain Haskell (not UUAG pretty printer) pretty printer that uses the new pretty printing combinators. The plain version is now as comprehensive as the UUAG version and supersedes it (I will remove UUAG version quite soon).

Frown: c2hs parser

Copperbox revision 57.

Updates to the pretty printer and pretty-print combinators. The combinators now have combinators for prefixing and suffixing. Also the symbols have been changed on the infix combinators, which makes them more pleasant I'd say.

Frown: c2hs parser

Copperbox revision 56

Minor updates to the pretty printer to remove the `optEmpty` function - this was a relic from the old PPrint based pretty printer. Correct a mistake where space char wasn't being printed properly in declarations.

Frown: c2hs parser

Copperbox revision 55.

The pretty printer has been substantially revised, it should now better handle 'empty' documents.

To do this I've introduced a new pretty printing library based on Daan Leijen's PPrint but which is 'empty biased':

Paraphrasing Haskell into something I can type into Blogger:

empty `space` doc results in (doc), whereas with the usual pretty printers it would result in (space, doc).

At the moment the output is less pretty than the previous revision and the new infix combinators have symbols that may be changed, but overall I think it is a good bit simpler for printing C where there are many AST elements that have optional properties.

Frown: c2hs parser

Copperbox revision 54.

Missed update to Demo.hs - should have gone in with the last commit.

Copperbox revision 53.

Added Pretty instances to the AG pretty printer - this means that syntax tree elements can be individually printed.

Frown: c2hs parser

Copperbox revision 52.

Updated the AG pretty printer to use Norman Ramsey's technique for avoiding Lisp-like parens overload.

Text.Diff

Copperbox revision 51.

Updated the udiff parser. Previously it used the Parsec function reserved for hunk markers. This was inadvertently causing end-of-lines to be consumed, not cool on a line based parser.

Text.Diff

Copperbox revision 50.

Added copyright and license notices to Text.Diff.

Frown: c2hs parser

Copperbox revision 49.

Ahem, __attribute__ had been missing as a token from the lexer so attributes wouldn't parse - now corrected.

Added initial support for pretty printing attributes on structs and enums, though it looks like this is incorrect. I think enums and structs can have prefix and suffix attributes, currently they attributes are only printed in prefix position.

Frown: c2hs parser

Copperbox revision 48.

Improved the handling of attribute specifiers in CDecl's - decls can have attributes specs in prefix and suffix positions so now they are separated accordingly.

By the way, yesterday I felt like it was time for an announcement
http://www.haskell.org/pipermail/libraries/2007-May/007537.html

Text.Diff

Copperbox revision 45.

Added a library for reading and creating diff files in the unified format.

In the directory libs/hsdiff.

Frown: c2hs parser

Copperbox revision 44.

Some improvements to the pretty print, plus added initial support for GCC attributes. There is still going to be quite a bit of work to support attributes, some lists seemingly have their elements attributed which might mean the elements will have to be tupled.

Frown: c2hs parser

Copperbox revision 43 - Fixed 'typo' in the Frown parser where enterScope and leaveScope actions were on the wrong productions. Improved the pretty printing quite a bit though there is still much to do.

Frown: c2hs parser

Copperbox revision 40.

Added UUAG attribute grammar support. Because we start with Haskell datatypes the UUAG support is a little bit convoluted (as it needs wrappers over the datatypes), but it is certainly workable.

Started a new AG-based pretty printer for the C syntax.

Frown: c2hs parser

Copperbox revision 39 - added Haddock comment formatting to the Language.C modules

Frown: c2hs parser

Copperbox revision 38 - the Frown version now has the proper typedef from the Happy original, and the typedef.i test file in the C2Hs distribution now parses.

Frown: c2hs parser

Revision 36 - Added expected option to the parser, so that it reports expected tokens on parse failure. Changed the directory layout of the dependent taken from C2Hs so that they resemble Language.Haskell from the hierarchical libraries. Now in the folder:

http://copperbox.googlecode.com/svn/trunk/tools/LanguageC/

Frown: c2hs parser

(Copperbox - Revision 34) - Restored attrs to the C abstract syntax tree. This makes the frown version pretty much equivalent to the Happy original. Of course there may be errors tucked away, and the lexer is still minimal...

Frown: c2hs parser

Typedef handling added.

I have added in the typedef handling from the original Happy parser - at present I have not added the shadowing that was in the original.

copperbox/tools/c2hs_frown revision 30.

Frown: c2hs parser

The Frown parser currently doesn't handle typdefs. As a prelude to adding them I've changed the hand rolled Alex monad into and ErrorT / State monad using the hierarchical libraries.

Frown: c2hs parser

The Frown version of the c2hs parser now works (thats to say it works as far as it has been tested).

In tools directory of the Copperbox project - revision 28.

http://copperbox.googlecode.com/svn/trunk/tools/c2hs_frown/

Frown: c2hs parser

Correction - now all productions really do have actions, though parsing declarators has a bug that needs tracking down.

Frown: c2hs parser

Updated the parser - now all actions are implemented.

The lexer has been updated, though it is still very much demo quality.

Alex / Frown

Added a new Alex template to copperbox/tools/alex_frown that has prettier error messages (at the expense of tracking more state).

Frown: c2hs parser

I have been working on a Frown version of the c2hs C Parser. This is the initial check-in.

The code compiles though the parser has no actions, so it does not build a parse tree. The lexer is also incomplete - white space is the most obvious omission. Getting the code to compile has been over 4 days work, so I'm commiting this draft now.

GHC is taxed by the code that Frown generates. In particular Frown's compact format will not compile even though the code is smaller - the absence of type signatures on such a large file makes trouble for GHC's type inferencing.

NuevoAsdl

Tidied up the 'Compiler' a bit, but it still needs more work to make it something approaching comprehensible. Added LambdaCore a 'typed intermediate language' that will hopefully make code generation easier (we shall see...).

NuevoAsdl

Changes to the makefile. The makefile used to do elaborate things in the Gen directory, now it doesn't. Instead components look after their own construction.

NuevoAsdl

NuevoAsdl updated. Initial work to simplify the 'compiler' and Haskell code generation.

Copperbox

I have a new google code repository to hold projects:
http://code.google.com/p/copperbox/

Currently it holds NuevoAsdl, my Haskell implementation of AsdlGen that generates much of the code for Cil Pickle.

Parsec - a combinator to drop 'water'

Poor man's island parsing with Parsec, water drops lines until the parser p succeeds.
(Somehow Blogger seems to drop the whitespace before where)

water :: Parser a -> Parser a
water p = p <|> do { line; water p }
where line = manyTill anyChar newline

Cil Pickle - commit

Tidied up the OCaml ATerm code a bit (at some point this will be generated from the ASDL definition of the CIL AST).

Cil Pickle - commit

Float pickling added (untested).

Note this converts the float to a string then pickles that, this might contradict what the original ASDL does.

Cil Pickle - commit

Success - Test01 now runs.

This means that Cil/OCaml to ASDL pickle; ASDL pickle to Haskell now works to some degree.

Caveat - floats aren't handled and no doubt there are some bugs lurking where the ASDL description of the CIL AST is slightly different to the OCaml one (it doesn't use 'anonymous' tuples as much as the original OCaml AST).

But... As I'm working out Subversion as I go along I've tagged the code as Release-0.1 (after several attempts - by the time I've got a useful release I should be 'useful' with Subversion).

Cil Pickle - commit

Latest changes:
- added first test (it fails!)
- updated the Haskell unpickling modules

Cil Pickle - commit

Better naming for the aterm pickler code. Conversion to ATerms are done by functions prefixed to_aterm_ .

Cil Pickle - commit

Added generated Haskell AST and pickler code - completely untested.
The code is generated by my own version of ASDLgen which, like cil pickle, is pretty unstable at the moment.

src-code: Cil pickle

cil-pickle project notes
http://code.google.com/p/cil-pickle/

The code is pre-pre-alpha and is of no practical use in its current state...

..but I wanted it to be under version control and using Google Code seemed more convenient than setting up a version control system at home.

Please bear with me.