Free where is amsterdam software for linux

The Amsterdam Compiler Kit or in short just ACK, is a fast, lightweight and retargetable compiler suite and toolchain written by Andrew Tanenbaum and Ceriel Jacobs, and was Minix native toolchain. The ACK was originally closed-source software (that allowed binaries to be distributed for Minix as a special case), but in April 2003 it was released under a BSD open source license.
The ACK achieves maximum portability by using an intermediate byte-code language called EM. Each language front-end produces EM object files, which are then processed through a number of generic optimisers before being translated by a back-end into native machine code.
Unlike gccs intermediate language, EM is a real programming language and could be implemented in hardware; a number of the language front-ends have libraries implemented in EM assembly. EM is a relatively high-level stack-based machine, and one of the tools supplied with ACK is an interpreter capable of executing EM binaries directly, with a high degree of safety checking. See the em document referenced below for more information.
ACK comes with a generic linker and librarian capable of manipulating files in the ACKs own a.out-based format; it will work on files containing EM code as well as native machine code. (You can not, however, link EM code to native machine code without translating the EM binary first.)
Installation:
To install the ACK, you need to download the source package and compile it.
Version 5.6 compiles cleanly on Linux, but it has had little testing so far. The installation instructions are complex but straightforward provided you follow the instructions. Please read the README; it provides a detailed walk-through of the compilation process, telling you what to type at each stage.
Enhancements:
- Support has been added for generating CP/M binaries using the 8080 code generator.
- The various optimisers have been beaten into shape, and its now possible to use them on all platforms; a basic peephole optimiser has been set up for the 8080.
- The floating point system has been confirmed working on the pc86 and linux386 platforms.
- ANSI compatibility has been improved, binary sizes have been reduced, and there are many bugfixes everywhere.

File::Where is a Perl module to find the absolute file for a program module; absolute dir for a repository.

SYNOPSIS

#######
# Subroutine interface
#
use File::Where qw(pm2require where where_dir where_file where_pm where_repository);

$program_module = is_module(@program_modules);
@program_modules = dir_pms( $dir );
@program_modules = program_modules( $dir, file_flag, @dirs);
$file = pm2require($pm);
@program_modules = repository_pms($repository);

$abs_file = where($relative_file);
$abs_file = where($relative_file, @path);

($abs_file, $inc_path, $rel_fle) = where($relative_file)
($abs_file, $inc_path, $rel_fle) = where($relative_file, @path);

$abs_dir = where($relative_dir, , nofile);
$abs_dir = where($relative_dir, @path, nofile);

($abs_dir, $inc_path, $rel_dir) = where($relative_dir, , nofile);
($abs_dir, $inc_path, $rel_dir) = where($relative_dir, @path, nofile);

