Free atari 8 software for linux

Hatari is project an Atari ST and STE emulator for Linux, BSD, BeOS, Mac OS X and other systems that are supported by the SDL library. The Atari ST was a 16/32 bit computer system which was first released by Atari in 1985.
Using the Motorola 68000 CPU, it was a very popular computer having quite a lot of CPU power at that time. Unlike many other Atari ST emulators which try to give you a good environment for running GEM applications, Hatari tries to emulate the hardware of a ST as close as possible so that it is able to run most of the old ST games and demos.
Hatari is open source software and is distributed under the terms of the GNU General Public License (GPL).
Enhancements:
- This release brings you basic Atari TT and Falcon emulation! Please note that both new emulation modes are still highly experiemental, some few games and demos work, but most still have more or less big problems.
- Basic emulation of Falcon video shifter (Videl), NVRAM and DMA sound is in place. The biggest drawback: There is no working Falcon DSP emulation yet.
- Screen/Shifter emulation timings have slightly been changed. Some things now work better, some others work worse...
- Some patches for compiling on RiscOS and AmigaOS have been included.
- Compiling Hatari for Windows now works better.
- Added Hatari icon (hatari-icon.bmp).
- Fixed "movec" bug in 68020 CPU mode.
- Keyboard shortcuts for loading & saving memory snapshots (AltGr+k & AltGr+l).
- The built-in debugger has been slightly improved to be more user-friendly.
- Added "hmsa" tool a little program for converting .MSA files to .ST and vice versa.

hatatap project is an HTTP scripting tool with scripts in XML. The scripts are transformed into Java/o:XML before they are either executed from the commandline, integrated into Ant build files, or run interactively from a Web application.
hatatap supports cookies, Javascript, HTML DOM, Web Services/SOAP, performance tests with concurrency, test reports, regular expression matching, and stateful Web site navigation. It is written in o:XML and uses HttpUnit.
Main features:
- stateful navigation
- HTML forms
- nested frames
- pop-up windows
- cookies and headers
- GET, POST and PUT requests
- HTTPS support
- regular expressions
- DOM-based response navigation using XPath
- XML requests and responses (eg SOAP) for testing web services
- multipart forms and file uploads
- multipart MIME XML requests
- millisecond timings and concurrency for performance testing
- XML test results
- random value functions
- extensible test scripts
- JavaScript support
- basic HTTP authentication
- HTTP proxy settings with authentication
- automatic redirect and refresh
- SSL certificate management
- domain name aliasing
- multipart MIME server responses (todo)
Enhancements:
- Binary attachment capabilities were added.
- A classpath problem was fixed in the Ant task.
- An upgrade was made to HttpUnit 1.6.2 and the latest ObjectBox and o:Lib releases.

AutoSplit is a Perl module that can split a package for autoloading.

SYNOPSIS

autosplit($file, $dir, $keep, $check, $modtime);

autosplit_lib_modules(@modules);

This function will split up your program into files that the AutoLoader module can handle. It is used by both the standard perl libraries and by the MakeMaker utility, to automatically configure libraries for autoloading.

The autosplit interface splits the specified file into a hierarchy rooted at the directory $dir. It creates directories as needed to reflect class hierarchy, and creates the file autosplit.ix. This file acts as both forward declaration of all package routines, and as timestamp for the last update of the hierarchy.
The remaining three arguments to autosplit govern other options to the autosplitter.

$keep

If the third argument, $keep, is false, then any pre-existing *.al files in the autoload directory are removed if they are no longer part of the module (obsoleted functions). $keep defaults to 0.

$check

The fourth argument, $check, instructs autosplit to check the module currently being split to ensure that it includes a use specification for the AutoLoader module, and skips the module if AutoLoader is not detected. $check defaults to 1.

$modtime

Lastly, the $modtime argument specifies that autosplit is to check the modification time of the module against that of the autosplit.ix file, and only split the module if it is newer. $modtime defaults to 1.

