rail-compiler-editor: Compiler and editor for the esolang rail.

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.


A compiler and a graphical editor for the esoteric programming language rail.

[Skip to ReadMe]


Change logNone available
Dependenciesbase (>= && <5), containers, gtk, llvm-general (<3.3.12 || >=3.4 && <3.4.3), llvm-general-pure, mtl, process, transformers [details]
Authorsee AUTHORS
Home pagehttps://github.com/SWP-Ubau-SoSe2014-Haskell/SWPSoSe14
Source repositoryhead: git clone https://github.com/SWP-Ubau-SoSe2014-Haskell/SWPSoSe14.git
ExecutablesRailEditor, RailCompiler
UploadedThu Jun 19 12:55:45 UTC 2014 by bubuiic


Maintainers' corner

For package maintainers and hackage trustees

Readme for rail-compiler-editor-

[back to package description]

# A Rail compiler written in Haskell Build Status

This is (or rather: will become) a compiler for the esoteric programming language Rail, written in Haskell.

Contents of this repository


If you plan to contribute to the project, make sure that your contribution does not break any tests and hlint is happy.

Coding conventions

Though not applied consistently until now, there are some things which would be really NICE to have:

Module testing with HUnit

tests contains a Main.hs file that runs an HUnit test with a list of test functions. For each module src/[module-name].hs of the compiler pipeline exists a corresponding test file tests/T[module-name].hs exporting a list of test functions for the named module. In the Main.hs file the list that is tested by HUnit, is concatenated by the exported test lists of all test modules.

Integration tests

Integration tests are stored in integration-tests in three subdirectories:

Each test consists of two files. A rail program [test-name].rail and an io-file [test-name].io.

The io-file specifies test cases, i.e. a set of inputs with the expected corresponding outputs of the rail-program.

Input and output as well as the test cases themselves are separated by a hash tag. If an input has more than one value, they are separated by a newline. Consider a rail program adding two numbers and printing the result (without any newlines). A corresponding io-file with two test cases could look as follows:


NOTE 1: printed newlines have to be stated explicitly. Consider a hello-world program printing Hello World\n (without any input). The io-file has to look as follows:

Hello World\n

NOTE 2: The expected output is only tested against stdout. If you want to test the output on stderr as well, you can add another section to a test case, separated by a single % line:

This is the input.
This is the expected output on stdout.
This is the expected output on stderr.
Another input.
Another stdout output.

NOTE 3: Lines containing only a single % or # character always delimit sections as described above. There is no way to escape them, sorry.

tests/integration_tests.sh is a script written in bash. It iterates over all rail programs in passing/, compiles each of them using the current version of our rail compiler and retrieves runnable llvm-code, i.e. it already links it with the stack implementation, etc. For each input/output value, it puts the input into the llvm-binary and compares the actual output with the current output. The result will be printed to stdout.

(TODO: do we have to run cabal first manually?)

Dependencies / Building the Compiler


You can generate the compiler documentation using cabal haddock --executables --haddock-options --ignore-all-exports from the root project directory.

Branching model

Currently, there are several (long-lived) team branches and one main development branch, master. The master branch should always contain something that "works" to some degree, i. e. it should never break.

All team branches are merged into the master branch on a regular basis.

Team branches

The following team branches exist. Except for master, all branches not mentioned here are to be considered (short-lived) feature branches.

Additional Information

For additional information take a look at our wiki pages: https://github.com/SWP-Ubau-SoSe2014-Haskell/SWPSoSe14/wiki