high level programming language and compiler targeting 6502 machines such as the C-64 and CommanderX16
Go to file
2021-11-29 22:09:05 +01:00
.idea converting compiler module's testcases to kotest (ongoing) 2021-11-08 15:08:48 +01:00
codeGeneration also consider Y register for clobber check for functioncall arguments 2021-11-29 22:09:05 +01:00
codeOptimizers fix invalid range size check when stepval is not a positive integer 2021-11-29 02:01:19 +01:00
compiler also consider Y register for clobber check for functioncall arguments 2021-11-29 22:09:05 +01:00
compilerAst optimize 1-arg functioncalls 2021-11-28 16:55:10 +01:00
compilerInterfaces also consider Y register for clobber check for functioncall arguments 2021-11-29 22:09:05 +01:00
dbusCompilerService converting compiler module's testcases to kotest assertions 2021-11-08 16:14:22 +01:00
docs also consider Y register for clobber check for functioncall arguments 2021-11-29 22:09:05 +01:00
examples also consider Y register for clobber check for functioncall arguments 2021-11-29 22:09:05 +01:00
gradle/wrapper updated gradle scripts (fixed warnings), updated some library dependencies 2021-06-13 18:10:07 +02:00
httpCompilerService converting compiler module's testcases to kotest assertions 2021-11-08 16:14:22 +01:00
parser fixed 'not' operator priority: it now has higher priority as or/and/xor. 2021-11-08 18:38:04 +01:00
scripts migrated compilerAst module to KoTest (but not finished with the assertions yet) 2021-11-07 17:25:53 +01:00
syntax-files undid failed attempt of using sys.push/sys.pop for stack args - now using new push(), pushw(), pop(), popw() builtin functions 2021-11-28 01:22:40 +01:00
.gitignore libs updated to maven 2021-10-12 03:33:52 +02:00
.readthedocs.yaml attempt to fix ReadTheDocs build issue 2021-11-07 00:37:31 +01:00
build.gradle simplified gradle config, automatically run installDist task after build 2021-10-30 12:01:52 +02:00
CompilerDevelopment.md Update CompilerDevelopment.md 2021-07-03 15:11:34 +02:00
gradle.properties update to Kotlin 1.6.0 2021-11-16 22:36:23 +01:00
gradlew updated gradle scripts (fixed warnings), updated some library dependencies 2021-06-13 18:10:07 +02:00
gradlew.bat updated gradle scripts (fixed warnings), updated some library dependencies 2021-06-13 18:10:07 +02:00
LICENSE software license 2021-05-02 15:31:14 +02:00
README.md get rid of automated CI builds for now 2021-10-12 20:27:25 +02:00
settings.gradle kotlin 1.5.31 2021-10-30 12:26:05 +02:00

Documentation

Prog8 - Structured Programming Language for 8-bit 6502/65c02 microprocessors

Written by Irmen de Jong (irmen@razorvine.net)

This is a structured programming language for the 8-bit 6502/6510/65c02 microprocessor from the late 1970's and 1980's as used in many home computers from that era. It is a medium to low level programming language, which aims to provide many conveniences over raw assembly code (even when using a macro assembler).

Documentation

Full documentation (syntax reference, how to use the language and the compiler, etc.) can be found at: https://prog8.readthedocs.io/

Software license

GNU GPL 3.0, see file LICENSE

  • prog8 (the compiler + libraries) is licensed under GNU GPL 3.0
  • exception: the resulting files created by running the compiler are free to use in whatever way desired.

What does Prog8 provide?

  • reduction of source code length over raw assembly
  • fast execution speed due to compilation to native assembly code. It's possible to write certain raster interrupt 'demoscene' effects purely in Prog8.
  • modularity, symbol scoping, subroutines
  • various data types other than just bytes (16-bit words, floats, strings)
  • floating point math is supported if the target system provides floating point library routines (C64 and Cx16 both do)
  • 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.
  • automatic static variable allocations, automatic string and array variables and string sharing
  • subroutines with input parameters and result values
  • high-level program optimizations
  • small program boilerplate/compilersupport overhead
  • programs can be run multiple times without reloading because of automatic variable (re)initializations.
  • conditional branches
  • 'when' statement to provide a concise jump table alternative to if/elseif chains
  • many built-in functions such as sin, cos, rnd, abs, min, max, sqrt, msb, rol, ror, swap, sort and reverse
  • various powerful built-in libraries to do I/O, number conversions, graphics and more
  • convenience abstractions for low level aspects such as ZeroPage handling, program startup, explicit memory addresses
  • inline assembly allows you to have full control when every cycle or byte matters
  • supports the sixteen 'virtual' 16-bit registers R0 - R15 from the Commander X16, and provides them also on the C64.
  • encode strings and characters into petscii or screencodes as desired (C64/Cx16)

Rapid edit-compile-run-debug cycle:

  • use a modern PC to do the work on, use nice editors and enjoy quick compilation times
  • can automatically run the program in the Vice emulator after succesful compilation
  • breakpoints, that let the Vice emulator drop into the monitor if execution hits them
  • source code labels automatically loaded in Vice emulator so it can show them in disassembly

Two supported compiler targets (contributions to improve these or to add support for other machines are welcome!):

  • "c64": Commodore-64 (6510 CPU = almost a 6502)
  • "cx16": CommanderX16 (65c02 CPU)
  • If you only use standard kernal and prog8 library routines, it is possible to compile the exact same program for both machines (just change the compiler target flag)!

Additional required tools

64tass - cross assembler. Install this on your shell path. A recent .exe version of this tool for Windows can be obtained from my clone of this project. For other platforms it is very easy to compile it yourself (make ; make install).

A Java runtime (jre or jdk), version 11 or newer is required to run a prepackaged version of the compiler. If you want to build it from source, you'll need a Java SDK + Kotlin 1.3.x SDK (or for instance, IntelliJ IDEA with the Kotlin plugin).

It's handy to have an emulator (or a real machine perhaps!) to run the programs on. The compiler assumes the presence of the Vice emulator for the C64 target, and the x16emu emulator for the CommanderX16 target.

Example code

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

%import textio
%zeropage basicsafe

main {

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

    sub start() {
        sys.memset(sieve, 256, false)   ; 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 C-64 you'll get:

c64 screen

One of the included examples (wizzine.p8) animates a bunch of sprite balloons and looks like this:

wizzine screen

Another example (cube3d-sprites.p8) draws the vertices of a rotating 3d cube:

cube3d screen

If you want to play a video game, a fully working Tetris clone is included in the examples:

tehtriz_screen

There are a couple of examples specially made for the CommanderX16 compiler target. For instance here's a well known space ship animated in 3D with hidden line removal, in the CommanderX16 emulator:

cobra3d