WebSVN – tendra.SVN – Diff – /branches/tendra5/src/installers/common/construct/case_opt.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) 1997
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
 #ifndef max_jump_table_size
 #define max_jump_table_size 100
 #endif
 #ifndef min_no_of_default_destinations
 #define min_no_of_default_destinations 3
 #endif
-static int density PROTO_S ( ( exp *, int, int, int ) ) ;
+static int density(exp *, int, int, int);
-static exp exhaustive_conditional_maker PROTO_S ( ( int, int, exp ) ) ;
+static exp exhaustive_conditional_maker(int, int, exp);
-static exp inexhaustive_conditional_maker PROTO_S ( ( int, int, exp, exp ) ) ;
+static exp inexhaustive_conditional_maker(int, int, exp, exp);
-static exp set_up_sequence PROTO_S ( ( exp, exp, ntest, int, exp, int ) ) ;
+static exp set_up_sequence(exp, exp, ntest, int, exp, int);
-static exp set_up_assign PROTO_S ( ( exp, int ) ) ;
+static exp set_up_assign(exp, int);
-static exp set_up_unsigned_test PROTO_S ( ( exp, exp, int, ntest ) ) ;
+static exp set_up_unsigned_test(exp, exp, int, ntest);
-static exp like_me_q1 PROTO_S ( ( int, ntest, exp, exp, exp, unsigned char ) ) ;
+static exp like_me_q1(int, ntest, exp, exp, exp, unsigned char);
 /* VARIABLES */
 static int  no_of_nodes;
-static  exp * node_start;
+static exp *node_start;
-static  exp * node_end;
+static exp *node_end;
 static double *node_weight;
 static unsigned char *node_start_flag;
 static unsigned char *node_end_flag;
 /* PROCEDURES */
 /*
  * case_optimisation takes a case_tag and an ident_tag and
  * splits up the case_tag into parts which it thinks should
  * be done as jump tables.
  */
