WebSVN – tendra.SVN – Diff – /trunk/src/utilities/calculus/write_def.h

 #include "type_ops.h"
 /* Disk writing function declarations */
 #ifndef WRITE_disk_list_ptr_type
-#define WRITE_disk_list_ptr_type( A ) WRITE_list_ptr_type ( A )
+#define WRITE_disk_list_ptr_type(A) WRITE_list_ptr_type(A)
 #endif
 #ifndef WRITE_list_ptr_type
-static void WRITE_list_ptr_type PROTO_S ( ( LIST ( PTR ( TYPE ) ) ) ) ;
+static void WRITE_list_ptr_type(LIST(PTR(TYPE)));
 #endif
 #ifndef WRITE_disk_string
-#define WRITE_disk_string( A ) WRITE_string ( A )
+#define WRITE_disk_string(A) WRITE_string(A)
 #endif
 #ifndef WRITE_disk_int
-#define WRITE_disk_int( A ) WRITE_int ( A )
+#define WRITE_disk_int(A) WRITE_int(A)
 #endif
 #ifndef WRITE_type
-static void WRITE_type PROTO_S ( ( TYPE ) ) ;
+static void WRITE_type(TYPE);
 #endif
 #ifndef WRITE_zero_int
-#define WRITE_zero_int( A ) WRITE_int ( A )
+#define WRITE_zero_int(A) WRITE_int(A)
 #endif
 #ifndef WRITE_PRIMITIVE_P
-#define WRITE_PRIMITIVE_P( A ) WRITE_ptr_prim ( A )
+#define WRITE_PRIMITIVE_P(A) WRITE_ptr_prim(A)
 #endif
 #ifndef WRITE_ptr_prim
-static void WRITE_ptr_prim PROTO_S ( ( PTR ( PRIMITIVE ) ) ) ;
+static void WRITE_ptr_prim(PTR(PRIMITIVE));
 #endif
 #ifndef WRITE_prim
-static void WRITE_prim PROTO_S ( ( PRIMITIVE ) ) ;
+static void WRITE_prim(PRIMITIVE);
 #endif
 #ifndef WRITE_CLASS_ID_P
-#define WRITE_CLASS_ID_P( A ) WRITE_ptr_cid ( A )
+#define WRITE_CLASS_ID_P(A) WRITE_ptr_cid(A)
 #endif
 #ifndef WRITE_ptr_cid
-static void WRITE_ptr_cid PROTO_S ( ( PTR ( CLASS_ID ) ) ) ;
+static void WRITE_ptr_cid(PTR(CLASS_ID));
 #endif
 #ifndef WRITE_cid
-static void WRITE_cid PROTO_S ( ( CLASS_ID ) ) ;
+static void WRITE_cid(CLASS_ID);
 #endif
 #ifndef WRITE_name_string
-#define WRITE_name_string( A ) WRITE_string ( A )
+#define WRITE_name_string(A) WRITE_string(A)
 #endif
 #ifndef WRITE_IDENTITY_P
-#define WRITE_IDENTITY_P( A ) WRITE_ptr_ident ( A )
+#define WRITE_IDENTITY_P(A) WRITE_ptr_ident(A)
 #endif
 #ifndef WRITE_ptr_ident
-static void WRITE_ptr_ident PROTO_S ( ( PTR ( IDENTITY ) ) ) ;
+static void WRITE_ptr_ident(PTR(IDENTITY));
 #endif
 #ifndef WRITE_ident
-static void WRITE_ident PROTO_S ( ( IDENTITY ) ) ;
+static void WRITE_ident(IDENTITY);
 #endif
 #ifndef WRITE_TYPE_P
-#define WRITE_TYPE_P( A ) WRITE_ptr_type ( A )
+#define WRITE_TYPE_P(A) WRITE_ptr_type(A)
 #endif
 #ifndef WRITE_ptr_type
-static void WRITE_ptr_type PROTO_S ( ( PTR ( TYPE ) ) ) ;
+static void WRITE_ptr_type(PTR(TYPE));
 #endif
 #ifndef WRITE_ENUM_P
