Skip to content

Latest commit

 

History

History
115 lines (76 loc) · 6.75 KB

README.md

File metadata and controls

115 lines (76 loc) · 6.75 KB

Commodore Commander The Commodore 64, an iconic 8-bit home computer from the 1980s, has experienced a vibrant renaissance in the retro computing world. Renowned for its affordability, robust hardware, and expansive software library, the C64 continues to captivate enthusiasts worldwide. Modern resources such as FPGA-based replicas, enhanced peripherals, and thriving online communities have made it easier than ever to explore and develop for this classic machine. Essential tools like cross-assemblers, emulators like VICE, and comprehensive documentation for its 6502 architecture have become indispensable for both newcomers and seasoned developers.

Programming for the Commodore 64 is an enjoyable experience, thanks to its simplicity, constraints, and direct interaction with hardware. The 6502 assembly language offers a rewarding challenge that inspires creativity, while the well-documented architecture and active retro community make problem-solving an engaging process. Whether pushing graphical limits, composing SID chip music, or crafting efficient code within tight memory constraints, developing for the C64 is a nostalgic journey that combines technical mastery with pure joy.

The Commodore Commander aims to be a valuable addition to this ecosystem of tools.

Installing

This project provides a set of features for the Eclipse IDE that can be built and added into an existing Eclipse installation. It also comes with product builds which are standalone applications. However these require that Java 21 is installed and in the system PATH.

Currently only macOS builds are downloadable from the project site. These are not notarized and must be taken out quarantine in order to work. Execute xattr -d com.apple.quarantine ~/Downloads/Commodore\ Commander.app after downloading and unpacking the archive.

Features

Editing

  • Editor with 6502 opcode syntax coloring
  • As with most Eclipse based editors:
    • "Quick diff" and revision information
    • Task and bookmarks
    • Search and navigation
    • Block selection
    • TODO and FIXME markers
    • Bookmarks, and much more
  • Tooltips for 6510 mnemonics
  • Tooltips for the Commodore 64 memory map

Compiling

Compilation is done automatically with the built-in Kick Assembler compiler whenever a source file has been changed.

  • Problem markers when a compilation produces errors.
  • Compilation output to the Commodore Commander console view.

Running

  • Launches the VICE emulator when double clicking a *.prg file.
  • Launches will automatically pick up VICE configuration files found either in the same folder as the program, or in any of it's parent folders.

Debugging

The debugger implements a VICE Binary Monitor interface and is currently fairly basic. It currently supports the following features:

  • Built in VICE emulator
    • macOS GTK version on aarch64 and x86
    • Windows GTK x86 version (planned)
    • Linux GTK x86 version (planned)
  • Support for Eclipse run and debug launch shortcuts.
  • Debug launches pick up *.vs files created by Kick Assembler and passes these to VICE.
  • Support for step over, step into, step return, suspend, resume and terminate

Breakpoints

The only type of checkpoints currently supported are breakpoints. These are triggered whenever the program counter enteres an address where a breakpoint has been added and will halt the emulator. Breakpoints can be individually disabled and enabled, and as usual be grouped, placed in working sets etc.

Variables

When building your application, the IDE will automatically detect sections of code that are labelled and that contains data. For example:

ClearTable:
    .byte %11111110
    .byte %11111101
    .byte %11111011

The parser will also determine which format was used to declare the values and this information is used when presenting the value in the IDE.

The Variables view is updated whenever the CPU is suspended. Values that are shown using the diamond icon are editable. Simply click on the value cell and specify a new value. Make sure the value is within the range of the data type. A byte value is for example between 0 and 255.

Memory monitor

The memory monitor is used to observe and edit the main computer memory.

Using the New Memory View command you can create a view that is able to display one single area of memory at the time (Add Memory Monitor ). This will bring up a prompt where you can specify the from and optionally to-address in either hexadecimal (prefix with 0x or $). Use - to specify a range, and , to create multiple monitors.

Each monitor can be presented using different renderings. Each rendering is a visualization of the memory area and may or may not be editable. The table renderings are typically editable, while the screen rendering shown below is not.

Note that monitors are only updated when the CPU has stopped because of i.e. a breakpoint and any changes to the memory will only take effect when the CPU has resumed operation.

By selecting Custom Character set and specifying it's location one can see the memory monitor rendered using this character set.

Related resources

These resources are only some of those consulted when building this IDE. You may find them useful: