VPR-6.0

libvpr/util.c File Reference

#include <string.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include "util.h"
Include dependency graph for util.c:

Go to the source code of this file.

Defines

#define CHUNK_SIZE   32768
#define FRAGMENT_THRESHOLD   100
#define IA   1103515245u
#define IC   12345u
#define IM   2147483648u
#define CHECK_RAND

Functions

int limit_value (int cur, int max, const char *name)
char * my_strncpy (char *dest, const char *src, size_t size)
FILE * my_fopen (const char *fname, const char *flag, int prompt)
char * my_strdup (const char *str)
int my_atoi (const char *str)
void * my_calloc (size_t nelem, size_t size)
void * my_malloc (size_t size)
void * my_realloc (void *ptr, size_t size)
void * my_chunk_malloc (size_t size, struct s_linked_vptr **chunk_ptr_head, int *mem_avail_ptr, char **next_mem_loc_ptr)
void free_chunk_memory (struct s_linked_vptr *chunk_ptr_head)
struct s_linked_vptrinsert_in_vptr_list (struct s_linked_vptr *head, void *vptr_to_add)
struct s_linked_vptrdelete_in_vptr_list (struct s_linked_vptr *head)
t_linked_intinsert_in_int_list (t_linked_int *head, int data, t_linked_int **free_list_head_ptr)
void free_int_list (t_linked_int **int_list_head_ptr)
void alloc_ivector_and_copy_int_list (t_linked_int **list_head_ptr, int num_items, struct s_ivec *ivec, t_linked_int **free_list_head_ptr)
char * my_fgets (char *buf, int max_size, FILE *fp)
char * my_strtok (char *ptr, char *tokens, FILE *fp, char *buf)
void free_ivec_vector (struct s_ivec *ivec_vector, int nrmin, int nrmax)
void free_ivec_matrix (struct s_ivec **ivec_matrix, int nrmin, int nrmax, int ncmin, int ncmax)
void free_ivec_matrix3 (struct s_ivec ***ivec_matrix3, int nrmin, int nrmax, int ncmin, int ncmax, int ndmin, int ndmax)
void ** alloc_matrix (int nrmin, int nrmax, int ncmin, int ncmax, size_t elsize)
void free_matrix (void *vptr, int nrmin, int nrmax, int ncmin, size_t elsize)
void *** alloc_matrix3 (int nrmin, int nrmax, int ncmin, int ncmax, int ndmin, int ndmax, size_t elsize)
void **** alloc_matrix4 (int nrmin, int nrmax, int ncmin, int ncmax, int ndmin, int ndmax, int nemin, int nemax, size_t elsize)
void print_int_matrix3 (int ***vptr, int nrmin, int nrmax, int ncmin, int ncmax, int ndmin, int ndmax, char *file)
void free_matrix3 (void *vptr, int nrmin, int nrmax, int ncmin, int ncmax, int ndmin, size_t elsize)
void free_matrix4 (void *vptr, int nrmin, int nrmax, int ncmin, int ncmax, int ndmin, int ndmax, int nemin, size_t elsize)
void my_srandom (int seed)
int my_irand (int imax)
float my_frand (void)

Variables

int linenum
char * OutFilePrefix = NULL
static int cont
static unsigned int current_random = 0

Detailed Description

This file contains utility functions widely used in my programs. Many are simply versions of file and memory grabbing routines that take the same arguments as the standard library ones, but exit the program if they find an error condition.

Definition in file util.c.


Define Documentation

#define CHECK_RAND

Definition at line 767 of file util.c.

#define CHUNK_SIZE   32768
#define FRAGMENT_THRESHOLD   100
#define IA   1103515245u

Definition at line 764 of file util.c.

#define IC   12345u

Definition at line 765 of file util.c.

#define IM   2147483648u

Definition at line 766 of file util.c.


Function Documentation

void alloc_ivector_and_copy_int_list ( t_linked_int **  list_head_ptr,
int  num_items,
struct s_ivec ivec,
t_linked_int **  free_list_head_ptr 
)

