prog8/README.md

115 lines
4.2 KiB
Markdown
Raw Normal View History

2018-09-15 14:21:05 +00:00
Prog8 - Structured Programming Language for 8-bit 6502/6510 microprocessors
===========================================================================
2017-12-21 13:52:30 +00:00
2018-01-09 23:44:11 +00:00
*Written by Irmen de Jong (irmen@razorvine.net)*
2017-12-21 13:52:30 +00:00
2018-01-08 02:31:23 +00:00
*Software license: GNU GPL 3.0, see file LICENSE*
2017-12-25 15:00:25 +00:00
2018-09-15 14:21:05 +00:00
This is a structured programming language for the 8-bit 6502/6510 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,
2017-12-25 15:00:25 +00:00
which aims to provide many conveniences over raw assembly code (even when using a macro assembler):
- reduction of source code length
- easier program understanding (because it's higher level, and more terse)
2017-12-27 22:45:22 +00:00
- option to automatically run the compiled program in the Vice emulator
2017-12-25 15:00:25 +00:00
- modularity, symbol scoping, subroutines
- subroutines have enforced input- and output parameter definitions
2017-12-29 01:18:50 +00:00
- various data types other than just bytes (16-bit words, floats, strings, 16-bit register pairs)
2017-12-29 00:16:39 +00:00
- automatic variable allocations, automatic string variables and string sharing
2018-01-09 23:44:11 +00:00
- constant folding in expressions (compile-time evaluation)
2017-12-25 15:00:25 +00:00
- automatic type conversions
- floating point operations
- abstracting away low level aspects such as ZeroPage handling, program startup, explicit memory addresses
2017-12-27 22:45:22 +00:00
- 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
- conditional gotos
2018-01-29 20:10:06 +00:00
- various code optimizations (code structure, logical and numerical expressions, ...)
2017-12-25 15:00:25 +00:00
2019-01-26 17:41:25 +00:00
It is mainly targeted at the Commodore-64 machine at this time.
2017-12-25 15:00:25 +00:00
2019-01-26 17:56:53 +00:00
Documentation is online at https://prog8.readthedocs.io/
2019-01-26 17:41:25 +00:00
Required tools:
---------------
2017-12-25 15:00:25 +00:00
2019-01-26 17:59:14 +00:00
[64tass](https://sourceforge.net/projects/tass64/) - cross assembler. Install this on your shell path.
A recent .exe version of this tool for Windows can be obtained from my [clone](https://github.com/irmen/64tass/releases) of this project.
2019-01-26 17:41:25 +00:00
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 the packaged compiler.
If you want to build it from source, you'll need a Kotlin 1.3 SDK as well (or for instance,
IntelliJ IDEA with the Kotlin plugin).
It's handy to have a C-64 emulator or a real C-64 to run the programs on. The compiler assumes the presence
2019-01-26 17:59:14 +00:00
of the [Vice emulator](http://vice-emu.sourceforge.net/)
2019-01-26 17:41:25 +00:00
Example code
------------
When this code is compiled::
%import c64lib
%import c64utils
%import c64flt
~ main {
sub start() {
; set text color and activate lowercase charset
c64.COLOR = 13
c64.VMCSB |= 2
; use optimized routine to write text
c64scr.print("Hello!\n")
; use iteration to write text
str question = "How are you?\n"
for ubyte char in question
c64.CHROUT(char)
; use indexed loop to write characters
str bye = "Goodbye!\n"
for ubyte c in 0 to len(bye)
c64.CHROUT(bye[c])
2019-01-26 17:45:17 +00:00
float clock_seconds = ((mkword(c64.TIME_LO, c64.TIME_MID) as float)
+ (c64.TIME_HI as float)*65536.0)
/ 60
2019-01-26 17:41:25 +00:00
float hours = floor(clock_seconds / 3600)
clock_seconds -= hours*3600
float minutes = floor(clock_seconds / 60)
clock_seconds = floor(clock_seconds - minutes * 60.0)
c64scr.print("system time in ti$ is ")
c64flt.print_f(hours)
c64.CHROUT(':')
c64flt.print_f(minutes)
c64.CHROUT(':')
c64flt.print_f(clock_seconds)
c64.CHROUT('\n')
}
}
2019-01-26 17:45:17 +00:00
2019-01-26 17:41:25 +00:00
you get a program that outputs this when loaded on a C-64:
![c64 screen](docs/source/_static/hello_screen.png)
2019-01-26 18:13:42 +00:00
One of the included examples (wizzine.p8) animates a bunch of sprite balloons and looks like this:
![wizzine screen](docs/source/_static/wizzine.png)
Another example (cube3d-sprites.p8) draws the vertices of a rotating 3d cube:
![cube3d screen](docs/source/_static/cube3d.png)
2019-03-10 04:38:14 +00:00
If you want to play a video game, a fully working Tetris clone is included in the examples:
![tehtriz_screen](docs/source/_static/tehtriz.png)