



Power C for the Commodore 64 (last updated 2017-06-08)

This page is about the Power C compiler for the Commodore 64. It's one of the best high-level languages available for this machine, with an excellent editor, a compiler, and a linker. Although its dialect is K & R (pre-ANSI) C, it's very capable. An assembler is also available, making it even more useful for large projects (see the links to Transactor articles on linking C and assembly). Further down the page, you'll find a collection of add-on utilities I downloaded from Q-Link back in the day. If you have any questions, you can mail me email me (cenbe at kolabnow dot com).

The Power C Compiler (D64 images)

Power C Tips 'n' Tricks

Power C and Assembly Language

Power C Downloads





Here are D64 images of the Power C diskettes as distributed. There's also a complete copy of the documentation.

side one (editor, compiler, linker, headers, object files)

side two (libraries, more object files)

manual (from DLH)



back to top

Here are some helpful things I've found while using Power C:

Remember to use old-style function declarations ; you will get hard-to-find errors otherwise. Modern function declaration: int foo (int bar) { // clever code here } K & R (old-style) function declaration (use for Power C) : int foo (bar) int bar; { // clever code here }

Be careful not to use the same field names in different structures; Power C will confuse them . I recommend using a prefix for each structure field, like this: struct extMenu { int emRecno; char emFlags; int emFirst; }

In Power C, you can declare a function with no return value (instead of a void return value). However, if you need to reference the address of such a function later, the compiler won't let you. This won't work: dispatch() { /* some code here */ } widget->wAction = &dispatch; But it will if you just change the function declaration to return int .

But it will if you just change the function declaration to return . The editor's multiple buffer support can be very useful. If you're working on a large source file and want to print just part of it for study, select the region, then delete it and paste it right back again. Then open another buffer (e.g. hit STOP and enter "go print"), paste the region into it, and print it by hitting STOP and entering "pr".

There appears to be a bug in the compiler: on rare occasions it will just hang during a compile and the machine will have to be restarted; the result will be a couple of splat files with names like XXXTEMP. Make sure you validate the drive your source is on if this happens!

Another rarely-seen bug in the compiler is that he sometimes shows a lower-case 'g' on a line by itself at the end of the source when the compile completes, with an "illegal character" message. Ignore it and compile again.

The trim utility mentioned in the documentation sounds like a great idea, and I've seen it reduce the size of object files by 25% or more... but I've also found strange bugs that could reliably be fixed by recompiling modules without trim ming them. My advice is not to use it; find other ways to optimize your code (like writing some of the program in assembler using C-ASSM).



back to top



For some excellent detail on coding Power C functions in assembler, see the following Transactor articles: The Link Between C and Assembly (volume 8, issue 5) C And Assembly: Clarifying the Link (volume 9, issue 2) For the impatient, here's the recipe for a Power C function in assembler (C-ASSM format) that takes and returns an int: .ref c$funct_init ;linker will resolve .def funcname ;tell linker our name parmndx = $4b data = $4c c$parms = $033c funcname jsr c$funct_init stx parmndx ;index to parameters lda c$parms,x ;function parameters sta data lda c$parms+1,x sta data+1 ;do something interesting with the int... ldx parmndx lda data sta c$parms,x ;return the int lda data+1 sta c$parms+1,x rts You can use the temporary storage areas from $22 - $2a and $4b - $60 in your function.

You can use the temporary storage areas from $22 - $2a and $4b - $60 in your function. C-ASSM's expression syntax is unusual compared to that of other Commodore assemblers. For example, say you have a routine to check for numeric characters, and you want to compare to '0' and then to "the character after 9". The code would be: cmp #'0 bcc notnum cmp #['9+1] bcs notnum ...

You may be tempted to name assembler modules starting with an underscore... don't . You'll find later on that you can't put them into a library using the lib utility! Symbols starting with underscores (e.g. alternate entry points for functions that can be called from either C or assembler) are OK, though: lib doesn't show them when you display the contents of a library, but trust me, they're there.

Have you wanted to rewrite some of your C code in assembler only to end up saying to yourself "but I'll need to call malloc() "? Well, you can. Just bypass the call to c$funct_init by calling 16 bytes into malloc 's object code, like this: .ref c$funct_init ;linker will resolve .ref malloc parmndx = $4b jsr c$funct_init stx parmndx ;index to parameters ;put amount of memory to allocate in memsize before calling lda memsize sta $4c lda memsize+1 sta $4d jsr malloc+16 ldx parmndx lda c$parms,x ora c$parms+1,x beq error ;oops, malloc() returned 0 ;now you can use the memory pointer at c$parms,x memsize .bss 2 You can also call free() from assembler, by JSR ing to free+3 . Just bear in mind that both routines use the temporary storage area, so you may need to save your local variables before the call and restore them again afterward. parmndx ($4b), however, is not disturbed when calling them in this way. (Hint: there's a reverse assembler in the download section below.) And if you really want to go overboard, you could always roll your own malloc (assembler source, C test program). But of course, no one would do such an insane thing.



back to top

This is a collection of add-ons for Power C. I used to have them in ARC format, just as I downloaded them from Q-Link in the olden times, but D64 images are much easier to work with. In a few cases, I had hard copies of the original Q-Link download descriptions, and typed them in by hand.

C-Windows by Rubens Abboud (windowing utility that does a custom character set 40 in 64, or 80 columns):

C-ASSM by Mark Rinfret and David Zarling, an assembler (written in C) that creates Power C compatible object files:

Power C utilities

These were sent to me in early 2013 by a visitor to the site from Italy, Pasquale Frega. Grazie mille!

This D64 image contains:

CREF , a cross-reference utility. Originally written in 1982 by Jeff Taylor for UNIX 4.2 BSD, it was ported to Power C in 1989 by Ben Pedersen.

, a cross-reference utility. Originally written in 1982 by Jeff Taylor for UNIX 4.2 BSD, it was ported to Power C in 1989 by Ben Pedersen. sysaxyc , a replacement for Power C's sys() function which allows the caller to set and read the carry flag as well as the A, X, and Y registers.

GRAFPAK (graphics library by Marc Rinfret/Rich Helms):

(also contributed by Pasquale)

D64 image (source, docs, and a demo program)

C-Power Graphics Library (by David Kesler and David Brown):

This library is based on Mark Rinfret's GRAFPAK (see above).

D64 image (source, object files, docs, and demo code)

Cmaster (a terminal with Xmodem written by W Mat Waites):

Cmaster was written using serial routines originally published in the Transactor (February 1989, Volume 9, Issue 3).

Here's the original article, "Serial I/O in Power C."

(Note that the date and issue number are misprinted in the page footers.)

D64 image (source, docs, and executable)

Utilities and replacements for Power C by Adrian Pepper:

This D64 image (source and docs) includes:

exec , a "batch file" or scripting utility for the Power C shell

original Q-Link download description

, a "batch file" or scripting utility for the Power C shell original Q-Link download description newshell , a replacement shell (with "exec" scripts)

original Q-Link download description



back to top

and now for something completely different...

Here's something a little more obscure... it's some code I hacked together with help from the guys on the comp.sys.cbm mailing list. It's a machine language routine, meant to be called from a Power C program, that loads and runs a BASIC program.

assembler source (ASCII, Unix-formatted)