compilers
Tako Compiler 1.1
Tako Compiler - Compiler for a direct programming language with Java-like syntax more>> DVD To MP3 Converter is a powerful DVD To MP3 converter software for MAC. DVD To MP3 Converter provides fast access to high-qualified, easily handle DVD to MP3 rip, convert DVD to MP3, WAV, WMA, AAC, AC3, OGG, RA formats, which are extensively supported by most portable MP3 players such as video iPod, iPod touch, Apple TV, Zune, Archos AV500/AV700/Gmini402, iRiver PMP-100, Creative Zen Vision, etc. DVD to MP3 Ripper helps you easily convert them to MP3 format that can play in your MP3 player. And you will be enjoy it anytime anywhere.<<less
PList Compiler 0.6
PList Compiler - XCode property list compler more>> PList Compiler - XCode property list compler
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.
Bernard Desgraupes - PList Compiler - XCode property list compler. PList Compiler. PList Compiler lets you build localized and non-localizedFileName List Compiler 1.7
FileName List Compiler - Set your clipboard to the names of selected files more>>
The script can be activated by a script launching utility, the Apple menu or by dropping files onto its icon.
Equation Compiler Plugin 3.1
Equation Compiler Plugin - Compile string into machine language for rapid evaluation more>>
Only two functions are needed for the plugin. They are compile() and evaluate(), both of which can take a variable number of arguments.
The compile() function can take from 1 to 7 arguments. The first is the function text. The remaining are the string names of the user variables. Their order defines how the plugin uses the arguments of the evaluate function. The return type of compile() is a Boolean, true for a good compile, false for a bad one.
The evaluate() function takes from 0 to 6 arguments. These are the input double values for the variables defined with compile{}. With no argument the function has no variables, as say 2*exp(3.5). The return type of evaluate() is a double which results from evaluating the function.
State Machine Compiler 6.0.0
Generates a State pattern in eleven programming languages more>> Generates a State pattern in eleven programming languages
SMC takes a state machine stored in a .sm file and generates a State pattern in eleven programming languages.
Includes: default transitions, transition args, transition guards, push/pop transitions and Entry/Exit actions.
Enter SMC - The State Machine Compiler. Now you put your state diagram in one file using an easy-to-understand language. SMC generates the state pattern classes for you. No more hand-maintained transition matrices.
No more widely scattered switch statements. Instead, the state diagram is in one place, coded directly from the picture to the SMC language and is easily maintained.
SMC uses the state pattern to its fullest extent. In the real world, events dont always happen when they should. Dealing with unexpected events is a must for a robust application.
By combining virtual methods with the state pattern, SMC allows you to define "Default" transitions - transitions which allow your objects to handle unexpected events, recover and continue providing service (rather than crashing, burning and getting you into trouble).
SMC is a Java application, which means SMC will work on any platform that comes with Java 1.5.0 support.
NOTE: State Machine Compiler is released under the Mozilla Public License 1.1 (MPL 1.1).
Enhancements
- Added support for PHP programming language (-php).
- Added support for Scala programming language (-scala).
- Jump transition added. Works the same as a simple transition.
- The TransitionUndefinedException was missing the transition
- name. The transition name is now placed into the exception.
- Correctly handles $ in transition arguments.
- Corrected statemap.h -I include path in C examples.
- Corrected C example 4 #if __GNUC__ condition.
- Corrected C example 6 #include.
- Corrected file names in TCL examples 4 and 5.
- Corrected examples "all" rule.
- Corrected #!/interpreter calls in scripts.
CodeWarrior Compiler and MSL Update 2.2.1
This file 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 more>>
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.
GPlates 0.94
GPlates lends you the ability of using an interactive plate-tectonics visualisation program which enables interactive visualisation and manipulation of the plate-tectonic reconstructions of geological and paleo-geographic features through geological time. more>> GPlates 0.94 lends you the ability of using an interactive plate-tectonics visualisation program which enables interactive visualisation and manipulation of the plate-tectonic reconstructions of geological and paleo-geographic features through geological time.
Enhancements:
- The transition to the CMake build system has been completed. This new build system replaces both the Autoconf/Automake/Libtool-based build system for Linux and the project files for the MS Visual Studio compilers, in addition to enabling compilation on MacOS X.
- GPlates now compiles and runs on the three main desktop operating systems: Windows, Linux and MacOS X.
- It is now possible to manipulate geometries interactively, dragging vertices using the new Move Vertex tool. This tool can be used on both existing feature geometries, as well as geometries which are in the process of being digitised. When the tool has been selected, the selected geometry will be drawn in grey, while its vertices will be highlighted and draggable.
- Previously, a raster image would always be shown by GPlates to cover the whole globe, from -180 to +180 degrees longitude and -90 to +90 latitude. Its now possible to specify a surface extent of any longitude and latitude range for the raster, enabling rasters of a smaller size to be correctly sized and positioned.
- The Manage Feature Collections dialog offers the ability to reload a file from disk with a single click, as well as the ability to enable or disable a feature collection without unloading or reloading the file.
- It is now possible to save feature collections in GMT format, with a choice of header formats: PLATES4 line header; GPGIM feature properties; or a mixture of the two. Its also possible to export a digitised geometry in GMT format (it was already possible to export a digitised geometry in PLATES4 line-format) during the digitisation process, without needing to create a whole new feature.
- Shapefile attributes may now be edited in the Feature Properties dialog in the same way as native GPGIM property-values.
- The Task Panel can now be resized in the main window, enabling text fields to be widened in order to display longer lines of text.
- All the attributes in a Shapefile may additionally be viewed in a more compact tabular (spreadsheet-like) format, with one attribute per column.
- Mac OS X 10.4.11 or later.
Exchange CodeWarrior Java Compiler 1.0
Exchange CodeWarrior Java Compiler - Change the required software kit to develope Java programs more>>
The related software is classes.zip library and MW Java compiler. Please note that Java 1.1.3 public beta folder should be stayed in the Metrowerks CodeWarrior folder where the installer of public beta has initially located the stuff.
TooHot Crossword Puzzles Compiler 0.5.0
TooHot Crossword Puzzles Compiler allows you to create custom crossword puzzles fully automatically using your own databases or built in clue-answer dictionaries more>> TooHot Crossword Puzzles Compiler allows you to create custom crossword puzzles fully automatically using your own databases or built in clue-answer dictionaries. Puzzles can be exported as HTML or published as Online-Game with popular TooHot Open Source Java Applet.
Java 1.2 or later.
CMake 2.6.4
Cross-platform, open-source make system more>> Cross-platform, open-source make system
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
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 beLicense:GPL
Metasm 0.1
Metasm - Cross-architecture assembler, disassembler, compiler, linker and debugger more>> Metasm - Cross-architecture assembler, disassembler, compiler, linker and debugger
Metasm is a cross-architecture assembler, disassembler, compiler, linker and debugger.
Metasm has some advanced features such as remote process manipulation, GCC-compatible preprocessor automatic backtracking in the disassembler, C headers shrinking and debugging API interface.
The development version also adds a C compiler, a decompiler and various advanced features. It is written in pure Ruby.
Main features:
- Metasm has been written in such a way that it is easy to add a new architecture. For now, the following architectures are supported:
- Intel IA32
- MIPS
- In development: Cell, SPARC, ARM, PPC, PIC
The following file formats are supported:
- Raw (for shellcodes)
- MZ, PE/COFF (32 and 64 bits)
- ELF (32 and 64 bits)
NOTE: Metasm is licensed and provided under the GNU Lesser GPL License.
toolserver(1) 1.2
toolserver(1) is a command line program to invoke ToolServer and to execute MPW tools more>>
For example, thanks to toolserver(1), you can use PowerPC and 68K MPW C/C++ compilers with GNU Make or Xcode. You can also use GNU Make to compile native code of Newton packages, such as LPR Driver.
Enhancements:
- [CODEFIX] Create temporary files in Classics temporary folder.
- [CODEFIX] Fixed a bug where the paths to the files were not null terminated (thanks Ben).
- [CODEFIX] Updated the project for Xcode 2.0 (removed libstdc++).
D4Xcode 1.0
D4Xcode is an application that will offer support for editing D source code files using the Xcode IDE on Mac OS X more>>
Note: D4Xcode does not include a D compiler that can be plugged into Xcode, it only adds syntax hightling and file icon associations for .d files. To compile D code on Mac OS X, download the free GDC compiler.
sparqltoxquery 0.1
Semantic Web implementation using native xml database as backend storage more>> Semantic Web implementation using native xml database as backend storage
The Semantic Web implementation using native xml database as backend storage. A SPARQL java compiler to XQuery using Jena. There are XQuery scripts for the native xml database Sedna.
Enhancements
- Created the first release for this project.
- In this release of the project you can make simple semantic web queries to rdf/xml documents.
Visual Component Framework 0.6.5
Advanced C++ application framework that makes it easy to produce powerful Mac OS X applications in C++ more>> Advanced C++ application framework that makes it easy to produce powerful Mac OS X applications in C++
Visual Component Framework is a based on a thoroughly modern C++ design and has built in support for Rapid Application Development (RAD).
The Visual Component Framework framework is designed to be portable over multiple compilers and platforms, so you dont have to lose all that work that went into writing your app for a single platform!
Main features:>
- Modern C++ design - use of modern C++ techniques like exceptions, templates (where useful), name spaces, and heavy use of the Standard Template Library.
- Advanced RTTI features that allow for such things as dynamic object creation given a registered class name or a registered UUID string that represents the class, dynamic introspection of a given objects class and listing such data as the class name, super class, the properties of the class, member methods, and implemented interfaces.
- Modular - built across several libraries as opposed to one huge monolithic library that then becomes difficult to break apart. This means that while the VCF is incredibly powerful as a framework for writing GUI based applications, if you just want to use the core features, such as threads, file IO, and RTTI you can do so, without having to have dependencies on all the GUI code.
- Easy to use, and powerful event system, suitable for console as well as GUI based applications.
- Support for Thread, Mutexes, Semaphores, Files, Streaming data, error logging, string utility functions, and other basic services. All of this is part of the FoundationKit and has no dependencies on the graphics or UI code.
- Powerful and easy to use graphics classes, plus more advanced support for anti aliased vector graphics through the use the AntiGrain Graphics libraries.
- A simple to use image loading architecture that allows multiple formats to be registered dynamically, for loading up a variety of different graphics formats. On Win32 systems the default image loading support is limited to BMP files, but by using the ImageFormats library (also a part of the VCF) a wide variety of additional image types are also supported. Currently the ImageFormats library uses FreeImage to support a image types such as .TIFF, .TGA, .PSD, .PNG, .PCX, .SGI, .MNG, .RAS, .PBM, .PPM. and many others.
- More advanced classes for customizing the drawing process by extending Stroke and Fill classes.
- A complete set of powerful GUI classes, including a common set of base classes enabling advanced custom control creation. Some of the control classes include tree controls, list controls, check box and radio controls, push buttons, single line and multi line text controls, and many others.
- A standard set of application classes for things like resources, loading windows or forms dynamically at application startup, saving of application state, a registry class for common storage of system and application information.
- Other application classes include an Undo/Redo architecture based on commands that allows for undoing and redoing commands as well as notifying other objects of the events.
- GUI controls that support both alignment and anchoring. Any control may be aligned to the top, bottom, left or right of its parent container control. Alternately controls may use their anchoring properties to anchor themselves to the left, right, top and/or bottom sides of their parent container control. In addition to control alignment, it is possible to write custom layout containers and assign them to a control to customize layout logic.
- The ApplicationKit provides a set of Model and View classes for using in MVC patterns. A series of models like the ListModel, TreeModel, and TextModel are used in controls to provide separation of the data from the UI presentation code. Because a View can be dynamically attached to a Control at runtime, it will be possible to develop "themes" in the future.
- Because of the RTTI features and the event handlers, the VCF easily supports component programming with in IDE that allow for visual development.
- The VCF tries to be as flexible as possible, allowing you to use the parts you want, and allowing for inter-operability with other frameworks. Thus VCF controls can be used inside of an MFC application if you like, or only use the graphics module for enhanced graphics features.
- No need of special preprocessor tools - if you have a reasonably complete C++ compiler then youre all set to go.
- The ability to access the low level handles for most native objects. For example, by accessing the Threads peer class, you can get a handle to the native thread handle itself. For a control, you can access the controls peer and get a handle id that represents the windowing systems native handle for a window/widget. This allows you to use platform specific calls when necessary.
Enhancements:
- This is the very first src release of the Mac OS X port of the VCF. It should build and run some of the examples, but is obviously very much still a work in progress.
