WebSVN – tendra.SVN – Diff – /branches/tendra5/src/installers/680x0/common/utility.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
 #endif
 #include "common_types.h"
 #include "basicread.h"
 #include "instrs.h"
 #include "utility.h"
-extern long crt_line_num ;
+extern long crt_line_num;
-extern char *crt_fname ;
+extern char *crt_fname;
-extern char *progname ;
+extern char *progname;
-long total_calloced ;
+long total_calloced;
 #if 0
 /* Makes automatically generated makefile work */
 #include "xalloc.c"
 #endif
 /*
     FIND THE BASENAME OF A FILE
     The string nm is analysed and a pointer to the character after the
     last '/' is returned.
 */
-char *basename
+char *
-    PROTO_N ( ( nm ) )
-    PROTO_T ( char *nm )
+basename(char *nm)
 {
-    char *bn = nm ;
+	char *bn = nm;
-    for ( ; *nm ; nm++ ) if ( *nm == '/' ) bn = nm + 1 ;
+	for (; *nm; nm++) {
+		if (*nm == '/') {
+			bn = nm + 1;
+		}
+	}
-    return ( bn ) ;
+	return (bn);
 }
 /*
     FIND THE FIRST NONZERO BIT
     This routine returns the bit number of the least significant set
     bit in n.  For 0 it returns -1.
 */
-int bit_one
+int
-    PROTO_N ( ( n ) )
-    PROTO_T ( bitpattern n )
+bit_one(bitpattern n)
+{
-    int c = 0 ;
+	int c = 0;
-    bitpattern m ;
+	bitpattern m;
-    for ( m = n ; m ; m >>= 1, c++ ) if ( m & 1 ) return ( c ) ;
+	for (m = n; m; m >>= 1, c++) {
+		if (m & 1) {
+			return (c);
+		}
+	}
-    return ( -1 ) ;
+	return (-1);
+}
 /*
     FIND THE NUMBER OF SET BITS
     The number of set bits in n is returned.
 */