Typical use of AutoSplit in the perl MakeMaker utility is via the command-line with:

perl -e use AutoSplit; autosplit($ARGV[0], $ARGV[1], 0, 1, 1)

Defined as a Make macro, it is invoked with file and directory arguments; autosplit will split the specified file into the specified directory and delete obsolete .al files, after checking first that the module does use the AutoLoader, and ensuring that the module is not already currently split in its current form (the modtime test).

The autosplit_lib_modules form is used in the building of perl. It takes as input a list of files (modules) that are assumed to reside in a directory lib relative to the current directory. Each file is sent to the autosplitter one at a time, to be split into the directory lib/auto.

In both usages of the autosplitter, only subroutines defined following the perl __END__ token are split out into separate files. Some routines may be placed prior to this marker to force their immediate loading and parsing.

Multiple packages

As of version 1.01 of the AutoSplit module it is possible to have multiple packages within a single file. Both of the following cases are supported:

package NAME;
__END__
sub AAA { ... }
package NAME::option1;
sub BBB { ... }
package NAME::option2;
sub BBB { ... }

package NAME;
__END__
sub AAA { ... }
sub NAME::option1::BBB { ... }
sub NAME::option2::BBB { ... }

B::Asmdata is an autogenerated data about Perl ops, used to generate bytecode.

SYNOPSIS

use B::Asmdata qw(%insn_data @insn_name @optype @specialsv_name);

Provides information about Perl ops in order to generate bytecode via a bunch of exported variables. Its mostly used by B::Assembler and B::Disassembler.

%insn_data

my($bytecode_num, $put_sub, $get_meth) = @$insn_data{$op_name};

For a given $op_name (for example, cop_label, sv_flags, etc...) you get an array ref containing the bytecode number of the op, a reference to the subroutine used to PUT, and the name of the method used to GET.

@insn_name

my $op_name = $insn_name[$bytecode_num];

A simple mapping of the bytecode number to the name of the op. Suitable for using with %insn_data like so:

my $op_info = $insn_data{$insn_name[$bytecode_num]};

@optype

my $op_type = $optype[$op_type_num];

A simple mapping of the op type number to its type (like COP or BINOP).

@specialsv_name

my $sv_name = $specialsv_name[$sv_index];

Certain SV types are considered special. Theyre represented by B::SPECIAL and are referred to by a number from the specialsv_list. This array maps that number back to the name of the SV (like Nullsv or &PL_sv_undef).

TargetAlert is a Firefox extension that provides a visual cue for the destination of a hyperlink by appending a link with an icon that shows what type of file it leads to, or the effects it may have, such as opening a new window or leaving a secure site.

Icons can be set to appear only when mousing over a link (default), or they may be added to links automatically when the page loads. TargetAlert makes it easier to locate links to important document types while also providing warnings for links with undesired effects.

Supported locales: cs-CZ, de-DE, en-US, es-ES, fr-FR, it-IT, nl-NL, pl-PL, pt-BR, ru-RU.

ActivePerl project is the complete, quality-assured and ready-to-install Perl distribution for AIX, HP-UX, Linux, Mac OS X, Solaris, and Windows.
Whats included:
- Perl core
- Perl Package Manager
- Installers
- Complete online documentation
Enhancements:
- Release version of 64-bit ActivePerl for Linux, Solaris and Windows.
- Rewritten PPM client. The command line shell has been replaced by a graphical user interface.
- Bundles the Tcl and Tkx modules, plus a significant subset of the latest Tcl/Tk widgets.