-exp case_optimisation
+exp
-    PROTO_N ( (body, id, shape_of_case, control_expression) )
-    PROTO_T ( exp body X exp id X shape shape_of_case X exp control_expression )
+case_optimisation(exp body, exp id, shape shape_of_case, exp control_expression)
 {
-  exp t;
+	exp t;
-  exp * ELEMENTS;
+	exp *ELEMENTS;
-  int   i;
+	int i;
-  int   n;
+	int n;
-  int   no_of_cases = 1;
+	int no_of_cases = 1;
-  int jump_table_present = 0;
+	int jump_table_present = 0;
-  no_of_nodes = 0;
+	no_of_nodes = 0;
-  /* Calculate the number of cases in the case_tag */
+	/* Calculate the number of cases in the case_tag */
-  t = body;
+	t = body;
-  while (!last (t)) {
+	while (!last(t)) {
-    no_of_cases = no_of_cases + 1;
+		no_of_cases = no_of_cases + 1;
-    t = bro (t);
+		t = bro(t);
-  }
+	}
-  ELEMENTS = (exp *) xcalloc (no_of_cases, sizeof (exp));
+	ELEMENTS = (exp *)xcalloc(no_of_cases, sizeof(exp));
-  node_start = (exp *) xcalloc (no_of_cases, sizeof (exp));
+	node_start = (exp *)xcalloc(no_of_cases, sizeof(exp));
-  node_end = (exp *) xcalloc (no_of_cases, sizeof (exp));
+	node_end = (exp *)xcalloc(no_of_cases, sizeof(exp));
-  node_weight = (double *) xcalloc (no_of_cases, sizeof (double));
+	node_weight = (double *)xcalloc(no_of_cases, sizeof(double));
-  /* Set up the values of these arrays * First set up the ELEMENTS array
+	/* Set up the values of these arrays * First set up the ELEMENTS array
-  */
+	 */
-  t = body;
+	t = body;
-  for (i = 0; i < no_of_cases; i++) {
+	for (i = 0; i < no_of_cases; i++) {
-    ELEMENTS[i] = t;
+		ELEMENTS[i] = t;
-    t = bro (t);
+		t = bro(t);
-  }
+	}
-  n = 0;
+	n = 0;
-  /* Calculation of where should do jump tables * This sets up the arrays
+	/* Calculation of where should do jump tables * This sets up the arrays
-     node_weight, node_start and node_end */
+	   node_weight, node_start and node_end */
-  while (n < no_of_cases) {
+	while (n < no_of_cases) {
-    int   z;
+		int z;
-    double   node_weight_sum = 0.0;
+		double node_weight_sum = 0.0;
-    i = no_of_cases - 1;
+		i = no_of_cases - 1;
+		while (density(ELEMENTS, n, i,
-    while (density (ELEMENTS, n, i, is_signed(sh(control_expression)))
+			       is_signed(sh(control_expression)))
-		 < jump_table_density)
+		       < jump_table_density) {
-    {
-      i--;
+			i--;
-    }
+		}
-    for (z = n; z <= i; z++) {
+		for (z = n; z <= i; z++) {
-      if (son (ELEMENTS[z]) != nilexp) {
+			if (son(ELEMENTS[z]) != nilexp) {
-	if (is_signed(sh(control_expression)))
+				if (is_signed(sh(control_expression))) {
+					node_weight_sum +=
-	  node_weight_sum += ((double) no (son (ELEMENTS[z]))
+					    ((double)no(son(ELEMENTS[z])) -
-			      - (double) no (ELEMENTS[z]));
+					     (double)no(ELEMENTS[z]));
-	else
+				} else {
+					node_weight_sum +=
-	  node_weight_sum += ((double) (unsigned long) no (son (ELEMENTS[z]))
+					    ((double)(unsigned long)no(son(ELEMENTS[z]))
-			      - (double) (unsigned long) no (ELEMENTS[z]));
+					     - (double)(unsigned long)no(ELEMENTS[z]));
-      }
+				}
+			}
-      node_weight_sum += 1.0;
+			node_weight_sum += 1.0;
-    }
+		}
-    if (node_weight_sum < (double) min_jump_table_size)
+		if (node_weight_sum < (double)min_jump_table_size) {
-    {
-      i = n;
+			i = n;
-    }
+		}
-    if (node_weight_sum > (double) max_jump_table_size)
+		if (node_weight_sum > (double)max_jump_table_size) {
-    {
-      i=n;
+			i=n;
-    }
+		}
-    if ((i - n) < min_no_of_default_destinations)
+		if ((i - n) < min_no_of_default_destinations) {
-    {
-      i = n;
+			i = n;
-    }
+		}
-    /* Lump together into a jump_table or a single * Sets up the
+		/* Lump together into a jump_table or a single * Sets up the
-       node_start pointers */
+		   node_start pointers */
-    node_start[no_of_nodes] = ELEMENTS[n];
+		node_start[no_of_nodes] = ELEMENTS[n];
-    /* Sets up the node_end pointers */
+		/* Sets up the node_end pointers */
-    node_end[no_of_nodes] = (son (ELEMENTS[i]) == nilexp
+		node_end[no_of_nodes] = (son(ELEMENTS[i]) == nilexp
-      ? ELEMENTS[i]
-      : son (ELEMENTS[i]));
+					 ? ELEMENTS[i] : son(ELEMENTS[i]));
-    /* sets up the node_weight of the node */
+		/* sets up the node_weight of the node */
-    node_weight[no_of_nodes] = 0.0;
+		node_weight[no_of_nodes] = 0.0;
-    for (z = n; z <= i; z++) {
+		for (z = n; z <= i; z++) {
-      if (son (ELEMENTS[z]) != nilexp) {
+			if (son(ELEMENTS[z]) != nilexp) {
-	if (is_signed(sh(control_expression)))
+				if (is_signed(sh(control_expression))) {
+					node_weight[no_of_nodes] +=
-	  node_weight[no_of_nodes] += ((double) no (son (ELEMENTS[z]))
+					    ((double)no(son(ELEMENTS[z])) -
-				       - (double) no (ELEMENTS[z]));
+					     (double)no(ELEMENTS[z]));
-        else
+				} else {
+					node_weight[no_of_nodes] +=
-	  node_weight[no_of_nodes] += ((double) (unsigned long) no (son (ELEMENTS[z]))
+					    ((double)(unsigned long)no(son(ELEMENTS[z])) -
-				       - (double) (unsigned long) no (ELEMENTS[z]));
+					     (double)(unsigned long)no(ELEMENTS[z]));
-      }
+				}
+			}
-      node_weight[no_of_nodes] += 1.0;
+			node_weight[no_of_nodes] += 1.0;
-    }
+		}
-    if (n != i)
+		if (n != i) {
-    {
-      jump_table_present = 1;
+			jump_table_present = 1;
-    }
+		}
-    no_of_nodes = no_of_nodes + 1;
+		no_of_nodes = no_of_nodes + 1;
-    bro (ELEMENTS[i]) = nilexp;
+		bro(ELEMENTS[i]) = nilexp;
-    /* Chops up the list for later use */
+		/* Chops up the list for later use */
-    setlast (ELEMENTS[i]);
+		setlast(ELEMENTS[i]);
-    /* Sets the last of ELEMENTS[i] so can be substituted directly into
+		/* Sets the last of ELEMENTS[i] so can be substituted directly into
-       new case_tag's */
+		   new case_tag's */
-    n = i + 1;
+		n = i + 1;
-  }
+	}
 #if has_byte_ops
-  if (!jump_table_present) {
+	if (!jump_table_present) {
-    kill_exp(son(id), son(id));
+		kill_exp(son(id), son(id));
-    son(id) = control_expression;
+		son(id) = control_expression;
-    sh(id) = sh(control_expression);
+		sh(id) = sh(control_expression);
-    t = body;
+		t = body;
-    for (;;) {
+		for (;;) {
-      sh(t) = sh(control_expression);
+			sh(t) = sh(control_expression);
-      if (son(t) != nilexp)
+			if (son(t) != nilexp) {
-	sh(son(t)) = sh(control_expression);
+				sh(son(t)) = sh(control_expression);
+			}
-      if (last(t))
+			if (last(t)) {
-	break;
+				break;
-    }
+			}
-  }
+		}
-  else {
+	} else {
-    kill_exp(control_expression, control_expression);
+		kill_exp(control_expression, control_expression);
-  }
+	}
 #else
-  kill_exp(control_expression, control_expression);
+	kill_exp(control_expression, control_expression);
-  UNUSED(jump_table_present);
+	UNUSED(jump_table_present);
 #endif
-  /* Set up the node_start_flag and node_end_flag arrays */
+	/* Set up the node_start_flag and node_end_flag arrays */
-  node_start_flag =
+	node_start_flag =
-    (unsigned char *) xcalloc (no_of_nodes, sizeof (unsigned char));
+	    (unsigned char *)xcalloc(no_of_nodes, sizeof(unsigned char));
-  node_end_flag =
+	node_end_flag =
-    (unsigned char *) xcalloc (no_of_nodes, sizeof (unsigned char));
+	    (unsigned char *)xcalloc(no_of_nodes, sizeof(unsigned char));
-  for (i=0; i < no_of_nodes; i++) {
+	for (i=0; i < no_of_nodes; i++) {
-    node_start_flag[i] = node_end_flag[i] = 0;
+		node_start_flag[i] = node_end_flag[i] = 0;
-  }
+	}
-  if (shape_of_case == f_bottom)
+	if (shape_of_case == f_bottom) {
-  {
-    t = exhaustive_conditional_maker (0, no_of_nodes - 1, id);
+		t = exhaustive_conditional_maker(0, no_of_nodes - 1, id);
-  }
+	}
-  if (shape_of_case == f_top) {
+	if (shape_of_case == f_top) {
-    exp COND__TAG;
+		exp COND__TAG;
-    exp LABST__TAG;
+		exp LABST__TAG;
-    exp TOP__TAG;
+		exp TOP__TAG;
-    exp CLEAR__TAG;
+		exp CLEAR__TAG;
-    TOP__TAG = getexp (f_top, nilexp, 0, nilexp, nilexp, 0, 0, top_tag);
+		TOP__TAG = getexp(f_top, nilexp, 0, nilexp, nilexp, 0, 0,
+				  top_tag);
-    CLEAR__TAG = getexp (f_top, nilexp, 0, nilexp, nilexp,
+		CLEAR__TAG = getexp(f_top, nilexp, 0, nilexp, nilexp, 0, 0,
-, 0, clear_tag);
+				    clear_tag);
-    LABST__TAG = me_b3 (sh (TOP__TAG), CLEAR__TAG, TOP__TAG, labst_tag);
+		LABST__TAG = me_b3(sh(TOP__TAG), CLEAR__TAG, TOP__TAG,
+				   labst_tag);
-    t = inexhaustive_conditional_maker (0, no_of_nodes - 1, id,
+		t = inexhaustive_conditional_maker(0, no_of_nodes - 1, id,
-	LABST__TAG);
+						   LABST__TAG);
-    COND__TAG = me_b3 (f_top, t, LABST__TAG, cond_tag);
+		COND__TAG = me_b3(f_top, t, LABST__TAG, cond_tag);
-    t = COND__TAG;
+		t = COND__TAG;
-  }
+	}
-  xfree ((void*)ELEMENTS);
+	xfree((void*)ELEMENTS);
-  xfree ((void*)node_start);
+	xfree((void*)node_start);
-  xfree ((void*)node_end);
+	xfree((void*)node_end);
-  xfree ((void*)node_weight);
+	xfree((void*)node_weight);
-  xfree ((void*)node_start_flag);
+	xfree((void*)node_start_flag);
-  xfree ((void*)node_end_flag);
+	xfree((void*)node_end_flag);
-  return t;
+	return t;
 }
 /*
  * density is used for calculating whether the elements of the
  * case_tag should be made into jump tables.
  */