-#define WRITE_ENUM_P( A ) WRITE_ptr_en ( A )
+#define WRITE_ENUM_P(A) WRITE_ptr_en(A)
 #endif
 #ifndef WRITE_ptr_en
-static void WRITE_ptr_en PROTO_S ( ( PTR ( ENUM ) ) ) ;
+static void WRITE_ptr_en(PTR(ENUM));
 #endif
 #ifndef WRITE_en
-static void WRITE_en PROTO_S ( ( ENUM ) ) ;
+static void WRITE_en(ENUM);
 #endif
 #ifndef WRITE_list_ptr_ec
-static void WRITE_list_ptr_ec PROTO_S ( ( LIST ( PTR ( ECONST ) ) ) ) ;
+static void WRITE_list_ptr_ec(LIST(PTR(ECONST)));
 #endif
 #ifndef WRITE_list_ECONST_P
-#define WRITE_list_ECONST_P( A ) WRITE_list_ptr_ec ( A )
+#define WRITE_list_ECONST_P(A) WRITE_list_ptr_ec(A)
 #endif
 #ifndef WRITE_ECONST_P
-#define WRITE_ECONST_P( A ) WRITE_ptr_ec ( A )
+#define WRITE_ECONST_P(A) WRITE_ptr_ec(A)
 #endif
 #ifndef WRITE_ptr_ec
-static void WRITE_ptr_ec PROTO_S ( ( PTR ( ECONST ) ) ) ;
+static void WRITE_ptr_ec(PTR(ECONST));
 #endif
 #ifndef WRITE_ec
-static void WRITE_ec PROTO_S ( ( ECONST ) ) ;
+static void WRITE_ec(ECONST);
 #endif
 #ifndef WRITE_STRUCTURE_P
-#define WRITE_STRUCTURE_P( A ) WRITE_ptr_str ( A )
+#define WRITE_STRUCTURE_P(A) WRITE_ptr_str(A)
 #endif
 #ifndef WRITE_ptr_str
-static void WRITE_ptr_str PROTO_S ( ( PTR ( STRUCTURE ) ) ) ;
+static void WRITE_ptr_str(PTR(STRUCTURE));
 #endif
 #ifndef WRITE_str
-static void WRITE_str PROTO_S ( ( STRUCTURE ) ) ;
+static void WRITE_str(STRUCTURE);
 #endif
 #ifndef WRITE_list_ptr_cmp
-static void WRITE_list_ptr_cmp PROTO_S ( ( LIST ( PTR ( COMPONENT ) ) ) ) ;
+static void WRITE_list_ptr_cmp(LIST(PTR(COMPONENT)));
 #endif
 #ifndef WRITE_list_COMPONENT_P
-#define WRITE_list_COMPONENT_P( A ) WRITE_list_ptr_cmp ( A )
+#define WRITE_list_COMPONENT_P(A) WRITE_list_ptr_cmp(A)
 #endif
 #ifndef WRITE_COMPONENT_P
-#define WRITE_COMPONENT_P( A ) WRITE_ptr_cmp ( A )
+#define WRITE_COMPONENT_P(A) WRITE_ptr_cmp(A)
 #endif
 #ifndef WRITE_ptr_cmp
-static void WRITE_ptr_cmp PROTO_S ( ( PTR ( COMPONENT ) ) ) ;
+static void WRITE_ptr_cmp(PTR(COMPONENT));
 #endif
 #ifndef WRITE_cmp
-static void WRITE_cmp PROTO_S ( ( COMPONENT ) ) ;
+static void WRITE_cmp(COMPONENT);
 #endif
 #ifndef WRITE_UNION_P
-#define WRITE_UNION_P( A ) WRITE_ptr_un ( A )
+#define WRITE_UNION_P(A) WRITE_ptr_un(A)
 #endif
 #ifndef WRITE_ptr_un
-static void WRITE_ptr_un PROTO_S ( ( PTR ( UNION ) ) ) ;
+static void WRITE_ptr_un(PTR(UNION));
 #endif
 #ifndef WRITE_un
-static void WRITE_un PROTO_S ( ( UNION ) ) ;
+static void WRITE_un(UNION);
 #endif
 #ifndef WRITE_list_ptr_fld
