Index: src/Tests/Abstype.c
===================================================================
--- src/Tests/Abstype.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Abstype.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -1,3 +1,3 @@
-type T | { T x( T ); };
+otype T | { T x( T ); };
 
 T y( T t ) {
@@ -6,10 +6,10 @@
 }
 
-forall( type T ) lvalue T *?( T * );
+forall( otype T ) lvalue T *?( T * );
 int ?++( int * );
 int ?=?( int *, int );
 forall( dtype DT ) DT * ?=?( DT **, DT * );
 
-type U = int *;
+otype U = int *;
 
 U x( U u ) {
Index: src/Tests/Array.c
===================================================================
--- src/Tests/Array.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Array.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -1,8 +1,8 @@
 int a1[];
-int a2[*];
-double a4[3.0];
+//int a2[*];
+//double a4[3.0];
 
 int m1[][3];
-int m2[*][*];
+//int m2[*][*];
 int m4[3][3];
 
@@ -10,6 +10,6 @@
 
 int fred() {
-	int a1[];
-	int a2[*];
+//	int a1[];
+//	int a2[*];
 	int a4[3];
 	int T[3];
Index: src/Tests/Attributes.c
===================================================================
--- src/Tests/Attributes.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Attributes.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -6,11 +6,11 @@
 //    @max
 // 
-// 2. a direct application to a manifest type
+// 2. a direct application to a manifest otype
 // 
 //    @max( int )
 // 
-// 3. constraining a type variable; the application is implicitly performed at the call site as in (2)
+// 3. constraining a otype variable; the application is implicitly performed at the call site as in (2)
 // 
-//    forall( type T | { T @max( T ); } ) T x( T t );
+//    forall( otype T | { T @max( T ); } ) T x( T t );
 // 
 // 
@@ -23,9 +23,9 @@
 //    x = (*attr_var);
 // 
-// 2. an indirect application to a manifest type
+// 2. an indirect application to a manifest otype
 // 
 //    (*attr_var)( int )
 // 
-// 3. a direct application to a type variable
+// 3. a direct application to a otype variable
 // 
 //    @max( T )
@@ -47,5 +47,5 @@
 // 3. polymorphic
 // 
-//    forall( type T | constraint( T ) ) int @attr( T );
+//    forall( otype T | constraint( T ) ) int @attr( T );
 
 int @max = 3;
@@ -53,9 +53,9 @@
 int main() {
     int x;
-    type @type(type t);									// compiler intrinsic
-    type @widest(type t);
-    @type(x) *y;										// gcc: typeof(x) *y;
-    const @widest(double) *w;							// gcc: const typeof(x) *w;
-    * @type(3 + 4) z;									// cfa declaration syntax
+    otype @otype(otype t);									// compiler intrinsic
+    otype @widest(otype t);
+    @otype(x) *y;										// gcc: otypeof(x) *y;
+    const @widest(double) *w;							// gcc: const otypeof(x) *w;
+    * @otype(3 + 4) z;									// cfa declaration syntax
     y = @max;		
     z = @max(x) + @size(int);
Index: src/Tests/Context.c
===================================================================
--- src/Tests/Context.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Context.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -1,12 +1,12 @@
-context has_q( type T ) {
+context has_q( otype T ) {
 	T q( T );
 };
 
-forall( type z | has_q( z ) ) void f() {
-	context has_r( type T, type U ) {
+forall( otype z | has_q( z ) ) void f() {
+	context has_r( otype T, otype U ) {
 		T r( T, T (T,U) );
 	};
   
-	extern type x, y | has_r( x, y );
+	extern otype x, y | has_r( x, y );
 }
 
Index: src/Tests/Forall.c
===================================================================
--- src/Tests/Forall.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Forall.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -7,5 +7,5 @@
 
 void g1() {
-	forall( type T ) T f( T );
+	forall( otype T ) T f( T );
 	void f( int );
 	void h( void (*p)(void) );
@@ -24,6 +24,6 @@
 
 void g2() {
-	forall( type T ) void f( T, T );
-	forall( type T, type U ) void f( T, U );
+	forall( otype T ) void f( T, T );
+	forall( otype T, otype U ) void f( T, U );
   
 	int x;
@@ -37,7 +37,7 @@
 }
 
-typedef forall ( type T ) int (*f)( int );
+typedef forall ( otype T ) int (*f)( int );
 
-forall( type T )
+forall( otype T )
 void swap( T left, T right ) {
 	T temp = left;
@@ -46,5 +46,5 @@
 }
 
-context sumable( type T ) {
+context sumable( otype T ) {
 	const T 0;
 	T ?+?(T, T);
@@ -53,17 +53,17 @@
 };
 
-type T1 | { const T1 0; T1 ?+?(T1, T1); T1 ?++(T1); [T1] ?+=?(T1,T1); },
-	T2(type P1, type P2 ),
+otype T1 | { const T1 0; T1 ?+?(T1, T1); T1 ?++(T1); [T1] ?+=?(T1,T1); },
+	T2(otype P1, otype P2 ),
 	T3 | sumable(T3);
 
-type T2(type P1, type P2) | sumable(T2(P1,P2)) = struct { P1 i; P2 j; };
+otype T2(otype P1, otype P2) | sumable(T2(P1,P2)) = struct { P1 i; P2 j; };
 
 T2(int, int) w1;
 typedef T2(int, int) w2;
 w2 g2;
-type w3 = T2(int, int);
+otype w3 = T2(int, int);
 w3 g3;
 
-forall( type T | sumable( T ) )
+forall( otype T | sumable( T ) )
 T sum( int n, T a[] ) {
 	T total = 0;
@@ -74,10 +74,10 @@
 }
 
-forall( type T | { const T 0; T ?+?(T, T); T ?++(T); [T] ?+=?(T,T); } )
+forall( otype T | { const T 0; T ?+?(T, T); T ?++(T); [T] ?+=?(T,T); } )
 T twice( T t ) {
 	return t + t;
 }
 
-forall( type T | { const T 0; int ?!=?(T, T); int ?<?(T, T); } )
+forall( otype T | { const T 0; int ?!=?(T, T); int ?<?(T, T); } )
 T min( T t1, T t2 ) {
 	return t1 < t2 ? t1 : t2;
Index: src/Tests/Functions.c
===================================================================
--- src/Tests/Functions.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Functions.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -28,5 +28,5 @@
 int ((*f12())[])[3] {}
 
-// "implicit int" type specifier (not ANSI)
+// "implicit int" otype specifier (not ANSI)
 
 fII1( int i ) {}
Index: src/Tests/GccExtensions.c
===================================================================
--- src/Tests/GccExtensions.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/GccExtensions.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -19,6 +19,6 @@
     __signed s2;
 
-    __typeof(s1) t1;
-    __typeof__(s1) t2;
+    __otypeof(s1) t1;
+    __otypeof__(s1) t2;
 
     __volatile int v1;
Index: src/Tests/InferParam.c
===================================================================
--- src/Tests/InferParam.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/InferParam.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -3,5 +3,5 @@
 double ?=?( double*, double );
 
-forall( type T, type U | { U f(T); } ) U g(T);
+forall( otype T, otype U | { U f(T); } ) U g(T);
 float f( int );
 double f( int );
@@ -13,5 +13,5 @@
 }
 
-context has_f_and_j( type T, type U ) {
+context has_f_and_j( otype T, otype U ) {
 	U f( T );
 	U j( T, U );
@@ -19,5 +19,5 @@
 
 float j( int, float );
-forall( type T, type U | has_f_and_j( T, U ) ) U k( T );
+forall( otype T, otype U | has_f_and_j( T, U ) ) U k( T );
 
 void l() {
Index: src/Tests/Makefile
===================================================================
--- src/Tests/Makefile	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Makefile	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -1,3 +1,3 @@
-CFA ?= ../cfa-cpp
+CFA ?= ../driver/cfa-cpp
 CFAOPT ?= -a
 OUTPUT ?= Output
@@ -32,5 +32,5 @@
 
 ${OUTPUTDIR} :
-	mkdir $@
+	mkdir -p $@
 
 # remove the expected results directories to generate new ones from the current output
Index: src/Tests/Members.c
===================================================================
--- src/Tests/Members.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Members.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -3,5 +3,5 @@
 float ?=?( float*, float );
 forall( dtype DT ) DT * ?=?( DT**, DT* );
-forall(type T) lvalue T *?( T* );
+forall(otype T) lvalue T *?( T* );
 char *__builtin_memcpy();
 
Index: src/Tests/OccursError.c
===================================================================
--- src/Tests/OccursError.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/OccursError.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -1,4 +1,4 @@
-forall( type T ) void f( void (*)( T, T* ) );
-forall( type U ) void g( U*, U );
+forall( otype T ) void f( void (*)( T, T* ) );
+forall( otype U ) void g( U*, U );
 
 void test() {
Index: src/Tests/Quad.c
===================================================================
--- src/Tests/Quad.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Quad.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -2,10 +2,10 @@
 int ?*?( int, int );
 
-forall( type T | { T ?*?( T, T ); } )
+forall( otype T | { T ?*?( T, T ); } )
 T square( T t ) {
 	return t * t;
 }
 
-forall( type U | { U square( U ); } )
+forall( otype U | { U square( U ); } )
 U quad( U u ) {
 	return square( square( u ) );
Index: src/Tests/Rank2.c
===================================================================
--- src/Tests/Rank2.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Rank2.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -3,6 +3,6 @@
 
 void a() {
-	forall( type T ) void f( T );
-	void g( forall( type U ) void p( U ) );
+	forall( otype T ) void f( T );
+	void g( forall( otype U ) void p( U ) );
 	g( f );
 }
@@ -10,5 +10,5 @@
 void g() {
 	void h( int *null );
-	forall( type T ) T id( T );
+	forall( otype T ) T id( T );
 	forall( dtype T ) T *0;
 	int 0;
Index: src/Tests/Scope.c
===================================================================
--- src/Tests/Scope.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Scope.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -3,10 +3,10 @@
 typedef float t;
 y z;
-type u = struct { int a; double b; };
+otype u = struct { int a; double b; };
 int f( int y );
 y q;
 
 y w( y y, u v ) {
-	type x | { x t(u); };
+	otype x | { x t(u); };
 	u u = y;
 	x z = t(u);
@@ -15,9 +15,9 @@
 y p;
 
-context has_u( type z ) {
+context has_u( otype z ) {
 	z u(z);
 };
 
-forall( type t | has_u( t ) )
+forall( otype t | has_u( t ) )
 y q( t the_t ) {
 	t y = u( the_t );
Index: src/Tests/Subrange.c
===================================================================
--- src/Tests/Subrange.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Subrange.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -1,16 +1,16 @@
-// A small context defining the notion of an ordered type.  (The standard
+// A small context defining the notion of an ordered otype.  (The standard
 // library should probably contain a context for this purpose.)
-context ordered(type T) {
+context ordered(otype T) {
     int ?<?(T, T), ?<=?(T, T);
 };
 
-// A subrange type resembling an Ada subtype with a base type and a range
+// A subrange otype resembling an Ada subotype with a base otype and a range
 // constraint.
-type subrange(type base_t | ordered(base_t), base_t low = 0, base_t high = 8) = base_t;
+otype subrange(otype base_t | ordered(base_t), base_t low = 0, base_t high = 8) = base_t;
 
-// Note that subrange() can be applied to floating-point and pointer types, not
-// just integral types.
-//   This requires a "type generator" extension to Cforall.  Type generators
-// must accept type and non-type parameters, which is beyond what we discussed
+// Note that subrange() can be applied to floating-point and pointer otypes, not
+// just integral otypes.
+//   This requires a "otype generator" extension to Cforall.  Type generators
+// must accept otype and non-otype parameters, which is beyond what we discussed
 // previously.  Type parameters must be usable in the declaration of
 // subsequent parameters: parameter T is used to declare parameters "low"
@@ -22,5 +22,5 @@
 subrange(int, 0, (rand() & 0xF) ) foo;
 
-// What sorts of expressions can be used as arguments of type generators?  Is
+// What sorts of expressions can be used as arguments of otype generators?  Is
 // "subrange(int, 0, rand() & 0xF)" legal?  Probably.  The nearest C equivalent
 // to the "low" and "high" arguments is the array size in a variable-length
@@ -28,10 +28,10 @@
 
 // Convenient access to subrange bounds, for instance for iteration:
-forall (type T, T low, T high)
+forall (otype T, T low, T high)
 T lbound( subrange(T, low, high) v) {
     return low;
 }
 
-forall (type T, T low, T high)
+forall (otype T, T low, T high)
 T hbound( subrange(T, low, high) v) {
     return high;
@@ -41,8 +41,8 @@
 unsigned lday = lbound(day_of_month);
 
-// Assignment from the base type, with bounds checking.  I'll ignore the issue
+// Assignment from the base otype, with bounds checking.  I'll ignore the issue
 // of exception handling here.  Inlining allows the compiler to eliminate
 // bounds checks.
-forall (type T | ordered(T), T low, T high)
+forall (otype T | ordered(T), T low, T high)
 inline subrange(T, low, high) ?=?(subrange(T, low, high)* target, T source) {
     if (low <= source && source <= high) *((T*)target) = source;
@@ -51,8 +51,8 @@
 }
 
-// Assignment between subranges with a common base type.  The bounds check
+// Assignment between subranges with a common base otype.  The bounds check
 // compares range bounds so that the compiler can optimize checks away when the
 // ranges are known to overlap.
-forall (type T | ordered(T), T t_low, T t_high, T s_low, T s_high)
+forall (otype T | ordered(T), T t_low, T t_high, T s_low, T s_high)
 inline subrange(T, t_low, t_high) ?=?(subrange(T, t_low, t_high)* target,
 				      subrange(T, s_low, s_high) source) {
Index: src/Tests/TypeGenerator.c
===================================================================
--- src/Tests/TypeGenerator.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/TypeGenerator.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -1,8 +1,8 @@
-context addable( type T ) {
+context addable( otype T ) {
 	T ?+?( T,T );
 	T ?=?( T*, T);
 };
 
-type List1( type T | addable( T ) ) = struct { T data; List1( T ) *next; } *;
+otype List1( otype T | addable( T ) ) = struct { T data; List1( T ) *next; } *;
 typedef List1( int ) ListOfIntegers;
 //List1( int ) li;
@@ -11,14 +11,14 @@
 [int] h( * List1( int ) p );							// new declaration syntax
 
-struct( type T ) S2 { T i; };							// actual definition
+struct( otype T ) S2 { T i; };							// actual definition
 struct( int ) S3 v1, *p;								// expansion and instantiation
-struct( type T )( int ) S24 { T i; } v2;				// actual definition, expansion and instantiation
-struct( type T )( int ) { T i; } v2;					// anonymous actual definition, expansion and instantiation
+struct( otype T )( int ) S24 { T i; } v2;				// actual definition, expansion and instantiation
+struct( otype T )( int ) { T i; } v2;					// anonymous actual definition, expansion and instantiation
 
-struct( type T | addable( T ) ) node { T data; struct( T ) node *next; };
-type List( type T ) = struct( T ) node *;
+struct( otype T | addable( T ) ) node { T data; struct( T ) node *next; };
+otype List( otype T ) = struct( T ) node *;
 List( int ) my_list;
 
-type Complex | addable( Complex );
+otype Complex | addable( Complex );
 
 int main() {
Index: src/Tests/Typedef.c
===================================================================
--- src/Tests/Typedef.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Typedef.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -18,5 +18,5 @@
 a c;
 
-typedef typeof(3) x, y;  // GCC
+typedef otypeof(3) x, y;  // GCC
 
 x p;
@@ -24,5 +24,5 @@
 
 int main() {
-    typedef typeof(3) z, p;
+    typedef otypeof(3) z, p;
     z w;
     p x;
Index: src/Tests/Typeof.c
===================================================================
--- src/Tests/Typeof.c	(revision 4c82a3cab972bf8e5bd0f8a5f371e04d867d3447)
+++ src/Tests/Typeof.c	(revision 55ba73393e6f949adf1915b0709a5aa0b02fd192)
@@ -1,10 +1,10 @@
 int main() {
     int *v1;
-    typeof(v1) v2;
-    typeof(*v1) v3[4];
+    otypeof(v1) v2;
+    otypeof(*v1) v3[4];
     char *v4[4];
-    typeof(typeof(char *)[4]) v5;
-    typeof (int *) v6;
-    typeof( int ( int, int p ) ) *v7;
-    typeof( [int] ( int, int p ) ) *v8;
+    otypeof(otypeof(char *)[4]) v5;
+    otypeof (int *) v6;
+    otypeof( int ( int, int p ) ) *v7;
+    otypeof( [int] ( int, int p ) ) *v8;
 }