Remove obsolete Haskell-based compiler.

55b3cc25 · Kenton Varda · ae33cf61 · ae33cf61 · ae33cf61 · ae33cf61
Commit 55b3cc25 authored Aug 10, 2013 by Kenton Varda
16 changed files
--- a/compiler/LICENSE.txt
+++ b/compiler/LICENSE.txt
-../LICENSE
\ No newline at end of file
--- a/compiler/README.txt
+++ b/compiler/README.txt
-Cap'n Proto - Insanely Fast Data Serialization Format
-Copyright 2013 Kenton Varda
-http://kentonv.github.com/capnproto/
-
-Cap'n Proto is an insanely fast data interchange format and capability-based
-RPC system.  Think JSON, except binary.  Or think of Google's Protocol Buffers
-(http://protobuf.googlecode.com), except faster.  In fact, in benchmarks,
-Cap'n Proto is INFINITY TIMES faster than Protocol Buffers.
-
-This package is the executable tool which parses Cap'n Proto schema definitions
-and generates corresponding source code in various target languages.  To be
-useful, you will also need to obtain a runtime library for your target
-language.  These are distributed separately.
-
-Full installation and usage instructions and other documentation are maintained
-on the Cap'n Proto web site:
-  http://kentonv.github.io/capnproto/install.html
-  
-To build and install, simply do:
-  cabal install capnproto-compiler.cabal
--- a/compiler/Setup.hs
+++ b/compiler/Setup.hs
-import Distribution.Simple
-main = defaultMain
--- a/compiler/capnproto-compiler.cabal
+++ b/compiler/capnproto-compiler.cabal
-name:           capnproto-compiler
-version:        0.2-dev
-cabal-version:  >=1.2
-build-type:     Simple
-author:         Kenton Varda <temporal@gmail.com>
-maintainer:     capnproto@googlegroups.com
-homepage:       http://kentonv.github.io/capnproto/
-- actually BSD2, but that's not on the list for some reason
-license:        BSD3
-license-file:   LICENSE.txt
-synopsis:       Schema parser and code generator for Cap'n Proto serialization/RPC system.
-category:       Data
-description:
-  Cap’n Proto is an insanely fast data interchange format and capability-based RPC system. Think
-  JSON, except binary. Or think Protocol Buffers, except faster. In fact, in benchmarks, Cap’n
-  Proto is INFINITY TIMES faster than Protocol Buffers.
-
-  This package is the executable tool which parses Cap'n Proto schema definitions and generates
-  corresponding source code in various target languages.  To be useful, you will also need to
-  obtain a runtime library for your target language.  These are distributed separately.
-
-  See the web site for full documentation:  http://kentonv.github.io/capnproto/
-
-- How to get stack traces:
-- 1. Compile normally and do not clean.
-- 2. Add "-prof -fprof-auto -osuf .prof.o" to ghc-options and compile again.
--    (TODO:  Figure out how to add these through "cabal configure" instead of by editing
--    this file.  --enable-executable-profiling alone doesn't appear to get the job done.)
-- 3. Run with +RTS -xc -RTS on the command line.
-
-extra-source-files:
-                   README.txt,
-                   src/c++-source.mustache,
-                   src/c++-header.mustache
-
-executable capnpc
-  hs-source-dirs:  src
-  main-is:         Main.hs
-  build-depends:
-                   base >= 4,
-                   parsec,
-                   mtl,
-                   containers,
-                   file-embed,
-                   bytestring,
-                   Crypto,
-                   utf8-string,
-                   hastache,
-                   array,
-                   data-binary-ieee754,
-                   filepath,
-                   directory,
-                   syb,
-                   transformers,
-                   entropy,
-                   process
-  ghc-options:     -Wall -fno-warn-missing-signatures
-  other-modules:
-                   Lexer,
-                   Token,
-                   Grammar,
-                   Parser,
-                   Compiler,
-                   Semantics,
-                   Util,
-                   CxxGenerator,
-                   WireFormat
--- a/compiler/src/Compiler.hs
+++ b/compiler/src/Compiler.hs
--- a/compiler/src/CxxGenerator.hs
+++ b/compiler/src/CxxGenerator.hs
--- a/compiler/src/Grammar.hs
+++ b/compiler/src/Grammar.hs
-- Copyright (c) 2013, Kenton Varda <temporal@gmail.com>
-- All rights reserved.
--
-- Redistribution and use in source and binary forms, with or without
-- modification, are permitted provided that the following conditions are met:
--
-- 1. Redistributions of source code must retain the above copyright notice, this
--    list of conditions and the following disclaimer.
-- 2. Redistributions in binary form must reproduce the above copyright notice,
--    this list of conditions and the following disclaimer in the documentation
--    and/or other materials provided with the distribution.
--
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-module Grammar where
-
-import Token (Located)
-import Data.Maybe (maybeToList)
-import Data.Word (Word64)
-
-data DeclName = AbsoluteName (Located String)
-              | RelativeName (Located String)
-              | ImportName (Located String)
-              | MemberName DeclName (Located String)
-              deriving (Show)
-
-declNameImport :: DeclName -> Maybe (Located String)
-declNameImport (AbsoluteName _) = Nothing
-declNameImport (RelativeName _) = Nothing
-declNameImport (ImportName s) = Just s
-declNameImport (MemberName parent _) = declNameImport parent
-
-data TypeParameter = TypeParameterType TypeExpression
-                   | TypeParameterInteger Integer
-                   deriving (Show)
-data TypeExpression = TypeExpression DeclName [TypeParameter]
-                    deriving (Show)
-
-typeParameterImports :: TypeParameter -> [Located String]
-typeParameterImports (TypeParameterType t) = typeImports t
-typeParameterImports (TypeParameterInteger _) = []
-
-typeImports :: TypeExpression -> [Located String]
-typeImports (TypeExpression name params) =
-    maybeToList (declNameImport name) ++ concatMap typeParameterImports params
-
-data Annotation = Annotation DeclName (Located FieldValue) deriving(Show)
-
-annotationImports (Annotation name _) = maybeToList $ declNameImport name
-
-data FieldValue = VoidFieldValue
-                | BoolFieldValue Bool
-                | IntegerFieldValue Integer
-                | FloatFieldValue Double
-                | StringFieldValue String
-                | IdentifierFieldValue String
-                | ListFieldValue [Located FieldValue]
-                | RecordFieldValue [(Located String, Located FieldValue)]
-                | UnionFieldValue String FieldValue
-                deriving (Show)
-
-data ParamDecl = ParamDecl String TypeExpression [Annotation] (Maybe (Located FieldValue))
-               deriving (Show)
-
-paramImports (ParamDecl _ t ann _) = typeImports t ++ concatMap annotationImports ann
-
-data AnnotationTarget = FileAnnotation
-                      | ConstantAnnotation
-                      | EnumAnnotation
-                      | EnumerantAnnotation
-                      | StructAnnotation
-                      | FieldAnnotation
-                      | UnionAnnotation
-                      | InterfaceAnnotation
-                      | MethodAnnotation
-                      | ParamAnnotation
-                      | AnnotationAnnotation
-                      deriving(Eq, Ord, Bounded, Enum)
-
-instance Show AnnotationTarget where
-    show FileAnnotation = "file"
-    show ConstantAnnotation = "const"
-    show EnumAnnotation = "enum"
-    show EnumerantAnnotation = "enumerant"
-    show StructAnnotation = "struct"
-    show FieldAnnotation = "field"
-    show UnionAnnotation = "union"
-    show InterfaceAnnotation = "interface"
-    show MethodAnnotation = "method"
-    show ParamAnnotation = "param"
-    show AnnotationAnnotation = "annotation"
-
-data Declaration = UsingDecl (Located String) DeclName
-                 | ConstantDecl (Located String) TypeExpression [Annotation] (Located FieldValue)
-                 | EnumDecl (Located String) (Maybe (Located Word64)) [Annotation] [Declaration]
-                 | EnumerantDecl (Located String) (Located Integer) [Annotation]
-                 | StructDecl (Located String) (Maybe (Located Word64))
-                              (Maybe (Located (Integer, Integer))) [Annotation] [Declaration]
-                 | FieldDecl (Located String) (Located Integer)
-                             TypeExpression [Annotation] (Maybe (Located FieldValue))
-                 | UnionDecl (Located String) (Located Integer) [Annotation] [Declaration]
-                 | InterfaceDecl (Located String) (Maybe (Located Word64))
-                                 [Annotation] [Declaration]
-                 | MethodDecl (Located String) (Located Integer) [ParamDecl]
-                              TypeExpression [Annotation]
-                 | AnnotationDecl (Located String) (Maybe (Located Word64)) TypeExpression
-                                  [Annotation] [AnnotationTarget]
-                 deriving (Show)
-
-declarationName :: Declaration -> Maybe (Located String)
-declarationName (UsingDecl n _)            = Just n
-declarationName (ConstantDecl n _ _ _)     = Just n
-declarationName (EnumDecl n _ _ _)         = Just n
-declarationName (EnumerantDecl n _ _)      = Just n
-declarationName (StructDecl n _ _ _ _)     = Just n
-declarationName (FieldDecl n _ _ _ _)      = Just n
-declarationName (UnionDecl n _ _ _)        = Just n
-declarationName (InterfaceDecl n _ _ _)    = Just n
-declarationName (MethodDecl n _ _ _ _)     = Just n
-declarationName (AnnotationDecl n _ _ _ _) = Just n
-
-declImports :: Declaration -> [Located String]
-declImports (UsingDecl _ name) = maybeToList (declNameImport name)
-declImports (ConstantDecl _ t ann _) = typeImports t ++ concatMap annotationImports ann
-declImports (EnumDecl _ _ ann decls) = concatMap annotationImports ann ++ concatMap declImports decls
-declImports (EnumerantDecl _ _ ann) = concatMap annotationImports ann
-declImports (StructDecl _ _ _ ann decls) = concatMap annotationImports ann ++
-                                           concatMap declImports decls
-declImports (FieldDecl _ _ t ann _) = typeImports t ++ concatMap annotationImports ann
-declImports (UnionDecl _ _ ann decls) = concatMap annotationImports ann ++
-                                        concatMap declImports decls
-declImports (InterfaceDecl _ _ ann decls) = concatMap annotationImports ann ++
-                                            concatMap declImports decls
-declImports (MethodDecl _ _ params t ann) =
-    concat [concatMap paramImports params, typeImports t, concatMap annotationImports ann]
-declImports (AnnotationDecl _ _ t ann _) = typeImports t ++ concatMap annotationImports ann
--- a/compiler/src/Lexer.hs
+++ b/compiler/src/Lexer.hs
-- Copyright (c) 2013, Kenton Varda <temporal@gmail.com>
-- All rights reserved.
--
-- Redistribution and use in source and binary forms, with or without
-- modification, are permitted provided that the following conditions are met:
--
-- 1. Redistributions of source code must retain the above copyright notice, this
--    list of conditions and the following disclaimer.
-- 2. Redistributions in binary form must reproduce the above copyright notice,
--    this list of conditions and the following disclaimer in the documentation
--    and/or other materials provided with the distribution.
--
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-module Lexer (lexer) where
-
-import Text.Parsec hiding (token, tokens)
-import Text.Parsec.String
-import Control.Monad (liftM, when)
-import qualified Text.Parsec.Token as T
-import Text.Parsec.Language (emptyDef)
-import Token
-import Data.Char (isUpper, isLower)
-
-keywords =
-    [ (VoidKeyword, "void")
-    , (TrueKeyword, "true")
-    , (FalseKeyword, "false")
-    , (InKeyword, "in")
-    , (OfKeyword, "of")
-    , (OnKeyword, "on")
-    , (AsKeyword, "as")
-    , (WithKeyword, "with")
-    , (FromKeyword, "from")
-    , (ImportKeyword, "import")
-    , (UsingKeyword, "using")
-    , (ConstKeyword, "const")
-    , (EnumKeyword, "enum")
-    , (StructKeyword, "struct")
-    , (UnionKeyword, "union")
-    , (InterfaceKeyword, "interface")
-    , (AnnotationKeyword, "annotation")
--    , (FixedKeyword, "fixed")     -- Inlines have been disabled because they were too complicated.
-    ]
-
-languageDef :: T.LanguageDef st
-languageDef = emptyDef
-    { T.commentLine = "#"
-    , T.identStart = letter <|> char '_'
-    , T.identLetter = alphaNum <|> char '_'
-    , T.reservedNames = [name | (_, name) <- keywords]
-    , T.opStart = T.opLetter languageDef
-    , T.opLetter = fail "There are no operators."
-    }
-
-tokenParser = T.makeTokenParser languageDef
-
-rawIdentifier  = T.identifier tokenParser
-reserved       = T.reserved tokenParser
-symbol         = T.symbol tokenParser
-naturalOrFloat = T.naturalOrFloat tokenParser
-braces         = T.braces tokenParser
-parens         = T.parens tokenParser
-brackets       = T.brackets tokenParser
-whiteSpace     = T.whiteSpace tokenParser
-stringLiteral  = T.stringLiteral tokenParser
-
-keyword :: Parser Token
-keyword = foldl1 (<|>) [reserved name >> return t | (t, name) <- keywords]
-
-toLiteral :: Either Integer Double -> Token
-toLiteral (Left i) = LiteralInt i
-toLiteral (Right d) = LiteralFloat d
-
-located :: Parser t -> Parser (Located t)
-located p = do
-    pos <- getPosition
-    t <- p
-    return (Located pos t)
-
-isTypeName (c:_) = isUpper c
-isTypeName _ = False
-
-hasUppercaseAcronym (a:rest@(b:c:_)) =
-    (isUpper a && isUpper b && not (isLower c)) || hasUppercaseAcronym rest
-hasUppercaseAcronym (a:b:[]) = isUpper a && isUpper b
-hasUppercaseAcronym _ = False
-
-identifier :: Parser Token
-identifier = do
-    text <- rawIdentifier
-    when (elem '_' text) $
-        fail "Identifiers containing underscores are reserved for the implementation.  Use \
-             \camelCase style for multi-word names."
-    when (hasUppercaseAcronym text) $
-        fail "Wrong style:  Only the first letter of an acronym should be capitalized.  \
-             \Consistent style is necessary to allow code generators to sanely translate \
-             \names into the target language's preferred style."
-    return (if isTypeName text then TypeIdentifier text else Identifier text)
-
-tokenSequence = do
-    tokens <- many1 locatedToken
-    endPos <- getPosition
-    return (TokenSequence tokens endPos)
-
-token :: Parser Token
-token = keyword
-    <|> identifier
-    <|> liftM ParenthesizedList   (parens (sepBy tokenSequence (symbol ",")))
-    <|> liftM BracketedList       (brackets (sepBy tokenSequence (symbol ",")))
-    <|> liftM toLiteral           naturalOrFloat
-    <|> liftM LiteralString       stringLiteral
-    <|> liftM (const AtSign)      (symbol "@")
-    <|> liftM (const Colon)       (symbol ":")
-    <|> liftM (const DollarSign)  (symbol "$")
-    <|> liftM (const Period)      (symbol ".")
-    <|> liftM (const EqualsSign)  (symbol "=")
-    <|> liftM (const MinusSign)   (symbol "-")
-    <|> liftM (const Asterisk)    (symbol "*")
-    <|> liftM (const ExclamationPoint) (symbol "!")
-    <?> "token"
-
-locatedToken = located token
-
-statementEnd :: Parser (Maybe [Located Statement])
-statementEnd = (symbol ";" >>= \_ -> return Nothing)
-           <|> (braces (many locatedStatement) >>= \statements -> return (Just statements))
-
-compileStatement :: TokenSequence -> Maybe [Located Statement] -> Statement
-compileStatement tokens Nothing = Line tokens
-compileStatement tokens (Just statements) = Block tokens statements
-
-statement :: Parser Statement
-statement = do
-    tokens <- tokenSequence
-    end <- statementEnd
-    return (compileStatement tokens end)
-
-locatedStatement = located statement
-
-lexer :: Parser [Located Statement]
-lexer = do
-    whiteSpace
-    tokens <- many locatedStatement
-    eof
-    return tokens
--- a/compiler/src/Main.hs
+++ b/compiler/src/Main.hs
--- a/compiler/src/Parser.hs
+++ b/compiler/src/Parser.hs
--- a/compiler/src/Semantics.hs
+++ b/compiler/src/Semantics.hs
--- a/compiler/src/Token.hs
+++ b/compiler/src/Token.hs
-- Copyright (c) 2013, Kenton Varda <temporal@gmail.com>
-- All rights reserved.
--
-- Redistribution and use in source and binary forms, with or without
-- modification, are permitted provided that the following conditions are met:
--
-- 1. Redistributions of source code must retain the above copyright notice, this
--    list of conditions and the following disclaimer.
-- 2. Redistributions in binary form must reproduce the above copyright notice,
--    this list of conditions and the following disclaimer in the documentation
--    and/or other materials provided with the distribution.
--
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-{-# LANGUAGE DeriveDataTypeable #-}
-
-module Token where
-
-import Data.Generics
-import Text.Parsec.Pos (SourcePos, sourceLine, sourceColumn)
-import Text.Printf (printf)
-
-data Located t = Located { locatedPos :: SourcePos, locatedValue :: t } deriving (Typeable, Data)
-
-instance Show t => Show (Located t) where
-    show (Located pos x) = printf "%d:%d:%s" (sourceLine pos) (sourceColumn pos) (show x)
-
-instance Eq a => Eq (Located a) where
-    Located _ a == Located _ b = a == b
-
-instance Ord a => Ord (Located a) where
-    compare (Located _ a) (Located _ b) = compare a b
-
-data TokenSequence = TokenSequence [Located Token] SourcePos deriving(Data, Typeable, Show, Eq)
-
-data Token = Identifier String
-           | TypeIdentifier String
-           | ParenthesizedList [TokenSequence]
-           | BracketedList [TokenSequence]
-           | LiteralInt Integer
-           | LiteralFloat Double
-           | LiteralString String
-           | VoidKeyword
-           | TrueKeyword
-           | FalseKeyword
-           | AtSign
-           | Colon
-           | DollarSign
-           | Period
-           | EqualsSign
-           | MinusSign
-           | Asterisk
-           | ExclamationPoint
-           | InKeyword
-           | OfKeyword    -- We reserve some common, short English words for use as future keywords.
-           | OnKeyword
-           | AsKeyword
-           | WithKeyword
-           | FromKeyword
-           | ImportKeyword
-           | UsingKeyword
-           | ConstKeyword
-           | EnumKeyword
-           | StructKeyword
-           | UnionKeyword
-           | InterfaceKeyword
-           | AnnotationKeyword
-           | FixedKeyword
-           deriving (Data, Typeable, Show, Eq)
-
-data Statement = Line TokenSequence
-               | Block TokenSequence [Located Statement]
-               deriving (Show)
--- a/compiler/src/Util.hs
+++ b/compiler/src/Util.hs
-- Copyright (c) 2013, Kenton Varda <temporal@gmail.com>
-- All rights reserved.
--
-- Redistribution and use in source and binary forms, with or without
-- modification, are permitted provided that the following conditions are met:
--
-- 1. Redistributions of source code must retain the above copyright notice, this
--    list of conditions and the following disclaimer.
-- 2. Redistributions in binary form must reproduce the above copyright notice,
--    this list of conditions and the following disclaimer in the documentation
--    and/or other materials provided with the distribution.
--
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-module Util where
-
-import Data.Char (isUpper, toUpper)
-import Data.List (intercalate, isPrefixOf)
-import Data.Bits(shiftR, Bits)
-import Data.Word(Word8)
-
--delimit _ [] = ""
--delimit delimiter (h:t) = h ++ concatMap (delimiter ++) t
-delimit = intercalate
-
-splitOn :: String -> String -> [String]
-splitOn _ "" = [""]
-splitOn delimiter text | delimiter `isPrefixOf` text =
-    []:splitOn delimiter (drop (length delimiter) text)
-splitOn delimiter (c:rest) = let (first:more) = splitOn delimiter rest in (c:first):more
-
-- Splits "camelCase" into ["camel", "Case"]
-splitName :: String -> [String]
-splitName (a:rest@(b:_)) | isUpper b = [a]:splitName rest
-splitName (a:rest) = case splitName rest of
-    firstWord:moreWords -> (a:firstWord):moreWords
-    [] -> [[a]]
-splitName [] = []
-
-toTitleCase :: String -> String
-toTitleCase (a:rest) = toUpper a:rest
-toTitleCase [] = []
-
-toUpperCaseWithUnderscores :: String -> String
-toUpperCaseWithUnderscores name = delimit "_" $ map (map toUpper) $ splitName name
-
-intToBytes :: (Integral a, Bits a) => a -> Int -> [Word8]
-intToBytes i count = map (byte i) [0..(count - 1)] where
-    byte :: (Integral a, Bits a) => a -> Int -> Word8
-    byte i2 amount = fromIntegral (shiftR i2 (amount * 8))
--- a/compiler/src/WireFormat.hs
+++ b/compiler/src/WireFormat.hs
--- a/compiler/src/c++-header.mustache
+++ b/compiler/src/c++-header.mustache
--- a/compiler/src/c++-source.mustache
+++ b/compiler/src/c++-source.mustache
-{{!
-| Copyright (c) 2013, Kenton Varda <temporal@gmail.com>
-| All rights reserved.
-|
-| Redistribution and use in source and binary forms, with or without
-| modification, are permitted provided that the following conditions are met:
-|
-| 1. Redistributions of source code must retain the above copyright notice, this
-|    list of conditions and the following disclaimer.
-| 2. Redistributions in binary form must reproduce the above copyright notice,
-|    this list of conditions and the following disclaimer in the documentation
-|    and/or other materials provided with the distribution.
-|
-| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-| ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-| WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-| DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-| ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-| (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-| LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-| ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-| SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-Template for generated C++ source files.
-}}// Generated code, DO NOT EDIT
-
-#include "{{fileName}}.h"
-
-{{#fileNamespaces}}
-namespace {{namespaceName}} {
-{{/fileNamespaces}}
-
-{{#fileTypes}}
-{{#typeStructOrUnion}}
-{{#typeStruct}}
-{{#structFields}}
-{{#fieldDefaultBytes}}
-const ::capnp::_::AlignedData<{{defaultWordCount}}>
-    {{structFullName}}::DEFAULT_{{fieldUpperCase}} = {
-  { {{defaultByteList}} }
-};
-{{/fieldDefaultBytes}}
-{{/structFields}}
-{{/typeStruct}}
-{{/typeStructOrUnion}}
-{{/fileTypes}}
-
-{{#fileNamespaces}}
-}  // namespace
-{{/fileNamespaces}}
-
-namespace capnp {
-namespace schemas {
-
-{{#fileTypes}}
-{{#typeSchema}}
-static const ::capnp::_::AlignedData<{{schemaWordCount}}> b_{{schemaId}} = {
-  { {{schemaBytes}} }
-};
-static const ::capnp::_::RawSchema* const d_{{schemaId}}[] = {
-{{#schemaDependencies}}
-  &s_{{dependencyId}},
-{{/schemaDependencies}}
-};
-static const ::capnp::_::RawSchema::MemberInfo m_{{schemaId}}[] = {
-{{#schemaMembersByName}}
-  { {{memberUnionIndex}}, {{memberIndex}} },
-{{/schemaMembersByName}}
-};
-const ::capnp::_::RawSchema s_{{schemaId}} = {
-  0x{{schemaId}}, b_{{schemaId}}.words, {{schemaWordCount}}, d_{{schemaId}}, m_{{schemaId}},
-  {{schemaDependencyCount}}, {{schemaMemberCount}}, nullptr, nullptr
-};
-{{/typeSchema}}
-{{/fileTypes}}
-}  // namespace schemas
-namespace _ {  // private
-{{#fileTypes}}
-{{#typeStructOrUnion}}
-{{#typeStruct}}
-CAPNP_DEFINE_STRUCT(
-    ::{{#fileNamespaces}}{{namespaceName}}::{{/fileNamespaces}}{{typeFullName}});
-{{#structNestedEnums}}
-CAPNP_DEFINE_ENUM(
-    ::{{#fileNamespaces}}{{namespaceName}}::{{/fileNamespaces}}{{typeFullName}}::{{enumName}});
-{{/structNestedEnums}}
-{{#structUnions}}
-CAPNP_DEFINE_UNION(
-    ::{{#fileNamespaces}}{{namespaceName}}::{{/fileNamespaces}}{{structFullName}}::{{unionTitleCase}});
-{{/structUnions}}
-{{/typeStruct}}
-{{/typeStructOrUnion}}
-{{/fileTypes}}
-{{#fileEnums}}
-CAPNP_DEFINE_ENUM(
-    ::{{#fileNamespaces}}{{namespaceName}}::{{/fileNamespaces}}{{enumName}});
-{{/fileEnums}}
-}  // namespace _ (private)
-}  // namespace capnp