Stella is a multi-platform Atari 2600 VCS emulator.
Stella was originally developed for Linux by Bradford W. Mott, however, since its original release several people have joined the development team to port Stella to other operating systems such as AcornOS, AmigaOS, DOS, FreeBSD, IRIX, Linux, OS/2, MacOS, Unix, and Windows. The development team is working hard to perfect the emulator and we hope you enjoy our effort.
On this site youll find information about downloading, installing, using, and enhancing Stella. Youll also find useful information about the Atari 2600 and emulation.
Enhancements:
Added new video sub-system where fullscreen and windowed modes are treated
differently. Windowed modes now use -zoom_tia and -zoom_ui arguments,
while fullscreen modes can be specified by resolution using the new
-fullres argument.
- Widescreen video modes are now supported; Stella will simply center the
image with surrounding black borders.
- Many UI-related changes, including resizable ROM launcher and debugger
windows, and a new UI palette (the previous classic palette is still
available). This is still a work in progress.
- The locations of all major config files (statedir, palette file,
cheat file, properties file, etc) are now configurable from the
commandline and within the UI.
- Updates to TIA palette support. Added SECAM support, and removed the
built-in original palette. Standard, z26, and user are still
available.
- Various bugfixes to some debugger commands. The run command no
longer causes a crash, and several others have better error-checking.
- Added more complete cartridge auto-detection for Commavid (CV), 3E,
3F and Activision (FE) formats.
- Removed XStart and Width ROM properties, since the forthcoming TIA
rework wont be using them.
- Reworked internal storage of ROM properties to be faster and take up
less space.
- Added several different ways of stretching the OpenGL image to the
-gl_fsmax argument, for more flexibility.
- Removed OpenGL aspect ratio setting favour of the previously mentioned
video changes. Well see how this goes.
- Removed dirty-rect support from software rendering, since it was actually
sub-optimal in Windows and OSX and defaulted to off in previous versions.
- Added support for gzipped ROMs.
- Re-added pause support.
- Re-added support for Windows 98.
- Removed support for STELLA_BASEDIR environment variable, since each
config file can be now configured separately.
- Removed -fastscbios argument, since it must always be turned on.
- Removed PSP support, since it hasnt been updated in over a year, and
someone else is maintaining another port elsewhere.
- For the Unix/Linux port; fixed make install issues, and changed icon to
PNG format.

B::Deparse is a Perl compiler backend to produce perl code.

SYNOPSIS

perl -MO=Deparse[,-d][,-fFILE][,-p][,-q][,-l] [,-sLETTERS][,-xLEVEL] prog.pl

B::Deparse is a backend module for the Perl compiler that generates perl source code, based on the internal compiled structure that perl itself creates after parsing a program. The output of B::Deparse wont be exactly the same as the original source, since perl doesnt keep track of comments or whitespace, and there isnt a one-to-one correspondence between perls syntactical constructions and their compiled form, but it will often be close. When you use the -p option, the output also includes parentheses even when they are not required by precedence, which can make it easy to see if perl is parsing your expressions the way you intended.

While B::Deparse goes to some lengths to try to figure out what your original program was doing, some parts of the language can still trip it up; it still fails even on some parts of Perls own test suite. If you encounter a failure other than the most common ones described in the BUGS section below, you can help contribute to B::Deparses ongoing development by submitting a bug report with a small example.

OPTIONS

As with all compiler backend options, these must follow directly after the -MO=Deparse, separated by a comma but not any white space.

-d

Output data values (when they appear as constants) using Data::Dumper. Without this option, B::Deparse will use some simple routines of its own for the same purpose. Currently, Data::Dumper is better for some kinds of data (such as complex structures with sharing and self-reference) while the built-in routines are better for others (such as odd floating-point values).

-fFILE

Normally, B::Deparse deparses the main code of a program, and all the subs defined in the same file. To include subs defined in other files, pass the -f option with the filename. You can pass the -f option several times, to include more than one secondary file. (Most of the time you dont want to use it at all.) You can also use this option to include subs which are defined in the scope of a #line directive with two parameters.

-l

Add #line declarations to the output based on the line and file locations of the original code.

-p

Print extra parentheses. Without this option, B::Deparse includes parentheses in its output only when they are needed, based on the structure of your program. With -p, it uses parentheses (almost) whenever they would be legal. This can be useful if you are used to LISP, or if you want to see how perl parses your input. If you say