-static void WRITE_list_ptr_fld PROTO_S ( ( LIST ( PTR ( FIELD ) ) ) ) ;
+static void WRITE_list_ptr_fld(LIST(PTR(FIELD)));
 #endif
 #ifndef WRITE_list_FIELD_P
-#define WRITE_list_FIELD_P( A ) WRITE_list_ptr_fld ( A )
+#define WRITE_list_FIELD_P(A) WRITE_list_ptr_fld(A)
 #endif
 #ifndef WRITE_FIELD_P
-#define WRITE_FIELD_P( A ) WRITE_ptr_fld ( A )
+#define WRITE_FIELD_P(A) WRITE_ptr_fld(A)
 #endif
 #ifndef WRITE_ptr_fld
-static void WRITE_ptr_fld PROTO_S ( ( PTR ( FIELD ) ) ) ;
+static void WRITE_ptr_fld(PTR(FIELD));
 #endif
 #ifndef WRITE_fld
-static void WRITE_fld PROTO_S ( ( FIELD ) ) ;
+static void WRITE_fld(FIELD);
 #endif
 #ifndef WRITE_list_ptr_map
-static void WRITE_list_ptr_map PROTO_S ( ( LIST ( PTR ( MAP ) ) ) ) ;
+static void WRITE_list_ptr_map(LIST(PTR(MAP)));
 #endif
 #ifndef WRITE_list_MAP_P
-#define WRITE_list_MAP_P( A ) WRITE_list_ptr_map ( A )
+#define WRITE_list_MAP_P(A) WRITE_list_ptr_map(A)
 #endif
 #ifndef WRITE_MAP_P
-#define WRITE_MAP_P( A ) WRITE_ptr_map ( A )
+#define WRITE_MAP_P(A) WRITE_ptr_map(A)
 #endif
 #ifndef WRITE_ptr_map
-static void WRITE_ptr_map PROTO_S ( ( PTR ( MAP ) ) ) ;
+static void WRITE_ptr_map(PTR(MAP));
 #endif
 #ifndef WRITE_map
-static void WRITE_map PROTO_S ( ( MAP ) ) ;
+static void WRITE_map(MAP);
 #endif
 #ifndef WRITE_list_ptr_arg
-static void WRITE_list_ptr_arg PROTO_S ( ( LIST ( PTR ( ARGUMENT ) ) ) ) ;
+static void WRITE_list_ptr_arg(LIST(PTR(ARGUMENT)));
 #endif
 #ifndef WRITE_list_ARGUMENT_P
-#define WRITE_list_ARGUMENT_P( A ) WRITE_list_ptr_arg ( A )
+#define WRITE_list_ARGUMENT_P(A) WRITE_list_ptr_arg(A)
 #endif
 #ifndef WRITE_ARGUMENT_P
-#define WRITE_ARGUMENT_P( A ) WRITE_ptr_arg ( A )
+#define WRITE_ARGUMENT_P(A) WRITE_ptr_arg(A)
 #endif
 #ifndef WRITE_ptr_arg
-static void WRITE_ptr_arg PROTO_S ( ( PTR ( ARGUMENT ) ) ) ;
+static void WRITE_ptr_arg(PTR(ARGUMENT));
 #endif
 #ifndef WRITE_arg
-static void WRITE_arg PROTO_S ( ( ARGUMENT ) ) ;
+static void WRITE_arg(ARGUMENT);
 #endif
