pan/symbol.c - platform/external/ltp - Gitiles

 /*
  * Copyright (c) 2000 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  *
  * Further, this software is distributed without any warranty that it is
  * free of the rightful claim of any third person regarding infringement
  * or the like.  Any license provided herein, whether implied or
  * otherwise, applies only to this software file.  Patent licenses, if
  * any, provided herein do not apply to combinations of this program with
  * other software, or any other product whatsoever.
  *
  * You should have received a copy of the GNU General Public License along
  * with this program; if not, write the Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
  * Mountain View, CA  94043, or:
  *
  * http://www.sgi.com
  *
  * For further information regarding this notice, see:
  *
  * http://oss.sgi.com/projects/GenInfo/NoticeExplan/
  *
  */
 /* $Id: symbol.c,v 1.4 2002/05/28 16:26:16 robbiew Exp $ */
 /*
  *			Generic Symbol Table
  *
  * This is intended to look a lot like ndbm, except that all information
  * is kept in memory, and a multi-key, hierarchical access mode is provided.
  * This is largely patterned after the Berkeley "DB" package.
  *
  *			    Requirements
  *
  *	- "key" is ASCII (a C string, in fact)
  *
  *			Symbol Table Structure
  *
  *	Two data structures:
  *		Symbol Table Header
  *		Symbol Table Node
  *
  *	A symbol table header consists of a magic number, a pointer to
  *	the first node in the symbol table, and a cursor that is used
  *	when sequentialy stepping thru the entire list.
  *
  *	Symbol table nodes contain a pointer to a key, a pointer to this
  *	key's data, and a pointer to the next node in the chain.
  *	Note that to create a hierarchical symbol table, a node is created
  *	whose data points to a symbol table header.
  */

 #include <stdio.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include "symbol.h"
 #include "splitstr.h"

 #define SYM_MAGIC	0xbadc0de

 /*
  * Some functions can report an error message by assigning it to this
  * string.
  */

 static char *sym_error = NULL;

 /*
  *	Memory Allocators
  *
  * newsym() allocates a new symbol table header node
  * mknode(...) allocates a new symbol table entry
  */

 SYM newsym()
 {
 	SYM h;

 	if ((h = (SYM) malloc(sizeof(struct symh))) == NULL) {
 		sym_error = "sym header malloc failed!";
 		return (NULL);
 	}

 	h->magic = SYM_MAGIC;
 	h->sym = NULL;
 	h->cursor = NULL;
 	return (h);
 }

 static struct sym *mknode(struct sym *next, char *key, void *data)
 {
 	struct sym *n;

 	if ((n = (struct sym *)malloc(sizeof(struct sym))) == NULL) {
 		sym_error = "sym node malloc failed!";
 		return (NULL);
 	}

 	n->next = next;
 	n->key = strdup(key);
 	n->data = data;

 	if (n->key == NULL) {
 		sym_error = "sym node strdup(key) failed!";
 		return (NULL);
 	}
 	return (n);
 }

 /*
  * Search for a key in a single-level symbol table hierarchy.
  */
 static struct sym *find_key1(struct sym *sym, char *key)
 {
 	while (sym != NULL)
 		if (strcmp(sym->key, key) == 0)
 			return (sym);
 		else
 			sym = sym->next;
 	return (NULL);
 }

 /*
  * Create a new key node, add it to the *end* of this list
  */
 static int add_key(SYM sym, char *key, void *data)
 {
 	register struct sym *sn;

 	if (sym->sym == NULL) {
 		sym->sym = mknode(NULL, key, data);
 		if (sym->sym == NULL) {
 			return (-1);
 		}
 	} else {
 		for (sn = sym->sym; sn != NULL && sn->next != NULL;
 		     sn = sn->next) ;
 		sn->next = mknode(NULL, key, data);
 		assert(sn->next != NULL);
 		if (sn->next == NULL)
 			return (-1);
 	}
 	return (0);
 }

 /*
  *  Create a new symbol table
  */
 SYM sym_open(int flags, int mode, int openinfo)
 {
 	return (newsym());
 }

 /*
  *	Add (key, data) to an existing symbol table
  *
  *  If the key does not exist, a new key is added to the end of the list.
  *  If the key exists and the PUT_REPLACE flag is not supplied, return EEXIST.
  *  If a symbol table entry in a multi-part key is not a symbol table (i.e.
  *  element two of a three or more element key), return ENOTDIR.
  *
  *  "data" is not duplicated and must not point to a static area that could
  *  go away before the element is deleted (such as a local string in a
  *  function)
  *
  *  "key" is duplicated as needed, and is not modified.
  *
  * Code:
  * chop up key on commas
  *
  * search until a key element isn't found in the key tree, the key list is
  * exhausted, or a key's data element is not a sub-tree
  *
  * if the key list is exhausted, return a "duplicate entry" error
  *
  * if the last found key's data element is not a sub-tree, return
  * something like "ENOTDIR".
  *
  * add new keys for sub-trees until key list is exhausted;
  * last node gets 'data'.
  *
  */
 int sym_put(SYM sym, char *key, void *data, int flags)
 {
 	const char **keys;	/* key split into a 2d string array */
 	char **kk;
 	char *nkey;		/* copy of 'key' -- before split */
 	SYM csym, ncsym;	/* search: current symbol table */
 	struct sym *nsym = NULL;	/* search: found symbol entry */

 	if (sym == NULL)
 		return (EINVAL);

 	nkey = strdup(key);
 	keys = splitstr(key, ",", NULL);

 	if (keys == NULL)
 		return (EINVAL);

 	for (kk = (char **)keys, csym = sym;
 	     *kk != NULL && (nsym = find_key1(csym->sym, *kk)) != NULL;
 	     csym = nsym->data) {

 		if (*++kk == NULL)
 			break;

 		if (nsym->data == NULL) {	/* fatal error */
 			free(nkey);
 			splitstr_free(keys);
 			return (ENOTDIR);
 		}
 		if (((SYM) (nsym->data))->magic != SYM_MAGIC) {
 			free(nkey);
 			splitstr_free(keys);
 			return (ENOTDIR);
 		}
 	}

 	if (*kk == NULL) {	/* found a complete match */
 		free(nkey);
 		splitstr_free(keys);

 		if (flags == PUT_REPLACE) {
 			nsym->data = data;
 			return (0);
 		} else {
 			return (EEXIST);
 		}
 	}

 	/* csym is a ptr to a list */
 	for (; *kk != NULL; kk++) {
 		if (*(kk + 1) != NULL) {
 			add_key(csym, *kk, (void *)(ncsym = newsym()));
 			csym = ncsym;
 		} else {
 			add_key(csym, *kk, data);	/* last key */
 		}
 	}

 	free(nkey);
 	splitstr_free(keys);
 	return (0);
 }

 /*
  *	Retrieve a Symbol's Contents
  *
  *  "key" is not modified.
  *  If the key cannot be found, NULL is returned
  */
 void *sym_get(SYM sym, char *key)
 {
 	char *nkey;
 	const char **keys;	/* key split into a 2d string array */
 	char **kk;
 	SYM csym;		/* search: current symbol table */
 	struct sym *nsym = NULL;	/* search: found symbol entry */

 	if (sym == NULL)
 		return (NULL);

 	nkey = strdup(key);
 	keys = splitstr(nkey, ",", NULL);
 	if (keys == NULL)
 		return (NULL);

 	for (kk = (char **)keys, csym = sym;
 	     *kk != NULL && (nsym = find_key1(csym->sym, *kk)) != NULL;
 	     csym = nsym->data) {

 		if (*++kk == NULL)
 			break;

 		if (nsym->data == NULL) {	/* fatal error */
 			free(nkey);
 			splitstr_free(keys);
 			return (NULL);
 		}
 		if (((SYM) (nsym->data))->magic != SYM_MAGIC) {
 			free(nkey);
 			splitstr_free(keys);
 			return (NULL);
 		}
 	}

 	if (*kk == NULL) {	/* found a complete match */
 		splitstr_free(keys);
 		free(nkey);
 		return (nsym->data);
 	} else {
 		splitstr_free(keys);
 		free(nkey);
 		return (NULL);
 	}
 }

 /*
  *  Step thru a symbol table list
  *
  *  The cursor must be set by R_CURSOR, R_FIRST before using R_NEXT.
  *  NULL is returned when no more items are available.
  */
 int sym_seq(SYM sym, DBT * key, DBT * data, int flags)
 {
 	SYM csym;

 	switch (flags) {
 		/*
 		 * A number of ways to do this:
 		 * specificly: sym_seq( .., "key,key") sets to Nth element of the 2nd
 		 *  level symbol table
 		 * sym_seq(.., "key,key,") sets to the first element of the 3rd
 		 *  level symbol table
 		 *
 		 * sym_seq(.., "key,key") where both must be complete keys, sets
 		 *  cursor to the first element of the 3rd level symbol table;
 		 *  if there is no 3rd level, return an error.
 		 */
 	case R_CURSOR:
 		csym = (SYM) sym_get(sym, (char *)key->data);
 		if (csym == NULL || csym->magic != SYM_MAGIC) {
 			return (2);
 		}
 		sym->cursor = csym->sym;
 		if (sym->cursor == NULL)
 			return (1);
 		key->data = sym->cursor->key;
 		data->data = sym->cursor->data;

 		return (0);

 	case R_FIRST:
 		sym->cursor = sym->sym;
 		if (sym->cursor == NULL)
 			return (1);
 		key->data = sym->cursor->key;
 		data->data = sym->cursor->data;

 		return (0);

 	case R_NEXT:
 		if (sym->cursor == NULL)
 			return (1);
 		sym->cursor = sym->cursor->next;

 		if (sym->cursor == NULL)
 			return (1);

 		key->data = sym->cursor->key;
 		data->data = sym->cursor->data;

 		return (0);

 	case R_LAST:
 	case R_PREV:
 	default:
 		return (-1);
 	}
 }

 /*
  *	Dump a symbol table's keys.
  *	Handles hierarchies, using a double quote to indicate depth, one
  *	double quote for each level.
  */
 int sym_dump(SYM sym, int depth)
 {

 	register struct sym *se;	/* symbol entry */
 	register int d;

 	if (sym == NULL || sym->magic != SYM_MAGIC)
 		return -1;

 	for (se = sym->sym; se != NULL; se = se->next) {
 		for (d = 0; d < depth; d++) {
 			putchar('"');
 			putchar(' ');
 		}
 		printf("%s\n", se->key);
 		sym_dump((SYM) se->data, depth + 1);
 	}
 	return 0;
 }

 /*
  * sym dump, but data is _always_ a string (print it)
  */
 int sym_dump_s(SYM sym, int depth)
 {

 	register struct sym *se;	/* symbol entry */
 	register int d;

 	if (sym == NULL)
 		return 0;

 	if (sym->magic != SYM_MAGIC) {
 		for (d = 0; d < depth; d++) {
 			putchar('"');
 			putchar(' ');
 		}
 		printf(" = %s\n", (char *)sym);
 		return 0;
 	}

 	for (se = sym->sym; se != NULL; se = se->next) {
 		for (d = 0; d < depth; d++) {
 			putchar('"');
 			putchar(' ');
 		}
 		printf("%s", se->key);
 		if (((SYM) se->data)->magic == SYM_MAGIC) {
 			putchar('\n');
 			sym_dump_s((SYM) se->data, depth + 1);
 		} else {
 			printf("(%p) = %s (%p)\n", se->key, (char *)se->data,
 			       se->data);
 		}
 	}
 	return 0;
 }

 /*
  *	Remove an entire symbol table (done bottom up)
  */
 int sym_rm(SYM sym, int flags)
 {
 	register struct sym *se, *nse;	/* symbol entry */

 	if (sym == NULL)
 		return 0;

 	if (sym->magic != SYM_MAGIC) {
 		if (!(flags & RM_DATA))
 			free(sym);
 		return 0;
 	}

 	for (se = sym->sym; se != NULL;) {
 		sym_rm((SYM) se->data, flags);
 		nse = se->next;
 		if (flags & RM_KEY)
 			free(se->key);
 		if (flags & RM_DATA)
 			free(se->data);
 		free(se);
 		se = nse;
 	}
 	if (!(flags & RM_DATA))
 		free(sym);
 	return 0;
 }
	/*
	* Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
	*
	* This program is free software; you can redistribute it and/or modify it
	* under the terms of version 2 of the GNU General Public License as
	* published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it would be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	*
	* Further, this software is distributed without any warranty that it is
	* free of the rightful claim of any third person regarding infringement
	* or the like. Any license provided herein, whether implied or
	* otherwise, applies only to this software file. Patent licenses, if
	* any, provided herein do not apply to combinations of this program with
	* other software, or any other product whatsoever.
	*
	* You should have received a copy of the GNU General Public License along
	* with this program; if not, write the Free Software Foundation, Inc.,
	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
	* Mountain View, CA 94043, or:
	*
	* http://www.sgi.com
	*
	* For further information regarding this notice, see:
	*
	* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
	*
	*/
	/* $Id: symbol.c,v 1.4 2002/05/28 16:26:16 robbiew Exp $ */
	/*
	* Generic Symbol Table
	*
	* This is intended to look a lot like ndbm, except that all information
	* is kept in memory, and a multi-key, hierarchical access mode is provided.
	* This is largely patterned after the Berkeley "DB" package.
	*
	* Requirements
	*
	* - "key" is ASCII (a C string, in fact)
	*
	* Symbol Table Structure
	*
	* Two data structures:
	* Symbol Table Header
	* Symbol Table Node
	*
	* A symbol table header consists of a magic number, a pointer to
	* the first node in the symbol table, and a cursor that is used
	* when sequentialy stepping thru the entire list.
	*
	* Symbol table nodes contain a pointer to a key, a pointer to this
	* key's data, and a pointer to the next node in the chain.
	* Note that to create a hierarchical symbol table, a node is created
	* whose data points to a symbol table header.
	*/

	#include <stdio.h>
	#include <errno.h>
	#include <stdlib.h>
	#include <string.h>
	#include <assert.h>
	#include "symbol.h"
	#include "splitstr.h"

	#define SYM_MAGIC 0xbadc0de

	/*
	* Some functions can report an error message by assigning it to this
	* string.
	*/

	static char *sym_error = NULL;

	/*
	* Memory Allocators
	*
	* newsym() allocates a new symbol table header node
	* mknode(...) allocates a new symbol table entry
	*/

	SYM newsym()
	{
	SYM h;

	if ((h = (SYM) malloc(sizeof(struct symh))) == NULL) {
	sym_error = "sym header malloc failed!";
	return (NULL);
	}

	h->magic = SYM_MAGIC;
	h->sym = NULL;
	h->cursor = NULL;
	return (h);
	}

	static struct sym mknode(struct sym next, char key, void data)
	{
	struct sym *n;

	if ((n = (struct sym *)malloc(sizeof(struct sym))) == NULL) {
	sym_error = "sym node malloc failed!";
	return (NULL);
	}

	n->next = next;
	n->key = strdup(key);
	n->data = data;

	if (n->key == NULL) {
	sym_error = "sym node strdup(key) failed!";
	return (NULL);
	}
	return (n);
	}

	/*
	* Search for a key in a single-level symbol table hierarchy.
	*/
	static struct sym find_key1(struct sym sym, char *key)
	{
	while (sym != NULL)
	if (strcmp(sym->key, key) == 0)
	return (sym);
	else
	sym = sym->next;
	return (NULL);
	}

	/*
	* Create a new key node, add it to the end of this list
	*/
	static int add_key(SYM sym, char key, void data)
	{
	register struct sym *sn;

	if (sym->sym == NULL) {
	sym->sym = mknode(NULL, key, data);
	if (sym->sym == NULL) {
	return (-1);
	}
	} else {
	for (sn = sym->sym; sn != NULL && sn->next != NULL;
	sn = sn->next) ;
	sn->next = mknode(NULL, key, data);
	assert(sn->next != NULL);
	if (sn->next == NULL)
	return (-1);
	}
	return (0);
	}

	/*
	* Create a new symbol table
	*/
	SYM sym_open(int flags, int mode, int openinfo)
	{
	return (newsym());
	}

	/*
	* Add (key, data) to an existing symbol table
	*
	* If the key does not exist, a new key is added to the end of the list.
	* If the key exists and the PUT_REPLACE flag is not supplied, return EEXIST.
	* If a symbol table entry in a multi-part key is not a symbol table (i.e.
	* element two of a three or more element key), return ENOTDIR.
	*
	* "data" is not duplicated and must not point to a static area that could
	* go away before the element is deleted (such as a local string in a
	* function)
	*
	* "key" is duplicated as needed, and is not modified.
	*
	* Code:
	* chop up key on commas
	*
	* search until a key element isn't found in the key tree, the key list is
	* exhausted, or a key's data element is not a sub-tree
	*
	* if the key list is exhausted, return a "duplicate entry" error
	*
	* if the last found key's data element is not a sub-tree, return
	* something like "ENOTDIR".
	*
	* add new keys for sub-trees until key list is exhausted;
	* last node gets 'data'.
	*
	*/
	int sym_put(SYM sym, char key, void data, int flags)
	{
	const char *keys; / key split into a 2d string array */
	char **kk;
	char nkey; / copy of 'key' -- before split */
	SYM csym, ncsym; /* search: current symbol table */
	struct sym nsym = NULL; / search: found symbol entry */

	if (sym == NULL)
	return (EINVAL);

	nkey = strdup(key);
	keys = splitstr(key, ",", NULL);

	if (keys == NULL)
	return (EINVAL);

	for (kk = (char **)keys, csym = sym;
	kk != NULL && (nsym = find_key1(csym->sym, kk)) != NULL;
	csym = nsym->data) {

	if (*++kk == NULL)
	break;

	if (nsym->data == NULL) { /* fatal error */
	free(nkey);
	splitstr_free(keys);
	return (ENOTDIR);
	}
	if (((SYM) (nsym->data))->magic != SYM_MAGIC) {
	free(nkey);
	splitstr_free(keys);
	return (ENOTDIR);
	}
	}

	if (kk == NULL) { / found a complete match */
	free(nkey);
	splitstr_free(keys);

	if (flags == PUT_REPLACE) {
	nsym->data = data;
	return (0);
	} else {
	return (EEXIST);
	}
	}

	/* csym is a ptr to a list */
	for (; *kk != NULL; kk++) {
	if (*(kk + 1) != NULL) {
	add_key(csym, kk, (void )(ncsym = newsym()));
	csym = ncsym;
	} else {
	add_key(csym, kk, data); / last key */
	}
	}

	free(nkey);
	splitstr_free(keys);
	return (0);
	}

	/*
	* Retrieve a Symbol's Contents
	*
	* "key" is not modified.
	* If the key cannot be found, NULL is returned
	*/
	void sym_get(SYM sym, char key)
	{
	char *nkey;
	const char *keys; / key split into a 2d string array */
	char **kk;
	SYM csym; /* search: current symbol table */
	struct sym nsym = NULL; / search: found symbol entry */

	if (sym == NULL)
	return (NULL);

	nkey = strdup(key);
	keys = splitstr(nkey, ",", NULL);
	if (keys == NULL)
	return (NULL);

	for (kk = (char **)keys, csym = sym;
	kk != NULL && (nsym = find_key1(csym->sym, kk)) != NULL;
	csym = nsym->data) {

	if (*++kk == NULL)
	break;

	if (nsym->data == NULL) { /* fatal error */
	free(nkey);
	splitstr_free(keys);
	return (NULL);
	}
	if (((SYM) (nsym->data))->magic != SYM_MAGIC) {
	free(nkey);
	splitstr_free(keys);
	return (NULL);
	}
	}

	if (kk == NULL) { / found a complete match */
	splitstr_free(keys);
	free(nkey);
	return (nsym->data);
	} else {
	splitstr_free(keys);
	free(nkey);
	return (NULL);
	}
	}

	/*
	* Step thru a symbol table list
	*
	* The cursor must be set by R_CURSOR, R_FIRST before using R_NEXT.
	* NULL is returned when no more items are available.
	*/
	int sym_seq(SYM sym, DBT * key, DBT * data, int flags)
	{
	SYM csym;

	switch (flags) {
	/*
	* A number of ways to do this:
	* specificly: sym_seq( .., "key,key") sets to Nth element of the 2nd
	* level symbol table
	* sym_seq(.., "key,key,") sets to the first element of the 3rd
	* level symbol table
	*
	* sym_seq(.., "key,key") where both must be complete keys, sets
	* cursor to the first element of the 3rd level symbol table;
	* if there is no 3rd level, return an error.
	*/
	case R_CURSOR:
	csym = (SYM) sym_get(sym, (char *)key->data);
	if (csym == NULL \|\| csym->magic != SYM_MAGIC) {
	return (2);
	}
	sym->cursor = csym->sym;
	if (sym->cursor == NULL)
	return (1);
	key->data = sym->cursor->key;
	data->data = sym->cursor->data;

	return (0);

	case R_FIRST:
	sym->cursor = sym->sym;
	if (sym->cursor == NULL)
	return (1);
	key->data = sym->cursor->key;
	data->data = sym->cursor->data;

	return (0);

	case R_NEXT:
	if (sym->cursor == NULL)
	return (1);
	sym->cursor = sym->cursor->next;

	if (sym->cursor == NULL)
	return (1);

	key->data = sym->cursor->key;
	data->data = sym->cursor->data;

	return (0);

	case R_LAST:
	case R_PREV:
	default:
	return (-1);
	}
	}

	/*
	* Dump a symbol table's keys.
	* Handles hierarchies, using a double quote to indicate depth, one
	* double quote for each level.
	*/
	int sym_dump(SYM sym, int depth)
	{

	register struct sym se; / symbol entry */
	register int d;

	if (sym == NULL \|\| sym->magic != SYM_MAGIC)
	return -1;

	for (se = sym->sym; se != NULL; se = se->next) {
	for (d = 0; d < depth; d++) {
	putchar('"');
	putchar(' ');
	}
	printf("%s\n", se->key);
	sym_dump((SYM) se->data, depth + 1);
	}
	return 0;
	}

	/*
	* sym dump, but data is _always_ a string (print it)
	*/
	int sym_dump_s(SYM sym, int depth)
	{

	register struct sym se; / symbol entry */
	register int d;

	if (sym == NULL)
	return 0;

	if (sym->magic != SYM_MAGIC) {
	for (d = 0; d < depth; d++) {
	putchar('"');
	putchar(' ');
	}
	printf(" = %s\n", (char *)sym);
	return 0;
	}

	for (se = sym->sym; se != NULL; se = se->next) {
	for (d = 0; d < depth; d++) {
	putchar('"');
	putchar(' ');
	}
	printf("%s", se->key);
	if (((SYM) se->data)->magic == SYM_MAGIC) {
	putchar('\n');
	sym_dump_s((SYM) se->data, depth + 1);
	} else {
	printf("(%p) = %s (%p)\n", se->key, (char *)se->data,
	se->data);
	}
	}
	return 0;
	}

	/*
	* Remove an entire symbol table (done bottom up)
	*/
	int sym_rm(SYM sym, int flags)
	{
	register struct sym se, nse; /* symbol entry */

	if (sym == NULL)
	return 0;

	if (sym->magic != SYM_MAGIC) {
	if (!(flags & RM_DATA))
	free(sym);
	return 0;
	}

	for (se = sym->sym; se != NULL;) {
	sym_rm((SYM) se->data, flags);
	nse = se->next;
	if (flags & RM_KEY)
	free(se->key);
	if (flags & RM_DATA)
	free(se->data);
	free(se);
	se = nse;
	}
	if (!(flags & RM_DATA))
	free(sym);
	return 0;
	}