WebSVN – tendra.SVN – Diff – /branches/tendra5/src/installers/680x0/common/tests.c

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1996
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
     supported, but the cc conventions are default on the HP.  NeXT
     cc is gcc.
 */
 #ifdef hp_cc_conventions
-int cc_conventions = 1 ;
+int cc_conventions = 1;
 #else
-int cc_conventions = 0 ;
+int cc_conventions = 0;
 #endif
-bool reused_parameter
+bool
-    PROTO_N ( ( e ) )
-    PROTO_T ( exp e )
+reused_parameter(exp e)
+{
-   bool reused = 0 ;
+	bool reused = 0;
-   exp def, ident_exp ;
+	exp def, ident_exp;
-   def = son ( e ) ;
+	def = son(e);
-   if ( name ( def ) == name_tag ) {
+	if (name(def) == name_tag) {
-      ident_exp = son ( def ) ;
+		ident_exp = son(def);
-      if ( ! isvar ( ident_exp ) ) {
+		if (! isvar(ident_exp)) {
-         /* This an obtain_tag of a parameter */
+			/* This an obtain_tag of a parameter */
-         if ( name( son( ident_exp ) ) == formal_callee_tag) {
+			if (name(son(ident_exp)) == formal_callee_tag) {
-            reused = cur_proc_use_same_callees ;
+				reused = cur_proc_use_same_callees;
-         }
+			}
-         else {
+			else {
-            /* caller parameter */
+				/* caller parameter */
-            reused = cur_proc_has_tail_call ;
+				reused = cur_proc_has_tail_call;
-         }
+			}
-      }
+		}
-   }
+	}
-   return reused ;
+	return reused;
+}
 /*
     CAN THE VALUE OF AN EXPRESSION BE PUT INTO A REGISTER?
     This routine returns 1 if the expression e can be put into a register.
     It has to have its visible flag false, and to be of a suitable shape.
 */
-bool regable
+bool
-    PROTO_N ( ( e ) )
-    PROTO_T ( exp e )
+regable(exp e)
+{
-    shape sha ;
+	shape sha;
-    char n ;
+	char n;
-    long sz ;
+	long sz;
-    if ( isvis ( e ) ) return ( 0 ) ;
+	if (isvis(e)) {
+		return (0);
+	}
-    sha = sh ( son ( e ) ) ;
+	sha = sh(son(e));
-    n = name ( sha ) ;
+	n = name(sha);
-    if ( n == realhd || n == doublehd ) return ( 1 ) ;
+	if (n == realhd || n == doublehd) {
+		return (1);
+	}
-    sz = shape_size ( sha ) ;
+	sz = shape_size(sha);
-    return ( n != cpdhd && n != nofhd && sz <= 32 ) ;
+	return (n != cpdhd && n != nofhd && sz <= 32);
+}
 /*
     DOES AN EXP HAVE NO SIDE EFFECTS?
     This routine returns 1 if e has no side effects.
 */
-bool no_side
+bool
-    PROTO_N ( ( e ) )
-    PROTO_T ( exp e )
+no_side(exp e)
 {
-    int n = name ( e ) ;
+	int n = name(e);
-    if ( n == ident_tag ) {
+	if (n == ident_tag) {
-	return ( no_side ( son ( e ) ) && (no_side ( bro ( son ( e ) ) ) ) ) ;
+		return (no_side(son(e)) && (no_side(bro(son(e)))));
-    }
+	}
-    return ( is_a ( n ) || n == test_tag ||
-	     n == ass_tag || n == testbit_tag ) ;
+	return (is_a(n) || n == test_tag || n == ass_tag || n == testbit_tag);
 }
-    char n ;
+    char n;
 /*
     IS AN EXP A PUSHABLE PROCEDURE ARGUMENT?
     Can the expression e be pushed directly onto the stack when it is
     the parameter of a procedure?
 */
-bool push_arg
+bool
-    PROTO_N ( ( e ) )
-    PROTO_T ( exp e )
+push_arg(exp e)
+{
-    unsigned char n = name ( e ) ;
+	unsigned char n = name(e);
-    if ( is_a ( n ) ) return ( 1 ) ;
+	if (is_a(n)) {
+		return (1);
+	}
-    if ( n == apply_tag || n == apply_general_tag ) return ( reg_result ( sh ( e ) ) ) ;
+	if (n == apply_tag || n == apply_general_tag) {
+		return (reg_result(sh(e)));
+	}
-    if ( n == ident_tag ) {
+	if (n == ident_tag) {
-	return ( push_arg ( son ( e ) ) && push_arg ( bro ( son ( e ) ) ) ) ;
+		return (push_arg(son(e)) && push_arg(bro(son(e))));
-    }
+	}
-    return ( 0 ) ;
+	return (0);
+}
 #if 0
 #ifndef PTR_VOID_MIN
 #define PTR_VOID_MIN	10
 #endif
-bool is_ptr_void
+bool
-    PROTO_N ( ( sha ) )
-    PROTO_T ( shape sha )
+is_ptr_void(shape sha)
+{
-    bool go ;
+	bool go;
-    int ptrs = 0 ;
+	int ptrs = 0;
-    exp t = son ( sha ) ;
+	exp t = son(sha);
-    if ( t == nilexp ) return ( 0 ) ;
+	if (t == nilexp) {
+		return (0);
+	}
-    do {
+	do {
-	go = ( last ( t ) ? 0 : 1 ) ;
+		go = (last(t) ? 0 : 1);
-	if ( name ( sh ( t ) ) != ptrhd ) return ( 0 ) ;
+		if (name(sh(t)) != ptrhd) {
+			return (0);
+		}
-	ptrs++ ;
+		ptrs++;
-	t = bro ( t ) ;
+		t = bro(t);
-    } while ( go ) ;
+	} while (go);
-    if ( ptrs < PTR_VOID_MIN ) return ( 0 ) ;
+	if (ptrs < PTR_VOID_MIN) {
+		return (0);
+	}
 #ifdef PTR_VOID_MAX
-    if ( ptrs > PTR_VOID_MAX ) return ( 0 ) ;
+	if (ptrs > PTR_VOID_MAX) {
+		return (0);
+	}
 #endif
-    return ( 1 ) ;
+	return (1);
+}
 #endif
     This routine is designed to test whether a given shape is compound,
     and thus likely to cause problems when it is the parameter of a
     procedure.
 */
