CMake Visual Studio generator translates add_custom_command into a batch
file embedded in Visual Studio project. Batch files have problems with
paths that contain non-ascii characters because they are limited to DOS
encoding. It so happens that cabal is quite likely to be installed in
such a path because by default cabal installs into a directory under
%APPDATA% which contains user name. As a workaround we execute cmake
scripts as a custom commands and depend on CMake cache to get access to
variables set during configuration. This way embedded batch files are
free of non-ascii characters.

Fix compiler CMake permissions for OSX

Fix a typo in documentation

OutputBuffer implements IOutputStream not IOutputBuffer.

Custom actions in Visual Studio projects are executed as batch files.
If cmake is also a batch file then the statement:

        cmake ...

will call cmake.bat and never return from it. Replacing it with:

        call cmake ...

makes sure that the custom command batch file continues after cmake
returns.

This project was more of a playground than a proper example. It was
never included in cs.sln.

For now only configuring OS X build. Travis-CI runs Linux builds on
Ubuntu 12.04 for which pre-built Boost packages end at 1.48. Bond
currently requires 1.54.

Update OS X instruction for homebrew Python

Use Homebrew to install cmake, ghc and cabal-install instead of CMake
and Haskell Platform manual installations.

Rename Bond.cs to Bond.CSharp and Bond.Runtime.cs to Bond.Runtime.CSharp.

The old packages on nuget.org are converted to redirect packages that
are empty and only have dependency on the new packages.

The compiler now supports C++11 defaulted functions. Since Boost config
doesn't detect features for the new compiler yet, we ignore
BOOST_NO_CXX11_DEFAULTED_FUNCTIONS macro when _MSC_VER > 1900.

Use multi-line string both in the JSON input and the verification assert.

By default the blob type maps in C# to ArraySegment<byte>. This choice
is dictated by performance: using ArraySegment rather than a simple
array allows deserializer to avoid memcpy.

At the same time arrays are often a very convenient type in C# and Bond
supports T[] as an alternative mapping for the schema type vector<T>.
Although C# codegen doesn't generate arrays by default, users can either
manually annotate array fields in their own classes with Bond attributes
or they can use custom type alias mapping support (the gbc command line
option --using) to generate classes with array fields.

This change optimizes how C# byte[] is handled by object parser as well
as serializer and deserializer transforms. Instead of reading/writing
each byte individually, which is very expensive, when possible Bond will
use fast block operations exposed by IUntaggedProtocolReader.ReadBytes,
ITaggedProtocolReader.ReadBytes, IProtocolWriter.WriteBytes and
IParser.Blob.

It is important to note that even though byte[] gets the performance
optimizations associated with blob, it is not the same as schema blob
type. On the wire blob is represented as vector<int8> and C# byte[] maps
to vector<uint8>. It is of course possible to map byte[] to schema blob
type via an explicit type annotation:

    [global::Bond.Id(0), global::Bond.Type(typeof(global::Bond.Tag.blob))]
    public byte[] Arr { get; set; }

The same can be achieved using type aliases:

    using ArrayBlob = blob;
    struct Foo
    {
        0: ArrayBlob data = nothing;
    }

    gbc --using="ArrayBlob=byte[]" foo.bond

Representing blob using a byte[] instead of the default
ArraySegment<byte> is still a performance compromise because it requires
memcpy during deserialization. In some cases the convenience of byte[]
may justify it but for optimal performance ArraySegment<byte> is
recommended. To make this trade-off clear, aliasing blob as byte[]
requires that user provides explicit type converter, like for any other
type alias.

Looks like AppVeyor doesn't support YAML line continuations.

The bug in the parser caused it to interpret any default value starting
with the letter L as a string literal, resulting in a parsing error for
constructs like:

    struct Foo
    {
        0: Verbosity verbosity = Low;
    }

Optimize C# byte[]

This change fixes a bug in lookup of an unqualified symbol from an
imported schema file when one of the files is using a language specific
namespace. Language specific namespaces are not documented and their
use is not recommended, but the compiler supports them for backward
compatibility with legacy code.

This is the first step to make the bond solution compilable with xbuild
This commit allows to build Bond libraries and some bond examples. There
are some limitations due to the reason xbuild does not support
all MSBuild features.

