WebSVN – tendra.SVN – Diff – /trunk/src/installers/680x0/common/weights.c

+/*
+ * Copyright (c) 2002-2005 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
 /*
     MAXIMUM AND MINIMUM WEIGHTS
 */
-#define  cant_use		( ( float ) -1.0e10 )
+#define  cant_use		((float) -1.0e10)
 /*
     NUMBERS OF AVAILABLE REGISTERS
 */
 #define  wdno		16
 #define  wano		16
 #define  wfno		6
-#define  wno		( wdno + wano + wfno )
+#define  wno		(wdno + wano + wfno)
 /*
     STRUCTURE DEFINITIONS OF weights, wp, explist
 */
 typedef struct {
-    float wts [ wno ] ;
+    float wts[wno];
-    long d_used ;
+    long d_used;
-    long a_used ;
+    long a_used;
-    long f_used ;
+    long f_used;
-} weights ;
+} weights;
 typedef struct {
-    weights wt ;
+    weights wt;
-    long bkpt ;
+    long bkpt;
-} wp ;
+} wp;
 typedef struct elt {
-    exp member ;
+    exp member;
-    struct elt *next ;
+    struct elt *next;
-} explist  ;
+} explist ;
 /*
     BASIC WEIGHTS
 */
-static weights zeros ;
+static weights zeros;
-static weights weightsv PROTO_S ( ( exp, explist * ) ) ;
+static weights weightsv(exp, explist *);
 /*
     CURRENT WEIGHTS SCALE FACTOR
 */
-static float scale ;
+static float scale;
 /*
     ADD TWO WEIGHT VECTORS
 */
 static weights add_weights
