V6 C (at least, the version on the V6 dist, there are a lot of later
bootlegs) doesn't support a lot of things. It also has a number of
syntax differences. Here's a list (to date):


Syntax:


- Initializers; no "=": "int foo 1", not "int foo = 1"

- Arithmetic storage operators use the old inversed representation:
	"foo =& 1", not "foo &= 1"


Missing (in order of pain):

- No longs or unsigneds (although "char *" works almost as well as an
	unsigned, but doing math with other kinds of pointers may not
	work, although:
	int	*ip;
	char	*cp, *xp;
	((xp = ip) + cp)
	works

- Expressions as initializers: no "int foo (1 + 2);" (this includes
	no "int foo (1);")

- Initialization of structures (although you can initialize arrays,
	and if you're lucky, you can initialize an array and then
	treat it like a structure; see bdevsw/cdevsw in Unix)

- No register storage class for arguments, hence the common:
	foo(acp)
	char	*acp;
	{	register	char	*cp;
		cp = acp;

- No initialization of automatic variables: so no:
	{	int	i	1;

- No casts: so no:
	int	*ip;
	char	*cp;
	cp = ((char *) ip);
	although this doesn't matter so much as you can assign anything
	to anything else, or use anything as a pointer, e.g.:
	int	a, b;
	b = a->some_struct_elem;

- No sizeof(<abstract type>): so no:
	sizeof(struct <foo>)
	although you can take the size of an actual instance of that
	structure type, or an instance of something else you want the
	size of

- Bit fields in structures (probably; haven't checked this one yet)



And just for grins, some things it actually _does_ support:

- Macros with arguments!

- Conditional compilation (#ifdef/#endif)