-static int   density
+static int
-    PROTO_N ( (ELEMENTS, start, end, sgn) )
-    PROTO_T ( exp * ELEMENTS X int start X int end X int sgn )
+density(exp *ELEMENTS, int start, int end, int sgn)
+{
-  int   index;
+	int index;
-  double numerator;
+	double numerator;
-  double denominator;
+	double denominator;
-  if (son (ELEMENTS[end]) == nilexp)
+	if (son(ELEMENTS[end]) == nilexp) {
-  {
-    if (sgn)
+		if (sgn) {
-      denominator = (double) no (ELEMENTS[end]) - (double) no (ELEMENTS[start]);
+			denominator = (double)no(ELEMENTS[end]) -
+			    (double)no(ELEMENTS[start]);
-    else
+		} else {
-      denominator = (double) (unsigned long) no (ELEMENTS[end])
+			denominator = (double)(unsigned long)no(ELEMENTS[end]) -
-	- (double) (unsigned long) no (ELEMENTS[start]);
+			    (double)(unsigned long)no(ELEMENTS[start]);
-  }
+		}
-  else
+	} else {
-  {
-    if (sgn)
+		if (sgn) {
-      denominator = (double) no (son (ELEMENTS[end])) - (double) no (ELEMENTS[start]);
+			denominator = (double)no(son(ELEMENTS[end])) -
+			    (double)no(ELEMENTS[start]);
-    else
+		} else {
+			denominator =
-      denominator = (double) (unsigned long) no (son (ELEMENTS[end]))
+			    (double)(unsigned long)no(son(ELEMENTS[end])) -
-	- (double) (unsigned long) no (ELEMENTS[start]);
+			    (double)(unsigned long)no(ELEMENTS[start]);
-  }
+		}
+	}
-  denominator = denominator + 1.0;
+	denominator = denominator + 1.0;
-  numerator = 0.0;
+	numerator = 0.0;
-  for (index = start; index <= end; index++) {
+	for (index = start; index <= end; index++) {
-    if (son (ELEMENTS[index]) == nilexp)
+		if (son(ELEMENTS[index]) == nilexp) {
-    {
-      numerator = numerator + 1.0;
+			numerator = numerator + 1.0;
-    }
-    else
+		} else {
-    {
+			if (sgn) {
-      if (sgn)
+				numerator = numerator +
-	numerator = numerator + ((double) no (son (ELEMENTS[index]))
+				    ((double)no(son(ELEMENTS[index])) -
-				 - (double) no (ELEMENTS[index])) + 1.0;
+				     (double)no(ELEMENTS[index])) + 1.0;
-      else
+			} else {
+				numerator = numerator +
-	numerator = numerator + ((double) (unsigned long) no (son (ELEMENTS[index]))
+				    ((double)(unsigned long)no(son(ELEMENTS[index])) -
-				 - (double) (unsigned long) no (ELEMENTS[index])) + 1.0;
+				     (double)(unsigned long)no(ELEMENTS[index])) + 1.0;
-    }
+			}
-  }
+		}
+	}
-  return ((int) (100.0*(numerator/denominator)));
+	return((int)(100.0 * (numerator / denominator)));
+}
 /*
  * set_up_sequence creates a simple sequence with a
  * test_tag.
  */
