You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
436 lines
10 KiB
436 lines
10 KiB
/**CFile**********************************************************************
|
|
|
|
FileName [dddmpUtil.c]
|
|
|
|
PackageName [dddmp]
|
|
|
|
Synopsis [Util Functions for the dddmp package]
|
|
|
|
Description [Functions to manipulate arrays.]
|
|
|
|
Author [Gianpiero Cabodi and Stefano Quer]
|
|
|
|
Copyright [
|
|
Copyright (c) 2004 by Politecnico di Torino.
|
|
All Rights Reserved. This software is for educational purposes only.
|
|
Permission is given to academic institutions to use, copy, and modify
|
|
this software and its documentation provided that this introductory
|
|
message is not removed, that this software and its documentation is
|
|
used for the institutions' internal research and educational purposes,
|
|
and that no monies are exchanged. No guarantee is expressed or implied
|
|
by the distribution of this code.
|
|
Send bug-reports and/or questions to:
|
|
{gianpiero.cabodi,stefano.quer}@polito.it.
|
|
]
|
|
|
|
******************************************************************************/
|
|
|
|
#include "dddmpInt.h"
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Stucture declarations */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Type declarations */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Variable declarations */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Macro declarations */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/**AutomaticStart*************************************************************/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Static function prototypes */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
|
|
/**AutomaticEnd***************************************************************/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Definition of exported functions */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Definition of internal functions */
|
|
/*---------------------------------------------------------------------------*/
|
|
|
|
/**Function********************************************************************
|
|
|
|
Synopsis [String compare for qsort]
|
|
|
|
Description [String compare for qsort]
|
|
|
|
SideEffects [None]
|
|
|
|
SeeAlso []
|
|
|
|
******************************************************************************/
|
|
|
|
int
|
|
QsortStrcmp(
|
|
const void *ps1 /* IN: pointer to the first string */,
|
|
const void *ps2 /* IN: pointer to the second string */
|
|
)
|
|
{
|
|
return (strcmp (*((char**)ps1),*((char **)ps2)));
|
|
}
|
|
|
|
/**Function********************************************************************
|
|
|
|
Synopsis [Performs binary search of a name within a sorted array]
|
|
|
|
Description [Binary search of a name within a sorted array of strings.
|
|
Used when matching names of variables.
|
|
]
|
|
|
|
SideEffects [None]
|
|
|
|
SeeAlso []
|
|
|
|
******************************************************************************/
|
|
|
|
int
|
|
FindVarname (
|
|
char *name /* IN: name to look for */,
|
|
char **array /* IN: search array */,
|
|
int n /* IN: size of the array */
|
|
)
|
|
{
|
|
int d, m, u, t;
|
|
|
|
d = 0; u = n-1;
|
|
|
|
while (u>=d) {
|
|
m = (u+d)/2;
|
|
t=strcmp(name,array[m]);
|
|
if (t==0)
|
|
return m;
|
|
if (t<0)
|
|
u=m-1;
|
|
else
|
|
d=m+1;
|
|
}
|
|
|
|
return (-1);
|
|
}
|
|
|
|
|
|
/**Function********************************************************************
|
|
|
|
Synopsis [Duplicates a string]
|
|
|
|
Description [Allocates memory and copies source string]
|
|
|
|
SideEffects [None]
|
|
|
|
SeeAlso []
|
|
|
|
******************************************************************************/
|
|
|
|
char *
|
|
DddmpStrDup (
|
|
char *str /* IN: string to be duplicated */
|
|
)
|
|
{
|
|
char *str2;
|
|
|
|
str2 = DDDMP_ALLOC(char,strlen(str)+1);
|
|
if (str2 != NULL) {
|
|
strcpy (str2,str);
|
|
}
|
|
|
|
return (str2);
|
|
}
|
|
|
|
/**Function********************************************************************
|
|
|
|
Synopsis [Duplicates an array of strings]
|
|
|
|
Description [Allocates memory and copies source array]
|
|
|
|
SideEffects [None]
|
|
|
|
SeeAlso []
|
|
|
|
******************************************************************************/
|
|
|
|
char **
|
|
DddmpStrArrayDup (
|
|
char **array /* IN: array of strings to be duplicated */,
|
|
int n /* IN: size of the array */
|
|
)
|
|
{
|
|
char **array2;
|
|
int i;
|
|
|
|
array2 = DDDMP_ALLOC(char *, n);
|
|
if (array2 == NULL) {
|
|
(void) fprintf (stderr, "DddmpStrArrayDup: Error allocating memory\n");
|
|
fflush (stderr);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* initialize all slots to NULL for fair FREEing in case of failure
|
|
*/
|
|
|
|
for (i=0; i<n; i++) {
|
|
array2[i] = NULL;
|
|
}
|
|
|
|
for (i=0; i<n; i++) {
|
|
if (array[i] != NULL) {
|
|
if ((array2[i]=DddmpStrDup(array[i]))==NULL) {
|
|
DddmpStrArrayFree (array2, n);
|
|
return (NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (array2);
|
|
}
|
|
|
|
/**Function********************************************************************
|
|
|
|
Synopsis [Inputs an array of strings]
|
|
|
|
Description [Allocates memory and inputs source array]
|
|
|
|
SideEffects [None]
|
|
|
|
SeeAlso []
|
|
|
|
******************************************************************************/
|
|
|
|
char **
|
|
DddmpStrArrayRead (
|
|
FILE *fp /* IN: input file */,
|
|
int n /* IN: size of the array */
|
|
)
|
|
{
|
|
char buf[DDDMP_MAXSTRLEN];
|
|
char **array;
|
|
int i;
|
|
|
|
assert(fp!=NULL);
|
|
|
|
array = DDDMP_ALLOC(char *, n);
|
|
if (array == NULL) {
|
|
(void) fprintf (stderr, "DddmpStrArrayRead: Error allocating memory\n");
|
|
fflush (stderr);
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* initialize all slots to NULL for fair FREEing in case of failure
|
|
*/
|
|
for (i=0; i<n; i++)
|
|
array[i] = NULL;
|
|
|
|
for (i=0; i < n; i++) {
|
|
if (fscanf (fp, "%s", buf)==EOF) {
|
|
fprintf (stderr, "DddmpStrArrayRead: Error reading file - EOF found\n");
|
|
fflush (stderr);
|
|
DddmpStrArrayFree (array, n);
|
|
return (NULL);
|
|
}
|
|
if ((array[i]=DddmpStrDup(buf))==NULL) {
|
|
DddmpStrArrayFree (array, n);
|
|
return (NULL);
|
|
}
|
|
}
|
|
|
|
return (array);
|
|
}
|
|
|
|
/**Function********************************************************************
|
|
|
|
Synopsis [Outputs an array of strings]
|
|
|
|
Description [Outputs an array of strings to a specified file]
|
|
|
|
SideEffects [None]
|
|
|
|
SeeAlso []
|
|
|
|
******************************************************************************/
|
|
|
|
int
|
|
DddmpStrArrayWrite (
|
|
FILE *fp /* IN: output file */,
|
|
char **array /* IN: array of strings */,
|
|
int n /* IN: size of the array */
|
|
)
|
|
{
|
|
int i;
|
|
|
|
assert(fp!=NULL);
|
|
|
|
for (i=0; i<n; i++) {
|
|
if (fprintf (fp, " %s", array[i]) == EOF) {
|
|
fprintf (stderr, "DddmpStrArrayWrite: Error writing to file\n");
|
|
fflush (stderr);
|
|
return (EOF);
|
|
}
|
|
}
|
|
|
|
return (n);
|
|
}
|
|
|
|
|
|
/**Function********************************************************************
|
|
|
|
Synopsis [Frees an array of strings]
|
|
|
|
Description [Frees memory for strings and the array of pointers]
|
|
|
|
SideEffects [None]
|
|
|
|
SeeAlso []
|
|
|
|
******************************************************************************/
|
|
|
|
void
|
|
DddmpStrArrayFree (
|
|
char **array /* IN: array of strings */,
|
|
int n /* IN: size of the array */
|
|
)
|
|
{
|
|
int i;
|
|
|
|
if (array == NULL) {
|
|
return;
|
|
}
|
|
|
|
for (i=0; i<n; i++) {
|
|
DDDMP_FREE (array[i]);
|
|
}
|
|
|
|
DDDMP_FREE (array);
|
|
|
|
return;
|
|
}
|
|
|
|
/**Function********************************************************************
|
|
|
|
Synopsis [Duplicates an array of ints]
|
|
|
|
Description [Allocates memory and copies source array]
|
|
|
|
SideEffects [None]
|
|
|
|
SeeAlso []
|
|
|
|
******************************************************************************/
|
|
|
|
int *
|
|
DddmpIntArrayDup (
|
|
int *array /* IN: array of ints to be duplicated */,
|
|
int n /* IN: size of the array */
|
|
)
|
|
{
|
|
int *array2;
|
|
int i;
|
|
|
|
array2 = DDDMP_ALLOC(int, n);
|
|
if (array2 == NULL) {
|
|
(void) fprintf (stderr, "DddmpIntArrayDup: Error allocating memory\n");
|
|
fflush (stderr);
|
|
return (NULL);
|
|
}
|
|
|
|
for (i=0; i<n; i++) {
|
|
array2[i] = array[i];
|
|
}
|
|
|
|
return (array2);
|
|
}
|
|
|
|
|
|
/**Function********************************************************************
|
|
|
|
Synopsis [Inputs an array of ints]
|
|
|
|
Description [Allocates memory and inputs source array]
|
|
|
|
SideEffects [None]
|
|
|
|
SeeAlso []
|
|
|
|
******************************************************************************/
|
|
|
|
int *
|
|
DddmpIntArrayRead (
|
|
FILE *fp /* IN: input file */,
|
|
int n /* IN: size of the array */
|
|
)
|
|
{
|
|
int *array;
|
|
int i;
|
|
|
|
assert(fp!=NULL);
|
|
|
|
array = DDDMP_ALLOC(int, n);
|
|
if (array == NULL) {
|
|
(void) fprintf (stderr, "DddmpIntArrayRead: Error allocating memory\n");
|
|
fflush (stderr);
|
|
return NULL;
|
|
}
|
|
|
|
for (i=0; i < n; i++) {
|
|
if (fscanf (fp, "%d", &array[i])==EOF) {
|
|
(void) fprintf (stderr,
|
|
"DddmpIntArrayRead: Error reading file - EOF found\n");
|
|
fflush (stderr);
|
|
DDDMP_FREE (array);
|
|
return (NULL);
|
|
}
|
|
}
|
|
|
|
return (array);
|
|
}
|
|
|
|
/**Function********************************************************************
|
|
|
|
Synopsis [Outputs an array of ints]
|
|
|
|
Description [Outputs an array of ints to a specified file]
|
|
|
|
SideEffects [None]
|
|
|
|
SeeAlso []
|
|
|
|
******************************************************************************/
|
|
|
|
int
|
|
DddmpIntArrayWrite (
|
|
FILE *fp /* IN: output file */,
|
|
int *array /* IN: array of ints */,
|
|
int n /* IN: size of the array */
|
|
)
|
|
{
|
|
int i;
|
|
|
|
assert(fp!=NULL);
|
|
|
|
for (i=0; i<n; i++) {
|
|
if (fprintf (fp, " %d", array[i]) == EOF) {
|
|
(void) fprintf (stderr, "DddmpIntArrayWrite: Error writing to file\n");
|
|
fflush (stderr);
|
|
return EOF;
|
|
}
|
|
}
|
|
|
|
return (n);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------*/
|
|
/* Definition of static functions */
|
|
/*---------------------------------------------------------------------------*/
|
|
|