-/* Disk writing routine for LIST ( PTR ( TYPE ) ) */
+/* Disk writing routine for LIST(PTR(TYPE)) */
 #ifndef WRITE_list_ptr_type
 static void WRITE_list_ptr_type
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( LIST ( PTR ( TYPE ) ) x_ )
+(LIST(PTR(TYPE)) x_)
 {
-    while ( !IS_NULL_list ( x_ ) ) {
+    while (!IS_NULL_list(x_)) {
-	PTR ( TYPE ) y_ ;
+	PTR(TYPE) y_;
-	y_ = DEREF_ptr ( HEAD_list ( x_ ) ) ;
+	y_ = DEREF_ptr(HEAD_list(x_));
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_ptr_type ( y_ ) ;
+	WRITE_ptr_type(y_);
-	x_ = TAIL_list ( x_ ) ;
+	x_ = TAIL_list(x_);
     }
-    WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+    WRITE_BITS(1, (unsigned)0);
-    return ;
+    return;
 }
 #endif
 /* Disk writing routine for TYPE */
 #ifndef WRITE_type
 static void WRITE_type
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( TYPE x_ )
+(TYPE x_)
+{
-    if ( IS_NULL_type ( x_ ) ) {
+    if (IS_NULL_type(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
+	    }
-	    case type_undef_tag : {
+	    case type_undef_tag: {
-		string name ;
+		string name;
-		DECONS_type_undef ( size, name,  x_ ) ;
+		DECONS_type_undef(size, name,  x_);
-		WRITE_zero_int ( size ) ;
+		WRITE_zero_int(size);
-		WRITE_string ( name ) ;
+		WRITE_string(name);
-		break ;
+		break;
+	    }
+	}
+    }
-    return ;
+    return;
-}
-#endif
-/* Disk writing routine for PTR ( PRIMITIVE ) */
-#ifndef WRITE_ptr_prim
-static void WRITE_ptr_prim
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( PRIMITIVE ) x_ )
-{
-    if ( IS_NULL_ptr ( x_ ) ) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
-    } else {
-	PRIMITIVE y_ ;
-	DEREF_prim ( x_, y_ ) ;
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
-	WRITE_prim ( y_ ) ;
-    }
-    return ;
+}
 #endif
+/* Disk writing routine for PTR(PRIMITIVE) */
+#ifndef WRITE_ptr_prim
+static void WRITE_ptr_prim
+(PTR(PRIMITIVE) x_)
+{
+    if (IS_NULL_ptr(x_)) {
+	WRITE_BITS(1, (unsigned)0);
+    } else {
+	PRIMITIVE y_;
+	DEREF_prim(x_, y_);
+	WRITE_BITS(1, (unsigned)1);
+	WRITE_prim(y_);
+    }
+    return;
+}
+#endif
 /* Disk writing routine for PRIMITIVE */
 #ifndef WRITE_prim
 static void WRITE_prim
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PRIMITIVE x_ )
+(PRIMITIVE x_)
+{
-    WRITE_CLASS_ID_P ( x_.id ) ;
+    WRITE_CLASS_ID_P(x_.id);
-    WRITE_string ( x_.defn ) ;
+    WRITE_string(x_.defn);
-    return ;
+    return;
+}
 #endif
-/* Disk writing routine for PTR ( CLASS_ID ) */
+/* Disk writing routine for PTR(CLASS_ID) */
 #ifndef WRITE_ptr_cid
 static void WRITE_ptr_cid
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( CLASS_ID ) x_ )
+(PTR(CLASS_ID) x_)
+{
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	CLASS_ID y_ ;
+	CLASS_ID y_;
-	DEREF_cid ( x_, y_ ) ;
+	DEREF_cid(x_, y_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_cid ( y_ ) ;
+	WRITE_cid(y_);
+    }
-    return ;
+    return;
+}
 #endif
 /* Disk writing routine for CLASS_ID */
 #ifndef WRITE_cid
 static void WRITE_cid
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( CLASS_ID x_ )
+(CLASS_ID x_)
 {
-    WRITE_string ( x_.name ) ;
+    WRITE_string(x_.name);
-    WRITE_string ( x_.name_aux ) ;
+    WRITE_string(x_.name_aux);
-    WRITE_int ( x_.flag ) ;
+    WRITE_int(x_.flag);
-    WRITE_name_string ( x_.file ) ;
+    WRITE_name_string(x_.file);
-    WRITE_int ( x_.line ) ;
+    WRITE_int(x_.line);
-    return ;
+    return;
 }
 #endif
