Let's allow a variation of styles but be consistent within a given source
file.

== function declarations:

static object *
contains(object obj)
{
    if (!obj) {
         obj = this_object();
    }
    return all_inventory(obj);
}

I like to see the return type of the function on its own line but I'm
optional on that as long as you are consistent within a given source file.

However, please don't put the opening curly brace on the same line as the
parameter list of the function.

== if, while, for

let's allow either of two styles:

if (condition) {
    /* statements */
}

or:

if (condition)
{
    /* statements */
}

I think it's a good idea to use { and } even on if's that only have
a single statement in the body.  The reason why is that it prevents
confusion as to what should be in the body of the if.  And it makes
it easy to add additional lines to the if in the future.

Let's be consistent within a single source module (no mixing of
styles).

Everyone seems to have their own idea on how to internally space
control constructs vs. function calls.  I see all of these styles:

x = all_inventory(this_object()));
if (sizeof(x) != 0) {
}

x = all_inventory (this_object());
if(sizeof(x) != 0){
}

I like the style of the first two constructs.  All I ask is that you be
consistent within a source file.

Indention is important.  There are many ways to indent and everyone
has his/her own ideas on what is the right way (tm) to do it.  With this
in mind, I'm open to any of the following indention styles as long as
the style is consistent throughout the file.

1) 4-space indention using only the space character to indent

2) 4-space indention using only the tab character to indent (set tabstops
to four spaces using :set ts=4 in vi or create an .exrc file containing
set ts=4).  I (John) like this one the best.

3) 4-space indention using the tab character (eight space tabs) to do
indentions as much as possible and using four spaces (using space key) for
the remainders of indentions that aren't multiples of eight spaces.  James 
likes this one the best.

The one rule is to use four space indention.

In program statements that take more than one line, please being continuation
lines with an operator if posible.  E.g. if doing a write statement:

use:

write("blah blah"
	+ " and more blah blah\n");

rather than:

write("blah blah" +
	" and more blah blah\n");

