Free Software Foundation!

Join now


From Free Software Directory
Jump to: navigation,

Broaden your selection:


Category/Program-build-automation Search icon.png

Program-build-automation (94)

ACDK is a development framework with a similar target of Microsoft's .NET or Sun's ONE platform, but instead of using Basic/C# or Java as programming language, it bases C++ as core implementation language. ACDK implements the standard library packages, including acdk::lang, acdk::lang::reflect, acdk::util, acdk::io, acdk::text (including regexpr), acdk::net, acdk::sql, acdk::xml and more, as well as technologies like flexible Allocator/Garbage Collection, Threading and Unicode. With the extensions of ACDK C++ objects are available for reflection, serialization, aspect oriented class attributes and [D]ynamic [M]ethod [I]nvocation. This DMI act as an universal object oriented call interface to connect C++ with scripting languages (Java, Perl, Tcl, Python, Lisp, Visual Basic, VBScript) and standard component technologies (CORBA, COM+).

The Aap program executes recipes. It is a kind of super-make program. In a recipe you describe how to perform a certain task. Like a Makefile it contains dependencies and build commands. Additionally, many powerful features are included, so that you can use a recipe to:

  • Build a program by just specifying the program name and the source files
  • Maintain a web site (the A-A-P site is generated and uploaded with a recipe)
  • Download the latest version of files
  • Distribute files to several servers at once
  • Obtain a module from CVS
  • Commit changes to CVS; add and remove files automatically
  • Generate and filter files
  • Build several variants and on multiple platforms with little effort

The A-A-P GUI IDE is a framework in which separate tools can work together. Like any other Integrated Development Environment it supports:

  • Creating a project
  • Building and executing a program
  • Browsing files
  • Debugging a program while displaying source code
  • Framework Agide is not a monolitic application. Separate tools can be plugged in. Thus you are not forced to use one editor. Each tool implements part of the plugin interface. This interface makes it possible for a tool to communicate with other tools, without the need to know how the other tools work. For example, an editor can set a breakpoint in a file, without knowing what kind of debugger is being used. And the debugger can show the PC position in a source file, without knowing what editor is being used.

Alexis Makes (amake)
AMake is a make tool which uses powerful pattern transformation enabling a single makefile to automatically handle the compilation of any level of directory hierachy and have the possibility to add files in a project without having to modify even a character of the makefile thus saving a lot of time.

Anise helps you to implement a common mechanism for executing all automated tasks for all your software projects. The usage scenario is a developer (or a team) working on many different projects with different frameworks and different tools. Anise can streamline such a chaos of tools. Typical tasks you would add to an anise-aware project can be:

- generating documentation - creating packages - handling version information

 - e.g. print it in the manual

- creating a homepage automatically built from the available

 version information, the packages, the documentation and so on

- deploying this homepage to a web server - unit testing - ... or whatever your project needs

Anise provides a Python based infrastructure, while you will need to implement some parts in order to adapt the behavior to your project's needs. Anise contains some ready-to-use implementations for some tasks (like building binaries via qmake, debian and some other packages, svn interaction, doxygen, ...), so you can directly use it without non-trivial additional coding to do all kinds of stuff, including generating documentations, packages and a homepage. However, chances are good that you will have to help out with some own implementations.

Your part as a project developer is to create a *project description* file, which contains all project metadata and custom implementations of some tasks, and add this file to your project.

Ant is a Java based build tool, similar to make, but with better support for the cross platform issues involved with developing Java applications. Instead of a model where the tool is extended with shell based commands, it is extended using Java classes. Instead of writing shell commands, the configuration files are XML based calling out a target tree where various tasks get executed. Each task is run by an object which implements a particular Task interface.

AutoCodeGenerator is a tool which is able to generate other programs that insert, delete, or update database records for a number of different database programs. Programs can be generated in Python, bash, ksh, Java, C, or other languages; the package also generates code for various database servers via a plain text file.

'Autobuild' processes output from building software, primarily focused on packages using Autoconf and Automake, and generates HTML summaries. The output includes project name, version, build host types, build host name, and indication of success or failure. The output is indexed in many ways to simplify browsing.

Autoconf Heckert gnu.small.png
Extensible package of m4 macros that produce portable shell scripts to automatically configure software source code packages. These scripts can adapt the packages to many kinds of UNIX-like systems with minimal manual user intervention. Autoconf requires GNU M4. You must install GNU M4 1.4.5 or later before configuring Autoconf, so that Autoconf's configure script can find it. The configuration scripts produced by Autoconf are self-contained, so their users do not need to have Autoconf or GNU M4 installed.

Autoconf-archive Heckert gnu.small.png
Autoconf Archive is a collection of macros for GNU Autoconf that might be useful to some users, but are not sufficiently general purpose to include in the core Autoconf distribution.

The archive has been steadily growing since its inception in the mid-1999. The latest version contains more than 500 macros collected over the years for easy reuse in other projects, without requiring any changes in licensing.

… further results 

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the page “GNU Free Documentation License”.

The copyright and license notices on this page only apply to the text on this page. Any software or copyright-licenses or other similar notices described in this text has its own copyright notice and license, which can usually be found in the distribution or license text itself.

Personal tools