What is not supported:
- NET 4.0 profile. xbuild builds only .NET 4.5 profile, there are compile errors when
  it tries to build .NET 4.0 target after building .NET 4.5. The issue that xbuild does
  not pass codegenerated files to mcs when build for .NET 4.0. Need more investigation
  why this happens.
- Building tests. They are using VisualStudio test libraries which is not supported by mono.
  It will work when tests will be converted to NUnit tests
- There are some compile errors in examples related to using LinkedList<double>. Need
  more investigation is this class supported by mono and if yes why there are errors.

Make Bond compilable with mono xbuild

This is the second step of making solution compilable with xbuild.
It resolves all xbuild compilation issues except using references
to VisualStudio asseblies in test projects.
Fixed:
- wrong path dilimiter usage in bond files on linux system
- different case-sensitivity in file names
- passing global $(BondOptions) property to codegen process

Make test and examples projects are compilable with xbuild

Users can install the grammar by adding the files to their
`%AppData%\Roaming\Sublime Text 3\Packages\User` folder.
It's fairly simplistic, but should be a decent start.

Remove possible underflow in string buffer encoder

Remove unnecessary semicolons

Mono MemoryStream internal implementation differs from .NET implementation
It does not have `InternalGetOriginAndLength` method. So the cloning
method changed to use mono implementation of MemoryStream
when the method `InternalGetOriginAndLength` is not found

PowerShell script fails AppVeyor CI build when cabal install emits
warnings.

The cabal version 1.20+ was required only for the --required-sandbox
flag. However since the make files are setting up the sandbox we know
that we are always building using sandbox. The current Haskell Platform
comes with cabal 1.18 so this way installing cabal update is not needed.

Fix clone of MemoryStream on Mono

Made the following changes for the open source AppVeyor plan which
runs on very slow and memory limited VMs:
- Limit ghc heap size to 192MB when installing dependencies
- Use `appveyor DownloadFile` instead `Start-Download`
- Download Boost in the smaller 7Zip format
- Cache cabal sandbox and boost download
- Disable C++ build

Since C++ build is disabled we don't need to extract Boost and the build
is on the edge of time out.

This allows include directories to contain spaces.

This ensures that the MSBuild targets and gbc work when a .bond file or an
import directory has spaces in the path.

Add support for paths with quotes in C# MSBuild targets

When support for import directories with spaces in their paths was
added, that inadvertently broke codegen when one ended with a trailing
slash. We add a trailing \. like we do for the output directory to fix
that.

Fix import directories with trailing slashes

Add example showing how import can be used

When bonded<T> is serialized to untagged protocols like Simple Binary
it is first marshaled into a separate buffer using a tagged protocol and
then written as length prefixed blob to the untagged protocol.
OutputBuffer used for marshaling by default allocates 64KB which is
costly if the bonded<T> payload is small.

Unit tests take a long time to run in CI. Building all tests with
--collection-interfaces flag is somewhat wasteful because a lot of tests
don't use collections at all. Furthermore this way we only tested
collection interfaces together with properties. This change removes the
separate test configuration for --collection-interfaces and instead uses
concrete/interface collection alternatively for different .bond files in
Fields/Properties configuration. This way every schema is tested with
both interfaces and concrete collections and both are also tested with
fields and properties. This gives better coverage while eliminating
redundant identical tests in different assemblies.

Convert unit tests from MSTest to NUnit

Add building cs.sln and running unit tests in Travis.CI

When compiling multiple .bond files at once, the `--jobs=[NUM]` command
line option can be used to specify how many jobs should be run
concurrently. When used without arguments, the default is to run as many
jobs as there are processors. The option also accepts negative numbers
to specify fewer jobs than the number of processors. Often the optimal
performance is achieved by leaving one or more cores for other processes
on the machine.

In some scenarios the hierarchy of schemas may be very interconnected
and redundant parsing of the same imported files is a huge performance
overhead for code generation (this change showed 20x improvement when
compiling a sample set of ~900 interconnected schemas).

By default the Bond.CSharp.targets will run 2 fewer concurrent jobs than
there are processor cores on the machine. User can override this
behaviour for their project by specifying a different `--jobs` option in
`BondOptions` property.

