Main Page
Contents
* Overview
* Compiler features
* Other tools
* Supported Targets
* Host Systems
* Docs and Samples
* User Contributions
* Copyright
* Feedback
* Patch Acceptance Policy
* Download
* Mailing List
* Credits
Other pages:
* Frequently asked questions (last updated 02-Jan-2010)
* Known bugs (last updated 12-Jan-2009)
* News (last updated 09-Jul-2013)
* The cc65 wiki
* The cc65 search page
* User contributions
* Links

Overview

cc65 is a complete cross development package for 65(C)02 systems, including a powerful macro assembler, a C compiler, linker, librarian and several other tools. It is based on a C compiler that was originally adapted for the Atari 8bit computers by John R. Dunning. The original C compiler is a Small C descendant but has several extensions, and some of the limits of the original Small C compiler are gone. The original copyright allows free redistribution including sources, even if it would not qualify as Open Source Software according to the Open Source Definition.

The original Atari compiler is available from http://www.umich.edu/~archive/atari/8bit/Languages/Cc65/. The complete package consists of the compiler, an assembler, a librarian, a linker, and a C library for the Atari. There are some packages on the net that claim to be adapted as a crosscompiler for DOS or Unix, but was not able to get them working correctly.

Because I wanted a C compiler for my CBM machines, I took the Atari compiler and started a rewrite. Until today, I have rewritten large parts of the compiler, all of the library, completely replaced the assembler, the linker and the librarian, and added a frontend to simplify use. All changes have been done with portability in mind, so porting to new 6502 architectures should be quite easy.

Compiler Features

I'm working hard to make the compiler ISO C compatible, so you should be able to translate many sources from other systems. The following features are not available or do not work as described in the standard:

* The volatile qualifier is parsed but has no effect.
* The datatypes float and double are not available.
* Several C99 data types are not available: long long int, _Complex, _Bool and a few more. For most of these data types, this is a permanent limitation as I cannot see any sense in supporting 64-bit integers or complex numbers on a 6502 platform.
* C functions may not return structs and structs may not be passed as parameters by value. Struct assignment is possible. Assembler functions may return structs of size 1, 2 or 4.
* There are some limitation on the size of local variables. Not all operations are available if the size of local variables exceeds 256 bytes.
* Part of the C library is available only with fastcall calling conventions (see below). This means, that you may not mix pointers to those functions with pointers to user written functions.
* Some functions for wide characters (wchar_t) aren't available.

There may be other target system dependent limitations. One example is file I/O, which is not implemented on all platforms. This is no technical limitation (as with the stuff mentioned above) but does just mean that no one cared enough to write the actual code.

Depending on the mode the compiler is in (set with the --standard compiler switch), the following non standard features may be available:

* Single line comments that start with //.
* Unnamed parameters in parameter lists. The compiler will not issue warnings about unused parameters that don't have a name.
* Additional keywords that are needed for special features.
* Inline assembler commands.
* Flexible array members in structs.
* Unstructured data using the void keyword.
Other tools

The compiler is only one of the tools available in this package. The assembler suite (assembler, linker, archiver) is a complete development environment for itself, that may be used to write programs for any 6502 machine. C code and assembler code may be used together and may call each other.

The assembler is a one pass macroassembler and is able to output code for the 6502, the 65SC02 and 65SC816. It has a lot of nifty features like include files, conditional assembly, macros, nested lexical levels (that is, local symbols), and more. The assembler creates object files containing relocatable code. These files must be run through a linker to create the final program.

The linker has a flexible output format and is able to support ROMable code (different load and run addresses for data), banked systems (segments may share the same run address), systems with multiple ROMs, unlimited segments, more than one BSS segment and lots of other things.

The archiver is used to create libraries containing objects files. This simplifies code management. The linker will extract only those modules from a library that are actually needed.

To simplifiy use, there is also a frontend to the tools contained in the cc65 package. The frontend is named cl65. It knows how to build binaries from a list of C files, assembler files, object files and libraries. For smaller projects, just one invocation of the cl65 utility is needed to build a binary from several source files and libraries.

Target Systems

The runtime library and the standard C library have been designed with portability in mind. Changes for any 6502 system shouldn't be necessary. If you have a system not listed below, all you need is a new startup code.

Direct library support (that is, startup/initialization code) and support libraries for other features are available for...