-/* Disk writing routine for PTR ( IDENTITY ) */
+/* Disk writing routine for PTR(IDENTITY) */
 #ifndef WRITE_ptr_ident
 static void WRITE_ptr_ident
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( IDENTITY ) x_ )
+(PTR(IDENTITY) x_)
 {
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	IDENTITY y_ ;
+	IDENTITY y_;
-	DEREF_ident ( x_, y_ ) ;
+	DEREF_ident(x_, y_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_ident ( y_ ) ;
+	WRITE_ident(y_);
     }
-    return ;
+    return;
 }
 #endif
 /* Disk writing routine for IDENTITY */
 #ifndef WRITE_ident
 static void WRITE_ident
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( IDENTITY x_ )
+(IDENTITY x_)
 {
-    WRITE_CLASS_ID_P ( x_.id ) ;
+    WRITE_CLASS_ID_P(x_.id);
-    WRITE_TYPE_P ( x_.defn ) ;
+    WRITE_TYPE_P(x_.defn);
-    return ;
+    return;
+}
 #endif
-/* Disk writing routine for PTR ( TYPE ) */
+/* Disk writing routine for PTR(TYPE) */
 #ifndef WRITE_ptr_type
 static void WRITE_ptr_type
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( TYPE ) x_ )
+(PTR(TYPE) x_)
+{
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	TYPE y_ ;
+	TYPE y_;
-	y_ = DEREF_type ( x_ ) ;
+	y_ = DEREF_type(x_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_type ( y_ ) ;
+	WRITE_type(y_);
+    }
-    return ;
+    return;
+}
 #endif
-/* Disk writing routine for PTR ( ENUM ) */
+/* Disk writing routine for PTR(ENUM) */
 #ifndef WRITE_ptr_en
 static void WRITE_ptr_en
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( ENUM ) x_ )
+(PTR(ENUM) x_)
 {
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	ENUM y_ ;
+	ENUM y_;
-	DEREF_en ( x_, y_ ) ;
+	DEREF_en(x_, y_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_en ( y_ ) ;
+	WRITE_en(y_);
     }
-    return ;
+    return;
 }
 #endif
 /* Disk writing routine for ENUM */
 #ifndef WRITE_en
 static void WRITE_en
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( ENUM x_ )
+(ENUM x_)
 {
-    WRITE_CLASS_ID_P ( x_.id ) ;
+    WRITE_CLASS_ID_P(x_.id);
-    WRITE_list_ECONST_P ( x_.consts ) ;
+    WRITE_list_ECONST_P(x_.consts);
-    WRITE_number ( x_.order ) ;
+    WRITE_number(x_.order);
-    WRITE_int ( x_.lists ) ;
+    WRITE_int(x_.lists);
-    return ;
+    return;
 }
 #endif
-/* Disk writing routine for LIST ( PTR ( ECONST ) ) */
+/* Disk writing routine for LIST(PTR(ECONST)) */
 #ifndef WRITE_list_ptr_ec
 static void WRITE_list_ptr_ec
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( LIST ( PTR ( ECONST ) ) x_ )
+(LIST(PTR(ECONST)) x_)
 {
-    while ( !IS_NULL_list ( x_ ) ) {
+    while (!IS_NULL_list(x_)) {
-	PTR ( ECONST ) y_ ;
+	PTR(ECONST) y_;
-	y_ = DEREF_ptr ( HEAD_list ( x_ ) ) ;
+	y_ = DEREF_ptr(HEAD_list(x_));
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_ptr_ec ( y_ ) ;
+	WRITE_ptr_ec(y_);
-	x_ = TAIL_list ( x_ ) ;
+	x_ = TAIL_list(x_);
     }
-    WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+    WRITE_BITS(1, (unsigned)0);
-    return ;
+    return;
 }
 #endif
-/* Disk writing routine for PTR ( ECONST ) */
+/* Disk writing routine for PTR(ECONST) */
 #ifndef WRITE_ptr_ec
 static void WRITE_ptr_ec
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( ECONST ) x_ )
+(PTR(ECONST) x_)
+{
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	ECONST y_ ;
+	ECONST y_;
-	DEREF_ec ( x_, y_ ) ;
+	DEREF_ec(x_, y_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_ec ( y_ ) ;
+	WRITE_ec(y_);
+    }
-    return ;
+    return;
+}
 #endif
 /* Disk writing routine for ECONST */
 #ifndef WRITE_ec
 static void WRITE_ec
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( ECONST x_ )
-{
-    WRITE_string ( x_.name ) ;
-    WRITE_number ( x_.value ) ;
-    return ;
-}
-#endif
+(ECONST x_)
+{
+    WRITE_string(x_.name);
+    WRITE_number(x_.value);
+    return;
+}
+#endif
-/* Disk writing routine for PTR ( STRUCTURE ) */
+/* Disk writing routine for PTR(STRUCTURE) */
 #ifndef WRITE_ptr_str
 static void WRITE_ptr_str
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( STRUCTURE ) x_ )
+(PTR(STRUCTURE) x_)
 {
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	STRUCTURE y_ ;
+	STRUCTURE y_;
-	DEREF_str ( x_, y_ ) ;
+	DEREF_str(x_, y_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_str ( y_ ) ;
+	WRITE_str(y_);
     }
-    return ;
+    return;
 }
 #endif
 /* Disk writing routine for STRUCTURE */
 #ifndef WRITE_str
 static void WRITE_str
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( STRUCTURE x_ )
+(STRUCTURE x_)
 {
-    WRITE_CLASS_ID_P ( x_.id ) ;
+    WRITE_CLASS_ID_P(x_.id);
-    WRITE_STRUCTURE_P ( x_.base ) ;
+    WRITE_STRUCTURE_P(x_.base);
-    WRITE_list_COMPONENT_P ( x_.defn ) ;
+    WRITE_list_COMPONENT_P(x_.defn);
-    WRITE_zero_int ( x_.output ) ;
+    WRITE_zero_int(x_.output);
-    return ;
+    return;
 }
 #endif
