WebSVN – tendra.SVN – Diff – /branches/tendra5/src/installers/680x0/common/output.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
 /*
     OUTPUT FILE
 */
-FILE *fpout ;
+FILE *fpout;
 /*
     OPEN OUTPUT FILE
     This routine opens the file with the given name for output.  If the
     name is null, the standard output is used.
 */
-void open_output
+void
-    PROTO_N ( ( nm ) )
-    PROTO_T ( char *nm )
+open_output(char *nm)
+{
-    if ( nm == null ) {
+	if (nm == null) {
-	fpout = stdout ;
+		fpout = stdout;
-    } else {
+	} else {
-	fpout = fopen ( nm, "w" ) ;
+		fpout = fopen(nm, "w");
-	if ( fpout == null ) {
+		if (fpout == null) {
-	    error ( "Can't open output file, %s", nm ) ;
+			error("Can't open output file, %s", nm);
-	    exit ( EXIT_FAILURE ) ;
+			exit(EXIT_FAILURE);
+		}
+	}
-    }
-    return ;
+	return;
+}
 /*
     ARRAY OF INSTRUCTION NAMES
     This table gives the mapping between instruction numbers and the
     corresponding names.
 */
 #ifdef asm_dotty_instrs
 #define INSTR_SET_0
 #endif /* asm_dotty_instrs */
 #ifdef asm_simple_instrs
 #define INSTR_SET_1
 #endif /* asm_simple_instrs */
-char *instr_names [] = {
+char *instr_names[] = {
 #include "instr_aux.h"
-} ;
+};
 /*
     ARRAY OF GLOBAL REGISTER NAMES
     This table gives the mapping between register numbers and register
     names.
 */
 #ifdef asm_percent_regs
 #ifdef asm_simple_regs
 #define REGISTER_SET_1
 #endif /* asm_simple_regs */
-static char *glob_reg_names [] = {
+static char *glob_reg_names[] = {
 #include "instr_aux.h"
-} ;
+};
 /*
     ARRAY OF LOCAL REGISTER NAMES
     This table gives the local mapping between register numbers and
     register names.  It is initialized from the table of global register
     names, but may be changed thereafter.
 */
-char *reg_names [ NO_OF_REGS ] ;
+char *reg_names[NO_OF_REGS];
 /*
     OUTPUT A REGISTER NAME
     This routine outputs the register name corresponding to a given
     register number.
 */
-#define  out_reg_name( X )	outs ( reg_names [ ( X ) ] )
+#define  out_reg_name(X)	outs(reg_names[(X)])
 /*
     OUTPUT A SUM OF DATA, EXTERNALS AND LABELS
     This routine prints the sum of all data, external and labels, starting
     with ptr, and moving down the plus-chain.
 */
-static void out_data
+static void
-    PROTO_N ( ( ptr ) )
-    PROTO_T ( mach_op *ptr )
+out_data(mach_op *ptr)
 {
-    mach_op *p ;
+	mach_op *p;
-    bool neg_next = 0 ;
+	bool neg_next = 0;
-    bool need_plus = 0 ;
+	bool need_plus = 0;
-    for ( p = ptr ; p ; p = p->plus ) {
+	for (p = ptr; p; p = p->plus) {
-	switch ( p->type ) {
+		switch (p->type) {
-	    case MACH_EXT :
+		case MACH_EXT:
-	    case MACH_EXTQ : {
+		case MACH_EXTQ:
+			if (need_plus || neg_next) {
-		if ( need_plus || neg_next ) outc ( neg_next ? '-' : '+' ) ;
+				outc(neg_next ? '-' : '+');
+			}
-		outs ( p->def.str ) ;
+			outs(p->def.str);
-		need_plus = 1 ;
+			need_plus = 1;
-		neg_next = 0 ;
+			neg_next = 0;
-		break ;
+			break;
-	    }
-	    case MACH_LAB :
+		case MACH_LAB:
-	    case MACH_LABQ : {
+		case MACH_LABQ:
+			if (need_plus || neg_next) {
-		if ( need_plus || neg_next ) outc ( neg_next ? '-' : '+' ) ;
+				outc(neg_next ? '-' : '+');
+			}
-		outc ( LPREFIX ) ;
+			outc(LPREFIX);
-		outn ( p->def.num ) ;
+			outn(p->def.num);
-		need_plus = 1 ;
+			need_plus = 1;
-		neg_next = 0 ;
+			neg_next = 0;
-		break ;
+			break;
-	    }
-	    case MACH_SPEC :
+		case MACH_SPEC:
-	    case MACH_SPECQ : {
+		case MACH_SPECQ:
-		if ( !output_immediately && p->def.str == special_str ) {
+			if (!output_immediately && p->def.str == special_str) {
-		    /* The value of LSx is known, so use it */
+				/* The value of LSx is known, so use it */
-		    long n = ldisp ;
+				long n = ldisp;
-		    if ( neg_next ) n = ( -n ) ;
+				if (neg_next) {
+					n = (-n);
+				}
-		    if ( p->plus && p->plus->type == MACH_VAL ) {
+				if (p->plus && p->plus->type == MACH_VAL) {
-			p->plus->def.num += n ;
+					p->plus->def.num += n;
-		    } else {
+				} else {
-			if ( need_plus && n >= 0 ) outc ( '+' ) ;
+					if (need_plus && n >= 0) {
+						outc('+');
+					}
-			outn ( n ) ;
+					outn(n);
-			need_plus = 1 ;
+					need_plus = 1;
-		    }
+				}
-		} else {
+			} else {
+				if (need_plus || neg_next) {
-		    if ( need_plus || neg_next ) outc ( neg_next ? '-' : '+' ) ;
+					outc(neg_next ? '-' : '+');
+				}
-		    outc ( LPREFIX ) ;
+				outc(LPREFIX);
-		    outs ( p->def.str ) ;
+				outs(p->def.str);
-		    outn ( ( long ) special_no ) ;
+				outn((long)special_no);
-		    need_plus = 1 ;
+				need_plus = 1;
-		}
+			}
-		neg_next = 0 ;
+			neg_next = 0;
-		break ;
+			break;
-	    }
-	    case MACH_VAL :
+		case MACH_VAL:
-	    case MACH_VALQ : {
+		case MACH_VALQ: {
-		long n = p->def.num ;
+			long n = p->def.num;
-		if ( neg_next ) n = ( -n ) ;
+			if (neg_next) {
+				n = (-n);
+			}
-		if ( need_plus && n >= 0 ) outc ( '+' ) ;
+			if (need_plus && n >= 0) {
+				outc('+');
+			}
-		outn ( n ) ;
+			outn(n);
-		need_plus = 1 ;
+			need_plus = 1;
-		neg_next = 0 ;
+			neg_next = 0;
-		break ;
+			break;
-	    }
+		}
-	    case MACH_HEX :
+		case MACH_HEX:
-	    case MACH_HEXQ : {
+		case MACH_HEXQ: {
-		long n = p->def.num ;
+			long n = p->def.num;
-		if ( neg_next ) n = ( -n ) ;
+			if (neg_next) {
+				n = (-n);
+			}
-		if ( need_plus && n >= 0 ) outc ( '+' ) ;
+			if (need_plus && n >= 0) {
+				outc('+');
+			}
-		outh ( n ) ;
+			outh(n);
-		need_plus = 1 ;
+			need_plus = 1;
-		neg_next = 0 ;
+			neg_next = 0;
-		break ;
+			break;
-	    }
+		}
-	    case MACH_NEG : {
+		case MACH_NEG:
-		neg_next = 1 ;
+			neg_next = 1;
-		break ;
+			break;
-	    }
+		default:
-	    default : return ;
+			return;
-	}
+		}
-    }
+	}
-    return ;
+	return;
 }
 /*
     OUTPUT A SCALED OPERAND
     This routine outputs a scaled register operand.
 */
-static void out_scaled
+static void
-    PROTO_N ( ( ptr ) )
-    PROTO_T ( mach_op *ptr )
+out_scaled(mach_op *ptr)
+{
-    long sf = ptr->def.num ;
+	long sf = ptr->def.num;
-    asm_scale_before ;
+	asm_scale_before;
-    out_reg_name ( ptr->of->def.num ) ;
+	out_reg_name(ptr->of->def.num);
-    if ( sf == 1 ) {
+	if (sf == 1) {
-	asm_scale_1 ;
+		asm_scale_1;
-    } else {
+	} else {
-	asm_scale ;
+		asm_scale;
-	outn ( sf ) ;
+		outn(sf);
-    }
+	}
-    return ;
+	return;
+}
 /*
     OUTPUT A FLOATING POINT NUMBER
     This routine outputs a floating point number.
 */
-static void out_float
+static void
-    PROTO_N ( ( f ) )
-    PROTO_T ( flt *f )
+out_float(flt *f)
 {
-#if ( FBASE == 10 )
+#if (FBASE == 10)
-    int i ;
+	int i;
-    asm_fprefix ;
+	asm_fprefix;
-    if ( f->sign < 0 ) outc ( '-' ) ;
+	if (f->sign < 0) {
+		outc('-');
+	}
-    outc ( '0' + f->mant [0] ) ;
+	outc('0' + f->mant[0]);
-    outc ( '.' ) ;
+	outc('.');
-    for ( i = 1 ; i < MANT_SIZE ; i++ ) outc ( '0' + f->mant [i] ) ;
+	for (i = 1; i < MANT_SIZE; i++) {
+		outc('0' + f->mant[i]);
+	}
-    outc ( 'e' ) ;
+	outc('e');
-    if ( f->exp >= 0 ) outc ( '+' ) ;
+	if (f->exp >= 0) {
+		outc('+');
+	}
-    outn ( f->exp ) ;
+	outn(f->exp);
 #else
-    error ( "Illegal floating point constant" ) ;
+	error("Illegal floating point constant");
 #endif
-    return ;
+	return;
+}
 /*
     MACROS FOR CONSTRUCTS DEPENDING ON asm_data_first
 */
 #ifdef asm_data_first
-#define  out_data_1( X )	if ( X ) out_data ( X )
+#define  out_data_1(X)		if (X)out_data(X)
-#define  out_data_1a( X )	if ( X ) { out_data ( X ) ; outc ( ',' ) ; }
+#define  out_data_1a(X)		if (X) { out_data(X); outc(','); }
-#define  out_data_1b( X )	if ( X ) { outc ( ',' ) ; out_data ( X ) ; }
+#define  out_data_1b(X)		if (X) { outc(','); out_data(X); }
-#define  out_sf_data( X, Y )	if ( Y ) out_scaled ( Y )
+#define  out_sf_data(X, Y)	if (Y)out_scaled(Y)
 #else /* asm_data_first */
 #define  out_data_1( X )	/* empty */
 #define  out_data_1a( X )	/* empty */
 #define  out_data_1b( X )	/* empty */
-#define  out_sf_data( X, Y )	\
+#define  out_sf_data(X, Y)		\
-    if ( X ) {			\
+    if (X) {				\
-	outc ( '(' ) ;		\
+	    outc('(');			\
-	out_data ( X ) ;	\
+	    out_data(X);		\
-	if ( Y ) {		\
+	    if (Y) {			\
-	    outc ( ',' ) ;	\
+		    outc(',');		\
-	    out_scaled ( Y ) ;	\
+		    out_scaled(Y);	\
-	}			\
+	    }				\
-	outc ( ')' ) ;		\
+	    outc(')');			\
-    } else {			\
+    } else {				\
-	if ( Y ) {		\
+	    if (Y) {			\
-	    outc ( '(' ) ;	\
+		    outc('(');		\
-	    out_scaled ( Y ) ;	\
+		    out_scaled(Y);	\
-	    outc ( ')' ) ;	\
+		    outc(')');		\
-	}			\
+	    }				\
+    }
 #endif /* asm_data_first */
 /*
-    OUTPUT A MACHINE OPERAND
+   OUTPUT A MACHINE OPERAND
-    This routine prints a machine operand.
+   This routine prints a machine operand.
-*/
+ */
-static void out_mach_op
+static void
-    PROTO_N ( ( ptr ) )
-    PROTO_T ( mach_op *ptr )
+out_mach_op(mach_op *ptr)
+{
-    mach_op *p = ptr ;
+	mach_op *p = ptr;
-    switch ( p->type ) {
+	switch (p->type) {
-	case MACH_BF : {
+	case MACH_BF: {
-	    /* Bitfield operands */
+		/* Bitfield operands */
-	    long bf_off = p->def.num ;
+		long bf_off = p->def.num;
-	    long bf_bits = p->plus->def.num ;
+		long bf_bits = p->plus->def.num;
-	    out_mach_op ( p->of ) ;
+		out_mach_op(p->of);
-	    asm_bf_before ;
+		asm_bf_before;
-	    asm_nprefix ;
+		asm_nprefix;
-	    outn ( bf_off ) ;
+		outn(bf_off);
-	    asm_bf_middle ;
+		asm_bf_middle;
-	    asm_nprefix ;
+		asm_nprefix;
-	    outn ( bf_bits ) ;
+		outn(bf_bits);
-	    asm_bf_after ;
+		asm_bf_after;
-	    return ;
+		return;
+	}
-	case MACH_CONT : {
+	case MACH_CONT:
-	    p = p->of ;
+		p = p->of;
-	    switch ( p->type ) {
+		switch (p->type) {
-		case MACH_CONT : {
+		case MACH_CONT: {
-		    /* Memory indirect (post- or pre-indexed) */
+			/* Memory indirect (post- or pre-indexed) */
-		    mach_op *p1 = p->plus ;
+			mach_op *p1 = p->plus;
-		    mach_op *p2 = null ;
+			mach_op *p2 = null;
-		    mach_op *q = p->of ;
+			mach_op *q = p->of;
-		    mach_op *q1 = q->plus ;
+			mach_op *q1 = q->plus;
-		    mach_op *q2 = null ;
+			mach_op *q2 = null;
-		    if ( p1 && p1->type == MACH_SCALE ) {
+			if (p1 && p1->type == MACH_SCALE) {
-			p2 = p1 ;
+				p2 = p1;
-			p1 = p2->plus ;
+				p1 = p2->plus;
-		    }
+			}
-		    if ( q1 && q1->type == MACH_SCALE ) {
+			if (q1 && q1->type == MACH_SCALE) {
-			if ( p2 ) {
+				if (p2) {
-			    error ( "Illegal addressing mode" ) ;
+					error("Illegal addressing mode");
-			    outs ( "error" ) ;
+					outs("error");
-			    return ;
+					return;
+				}
+				q2 = q1;
+				q1 = q2->plus;
+			}
-			q2 = q1 ;
-			q1 = q2->plus ;
-		    }
-		    asm_mem_before ;
+			asm_mem_before;
-		    out_data_1a ( q1 ) ;
+			out_data_1a(q1);
-		    out_reg_name ( q->def.num ) ;
+			out_reg_name(q->def.num);
-		    asm_mem_second ;
+			asm_mem_second;
-		    out_sf_data ( q1, q2 ) ;
+			out_sf_data(q1, q2);
-		    asm_mem_third ;
+			asm_mem_third;
-		    out_sf_data ( p1, p2 ) ;
+			out_sf_data(p1, p2);
-		    if ( p2 ) out_scaled ( p2 ) ;
-		    out_data_1b ( p1 ) ;
-		    asm_mem_after ;
-		    return ;
-		}
-		case MACH_REG : {
-		    /* Register indirect (with displacement or index) */
-		    mach_op *p1 = p->plus ;
-		    mach_op *p2 = null ;
-		    if ( p1 ) {
+			if (p2) {
-			if ( p1->type == MACH_SCALE ) {
-			    p2 = p1 ;
-			    p1 = p2->plus ;
-			}
-			out_data_1 ( p1 ) ;
+				out_scaled(p2);
-		    }
-		    asm_ind_before ;
-		    out_reg_name ( p->def.num ) ;
-		    asm_ind_middle ;
-		    out_sf_data ( p1, p2 ) ;
-		    asm_ind_after ;
-		    return ;
-		}
-		case MACH_EXTQ : {
-		    /* External indirect (with displacement or index) */
-		    mach_op *p1 = p->plus ;
-		    mach_op *p2 = null ;
-		    if ( p1 ) {
-			if ( p1->type == MACH_SCALE ) {
-			    p2 = p1 ;
-			    p1 = p2->plus ;
+			}
-			out_data_1 ( p1 ) ;
+			out_data_1b(p1);
-		    }
-		    asm_ind_before ;
-		    outs ( p->def.str ) ;
-		    asm_ind_middle ;
-		    out_sf_data ( p1, p2 ) ;
-		    asm_ind_after ;
+			asm_mem_after;
-		    return ;
+			return;
+		}
+		case MACH_REG: {
+			/* Register indirect (with displacement or index) */
+			mach_op *p1 = p->plus;
+			mach_op *p2 = null;
+			if (p1) {
+				if (p1->type == MACH_SCALE) {
+					p2 = p1;
+					p1 = p2->plus;
+				}
+				out_data_1(p1);
+			}
+			asm_ind_before;
+			out_reg_name(p->def.num);
+			asm_ind_middle;
+			out_sf_data(p1, p2);
+			asm_ind_after;
+			return;
+		}
+		case MACH_EXTQ: {
+			/* External indirect (with displacement or index) */
+			mach_op *p1 = p->plus;
+			mach_op *p2 = null;
+			if (p1) {
+				if (p1->type == MACH_SCALE) {
+					p2 = p1;
+					p1 = p2->plus;
+				}
+				out_data_1(p1);
+			}
+			asm_ind_before;
+			outs(p->def.str);
+			asm_ind_middle;
+			out_sf_data(p1, p2);
+			asm_ind_after;
+			return;
+		}
-		case MACH_EXT :
+		case MACH_EXT:
-		case MACH_LAB :
+		case MACH_LAB:
-		case MACH_SPEC :
+		case MACH_SPEC:
-		case MACH_VAL :
+		case MACH_VAL:
-		case MACH_HEX :
+		case MACH_HEX:
-		case MACH_NEG : {
+		case MACH_NEG:
-		    /* Contents of immediate data, externals, labels */
+			/* Contents of immediate data, externals, labels */
-		    out_data ( p ) ;
+			out_data(p);
-		    return ;
+			return;
+		}
-	    }
-	    error ( "Illegal addressing mode" ) ;
+		error("Illegal addressing mode");
-	    outs ( "error" ) ;
+		outs("error");
-	    return ;
+		return;
+	}
-	case MACH_DEC : {
+	case MACH_DEC:
-	    /* Register indirect with predecrement */
+		/* Register indirect with predecrement */
-	    asm_predec_before ;
+		asm_predec_before;
-	    out_reg_name ( p->def.num ) ;
+		out_reg_name(p->def.num);
-	    asm_predec_after ;
+		asm_predec_after;
-	    return ;
+		return;
-	}
-	case MACH_INC : {
+	case MACH_INC:
-	    /* Register indirect with postincrement */
+		/* Register indirect with postincrement */
-	    asm_postinc_before ;
+		asm_postinc_before;
-	    out_reg_name ( p->def.num ) ;
+		out_reg_name(p->def.num);
-	    asm_postinc_after ;
+		asm_postinc_after;
-	    return ;
+		return;
-	}
-	case MACH_REG : {
+	case MACH_REG:
-	    /* Register direct */
+		/* Register direct */
-	    out_reg_name ( p->def.num ) ;
+		out_reg_name(p->def.num);
-	    return ;
+		return;
-	}
-	case MACH_RPAIR : {
+	case MACH_RPAIR:
-	    /* Register pair */
+		/* Register pair */
-	    out_reg_name ( p->def.num ) ;
+		out_reg_name(p->def.num);
-	    asm_rpair_sep ;
+		asm_rpair_sep;
-	    out_reg_name ( p->plus->def.num ) ;
+		out_reg_name(p->plus->def.num);
-	    return ;
+		return;
-	}
-	case MACH_EXT :
+	case MACH_EXT:
-	case MACH_LAB :
+	case MACH_LAB:
-	case MACH_SPEC :
+	case MACH_SPEC:
-	case MACH_VAL :
+	case MACH_VAL:
-	case MACH_HEX : {
+	case MACH_HEX:
-	    /* Immediate data, externals, labels */
+		/* Immediate data, externals, labels */
-	    asm_nprefix ;
+		asm_nprefix;
-	    out_data ( p ) ;
+		out_data(p);
-	    return ;
+		return;
-	}
-	case MACH_EXTQ :
+	case MACH_EXTQ:
-	case MACH_LABQ :
+	case MACH_LABQ:
-	case MACH_SPECQ : {
+	case MACH_SPECQ:
-	    /* Contents of externals, labels */
+		/* Contents of externals, labels */
-	    out_data ( p ) ;
+		out_data(p);
-	    return ;
+		return;
-	}
-	case MACH_FLOATQ : {
+	case MACH_FLOATQ:
-	    /* Floating-point data */
+		/* Floating-point data */
-	    out_float ( p->def.fp ) ;
+		out_float(p->def.fp);
-	    return ;
+		return;
-	}
-	case MACH_VALQ : {
+	case MACH_VALQ:
-	    /* Integer data */
+		/* Integer data */
-	    outn ( p->def.num ) ;
+		outn(p->def.num);
-	    return ;
+		return;
-	}
-	case MACH_HEXQ : {
+	case MACH_HEXQ:
-	    /* Integer data */
+		/* Integer data */
-	    outh ( p->def.num ) ;
+		outh(p->def.num);
-	    return ;
+		return;
+	}
-    }
-    error ( "Illegal addressing mode" ) ;
+	error("Illegal addressing mode");
-    outs ( "error" ) ;
+	outs("error");
-    return ;
+	return;
+}
 /*
     OUTPUT ALL MACHINE INSTRUCTIONS
     This routine outputs all the machine instructions, together with their
     operands (if any).
 */
-void output_all
+void
-    PROTO_Z ()
+output_all(void)
+{
-    int n ;
+	int n;
-    mach_ins *p ;
+	mach_ins *p;
-    for ( p = all_mach_ins ; p ; p = p->next ) {
+	for (p = all_mach_ins; p; p = p->next) {
-	n = p->ins_no ;
+		n = p->ins_no;
 #ifdef EBUG
 #if 1
-        if ( n != m_comment ) {
+		if (n != m_comment) {
-           outs ( "#inst" ) ;
+			outs("#inst");
-           outn ( p->id ) ;
+			outn(p->id);
-           outnl () ;
+			outnl();
-        }
+		}
-        if ( p->id == 4921 ) {
+		if (p->id == 4921) {
-           int found = 1 ;
+			int found = 1;
+		}
-        }
+#endif
 #endif
+		switch (n) {
+#ifdef EBUG
+		case m_comment:
+			outs("#");
+			outs(p->op1->def.str);
+			outnl();
+			break;
 #endif
-	switch ( n ) {
-#ifdef EBUG
-            case m_comment : {
-               outs ( "#" ) ;
-               outs ( p->op1->def.str ) ;
-               outnl () ;
-               break ;
-            }
-#endif
 #ifdef m_ignore_ins
-	    case m_ignore_ins : {
+		case m_ignore_ins:
-		/* Ignore */
+			/* Ignore */
-		break ;
+			break;
-	    }
 #endif /* m_ignore_ins */
-	    case m_label_ins : {
+		case m_label_ins:
-		/* Labels */
+			/* Labels */
-		outc ( LPREFIX ) ;
+			outc(LPREFIX);
-		outn ( p->op1->def.num ) ;
+			outn(p->op1->def.num);
-		outc ( ':' ) ;
+			outc(':');
-		outnl () ;
+			outnl();
-		break ;
+			break;
-	    }
-	    case m_extern_ins : {
+		case m_extern_ins:
-		/* Externals */
+			/* Externals */
-		out_data ( p->op1 ) ;
+			out_data(p->op1);
-		outc ( ':' ) ;
+			outc(':');
-		outnl () ;
+			outnl();
-		break ;
+			break;
-	    }
 #ifdef asm_uses_equals
-	    case m_as_assign : {
+		case m_as_assign:
-		out_mach_op ( p->op1 ) ;
+			out_mach_op(p->op1);
-		outc ( '=' ) ;
+			outc('=');
-		out_mach_op ( p->op2 ) ;
+			out_mach_op(p->op2);
-		outnl () ;
+			outnl();
-		break ;
+			break;
-	    }
 #endif /* asm_uses_equals */
-	    case m_as_byte :
+		case m_as_byte:
-	    case m_as_short :
+		case m_as_short:
-	    case m_as_long :
+		case m_as_long:
-	    case m_stabs :
+		case m_stabs:
-	    case m_stabd :
+		case m_stabd:
-	    case m_stabn :
+		case m_stabn:
-	    case m_dd_special : {
+		case m_dd_special: {
-		/* Data */
+			/* Data */
-		mach_op *q ;
+			mach_op *q;
-		bool started = 0 ;
+			bool started = 0;
-		int c = 0 ;
+			int c = 0;
-		for ( q = p->op1 ; q ; q = q->of ) {
+			for (q = p->op1; q; q = q->of) {
-		    if ( c == 0 ) {
+				if (c == 0) {
-			if ( started ) outnl () ;
+					if (started) {
+						outnl();
+					}
-			outs ( instr_names [n] ) ;
+					outs(instr_names[n]);
-		    } else {
+				} else {
-			outc ( ',' ) ;
+					outc(',');
-		    }
+				}
-		    out_data ( q ) ;
+				out_data(q);
-		    started = 1 ;
+				started = 1;
-		    if ( ++c == 8 ) c = 0 ;
+				if (++c == 8) {
+					c = 0;
+				}
+			}
+			outnl();
+			break;
+		}
-		outnl () ;
-		break ;
-	    }
-	    default : {
+		default:
-		if ( is_jump ( n ) ) {
+			if (is_jump(n)) {
-		    /* Jumps */
+				/* Jumps */
 #ifndef asm_does_jump_lens
-		    if ( is_unsized ( n ) ) n += long_jump ;
+				if (is_unsized(n)) {
+					n += long_jump;
+				}
 #endif /* !asm_does_jump_lens */
-		    outs ( instr_names [n] ) ;
+				outs(instr_names[n]);
-		    outc ( LPREFIX ) ;
+				outc(LPREFIX);
-		    outn ( p->op1->def.num ) ;
+				outn(p->op1->def.num);
-		    if ( n == m_bra || n == m_brab ||
+				if (n == m_bra || n == m_brab ||
-			 n == m_braw || n == m_bral ) {
+				    n == m_braw || n == m_bral) {
-			/* Align after unconditional jumps */
+					/* Align after unconditional jumps */
-			outnl () ;
+					outnl();
 #ifndef no_align_directives
-                        outs ( instr_names [ m_as_align4 ] ) ;
+					outs(instr_names[m_as_align4]);
 #endif
-		    }
+				}
-		} else {
+			} else {
-		    /* Simple instructions */
+				/* Simple instructions */
-		    outs ( instr_names [n] ) ;
+				outs(instr_names[n]);
+				if (p->op1) {
-		    if ( p->op1 ) out_mach_op ( p->op1 ) ;
+					out_mach_op(p->op1);
+				}
-		    if ( p->op2 ) {
+				if (p->op2) {
-			outc ( ',' ) ;
+					outc(',');
 #ifdef EBUG
-			outc ( ' ' ) ;
+					outc(' ');
 #endif /* EBUG */
-			out_mach_op ( p->op2 ) ;
+					out_mach_op(p->op2);
-		    }
+				}
+			}
+			outnl();
+			break;
+		}
-		outnl () ;
-		break ;
-	    }
+	}
-    }
-    return ;
+	return;
 }
 /*
     INITIALIZE INSTRUCTIONS
     Apply a couple of patches for odd instruction quirks.
 */
+void
-void init_instructions
+init_instructions(void)
-    PROTO_Z ()
+{
 #ifdef asm_no_btst_suffix
-    instr_names [ m_btstb ] = instr_names [ m_btst ] ;
+	instr_names[m_btstb] = instr_names[m_btst];
-    instr_names [ m_btstl ] = instr_names [ m_btst ] ;
+	instr_names[m_btstl] = instr_names[m_btst];
 #endif /* asm_no_btst_suffix */
-    return ;
+	return;
 }
 /*
     INITIALIZE OUTPUT ROUTINES
     This routine copies the table of global register names into the
     table of global register names and
 */
-void init_output
+void
-    PROTO_Z ()
+init_output(void)
 {
-    memcpy ( reg_names, glob_reg_names, sizeof ( glob_reg_names ) ) ;
+	memcpy(reg_names, glob_reg_names, sizeof(glob_reg_names));
 #ifdef SYSV_ABI
-    {
+	{
-	char *r = reg_names [ REG_A0 ] ;
+		char *r = reg_names[REG_A0];
-	reg_names [ REG_A0 ] = reg_names [ REG_A1 ] ;
+		reg_names[REG_A0] = reg_names[REG_A1];
-	reg_names [ REG_A1 ] = r ;
+		reg_names[REG_A1] = r;
-    }
+	}
 #endif /* SYS_ABI */
-    all_mach_ins = null ;
+	all_mach_ins = null;
-    current_ins = null ;
+	current_ins = null;
-    return ;
+	return;
+}
 #ifdef EBUG
-extern bool seek_line ;
+extern bool seek_line;
-extern int seek_line_no ;
+extern int seek_line_no;
 /*
     OUTPUT NEW LINE (DEBUG MODE ONLY)
     In debug mode a count is keep of the current line number in the
     output file to allow stopping the debugger at a given line.  Normally
     outnl is a macro which just outputs a newline character.
 */
-void outnl
+void
-    PROTO_Z ()
+outnl(void)
+{
-    static int line_no = 0 ;
+	static int line_no = 0;
-    outc ( '\n' ) ;
+	outc('\n');
-    line_no++ ;
+	line_no++;
-    if ( seek_line && line_no == seek_line_no ) {
+	if (seek_line && line_no == seek_line_no) {
-	warning ( "Line %d reached", line_no ) ;
+		warning("Line %d reached", line_no);
-	breakpoint () ;
+		breakpoint();
-    }
+	}
-    return ;
+	return;
+}
 #endif /* EBUG */

Subversion Repositories tendra.SVN

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