* ...the Commodore C64
* ...the GEOS operating system for the Commodore C64
* ...the Commodore C128
* ...the Commodore C16, C116 and Plus/4
* ...the Commodore P500
* ...the Commodore 600/700 family of computers
* ...the Apple ][
* ...the Atari 8bit machines
* ...the Oric Atmos
* ...the Nintendo Entertainment System (NES)
* ...the Supervision Game Console
* ...the Atari Lynx Console

Especially the CBM 600/700 are very nice targets, since the programs created by cc65 run in a separate memory bank and have almost FULL 64K of memory available!

The apple2 port was done by by Kevin Ruland, <kevin at rodin. wustl. edu>.

Support for GEOS was added by Maciej Witkowiak, <ytm at friko. onet. pl>.

The port back to the Atari machines was contributed by

Christian Groessler, <chris at groessler. org>
Mark Keates, <mark. keates at dendrite. com>
Freddy Offenga, <taf_offenga at yahoo. com>
David Lloyd, <dmlloyd at atari-central. com>

The NES port was done by groepaz, <groepaz at gmx. net>.

The Supervision startup files and linker config were supplied by Peter Trauner, <peter. trauner at utanet. at>.

The Lynx port was done by Karri Kaksonen, <karri at sipo. fi>based on the original Lynx compiler by Bastian Schick. Bastians code was used with permission - thanks!

The assembler sources from the runtime and C library, and the C64 specific files are available online, converted to HTML and crosslinked by ca65html for more viewing pleasure.

Host Systems

With one exception in the compiler (access()) the code is plain ISO C, so it should compile on most systems. Memory usage may be a problem, however.

I'm providing full sources and binaries for the following systems:

* Linux: This is the primary development platform, so the sources should compile out of the box under Linux. Binary and source RPMs for RedHat Linux are available.
* DOS: The binaries are compiled with the Watcom compiler and use the DOS4G/W extender.
* OS/2: There are very few downloads for this version, so while it is still available, it may get removed soon.
* Windows NT and 95/98: Watcom compiled binaries.

Apart from that, I have reports that the sources compile on the following platforms without, or with only minor changes:

* FreeBSD (report from Tim Vanderhoek <hoek at FreeBSD. org>).
* DOS using DJGPP (report from Keith W. Gerdes, <kwg at netzero. net>, see compile.txt for some notes).
* Windows NT using VC++ (report from Bill Craig <craigw at gusun. georgetown. edu>).
* Windows 9x/NT/2000/XP using cygwin (report from groepaz <groepaz at gmx. net>).
* BeOS using gcc as C compiler (report from Arvid Norberg <c99ang at cs. umu. se>).
* Irix 6.5 using gcc (tested that myself, compiles out of the box).
* Solaris 2.6 using gcc 2.95.3, no changes needed according to B. Watson, <atari at hardcoders. org>.
* MiNT on the Atari 68K, compiles without changes (report from Daniel Pralle <dpralle at gmx. de>).
* Amiga OS using either StormC v4.0 or SAS/C 6.58. No changes to the source code are needed, however SAS/C outputs a few warnings that can be ignored (report from Leslie Ayling <layling at intercoast. com. au>).
* QNX (report from Greg King <gngking at erols. com>. No changes needed.
* Mac OS X 10.2 using the gcc version that comes with the system (report from Eric Shepherd <sheppy at syndicomm. com>). No changes needed.
* SuSE Linux 7.1 for PowerPC (report from Stefan Andree <sandree at physik. tu-berlin. de>). No changes needed.
* MorphOS using spawn-amiga (report from Stefan Haubenthal <polluks at web. de>).
Docs and Samples

About 600K of documentation in HTML and ASCII format is available, describing the compiler and the other tools.

Please note, that there is nothing in the documentation that will teach you C! If you have never programmed in C before, your first action should be to get a good book covering C. The documentation files cover invocation of the programs, special features and differences to the standard, some internal workings and a step-by-step intro.

The docs are included in the distribution packages and are available online. By popular request, the docs for the daily snapshot are now also available.

The distribution packages do contain some sample programs that may be used as a first starting point:

* ascii.c Shows the ASCII (or ATASCII, PETSCII) codes of typed characters. Written and contributed by Greg King.
* diodemo.c shows the use of the direct disc i/o API. It was contributed by Oliver Schmidt.
* fire.c is a graphics demo written by groepaz/hitmem. It does currently run on the C64, but should be portable to all machines with a VIC (C128 and P500).
* gunzip65.c is a demo of the zlib code that comes with cc65. It was written by Piotr Fusik.
* hello.c is a simple hello world style program using the conio library.
* mandelbrot.c is a mandelbrot demo using integer arithmetic. Written by groepaz/hitmem.
* mousedemo.c shows how to use the mouse routines on systems that support it.
* nachtm.c runs on machines with a SID only. It plays "Eine kleine Nachtmusik" by W. A. Mozart.
* overlaydemo.c shows how to create overlays using a custom linker config. Written and contributed by Oliver Schmidt.
* plasma.c is a graphics demo written by groepaz/hitmem. It will run on the C64, C128 and P500.
* sieve.c is an implementation of the popular sieve benchmark program.
* tgidemo.c shows some of the graphics capabilities of the "tiny graphics interface".

Code from the sample programs may be freely used in your own programs.

User Contributions

In addition to the sample programs, there are also some user contributed programs. If you're searching for examples of working code, you may want to give them a try.

Copyright

This is the original cc65 compiler copyright:

In acknowledgment of this copyright, I will place my own changes to the compiler under the same copyright.

The library and the binary utils are a complete rewrite done by me and covered by the following license:

Feedback

I'm very interested in feedback. If you have any questions, experiences or suggestions, send me a mail. You may also consider to subscribe to the cc65 mailing list (see below). Please note that I cannot answer C programming questions that are not specific to the cc65 C compiler implementation.

If you have problems, please have a look at the list of known bugs before mailing me.

Patch acceptance policy

User contributions for cc65, the libraries and binary tools are highly appreciated! Because I would like to keep the licensing terms as uniform and as free as possible, authors of contributions that are to be included in the source and binary distributions must agree that their contributions are donated to the cc65 project under the terms of the following license (this is a copy of the above, and a copy of the zlib license):

When submitting material that is to be included into cc65, please state that you agree with this license.

Download

There are several versions available for download. When downloading binary packages, you need:

  1. One binary package with the compiler and tools for your hosting operating system (for example: cc65-win32-5.6.7.zip).
  2. One or more library packages for the target platforms. Example: cc65-c64-5.6.7.zip.

If you download zip files, be sure to unpack them in the same directory.

If you're interested in the latest version, you have two choices:

  1. You can either have a look at the snapshot directory. It contains the latest sources from the SVN repository, nightly RPM builds for RedHat Linux, and binary packages for DOS, Windows and OS/2.
  2. Or you can access the subversion source repository using your favourite subversion client. The access URL is svn://svn.cc65.org/cc65/. The development branch is located in the trunk/ subdirectory, the stable versions are located below branches/. To checkout the current development version into a directory named "cc65" using the command line client, one would issue
        	svn checkout svn://svn.cc65.org/cc65/trunk cc65
        
    To prevent people from erroneously checking out the complete archive, which would generate a lot of (probably useless) traffic, older stable versions aren't available to the general public.
Beware: Both methods supply a copy of the sources from the SVN repository, these sources may not even compile! My development platform is Linux. If you're in real need of a working new version, your best chances are using Linux, too.

Several people have setup mirrors of the ftp directory, thanks a lot!

Please note that some files may not be available from the mirrors.

There are also sites offering packages for other host systems:

Mailing List

There is a mailing list for discussion of cc65 related problems, ports, and announcements. To subscribe to the list, send a mail to majordomo@musoftware.de with the text

subscribe cc65

in the body of the mail. Please do not use MIME encoding, HTML or other stuff, since this will confuse majordomo (which is only a perl script parsing your mail).

Note: Because of massive SPAM attacks, the IP ranges of several ISPs and countries are blacklisted at the musoftware mail server. Countries/regions included are: China, Hong Kong and Korea, South America Nigeria, the Philipines and a growing number of others. ISPs blocked are: rackspace.com. In addition to that, connections from hosts without a valid reverse DNS may be refused. If you live in one of these regions or prefer to have a SPAM friendly or incompetent ISP, you will not be able to participate in the mailing list or send me any mail. I'm sorry, but I see nothing that I can currently do about it. If the extreme volume of SPAM from these origins decreases, I'm willing to reconsider my decision.

There is also a mailing list archive available for online browsing. You can search the archive using Google.

Credits

Many people have helped to make cc65 what it is today, and there are times when I receive bug reports, suggestions and even contributed code almost daily. A big "Thank you!" to you all!

Unfortunately, any list on this page would be outdated at the time you read it. I'm trying hard to keep the CREDITS file, that comes with the distribution up to date. You may want to have a look at the current version.


Valid HTML 4.01! Valid CSS! oldindex.php; last change: 09-Jul-2013
Impressum