136 lines
2.9 KiB
C
136 lines
2.9 KiB
C
#include <iso646.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
|
|
enum {
|
|
HASHSIZE = 101
|
|
};
|
|
|
|
|
|
|
|
/* Shamelessly copied from KnR. */
|
|
typedef struct NLIST {
|
|
char *name;
|
|
void *defn;
|
|
struct NLIST *next;
|
|
} nlist;
|
|
|
|
unsigned int hash(char *s)
|
|
{
|
|
unsigned int hashval;
|
|
|
|
for(hashval = 0; *s != '\0'; s++)
|
|
{
|
|
hashval = *s + 31 * hashval;
|
|
}
|
|
|
|
return hashval % HASHSIZE;
|
|
}
|
|
|
|
static nlist *hashtab[HASHSIZE];
|
|
|
|
struct nlist *lookup(char *s)
|
|
{
|
|
nlist *np;
|
|
|
|
for(np = hashtab[hash(s)];np != NULL; np = np->next)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
/* Key is the name of this particular argument -- "a", "h", or "find", for example */
|
|
/* Value is generally a boolean (to indicate presence), but can be used for other things. */
|
|
/* */
|
|
typedef struct CELL {
|
|
struct CELL *prev;
|
|
char *key;
|
|
char value;
|
|
struct CELL *next;
|
|
} cell;
|
|
|
|
/* arrccat -- function to copy arr2len bytes from arr2 to the arr1len'th position of arr1. returns *newarr, and stores the length */
|
|
/* of newarr[] in arr1len (that's why it needs to be a pointer to arr1len and not just a long unsigned integer). */
|
|
char *arrccat(char *arr1, char *arr2, size_t *arr1len, size_t arr2len)
|
|
{
|
|
char *newarr;
|
|
unsigned int i, i2;
|
|
newarr = malloc(*arr1len+arr2len);
|
|
i = i2 = 0;
|
|
|
|
for(i = 0; i < *arr1len; i++)
|
|
{
|
|
newarr[i] = arr1[i];
|
|
}
|
|
|
|
for(i2 = 0; i2 < arr2len; i2++, i++)
|
|
{
|
|
newarr[i] = arr2[i2];
|
|
}
|
|
|
|
*arr1len = *arr1len+arr2len;
|
|
|
|
return newarr;
|
|
}
|
|
|
|
/* Generate, initialize and return a doubly-linked list cell */
|
|
cell *cellgen(cell *pcell, char *key, int value, cell *ncell)
|
|
{
|
|
cell *newcell = malloc(sizeof(cell));
|
|
|
|
(*newcell).prev = pcell;
|
|
(*newcell).key = key;
|
|
(*newcell).value = value;
|
|
(*newcell).next = ncell;
|
|
|
|
return newcell;
|
|
}
|
|
|
|
/* Generate, initialize and return a doubly-linked list containing one cell per array key */
|
|
/* The final cell is guaranteed to have a value of NULL, 0, 0, NULL and serves as a sentinel. */
|
|
/* argstr is expected to be of similar format to argv -- an array of strings. argstrlen should */
|
|
/* correspond to the number of discrete strings are contained within argstr. */
|
|
cell *arglistgen(char **argstr, unsigned int argstrlen)
|
|
{
|
|
unsigned int i, i2;
|
|
i = i2 = 0;
|
|
cell *ci, *ci2;
|
|
ci = ci2 = 0;
|
|
|
|
for(i = 0; i <= argstrlen; i++)
|
|
{
|
|
if(!ci)
|
|
{
|
|
ci = ci2 = cellgen(NULL, argstr[i], 0, NULL);
|
|
}
|
|
else
|
|
{
|
|
ci -> next = cellgen(ci, argstr[i], 0, NULL);
|
|
ci = ci -> next;
|
|
}
|
|
}
|
|
|
|
|
|
return(ci2);
|
|
}
|
|
|
|
/* inlist_- -- return 1 if an element is in the provided list, 0 otherwise. list should be the first cell in a list */
|
|
int inlist_p(char *tofind, cell *list)
|
|
{
|
|
cell *ci = list;
|
|
|
|
for(; ci -> next != NULL and ci -> key != NULL; ci = ci -> next)
|
|
{
|
|
if(!strcmp(ci->key, tofind))
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|