Free compiler software for mac

PList Compiler lets you build localized and non-localized plist files from plc and ploc source files.
PList Compiler is a script that you execute as a Shell Script Build Phase within your XCode project and which takes care of generating automatically the property list files for your packaged applications, bundles, frameworks, plugins, etc
PList Compiler, a property list compiler for XCode.
Main features:
? - supports many different encodings (including utf-8 and utf-16)
? - supports many predefined variables (YEAR, DATE, OUTPUT_FILENAME, etc.)
? - supports all the XCode internal variables
? - supports conditional preprocessor macros, defines and includes
? - supports localized strings files
? - comes with a detailed help file.

CodeWarrior Compiler and MSL Update 2.2.1 provides you a useful patch that updates CodeWarrior Pro 4.0 to compiler version 2.2.1 and MSL C++ version 4.1.05. This is a bug fix release for the 2.2 compiler originally shipped with Pro 4.0. See the release notes for details. This update includes only Mac OS (68K, PowerPC) compilers. You should install the IDE 3.3 patch before installing this update. You will need to rebuild your libraries and precompiled headers after installing this patch.

tecomp is a command line compiler that currently works like an Eiffel interpreter. It compiles Eiffel source code into an internal representation and executes it in its virtual machine.
tecomp runs on Unix and Windows machines (64/32 bit, big/little endian) and on all machines which have gcc and the corresponding make utilities installed (requirements see below).
NOTE: tecomp is licensed and distributed under the terms of the GNU General Public License (GPL) and GNU Library or Lesser General Public License (LGPL).

Main features:
Kernel library:
- available classes: ANY, CHARACTER, CHARACTER_8, BOOLEAN, INTEGER, INTEGER_8/16/32/64, NATURAL, NATURAL_8/16/32/64, STRING, COMPARABLE, STD_FILES, FILE, POINTER, REAL, TYPE, PART_COMPARABLE, INTERVAL, TUPLE
- available features of ANY: io, default_create, type, out, print, is_equal, default_is_equal, copy, default_copy, cloned, default_cloned, is_deep_equal, deep_cloned.
- all conversions between basic types are implemented
- missing features of ANY: onces
- not yet available classes: HASHABLE, STORABLE, MEMORY, EXCEPTIONS, ARGUMENTS, PLATFORM, ONCE_MANAGER, ROUTINE, PROCEDURE, FUNCTION, PREDICATE
Language mechanisms:
available:
- object creation
- object test
- detachable types
- old expressions
- creation expressions
- conversion
- feature call
- feature redefinition
- developer defined expanded types
- deferred features
- polymorphic assignment (dynamic bind)
- assertions (preconditions, postconditions, class invariants, checks, loop variants, loop invariants)
- aliases (with standard operators only)
- rename, redefine, export, undefine, select
- once routines (Result cannot yet be expanded)
- ace files to control class assembly
- switchable assertion monitoring (per cluster)
- public and private features (but no selective export)
- void safety
- automatic boxing
- constant attributes
- TUPLEs
- garbage collection

Enhancements
- Version 0.18 implemented target conversion for binary operators.
- The implementation bypassed type validity checks with binary operators. Therefore invalid code could be executed which might cause runtime crashes.

Unicode HTML Generator 1.0.1 gives a tool to make the generation of static web pages including unicode characters not found in the ASCII set. It works like a simple compiler in that it reads a collection of rich text files containing html source and unicode text and generates html files. This application requires the user to be very familar with html and is for web hackers of the most patient kind.

Welcome to CMake, the cross-platform, open-source make system. CMake is used to control the software compilation process using simple platform and compiler independent configuration files. CMake generates native makefiles and workspaces that can be used in the compiler environment of your choice.
With CMake it is possible to support complex environments requiring system configuration, pre-processor generation, code generation, and template instantiation.
CMake was developed by Kitware as part of the NLM Insight Segmentation and Registration Toolkit project. The ASCI VIEWS project also provided support in the context of their parallel computation environment. Other sponsors include the Insight, VTK, and VXL open source software communities.
The goals for CMake include the following:
- Develop an open source, cross-platform tool to manage the build process,
- Allow the use of native compilers and systems,
- Simplify the build process,
- Optionally provide a user-interface to manage the build system,
- Create an extensible framework,
- Grow a self-sustaining community of software users and developers.
CMake is designed to support complex directory hierarchies and applications dependent on several libraries. For example, CMake supports projects consisting of multiple toolkits (i.e., libraries), where each toolkit might contain several directories, and the application depends on the toolkits plus additional code. CMake can also handle situations where executables must be built in order to generate code that is then compiled and linked into a final application. Because CMake is open source, and has a simple, extensible design, CMake can be extended as necessary to support new features.
Using CMake is simple. The build process is controlled by creating one or more CMakeLists.txt files in each directory (including subdirectories) that make up a project. Each CMakeLists.txt consists of one or more commands. Each command has the form COMMAND (args...) where COMMAND is the name of the command, and args is a white-space separated list of arguments. CMake provides many pre-defined commands, but if you need to, you can add your own commands. In addition, the advanced user can add other makefile generators for a particular compiler/OS combination. (While Unix and MSVC++ is supported currently, other developers are adding other compiler/OS support.) You may wish to study the examples page to see more details.

Main features:
- Supports complex, large build environments. CMake has been proven in several large projects.
- Generates native build files (e.g., makefiles on Unix; workspaces/projects on MS Visual C++). Therefore standard tools can be used on any platform/compiler configuration.
- Has powerful commands include the ability to locate include files, libraries, executables; include external CMake files that encapsulate standard functionality; interfaces to testing systems; supports recursive directory traversal with variable inheritance; can run external programs; supports conditional builds; supports regular expression expansion; and so on.
- Supports in-place and out-of-place builds. Multiple compilation trees are possible from a single source tree.
- Can be easily extended to add new features.
- CMake is open source.
- CMake operates with a cache designed to be interfaced with a graphical editor. The cache provides optional interaction to conditionally control the build process.

Enhancements
- Add parenthetical expressions to if
- Improve scoping of policies (see cmake_policy and CMP0011)
- Teach find_package more config file locations
- Many improved Find scripts in Modules
- Added an unset command
- Qt cmake-gui is the primary GUI for windows, deprecate CMakeSetup
- Better reporting when nmake compiler environment is not correct