Action!

From Wikipedia, the free encyclopedia

Action!

Developer:	Optimized Systems Software
Latest Release:	3.6
Release date:	1983
Platform:	Atari 400/800/XL/XE
Genre:	Programming Language
Media:	cartridge
License:	Copyright © 1994 Fine Tooned Engineering

Action! was a programming language and integrated editor, debugger, and 6502 code generating compiler, editor for the Atari 8-bit family of microcomputers. Action! was created by Clinton Parker and released on cartridge by Optimized Systems Software in 1983. Its syntax was similar to that of ALGOL 68.

Action! was significant for its high performance, which allowed games and graphics demos to be written in a high-level language in an era when it was generally understood that performance required hand-written assembly language code. The language was tailored so there was a clean mapping between language constructs and the 6502 hardware.

A library was available as a separate product called the Action! Toolkit. Action! was used to develop at least one commercial product: the Homepak productivity suite. The language was never ported to other systems.

In 2007 it inspired Effectus - a cross-compiler currently running on Windows targeting the Atari 8-bit. Effectus resembles Action! syntax and is intended to be as compatible as possible with it.

1 Data Types
2 Reserved keywords
3 Programming
4 Example code
5 See also
6 External links

[edit] Data Types

Action! has three numerical datatypes BYTEs, CARDinals and INTegers. The BYTE datatype is a single unsigned 8-bit byte, CARD is unsigned and two bytes long, and INT is signed and two bytes. Action! also has CHARs, ARRAYs, POINTERs and user defined TYPEs. No floating point support was available.

An example of a user-defined TYPE:

 TYPE CORD=[CARD x,y]
 CORD point
 point.x=42
 point.y=23

[edit] Reserved keywords

 AND     FI       OR       UNTIL  =<   (
 ARRAY   FOR      POINTER  WHILE  <>   )
 BYTE    FUNC     PROC     XOR    #    .
 CARD    IF       RETURN   =      >    [
 CHAR    INCLUDE  RSH      -      >=   ]
 DEFINE  INT      SET      *      <    "
 DO      LSH      STEP     /      <=   '
 ELSE    MOD      THEN     &      $    ;
 ELSEIF  MODULE   TO       %      !    @
 EXIT    OD       TYPE

[edit] Programming

Programming in Action! required working with the editor and compiling/debugging in the monitor. The editor had a full-screen, scrolling display capable of displaying two windows. The editor included block operations and global search and replace. Compiling took place in the monitor, a mode that allowed compiling and debugging.

Action! was a one-pass compiler. It compiled the source code entirely in memory. This allowed great speed, but limited the amount of code that could be compiled.

Local variables were assigned fixed addresses in memory instead of being allocated on the stack. This enabled tight code to be generated for the 6502, but precluded the use of recursion.

[edit] Example code

The following is example code for Sieve of Eratosthenes written in Action. In order to increase performance, it disables the ANTIC graphics coprocessor on the Atari hardware, thus preventing its DMA engine from "stealing" CPU cycles during the computation.

BYTE RTCLOK=20, ; addr of sys timer
     SDMCTL=559 ; DMA control

BYTE ARRAY FLAGS(8190)

CARD COUNT,I,K,PRIME,TIME

PROC SIEVE()

  SDMCTL=0 ; shut off Antic
  RTCLOK=0 ; only one timer needed

  COUNT=0         ; init count
  FOR I=0 TO 8190 ; and flags
    DO
    FLAGS(I)='T ; "'T" is a compiler-provided constant for True
    OD

  FOR I=0 TO 8190 ; and flags
    DO
    IF FLAGS(I)='T THEN
      PRIME=I+I+3
      K=I+PRIME
      WHILE K<=8190
        DO
        FLAGS(K)='F ; "'F" is a compiler-provided constant for False
        K==+PRIME
        OD
      COUNT==+1
    FI
    OD
  TIME=RTCLOK ; get timer reading
  SDMCTL=34   ; restore screen

  PRINTF("%E %U PRIMES IN",COUNT)
  PRINTF("%E %U JIFFIES",TIME)
RETURN