This page (revision-270) was last changed on 26-Mar-2023 02:03 by Administrator 

This page was created on 20-Feb-2010 19:16 by Carsten Strotmann

Only authorized users are allowed to rename pages.

Only authorized users are allowed to delete pages.

Page revision history

Version Date Modified Size Author Changes ... Change note
270 26-Mar-2023 02:03 17 KB Administrator to previous
269 26-Mar-2023 02:02 17 KB Administrator to previous | to last
268 26-Mar-2023 02:01 17 KB Administrator to previous | to last
267 26-Mar-2023 02:00 17 KB Administrator to previous | to last ACTION Source Code ==> Action Source Code
266 26-Mar-2023 01:59 17 KB Administrator to previous | to last
265 26-Mar-2023 01:58 17 KB Administrator to previous | to last
264 26-Mar-2023 01:56 17 KB Administrator to previous | to last Remove links to delete manual pages
263 26-Mar-2023 01:22 17 KB Administrator to previous | to last Fix SF links
262 26-Mar-2023 01:21 17 KB Administrator to previous | to last
261 26-Mar-2023 01:18 17 KB Administrator to previous | to last Move manuals to Sourceforge

Page References

Incoming links Outgoing links
Action

Version management

Difference between version and

At line 4 added 2 lines
[{TableOfContents }]
At line 5 changed one line
Action! is an Atari-specific programming language written by Clinton Parker and sold by Optimized Systems Software (OSS) in ROM cartridge form starting in August 1983. It is perhaps the only 3rd party language (as opposed to BASIC or assembler) that had real popularity on the platform and saw any significant coverage in the Atari press; type-in programs and various technical articles were found in most magazines. In comparison, languages like [Forth] and [Logo] saw much less use and almost no press coverage.
Action! is an Atari-specific programming language written by Clinton Parker and sold by Optimized Systems Software (OSS) in ROM cartridge form starting in August 1983. It is the only language other than [BASIC|Basic] and [assembler]) that had real popularity on the platform and saw any significant coverage in the Atari press; type-in programs and various technical articles were found in most magazines. In comparison, languages like [Forth] and [Logo] saw much less use and almost no press coverage.
At line 7 changed one line
Action! uses a greatly cut-down version of the ALGOL syntax, and thus bears strong similarities with [Pascal] and [C]. Like those languages, Action! is procedural, with programs essentially consisting of a large collection of functions that call each other. It lacked encapsulation or data hiding, but that is not a serious concern in the limited program sizes available on an 8-bit machine. Syntactically it looks very similar to Pascal, with the exception that it uses ALGOL68 DO/OD style bracketing rather than Pascal's BEGIN/END.
Reviewers at the time gushed about the system. They noted that practically every aspect was superior to anything available at the time; compiling was almost instantaneous, the resulting code ran almost as fast as hand-coded assembler, the full-screen editor was universally loved, and the entire system took up only 8k due to clever memory management. The only complaint, also universal, was the poor quality of the original manual set.
At line 9 changed one line
Action! included a number of features to allow it to run as fast as possible. Notably, it's main data types were BYTE, INT and CARD, 8-bit and 16-bit signed and unsigned values, respectively. These map directly onto the basic 6502-types. The language also included a syntax to directly refer to these objects in memory so they could be mapped into hardware registers. For instance, one could set a variable to "BYTE RTCLOK=20" which defined the 8-bit value at memory location 20 to be the value of the real-time clock. The user could then read that register using the name "RTCLOK".
Action! uses a greatly cut-down version of the ALGOL syntax, and thus bears strong similarities with [Pascal] and [C], which were also derived from ALGOL. Like those languages, Action! is procedural, with programs essentially consisting of a large collection of functions that call each other. It lacked encapsulation or data hiding, but that is not a serious concern in the limited program sizes available on an 8-bit machine. Syntactically it looks very similar to Pascal, with the exception that it uses ALGOL 68 DO/OD style bracketing rather than Pascal's BEGIN/END.
At line 11 changed one line
Curiously, Action! did not include support for floating point types, although such support is built into the machine's OS ROM (see [Atari Basic] for details) and available to any programming language. This is a significant limitation in some roles, although perhaps not for its target market. It also lacked most string handling, but made up for this somewhat with a PRINTF command that made formatted output easy.
Action! included a number of features to allow it to run as fast as possible. Notably, it's main data types were BYTE, INT and CARD, 8-bit and 16-bit signed and unsigned values, respectively. These map directly onto the basic 6502-types. The language also included a syntax to directly refer to these objects in memory so they could be mapped into hardware registers. For instance, one could set a variable to {{BYTE RTCLOK=20}} which defined the 8-bit value at memory location 20 to be the value of the real-time clock. The user could then read or write to that register using the name {{RTCLOK}}.
At line 13 changed one line
Generally, Action! programs had performance on-par with reasonable-quality [assembler], while being much easier to program. In one review, it ran Byte's Sieve of Eratosthenes 219 times faster than Atari BASIC, while its source was only a few lines longer. In comparison, the assembler version's source ran on for several pages. Such performance, combined with terse code and library functions to access much of the platform's hardware, made it suitable for action games while still having a simple format suitable for type-in programs. It deserved to be much more popular, and may have been had it been released earlier, or by Atari itself.
These design details helped increase performance, but the primary reason Action! was much faster than other languages of the era was due to its memory management model. In languages like C and Pascal, procedure calls use a stack of records known as "activation records" that record the values of variables when the procedure was called. This allows a procedure to call itself, as each call can have its own values, and it is this feature that allows recursion. This concept requires the manipulation of a stack, which in the 6502 was a non-trivial prospect given the CPU stack was only 256 bytes.
At line 17 added 6 lines
Action! solved this problem by simply not implementing activation records. Instead, the storage space for variables was allocated at compile time (not dissimilar to Atari BASIC's model). This meant Action! could not support recursion, but also eliminated the necessity to build and manipulate a complex stack. This dramatically lowers the overhead of procedure calls, and in a language that organizes a program as a series of procedure calls, this represents a significant amount of time.
Action! had a number of limitations, none of them very serious. Curiously, Action! did not include support for floating-point types, although such support is built into the machine's OS ROM (see [Atari BASIC] for details) and available to any programming language. This is a significant limitation in some roles, although perhaps not for its target market. It also lacked most string handling routines, but made up for this somewhat with a series of PRINT commands that made formatted output easy.
Generally, Action! programs had performance on-par with reasonable-quality [assembler], while being much easier to program. In one review, it ran Byte's Sieve of Eratosthenes 219 times faster than Atari BASIC, while its source was only a few lines longer. In comparison, the assembler version's source ran on for several pages. Such performance, combined with terse code and library functions to access much of the platform's hardware, made it suitable for action games while still having a simple source format suitable for type-in programs. It deserved to be much more popular, and may have been had it been released earlier, or by Atari itself.
At line 17 removed one line
''Editor's note:'' A version of Action! with support for a FLOAT type and a replacement floating point library like the one in [TURBO-BASIC XL] would be a ''very'' interesting project. A STRING type would also be useful!
At line 20 removed 7 lines
{{
\\
; Hello world in Action! programming language for the Atari 8-Bit computers\\
PROC Main()\\
PrintE("Hello World!")\\
RETURN\\
}}
At line 28 changed one line
The ; is a comment marker, which was a commonly used in assembler. The PROC is the start of a PROCedure, which ends (perhaps oddly) with RETURN. Like C-based languages, execution begins by calling the PROC named "Main". The only line of code in this example is PrintE, which simply prints a string, while the more common PrintF is a formatted print similar to printf in C.
{{{
; Hello world in Action! programming language for the Atari 8-Bit computers
PROC Hello()
PrintE("Hello World!")
RETURN
}}}
At line 35 added 2 lines
The {{;}} is a comment marker, which was a commonly used as the comment marker in assembler as well. The {{PROC}} is the start of a PROCedure, which ends (perhaps oddly) with {{RETURN}}. In Action!, the last {{PROC}} in the program is the one that runs first, in this case "Hello". This is something of a mix between Pascal where the "global code" defines the program entry point, and C, where the function called "Main" is the entry point. The only line of code in this example is {{PrintE}}, which simply prints a string, while the more common {{PrintF}} is a formatted print similar to {{printf}} in C.
At line 31 changed 19 lines
{{
\\
; Hello world in a loop\\
PROC Main()\\
BYTE RTCLOK=20, ; address of system timer\\
CONSOL=$D01F ; address of the key-pressed register\\
CARD TIME\\
\\
RTCLOK=0 ; reset the clock\\
WHILE CONSOL>6\\
DO\\
PRINTE("Hello World!")\\
OD\\
TIME = RTCLOK\\
PRINTF("Ran for %E %U jiffies",TIME)\\
RETURN\\
\\
}}
Note that the definitions of RTCLOK and CONSOL are not setting the values, but stating that they are at those memory locations. The syntax changes when those variables are accessed; the RTCLOK=0 ''does'' set the value of that location. Also notice the syntax of loops, which work similarly to Pascal's BEGIN/END but use DO/OD.
{{{
; Hello world in a loop
PROC Hello()
BYTE RTCLOK=20, ; decimal address of system timer
CONSOL=$D01F ; hex address of the key-pressed register
CARD TIME
RTCLOK=0 ; reset the clock
WHILE CONSOL>6 ; did the user press a key?
DO
PRINTE("Hello World!")
OD
TIME = RTCLOK
PRINTF("Ran for %E %U jiffies",TIME)
RETURN
}}}
Note that the definitions of {{RTCLOK}} and {{CONSOL}} are not setting the values, but stating that they are at those memory locations. The syntax changes when those variables are accessed; the {{RTCLOK=0}} ''does'' set the value of that location. Also notice the syntax of loops, which work similarly to Pascal's {{BEGIN/END}} but use {{DO/OD}}.
At line 51 changed one line
[{TableOfContents }]
There is a clever trick in this code. Note that {{RTCLOK}} is defined as a {{BYTE}} but {{TIME}} is defined as a {{CARD}}, a 16-bit value. This is because the clock value is stored in three bytes, 18, 19 and 20. By defining {{TIME}} as a {{CARD}}, when that value is read it automatically reads two bytes, thereby getting a value from both 20 and 19. This solution ignores the third byte, but since the value is from 0 to 65535 jiffies, about 36 minutes, this can safely be ignored for a program that is likely to run for a few seconds. This solution avoids the need to read two bytes and manipulate them into a 16-bit value, something that is commonly found in BASIC programs.
At line 70 changed 2 lines
Thank you Alfred\\
\\
Thank you Alfred
* [Action-Editor.asm] ; Source code for the ACTION! editor extracted out of the ACTION! source code. Mega-thanks to Alfred from AtariAge. :-)))
At line 76 changed 2 lines
* [Action_manual_3rd-revised_edition_2015_by_GBXL.pdf] ;The complete Action! manual! Editor, Monitor, Language, Compiler, Library, Run Time, Toolkit. 3rd revised edition 2015 by [GoodByteXL|http://home.arcor.de/walter.lojek/MyATARIHomepage/old_hp/OSS/OSS.HTM]. Highly recommended by the AtariWiki! This is, without any(!) doubt, the very best edition worldwide available. Nobody does it better. Mega-thanks to [GoodByteXL|http://home.arcor.de/walter.lojek/MyATARIHomepage/old_hp/OSS/OSS.HTM] for this outstanding work and the many hours of work to the community. We are deep in your debt! Thank you so much. :-)))
* [Action-Handbuch-komplett_2016_von_GBXL.pdf] ; Das komplette, vollständige, restaurierte und überarbeitete Action!-Handbuch in deutsch! Der totale Hammer, inkl. Editor, Monitor, Language, Compiler, Library, Run Time, Toolkit. Vollständig überarbeitete Version von 2016 von [GoodByteXL|http://home.arcor.de/walter.lojek/MyATARIHomepage/old_hp/OSS/OSS.HTM]. So müssen PDF-Dateien aussehen, es gibt weltweit nichts vergleichbares. AtariWiki empfiehlt die PDF-Datei auf das Wärmste! Wer diese nicht lädt, ist selber schuld. Wir bedanken uns an dieser Stelle sehr, sehr herzlich bei [GoodByteXL|http://home.arcor.de/walter.lojek/MyATARIHomepage/old_hp/OSS/OSS.HTM] für seine lange andauernde und intensive Arbeit an diesem Werk, dass er hiermit der Atari-Gemeinschaft zur Verfügung stellt. Empfohlen sei auch seine Webseite: [GoodByteXL|http://home.arcor.de/walter.lojek/MyATARIHomepage/old_hp/OSS/OSS.HTM] in der immer die neueste Version sowie viele andere interessante Sachen über Atari zu finden sind. [GoodByteXL|http://home.arcor.de/walter.lojek/MyATARIHomepage/old_hp/OSS/OSS.HTM] mega-Danke für Deine Arbeit, die Gemeinschaft steht tief in Deiner Schuld. :-)))
* [Action_manual_3rd-revised_edition_2018_by_GBXL|action_rev_3-6_GBXL_2018.pdf] ; size: 991 KB ; 3rd revised and enlarged edition (p) 2018 by GBXL. There is no better version worldwide! Thank you so much GBXL. We are deep in your debt! :-)))
* [Action-Handbuch-komplett_2016_von_GBXL.pdf] ; Das komplette, vollständige, restaurierte und überarbeitete Action!-Handbuch in deutsch! Der totale Hammer, inkl. Editor, Monitor, Language, Compiler, Library, Run Time, Toolkit. Vollständig überarbeitete Version von 2016 von GoodByteXL. So müssen PDF-Dateien aussehen, es gibt weltweit nichts vergleichbares. AtariWiki empfiehlt die PDF-Datei auf das Wärmste! Wer diese nicht lädt, ist selber schuld. Wir bedanken uns an dieser Stelle sehr, sehr herzlich bei GoodByteXL für seine lange andauernde und intensive Arbeit an diesem Werk, dass er hiermit der Atari-Gemeinschaft zur Verfügung stellt. GoodByteXL mega-Danke für Deine Arbeit, die Gemeinschaft steht tief in Deiner Schuld. :-)))
* [Action_manual_3rd-revised_edition_2015_by_GBXL.pdf] ;The complete Action! manual! Editor, Monitor, Language, Compiler, Library, Run Time, Toolkit. 3rd revised edition 2015 by GoodByteXL. Highly recommended by the AtariWiki! This is, without any(!) doubt, the very best edition worldwide available. Nobody does it better. Mega-thanks to GoodByteXL for this outstanding work and the many hours of work to the community. We are deep in your debt! Thank you so much. :-)))
At line 95 changed one line
* [ACTION! greater than version 3.6|http://www.wudsn.com/productions/atari800/action/action.zip] ; thanks to JAC! for compiling and fixing the known bugs. Please go ahead with your outstanding work in this, we really appreciate your help and work very much.
* [Action! greater than version 3.6|http://www.wudsn.com/productions/atari800/action/action.zip] ; thanks to JAC! for compiling and fixing the known bugs. Please go ahead with your outstanding work in this, we really appreciate your help and work very much.
At line 105 changed 2 lines
!! Runtimes
* [OSS_ACTION_Programmers_Aid_Disk_100.atr]
!! ATR-Images
* [OSS_ACTION_Programmers_Aid_Disk_100.atr] ; rebuild from damaged discs and files around the world
At line 117 changed 2 lines
!! XEX-File
* [ACTION.XEX] ; Thanks goes to Peter Dell for making the XEX-file out of the above source code. Peter, we owe you so much, please go ahead! :-)
!! XEX-Files
* [ACTION.XEX] ; Thanks goes to Peter Dell for making the XEX-file out of the above source code. Peter, we owe you so much, please go ahead! :-)
* [Action_Editor-MADS.xex] ; If you rename the file to E.COM, you can even use it under SpartaDOS I for example with D1:E MYSRC.ACT to direct load the MYSRC.ACT file into the editor. Further, this editor can even be used for BASIC, PASCAL, FORTH etc... A Giga-thanks goes to Alfred from AtariAge for extracting the source code from Clinton Parker's original source code and JAC! from AtariAge for building the xex file from that very source code, while adapting to MADS. Great job, not only for Action! :-)))
At line 211 changed one line
Now just these two are missing. Any hint, any help is welcome at any time. We would really appreciate your help in that case.\\
__As of 2020, just these two programs are still missing. They were published via OSS-BBS only! The number was: +1 (408) 438 - 6775. Any hint, any help is welcome at any time. We would really appreciate your help in that case.__\\
At line 220 changed one line
Shape Editor and Animator for ACTION! \\
Shape Editor and Animator for ACTION!\\
\\
[{Image src='OSS-BBS_.jpg' width=556 height=310 }]
OSS-BBS with the number: +1 (408) 438 - 6775 where the two missing programs were published only!
At line 239 changed one line
|[Trails]|#50 (01/ 87)|en|
|[Trails]|#50 (01/ 87)|en|tool for using the KoalaPad in ACTION!
At line 272 changed one line
|[ACTION! Deel]| |nl|A collection of ACTION! Articles
|[ACTION! Deel]| |nl|A collection of ACTION! Articles
!ACTION! ads
[{Image src='00_first_ad_in_compute_Jul1983.jpg' width=600 height=802 }]
ACTION! first ad in Compute July, 1983 ; please take into account: 128-column screen and for Apple II & Commodore 64. Thanks to GoodByteXL!
!!!Cross Compiler for ACTION!
* [http://gury.atari8.info/effectus/] ; Thank you soooo much Gury! That is totally incredible, we now can use high end editors, eclipse and have the results in a flash! We are deep in your debt! Thank you so much, really. :-)