WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/utility/debug.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
     acting through the Defence Evaluation and Research Agency
     (DERA).  It is made available to Recipients with a
     royalty-free licence for its use, reproduction, transfer
     to other parties and amendment for any purpose not excluding
     product development provided that any such use et cetera
     shall be deemed to be acceptance of the following conditions:-
         (1) Its Recipients shall ensure that this Notice is
         reproduced upon any copies or amended versions of it;
         (2) Any amended version of it shall be clearly marked to
         show both the nature of and the organisation responsible
         for the relevant amendment or amendments;
         (3) Its onward transfer from a recipient to another
         party shall be deemed to be that party's acceptance of
         these conditions;
         (4) DERA gives no warranty or assurance as to its
         quality or suitability for any purpose and DERA accepts
         no liability whatsoever in relation to any use to which
         it may be put.
 */
 #include "config.h"
 #include "c_types.h"
 #include "exp_ops.h"
 #include "hashid_ops.h"
 #include "id_ops.h"
 /*
     EXTENDED DEBUGGING FLAG
     This flag enables the extended debug printing routines.
 */
-int debugging = 0 ;
+int debugging = 0;
 /*
     EXTENDED OFFSET PRINTING
     This routine deals with those cases in print_offset which are only
     output in debugging mode.
 */
-int print_offset_aux
+int
-    PROTO_N ( ( off, bf, sp ) )
-    PROTO_T ( OFFSET off X BUFFER *bf X int sp )
+print_offset_aux(OFFSET off, BUFFER *bf, int sp)
+{
-    if ( !IS_NULL_off ( off ) ) {
+	if (!IS_NULL_off(off)) {
-	switch ( TAG_off ( off ) ) {
+		switch (TAG_off(off)) {
-	    case off_type_tag : {
+		case off_type_tag: {
-		TYPE t = DEREF_type ( off_type_type ( off ) ) ;
+			TYPE t = DEREF_type(off_type_type(off));
-		sp = print_type ( t, bf, sp ) ;
+			sp = print_type(t, bf, sp);
-		break ;
+			break;
-	    }
+		}
-	    default : {
+		default: {
-		sp = print_lex ( lex_member_Hcap, bf, sp ) ;
+			sp = print_lex(lex_member_Hcap, bf, sp);
-		break ;
+			break;
+		}
-	    }
+		}
+	}
-    }
-    return ( sp ) ;
+	return (sp);
+}
 /*
     PRINT A UNARY OPERATION
     This routine prints the unary operation 'op a' to the buffer bf.
 */
-static int print_unary
+static int
-    PROTO_N ( ( a, op, bf, sp ) )
-    PROTO_T ( EXP a X int op X BUFFER *bf X int sp )
+print_unary(EXP a, int op, BUFFER *bf, int sp)
-{
-    IGNORE print_lex ( op, bf, sp ) ;
-    sp = print_exp ( a, 1, bf, 0 ) ;
-    return ( sp ) ;
-}
-/*
-    PRINT A BINARY OPERATION
-    This routine prints the binary operation 'a op b' to the buffer bf.
-*/
-static int print_binary
-    PROTO_N ( ( a, b, op, bf, sp ) )
-    PROTO_T ( EXP a X EXP b X int op X BUFFER *bf X int sp )
+{
-    sp = print_exp ( a, 1, bf, sp ) ;
-    sp = print_lex ( op, bf, sp ) ;
+	IGNORE print_lex(op, bf, sp);
-    sp = print_exp ( b, 1, bf, sp ) ;
+	sp = print_exp(a, 1, bf, 0);
-    return ( sp ) ;
+	return (sp);
+}
+/*
+    PRINT A BINARY OPERATION
+    This routine prints the binary operation 'a op b' to the buffer bf.
+*/
+static int
+print_binary(EXP a, EXP b, int op, BUFFER *bf, int sp)
+{
+	sp = print_exp(a, 1, bf, sp);
+	sp = print_lex(op, bf, sp);
+	sp = print_exp(b, 1, bf, sp);
+	return (sp);
+}
 /*
     PRINT A CAST OPERATION
     This routine prints the cast operation 'op < t > ( a )' to the
     buffer bf.
 */
-static int print_cast
+static int
-    PROTO_N ( ( t, a, op, bf, sp ) )
-    PROTO_T ( TYPE t X EXP a X int op X BUFFER *bf X int sp )
+print_cast(TYPE t, EXP a, int op, BUFFER *bf, int sp)
+{
-    sp = print_lex ( op, bf, sp ) ;
+	sp = print_lex(op, bf, sp);
-    sp = print_lex ( lex_less, bf, sp ) ;
+	sp = print_lex(lex_less, bf, sp);
-    sp = print_type ( t, bf, sp ) ;
+	sp = print_type(t, bf, sp);
-    sp = print_lex ( lex_greater, bf, sp ) ;
+	sp = print_lex(lex_greater, bf, sp);
-    sp = print_exp ( a, 1, bf, sp ) ;
+	sp = print_exp(a, 1, bf, sp);
-    return ( sp ) ;
+	return (sp);
+}
 /*
     PRINT A LIST OF EXPRESSIONS
     This routine prints the list of expressions p, enclosed in brackets,
     to the buffer bf.
 */
-static int print_exp_list
+static int
-    PROTO_N ( ( p, bf, sp ) )
-    PROTO_T ( LIST ( EXP ) p X BUFFER *bf X int sp )
+print_exp_list(LIST(EXP)p, BUFFER *bf, int sp)
+{
-    sp = print_lex ( lex_open_Hround, bf, sp ) ;
+	sp = print_lex(lex_open_Hround, bf, sp);
-    if ( IS_NULL_list ( p ) ) {
+	if (IS_NULL_list(p)) {
-	sp = 0 ;
+		sp = 0;
-    } else {
+	} else {
-	while ( !IS_NULL_list ( p ) ) {
+		while (!IS_NULL_list(p)) {
-	    EXP a = DEREF_exp ( HEAD_list ( p ) ) ;
+			EXP a = DEREF_exp(HEAD_list(p));
-	    sp = print_exp ( a, 1, bf, sp ) ;
+			sp = print_exp(a, 1, bf, sp);
-	    bfputc ( bf, ',' ) ;
+			bfputc(bf, ',');
-	    p = TAIL_list ( p ) ;
+			p = TAIL_list(p);
+		}
+	}
-    }
-    sp = print_lex ( lex_close_Hround, bf, sp ) ;
+	sp = print_lex(lex_close_Hround, bf, sp);
-    return ( sp ) ;
+	return (sp);
+}
 /*
     EXTENDED EXPRESSION PRINTING
     This routine deals with those cases in print_exp which are only
     output in debugging mode.
 */
-int print_exp_aux
+int
-    PROTO_N ( ( e, paren, bf, sp ) )
-    PROTO_T ( EXP e X int paren X BUFFER *bf X int sp )
+print_exp_aux(EXP e, int paren, BUFFER *bf, int sp)
+{
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	ASSERT ( ORDER_exp == 88 ) ;
+		ASSERT(ORDER_exp == 88);
-	if ( paren ) sp = print_lex ( lex_open_Hround, bf, sp ) ;
-	switch ( TAG_exp ( e ) ) {
-	    case exp_paren_tag : {
-		EXP a = DEREF_exp ( exp_paren_arg ( e ) ) ;
-		sp = print_exp ( a, !paren, bf, sp ) ;
-		break ;
-	    }
-	    case exp_copy_tag : {
-		EXP a = DEREF_exp ( exp_copy_arg ( e ) ) ;
-		sp = print_exp ( a, 0, bf, sp ) ;
-		break ;
-	    }
-	    case exp_assign_tag : {
-		EXP a = DEREF_exp ( exp_assign_ref ( e ) ) ;
-		EXP b = DEREF_exp ( exp_assign_arg ( e ) ) ;
-		sp = print_binary ( a, b, lex_assign, bf, sp ) ;
-		break ;
-	    }
-	    case exp_init_tag : {
-		IDENTIFIER id = DEREF_id ( exp_init_id ( e ) ) ;
-		EXP a = DEREF_exp ( exp_init_arg ( e ) ) ;
-		sp = print_id_short ( id, qual_none, bf, sp ) ;
-		sp = print_lex ( lex_assign, bf, sp ) ;
-		sp = print_exp ( a, 0, bf, sp ) ;
-		break ;
-	    }
-	    case exp_preinc_tag : {
-		EXP a = DEREF_exp ( exp_preinc_ref ( e ) ) ;
-		EXP b = DEREF_exp ( exp_preinc_op ( e ) ) ;
-		sp = print_binary ( a, b, lex_assign, bf, sp ) ;
-		break ;
-	    }
-	    case exp_postinc_tag : {
-		EXP a = DEREF_exp ( exp_postinc_ref ( e ) ) ;
-		EXP b = DEREF_exp ( exp_postinc_op ( e ) ) ;
-		sp = print_binary ( a, b, lex_assign, bf, sp ) ;
-		break ;
-	    }
-	    case exp_indir_tag : {
-		EXP a = DEREF_exp ( exp_indir_ptr ( e ) ) ;
-		sp = print_unary ( a, lex_star, bf, sp ) ;
-		break ;
-	    }
-	    case exp_address_tag : {
-		EXP a = DEREF_exp ( exp_address_arg ( e ) ) ;
-		sp = print_unary ( a, lex_and_H1, bf, sp ) ;
-		break ;
-	    }
-	    case exp_address_mem_tag : {
-		EXP a = DEREF_exp ( exp_address_mem_arg ( e ) ) ;
-		sp = print_unary ( a, lex_and_H1, bf, sp ) ;
-		break ;
+		if (paren) {
-	    }
-	    case exp_func_tag : {
-		EXP a = DEREF_exp ( exp_func_fn ( e ) ) ;
-		LIST ( EXP ) p = DEREF_list ( exp_func_args ( e ) ) ;
-		sp = print_exp ( a, 1, bf, sp ) ;
-		sp = print_exp_list ( p, bf, sp ) ;
-		break ;
-	    }
-	    case exp_func_id_tag : {
-		IDENTIFIER id = DEREF_id ( exp_func_id_id ( e ) ) ;
-		LIST ( EXP ) p = DEREF_list ( exp_func_id_args ( e ) ) ;
-		sp = print_id_short ( id, qual_none, bf, sp ) ;
-		sp = print_exp_list ( p, bf, sp ) ;
-		break ;
-	    }
-	    case exp_call_tag : {
-		EXP a = DEREF_exp ( exp_call_ptr ( e ) ) ;
-		EXP b = DEREF_exp ( exp_call_arg ( e ) ) ;
-		sp = print_binary ( a, b, lex_dot_Hstar, bf, sp ) ;
-		break ;
-	    }
-	    case exp_negate_tag :
-	    case exp_compl_tag :
-	    case exp_not_tag :
-	    case exp_abs_tag : {
-		int op = op_token ( e, lex_unknown ) ;
-		EXP a = DEREF_exp ( exp_negate_etc_arg ( e ) ) ;
-		sp = print_unary ( a, op, bf, sp ) ;
-		break ;
-	    }
-	    case exp_plus_tag :
-	    case exp_minus_tag :
-	    case exp_mult_tag :
-	    case exp_div_tag :
-	    case exp_rem_tag :
-	    case exp_and_tag :
-	    case exp_or_tag :
-	    case exp_xor_tag :
-	    case exp_log_and_tag :
-	    case exp_log_or_tag :
-	    case exp_lshift_tag :
-	    case exp_rshift_tag :
-	    case exp_max_tag :
-	    case exp_min_tag : {
-		int op = op_token ( e, lex_unknown ) ;
-		EXP a = DEREF_exp ( exp_plus_etc_arg1 ( e ) ) ;
-		EXP b = DEREF_exp ( exp_plus_etc_arg2 ( e ) ) ;
-		sp = print_binary ( a, b, op, bf, sp ) ;
-		break ;
-	    }
-	    case exp_test_tag : {
-		int op = op_token ( e, lex_unknown ) ;
-		EXP a = DEREF_exp ( exp_test_arg ( e ) ) ;
-		sp = print_exp ( a, 1, bf, sp ) ;
-		IGNORE print_lex ( op, bf, sp ) ;
-		bfprintf ( bf, " 0" ) ;
-		sp = 1 ;
-		break ;
-	    }
-	    case exp_compare_tag : {
-		int op = op_token ( e, lex_unknown ) ;
-		EXP a = DEREF_exp ( exp_compare_arg1 ( e ) ) ;
-		EXP b = DEREF_exp ( exp_compare_arg2 ( e ) ) ;
-		sp = print_binary ( a, b, op, bf, sp ) ;
-		break ;
-	    }
-	    case exp_cast_tag : {
-		TYPE t = DEREF_type ( exp_type ( e ) ) ;
-		EXP a = DEREF_exp ( exp_cast_arg ( e ) ) ;
-		sp = print_cast ( t, a, lex_cast, bf, sp ) ;
-		break ;
-	    }
-	    case exp_base_cast_tag : {
-		TYPE t = DEREF_type ( exp_type ( e ) ) ;
-		EXP a = DEREF_exp ( exp_base_cast_arg ( e ) ) ;
-		sp = print_cast ( t, a, lex_cast, bf, sp ) ;
-		break ;
-	    }
-	    case exp_dyn_cast_tag : {
-		TYPE t = DEREF_type ( exp_type ( e ) ) ;
-		EXP a = DEREF_exp ( exp_dyn_cast_arg ( e ) ) ;
-		sp = print_cast ( t, a, lex_dynamic_Hcast, bf, sp ) ;
-		break ;
-	    }
-	    case exp_add_ptr_tag : {
-		EXP a = DEREF_exp ( exp_add_ptr_ptr ( e ) ) ;
-		OFFSET off = DEREF_off ( exp_add_ptr_off ( e ) ) ;
-		sp = print_exp ( a, 0, bf, sp ) ;
-		sp = print_lex ( lex_plus, bf, sp ) ;
-		sp = print_offset ( off, bf, sp ) ;
-		break ;
-	    }
-	    case exp_offset_size_tag : {
-		OFFSET off = DEREF_off ( exp_offset_size_off ( e ) ) ;
-		TYPE t = DEREF_type ( exp_offset_size_step ( e ) ) ;
-		sp = print_offset ( off, bf, sp ) ;
-		sp = print_lex ( lex_div, bf, sp ) ;
-		sp = print_type ( t, bf, sp ) ;
-		break ;
-	    }
-	    case exp_constr_tag : {
-		EXP a = DEREF_exp ( exp_constr_call ( e ) ) ;
-		sp = print_exp ( a, 0, bf, sp ) ;
-		break ;
-	    }
-	    case exp_destr_tag : {
-		EXP a = DEREF_exp ( exp_destr_call ( e ) ) ;
-		sp = print_exp ( a, 0, bf, sp ) ;
-		break ;
-	    }
-	    case exp_alloc_tag : {
-		EXP a = DEREF_exp ( exp_alloc_call ( e ) ) ;
-		sp = print_exp ( a, 0, bf, sp ) ;
-		break ;
-	    }
-	    case exp_dealloc_tag : {
-		EXP a = DEREF_exp ( exp_dealloc_call ( e ) ) ;
-		sp = print_exp ( a, 0, bf, sp ) ;
-		break ;
-	    }
-	    case exp_rtti_tag : {
-		EXP a = DEREF_exp ( exp_rtti_arg ( e ) ) ;
-		int op = DEREF_int ( exp_rtti_op ( e ) ) ;
-		sp = print_lex ( op, bf, sp ) ;
-		sp = print_exp ( a, 1, bf, sp ) ;
-		break ;
-	    }
-	    case exp_rtti_type_tag : {
-		TYPE t = DEREF_type ( exp_rtti_type_arg ( e ) ) ;
-		int op = DEREF_int ( exp_rtti_type_op ( e ) ) ;
-		sp = print_lex ( op, bf, sp ) ;
-		sp = print_type ( t, bf, sp ) ;
-		break ;
-	    }
-	    case exp_rtti_no_tag : {
-		TYPE t = DEREF_type ( exp_rtti_no_arg ( e ) ) ;
-		sp = print_lex ( lex_typeid, bf, sp ) ;
+			sp = print_lex(lex_open_Hround, bf, sp);
-		sp = print_type ( t, bf, sp ) ;
-		break ;
-	    }
-	    case exp_dynamic_tag : {
-		EXP a = DEREF_exp ( exp_dynamic_arg ( e ) ) ;
-		sp = print_exp ( a, 0, bf, sp ) ;
-		break ;
-	    }
-	    case exp_aggregate_tag : {
-		LIST ( EXP ) p = DEREF_list ( exp_aggregate_args ( e ) ) ;
-		sp = print_lex ( lex_initialization, bf, sp ) ;
-		sp = print_exp_list ( p, bf, sp ) ;
-		break ;
-	    }
-	    case exp_initialiser_tag : {
-		LIST ( EXP ) p = DEREF_list ( exp_initialiser_args ( e ) ) ;
-		sp = print_lex ( lex_initialization, bf, sp ) ;
-		sp = print_exp_list ( p, bf, sp ) ;
-		break ;
-	    }
-	    case exp_nof_tag : {
-		EXP a = DEREF_exp ( exp_nof_start ( e ) ) ;
-		EXP b = DEREF_exp ( exp_nof_pad ( e ) ) ;
-		EXP c = DEREF_exp ( exp_nof_end ( e ) ) ;
-		if ( !IS_NULL_exp ( a ) ) {
-		    sp = print_exp ( a, 0, bf, sp ) ;
-		    bfprintf ( bf, ", " ) ;
-		}
-		sp = print_exp ( b, 0, bf, sp ) ;
-		bfprintf ( bf, ", ..." ) ;
-		if ( !IS_NULL_exp ( c ) ) {
-		    bfprintf ( bf, ", " ) ;
-		    sp = print_exp ( c, 0, bf, sp ) ;
+		}
+		}
-		break ;
-	    }
-	    case exp_opn_tag : {
-		int op = DEREF_int ( exp_opn_lex ( e ) ) ;
-		LIST ( EXP ) p = DEREF_list ( exp_opn_args ( e ) ) ;
-		sp = print_lex ( op, bf, sp ) ;
-		sp = print_exp_list ( p, bf, sp ) ;
-		break ;
-	    }
-	    case exp_uncompiled_tag : {
-		if ( sp ) bfputc ( bf, ' ' ) ;
-		bfprintf ( bf, "..." ) ;
-		sp = 1 ;
-		break ;
-	    }
-	    case exp_fail_tag : {
-		string s = DEREF_string ( exp_fail_msg ( e ) ) ;
-		if ( sp ) bfputc ( bf, ' ' ) ;
-		bfputs ( bf, s ) ;
-		sp = 1 ;
-		break ;
-	    }
-	    case exp_dummy_tag : {
-		EXP a = DEREF_exp ( exp_dummy_value ( e ) ) ;
-		if ( IS_NULL_exp ( a ) ) {
-		    sp = print_lex ( lex_exp_Hcap, bf, sp ) ;
-		} else {
-		    sp = print_exp ( a, 0, bf, sp ) ;
 		}
-		break ;
-	    }
-	    default : {
-		sp = print_lex ( lex_exp_Hcap, bf, sp ) ;
+		if (paren)sp = print_lex(lex_close_Hround, bf, sp);
-		break ;
-	    }
 	}
-	if ( paren ) sp = print_lex ( lex_close_Hround, bf, sp ) ;
-    }
-    return ( sp ) ;
+	return (sp);
+}
 /*
     PRINT AN INDENTED STRING
     This routine prints an indentation of indent steps followed by the
     string text to the file f.
 */
-static void print_indent
+static void
-    PROTO_N ( ( indent, text, f ) )
-    PROTO_T ( int indent X CONST char *text X FILE *f )
+print_indent(int indent, CONST char *text, FILE *f)
 {
-    while ( indent > 1 ) {
+	while (indent > 1) {
-	fputc_v ( '\t', f ) ;
+		fputc_v('\t', f);
-	indent -= 2 ;
+		indent -= 2;
-    }
+	}
-    if ( indent ) {
+	if (indent) {
-	unsigned long i = tab_width / 2 ;
+		unsigned long i = tab_width / 2;
-	while ( i ) {
+		while (i) {
-	    fputc_v ( ' ', f ) ;
+			fputc_v(' ', f);
-	    i-- ;
+			i--;
-	}
+		}
-    }
+	}
-    fputs_v ( text, f ) ;
+	fputs_v(text, f);
-    return ;
+	return;
 }
 /*
     PRINT AN EXPRESSION
     This routine prints the expression e, enclosed in parentheses if paren
     is true and preceded by a space if sp is true, to the file f.
 */
-static void print_expr
+static void
-    PROTO_N ( ( e, paren, sp, f ) )
-    PROTO_T ( EXP e X int paren X int sp X FILE *f )
+print_expr(EXP e, int paren, int sp, FILE *f)
 {
-    BUFFER *bf = clear_buffer ( &print_buff, f ) ;
+	BUFFER *bf = clear_buffer(&print_buff, f);
+	if (paren) {
-    if ( paren ) sp = print_lex ( lex_open_Hround, bf, sp ) ;
+		sp = print_lex(lex_open_Hround, bf, sp);
+	}
-    IGNORE print_exp ( e, 0, bf, sp ) ;
+	IGNORE print_exp(e, 0, bf, sp);
+	if (paren) {
-    if ( paren ) IGNORE print_lex ( lex_close_Hround, bf, sp ) ;
+		IGNORE print_lex(lex_close_Hround, bf, sp);
+	}
-    output_buffer ( bf, 1 ) ;
+	output_buffer(bf, 1);
-    return ;
+	return;
+}
 /*
     PRINT AN INTEGER CONSTANT
     This routine prints the integer constant n to the file f.
 */
-static void print_nat_val
+static void
-    PROTO_N ( ( n, f ) )
-    PROTO_T ( NAT n X FILE *f )
+print_nat_val(NAT n, FILE *f)
+{
-    BUFFER *bf = clear_buffer ( &print_buff, f ) ;
+	BUFFER *bf = clear_buffer(&print_buff, f);
-    IGNORE print_nat ( n, 0, bf, 0 ) ;
+	IGNORE print_nat(n, 0, bf, 0);
-    output_buffer ( bf, 1 ) ;
+	output_buffer(bf, 1);
-    return ;
+	return;
+}
 /*
     PRINT A DECLARATION
     This routine prints the declaration id to the file f.
 */
-static void print_decl
+static void
-    PROTO_N ( ( id, f ) )
-    PROTO_T ( IDENTIFIER id X FILE *f )
+print_decl(IDENTIFIER id, FILE *f)
+{
-    EXP e ;
+	EXP e;
-    BUFFER *bf = clear_buffer ( &print_buff, f ) ;
+	BUFFER *bf = clear_buffer(&print_buff, f);
-    print_id_desc++ ;
+	print_id_desc++;
-    IGNORE print_id_long ( id, qual_none, bf, 0 ) ;
+	IGNORE print_id_long(id, qual_none, bf, 0);
-    print_id_desc-- ;
+	print_id_desc--;
-    e = DEREF_exp ( id_variable_init ( id ) ) ;
+	e = DEREF_exp(id_variable_init(id));
-    if ( !IS_NULL_exp ( e ) ) {
+	if (!IS_NULL_exp(e)) {
-	bfprintf ( bf, " = " ) ;
+		bfprintf(bf, " = ");
-	IGNORE print_exp ( e, 0, bf, 0 ) ;
+		IGNORE print_exp(e, 0, bf, 0);
-    }
+	}
-    output_buffer ( bf, 1 ) ;
+	output_buffer(bf, 1);
-    return ;
+	return;
+}
 /*
     PRINT A LABEL
     This routine prints the label lab to the file f.
 */
-static void print_label
+static void
-    PROTO_N ( ( lab, f ) )
-    PROTO_T ( IDENTIFIER lab X FILE *f )
+print_label(IDENTIFIER lab, FILE *f)
 {
-    int op = DEREF_int ( id_label_op ( lab ) ) ;
+	int op = DEREF_int(id_label_op(lab));
-    if ( op == lex_identifier ) {
+	if (op == lex_identifier) {
-	HASHID nm = DEREF_hashid ( id_name ( lab ) ) ;
+		HASHID nm = DEREF_hashid(id_name(lab));
-	if ( IS_hashid_name_etc ( nm ) ) {
+		if (IS_hashid_name_etc(nm)) {
-	    string s = DEREF_string ( hashid_name_etc_text ( nm ) ) ;
+			string s = DEREF_string(hashid_name_etc_text(nm));
-	    fputs_v ( strlit ( s ), f ) ;
+			fputs_v(strlit(s), f);
-	} else {
+		} else {
-	    fputs_v ( "????", f ) ;
+			fputs_v("????", f);
+		}
+	} else if (op == lex_case) {
+		NAT n = find_case_nat(lab);
+		fputs_v("case ", f);
+		print_nat_val(n, f);
+	} else {
+		fputs_v(token_names[op], f);
+	}
-    } else if ( op == lex_case ) {
-	NAT n = find_case_nat ( lab ) ;
-	fputs_v ( "case ", f ) ;
-	print_nat_val ( n, f ) ;
-    } else {
-	fputs_v ( token_names [ op ], f ) ;
-    }
-    return ;
+	return;
+}
 /*
     PRINT A STATEMENT
     This routine prints the statement e at an indentation of indent to the
     file f.  block is false to suppress braces around compound statements.
+	}
-	case exp_location_tag : {
+	case exp_location_tag: {
-	    /* Location statements */
+		/* Location statements */
-	    EXP a = DEREF_exp ( exp_location_arg ( e ) ) ;
+		EXP a = DEREF_exp(exp_location_arg(e));
-	    print_stmt ( a, indent, block, f ) ;
+		print_stmt(a, indent, block, f);
-	    break ;
+		break;
+	}
 	default : {
-	    /* Expression statements */
+		/* Expression statements */
-	    print_indent ( indent, "", f ) ;
+		print_indent(indent, "", f);
-	    print_expr ( e, 0, 0, f ) ;
+		print_expr(e, 0, 0, f);
-	    fputs_v ( " ;\n", f ) ;
+		fputs_v(" ;\n", f);
-	    break ;
+		break;
 	}
-    }
+	}
-    return ;
+	return;
 }
 /*
     PRINT A BITMASK TYPE
     This routine prints the bitmask value n using the attribute names
     given by s.
 */