-static exp set_up_sequence
+static exp
-    PROTO_N ( (left, right, test, integer_value, id, probability) )
+set_up_sequence(exp left, exp right, ntest test, int integer_value, exp id,
-    PROTO_T ( exp left X exp right X ntest test X int integer_value X exp id X int probability )
+		int probability)
 {
-  exp SEQ__TAG;
+	exp SEQ__TAG;
-  exp ZERO__TAG;
+	exp ZERO__TAG;
-  exp TEST__TAG;
+	exp TEST__TAG;
-  exp NAME__TAG;
+	exp NAME__TAG;
-  exp VAL__TAG;
+	exp VAL__TAG;
-  exp CONT__TAG;
+	exp CONT__TAG;
-  /* sets up the test_tag                      */
+	/* sets up the test_tag */
-  NAME__TAG = me_obtain (id);
+	NAME__TAG = me_obtain(id);
-  CONT__TAG = me_u3 (sh (id), NAME__TAG, cont_tag);
+	CONT__TAG = me_u3(sh(id), NAME__TAG, cont_tag);
-  VAL__TAG = me_shint (sh (CONT__TAG), integer_value);
+	VAL__TAG = me_shint(sh(CONT__TAG), integer_value);
-  TEST__TAG = like_me_q1 (probability, test, right, CONT__TAG,
+	TEST__TAG = like_me_q1(probability, test, right, CONT__TAG, VAL__TAG,
-      VAL__TAG, test_tag);
+			       test_tag);
-  /* sets up the seq_tag for the conditional   */
+	/* sets up the seq_tag for the conditional */
-  ZERO__TAG = me_u3 (f_top, TEST__TAG, 0);
+	ZERO__TAG = me_u3(f_top, TEST__TAG, 0);
-  SEQ__TAG = me_b3 (sh (left), ZERO__TAG, left, seq_tag);
+	SEQ__TAG = me_b3(sh(left), ZERO__TAG, left, seq_tag);
-  return SEQ__TAG;
+	return SEQ__TAG;
 }
 /*
  * set_up_conditional creates a conditional based on a simple
  * integer test.
  */
