util.h

Go to the documentation of this file.

/**

  \file util.h

  \brief Low-level utilities

******************************************************************************/

#ifndef _UTIL
#define _UTIL

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <ctype.h>
#include <math.h>

#include <string.h>
#include <stdlib.h>

#include <assert.h>
#include <unistd.h>
#include <sys/time.h>
#include <tcl.h>
#include "array.h"
#include "var_set.h"
#include "timing.h"

#ifdef NM_DEBUG
#define util_assert( x ) if ( !x ) { fail("util_assert fails!\n"); }
#else
#define util_assert( x )
#endif

#define fail(why) {\
    (void) fprintf(stderr, "Fatal error: file %s, line %d\n%s\n",\
    __FILE__, __LINE__, why);\
    (void) fflush(stdout);\
    abort();\
}

/*
 * A neater way to define zero pointers
 *
 * Usage:
 *  int * fred;
 *  fred = NIL(int);
 */

#define NIL(type)       ((type *) 0)


/** \brief Allocates 'number' objects of type 'type'.  

This macro should be
used rather than calling <code>malloc()</code> directly because it casts the
arguments appropriately, and <code>ALLOC()</code> will never return <code>NIL(char)</code>,
choosing instead to terminate the program.
*/

#  define ALLOC(type, num)  \
    ((type *) MMalloc((long) sizeof(type) * (long) (num)))


/** \brief Re-allocate 'obj' to hold 'number' objects of type 'type'.

This macro should be used rather than calling realloc()
directly because it casts the arguments appropriately, and
REALLOC() will never return NIL(char), instead choosing to
terminate the program.  It also guarantees that REALLOC(type, 0, n)
is the same as ALLOC(type, n).
*/

#  define REALLOC(type, obj, num)   \
    ((type *) MMrealloc((char *) (obj), (long) sizeof(type) * (long) (num)))

/**
  *     \brief  Macro to make an unused variable look like it's used.
  *
  *     Program checkers issue warnings about variables that are
  *     declared but never used.  Most of the time, such variables should be removed
  *     to simplify the code.  However, on occasion we want to keep such variables,
  *     but we don't want program checkers to complain about them.  Using this macro
  *     will make an unused variable look like it's being used.  This macro is
  *     straight out of the gcc documentation, Chapter 5 GCC 3.4.1.<p>
  *
  *     Usage:  put USE immediately after the variable gcc -Wall complains about<p>
  *     Example: int foo USE;
  *
  */


#define USE  __attribute__((unused))


// old decls abound

#ifndef EXTERN
#  define EXTERN extern
#endif

#ifndef ABS
#  define ABS(a) ((a) < 0 ? -(a) : (a))
#endif

#ifndef MAX
#  define MAX(a,b)              ((a) > (b) ? (a) : (b))
#endif

#ifndef MIN
#  define MIN(a,b)              ((a) < (b) ? (a) : (b))
#endif

#ifndef HUGE_VAL
#  ifndef HUGE
#    define HUGE  8.9884656743115790e+307
#  endif
#  define HUGE_VAL HUGE
#endif

#ifndef MAXINT
#  define MAXINT (1 << 30)
#endif




/**
  * \brief  Types of modes in which to open files.
  * 
  * Types of modes in which to open files.
  * 
  */


typedef enum
{
  Util_FileOverWrite_c,
  Util_FileAppend_c
} Util_FileOpenMode_t;

/**
  * \brief  Struct to represent int-arrays.
  * 
  * Struct to represent int-arrays. We allocate a single block
  * of sizeof(int) + sizeof(int*) + length * sizeof(int),
  * so entries is not malloced seperately.  This saves
  * one call to malloc, its associated wastage, also gives
  * us better locality of reference.
  * 
  */


struct util_int_array_t
{
  int length;
  int *entries;
};

typedef struct util_int_array_t util_int_array_t;

/**
  * \brief  Struct to represent byte-array.
  * 
  * Struct to represent byte-array. Need length because cannot
  * depend on null termination, as 0 may be present in array. As
  * with int arrays, allocate as sizeof(int) + sizeof(char*) + 
  * length * sizeof(char). 
  * 
  */


struct util_byte_array_t
{
  int length;
  char *bytes;
};

typedef struct util_byte_array_t util_byte_array_t;


/**
  *     \brief  Attribute-value pair used to read formula
  *
  */

struct util_attrib_val_t
{
  char *rawAttribute;
  char *rawValue;
};

typedef struct util_attrib_val_t util_attrib_val_t;


/*---------------------------------------------------------------------------*/
/* Function prototypes                                                       */
/*---------------------------------------------------------------------------*/

extern void MMout_of_memory (int);
extern char *MMalloc (int);
extern char *MMrealloc (char *, int);
extern void MMfree (char *);


extern void util_print_cpu_stats (FILE *);
extern void util_getopt_reset (void);
extern int util_getopt (int, char **, char *);
extern char *util_optarg;

extern char *util_path_search (char *);
extern char *util_file_search (char *, char *, char *);
extern int util_save_image (char *, char *);
extern int strstrN (char *, char *, int);
extern char *util_strsav (char *);
extern char *util_strchr_N (char *, char, int);
extern int util_strequal (char *, char *);
extern char *util_strmax (char *, char *);
extern char *util_strmin (char *, char *);
extern int util_strequalN (char *, char *, int);
extern char *util_strcat (char *, char *);
extern char *util_strcat3 (char *, char *, char *);
extern char *util_strcat5 (char *, char *, char *, char *, char *);
extern char *util_sgets (array_t *, char *);
extern char *util_file_to_string (FILE *);
extern array_t *util_process_file (char *);
extern array_t *util_get_raw_rules (char *);
extern char *util_get_full_line (array_t *, char *);

util_byte_array_t *util_byte_array_join (util_byte_array_t *,
                     util_byte_array_t *);
int util_byte_array_free (util_byte_array_t *);
int util_byte_array_print (util_byte_array_t *);
int util_byte_array_hash (char *, int);
u_int32_t util_fast_hash (const char *, int);
int util_byte_array_cmp (char *, char *);
util_byte_array_t *util_byte_array_create (char *, int);
util_byte_array_t *util_byte_array_to_lower_case (util_byte_array_t *);

int util_int_array_print (util_int_array_t *);
int util_int_array_free (util_int_array_t *);
util_int_array_t *util_int_array_create (int);
util_int_array_t *util_arrayT_to_int_array (array_t *);
util_int_array_t *var_set_to_int_array (var_set_t *);

// random number generation code
double util_unit_rand ();
int util_rand_int ();

// code for timing 
void util_set_processor_frequency ();
void util_time (char *);
u_int32_t util_time_to_ticks (double);
array_t *util_time_stamp_init (int);
void util_time_stamp_set (array_t *, int);
void util_time_stamp_print (array_t *);

// code for performance checking

extern int Perf_CheckHardware (ClientData cd, Tcl_Interp * interp, int objc,
                   Tcl_Obj * const objv[]);
extern int Perf_TimePerf (ClientData cd, Tcl_Interp * interp, int objc,
              Tcl_Obj * const objv[]);
extern int Perf_TimePerf2 (ClientData cd, Tcl_Interp * interp, int objc,
               Tcl_Obj * const objv[]);
extern int Perf_SpacePerf (ClientData cd, Tcl_Interp * interp, int objc,
               Tcl_Obj * const objv[]);
extern int Perf_CheckTimingCode (ClientData cd, Tcl_Interp * interp, int objc,
                 Tcl_Obj * const objv[]);

#ifdef __cplusplus
}
#endif


#endif /* _UTIL */