-/* Disk writing routine for LIST ( PTR ( COMPONENT ) ) */
+/* Disk writing routine for LIST(PTR(COMPONENT)) */
 #ifndef WRITE_list_ptr_cmp
 static void WRITE_list_ptr_cmp
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( LIST ( PTR ( COMPONENT ) ) x_ )
+(LIST(PTR(COMPONENT)) x_)
+{
-    while ( !IS_NULL_list ( x_ ) ) {
+    while (!IS_NULL_list(x_)) {
-	PTR ( COMPONENT ) y_ ;
+	PTR(COMPONENT) y_;
-	y_ = DEREF_ptr ( HEAD_list ( x_ ) ) ;
+	y_ = DEREF_ptr(HEAD_list(x_));
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_ptr_cmp ( y_ ) ;
+	WRITE_ptr_cmp(y_);
-	x_ = TAIL_list ( x_ ) ;
+	x_ = TAIL_list(x_);
+    }
-    WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+    WRITE_BITS(1, (unsigned)0);
-    return ;
+    return;
+}
 #endif
-/* Disk writing routine for PTR ( COMPONENT ) */
+/* Disk writing routine for PTR(COMPONENT) */
 #ifndef WRITE_ptr_cmp
 static void WRITE_ptr_cmp
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( COMPONENT ) x_ )
+(PTR(COMPONENT) x_)
 {
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	COMPONENT y_ ;
+	COMPONENT y_;
-	DEREF_cmp ( x_, y_ ) ;
+	DEREF_cmp(x_, y_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_cmp ( y_ ) ;
+	WRITE_cmp(y_);
     }
-    return ;
+    return;
 }
 #endif
 /* Disk writing routine for COMPONENT */
 #ifndef WRITE_cmp
 static void WRITE_cmp
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( COMPONENT x_ )
+(COMPONENT x_)
 {
-    WRITE_string ( x_.name ) ;
+    WRITE_string(x_.name);
-    WRITE_TYPE_P ( x_.type ) ;
+    WRITE_TYPE_P(x_.type);
-    WRITE_string ( x_.value ) ;
+    WRITE_string(x_.value);
-    return ;
+    return;
 }
 #endif