-bool cpd_param
+bool
-    PROTO_N ( ( sha ) )
-    PROTO_T ( shape sha )
+cpd_param(shape sha)
+{
-    char n = name ( sha ) ;
+	char n = name(sha);
-    if ( !cc_conventions || n == bitfhd ) {
+	if (!cc_conventions || n == bitfhd) {
-	long sz = shape_size ( sha ) ;
+		long sz = shape_size(sha);
-	if ( sz <= 32 ) return ( 0 ) ;
+		if (sz <= 32) {
+			return (0);
-    }
+		}
-    return ( n == cpdhd || n == nofhd || n == bitfhd
+	}
-            || n == s64hd || n == u64hd
+	return (n == cpdhd || n == nofhd || n == bitfhd || n == s64hd ||
-            ) ;
+		n == u64hd);
+}
 /*
     DOES A PROCEDURE RETURN A RESULT OF A GIVEN SHAPE IN A REGISTER?
     register.  This routine works out whether or not a procedure
     delivering a result of shape sha will use the first method.
 */
-int reg_result
+int
-    PROTO_N ( ( sha ) )
-    PROTO_T ( shape sha )
+reg_result(shape sha)
+{
-    char n = name ( sha ) ;
+	char n = name(sha);
-    if ( cc_conventions ) {
+	if (cc_conventions) {
-	/* HP cc doesn't return any tuples, unions etc in a register */
+		/* HP cc doesn't return any tuples, unions etc in a register */
-	return ( n != cpdhd && n != nofhd ) ;
+		return (n != cpdhd && n != nofhd);
-    } else {
+	} else {
-	/* Return anything of size <= 32 or 64 in a register */
+		/* Return anything of size <= 32 or 64 in a register */
-	long sz = shape_size ( sha ) ;
+		long sz = shape_size(sha);
-	return ( sz <= 32 || sz == 64 ) ;
+		return (sz <= 32 || sz == 64);
-    }
+	}
+}
 /*
     IS A SHAPE OF VARIABLE SIZE?
     This routine returns 1 if sha involves an array.
 */
-bool varsize
+bool
-    PROTO_N ( ( sha ) )
-    PROTO_T ( shape sha )
+varsize(shape sha)
+{
-    return ( name ( sha ) == nofhd ? 1 : 0 ) ;
+	return (name(sha) == nofhd ? 1 : 0);
+}
 #if 0
 Use is_signed macro instead
     This routine returns 1 if the integer variety shape sha is signed
     and 0 otherwise.
 */
-bool issigned
+bool
-    PROTO_N ( ( sha ) )
-    PROTO_T ( shape sha )
+issigned(shape sha)
+{
-    char n = name ( sha ) ;
+	char n = name(sha);
-    if ( n == ucharhd || n == uwordhd || n == ulonghd ) return ( 0 ) ;
+	if (n == ucharhd || n == uwordhd || n == ulonghd) {
+		return (0);
+	}
-    return ( 1 ) ;
+	return (1);
+}
 #endif
 /*
     CHECK ON DECLARATION FOR PARAMETER SUBSTITUTION
     This routine checks if the declaration e should be substituted
     for all its uses or not.
 */
-int do_sub_params = 1 ;
+int do_sub_params = 1;
-int check_anyway
+int
-    PROTO_N ( ( e ) )
-    PROTO_T ( exp e )
+check_anyway(exp e)
+{
 #ifndef tdf3
-   return 0 ;
+	return 0;
 #else
-    if ( do_sub_params ) {
+	if (do_sub_params) {
-	setmarked ( e ) ;
+		setmarked(e);
-	if ( no ( e ) > 2 ) return ( 1 ) ;
+		if (no(e) > 2) {
+			return (1);
-    }
+		}
+	}
-    return ( 0 ) ;
+	return (0);
 #endif
+}
 /*
     IS IT WORTH EXTRACTING A CONSTANT?
 */
-int is_worth
+int
-    PROTO_N ( ( c ) )
-    PROTO_T ( exp c )
+is_worth(exp c)
+{
-  unsigned char cnam = name ( c ) ;
+	unsigned char cnam = name(c);
-  return ( ( !is_o ( cnam ) && cnam != clear_tag ) ||
+	return ((!is_o(cnam) && cnam != clear_tag) ||
-      /* ignore simple things unless ... */
+		/* ignore simple things unless ... */
-      ( cnam == cont_tag && name ( son ( c ) ) == cont_tag &&
+		(cnam == cont_tag && name(son(c)) == cont_tag &&
-	name ( son ( son ( c ) ) )  == name_tag ) ||
+		 name(son(son(c))) == name_tag) ||
-      ( cnam == name_tag && isparam ( son ( c ) ) && !isvar ( son ( c ) ) &&
+		(cnam == name_tag && isparam(son(c)) && !isvar(son(c)) &&
-	shape_size ( sh ( c ) ) <= 32 && name ( sh ( c ) ) != shrealhd ) ) ;
+		 shape_size(sh(c)) <= 32 && name(sh(c)) != shrealhd));
+}

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/installers/680x0/common/tests.c – Rev 5 → 6