Xcpp

CEDA is implemented in C++, and provides a front end compiler (the Xcpp console application) for the Xc++ language which is an extension to C++.

The Xcpp Build System provides a convenient and flexible means to create and edit C++ projects and solutions that target the following platforms:

• Windows
• Linux
• Linux (old)
• Mac OSX
• Android
• iOS

The Xcpp build system allows developers to create textual representations of projects and workspaces, in files with extensions xcpj and xcws respectively. These textual representations are written in a custom designed language that is simple, elegant, flexible and very concise. It promotes sharing of build settings with the result that a given project typically only needs to specify the files in that project (because all the compiler switches, linker switches and configurations are inherited using an @import directive).

All the source files are assumed to exist in a virtual tree structure which is "virtual" or "logical" in the sense that physically there may be multiple root folders which together provide all the source code.

The concept of the virtual tree helps provide a satisfactory approach for dealing with multiple versions of a given library that are needed in by other libraries and projects in various combinations, without needing to duplicate the source files.

The build artefacts folder is a folder which holds all generated outputs of the build process.

Xcpp Papers

The following papers have been written:

• Xcpp Build System describes the support for writing projects and workspaces in simple text files that can then be used to produce VC++ solution and project files.
• Xcpp Macro Preprocessor describes the support for macros which is similar to the normal C++ preprocessor, but much more powerful. For example, it allows for static type checking of macro arguments, nested macros, recursive macros and loops. It also provides access to the Python interpreter during the execution of the front end.
• Xcpp Interfaces are based on a proposal for C++ interfaces by Christopher Diggins. The interface directive allows for polymorphic interfaces to be defined, in a way that is more flexible and less type intrusive than the normal support for dynamic polymorphism in C++ using Abstract Base Classes.
• Xcpp Mixins provide a very convenient syntax for defining and using template mixins which are like fragments of a class intended to be composed with other classes or mixins.
• Xcpp Reflection describes the support for type reflection.