-static exp set_up_conditional
+static exp
-    PROTO_N ( (left, right, test, integer_value, id, probability) )
+set_up_conditional(exp left, exp right, ntest test, int integer_value, exp id,
-    PROTO_T ( exp left X exp right X ntest test X int integer_value X exp id X int probability )
+		   int probability)
 {
-  exp CLEAR__TAG;
+	exp CLEAR__TAG;
-  exp LABST__TAG;
+	exp LABST__TAG;
-  exp NAME__TAG;
+	exp NAME__TAG;
-  exp VAL__TAG;
+	exp VAL__TAG;
-  exp TEST__TAG;
+	exp TEST__TAG;
-  exp ZERO__TAG;
+	exp ZERO__TAG;
-  exp SEQ__TAG;
+	exp SEQ__TAG;
-  exp COND__TAG;
+	exp COND__TAG;
-  exp CONT__TAG;
+	exp CONT__TAG;
-  /* Sets up the labst_tag for the conditional */
+	/* Sets up the labst_tag for the conditional */
-  CLEAR__TAG = getexp (f_top, nilexp, 0, nilexp, nilexp, 0, 0, clear_tag);
+	CLEAR__TAG = getexp(f_top, nilexp, 0, nilexp, nilexp, 0, 0, clear_tag);
-  LABST__TAG = me_b3 (sh (right), CLEAR__TAG, right, labst_tag);
+	LABST__TAG = me_b3(sh(right), CLEAR__TAG, right, labst_tag);
-  /* sets up the test_tag                      */
+	/* sets up the test_tag */
-  NAME__TAG = me_obtain (id);
+	NAME__TAG = me_obtain(id);
-  CONT__TAG = me_u3 (sh (id), NAME__TAG, cont_tag);
+	CONT__TAG = me_u3(sh(id), NAME__TAG, cont_tag);
-  VAL__TAG = me_shint (sh (CONT__TAG), integer_value);
+	VAL__TAG = me_shint(sh(CONT__TAG), integer_value);
-  TEST__TAG = like_me_q1 (probability, test, LABST__TAG,
+	TEST__TAG = like_me_q1(probability, test, LABST__TAG, CONT__TAG,
-      CONT__TAG, VAL__TAG, test_tag);
+			       VAL__TAG, test_tag);
-  /* sets up the seq_tag for the conditional   */
+	/* sets up the seq_tag for the conditional */
-  ZERO__TAG = me_u3 (f_top, TEST__TAG, 0);
+	ZERO__TAG = me_u3(f_top, TEST__TAG, 0);
-  SEQ__TAG = me_b3 (sh (left), ZERO__TAG, left, seq_tag);
+	SEQ__TAG = me_b3(sh(left), ZERO__TAG, left, seq_tag);
-  /* sets up the cond_tag                      */
+	/* sets up the cond_tag */
-  COND__TAG = me_b3 (f_bottom, SEQ__TAG, LABST__TAG, cond_tag);
+	COND__TAG = me_b3(f_bottom, SEQ__TAG, LABST__TAG, cond_tag);
-  return COND__TAG;
+	return COND__TAG;
 }
 /*
  * set_up_exhaustive_case does exactly what it suggests.
  */
