Prog8 documentation - 10.3 

What is Prog8?

This is a compiled programming language targeting the 8-bit 6502 / 6510 / 65c02 microprocessors. This CPU is from the late 1970’s and early 1980’s and was used in many home computers from that era, such as the Commodore 64. The language aims to provide many conveniences over raw assembly code (even when using a macro assembler), while still being low level enough to create high performance programs. You can compile programs for various machines with this CPU:

Commander X16
Commodore 64
Commodore 128 (limited support)
Commodore PET (limited support)
Atari 800 XL (limited support)

The source code is on github: https://github.com/irmen/prog8.git

Software License

This is free software, as defined in the GNU GPL 3.0 (https://www.gnu.org/licenses/gpl.html) Exception: All output files generated by the compiler (intermediary files and compiled binary programs) are excluded from this particular license: you can do with those whatever you want. This means, for instance, that you can use the Prog8 compiler to create commercial software as long as you only sell the actual resulting program.

Want to buy me a coffee or a pizza perhaps?

This project was created over the last couple of years by dedicating thousands of hours of my free time to it, to make it the best I possibly can. If you like Prog8, and think it’s worth a nice cup of hot coffee or a delicious pizza, you can help me out a little bit over at https://ko-fi.com/irmen .

Features

it is a cross-compiler running on modern machines (Linux, MacOS, Windows, …)
the compiled programs run very fast, because compilation to highly efficient native machine code.
Provides a convenient and fast edit/compile/run cycle by being able to directly launch the compiled program in an emulator and provide debugging information to this emulator.
the language looks like a mix of Python and C so should be quite easy to learn
Modular programming, scoping via modules, code blocks, and subroutines. No need for forward declarations.
Provide high level programming constructs but at the same time stay close to the metal; still able to directly use memory addresses and ROM subroutines, and inline assembly to have full control when every register, cycle or byte matters
Subroutines with parameters and return values of various types
Complex nested expressions are possible
Variables are all allocated statically, no memory allocator overhead
Conditional branches for status flags that map 1:1 to processor branch instructions for optimal efficiency
when statement to avoid if-else chains
in expression for concise and efficient multi-value/containment test
Several powerful built-in functions, such as lsb, msb, min, max, rol, ror, sort and reverse
Variable data types include signed and unsigned bytes and words, arrays, strings.
Various powerful built-in libraries to do I/O, number conversions, graphics and more
Floating point math is supported on select compiler targets.
Easy and highly efficient integration with external subroutines and ROM routines on the target systems.
Strings can contain escaped characters but also many symbols directly if they have a PETSCII equivalent, such as “♠♥♣♦π▚●○╳”. Characters like ^, _, \, {, } and | are also accepted and converted to the closest PETSCII equivalents.
Encode strings and characters into petscii or screencodes or even other encodings, as desired (C64/Cx16)
Identifiers can contain Unicode Letters, so knäckebröd, приблизительно, 見せしめ and π are all valid identifiers.
Advanced code optimizations to make the resulting program smaller and faster
Programs can be restarted after exiting (i.e. run them multiple times without having to reload everything), due to automatic variable (re)initializations.
Supports the sixteen ‘virtual’ 16-bit registers R0 to R15 as defined on the Commander X16. These are also available on the other compilation targets!
On the Commander X16: Support for low level system features such as Vera Fx, which includes 16x16 bits multiplication in hardware and fast memory copy and fill.
Many library routines are available across compiler targets. This means that as long as you only use standard Kernal and core prog8 library routines, it is sometimes possible to compile the exact same program for different machines (just change the compilation target flag).

Code example

Here is a hello world program:

%import textio
%zeropage basicsafe

main {
    sub start() {
        txt.print("hello world i ♥ prog8\n")
    }
}

This code calculates prime numbers using the Sieve of Eratosthenes algorithm:

%import textio
%zeropage basicsafe

main {
    bool[256] sieve
    ubyte candidate_prime = 2       ; is increased in the loop

    sub start() {
        sys.memset(sieve, 256, 0)   ; clear the sieve
        txt.print("prime numbers up to 255:\n\n")
        ubyte amount=0
        repeat {
            ubyte prime = find_next_prime()
            if prime==0
                break
            txt.print_ub(prime)
            txt.print(", ")
            amount++
        }
        txt.nl()
        txt.print("number of primes (expected 54): ")
        txt.print_ub(amount)
        txt.nl()
    }

    sub find_next_prime() -> ubyte {
        while sieve[candidate_prime] {
            candidate_prime++
            if candidate_prime==0
                return 0        ; we wrapped; no more primes
        }

        ; found next one, mark the multiples and return it.
        sieve[candidate_prime] = true
        uword multiple = candidate_prime

        while multiple < len(sieve) {
            sieve[lsb(multiple)] = true
            multiple += candidate_prime
        }
        return candidate_prime
    }
}

when compiled an ran on a C64 you get this:

when the exact same program is compiled for the Commander X16 target, and run on the emulator, you get this:

Getting the compiler

Usually you just download a fat jar of an official released version, but you can also build it yourself from source. Detailed instructions on how to obtain a version of the compiler are in First, getting a working compiler.

Required additional tools

64tass - cross assembler. Install this program somewhere on your shell’s search path. It’s easy to compile yourself, but a recent precompiled .exe (only for Windows) can be obtained from the files section in the official project on sourceforge. You need at least version 1.58.0 of this assembler. If you are on Linux, there’s probably a “64tass” package in the repositories, but check if it is a recent enough version.

A Java runtime (jre or jdk), version 11 or newer is required to run the prog8 compiler itself. If you’re scared of Oracle’s licensing terms, get one of the versions of another vendor. Even Microsoft provides their own version. Other OpenJDK builds can be found at Adoptium . For MacOS you can also use the Homebrew system to install a recent version of OpenJDK.

Finally: an emulator (or a real machine of course) to test and run your programs on. For the PET, C64 and C128 targets, the compiler assumes the presence of the VICE emulator. If you’re targeting the Commander X16 instead, download a recent emulator version for the CommanderX16, such as x16emu (preferred, this is the official emulator. If required, source code is here. There is also Box16 which has powerful debugging features. For the Atari target, it assumes the “atari800” or “altirra” emulator. If multiple options are listed above, you can select which one you want to launch using the -emu or -emu2 command line options.

Syntax highlighting: for a few different editors, syntax highlighting definition files are provided. Look in the syntax-files directory in the github repository to find them.

Contents of this manual:

Index

Index