$abs_dir = where_dir($relative_dir);
$abs_dir = where_dir($relative_dir, @path;
$abs_dir = where_dir($relative_dir, @path;

($abs_dir, $inc_path, $rel_dir) = where_dir($relative_dir);
($abs_dir, $inc_path, $rel_dir) = where_dir($relative_dir, @path);
($abs_dir, $inc_path, $rel_dir) = where_dir($relative_dir, @path);

$abs_file = where_file($relative_file);
$abs_file = where_file($relative_file, @path);
$abs_file = where_file($relative_file, @path);

($abs_file, $inc_path, $rel_fle) = where_file($relative_file)
($abs_file, $inc_path, $rel_fle) = where_file($relative_file, @path)
($abs_file, $inc_path, $rel_fle) = where_file($relative_file, @path)

$abs_file = where_pm($pm);
$abs_file = where_pm($pm, @path);
$abs_file = where_pm($pm, @path);

($abs_file, $inc_path, $require) = where_pm($pm);
($abs_file, $inc_path, $require) = where_pm($pm, @path);
($abs_file, $inc_path, $require) = where_pm($pm, @path);

$abs_dir = where_repository($repository);
$abs_dir = where_repository($repository, @path);
$abs_dir = where_repository($repository, @path);

($abs_dir, $inc_path, $rel_dir) = where_repository($repository);
($abs_dir, $inc_path, $rel_dir) = where_repository($repository, @path);
($abs_dir, $inc_path, $rel_dir) = where_repository($repository, @path);

#######
# Class interface
#
$program_module = File::Where->is_module(@program_modules);
@program_modules = File::Where->dir_pms( $dir );
@program_modules = File::Where->program_modules( $dir, file_flag, @dirs);
$file = File::Where->pm2require($pm);
@program_modules = File::Where->repository_pms($repository);


$abs_file = File::Where->where($relative_file);
$abs_file = File::Where->where($relative_file, @path);
$abs_dir = File::Where->where($relative_dir, , nofile);
$abs_dir = File::Where->where($relative_dir, @path, nofile);

($abs_file, $inc_path, $require) = File::Where->where($relative_file)
($abs_file, $inc_path, $require) = File::Where->where($relative_file, @path)
($abs_dir, $inc_path, $rel_dir) = File::Where->where($relative_dir, , nofile);
($abs_dir, $inc_path, $rel_dir) = File::Where->where($relative_dir, @path, nofile);

$abs_dir = File::Where->where_dir($relative_dir);
$abs_dir = File::Where->where_dir($relative_dir, @path;
$abs_dir = File::Where->where_dir($relative_dir, @path;

($abs_dir, $inc_path, $rel_dir) = File::Where->where_dir($relative_dir);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_dir($relative_dir, @path);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_dir($relative_dir, @path);

$abs_file = File::Where->where_file($relative_file);
$abs_file = File::Where->where_file($relative_file, @path);
$abs_file = File::Where->where_file($relative_file, @path);

($abs_file, $inc_path, $require) = File::Where->where_file($relative_file)
($abs_file, $inc_path, $require) = File::Where->where_file($relative_file, @path)
($abs_file, $inc_path, $require) = File::Where->where_file($relative_file, @path)

$abs_file = File::Where->where_pm($pm);
$abs_file = File::Where->where_pm($pm, @path);
$abs_file = File::Where->where_pm($pm, @path);

($abs_file, $inc_path, $require) = File::Where->where_pm($pm);
($abs_file, $inc_path, $require) = File::Where->where_pm($pm, @path);
($abs_file, $inc_path, $require) = File::Where->where_pm($pm, @path);

$abs_dir = File::Where->where_repository($repository);
$abs_dir = File::Where->where_repository($repository, @path);
$abs_dir = File::Where->where_repository($repository, @path);

($abs_dir, $inc_path, $rel_dir) = File::Where->where_repository($repository);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_repository($repository, @path);
($abs_dir, $inc_path, $rel_dir) = File::Where->where_repository($repository, @path);

From time to time, an program needs to know the abolute file for a program module that has not been loaded. The File::Where module provides methods to find this information. For loaded files, using the hash %INC may perform better than using the methods in this module.

Jinamp is primarily a music shuffler for command line junkies. Jinamp runs in the background and does not require X or even a terminal.
A control program allows limited control over the playing (pause, next song, etc., but no seeking).
The actual playing is done by other programs, so it can be adapted for other purposes, such as shuffling video clips for advertising.
Enhancements:
- The control tools have been improved, in particular making once-off song requests possible.

LINGOT is a musical instrument tuner. LINGOT is easy to use, accurate, and highly configurable. Originally conceived to tune electric guitars, its configurability gives it a more general character. (Tuning another instruments has not been tested).
It looks like an analogic tuner, with a gauge indicating the relative shift to a certain note --found automatically as the closest note to the estimated frequency--, indicating that note and its frequency.
The note will be found automatically, since the program hasnt any manual function mode (indicating the note to tune manually), for mantaining its general purpose.
We recommend using the tuner in conjunction with a sound mixer for selecting the desired recording source and the signal recording levels.
Main features:
- Accurate.
- Easy to use. Just plug in your instrument and run tuner.
- Very configurable via GUI. Its possible to change any parameter while the program is running, without editing any file.
- It works in an automatic way. It isnt necessary specify the note to tune; the program guesses it.
- Its free software. It has GPL license.
- Tuning other instruments than guitars is possible. Since this program guesses the note you are playing, it can be used to tune a piano, a bass, a violin, etc.
Enhancements:
- Files have been reorganized to a more "GNU-like" structure.
- Multi-lingual support has been added.

Image::WorldMap is a Perl module to create graphical world maps of data.

SYNOPSIS

use Image::WorldMap;
my $map = Image::WorldMap->new("earth-small.png", "maian/8");
$map->add(4.91, 52.35, "Amsterdam.pm");
$map->add(-2.355399, 51.3828, "Bath.pm");
$map->add(-0.093999, 51.3627, "Croydon.pm");
$map->draw("test.png");

This module helps create graphical world maps of data, such as the Perl Monger World Map (http://www.astray.com/Bath.pm/). This module takes in a number of label locations (longitude/latitude) and outputs an image. It can attach text to the labels, and tries to make sure that labels do not overlap.

It is intended to be used to create images of information such as "where are all the Perl Monger groups?", "where in the world are all the CPAN mirrors?" and so on.
This module comes with a low-resolution image of the world. Additional larger images have not been bundled with the module due to their size, but are available at: http://www.astray.com/WorldMap/

Speak Good Chinese is a cross-platform application based on GTK technology that allows you or your students to train their Mandarin pronunciation. Our software is based on Praat, leading software in speech analysis. Our speech technology is backed by the Institute of Phonetic Sciences part of the University of Amsterdam.
SpeakGoodChinese software was supported financially by the DU. Questions can be mailed to stefandekonink@xs4all.nl, they will be forwarded to the appropriate project member.
Enhancements:
- This release makes administrative tasks easier for teachers or students that want to manage or distribute their own wordlists.
- Another new feature in this subsystem is the shuffle function.
- Several bugs were solved related to cleaning up old recordings.
- New documentation was added.

DateTime::Format::Epoch::MacOS is a Perl module that can convert DateTimes to/from Mac OS epoch seconds.

SYNOPSIS

use DateTime::Format::Epoch::MacOS;

my $dt = DateTime::Format::Epoch::MacOS->parse_datetime( 1051488000 );
DateTime::Format::Epoch::MacOS->format_datetime($dt);
# 1051488000

my $formatter = DateTime::Format::Epoch::MacOS->new();

my $dt2 = $formatter->parse_datetime( 1051488000 );

$formatter->format_datetime($dt2);
# 1051488000

This module can convert a DateTime object (or any object that can be converted to a DateTime object) to the number of seconds since the Mac OS epoch.
Note that the Mac OS epoch is defined in the local time zone. This means that these two pieces of code will print the same number of seconds, even though they represent two datetimes 6 hours apart:

$dt = DateTime->new( year => 2003, month => 5, day => 2,
time_zone => Europe/Amsterdam );
print $formatter->format_datetime($dt);

$dt = DateTime->new( year => 2003, month => 5, day => 2,
time_zone => America/Chicago );
print $formatter->format_datetime($dt);

Mac OS X is a Unix system, and uses the Unix epoch (1970-01-01T00:00:00). Use DateTime::Format::Epoch::Unix instead.