-/* Disk writing routine for PTR ( UNION ) */
+/* Disk writing routine for PTR(UNION) */
 #ifndef WRITE_ptr_un
 static void WRITE_ptr_un
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( UNION ) x_ )
+(PTR(UNION) x_)
+{
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	UNION y_ ;
+	UNION y_;
-	DEREF_un ( x_, y_ ) ;
+	DEREF_un(x_, y_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_un ( y_ ) ;
+	WRITE_un(y_);
+    }
-    return ;
+    return;
 }
 #endif
 /* Disk writing routine for UNION */
 #ifndef WRITE_un
 static void WRITE_un
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( UNION x_ )
+(UNION x_)
+{
-    WRITE_CLASS_ID_P ( x_.id ) ;
+    WRITE_CLASS_ID_P(x_.id);
-    WRITE_UNION_P ( x_.base ) ;
+    WRITE_UNION_P(x_.base);
-    WRITE_list_COMPONENT_P ( x_.s_defn ) ;
+    WRITE_list_COMPONENT_P(x_.s_defn);
-    WRITE_list_FIELD_P ( x_.u_defn ) ;
+    WRITE_list_FIELD_P(x_.u_defn);
-    WRITE_list_MAP_P ( x_.map ) ;
+    WRITE_list_MAP_P(x_.map);
-    WRITE_int ( x_.no_fields ) ;
+    WRITE_int(x_.no_fields);
-    return ;
+    return;
+}
 #endif
-/* Disk writing routine for LIST ( PTR ( FIELD ) ) */
+/* Disk writing routine for LIST(PTR(FIELD)) */
 #ifndef WRITE_list_ptr_fld
 static void WRITE_list_ptr_fld
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( LIST ( PTR ( FIELD ) ) x_ )
+(LIST(PTR(FIELD)) x_)
 {
-    while ( !IS_NULL_list ( x_ ) ) {
+    while (!IS_NULL_list(x_)) {
-	PTR ( FIELD ) y_ ;
+	PTR(FIELD) y_;
-	y_ = DEREF_ptr ( HEAD_list ( x_ ) ) ;
+	y_ = DEREF_ptr(HEAD_list(x_));
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_ptr_fld ( y_ ) ;
+	WRITE_ptr_fld(y_);
-	x_ = TAIL_list ( x_ ) ;
+	x_ = TAIL_list(x_);
     }
-    WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+    WRITE_BITS(1, (unsigned)0);
-    return ;
+    return;
 }
 #endif
-/* Disk writing routine for PTR ( FIELD ) */
+/* Disk writing routine for PTR(FIELD) */
 #ifndef WRITE_ptr_fld
 static void WRITE_ptr_fld
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( FIELD ) x_ )
+(PTR(FIELD) x_)
+{
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	FIELD y_ ;
+	FIELD y_;
-	DEREF_fld ( x_, y_ ) ;
+	DEREF_fld(x_, y_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_fld ( y_ ) ;
+	WRITE_fld(y_);
     }
-    return ;
+    return;
 }
 #endif
 /* Disk writing routine for FIELD */
 #ifndef WRITE_fld
 static void WRITE_fld
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( FIELD x_ )
+(FIELD x_)
 {
-    WRITE_string ( x_.name ) ;
+    WRITE_string(x_.name);
-    WRITE_int ( x_.tag ) ;
+    WRITE_int(x_.tag);
-    WRITE_int ( x_.flag ) ;
+    WRITE_int(x_.flag);
-    WRITE_int ( x_.set ) ;
+    WRITE_int(x_.set);
-    WRITE_FIELD_P ( x_.base ) ;
+    WRITE_FIELD_P(x_.base);
-    WRITE_list_COMPONENT_P ( x_.defn ) ;
+    WRITE_list_COMPONENT_P(x_.defn);
-    return ;
+    return;
 }
 #endif