-static exp set_up_exhaustive_case
+static exp
-    PROTO_N ( (body_of_case, id) )
-    PROTO_T ( exp body_of_case X exp id )
+set_up_exhaustive_case(exp body_of_case, exp id)
+{
-  exp NAME__TAG;
+	exp NAME__TAG;
-  exp CASE__TAG;
+	exp CASE__TAG;
-  exp CONT__TAG;
+	exp CONT__TAG;
-  exp r;
+	exp r;
-  NAME__TAG = me_obtain (id);
+	NAME__TAG = me_obtain(id);
-  CONT__TAG = me_u3 (sh (id), NAME__TAG, cont_tag);
+	CONT__TAG = me_u3(sh(id), NAME__TAG, cont_tag);
-  CASE__TAG = getexp (f_bottom, nilexp, 0, CONT__TAG, nilexp,
+	CASE__TAG = getexp(f_bottom, nilexp, 0, CONT__TAG, nilexp, 0, 0,
-, 0, case_tag);
+			   case_tag);
-  bro (CONT__TAG) = body_of_case;
+	bro(CONT__TAG) = body_of_case;
-  clearlast (CONT__TAG);
+	clearlast(CONT__TAG);
-  r = body_of_case;
+	r = body_of_case;
-  while (!last (r))
+	while (!last(r)) {
-  {
-    r = bro (r);
+		r = bro(r);
-  }
+	}
-  bro (r) = CASE__TAG;
+	bro(r) = CASE__TAG;
-  return CASE__TAG;
+	return CASE__TAG;
+}
 /*
  * set_up_inexhaustive_case does exactly what it suggests.
  */
-static exp set_up_inexhaustive_case
+static exp
-    PROTO_N ( (body_of_case, id, default_exp) )
-    PROTO_T ( exp body_of_case X exp id X exp default_exp )
+set_up_inexhaustive_case(exp body_of_case, exp id, exp default_exp)
 {
-  exp NAME__TAG;
+	exp NAME__TAG;
-  exp GOTO__TAG;
+	exp GOTO__TAG;
-  exp CASE__TAG;
+	exp CASE__TAG;
-  exp ZERO__TAG;
+	exp ZERO__TAG;
-  exp SEQ__TAG;
+	exp SEQ__TAG;
-  exp CONT__TAG;
+	exp CONT__TAG;
-  exp r;
+	exp r;
-  NAME__TAG = me_obtain (id);
+	NAME__TAG = me_obtain(id);
-  CONT__TAG = me_u3 (sh (id), NAME__TAG, cont_tag);
+	CONT__TAG = me_u3(sh(id), NAME__TAG, cont_tag);
-  /* shape of case is f_top since it is not exhaustive */
+	/* shape of case is f_top since it is not exhaustive */
-  CASE__TAG = getexp (f_top, nilexp, 0, CONT__TAG, nilexp,
+	CASE__TAG = getexp(f_top, nilexp, 0, CONT__TAG, nilexp, 0, 0, case_tag);
-, 0, case_tag);
-  bro (CONT__TAG) = body_of_case;
+	bro(CONT__TAG) = body_of_case;
-  clearlast (CONT__TAG);
+	clearlast(CONT__TAG);
-  r = body_of_case;
+	r = body_of_case;
-  while (!last (r))
+	while (!last(r)) {
-    r = bro (r);
+		r = bro(r);
+	}
-  bro (r) = CASE__TAG;
+	bro(r) = CASE__TAG;
-  GOTO__TAG = getexp (f_bottom, nilexp, 0, nilexp, nilexp,
+	GOTO__TAG = getexp(f_bottom, nilexp, 0, nilexp, nilexp, 0, 0, goto_tag);
-, 0, goto_tag);
-  pt (GOTO__TAG) = default_exp;
+	pt(GOTO__TAG) = default_exp;
-  no (son (default_exp))++;
+	no(son(default_exp)) ++;
-  ZERO__TAG = me_u3 (f_top, CASE__TAG, 0);
+	ZERO__TAG = me_u3(f_top, CASE__TAG, 0);
-  /* doesn't matter what shape zero_tag is */
+	/* doesn't matter what shape zero_tag is */
-  SEQ__TAG = me_b3 (f_bottom, ZERO__TAG, GOTO__TAG, seq_tag);
+	SEQ__TAG = me_b3(f_bottom, ZERO__TAG, GOTO__TAG, seq_tag);
-  return SEQ__TAG;
+	return SEQ__TAG;
 }
 /*
  * like_me_q1 sets up a test_tag and is very similar to me_q1.
  * me_q1 is found in me_fns.c
  */