-int bits_in
+int
-    PROTO_N ( ( n ) )
-    PROTO_T ( bitpattern n )
+bits_in(bitpattern n)
 {
-    /* Table of bits in : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F */
+	/* Table of bits in : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F */
-    static int b [16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 } ;
+	static int b[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
-    int c = 0 ;
+	int c = 0;
-    while ( n ) {
+	while (n) {
-	c += b [ n & 0xf ] ;
+		c += b[n & 0xf];
-	n >>= 4 ;
+		n >>= 4;
-    }
+	}
-    return ( c ) ;
+	return (c);
 }
 /*
     BIT PATTERNS
     lo_bits [n] is the number with its bottom n bits set and the rest
     zero.  hi_bits [n] is the number with its top n bits set and the rest
     zero.
 */
-bitpattern lo_bits [] = { 0,
+bitpattern lo_bits[] = { 0,
 x00000001, 0x00000003, 0x00000007, 0x0000000f,
 x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
 x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
 x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
 x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
 x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
 x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
-x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff } ;
+x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff };
-bitpattern hi_bits [] = { 0,
+bitpattern hi_bits[] = { 0,
 x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
 xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
 xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
 xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
 xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
 xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
 xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
-xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff } ;
+xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff };
-/*
-    NUMBER OF ERRORS
-    errors is the number of errors which have occurred.  max_errors is
-    the maximum number of errors that will be tolerated before exiting.
-*/
-int errors = 0 ;
-#ifdef EBUG
-int max_errors = 10 ;
-#else
-int max_errors = 1 ;
-#endif
 /*
-    PRINT AN ERROR REPORT
+   NUMBER OF ERRORS
-    This routine prints the error report s together with any additional
+   errors is the number of errors which have occurred.  max_errors is
-    arguments.
+   the maximum number of errors that will be tolerated before exiting.
-*/
+ */
-void error
-    PROTO_V ( ( char *s, ... ) )
-{
-    char c ;
+int errors = 0;
-    char *p ;
-    va_list args ;
-#if FS_STDARG
+#ifdef EBUG
-    va_start ( args, s ) ;
+int max_errors = 10;
-    p = s ;
 #else
-    va_start ( args ) ;
+int max_errors = 1;
-    p = va_arg ( args, char * ) ;
 #endif
+/*
+   PRINT AN ERROR REPORT
+   This routine prints the error report s together with any additional
+   arguments.
+ */
+void
+error(char *s, ...)
+{
+	char c;
+	char *p;
+	va_list args;
+#if FS_STDARG
+	va_start(args, s);
+	p = s;
+#else
+	va_start(args);
+	p = va_arg(args, char *);
+#endif
+	if (progname) {
-    if ( progname ) fprintf ( stderr, "%s : ", progname ) ;
+		fprintf(stderr, "%s : ", progname);
+	}
-    fprintf ( stderr, "Error : " ) ;
+	fprintf(stderr, "Error : ");
-    c = *p ;
+	c = *p;
-    if ( c >= 'a' && c <= 'z' ) {
+	if (c >= 'a' && c <= 'z') {
-	c += ( 'A' - 'a' ) ;
+		c += ('A' - 'a');
-	fputc ( c, stderr ) ;
+		fputc(c, stderr);
-	p++ ;
+		p++;
-    }
+	}
-    vfprintf ( stderr, p, args ) ;
+	vfprintf(stderr, p, args);
-    if ( crt_line_num != -1 && crt_fname ) {
+	if (crt_line_num != -1 && crt_fname) {
-	fprintf ( stderr, ", %s, line %ld", crt_fname, crt_line_num ) ;
+		fprintf(stderr, ", %s, line %ld", crt_fname, crt_line_num);
-    }
+	}
-    fprintf ( stderr, ".\n" ) ;
+	fprintf(stderr, ".\n");
-    va_end ( args ) ;
+	va_end(args);
 #ifdef IGNORE_ERRORS
-    return ;
+	return;
 #endif
-    if ( max_errors == 0 ) exit ( EXIT_FAILURE ) ;
+	if (max_errors == 0) {
+		exit(EXIT_FAILURE);
+	}
-    if ( ++errors > max_errors ) {
+	if (++errors > max_errors) {
-	fprintf ( stderr, "%s : Too many errors.\n", progname ) ;
+		fprintf(stderr, "%s : Too many errors.\n", progname);
-	exit ( EXIT_FAILURE ) ;
+		exit(EXIT_FAILURE);
-    }
+	}
-    return ;
+	return;
 }
 /*
     PRINT A SIMPLE ERROR
     This routine prints the simple error report s.
 */
-void failer
+void
-    PROTO_N ( ( s ) )
-    PROTO_T ( char *s )
+failer(char *s)
 {
-    error ( s ) ;
+	error(s);
-    return ;
+	return;
 }
 /*
     PRINT A WARNING
     This routine prints the warning message s together with any additional
     arguments.
 */
-void warning
+void
-    PROTO_V ( ( char *s, ... ) )
+warning(char *s, ...)
+{
-    char c ;
+	char c;
-    char *p ;
+	char *p;
-    va_list args ;
+	va_list args;
 #if FS_STDARG
-    va_start ( args, s ) ;
+	va_start(args, s);
-    p = s ;
+	p = s;
 #else
-    va_start ( args ) ;
+	va_start(args);
-    p = va_arg ( args, char * ) ;
+	p = va_arg(args, char *);
 #endif
+	if (progname) {
-    if ( progname ) ( void ) fprintf ( stderr, "%s : ", progname ) ;
+		(void)fprintf(stderr, "%s : ", progname);
+	}
-    fprintf ( stderr, "Warning : " ) ;
+	fprintf(stderr, "Warning : ");
-    c = *p ;
+	c = *p;
-    if ( c >= 'a' && c <= 'z' ) {
+	if (c >= 'a' && c <= 'z') {
-	c += ( 'A' - 'a' ) ;
+		c += ('A' - 'a');
-	fputc ( c, stderr ) ;
+		fputc(c, stderr);
-	p++ ;
+		p++;
-    }
+	}
-    ( void ) vfprintf ( stderr, p, args ) ;
+	(void)vfprintf(stderr, p, args);
-    ( void ) fprintf ( stderr, ".\n" ) ;
+	(void)fprintf(stderr, ".\n");
-    va_end ( args ) ;
+	va_end(args);
-    return ;
+	return;
 }
 /*
     MEMORY HACK VALUE
 */
 #define memhack 0
 /*
     ALLOCATE A BLOCK OF MEMORY
     A pointer to a block of memory of size sz is returned.  Failure to
     allocate this memory gives an immediate fatal error.
 */
-voidstar xmalloc
+voidstar
-    PROTO_N ( ( sz ) )
-    PROTO_T ( size_t sz )
+xmalloc(size_t sz)
+{
-    voidstar res ;
+	voidstar res;
+	if (sz == 0) {
-    if ( sz == 0 ) return ( null ) ;
+		return (null);
+	}
-    res = ( voidstar ) malloc ( sz + memhack ) ;
+	res = (voidstar)malloc(sz + memhack);
-    if ( res == null ) {
+	if (res == null) {
-	error ( "Can't allocate memory" ) ;
+		error("Can't allocate memory");
-	exit ( EXIT_FAILURE ) ;
+		exit(EXIT_FAILURE);
-    }
+	}
 #ifdef MEM_DEBUG
-    printf ( "%d (malloc, %d bytes)\n", res, sz ) ;
+	printf("%d (malloc, %d bytes)\n", res, sz);
-    fflush ( stdout ) ;
+	fflush(stdout);
 #endif
-    return ( res ) ;
+	return (res);
+}
 /*
     ALLOCATE ROOM IN MEMORY
     A pointer to a block of memory of size n * sz is returned.  This
     memory is initialized to 0.  Failure to allocate memory gives an
     immediate fatal error.
 */
-voidstar xcalloc
+voidstar
-    PROTO_N ( ( n, sz ) )
-    PROTO_T ( int n X size_t sz )
+xcalloc(int n, size_t sz)
 {
-    voidstar res ;
+	voidstar res;
-    if ( n == 0 || sz == 0 ) return ( null ) ;
+	if (n == 0 || sz == 0) {
+		return (null);
+	}
-    if ( sz == sizeof ( char ) && n < 100 ) {
+	if (sz == sizeof(char) && n < 100) {
-	/* Be careful not to free character arrays */
+		/* Be careful not to free character arrays */
-	static char *cbuffer = null ;
+		static char *cbuffer = null;
-	static size_t cbuffsz = 0 ;
+		static size_t cbuffsz = 0;
-	if ( n + memhack >= cbuffsz ) {
+		if (n + memhack >= cbuffsz) {
-	    cbuffsz = 2000 ;
+			cbuffsz = 2000;
-	    cbuffer = ( char * ) calloc ( cbuffsz, sizeof ( char ) ) ;
+			cbuffer = (char *)calloc(cbuffsz, sizeof(char));
-	    if ( cbuffer == null ) {
+			if (cbuffer == null) {
-		error ( "Can't allocate memory" ) ;
+				error("Can't allocate memory");
-		exit ( EXIT_FAILURE ) ;
+				exit(EXIT_FAILURE);
-	    }
+			}
-	}
+		}
-	res = ( voidstar ) cbuffer ;
+		res = (voidstar)cbuffer;
-	cbuffer += ( n + memhack ) ;
+		cbuffer += (n + memhack);
-	cbuffsz -= ( n + memhack ) ;
+		cbuffsz -= (n + memhack);
-    } else {
+	} else {
-	res = ( voidstar ) calloc ( n + memhack, sz ) ;
+		res = (voidstar)calloc(n + memhack, sz);
-	if ( res == null ) {
+		if (res == null) {
-	    error ( "Can't allocate memory" ) ;
+			error("Can't allocate memory");
-	    exit ( EXIT_FAILURE ) ;
+			exit(EXIT_FAILURE);
-	}
+		}
-    }
+	}
 #ifdef MEM_DEBUG
-    printf ( "%d (calloc, %d bytes)\n", res, n * sz ) ;
+	printf("%d (calloc, %d bytes)\n", res, n * sz);
-    fflush ( stdout ) ;
+	fflush(stdout);
 #endif
-    return ( res ) ;
+	return (res);
 }
 /*
     REALLOCATE A BLOCK OF MEMORY
     The previously allocated memory pointed to by p is reallocated
     to size n.  A pointer to the new block of memory is returned.
     Failure to allocate memory gives an immediate fatal error.
 */
-voidstar xrealloc
+voidstar
-    PROTO_N ( ( p, sz ) )
-    PROTO_T ( voidstar p X size_t sz )
+xrealloc(voidstar p, size_t sz)
+{
-    voidstar res ;
+	voidstar res;
+	if (p == null) {
-    if ( p == null ) return ( xmalloc ( sz ) ) ;
+		return (xmalloc(sz));
+	}
+	if (sz == 0) {
-    if ( sz == 0 ) return ( null ) ;
+		return (null);
+	}
-    res = ( voidstar ) realloc ( p, sz + memhack ) ;
+	res = (voidstar)realloc(p, sz + memhack);
-    if ( res == null ) {
+	if (res == null) {
-	error ( "Can't reallocate memory" ) ;
+		error("Can't reallocate memory");
-	exit ( EXIT_FAILURE ) ;
+		exit(EXIT_FAILURE);
-    }
+	}
 #ifdef MEM_DEBUG
-    printf ( "%d (realloc, %d bytes)\n", res, sz ) ;
+	printf("%d (realloc, %d bytes)\n", res, sz);
-    fflush ( stdout ) ;
+	fflush(stdout);
 #endif
-    return ( res ) ;
+	return (res);
+}
 /*
     FREE A BLOCK OF MEMORY
     The block of memory pointed to by p is returned to free.  p must
     previously have been allocated using one of the routines above.
 */
-void xfree
+void
-    PROTO_N ( ( p ) )
-    PROTO_T ( voidstar p )
+xfree(voidstar p)
+{
-    if ( p == null ) return ;
+	if (p == null) {
+		return;
+	}
-    free ( p ) ;
+	free(p);
-    return ;
+	return;
+}

Subversion Repositories tendra.SVN

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