When reading string fields, the SimpleJsonParser expects to find a JsonToken of
type String. But if the string value matches a date format, the actual JsonToken
that is seen is of type Date. To fix this, we are setting the JsonTextReader to not
try to parse strings as dates.

Also improve the exception text when reading unenxpected input to help know
what JsonToken was actually read, and fix a similar possible issue with parsing
doubles.

The new builder appears to have less memory and fails while building
Haskell libraries.

Fix bug in JSON parsing when string value is a date

Update JSON parser test expression

Replace dynamic exception specifications with portable boost config specifier

The schema AST is written in JSON format. We foresee two classes of
scenarios that will use it.

Tools that need to process Bond schema files using languages other than
Haskell can avoid recreating Bond parser. Example might be schema
repositories, lints, etc.

The schema AST will also be used to allow users to inject schema
transformations into codegen process. This in many cases can be a
lightweight alternative to custom codegen.

Derived show typeclass for schema types in order to support QuickCheck.
Added custom ShowPretty typeclass for printing Declarations in parser
error messages. Implemented custom JSON parsing for types that had
custom JSON serialization.

The Generic instance is needed only to derive generic implementations of
FromJSON and ToJSON typeclasses so we move the declarations to
Schema/JSON.hs and only derive Generic for data types that need it.

File(s) with the `.json` extension are assumed to contain the JSON
representation of schema abstract syntax tree in the format produced by
`gbc schema`

The documentation is compiled from the markdown sources to html using
`pandoc`. In order to install `pandoc` run:

        cabal install pandoc

The documentation build is optional and if `pandoc` is not found during
cmake project configuration the documentation build is skipped.

A forward declaration is a valid type argument for bonded.

AppVeyor:
1. Work around memory limitations in Haskell build
2. Run subset of C# test matrix if the sandbox wasn't in cache

Travis CI
1. Change project type to C++
2. Install Mono manually in Linux
3. Use Clang as C++ compiler
4. cabal install happy

When the schemas dependency graph complexity increases, the expression
trees that are generated by the DeserializeTransform can become very
large, leading to long compilation times and high memory consumption.

This change adds some Deserializer constructors that support a flag to
disable expression inlining. As a result the runtime deserialization
operation will be slightly slower (with some added overhead of function
calls), but the initialization of the Deserializer is significantly
faster.

The tests compare checked-in generated files with code generated using
the current compiler.

Discrepancy indicates a change in the generated code which may be a
bug or an intentional change. In the latter case the generated file(s)
should be re-generated and updated in the same commit as the change.

Note that the checked-in files are generated with --no-banner option.

Parser:
- map<Alias, T> should be valid for type aliases of the string
type.

C# codegen:
- nullable<Alias> should generate Type? for aliases of scalar
types.

C++ codegen:
- Fields of an alias type can have default value if the aliased type
  allows explicit defaults.
- The allocator constructor had unused allocator parameter in some
  cases.

Prelude changes implementing the Functor/Applicative/Monad-Proposal as
well as the Foldable/Traversable-Proposal cause unused import
warnings on GHC 7.10.

Add support for Deserializer without inlining

The BondCodegen.Options property (the per-file Bond codegen options)
should to be initialized. The build should either uses the global
options (the BondOptions property) to compile multiple schema files in a
batch, or the per-file Options property to compile individual files that
need different options. Initializing the BondCodegen.Options to
BondOptions breaks the conditional which determines which schema files
can be compiled as one batch.

Fix links broken with the move of IDL syntax documentation to
compiler.html.

The cmdargs library silently skips short names for options if more than
one option starts with the same letter. This can lead to inadvertent
breaks when a new option is added, like happened with adding
`--no-banner` option, breaking the short name -n for the `--namespace`
option.

- Conditionally compile bond::blob convert/extract routines based on
  Python version with PyString_Type or PyBytes_Type
- Update Python unit tests to be compatible with Python3
- Generalize python/boost vars in Config.cmake to allow Python3
- Update python docs for blob

Add Python3 support

1) When running the generated makefile with multiple jobs the `cabal
install` could start before `cabal sandbox` finished initializing the
sandbox leading to packages being installed globally and not available
during `cabal build` which expects dependencies in the sandbox.