-static exp like_me_q1
+static exp
-    PROTO_N ( (prob, nt, lab, arg1, arg2, nm) )
-    PROTO_T ( int prob X ntest nt X exp lab X exp arg1 X exp arg2 X unsigned char nm )
+like_me_q1(int prob, ntest nt, exp lab, exp arg1, exp arg2, unsigned char nm)
 {
-  exp r;
+	exp r;
-  r = getexp (f_top, nilexp, 0, arg1, lab, 0, 0, nm);
+	r = getexp(f_top, nilexp, 0, arg1, lab, 0, 0, nm);
-  no (r) = prob;
+	no(r) = prob;
-  settest_number (r, nt);
+	settest_number(r, nt);
-  setbro (arg1, arg2);
+	setbro(arg1, arg2);
-  clearlast (arg1);
+	clearlast(arg1);
-  ++no (son (lab));
+	++no(son(lab));
-  setfather (r, arg2);
+	setfather(r, arg2);
-  return r;
+	return r;
 }
 /*
  *  find_the_split_value is used by exhaustive_conditional_maker
  *  and inexhaustive_conditional_maker in order to calculate
  *  where to do a comparison.
  */
-static int   find_the_split_value
+static int
-    PROTO_N ( (start, end) )
-    PROTO_T ( int start X int end )
+find_the_split_value(int start, int end)
+{
-  int   w;
+	int w;
-  int   split_value;
+	int split_value;
-  double   halfway_value;
+	double halfway_value;
-  double   best_diff;
+	double best_diff;
-  double   count;
+	double count;
-  count = 0.0;
+	count = 0.0;
-  halfway_value = 0.0;
+	halfway_value = 0.0;
-  for (w = start; w <= end; w++)
+	for (w = start; w <= end; w++) {
-  {
-    halfway_value += node_weight[w];
+		halfway_value += node_weight[w];
-  }
+	}
-  halfway_value = halfway_value / 2.0;
+	halfway_value = halfway_value / 2.0;
-  best_diff = node_weight[start] - halfway_value;
+	best_diff = node_weight[start] - halfway_value;
-  if (best_diff < 0.0)
+	if (best_diff < 0.0) {
-  {
-    best_diff = - best_diff;
+		best_diff = - best_diff;
-  }
+	}
-  split_value = start;
+	split_value = start;
-  for (w = start; w <= end; w++) {
+	for (w = start; w <= end; w++) {
-    count += node_weight[w];
+		count += node_weight[w];
-    if ((count - halfway_value) < best_diff
+		if ((count - halfway_value) < best_diff &&
-	&& (halfway_value - count) < best_diff)
+		    (halfway_value - count) < best_diff) {
-    {
-      split_value = w;
+			split_value = w;
-      best_diff = count - halfway_value;
+			best_diff = count - halfway_value;
-      if (best_diff < 0.0)
+			if (best_diff < 0.0) {
-      {
-	best_diff = - best_diff;
+				best_diff = - best_diff;
-      }
+			}
-    }
+		}
-  }
+	}
-  return split_value;
+	return split_value;
+}
 /*
  * exhaustive_conditional_maker is the recursive routine for
  * making the internal transformed tdf in the case of an
  * exhaustive case_tag.
  */
-static exp exhaustive_conditional_maker
+static exp
-    PROTO_N ( (start, end, id) )
-    PROTO_T ( int start X int end X exp id )
+exhaustive_conditional_maker(int start, int end, exp id)
 {
-  int   split_value;
+	int split_value;
-  exp option_left;
+	exp option_left;
-  exp option_right;
+	exp option_right;
-  exp t;
+	exp t;
-  /* first test to see if we have only one node */
+	/* first test to see if we have only one node */
-  if (start == end) {
+	if (start == end) {
-    /* Check to see if not a jump table      */
+		/* Check to see if not a jump table */
-    if (bro (node_start[start]) == nilexp) {
+		if (bro(node_start[start]) == nilexp) {
-      t = getexp (f_bottom, nilexp, 0, nilexp, nilexp, 0, 0, goto_tag);
+			t = getexp(f_bottom, nilexp, 0, nilexp, nilexp, 0, 0,
+				   goto_tag);
-      pt (t) = pt (node_start[start]);
+			pt(t) = pt(node_start[start]);
-      return t;
+			return t;
-    }
-    else {
+		} else {
-      /* We must have to make a jump table    */
+			/* We must have to make a jump table */
-      return set_up_exhaustive_case (node_start[start], id);
+			return set_up_exhaustive_case(node_start[start], id);
-    }
+		}
-  }
+	}
-  split_value = find_the_split_value (start, end);
+	split_value = find_the_split_value(start, end);
-  if (split_value == end)
+	if (split_value == end) {
-    split_value --;
+		split_value --;
+	}
-  option_left = exhaustive_conditional_maker (split_value + 1, end, id);
+	option_left = exhaustive_conditional_maker(split_value + 1, end, id);
-  option_right = exhaustive_conditional_maker (start, split_value, id);
+	option_right = exhaustive_conditional_maker(start, split_value, id);
-  return set_up_conditional (option_left, option_right,
+	return set_up_conditional(option_left, option_right,
-      f_greater_than_or_equal,
+				  f_greater_than_or_equal,
-      no (node_start[split_value + 1]),
+				  no(node_start[split_value + 1]), id, 1000);
-      id, 1000);
 }
 /*
  * inexhaustive_conditional_maker is the recursive routine for
  * making the internal transformed tdf in the case of an
  * inexhaustive case_tag.
-    option_right =
+		option_right =
-      inexhaustive_conditional_maker (start, split_value,
+		    inexhaustive_conditional_maker(start, split_value, id,
-	id, default_exp);
+						   default_exp);
-    option_left =
+		option_left =
-      inexhaustive_conditional_maker (split_value + 1, end,
+		    inexhaustive_conditional_maker(split_value + 1, end, id,
-	id, default_exp);
+						   default_exp);
-    return set_up_conditional (option_left, option_right,
+		return set_up_conditional(option_left, option_right,
+					  f_greater_than,
-	f_greater_than, no (node_end[split_value]), id, 1000);
+					  no(node_end[split_value]), id, 1000);
-  }
+	}
+}
 /*
  * set_up_assign takes a variable and adds an integer to
  * it, and replaces it.
  */
