Index: src/tests/Array.c
===================================================================
--- src/tests/Array.c	(revision 6cbc25aec785c39eb8b565ef2c369a483d89f4c6)
+++ src/tests/Array.c	(revision 545ef596525185351bc3df14e55206f9fc1f7cec)
@@ -1,9 +1,9 @@
 //Testing array declarations
 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];
 
@@ -11,6 +11,6 @@
 
 int fred() {
-	int a1[];
-	int a2[*];
+//	int a1[];
+//	int a2[*];
 	int a4[3];
 	int T[3];
Index: src/tests/Forall.c
===================================================================
--- src/tests/Forall.c	(revision 6cbc25aec785c39eb8b565ef2c369a483d89f4c6)
+++ src/tests/Forall.c	(revision 545ef596525185351bc3df14e55206f9fc1f7cec)
@@ -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 6cbc25aec785c39eb8b565ef2c369a483d89f4c6)
+++ src/tests/Functions.c	(revision 545ef596525185351bc3df14e55206f9fc1f7cec)
@@ -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 6cbc25aec785c39eb8b565ef2c369a483d89f4c6)
+++ src/tests/GccExtensions.c	(revision 545ef596525185351bc3df14e55206f9fc1f7cec)
@@ -19,6 +19,6 @@
     __signed s2;
 
-    __typeof(s1) t1;
-    __typeof__(s1) t2;
+    __otypeof(s1) t1;
+    __otypeof__(s1) t2;
 
     __volatile int v1;
Index: src/tests/Scope.c
===================================================================
--- src/tests/Scope.c	(revision 6cbc25aec785c39eb8b565ef2c369a483d89f4c6)
+++ src/tests/Scope.c	(revision 545ef596525185351bc3df14e55206f9fc1f7cec)
@@ -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 6cbc25aec785c39eb8b565ef2c369a483d89f4c6)
+++ src/tests/Subrange.c	(revision 545ef596525185351bc3df14e55206f9fc1f7cec)
@@ -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 6cbc25aec785c39eb8b565ef2c369a483d89f4c6)
+++ src/tests/TypeGenerator.c	(revision 545ef596525185351bc3df14e55206f9fc1f7cec)
@@ -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 6cbc25aec785c39eb8b565ef2c369a483d89f4c6)
+++ src/tests/Typedef.c	(revision 545ef596525185351bc3df14e55206f9fc1f7cec)
@@ -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 6cbc25aec785c39eb8b565ef2c369a483d89f4c6)
+++ src/tests/Typeof.c	(revision 545ef596525185351bc3df14e55206f9fc1f7cec)
@@ -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;
 }
Index: src/tests/io.c
===================================================================
--- src/tests/io.c	(revision 6cbc25aec785c39eb8b565ef2c369a483d89f4c6)
+++ src/tests/io.c	(revision 545ef596525185351bc3df14e55206f9fc1f7cec)
@@ -11,6 +11,6 @@
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu May 26 10:06:00 2016
-// Update Count     : 28
+// Last Modified On : Wed Jun  8 22:52:04 2016
+// Update Count     : 30
 // 
 
@@ -34,4 +34,11 @@
 	long double _Complex ldc;
 	char s1[10], s2[10];
+
+	int x = 3, y = 5, z = 7;
+	sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
+	sout | 1 | 2 | 3 | endl;
+	sout | '1' | '2' | '3' | endl;
+	sout | 1 | "" | 2 | "" | 3 | endl;
+	sout | endl;
 
 	ifstream in;												// create / open file