Allocates an integer vector with num_items elements and copies the integers from the list pointed to by list_head (of which there must be num_items) over to it. The int_list is then put on the free list, and the list_head_ptr is set to NULL.

Definition at line 391 of file util.c.

{
    t_linked_int *linked_int, *list_head;
    int i, *list;

    list_head = *list_head_ptr;

    if(num_items == 0)
        {                       /* Empty list. */
            ivec->nelem = 0;
            ivec->list = NULL;

            if(list_head != NULL)
                {
                    printf(ERRTAG
                           "alloc_ivector_and_copy_int_list: Copied %d elements, "
                           "but list at %p contains more.\n", num_items,
                           (void *)list_head);
                    exit(1);
                }
            return;
        }

    ivec->nelem = num_items;
    list = (int *)my_malloc(num_items * sizeof(int));
    ivec->list = list;
    linked_int = list_head;

    for(i = 0; i < num_items - 1; i++)
        {
            list[i] = linked_int->data;
            linked_int = linked_int->next;
        }

    list[num_items - 1] = linked_int->data;

    if(linked_int->next != NULL)
        {
            printf
                ("Error in alloc_ivector_and_copy_int_list:\n Copied %d elements, "
                 "but list at %p contains more.\n", num_items,
                 (void *)list_head);
            exit(1);
        }

    linked_int->next = *free_list_head_ptr;
    *free_list_head_ptr = list_head;
    *list_head_ptr = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void** alloc_matrix ( int  nrmin,
int  nrmax,
int  ncmin,
int  ncmax,
size_t  elsize 
)

allocates an generic matrix with nrmax-nrmin + 1 rows and ncmax - ncmin + 1 columns, with each element of size elsize. i.e. returns a pointer to a storage block [nrmin..nrmax][ncmin..ncmax]. Simply cast the returned array pointer to the proper type.

Definition at line 593 of file util.c.

{

    int i;
    char **cptr;

    cptr = (char **)my_malloc((nrmax - nrmin + 1) * sizeof(char *));
    cptr -= nrmin;
    for(i = nrmin; i <= nrmax; i++)
        {
            cptr[i] = (char *)my_malloc((ncmax - ncmin + 1) * elsize);
            cptr[i] -= ncmin * elsize / sizeof(char);   /* sizeof(char) = 1 */
        }
    return ((void **)cptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void*** alloc_matrix3 ( int  nrmin,
int  nrmax,
int  ncmin,
int  ncmax,
int  ndmin,
int  ndmax,
size_t  elsize 
)

allocates a 3D generic matrix with nrmax-nrmin + 1 rows, ncmax - ncmin + 1 columns, and a depth of ndmax-ndmin + 1, with each element of size elsize. i.e. returns a pointer to a storage block [nrmin..nrmax][ncmin..ncmax][ndmin..ndmax]. Simply cast the returned array pointer to the proper type.

Definition at line 632 of file util.c.

{

    int i, j;
    char ***cptr;

    cptr = (char ***)my_malloc((nrmax - nrmin + 1) * sizeof(char **));
    cptr -= nrmin;
    for(i = nrmin; i <= nrmax; i++)
        {
            cptr[i] =
                (char **)my_malloc((ncmax - ncmin + 1) * sizeof(char *));
            cptr[i] -= ncmin;
            for(j = ncmin; j <= ncmax; j++)
                {
                    cptr[i][j] =
                        (char *)my_malloc((ndmax - ndmin + 1) * elsize);
                    cptr[i][j] -= ndmin * elsize / sizeof(char);        /* sizeof(char) = 1) */
                }
        }
    return ((void ***)cptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void**** alloc_matrix4 ( int  nrmin,
int  nrmax,
int  ncmin,
int  ncmax,
int  ndmin,
int  ndmax,
int  nemin,
int  nemax,
size_t  elsize 
)

allocates a 3D generic matrix with nrmax-nrmin + 1 rows, ncmax - ncmin + 1 columns, and a depth of ndmax-ndmin + 1, with each element of size elsize. i.e. returns a pointer to a storage block [nrmin..nrmax][ncmin..ncmax][ndmin..ndmax]. Simply cast the returned array pointer to the proper type.

Definition at line 663 of file util.c.

{

    int i, j, k;
    char ****cptr;

    cptr = (char ****)my_malloc((nrmax - nrmin + 1) * sizeof(char ***));
    cptr -= nrmin;
    for(i = nrmin; i <= nrmax; i++)
        {
            cptr[i] =
                (char ***)my_malloc((ncmax - ncmin + 1) * sizeof(char **));
            cptr[i] -= ncmin;
            for(j = ncmin; j <= ncmax; j++)
                {
                    cptr[i][j] =
                        (char **)my_malloc((ndmax - ndmin + 1) *
                                           sizeof(char *));
                    cptr[i][j] -= ndmin;
                    for(k = ndmin; k <= ndmax; k++)
                        {
                            cptr[i][j][k] =
                                (char *)my_malloc((nemax - nemin + 1) *
                                                  elsize);
                            cptr[i][j][k] -= nemin * elsize / sizeof(char);     /* sizeof(char) = 1) */
                        }
                }
        }
    return ((void ****)cptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct s_linked_vptr* delete_in_vptr_list ( struct s_linked_vptr head) [read]

Deletes the element at the head of a linked list of void pointers. Returns the new head of the list.

Definition at line 326 of file util.c.

{
    struct s_linked_vptr *linked_vptr;

    if (head == NULL)
        return NULL;
    linked_vptr = head->next;
    free(head);
    return linked_vptr; /* New head of the list */
}
void free_chunk_memory ( struct s_linked_vptr chunk_ptr_head)

Frees the memory allocated by a sequence of calls to my_chunk_malloc.

Definition at line 290 of file util.c.

{
    struct s_linked_vptr *curr_ptr, *prev_ptr;

    curr_ptr = chunk_ptr_head;

    while(curr_ptr != NULL)
        {
            free(curr_ptr->data_vptr);  /* Free memory "chunk". */
            prev_ptr = curr_ptr;
            curr_ptr = curr_ptr->next;
            free(prev_ptr);     /* Free memory used to track "chunk". */
        }
}

Here is the caller graph for this function:

void free_int_list ( t_linked_int **  int_list_head_ptr)

This routine truly frees (calls free) all the integer list elements on the linked list pointed to by *head, and sets head = NULL.

Definition at line 368 of file util.c.

{

    t_linked_int *linked_int, *next_linked_int;

    linked_int = *int_list_head_ptr;

    while(linked_int != NULL)
        {
            next_linked_int = linked_int->next;
            free(linked_int);
            linked_int = next_linked_int;
        }

    *int_list_head_ptr = NULL;
}

Here is the caller graph for this function:

void free_ivec_matrix ( struct s_ivec **  ivec_matrix,
int  nrmin,
int  nrmax,
int  ncmin,
int  ncmax 
)

Frees a 2D matrix of integer vectors (ivecs).

Definition at line 543 of file util.c.

{
    int i, j;

    for(i = nrmin; i <= nrmax; i++)
        {
            for(j = ncmin; j <= ncmax; j++)
                {
                    if(ivec_matrix[i][j].nelem != 0)
                        {
                            free(ivec_matrix[i][j].list);
                        }
                }
        }

    free_matrix(ivec_matrix, nrmin, nrmax, ncmin, sizeof(struct s_ivec));
}

Here is the call graph for this function:

void free_ivec_matrix3 ( struct s_ivec ***  ivec_matrix3,
int  nrmin,
int  nrmax,
int  ncmin,
int  ncmax,
int  ndmin,
int  ndmax 
)

Frees a 3D matrix of integer vectors (ivecs).

Definition at line 564 of file util.c.

{
    int i, j, k;

    for(i = nrmin; i <= nrmax; i++)
        {
            for(j = ncmin; j <= ncmax; j++)
                {
                    for(k = ndmin; k <= ndmax; k++)
                        {
                            if(ivec_matrix3[i][j][k].nelem != 0)
                                {
                                    free(ivec_matrix3[i][j][k].list);
                                }
                        }
                }
        }

    free_matrix3(ivec_matrix3, nrmin, nrmax, ncmin, ncmax, ndmin,
                 sizeof(struct s_ivec));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void free_ivec_vector ( struct s_ivec ivec_vector,
int  nrmin,
int  nrmax 
)

Frees a 1D array of integer vectors.

Definition at line 530 of file util.c.

{
    int i;

    for(i = nrmin; i <= nrmax; i++)
        if(ivec_vector[i].nelem != 0)
            free(ivec_vector[i].list);

    free(ivec_vector + nrmin);
}

Here is the caller graph for this function:

void free_matrix ( void *  vptr,
int  nrmin,
int  nrmax,
int  ncmin,
size_t  elsize 
)

Definition at line 613 of file util.c.

{
    int i;
    char **cptr;

    cptr = (char **)vptr;

    for(i = nrmin; i <= nrmax; i++)
        free(cptr[i] + ncmin * elsize / sizeof(char));
    free(cptr + nrmin);
}

Here is the caller graph for this function:

void free_matrix3 ( void *  vptr,
int  nrmin,
int  nrmax,
int  ncmin,
int  ncmax,
int  ndmin,
size_t  elsize 
)

Definition at line 722 of file util.c.

{
    int i, j;
    char ***cptr;

    cptr = (char ***)vptr;

    for(i = nrmin; i <= nrmax; i++)
        {
            for(j = ncmin; j <= ncmax; j++)
                free(cptr[i][j] + ndmin * elsize / sizeof(char));
            free(cptr[i] + ncmin);
        }
    free(cptr + nrmin);
}

Here is the caller graph for this function:

void free_matrix4 ( void *  vptr,
int  nrmin,
int  nrmax,
int  ncmin,
int  ncmax,
int  ndmin,
int  ndmax,
int  nemin,
size_t  elsize 
)

Definition at line 740 of file util.c.

{
    int i, j, k;
    char ****cptr;

    cptr = (char ****)vptr;

    for(i = nrmin; i <= nrmax; i++)
        {
            for(j = ncmin; j <= ncmax; j++)
                {
                    for(k = ndmin; k <= ndmax; k++)
                                free(cptr[i][j][k] + nemin * elsize / sizeof(char));
                    free(cptr[i][j] + ndmin * elsize / sizeof(char));
                }
            free(cptr[i] + ncmin);
        }
    free(cptr + nrmin);
}

Here is the caller graph for this function:

t_linked_int* insert_in_int_list ( t_linked_int head,
int  data,
t_linked_int **  free_list_head_ptr 
)

Inserts a new element at the head of a linked list of integers. Returns the new head of the list. One argument is the address of the head of a list of free ilist elements. If there are any elements on this free list, the new element is taken from it. Otherwise a new one is malloced.

Definition at line 343 of file util.c.

{

    t_linked_int *linked_int;

    if(*free_list_head_ptr != NULL)
        {
            linked_int = *free_list_head_ptr;
            *free_list_head_ptr = linked_int->next;
        }
    else
        {
            linked_int = (t_linked_int *) my_malloc(sizeof(t_linked_int));
        }

    linked_int->data = data;
    linked_int->next = head;
    return (linked_int);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct s_linked_vptr* insert_in_vptr_list ( struct s_linked_vptr head,
void *  vptr_to_add 
) [read]

Inserts a new element at the head of a linked list of void pointers. Returns the new head of the list.

Definition at line 309 of file util.c.

{

    struct s_linked_vptr *linked_vptr;

    linked_vptr = (struct s_linked_vptr *)my_malloc(sizeof(struct
                                                           s_linked_vptr));

    linked_vptr->data_vptr = vptr_to_add;
    linked_vptr->next = head;
    return (linked_vptr);       /* New head of the list */
}

Here is the call graph for this function:

Here is the caller graph for this function:

int limit_value ( int  cur,
int  max,
const char *  name 
)

Returns the min of cur and max. If cur > max, a warning is emitted.

Definition at line 25 of file util.c.

{
    if(cur > max)
        {
            printf(WARNTAG "%s is being limited from [%d] to [%d]\n",
                   name, cur, max);
            return max;
        }
    return cur;
}
int my_atoi ( const char *  str)

Returns the integer represented by the first part of the character string.

Definition at line 120 of file util.c.

{

    if(str[0] < '0' || str[0] > '9')
        {
            if(!(str[0] == '-' && str[1] >= '0' && str[1] <= '9'))
                {
                    printf(ERRTAG "expected number instead of '%s'.\n", str);
                    exit(1);
                }
        }
    return (atoi(str));
}

Here is the caller graph for this function:

void* my_calloc ( size_t  nelem,
size_t  size 
)

Definition at line 135 of file util.c.

{
    void *ret;
        if(nelem == 0) {
                return NULL;
        }

    if((ret = calloc(nelem, size)) == NULL)
        {
            fprintf(stderr, "Error:  Unable to calloc memory.  Aborting.\n");
            exit(1);
        }
    return (ret);
}
void* my_chunk_malloc ( size_t  size,
struct s_linked_vptr **  chunk_ptr_head,
int *  mem_avail_ptr,
char **  next_mem_loc_ptr 
)

This routine should be used for allocating fairly small data structures where memory-efficiency is crucial. This routine allocates large "chunks" of data, and parcels them out as requested. Whenever it mallocs a new chunk it adds it to the linked list pointed to by chunk_ptr_head. This list can be used to free the chunked memory. If chunk_ptr_head is NULL, no list of chunked memory blocks will be kept -- this is useful for data structures that you never intend to free as it means you don't have to keep track of the linked lists. Information about the currently open "chunk" must be stored by the user program. mem_avail_ptr points to an int storing how many bytes are left in the current chunk, while next_mem_loc_ptr is the address of a pointer to the next free bytes in the chunk. To start a new chunk, simply set *mem_avail_ptr = 0. Each independent set of data structures should use a new chunk.

Definition at line 207 of file util.c.

{

/* To make sure the memory passed back is properly aligned, I must *
 * only send back chunks in multiples of the worst-case alignment  *
 * restriction of the machine.  On most machines this should be    *
 * a long, but on 64-bit machines it might be a long long or a     *
 * double.  Change the typedef below if this is the case.          */

    typedef long Align;

#define CHUNK_SIZE 32768
#define FRAGMENT_THRESHOLD 100

    char *tmp_ptr;
    int aligned_size;

    assert(*mem_avail_ptr >= 0);

    if((size_t) (*mem_avail_ptr) < size)
        {                       /* Need to malloc more memory. */
            if(size > CHUNK_SIZE)
                {               /* Too big, use standard routine. */
                    tmp_ptr = my_malloc(size);

/* When debugging, uncomment the code below to see if memory allocation size */
/* makes sense */
/*#ifdef DEBUG
       printf("NB:  my_chunk_malloc got a request for %d bytes.\n",
          size);
       printf("You should consider using my_malloc for such big requests.\n");
#endif */

                    if(chunk_ptr_head != NULL)
                        *chunk_ptr_head =
                            insert_in_vptr_list(*chunk_ptr_head, tmp_ptr);
                    return (tmp_ptr);
                }

            if(*mem_avail_ptr < FRAGMENT_THRESHOLD)
                {               /* Only a small scrap left. */
                    *next_mem_loc_ptr = my_malloc(CHUNK_SIZE);
                    *mem_avail_ptr = CHUNK_SIZE;
                    if(chunk_ptr_head != NULL)
                        *chunk_ptr_head = insert_in_vptr_list(*chunk_ptr_head,
                                                              *next_mem_loc_ptr);
                }

/* Execute else clause only when the chunk we want is pretty big,  *
 * and would leave too big an unused fragment.  Then we use malloc *
 * to allocate normally.                                           */

            else
                {
                    tmp_ptr = my_malloc(size);
                    if(chunk_ptr_head != NULL)
                        *chunk_ptr_head =
                            insert_in_vptr_list(*chunk_ptr_head, tmp_ptr);
                    return (tmp_ptr);
                }
        }

/* Find the smallest distance to advance the memory pointer and keep *
 * everything aligned.                                               */

    if(size % sizeof(Align) == 0)
        {
            aligned_size = size;
        }
    else
        {
            aligned_size = size + sizeof(Align) - size % sizeof(Align);
        }

    tmp_ptr = *next_mem_loc_ptr;
    *next_mem_loc_ptr += aligned_size;
    *mem_avail_ptr -= aligned_size;
    return (tmp_ptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* my_fgets ( char *  buf,
int  max_size,
FILE *  fp 
)

Get an input line, update the line number and cut off any comment part. A \ at the end of a line with no comment part (#) means continue.

Definition at line 447 of file util.c.

{
    char *val;
    int i;

    cont = 0;
    val = fgets(buf, max_size, fp);
    linenum++;
    if(val == NULL)
        return (val);

/* Check that line completely fit into buffer.  (Flags long line   *
 * truncation).                                                    */

    for(i = 0; i < max_size; i++)
        {
            if(buf[i] == '\n')
                break;
            if(buf[i] == '\0')
                {
                    printf
                        ("Error on line %d -- line is too long for input buffer.\n",
                         linenum);
                    printf("All lines must be at most %d characters long.\n",
                           BUFSIZE - 2);
                    printf
                        ("The problem could also be caused by a missing newline.\n");
                    exit(1);
                }
        }


    for(i = 0; i < max_size && buf[i] != '\0'; i++)
        {
            if(buf[i] == '#')
                {
                    buf[i] = '\0';
                    break;
                }
        }

    if(i < 2)
        return (val);
    if(buf[i - 1] == '\n' && buf[i - 2] == '\\')
        {
            cont = 1;           /* line continued */
            buf[i - 2] = '\n';  /* May need this for tokens */
            buf[i - 1] = '\0';
        }
    return (val);
}

Here is the caller graph for this function:

FILE* my_fopen ( const char *  fname,
const char *  flag,
int  prompt 
)

Uses global var 'OutFilePrefix'

Definition at line 59 of file util.c.

{
    FILE *fp;
    int Len;
    char *new_fname = NULL;
        char prompt_filename[256];

    /* Appends a prefix string for output files */
    if(OutFilePrefix)
        {
            if(strchr(flag, 'w'))
                {
                    Len = 1;    /* NULL char */
                    Len += strlen(OutFilePrefix);
                    Len += strlen(fname);
                    new_fname = (char *)my_malloc(Len * sizeof(char));
                    strcpy(new_fname, OutFilePrefix);
                    strcat(new_fname, fname);
                    fname = new_fname;
                }
        }

        if (prompt) 
        {
                scanf("%s",prompt_filename);
                fname = prompt_filename;
        }

    if(NULL == (fp = fopen(fname, flag)))
        {
            printf("Error opening file %s for %s access.\n", fname, flag);
            exit(1);
        }

    if(new_fname)
        free(new_fname);

    return (fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

float my_frand ( void  )

Creates a random float between 0 and 1. i.e. [0..1).

Definition at line 807 of file util.c.

{
    float fval;
    int ival;

    current_random = current_random * IA + IC;  /* Use overflow to wrap */
    ival = current_random & (IM - 1);   /* Modulus */
    fval = (float)ival / (float)IM;

#ifdef CHECK_RAND
    if((fval < 0) || (fval > 1.))
        {
            printf("Bad value in my_frand, fval = %g\n", fval);
            exit(1);
        }
#endif

    return (fval);
}

Here is the caller graph for this function:

int my_irand ( int  imax)

Creates a random integer between 0 and imax, inclusive. i.e. [0..imax]

Definition at line 779 of file util.c.

{
    int ival;

/* current_random = (current_random * IA + IC) % IM; */
    current_random = current_random * IA + IC;  /* Use overflow to wrap */
    ival = current_random & (IM - 1);   /* Modulus */
    ival = (int)((float)ival * (float)(imax + 0.999) / (float)IM);

#ifdef CHECK_RAND
    if((ival < 0) || (ival > imax))
        {
                if(ival == imax + 1) {
                        /* Due to random floating point rounding, sometimes above calculation gives number greater than ival by 1 */
                        ival = imax;
                } else {
                        printf("Bad value in my_irand, imax = %d  ival = %d\n", imax,
                           ival);
                        exit(1);
                }
        }
#endif

    return (ival);
}

Here is the caller graph for this function:

void* my_malloc ( size_t  size)

Definition at line 151 of file util.c.

{
    void *ret;
        if(size == 0) {
                return NULL;
        }

    if((ret = malloc(size)) == NULL)
        {
            fprintf(stderr, "Error:  Unable to malloc memory.  Aborting.\n");
            abort();
            exit(1);
        }
    return (ret);
}
void* my_realloc ( void *  ptr,
size_t  size 
)

Definition at line 168 of file util.c.

{
    void *ret;

    if(size <= 0)
        {
            printf("reallocating of size <= 0.\n");
        }

    ret = realloc(ptr, size);
    if(NULL == ret)
        {
            printf(ERRTAG "Unable to realloc memory. Aborting. "
                   "ptr=%p, Size=%d.\n", ptr, (int)size);
            if(ptr == NULL)
                {
                    printf(ERRTAG "my_realloc: ptr == NULL. Aborting.\n");
                }
            exit(1);
        }
    return (ret);
}

Here is the caller graph for this function:

void my_srandom ( int  seed)

Definition at line 772 of file util.c.

{
    current_random = (unsigned int)seed;
}

Here is the caller graph for this function:

char* my_strdup ( const char *  str)

Definition at line 100 of file util.c.

{
    int Len;
    char *Dst;

        if(str == NULL) {
                return NULL;
        }

    Len = 1 + strlen(str);
    Dst = (char *)my_malloc(Len * sizeof(char));
    memcpy(Dst, str, Len);

    return Dst;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* my_strncpy ( char *  dest,
const char *  src,
size_t  size 
)

Definition at line 39 of file util.c.

{
    /* Find string's length */
    size_t len = strlen(src);

    /* Cap length at (num - 1) to leave room for \0 */
    if(size <= len)
        len = (size - 1);

    /* Copy as much of string as we can fit */
    memcpy(dest, src, len);

    /* explicit null termination */
    dest[len] = '\0';

    return dest;
}

Here is the caller graph for this function:

char* my_strtok ( char *  ptr,
char *  tokens,
FILE *  fp,
char *  buf 
)

Get next token, and wrap to next line if \ at end of line. There is a bit of a "gotcha" in strtok. It does not make a copy of the character array which you pass by pointer on the first call. Thus, you must make sure this array exists for as long as you are using strtok to parse that line. Don't use local buffers in a bunch of subroutines calling each other; the local buffer may be overwritten when the stack is restored after return from the subroutine.

Definition at line 509 of file util.c.

{

    char *val;

    val = strtok(ptr, tokens);
    for(;;)
        {
            if(val != NULL || cont == 0)
                return (val);

            /* return unless we have a null value and a continuation line */
            if(my_fgets(buf, BUFSIZE, fp) == NULL)
                return (NULL);

            val = strtok(buf, tokens);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void print_int_matrix3 ( int ***  vptr,
int  nrmin,
int  nrmax,
int  ncmin,
int  ncmax,
int  ndmin,
int  ndmax,
char *  file 
)

Definition at line 696 of file util.c.

{
    FILE *outfile;
    int i, j, k;

    outfile = my_fopen(file, "w", 0);

    for(k = nrmin; k <= nrmax; ++k)
        {
            fprintf(outfile, "Plane %d\n", k);
            for(j = ncmin; j <= ncmax; ++j)
                {
                    for(i = ndmin; i <= ndmax; ++i)
                        {
                            fprintf(outfile, "%d ", vptr[k][j][i]);
                        }
                    fprintf(outfile, "\n");
                }
            fprintf(outfile, "\n");
        }

    fclose(outfile);
}

Here is the call graph for this function:


Variable Documentation

int cont [static]

line continued?

Definition at line 19 of file util.c.

unsigned int current_random = 0 [static]

Definition at line 769 of file util.c.

int linenum

Line in file being parsed.

Definition at line 17 of file util.c.

char* OutFilePrefix = NULL

Default prefix string for output files

Definition at line 18 of file util.c.