Free source code that make software for linux

Source Speak is a PHP program which enables a person to display their programs source code. If you are wondering why someone would want to share their code, there are many reasons.

displaying code for a potential employer
showing other developers your algorithms
developers on add to your code

This program is easy to use. Just copy the program to your web server that has PHP installed. The next step is to copy your project into the projects directory.

SourceBrowser is a documentation meta-programming tool that generates a wiki for a source tree.
The project provides a domain specific language called Source Annotation Language for writing documentation meta-programs.
A meta-program is embedded into the source code of a program or library, and defines an object-oriented database.
The meta-program can be evaluated with the tools provided by the project, and generate a wiki that integrates documentation and source code for seamless browsing.
Enhancements:
- Added an object for the project front page
- Added pragmas for special rendering of document objects.
- Added navigation uplinks.
- Added figure support.
- Improved wiki syntax for links.
- Improved default regular expressions for the SAL host language parser {@srcb.parser.mode|mode}.
- External links now open in blank browser frame (_blank instead of _frame)
- Fixed a bug in source tree construction.
- xcode2html now prints the offending file in case of language guess failure.
- Increased the frame margin to make it easier to resize.
- Split the documentation fornt page.

Fluxbox Tray Menu is a little tray menu for use with the Fluxbox window manager. It creates an icon where you can reach your ~/.fluxbox/menu menus.
Installation:
The simplest way to compile this package is:
1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type sh ./configure instead to prevent `csh from trying to execute `configure itself.
Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.
2. Type `make to compile the package.
3. Optionally, type `make check to run any self-tests that come with the package.
4. Type `make install to install the programs and any data files and documentation.
5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.
Enhancements:
- Some memory corrupted messages were fixed.

CodeWorker is a versatile Open Source, licensed under GNU Lesser General Public License, parsing tool and a source code generator devoted to generative programming.
Generative programming is a software engineering approach interested in automating the production of reusable, tailor-made, adaptable and reliable IT systems.
In laymans terms, CodeWorker lets you generate code by parsing existing languages, or by creating and parsing your own language. Once a language file has been parsed, CodeWorker provides several techniques for generating code.
The tools scripting language drives the parsing and source code generation process. The scripting language syntax is derived from the C family of languages, making it familiar to most programmers.
The template syntax is like like JSP, ASP, or Velocity. It has variations for parsing, code generation, or functional programming, giving the developer a number of options for organizing CodeWorker projects.
Parsing
CodeWorker can be trained to parse almost any language and provides two distinct methods for creating parsers:
- the extended-BNF notation is declarative, and is a derivative of BNF (the Backus-Naur Form defines the grammar of a language) extended with regular expressions, predefined non-terminals and useful directives. Something close to javacc or to ANTLR in the JAVA world except a separate parser class is not necessary with CodeWorker. This means that parsing scripts can be tested without having to compile a separate parser class.
- Reading tokens is procedural and a somewhat obsolete now that CodeWorker handles BNF parsing scripts smoothly.
While parsing files, CodeWorker feeds nodes into a parse tree. A tree is a convenient structure to represent a hierarchical set of nodes, as in XML for instance.
The parse tree is populated by the parsing task, and used by the source code generation script to generate code, text or binary data.
Source Code Generation
CodeWorker can parse a language and use the resulting parse tree to generate source code via template-based scripts. One example is database DDL (Database Definition Language). CodeWorker has been used to parse DDL and generate large portions of a Java application.
CodeWorkers source code generation can occur in three ways: generation, expansion or translation.
- generation uses a script, much like JSP or PHP, to produce an output file. Only certain areas, called protected areas in the vocabulary of CodeWorker, are preserved in the file.
- expansion is used when small portions of an existing file need to be generated. The points where code is to be inserted are called markers in the vocabulary of CodeWorker, and code is inserted at the markers. The Class Wizard of Visual C++ generates code using this principle.
- translation mode is used when both parsing and source code generation are required to produce a file. Here are the description of two main families of use:
- source-to-source translation: a file must be rewritten in a different syntax. For example, a LaTeX file might have to be translated in HTML.
- program transformation: a source file has to change for optimizing, refactoring, instrumenting or rewriting selected portions. For example, a script could add a trace at the beginning of each function body of a JAVA or C++ source code. To do that, parsing discovers function bodies, and source code generation will insert the code that implements the trace.
Enhancements:
- Concepts of Aspect-Oriented Programming were added to code generation with joint points, advices, and point cuts.
- It allows a better separation of concerns inside a code generation process, leading to improved reading and maintenance of large and complex template-based scripts.
- A new BNF directive was added: #readPythonString.
- Some bugfixes and updates were made in the Eclipse plugin.

This is the source code for Quake III Arena version 1.32b, released by id Software. Quake III Arena Source is subject to the terms of the GNU General Public License.
While we made sure we were still able to compile the game on Windows, GNU/Linux and Mac, this build didnt get any kind of extensive testing so it may not work completely right.
Whenever an id game is released under GPL, several projects start making the source code more friendly to nowadays compilers and environements.
If you are picking up this release weeks/months/years after we uploaded it, you probably want to look around on the net for cleaned up versions of this codebase as well.
The build system using cons, which may be known as sconss perl ancestor now you dont have to track it down though, the build script is provided in the tree you will need nasm and gcc 2.95
Make sure you have the X Direct Graphics Access and X Video Mode extensions headers for your X11 a typical compile command goes like this:
[..]/code$ ./unix/cons -- gcc=gcc-2.95 g++=g++-2.95
Enhancements:
- Fix for a security exploit.

Project Dune provides an issue tracker integrated with source code control systems.
Project Dune is a Web-based issue tracker that is fully integrated with source code control systems, which enables code inspections in the browser.
The project aims to automate the full cycle of development, from estimation to release.
This allows more time for productive tasks like architecture, design and coding. Especially if you have a quality plan in place based on ISO or CMM, you will find this software useful.
It is built for Tomcat with GWT, Hibernate, Java, Dozer, using the Postgres database.
Enhancements:
- An entire new layout.
- An administration module has been added.
- The inspection m- Eodule has been separated, and binary inspections added.
- Many fixes and features have been implemented.

ccovinstrument package contains instruments C/C++ code for test coverage analysis.

SYNOPSIS

ccovinstrument code.c > covcode.c
ccovinstrument code.c [-f] -o covcode.c [-e errs]
-f instrument fatal code as well as normal code

Scans C/C++ source (before cpp) and inserts trip-wires in each code path to record execution.

A number of error prone coding styles are also detected. Many of these ideas came from study of the highly regarded perl5 source code (and from my own coding experience.

This approach (or almost any approach) to coverage analysis is NOT fullproof! Just because you exercise every code path does NOT mean you have exercised all possibilities. For example, consider the following code:

char
fetch_char(int xx)
{
static char *string = "Dr. Zorph Trokien";
if (xx < 0) {
return 0;
} else {
return string[xx];
}
}

Unfortunately, you still have to be somewhat intelligent about designing your test scripts. However, assuming youre clever, you can use this tool to know when to stop writing more tests. Thus, thereby achieving test coverage.

CCov SOURCE DIRECTIVES

/* CCov: off */
Turns off coverage instrumentation. You probably dont want to analyze debugging code.

/* CCov: on */
Turns on coverage instrumentation.

/* CCov: jump if for do while else return */
Adds to the list of identifiers that cause a change in execution flow. In addition to the usual keywords, macros used by the perl core and XSUBs are included by default.

/* CCov: fatal myexit croak panic */
Adds to the list of identifiers that cause a fatal exception. Instrumentation of these blocks is turned off by default. (You usually want to make sure the code is suppose to work works before you make sure that the code that isnt support to work works.)

HOW DOES IT WORK?

The instrumenter processes source code before it is seen by cpp. This helps you isolate your testing. Usually, you want to do test analysis on each library/application individually. A global analysis would cause you to test new code and all the libraries you are using (for every single application!).

The instrumentor does not really use a lexer (tokenizer). The techniques are probably more similar to image processing than parsing. As you might imagine, this doesnt work in the general case. CCov tries to be forgiving, but it simply doesnt understand obfuscated code. Rather than calling it a bug, I think its an significant feature.

Simple code probably has fewer bugs than complex code. Not only is this tool aimed at test coverage analysis, it is also helps you improve your coding style. There are still some rough edges, but I am mostly satisfied with the degree of strictness.