git @ Cat's Eye Technologies SixtyPical / 0.11

Tree @0.11 (Download .tar.gz) @0.11view markup · raw · history · blame

History of SixtyPical


  • Each table has a specified size now (although, bounds checking is not performed.)
  • Initialized byte table values need not have all 256 bytes initialized.
  • Syntax for types has changed. routine (with constraints) is a type, while vector is now a type constructor (taking routines only) and table is also a type constructor. This permits a new vector table type.
  • Added typedef, allowing the user to define type aliases for readability.
  • Added define name routine {...} syntax; routine name {...} is now legacy.
  • Ability to copy vectors and routines into vector tables, and vectors out of same.
  • Removed the evaluator. The reference implementation only analyzes and compiles.
  • Fixed bug where index register wasn't required to be initialized before table access.
  • Fixed bug where trampolines for indirect calls weren't including a final RTS.


  • Can call and goto routines that are defined further down in the source code.
  • The forward modifier can also be used to indicate that the symbol being copied in a copy to a vector is a routine that is defined further down in the source.
  • Initialized word memory locations.
  • Can copy a literal word to a word table.
  • Subtract word (constant or memory location) from word memory location.
  • trash instruction explicitly indicates a value is no longer considered meaningful.
  • copy []+y, a can indirectly read a byte value into the a register.
  • Initialized byte table memory locations.
  • Fixed bug which was preventing if branches to diverge in what they initialized, if it was already initialized when going into the if.
  • Fixed a bug which was making it crash when trying to analyze repeat forever loops.


  • Add word (constant or memory location) to word memory location.
  • Add word to pointer (unchecked for now).
  • Added word table type.
  • Can copy from word storage location to word table and back.
  • A vector can name itself in its inputs and outputs or trashes sets.
  • Implementation: --debug shows some extra info during analysis.
  • Fixed bug where copying literal word into word storage used wrong endianness.
  • Fixed bug where every memory location was allocated 2 bytes of storage, regardless of type.
  • Tests: use to disassemble code for comparison.


  • Explicit word literals prefixed with word token.
  • Can copy literals into user-defined destinations.
  • Fixed bug where loop variable wasn't being checked at end of repeat loop.
  • buffer and pointer types.
  • copy ^ syntax to load the addr of a buffer into a pointer.
  • copy []+y syntax to read and write values to and from memory through a pointer.


  • User-defined byte locations can be given an initial value.
  • word type locations which can be defined and copyed between.
  • Can copy directly from one user-defined byte location to another.


  • Added routine and vector types, and copy instruction.
  • Both routines and vectors can declare inputs, outputs, and trashes, and these must be compatible to assign a routine or vector to a vector.
  • Added goto (tail call) instruction, jumps to routine or through vector.
  • call can call a subroutine indirectly, via a vector.
  • Routine name is now shown in analysis error messages.


  • Added byte table type locations and indexed addressing (+ x, + y).
  • Integer literals may be given in hexadecimal.
  • Line comments may be included in source code by prefixing them with //.


  • Added repeat loops to the language, which can repeat until a flag is set (or not set), or which can repeat forever.
  • if not inverts the sense of the test.
  • Added explicitly-addressed memory locations.


  • Added external routine declarations.
  • Added ability to compile to 6502 machine code and output a PRG file.


A complete reboot of SixtyPical 0.1. The reference implementation was rewritten in Python. The language was much simplified. The aim was to get the analysis completely right before adding more sophisticated and useful features in future versions.


Initial inspired-but-messy version implemented in Haskell.