2) Tarvis CI build sometimes would fail because nuget couldn't reach the
online repository. Added `travis_retry` to mitigate the problem.

Because unit test code has `using namespace std;` under VC14 RC
unqualified `empty` is ambiguous.

The compiler has a bug that won't be fixed until Update 1: it doesn't
resolve decltype in type arguments of a partial specialization. As a
workaround we define and use a type alias for the type of std::ignore.

Add to the build matrix:
- GCC compiler
- C# tests on OSX
- Non-default versions of GHC on Linux
- Python tests

Separate C++ and C# tests as distinct builds (C# still depends on core
C++ build to get the gbc compiler).

Signed-off-by: Vineel Kumar Reddy Kovvuri <vineel.kovvuri@gmail.com>

Fix a typo in C# user's manual

Remove the manually maintained Bond.Version module and use the cabal
generated Paths_bond module instead.

Some of the functions are used only internally by the parser while
others are used by the built-in codegen templates but are to specific to
expose them as public APIs. If a custom codegen needs similar
functionality it can be easily implemented using the more generic
helpers.

Rearranged and renamed some public APIs and moved some symbols to
private, unexposed modules.

Marshaler is a thin wrapper over Serializer adding 4 byte header
specifying protocol and its version. While the previous implementation
of Marshaler reused the Serializer source code, it resulted in a lot of
duplication of executable code if both Serializer and Marshaler were
instantiated for the same type(s). With this change Apply for Marshaler
simply delegates to Apply for Serializer.

Fast pass-through avoids field-by-field transcoding when source and
destination protocol are the same. Instead it just chains the source
blob into the serialization output.

Previously fast pass-through was hooked only for transcoding using
bonded<T> but not on bonded<T, Reader&>. In addition to improving
performance this change decreases build-time and size of executable code
for the generated _apply.cpp which defines transcoding overloads for
Apply with bonded<T, Reader&>.

When a protocol supports multiple version some compile-time
optimizations become impossible. For example protocol transcoding always
has to check version at runtime and perform fast pass-through only when
version of source and target are the same. Consequently both code paths,
fast pass-through and field-by-field transcoding, must be instantiated,
increasing build time and size of the executable code.

This change defines a global protocol trait that can be specialized by an
application to fix the version of a protocol. Effectively application can
promise to use only one version of the protocol (defined by
bond::default_version<Reader>). For example in order to use only the
version 2 of Compact Binary protocol application could include a header
file in the generated code using --header option:

        gbc c++ --header="<compact_binary_v2.h>" foo.bond

where compact_binary_v2.h contains:

        #include <bond/core/traits.h>
        #include <bond/core/bond_version.h>

        namespace bond
        {
            template <typename Input>
            class CompactBinaryReader;

            template <typename Input> struct
            default_version<CompactBinaryReader<Input> >
            {
                static const uint16_t value = v2;
            };

            template <typename Input> struct
            enable_protocol_versions<CompactBinaryReader<Input> >
                : false_type {};
        }

Use putStrLn instead of print to output parser errors from gbc.

1) Add custom allocator variant for all C++ cases.
2) Add collection interfaces variant for all C# cases.
3) Generated _apply.h/cpp is not schema content specific so it is
sufficient to test for one schema file.

Make each generated file comparison into a goldenTest case. Golden files
can be updated/added for changes in codegen/tests using --accept command
line switch.

- Remove the `os` property to move to the new, faster build environment.
- Use the `check` target for C++ build to run C++ and gbc tests.
- Update boost to version 1.58.

- Add support for type mapping specific annotated type name and
  declaration type name.
- Rename collection interfaces type mapping.
- Clean up white spaces in the generated _types.cs.
- Allow omitting [Bond.Default] attribute for scalar properties on
  interfaces.

We used to run all C# tests only when we could restore cabal sandbox
from the cache and avoid building all Haskell dependencies. The new
Appveyor VMs are much faster and this is no longer necessary.

With the faster Appveyor build VMs we don't need to customize the build
so much to finish it within time limit. We can now use more declarative
build matrix instead of custom build script.

Doxygen is available on non-Windows platform so name w/o the exe
extension allows building docs on other platforms.