	Documentation Latest release ZapRedraw Contact Download

This website is no longer maintained. Source is now available on Github.

Zap CVS Tree

Zap's source tree is maintained under CVS, a version/revision control system which lets multiple developers work on one source tree fairly easily. Access to the CVS tree is available through two methods: firstly, via a web gateway which lets you browse the tree, and secondly through CVS pserver. Write access is only available to main Zap developers at present; if you want to contribute material, send it to one of us (if you start sending lots of useful stuff you'll be a main developer by default, and we'll give you write access).

The files in the CVS tree are stored using Acorn's method for storing filetypes under NFS, namely as <filename>,<filetype> where the filetype is a three digit hex number with lower case letters. The RISC OS CVS port will handle this translation automatically, as will RISC OS NFS clients (allowing the files to reside on a UNIX machine).

pserver

People with the ability to run CVS can access the Zap tree through CVS's remote access system, called 'pserver'. The details are:

host: cvs.tartarus.org
user: cvsuser
CVS path: /home/cvs
password: anonymous
Entire CVS root (suitable for passing to cvs's -d option): :pserver:[email protected]:/home/cvs

Quick guide to using CVS and pserver:

cvs -d :pserver:[email protected]:/home/cvs login

Prompts you for the password (anonymous). You only need to do this once on most systems, because CVS will remember your password.

cvs -z6 -d :pserver:[email protected]:/home/cvs checkout zap

Checks out a complete copy of Zap. From then on, within the directory structure that it creates, you don't need to specify the -d option - it will remember the CVS root you are using. Note that the entire tree is quite big - it includes various extensions as well as Zap itself. If you just want part of it, a list of modules is available below.

Note that this will always give you the unstable (development) release of Zap.

cvs -z6 -d :pserver:[email protected]:/home/cvs checkout -r TAG zap/!ZapSource

As above, but checks out a copy of Zap with tag TAG. See below for more information - a tag will be created for each stable release, for bugfixes.

cvs -z6 update

Brings your copy of the source in line with the latest version on the server. This will use whatever tag you specified when checking out the source.

Modules

The HEAD (what you get when you check out without a tag) is the development version. This hasn't always been the case, so there is some muddling in some modules (particularly the Zap core source).

There are a whole bunch of other useful modules, as well. In general, individual parts of Zap will live within sources, dists or docs, depending on their purpose. Anything else at the top level of the Zap module is probably not used to build the distribution - individual maintainers' notes on progress, and so on.

zap/sources/!ZapSource: The main Zap source code.
zap/sources/!ZapRedraw: ZapRedraw source.
zap/sources/modes/!ZapBASIC: ZapBASIC source code.
zap/sources/extensions/!ZapExtSrc: Zap command extensions source code.
zap/sources/extensions/!ZapConfig: ZapConfig source code. (Currently not up to date with Zap.)
zap/docs: Zap's documentation.
zap/sja-notes: James Aylett's notes on current progress / future ideas. This includes the known bug and wish lists

Building Zap

Makefiles are provided to build Zap using either amu/objasm/link or make/AS/drlink under RISC OS. In addition, tools for building the main Zap code under Unix (using make/AS under unix/drlink under unix) are available.

Building using Acorn tools

There are two ways of building Zap using the Acorn tools. The first is more automated, but the second is the prefered system. You will need objasm v3.06, link v5.06 and amu v5.02 (earlier versions may work as well).

Double click on !Zap.!Makefile. This runs two separate Makefiles to build Zap.
From a taskwindow, while in the !Zap directory, run amu. This will build Zap with the standard build name (to get another build name, use amu BUILD=foo or amu BUILD=foo-42).

The amu Makefile actually has a number of different targets. The following are available:
- amu Zap - build Zap itself
- amu ZapHdrs - rebuild Zap's headers; you'll probably need to do this the first time you get the source. You'll also need to do this if the inter-file exports change; basically, if things aren't building right, try running this.
- amu clean - clean out all temporary files (but not the generated header files)
- amu rebuild - wipe o.ModuleBits and rebuild (ensures the the build name is correct)
- amu Revision - stamps h.Version (to make sure that a version number change ensures a consistent rebuild)

Building using free RISC OS tools

Again, there are two ways of building Zap using the free RISC OS tools. You will need AS v1.30, drlink v0.30 and make v1.02 (earlier versions of AS almost certainly won't work; get the latest version from Darren's website). The others are available from UK Mirror's HENSA archive.

Double click on !Zap.!MakeAS. This doesn't always work, and the second method is better anyway.
From a taskwindow, while in the !Zap directory, run make -r -f MakefileAS. This will build Zap with the standard build name (to get another build name, use make -r -f MakefileAS BUILD=foo or make -r -f MakefileAS BUILD=foo-42).

The AS Makefile actually has a number of different targets. The following are available:
- make -r -f MakefileAS Zap - build Zap itself
- make -r -f MakefileAS ZapHdrs - rebuild Zap's headers; you'll probably need to do this the first time you get the source. You'll also need to do this if the inter-file exports change; basically, if things aren't building right, try running this.
- make -r -f MakefileAS clean - clean out all temporary files (but not the generated header files)
- make -r -f rebuild - wipe o.ModuleBits and rebuild (ensures the the build name is correct)
- make -r -f MakefileAS Revision - stamps h.Version (to make sure that a version number change ensures a consistent rebuild)

Building under Unix

There is only one method for building under Unix. You will need AS v1.30, built for your Unix, available in your path as as_ro, drlink v0.3.4, built for your Unix, available in your path as link_ro, perl v5, sed v2.05 and make v3.76.1. Perl is available from www.perl.com; sed and make are available from The FSF (though try the sources for your districution first). as_ro can be built from the source, or we can supply it pre-built for ELF i386 linux; link_ro can probably be supplied pre-built for ELF i386 linux on request, but we do not have permission to distribute the source code. (Alternatively, if you have access to ARM's development kit, you can hack data/unix/Makefile to use that instead; you'll need to change the asm, link, asmflags and linkflags variables in the makefile, near the bottom of the [System] section.)

The command to run, from within the !Zap directory, is make -f data/unix/Makefile. This gives the default build name; you can use make -f data/unix/Makefile BUILD=foo and make -f data/unix/Makefile BUILD=foo-42 as above.