-static exp set_up_assign
+static exp
-    PROTO_N ( (id, number) )
-    PROTO_T ( exp id X int number )
+set_up_assign(exp id, int number)
+{
-  exp NAME__TAG;
+	exp NAME__TAG;
-  exp VAL__TAG;
+	exp VAL__TAG;
-  exp CONT__TAG;
+	exp CONT__TAG;
-  exp PLUS__TAG;
+	exp PLUS__TAG;
-  exp ASSIGN__TAG;
+	exp ASSIGN__TAG;
-  NAME__TAG = me_obtain (id);
+	NAME__TAG = me_obtain(id);
-  VAL__TAG = me_shint (sh (id), number);
+	VAL__TAG = me_shint(sh(id), number);
-  CONT__TAG = me_u3 (sh (id), NAME__TAG, cont_tag);
+	CONT__TAG = me_u3(sh(id), NAME__TAG, cont_tag);
-  PLUS__TAG = me_b3 (sh (id), CONT__TAG, VAL__TAG, plus_tag);
+	PLUS__TAG = me_b3(sh(id), CONT__TAG, VAL__TAG, plus_tag);
-  ASSIGN__TAG = me_b3 (f_top, me_obtain (id), PLUS__TAG, ass_tag);
+	ASSIGN__TAG = me_b3(f_top, me_obtain(id), PLUS__TAG, ass_tag);
-  return ASSIGN__TAG;
+	return ASSIGN__TAG;
+}
 /*
  * set_up_unsigned_test returns a test_tag. The test is
  * specified, along with the value to be tested against
  * the default_exp labst_tag and the var_tag to test
  * against.
  */
-static exp set_up_unsigned_test
+static exp
-    PROTO_N ( (default_exp, id, test_value, test) )
-    PROTO_T ( exp default_exp X exp id X int test_value X ntest test )
+set_up_unsigned_test(exp default_exp, exp id, int test_value, ntest test)
+{
-  exp NAME__TAG;
+	exp NAME__TAG;
-  exp CHVAR__TAG;
+	exp CHVAR__TAG;
-  exp CONT__TAG;
+	exp CONT__TAG;
-  exp VAL__TAG;
+	exp VAL__TAG;
-  exp TEST__TAG;
+	exp TEST__TAG;
-  NAME__TAG = me_obtain (id);
+	NAME__TAG = me_obtain(id);
-  CONT__TAG = me_u3 (sh (id), NAME__TAG, cont_tag);
+	CONT__TAG = me_u3(sh(id), NAME__TAG, cont_tag);
-  CHVAR__TAG = hold_check(me_u3 (ulongsh, CONT__TAG, chvar_tag));
+	CHVAR__TAG = hold_check(me_u3(ulongsh, CONT__TAG, chvar_tag));
-  VAL__TAG = me_shint (ulongsh, test_value);
+	VAL__TAG = me_shint(ulongsh, test_value);
-  TEST__TAG = like_me_q1 (1000, test, default_exp, CHVAR__TAG,
+	TEST__TAG = like_me_q1(1000, test, default_exp, CHVAR__TAG, VAL__TAG,
-      VAL__TAG, test_tag);
+			       test_tag);
-  return TEST__TAG;
+	return TEST__TAG;
+}

Subversion Repositories tendra.SVN

(root)/branches/tendra5/src/installers/common/construct/case_opt.c – Rev 5 → 6