-static void print_bitmask
+static void
-    PROTO_N ( ( n, s ) )
-    PROTO_T ( unsigned long n X CONST char **s )
+print_bitmask(unsigned long n, CONST char **s)
 {
-    int sp = 0 ;
+	int sp = 0;
-    FILE *f = DEBUG_file ;
+	FILE *f = DEBUG_file;
-    if ( n ) {
+	if (n) {
-	int i ;
+		int i;
-	unsigned long m = 1 ;
+		unsigned long m = 1;
-	for ( i = 0 ; i < 32 ; i++ ) {
+		for (i = 0; i < 32; i++) {
-	    if ( n & m ) {
+			if (n & m) {
-		CONST char *c = s [i] ;
+				CONST char *c = s[i];
-		if ( c ) {
+				if (c) {
+					if (sp) {
-		    if ( sp ) fputs_v ( " | ", f ) ;
+						fputs_v(" | ", f);
+					}
-		    fputs_v ( c, f ) ;
+					fputs_v(c, f);
-		    sp = 1 ;
+					sp = 1;
+				}
+			}
+			m <<= 1;
+		}
-	    }
-	    m <<= 1 ;
+	}
-    }
+	if (!sp) {
-    if ( !sp ) fputs_v ( "none", f ) ;
+		fputs_v("none", f);
+	}
-    fputc_v ( '\n', f ) ;
+	fputc_v('\n', f);
-    fflush_v ( f ) ;
+	fflush_v(f);
-    return ;
+	return;
+}
 /*
     PRINT A BITSTREAM
     This routine prints the contents of the bitstream bs to the file f.
 */
-static void print_bitstream
+static void
-    PROTO_N ( ( bs, f ) )
-    PROTO_T ( BITSTREAM *bs X FILE *f )
+print_bitstream(BITSTREAM *bs, FILE *f)
+{
-    if ( bs ) {
+	if (bs) {
-	string s = bs->text ;
+		string s = bs->text;
-	unsigned i = bs->bits ;
+		unsigned i = bs->bits;
-	unsigned n = bs->bytes ;
+		unsigned n = bs->bytes;
-	print_bitstream ( bs->prev, f ) ;
+		print_bitstream(bs->prev, f);
-	fprintf_v ( f, "0x%p = { ", ( gen_ptr ) bs ) ;
+		fprintf_v(f, "0x%p = { ",(gen_ptr)bs);
-	while ( n ) {
+		while (n) {
-	    unsigned j ;
+			unsigned j;
-	    unsigned c = ( unsigned ) *s ;
+			unsigned c = (unsigned)*s;
-	    for ( j = 0 ; j < 8 ; j++ ) {
+			for (j = 0; j < 8; j++) {
-		fputc_v ( ( ( c & 0x80 ) ? '1' : '0' ), f ) ;
+				fputc_v(((c & 0x80) ? '1' : '0'), f);
-		c <<= 1 ;
+				c <<= 1;
-	    }
+			}
-	    fputc_v ( ' ', f ) ;
+			fputc_v(' ', f);
-	    n-- ;
+			n--;
-	    s++ ;
+			s++;
+		}
+		if (i) {
+			unsigned j;
+			unsigned c = (unsigned)*s;
+			for (j = 0; j < i; j++) {
+				fputc_v(((c & 0x80) ? '1' : '0'), f);
+				c <<= 1;
+			}
+		}
+		fputs_v(" }\n", f);
+	}
-	if ( i ) {
-	    unsigned j ;
-	    unsigned c = ( unsigned ) *s ;
-	    for ( j = 0 ; j < i ; j++ ) {
-		fputc_v ( ( ( c & 0x80 ) ? '1' : '0' ), f ) ;
-		c <<= 1 ;
-	    }
-	}
-	fputs_v ( " }\n", f ) ;
-    }
-    return ;
+	return;
+}
 /*
     TYPE DEBUGGING ROUTINES
     These routines are used during debugging for printing objects of various
     types.
+}
+void
+DEBUG_virt(VIRTUAL vt)
+{
+	if (!IS_NULL_virt(vt)) {
+		if (IS_virt_table(vt)) {
+			unsigned n = 1;
+			LIST(VIRTUAL)vs = DEREF_list(virt_table_entries(vt));
+			while (!IS_NULL_list(vs)) {
+				vt = DEREF_virt(HEAD_list(vs));
+				fprintf_v(DEBUG_file, "%u: ", n);
-void DEBUG_where
+				DEBUG_virt(vt);
+				n++;
+				vs = TAIL_list(vs);
+			}
-    PROTO_Z ()
+		} else {
+			IDENTIFIER fn = DEREF_id(virt_func(vt));
+			DEBUG_id_long(fn);
+		}
+	}
+	return;
+}
+void
+DEBUG_where(void)
 {
-    update_column () ;
+	update_column();
-    DEBUG_loc ( &crt_loc ) ;
+	DEBUG_loc(&crt_loc);
-    return ;
+	return;
 }
 /*
     GENERIC TYPE DEBUGGING ROUTINE
     This routine is a generic debugging routine for printing any c_class
     object.  It relies on run-time type information to determine the
     static type of p.
 */
 #if c_class_IMPLEMENTATION
-void DEBUG_c_class
+void
-    PROTO_N ( ( p, indent ) )
-    PROTO_T ( c_class *p X int indent )
+DEBUG_c_class(c_class *p, int indent)
+{
-    FILE *f = DEBUG_file ;
+	FILE *f = DEBUG_file;
-    debugging++ ;
+	debugging++;
-    if ( p ) {
+	if (p) {
-	unsigned n = TYPEID ( p ) ;
+		unsigned n = TYPEID(p);
-	switch ( n ) {
+		switch (n) {
-	    case TYPEID_ptr : {
+		case TYPEID_ptr: {
-		DEBUG_c_class ( p->ag_ptr, indent ) ;
+			DEBUG_c_class(p->ag_ptr, indent);
-		break ;
+			break;
-	    }
-	    case TYPEID_list :
-	    case TYPEID_stack : {
-		print_indent ( indent, "{\n", f ) ;
-		while ( !IS_NULL_list ( p ) ) {
-		    c_class *q = ( HEAD_list ( p ) )->ag_ptr ;
-		    DEBUG_c_class ( q, indent + 1 ) ;
-		    p = TAIL_list ( p ) ;
+		}
-		print_indent ( indent, "}\n", f ) ;
-		break ;
-	    }
-	    case TYPEID_exp : {
+		case TYPEID_list:
-		print_stmt ( p, indent, 1, f ) ;
-		break ;
-	    }
-	    default : {
+		case TYPEID_stack: {
-		print_indent ( indent, "", f ) ;
+			print_indent(indent, "{\n", f);
-		switch ( n ) {
+			while (!IS_NULL_list(p)) {
-		    case TYPEID_ctype : DEBUG_ctype ( p ) ; break ;
-		    case TYPEID_err : report ( crt_loc, p ) ; break ;
-		    case TYPEID_etype : DEBUG_etype ( p ) ; break ;
-		    case TYPEID_flt : DEBUG_flt ( p ) ; break ;
-		    case TYPEID_ftype : DEBUG_ftype ( p ) ; break ;
-		    case TYPEID_graph : DEBUG_graph ( p ) ; break ;
-		    case TYPEID_hashid : DEBUG_hashid ( p ) ; break ;
-		    case TYPEID_id : DEBUG_id_long ( p ) ; break ;
-		    case TYPEID_inst : DEBUG_inst ( p ) ; break ;
+				c_class *q = (HEAD_list(p))->ag_ptr;
-		    case TYPEID_itype : DEBUG_itype ( p ) ; break ;
-		    case TYPEID_member : DEBUG_member ( p ) ; break ;
-		    case TYPEID_nat : DEBUG_nat ( p ) ; break ;
+				DEBUG_c_class(q, indent + 1);
-		    case TYPEID_nspace : DEBUG_nspace ( p ) ; break ;
-		    case TYPEID_off : DEBUG_offset ( p ) ; break ;
-		    case TYPEID_str : DEBUG_str ( p ) ; break ;
+				p = TAIL_list(p);
-		    case TYPEID_tok : DEBUG_sort ( p ) ; break ;
-		    case TYPEID_type : DEBUG_type ( p ) ; break ;
-		    case TYPEID_virt : DEBUG_virt ( p ) ; break ;
+			}
-		    case TYPEID_free : fputs_v ( "FREE\n", f ) ; break ;
+			print_indent(indent, "}\n", f);
-		    default : fputs_v ( "UNKNOWN\n", f ) ; break ;
+			break;
+		}
+		case TYPEID_exp: {
+			print_stmt(p, indent, 1, f);
-		break ;
+			break;
+		}
+		default : {
+			print_indent(indent, "", f);
+			switch (n) {
+			case TYPEID_ctype:
+				DEBUG_ctype(p);
+				break;
+			case TYPEID_err:
+				report(crt_loc, p);
+				break;
+			case TYPEID_etype:
+				DEBUG_etype(p);
+				break;
+			case TYPEID_flt:
+				DEBUG_flt(p);
+				break;
+			case TYPEID_ftype:
+				DEBUG_ftype(p);
+				break;
+			case TYPEID_graph:
+				DEBUG_graph(p);
+				break;
+			case TYPEID_hashid:
+				DEBUG_hashid(p);
+				break;
+			case TYPEID_id:
+				DEBUG_id_long(p);
+				break;
+			case TYPEID_inst:
+				DEBUG_inst(p);
+				break;
+			case TYPEID_itype:
+				DEBUG_itype(p);
+				break;
+			case TYPEID_member:
+				DEBUG_member(p);
+				break;
+			case TYPEID_nat:
+				DEBUG_nat(p);
+				break;
+			case TYPEID_nspace:
+				DEBUG_nspace(p);
+				break;
+			case TYPEID_off:
+				DEBUG_offset(p);
+				break;
+			case TYPEID_str:
+				DEBUG_str(p);
+				break;
+			case TYPEID_tok:
+				DEBUG_sort(p);
+				break;
+			case TYPEID_type:
+				DEBUG_type(p);
+				break;
+			case TYPEID_virt:
+				DEBUG_virt(p);
+				break;
+			case TYPEID_free:
+				fputs_v("FREE\n", f);
+				break;
+			default:
+				fputs_v("UNKNOWN\n", f);
+				break;
-	    }
+			}
+			break;
+		}
+		}
+	} else {
+		print_indent(indent, "NULL\n", f);
+	}
-    } else {
-	print_indent ( indent, "NULL\n", f ) ;
-    }
-    fflush_v ( f ) ;
+	fflush_v(f);
-    debugging-- ;
+	debugging--;
-    return ;
+	return;
+}
-void debug
+void
-    PROTO_N ( ( p ) )
-    PROTO_T ( c_class *p )
+debug(c_class *p)
+{
-    DEBUG_c_class ( p, 0 ) ;
+	DEBUG_c_class(p, 0);
-    return ;
+	return;
+}
 #ifdef DEBUG
 #undef DEBUG
 #endif
-void DEBUG
+void
-    PROTO_N ( ( p ) )
-    PROTO_T ( c_class *p )
+DEBUG(c_class *p)
+{
-    DEBUG_c_class ( p, 0 ) ;
+	DEBUG_c_class(p, 0);
-    return ;
+	return;
+}
 #endif /* c_class_IMPLEMENTATION */
     The terminals used in the parser are listed in two places - in symbols.h
     and in syntax.sid.
 */
 #if FS_STDC_HASH
-#define LEX_TOKEN( A, B, C )	print_terminal ( ( A ), #A, m ) ;
+#define LEX_TOKEN(A, B, C)	print_terminal((A), #A, m);
 #else
-#define LEX_TOKEN( A, B, C )	print_terminal ( ( A ), "A", m ) ;
+#define LEX_TOKEN(A, B, C)	print_terminal((A), "A", m);
 #endif
 /*
     TERMINAL COUNT
     This variable is used to keep count of the number of lexical tokens
     printed.
 */
-static int terminal_no = 0 ;
+static int terminal_no = 0;
 /*
     PRINT A TERMINAL
     This routine prints the single terminal, term, with the given return
     type.  The use argument may be set to false to indicate that the
     terminal is not used in the sid parser.
 */
-static void print_terminal
+static void
-    PROTO_N ( ( t, term, m ) )
-    PROTO_T ( int t X char *term X int m )
+print_terminal(int t, char *term, int m)
+{
-    char c ;
+	char c;
-    FILE *f = DEBUG_file ;
+	FILE *f = DEBUG_file;
-    unsigned long col = 0 ;
+	unsigned long col = 0;
-    unsigned long tab = tab_width ;
+	unsigned long tab = tab_width;
-    while ( *term == ' ' ) term++ ;
+	while (*term == ' ')term++;
-    if ( t != terminal_no ) {
+	if (t != terminal_no) {
-	error ( ERROR_WARNING, "Value of '%s' wrong", term ) ;
+		error(ERROR_WARNING, "Value of '%s' wrong", term);
-    }
-    if ( m ) {
-	term += strlen ( "lex_" ) ;
-    } else {
-	fprintf_v ( f, "#define " ) ;
-	col = ( unsigned long ) strlen ( "#define " ) ;
-    }
-    while ( c = *( term++ ), ( c != 0 && c != ' ' ) ) {
-	if ( c == '_' && m ) c = '-' ;
-	fputc_v ( c, f ) ;
-	col++ ;
-    }
-    if ( m ) {
-	fprintf_v ( f, " ;\n" ) ;
-    } else {
-	while ( col < 5 * tab ) {
-	    fputc_v ( '\t', f ) ;
-	    col = tab * ( col / tab + 1 ) ;
+	}
+	if (m) {
+		term += strlen("lex_");
+	} else {
+		fprintf_v(f, "#define ");
+		col = (unsigned long)strlen("#define ");
+	}
+	while (c = *(term++), (c != 0 && c != ' ')) {
+		if (c == '_' && m) {
+			c = '-';
+		}
+		fputc_v(c, f);
+		col++;
+	}
+	if (m) {
+		fprintf_v(f, " ;\n");
+	} else {
+		while (col < 5 * tab) {
+			fputc_v('\t', f);
+			col = tab *(col / tab + 1);
+		}
-	fprintf_v ( f, "%d\n", terminal_no ) ;
+		fprintf_v(f, "%d\n", terminal_no);
-    }
+	}
-    terminal_no++ ;
+	terminal_no++;
-    return ;
+	return;
+}
 /*
     PRINT ALL THE TERMINALS
     This routine prints all the terminals in a form acceptable to sid.
 */
-static void sid_terminals
+static void
-    PROTO_N ( ( m ) )
-    PROTO_T ( int m )
+sid_terminals(int m)
+{
-    FILE *f = DEBUG_file ;
+	FILE *f = DEBUG_file;
-    terminal_no = 0 ;
+	terminal_no = 0;
-    fprintf_v ( f, "/* Automatically generated list of terminals */\n" ) ;
+	fprintf_v ( f, "/* Automatically generated list of terminals */\n" ) ;
 #include "symbols.h"
 #undef LEX_TOKEN
-    return ;
+	return;
 }
 /*
     PRINT ALL THE ERRORS
     This routine lists all the error names.
 */
-static void list_errors
+static void
-    PROTO_Z ()
+list_errors(void)
 {
-    FILE *f = DEBUG_file ;
+	FILE *f = DEBUG_file;
-    ERR_DATA *p = ERR_CATALOG ;
+	ERR_DATA *p = ERR_CATALOG;
-    init_option ( 0 ) ;
+	init_option(0);
-    while ( p->name ) {
+	while (p->name) {
-	fprintf_v ( f, "%s\n", p->name ) ;
+		fprintf_v(f, "%s\n", p->name);
-	p++ ;
+		p++;
-    }
+	}
-    return ;
+	return;
+}
 /*
     PRINT ALL THE OPTIONS
     This routine lists all the option names.
 */
-static void list_options
+static void
-    PROTO_Z ()
+list_options(void)
 {
-    FILE *f = DEBUG_file ;
+	FILE *f = DEBUG_file;
-    OPT_DATA *p = OPT_CATALOG ;
+	OPT_DATA *p = OPT_CATALOG;
-    while ( p->name ) {
+	while (p->name) {
-	fprintf_v ( f, "%s\n", p->name ) ;
+		fprintf_v(f, "%s\n", p->name);
-	p++ ;
+		p++;
-    }
+	}
-    return ;
+	return;
 }
 /*
     DEFINE ALL THE OPTION VALUES
     This routine prints a list of all option values in a form suitable
     as a usage list in the error catalogue.
 */
-static void define_options
+static void
-    PROTO_Z ()
+define_options(void)
 {
-    int col = 0 ;
+	int col = 0;
-    int comma = 0 ;
+	int comma = 0;
-    CONST char *s ;
+	CONST char *s;
-    FILE *f = DEBUG_file ;
+	FILE *f = DEBUG_file;
-    OPT_DATA *p = OPT_CATALOG ;
+	OPT_DATA *p = OPT_CATALOG;
-    fprintf_v ( f, "    " ) ;
+	fprintf_v(f, "    ");
-    while ( s = p->name, s != NULL ) {
+	while (s = p->name, s != NULL) {
-	char c ;
+		char c;
-	if ( comma ) {
+		if (comma) {
-	    fputc_v ( ',', f ) ;
+			fputc_v(',', f);
+			col++;
+		}
+		if (col > 60) {
+			fprintf_v(f, "\n    ");
+			comma = 0;
+			col = 0;
+		}
+		if (comma) {
+			fputc_v(' ', f);
+			col++;
+		}
+		while (c = *(s++), c != 0) {
+			if (c == '.') {
+				c = '_';
+			}
+			fputc_v(c, f);
-	    col++ ;
+			col++;
+		}
+		comma = 1;
+		p++;
+	}
-	if ( col > 60 ) {
-	    fprintf_v ( f, "\n    " ) ;
-	    comma = 0 ;
-	    col = 0 ;
-	}
-	if ( comma ) {
-	    fputc_v ( ' ', f ) ;
-	    col++ ;
-	}
-	while ( c = *( s++ ), c != 0 ) {
-	    if ( c == '.' ) c = '_' ;
-	    fputc_v ( c, f ) ;
-	    col++ ;
-	}
-	comma = 1 ;
-	p++ ;
-    }
-    fputc_v ( '\n', f ) ;
+	fputc_v('\n', f);
-    return ;
+	return;
+}
 /*
     HANDLE DEBUGGING OPTIONS
     This routine is called to handle the debug option '-d arg'.
 */
-void debug_option
+void
-    PROTO_N ( ( arg ) )
-    PROTO_T ( char *arg )
+debug_option(char *arg)
+{
-    if ( streq ( arg, "error" ) ) {
+	if (streq(arg, "error")) {
-	list_errors () ;
+		list_errors();
-    } else if ( streq ( arg, "lex" ) ) {
+	} else if (streq(arg, "lex")) {
-	sid_terminals ( 0 ) ;
+		sid_terminals(0);
-    } else if ( streq ( arg, "opt" ) ) {
+	} else if (streq(arg, "opt")) {
-	define_options () ;
+		define_options();
-    } else if ( streq ( arg, "option" ) ) {
+	} else if (streq(arg, "option")) {
-	list_options () ;
+		list_options();
-    } else if ( streq ( arg, "sid" ) ) {
+	} else if (streq(arg, "sid")) {
-	sid_terminals ( 1 ) ;
+		sid_terminals(1);
-    } else {
+	} else {
-	error ( ERROR_WARNING, "Unknown option, '-d%s'", arg ) ;
+		error(ERROR_WARNING, "Unknown option, '-d%s'", arg);
-    }
+	}
-    return ;
+	return;
+}
 #else /* RUNTIME */
     not enabled.
 */
 #if c_class_IMPLEMENTATION
-void debug
+void
-   PROTO_N ( ( p ) )
-   PROTO_T ( c_class *p )
+debug(c_class *p)
+{
-    error ( ERROR_INTERNAL, "Not compiled with debugging enabled" ) ;
+	error(ERROR_INTERNAL, "Not compiled with debugging enabled");
-    UNUSED ( p ) ;
+	UNUSED(p);
-    return ;
+	return;
+}
 #endif /* c_class_IMPLEMENTATION */

Subversion Repositories tendra.SVN

(root)/trunk/src/producers/common/utility/debug.c – Rev 2 → 7