-/* Disk writing routine for LIST ( PTR ( MAP ) ) */
+/* Disk writing routine for LIST(PTR(MAP)) */
 #ifndef WRITE_list_ptr_map
 static void WRITE_list_ptr_map
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( LIST ( PTR ( MAP ) ) x_ )
+(LIST(PTR(MAP)) x_)
+{
-    while ( !IS_NULL_list ( x_ ) ) {
+    while (!IS_NULL_list(x_)) {
-	PTR ( MAP ) y_ ;
+	PTR(MAP) y_;
-	y_ = DEREF_ptr ( HEAD_list ( x_ ) ) ;
+	y_ = DEREF_ptr(HEAD_list(x_));
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_ptr_map ( y_ ) ;
+	WRITE_ptr_map(y_);
-	x_ = TAIL_list ( x_ ) ;
+	x_ = TAIL_list(x_);
+    }
-    WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+    WRITE_BITS(1, (unsigned)0);
-    return ;
+    return;
+}
 #endif
-/* Disk writing routine for PTR ( MAP ) */
+/* Disk writing routine for PTR(MAP) */
 #ifndef WRITE_ptr_map
 static void WRITE_ptr_map
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( MAP ) x_ )
+(PTR(MAP) x_)
 {
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	MAP y_ ;
+	MAP y_;
-	DEREF_map ( x_, y_ ) ;
+	DEREF_map(x_, y_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_map ( y_ ) ;
+	WRITE_map(y_);
     }
-    return ;
+    return;
+}
 #endif
 /* Disk writing routine for MAP */
 #ifndef WRITE_map
 static void WRITE_map
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( MAP x_ )
+(MAP x_)
 {
-    WRITE_string ( x_.name ) ;
+    WRITE_string(x_.name);
-    WRITE_int ( x_.flag ) ;
+    WRITE_int(x_.flag);
-    WRITE_TYPE_P ( x_.ret_type ) ;
+    WRITE_TYPE_P(x_.ret_type);
-    WRITE_list_ARGUMENT_P ( x_.args ) ;
+    WRITE_list_ARGUMENT_P(x_.args);
-    return ;
+    return;
 }
 #endif
-/* Disk writing routine for LIST ( PTR ( ARGUMENT ) ) */
+/* Disk writing routine for LIST(PTR(ARGUMENT)) */
 #ifndef WRITE_list_ptr_arg
 static void WRITE_list_ptr_arg
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( LIST ( PTR ( ARGUMENT ) ) x_ )
+(LIST(PTR(ARGUMENT)) x_)
 {
-    while ( !IS_NULL_list ( x_ ) ) {
+    while (!IS_NULL_list(x_)) {
-	PTR ( ARGUMENT ) y_ ;
+	PTR(ARGUMENT) y_;
-	y_ = DEREF_ptr ( HEAD_list ( x_ ) ) ;
+	y_ = DEREF_ptr(HEAD_list(x_));
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_ptr_arg ( y_ ) ;
+	WRITE_ptr_arg(y_);
-	x_ = TAIL_list ( x_ ) ;
+	x_ = TAIL_list(x_);
     }
-    WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+    WRITE_BITS(1, (unsigned)0);
-    return ;
+    return;
 }
 #endif
-/* Disk writing routine for PTR ( ARGUMENT ) */
+/* Disk writing routine for PTR(ARGUMENT) */
 #ifndef WRITE_ptr_arg
 static void WRITE_ptr_arg
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( PTR ( ARGUMENT ) x_ )
+(PTR(ARGUMENT) x_)
+{
-    if ( IS_NULL_ptr ( x_ ) ) {
+    if (IS_NULL_ptr(x_)) {
-	WRITE_BITS ( 1, ( unsigned ) 0 ) ;
+	WRITE_BITS(1, (unsigned)0);
     } else {
-	ARGUMENT y_ ;
+	ARGUMENT y_;
-	DEREF_arg ( x_, y_ ) ;
+	DEREF_arg(x_, y_);
-	WRITE_BITS ( 1, ( unsigned ) 1 ) ;
+	WRITE_BITS(1, (unsigned)1);
-	WRITE_arg ( y_ ) ;
+	WRITE_arg(y_);
+    }
-    return ;
+    return;
+}
 #endif
 /* Disk writing routine for ARGUMENT */
 #ifndef WRITE_arg
 static void WRITE_arg
-    PROTO_N ( ( x_ ) )
-    PROTO_T ( ARGUMENT x_ )
+(ARGUMENT x_)
+{
-    WRITE_string ( x_.name ) ;
+    WRITE_string(x_.name);
-    WRITE_TYPE_P ( x_.type ) ;
+    WRITE_TYPE_P(x_.type);
-    return ;
+    return;
+}
 #endif

Subversion Repositories tendra.SVN

(root)/trunk/src/utilities/calculus/write_def.h – Rev 2 → 7