GlitterIDE

C64 Notes

The current version of GlitterIDE includes a proof-of-concept environment for creating software for the Commodore 64 computer (C64). It is meant to be a foundation for targeting vintage computers and microcontrollers with the same sort of framework as is used for base GlitterIDE apps, but with machine code generation as the target (and on more constrained machiens). The C64 environment is planned to get considerable attention to allow the creation of reasonably advanced games and applications (with a built-in sprite and character graphic editors).

In the meantime, it is realatively simple, but the core language features are there. This includes:

• The implied co-operative multitasking, though all threads are "full speed" by default
• Blocks can be defined and called
• Messages can be defined and broadcast
• Variables can be declared and used
• Normal control features area available (if, while, repeat, forever,....)

The GlitterIDE compiles C64 projects directly to machine code, and will run them with the built-in emulator. Export options allow the code to be exported as "PRG" files, and to be run by external applications (such as Vice64).

Much is missing though, with very few built-in functions, and there is only a "stage".

Variable Types

The C64 environment requires full typing for now (that is, "any" is not accepted). Types must be quite specific, and currently only three types are supported. They are:

• ushort An unsigned 16-bit value. That is, a positive number from 0 to 65535
• ubyte An unsigned 8-bit value. That is, a positive number from 0 to 255
• boolean A value that is either true or false

Event Types

Only "flag" and message events are available. The "flag" event is the start of the app event (there is no actual flag with the C64 environment).

Available Functions

Only a few functions are available in the C64 environment. They are as follows:

Basics

Code in guava/Glitter is written similar to Java/C. In particular:

• poke(address,value) Set a byte in memory at location "address" to the value "value"
• print(value1, ... , valueN) Print the function values to the screen
• peek(address) Read the memory location at "address" and return the byte value (can be stored in a variable or used as an argument)
• joyLeft() Returns true if the joystick in port 2 is pressed left (mapped to cursor keys in the built-in emulator)
• joyRight() Returns true if the joystick in port 2 is pressed right
• joyUp() Returns true if the joystick in port 2 is pressed up
• joyDown() Returns true if the joystick in port 2 is pressed down
• joyFire() Returns true if the joystick in port 2 has fire button pressed (mapped to "ctrl" in the built-in emulator - I think)

Operators

Most basic operators function, such as comparisons, and basic math of "+", "-", "*", but not division yet. Boolean operators work, as well as bitwise boolean operators ("&", "|", "^").

Example

		ubyte startBorder = 0;
		block printHello(ubyte count) {
			repeat(count) {
					poke(53280, peek(53280)+1);
					print("Hello world");
					yield; //This pauses thread until next screen update
			}
		}
		flag {
			startBorder = peek(53280);
			printHello(10);
			poke(53280, startBorder);
		}
	

Future Plans

The immediate plans are to include a Sprite editor for C64 sprites (single colour at least), and character/screen editors, and to add support for using the built-in ROM routines for more functionality (for example, floating point math). It is hoped that the underlying assembler code can be exposed, to allow third-parties to extend the functionality. The language extensions to local variables will include the C64 environment (it's already set up for it).