high level programming language and compiler targeting 6502 machines such as the C-64 and CommanderX16
Go to file
2020-08-29 23:55:26 +02:00
.idea optimize callgraph 2020-03-10 21:47:15 +01:00
compiler got floating points working in commanderx16 2020-08-29 23:55:26 +02:00
docs cleanup cx16 things and added call signatures. c64graphics moved into built-in libraries. 2020-08-28 21:42:53 +02:00
examples got floating points working in commanderx16 2020-08-29 23:55:26 +02:00
gradle/wrapper gradle version 2020-08-18 00:47:23 +02:00
parser identifiers can no longer start with an underscore. (this interfered with 64tass syntax) 2020-08-22 17:03:40 +02:00
scripts removed fake vm functions 2019-08-21 22:00:05 +02:00
.gitignore don't include the generated parser java files in git 2020-03-20 22:53:56 +01:00
.travis.yml gradle version 2020-08-18 00:53:14 +02:00
gradle.properties removed bogus clang target 2020-02-07 01:22:07 +01:00
gradlew gradle version 2020-08-18 00:47:23 +02:00
gradlew.bat gradle version 2020-08-18 00:47:23 +02:00
LICENSE rethinking some aspects and rewriting text a bit 2018-07-01 23:24:32 +02:00
README.md readme and version 2020-08-27 18:18:29 +02:00
settings.gradle removed sim65 because it was moved to a separate repository 2019-09-11 02:24:44 +02:00

saythanks Build Status Documentation

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

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

Software license: GNU GPL 3.0, see file LICENSE

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):

  • reduction of source code length
  • modularity, symbol scoping, subroutines
  • various data types other than just bytes (16-bit words, floats, strings)
  • automatic variable allocations, automatic string and array variables and string sharing
  • subroutines with an input- and output parameter signature
  • constant folding in expressions
  • conditional branches
  • 'when' statement to provide a concise jump table alternative to if/elseif chains
  • structs to group together sets of variables and manipulate them at once
  • floating point operations (requires the C64 Basic ROM routines for this)
  • abstracting away low level aspects such as ZeroPage handling, program startup, explicit memory addresses
  • various code optimizations (code structure, logical and numerical expressions, unused code removal...)
  • inline assembly allows you to have full control when every cycle or byte matters
  • many built-in functions such as sin, cos, rnd, abs, min, max, sqrt, msb, rol, ror, swap, memset, memcopy, sort and reverse

Rapid edit-compile-run-debug cycle:

  • use a modern PC to do the work on
  • very 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

Prog8 is mainly targeted at the Commodore-64 machine. Preliminary support for the CommanderX16 is available as a second compilation target. Contributions to improve these or to add support for other machines are welcome!

Documentation/manual

https://prog8.readthedocs.io/

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 8 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 c64textio
%zeropage basicsafe

main {

    ubyte[256] sieve
    ubyte candidate_prime = 2

    sub start() {
        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++
        }
        c64.CHROUT('\n')
        txt.print("number of primes (expected 54): ")
        txt.print_ub(amount)
        c64.CHROUT('\n')
    }

    sub find_next_prime() -> ubyte {
        while sieve[candidate_prime] {
            candidate_prime++
            if candidate_prime==0
                return 0        ; we wrapped; no more primes available
        }
        ; 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