-    PROTO_N ( ( w1, w2 ) )
-    PROTO_T ( weights w1 X weights w2 )
+(weights w1, weights w2)
+{
-    long i ;
+    long i;
-    weights r ;
+    weights r;
-    float wa, wb ;
+    float wa, wb;
-    for ( i = 0 ; i < wno ; i++ ) {
+    for (i = 0; i < wno; i++) {
-	wa = ( w1.wts )[i] ;
+	wa = (w1.wts)[i];
-	wb = ( w2.wts )[i] ;
+	wb = (w2.wts)[i];
-	if ( wa == cant_use || wb == cant_use ) {
+	if (wa == cant_use || wb == cant_use) {
-	    ( r.wts )[i] = cant_use ;
+	   (r.wts)[i] = cant_use;
 	} else {
-	    ( r.wts )[i] = wa + wb ;
+	   (r.wts)[i] = wa + wb;
+	}
+    }
-    r.d_used = maximum ( w1.d_used, w2.d_used ) ;
+    r.d_used = maximum(w1.d_used, w2.d_used);
-    r.a_used = maximum ( w1.a_used, w2.a_used ) ;
+    r.a_used = maximum(w1.a_used, w2.a_used);
-    r.f_used = maximum ( w1.f_used, w2.f_used ) ;
+    r.f_used = maximum(w1.f_used, w2.f_used);
-    return ( r ) ;
+    return(r);
+}
 /*
     INITIALIZE BASIC WEIGHTS
 */
 void init_weights
-    PROTO_Z ()
+(void)
+{
-    long i ;
+    long i;
-    for ( i = 0 ; i < wno ; i++ ) ( zeros.wts )[i] = ( float ) 0.0 ;
+    for (i = 0; i < wno; i++)(zeros.wts)[i] = (float)0.0;
-    zeros.d_used = -1 ;
+    zeros.d_used = -1;
-    zeros.a_used = -1 ;
+    zeros.a_used = -1;
-    zeros.f_used = -1 ;
+    zeros.f_used = -1;
-    return ;
+    return;
+}
 /*
     MARK A LIST OF EXPS
 */
 static void markcall
-    PROTO_N ( ( el, b ) )
-    PROTO_T ( explist *el X bitpattern b )
+(explist *el, bitpattern b)
+{
-    explist *t ;
+    explist *t;
-    for ( t = el ; t != null ; t = t->next ) props ( t->member ) |= b ;
+    for (t = el; t != null; t = t->next)props(t->member) |= b;
-    return ;
+    return;
+}
 /*
     WORK OUT WEIGHTS FOR A DECLARATION
 */
 static wp max_weights
-    PROTO_N ( ( s, locp, ws, rtype ) )
-    PROTO_T ( long s X float locp X weights ws X int rtype )
+(long s, float locp, weights ws, int rtype)
+{
-    wp res ;
+    wp res;
-    bool bkset = 0 ;
+    bool bkset = 0;
-    long i, n ;
+    long i, n;
-    long sz = ( s + 31 ) / 32, bk = 1 ;
+    long sz = (s + 31) / 32, bk = 1;
-    long q = 0 ;
+    long q = 0;
-    float *w, *pw ;
+    float *w, *pw;
-    long used, total, offset ;
+    long used, total, offset;
     /* Find values for this register type */
-    switch ( rtype ) {
+    switch (rtype) {
-	case Dreg : {
+	case Dreg: {
-	    offset = 0 ;
+	    offset = 0;
-	    total = wdno ;
+	    total = wdno;
-	    used = ws.d_used ;
+	    used = ws.d_used;
-	    break ;
+	    break;
+	}
-	case Areg : {
+	case Areg: {
-	    offset = wdno ;
+	    offset = wdno;
-	    total = wano ;
+	    total = wano;
-	    used = ws.a_used ;
+	    used = ws.a_used;
-	    break ;
+	    break;
+	}
-	case Freg : {
+	case Freg: {
-	    offset = wdno + wano ;
+	    offset = wdno + wano;
-	    total = wfno ;
+	    total = wfno;
-	    used = ws.f_used ;
+	    used = ws.f_used;
-	    break ;
+	    break;
+	}
 	default : {
-	    error ( "Illegal register type" ) ;
+	    error("Illegal register type");
-	    exit ( EXIT_FAILURE ) ;
+	    exit(EXIT_FAILURE);
+	}
+    }
-    w = &( ws.wts )[ offset ] ;
+    w = & (ws.wts)[offset];
-    pw = &( ( res.wt ).wts )[ offset ] ;
+    pw = & ((res.wt).wts)[offset];
-    n = used + sz + 1 ;
+    n = used + sz + 1;
-    if ( n > total ) n = total ;
+    if (n > total)n = total;
     /* Copy ws to res.wt */
-    for ( i = 0 ; i < wno ; i++ ) ( ( res.wt ).wts )[i] = ( ws.wts )[i] ;
+    for (i = 0; i < wno; i++)((res.wt).wts)[i] = (ws.wts)[i];
-    res.wt.d_used = ws.d_used ;
+    res.wt.d_used = ws.d_used;
-    res.wt.a_used = ws.a_used ;
+    res.wt.a_used = ws.a_used;
-    res.wt.f_used = ws.f_used ;
+    res.wt.f_used = ws.f_used;
-    if ( locp == cant_use ) {
+    if (locp == cant_use) {
-	for ( i = 0 ; i < n ; i++ ) pw [i] = cant_use ;
+	for (i = 0; i < n; i++)pw[i] = cant_use;
-	for ( i = n ; i < total ; i++ ) pw [i] = w [i] ;
+	for (i = n; i < total; i++)pw[i] = w[i];
-	switch ( rtype ) {
+	switch (rtype) {
-	    case Dreg : res.wt.d_used = ws.d_used + sz ; break ;
+	    case Dreg: res.wt.d_used = ws.d_used + sz; break;
-	    case Areg : res.wt.a_used = ws.a_used + sz ; break ;
+	    case Areg: res.wt.a_used = ws.a_used + sz; break;
-	    case Freg : res.wt.f_used = ws.f_used + sz ; break ;
+	    case Freg: res.wt.f_used = ws.f_used + sz; break;
+	}
-	bk = 0 ;
+	bk = 0;
     } else {
-	float loc = locp * ( ( float ) sz ) ;
+	float loc = locp *((float)sz);
-	q = -1 ;
+	q = -1;
-	for ( i = 0 ; i < total ; i++ ) {
+	for (i = 0; i < total; i++) {
-	    if ( w [i] == cant_use ) {
+	    if (w[i] == cant_use) {
-		pw [i] = cant_use ;
+		pw[i] = cant_use;
-		q = i ;
+		q = i;
 	    } else {
-		if ( i < ( sz + q ) ) {
+		if (i < (sz + q)) {
-		    pw [i] = w [i] ;
+		    pw[i] = w[i];
 		} else {
-		    if ( i == ( sz + q ) ) {
+		    if (i == (sz + q)) {
-			if ( loc >= w [i] && used <= q ) {
+			if (loc >= w[i] && used <= q) {
-			    pw [i] = loc ;
+			    pw[i] = loc;
-			    bk = i + 1 ;
+			    bk = i + 1;
-			    bkset = 1 ;
+			    bkset = 1;
 			} else {
-			    pw [i] = w [i] ;
+			    pw[i] = w[i];
+			}
 		    } else {
-			float z = loc + w [ i - sz ] ;
+			float z = loc + w[i - sz];
-			if ( z >= w [i] ) {
+			if (z >= w[i]) {
-			    pw [i] = z ;
+			    pw[i] = z;
-			    if ( !bkset ) { bk = i + 1 ; bkset = 1 ; }
+			    if (!bkset) { bk = i + 1; bkset = 1; }
 			} else {
-			    pw [i] = w [i] ;
+			    pw[i] = w[i];
+			}
+		    }
+		}
+	    }
+	}
+    }
     /* Set the breakpoint */
-    res.bkpt = bk ;
+    res.bkpt = bk;
-    return ( res ) ;
+    return(res);
+}
 /*
     WORK OUT WEIGHTS FOR A LIST OF EXPS
 */
 static weights add_wlist
-    PROTO_N ( ( re, el ) )
-    PROTO_T ( exp re X explist *el )
+(exp re, explist *el)
+{
-    weights wl1, wl2 ;
+    weights wl1, wl2;
-    if ( re == nilexp ) return ( zeros ) ;
+    if (re == nilexp) return(zeros);
-    wl1 = weightsv ( re, el ) ;
+    wl1 = weightsv(re, el);
-    while ( !last ( re ) ) {
+    while (!last(re)) {
-	re = bro ( re ) ;
+	re = bro(re);
-	wl2 = weightsv ( re, el ) ;
+	wl2 = weightsv(re, el);
-	wl1 = add_weights ( wl1, wl2 ) ;
+	wl1 = add_weights(wl1, wl2);
+    }
-    return ( wl1 ) ;
+    return(wl1);
+}
 /*
     IS X AN ASSIGNMENT?
 */
-#define  ass( X )	( name ( X ) == ass_tag || name ( X ) == assvol_tag )
+#define  ass(X)	(name(X) == ass_tag || name(X) == assvol_tag)
 /*
     WORK OUT WEIGHTS FOR e SCALED BY scale AND SET BREAK POINTS
 */
 static weights weightsv
-    PROTO_N ( ( e, el ) )
-    PROTO_T ( exp e X explist *el )
+(exp e, explist *el)
+{
-    unsigned char n = name ( e ) ;
+    unsigned char n = name(e);
-    switch ( n ) {
+    switch (n) {
-	case name_tag : {
+	case name_tag: {
-	    if ( !isglob ( son ( e ) ) ) fno ( son ( e ) ) += scale ;
+	    if (!isglob(son(e)))fno(son(e)) += scale;
 	    /* Add value to the no field of the declaration */
-	    return ( zeros ) ;
+	    return(zeros);
+	}
-	case make_lv_tag : {
+	case make_lv_tag: {
-	    return ( zeros ) ;
+	    return(zeros);
+	}
-	case ident_tag : {
+	case ident_tag: {
-	    wp p ;
+	    wp p;
-	    long sz ;
+	    long sz;
-	    shape sha ;
+	    shape sha;
 	    /* Starting point for pt list */
-	    exp t = pt ( e ) ;
+	    exp t = pt(e);
-	    exp d = son ( e ) ;
+	    exp d = son(e);
 	    /* Add e to the list of exps */
-	    explist nel ;
+	    explist nel;
-	    nel.member = e ;
+	    nel.member = e;
-	    nel.next = el ;
+	    nel.next = el;
-	    while ( isvar ( e ) && !isvis ( e ) && t != nilexp ) {
+	    while (isvar(e) && !isvis(e) && t != nilexp) {
 		/* Scan along pt list */
-		if ( !( last ( t ) && name ( bro ( t ) ) == cont_tag ) &&
+		if (!(last(t) && name(bro(t)) == cont_tag) &&
-		     !( last ( bro ( t ) ) &&
+		     !(last(bro(t)) &&
-		     ass ( bro ( bro ( t ) ) ) ) )
+		     ass(bro(bro(t)))))
 		    /* Make sure it will not go in register */
-		    setvis ( e ) ;
+		    setvis(e);
-		t = pt ( t ) ;
+		t = pt(t);
+	    }
-	    if ( d != nilexp ) {
+	    if (d != nilexp) {
-		int sht ;
+		int sht;
-		weights wdef, wbody ;
+		weights wdef, wbody;
-		fno ( e ) = ( float ) 0.0 ;
+		fno(e) = (float)0.0;
 		/* Work out weights for the body */
-		wbody = weightsv ( bro ( d ), &nel ) ;
+		wbody = weightsv(bro(d), &nel);
 		/* Work out weights for the definition */
-		if ( name ( d ) == clear_tag ) {
+		if (name(d) == clear_tag) {
-		    wdef = zeros ;
+		    wdef = zeros;
 		} else {
-		    float old_scale = scale ;
+		    float old_scale = scale;
-		    if ( name ( d ) == name_tag ) scale = fno ( e ) ;
+		    if (name(d) == name_tag)scale = fno(e);
-		    wdef = weightsv ( d, el ) ;
+		    wdef = weightsv(d, el);
-		    scale = old_scale ;
+		    scale = old_scale;
+		}
 		/* Shape information */
-		sha = sh ( d ) ;
+		sha = sh(d);
-		sz = shape_size ( sha ) ;
+		sz = shape_size(sha);
-		sht = shtype ( sha ) ;
+		sht = shtype(sha);
 #if 0
 		/* Correct producer bug */
-		if ( name ( sha ) == slonghd && name ( d ) == val_tag &&
+		if (name(sha) == slonghd && name(d) == val_tag &&
-		     no ( d ) == 0 ) {
+		     no(d) == 0) {
-		    bool fix = 0 ;
+		    bool fix = 0;
-		    t = pt ( e ) ;
+		    t = pt(e);
-		    while ( t != nilexp ) {
+		    while (t != nilexp) {
-			exp f = father ( t ) ;
+			exp f = father(t);
-			if ( name ( f ) == cont_tag &&
+			if (name(f) == cont_tag &&
-			     name ( sh ( f ) ) == ptrhd ) fix = 1 ;
+			     name(sh(f)) == ptrhd)fix = 1;
-			t = ( last ( t ) ? nilexp : pt ( t ) ) ;
+			t = (last(t)? nilexp : pt(t));
+		    }
-		    if ( fix ) {
+		    if (fix) {
-			sh ( d ) = ptr_shape ( sha ) ;
+			sh(d) = ptr_shape(sha);
-			sht = Areg ;
+			sht = Areg;
+		    }
+		}
 #endif
-		if ( isusereg ( e ) ) {
+		if (isusereg(e)) {
 		    /* Work out breakpoint */
-		    p = max_weights ( sz, cant_use, wbody, sht ) ;
+		    p = max_weights(sz, cant_use, wbody, sht);
-		    no ( e ) = p.bkpt ;
+		    no(e) = p.bkpt;
-		    if ( no ( e ) == 13 ) error ( "Bad breakpoint" ) ;
+		    if (no(e) == 13)error("Bad breakpoint");
-		    return ( add_weights ( wdef, p.wt ) ) ;
+		    return(add_weights(wdef, p.wt));
+		}
-		if ( regable ( e ) ) {
+		if (regable(e)) {
 		    /* Work out breakpoint */
-		    float loc = fno ( e ) ;
+		    float loc = fno(e);
-		    if ( name ( d ) == name_tag && isusereg ( e ) ) {
+		    if (name(d) == name_tag && isusereg(e)) {
-			loc = ( float ) 1.0 ;
+			loc = (float)1.0;
+		    }
-		    p = max_weights ( sz, loc, wbody, sht ) ;
+		    p = max_weights(sz, loc, wbody, sht);
-		    no ( e ) = p.bkpt ;
+		    no(e) = p.bkpt;
-		    return ( add_weights ( wdef, p.wt ) ) ;
+		    return(add_weights(wdef, p.wt));
+		}
-		no ( e ) = 16 ;
+		no(e) = 16;
-		return ( add_weights ( wdef, wbody ) ) ;
+		return(add_weights(wdef, wbody));
+	    }
-	    return ( zeros ) ;
+	    return(zeros);
+	}
-	case labst_tag : {
+	case labst_tag: {
 	    /* Add e to list of exps */
-	    explist nel ;
+	    explist nel;
-	    nel.member = e ;
+	    nel.member = e;
-	    nel.next = el ;
+	    nel.next = el;
-	    if ( regable ( e ) ) {
+	    if (regable(e)) {
-		weights wbody ;
+		weights wbody;
-		float old_scale = scale ;
+		float old_scale = scale;
-		scale = fno ( e ) ;
+		scale = fno(e);
-		wbody = weightsv ( bro ( son ( e ) ), &nel ) ;
+		wbody = weightsv(bro(son(e)), &nel);
-		scale = old_scale ;
+		scale = old_scale;
-		return ( wbody ) ;
+		return(wbody);
 	    } else {
-		return ( add_wlist ( bro ( son ( e ) ), &nel ) ) ;
+		return(add_wlist(bro(son(e)), &nel));
+	    }
+	}
-	case rep_tag : {
+	case rep_tag: {
-	    weights swl, bwl ;
+	    weights swl, bwl;
-	    swl = weightsv ( son ( e ), el ) ;
+	    swl = weightsv(son(e), el);
-	    bwl = weightsv ( bro ( son ( e ) ), el ) ;
+	    bwl = weightsv(bro(son(e)), el);
-	    return ( add_weights ( swl, bwl ) ) ;
+	    return(add_weights(swl, bwl));
+	}
-	case compound_tag : {
+	case compound_tag: {
-	    return ( add_wlist ( son ( e ), el ) ) ;
+	    return(add_wlist(son(e), el));
+	}
-        case untidy_return_tag :
+        case untidy_return_tag:
-	case case_tag :
+	case case_tag:
-	case res_tag : {
+	case res_tag: {
-	    return ( weightsv ( son ( e ), el ) ) ;
+	    return(weightsv(son(e), el));
+	}
-	case apply_general_tag :
+	case apply_general_tag:
-	case apply_tag :
+	case apply_tag:
-	case round_tag :
+	case round_tag:
-	case float_tag : {
+	case float_tag: {
-	    markcall ( el, ( bitpattern ) 0x80 ) ;
+	    markcall(el,(bitpattern)0x80);
-	    return ( add_wlist ( son ( e ), el ) ) ;
+	    return(add_wlist(son(e), el));
+	}
-	case ass_tag :
+	case ass_tag:
-	case assvol_tag : {
+	case assvol_tag: {
-	    weights swl, bwl ;
+	    weights swl, bwl;
-	    swl = weightsv ( son ( e ), el ) ;
+	    swl = weightsv(son(e), el);
-	    bwl = weightsv ( bro ( son ( e ) ), el ) ;
+	    bwl = weightsv(bro(son(e)), el);
-	    return ( add_weights ( swl, bwl ) ) ;
+	    return(add_weights(swl, bwl));
+	}
-	case general_proc_tag :
+	case general_proc_tag:
-	case proc_tag : {
+	case proc_tag: {
-	    weightsv ( son ( e ), null ) ;
+	    weightsv(son(e), null);
-	    return ( zeros ) ;
+	    return(zeros);
+	}
-	case env_offset_tag : {
+	case env_offset_tag: {
-	    return ( zeros ) ;
+	    return(zeros);
+	}
-	case val_tag :
+	case val_tag:
-	case real_tag : {
+	case real_tag: {
-	    return ( zeros ) ;
+	    return(zeros);
+	}
-	case test_tag : {
+	case test_tag: {
-	    weights twl ;
+	    weights twl;
-	    twl = add_wlist ( son ( e ), el ) ;
+	    twl = add_wlist(son(e), el);
 	    /* scale = scale * ( ( ( float ) 1.0 ) - fno ( e ) ) ; */
-	    return ( twl ) ;
+	    return(twl);
+	}
 	default : {
-	    return ( add_wlist ( son ( e ), el ) ) ;
+	    return(add_wlist(son(e), el));
+	}
+    }
+}
 /*
     COMPUTE WEIGHTS
 */
 void comp_weights
-    PROTO_N ( ( e ) )
-    PROTO_T ( exp e )
+(exp e)
+{
-    scale = ( float ) 1.0 ;
+    scale = (float)1.0;
-    weightsv ( e, null ) ;
+    weightsv(e, null);
-    return ;
+    return;
+}

Subversion Repositories tendra.SVN

(root)/trunk/src/installers/680x0/common/weights.c – Rev 2 → 7