if ($var & 0x7f == 65) {print "Gimme an A!"}
print ($which ? $a : $b), "n";
$name = $ENV{USER} or "Bob";
B::Deparse,-p will print
if (($var & 0)) {
print(Gimme an A!)
};
(print(($which ? $a : $b)), ???);
(($name = $ENV{USER}) or ???)

which probably isnt what you intended (the ??? is a sign that perl optimized away a constant value).

-P

Disable prototype checking. With this option, all function calls are deparsed as if no prototype was defined for them. In other words,

perl -MO=Deparse,-P -e sub foo (@) { 1 } foo @x

will print

sub foo (@) {
1;
}
&foo(@x);

making clear how the parameters are actually passed to foo.

-q

Expand double-quoted strings into the corresponding combinations of concatenation, uc, ucfirst, lc, lcfirst, quotemeta, and join. For instance, print

print "Hello, $world, @ladies, u$gentlemenE, uL$me!";

as

print Hello, . $world . , . join($", @ladies) . ,
. ucfirst($gentlemen) . , . ucfirst(lc $me . !);

Note that the expanded form represents the way perl handles such constructions internally -- this option actually turns off the reverse translation that B::Deparse usually does. On the other hand, note that $x = "$y" is not the same as $x = $y: the former makes the value of $y into a string before doing the assignment.

-sLETTERS

Tweak the style of B::Deparses output. The letters should follow directly after the s, with no space or punctuation. The following options are available:

C

Cuddle elsif, else, and continue blocks. For example, print

if (...) {
...
} else {
...
}
instead of
if (...) {
...
}
else {
...
}

The default is not to cuddle.

iNUMBER

Indent lines by multiples of NUMBER columns. The default is 4 columns.

T

Use tabs for each 8 columns of indent. The default is to use only spaces. For instance, if the style options are -si4T, a line thats indented 3 times will be preceded by one tab and four spaces; if the options were -si8T, the same line would be preceded by three tabs.

vSTRING.

Print STRING for the value of a constant that cant be determined because it was optimized away (mnemonic: this happens when a constant is used in void context). The end of the string is marked by a period. The string should be a valid perl expression, generally a constant. Note that unless its a number, it probably needs to be quoted, and on a command line quotes need to be protected from the shell. Some conventional values include 0, 1, 42, , foo, and Useless use of constant omitted (which may need to be -sv"Useless use of constant omitted." or something similar depending on your shell). The default is ???. If youre using B::Deparse on a module or other file thats required, you shouldnt use a value that evaluates to false, since the customary true constant at the end of a module will be in void context when the file is compiled as a main program.

-xLEVEL

Expand conventional syntax constructions into equivalent ones that expose their internal operation. LEVEL should be a digit, with higher values meaning more expansion. As with -q, this actually involves turning off special cases in B::Deparses normal operations.

If LEVEL is at least 3, for loops will be translated into equivalent while loops with continue blocks; for instance

for ($i = 0; $i < 10; ++$i) {
print $i;
}
turns into
$i = 0;
while ($i < 10) {
print $i;
} continue {
++$i
}

Note that in a few cases this translation cant be perfectly carried back into the source code -- if the loops initializer declares a my variable, for instance, it wont have the correct scope outside of the loop.

If LEVEL is at least 5, use declarations will be translated into BEGIN blocks containing calls to require and import; for instance,

use strict refs;
turns into
sub BEGIN {
require strict;
do {
strict->import(refs)
};
}
If LEVEL is at least 7, if statements will be translated into equivalent expressions using &&, ?: and do {}; for instance
print hi if $nice;
if ($nice) {
print hi;
}
if ($nice) {
print hi;
} else {
print bye;
}
turns into
$nice and print hi;
$nice and do { print hi };
$nice ? do { print hi } : do { print bye };

Long sequences of elsifs will turn into nested ternary operators, which B::Deparse doesnt know how to indent nicely.