defaults.c

操作系统SunOS 4.1.3版本的源码

		read_private_database();
		if (read_defaults_database &&
			defaults_get_boolean("/Defaults/Read_Defaults_Database",
				True, (int *)NULL))  {
			read_master_database();
		}
		defaults->test_mode =
		    defaults_get_boolean("/Defaults/Test_Mode",
		    	False, (int *)NULL);
	}
}


/*
 * defaults_lookup(name, pairs) will linearly scan the Pairs data structure
 * looking for Name.  The value associated with Name will be returned.
 * If Name can not be found in Pairs, the value assoicated with NULL will
 * be returned.  (The Pairs data structure must be terminated with NULL.)
 */
int
defaults_lookup(name, pairs)
	register char		*name;	/* Name to look up */
	register Defaults_pairs	*pairs;	/* Default */
{
	register Defaults_pairs	*pair;	/* Current pair */

	for (pair = pairs; pair->name != NULL; pair++){
		if (name == NULL)
			continue;
		if (symbol_equal(name, pair->name))
			break;
	}
	return pair->value;
}

/*
 * defaults_reread(path_name, status) will reread the portion of the database
 * associated with Path_Name.
 */
/*ARGSUSED*/
void
defaults_reread(path_name, status)
	char		*path_name;	/* Path name to reread */
	int		*status;	/* Status flag */
{
#ifdef WILL_IMPLEMENT
	Symbol		name[MAX_NAME];	/* Temporary name */
	register Symbol	*name_pointer;	/* Name pointer */
	register Node	node;		/* Parent node */
#endif

	defaults = NULL;
}


/*
 * clear_status(status) will clear the status flag if it is non-NULL.
 */
void
clear_status(status)
	int	*status;	/* Status flag */
{
	if (status != NULL)
		warn("Somebody passed a non-NULL status code");
}


/*
 * defaults_create() will intialize the global defaults object.
 */
void
defaults_create()
{
	Symbol			name[1];	/* Empty name */
	register Defaults	new_defaults;	/* New defaults object */
	extern Hash hash_create();

	/* Create hash tables. */
	new_defaults = (Defaults)hash_get_memory(sizeof *defaults);
	defaults = new_defaults;
	new_defaults->database_dir = NULL;
	new_defaults->errors = 0;
	new_defaults->nodes = hash_create(250,
		NULL, (CHAR_FUNC)name_equal, name_hash, (INT_FUNC)NULL, NULL, (INT_FUNC)NULL, 7);
	new_defaults->prefix = NULL;
	new_defaults->private_dir = NULL;
	new_defaults->root = node_create();
	new_defaults->symbols = (Hash)hash_create(250,
		NULL, (CHAR_FUNC)symbol_equal, symbol_hash, (INT_FUNC)NULL, NULL, (INT_FUNC)NULL, 7);
	new_defaults->test_mode = False;
	name[0] = NULL;
	(void)hash_insert((Hash)new_defaults->nodes, (caddr_t)name_copy(name), (caddr_t)new_defaults->root);
}

/*
 * get_data(size) will get size words of memory.
 */
static long *
get_data(size)
	int	size;		/* Number of words to allocate */
{
	long	*data;		/* Pointer to beginning of data */

	data = (long *)hash_get_memory(size<<2);	/* Machine dependent! */
	return data;
}

/*
 * name_cat(dest_name, source_name) will concatonate Source_Name onto the
 * end of Dest_Name.
 */
static void
name_cat(dest_name, source_name)
	Symbol	*dest_name;	/* Destination name */
	Symbol	*source_name;	/* Source name */
{
	name_move(dest_name + name_length(dest_name), source_name);
}

/*
 * name_copy(name) will make and return a copy of Name.
 */
Name
name_copy(name)
	Name		name;		/* Name to copy */
{
	Name		new;		/* New name */

	new = (Name)get_data(name_length(name) + 1);
	name_move(new, name);
	return new;
}

/*
 * name_equal(name1, name2) will return True if Name1 equals Name2.
 */
static Bool
name_equal(name1, name2)
	register Name	name1;		/* First name */
	register Name	name2;		/* Second name */
{
	register Symbol	symbol1;	/* Symbol from first name */
	register Symbol	symbol2;	/* Symbol from second name */

	while (True){
		symbol1 = *name1++;
		symbol2 = *name2++;
		if (symbol1 != symbol2)
			return False;
		if (symbol1 == NULL)
			return True;
	}
}

/*
 * name_hash(name) will return a hash of Name.
 */
static int
name_hash(name)
	register Name	name;	/* Name to hash */
{
	register Symbol	symbol;	/* Symbol from name */
	register int	hash;	/* Hash value */

	hash = 0;
	do {	symbol = *name++;
		hash += (int)symbol;
	} while (symbol != NULL);
	return hash;
}

/*
 * name_length(name) will return the number of symbols in Name.
 */
int
name_length(name)
	register Name	name;	/* Name to return length of */
{
	register int	length;	/* Length of name */

	length = 0;
	while (*name++ != NULL)
		length++;
	return length;
}

/*
 * name_move(dest, source) will the name Source over to the name Dest.
 */
static int
name_move(dest, source)
	register Name	dest;		/* Destination name */
	register Name	source;		/* Source Name */
{
	while (*source != NULL)
		*dest++ = *source++;
	*dest = NULL;
}

/*
 * name_parse(in_file, symbols, default_name, name) will parse a node name
 * read from In_File into its component symbols and store the resulting
 * parts into Name.  Default symbols will be read from Default_Name.  The
 * symbol hash table is Symbols.  The number of simple node names in the full
 * node name will be returned.  0 will be returned on an error.
 */
/*ARGSUSED*/
static int
name_parse(in_file, symbols, default_name, name)
	register FILE	*in_file;	/* Input file */
	Hash		symbols;	/* Symbol hash table */
	Name		default_name;	/* Default name */
	register Name	name;		/* Place to store resultant name */
{
	register int	chr;		/* Temporary character */
	register int	default_size;	/* Size of default name */
	register Bool	fully;		/* TRUE => fully specified node name */
	register char	*symbol;	/* Current symbol */
	register int	size;		/* Number of parts in name */
	char		temp[MAX_STRING]; /* Temporary symbol name */

	size = 0;
	chr = parse_whitespace(in_file);
	fully = (Bool)(chr == SEP_CHR);
	if (fully){
		/* Fully specified node name. */
		(void) getchr(in_file);	/* Dispose of leading '/' */
		/* Process leading default_names. */
		while (True){
			chr = getchr(in_file);
			if (chr != SEP_CHR)
				break;
			if (*default_name == NULL){
				(void)strcpy(temp, SEP_STR);
				(void)strcat(temp, SEP_STR);
				warn("No default available for '%s'", temp);
				*name = NULL;
				return size;
			}
			*name++ = *default_name++;
			size++;
		}
		(void)ungetchr(chr, in_file);
	} else {
		/* Partially specified node name. */
		/* Copy over as many default_names as are available. */
		default_size = 0;
		while (*default_name != NULL){
			*name++ = *default_name++;
			default_size++;
		}
	}

	/* Process each simple node name. */
	while (chr_letter(chr) || chr_digit(chr)){
		if (parse_symbol(in_file, &temp[0]) == NULL)
			return 0;
		symbol = symbol_lookup(&temp[0]);
		*name++ = symbol;
		size++;
		if (fully){
			*default_name++ = symbol;
			*default_name = NULL;
		}
		chr = getchr(in_file);
		if ((chr == ' ') || (chr == '\t') ||
		    (chr == '\n') || (chr == EOF))
			break;
		if (chr == SEP_CHR){
			chr = getchr(in_file);
			(void)ungetchr(chr, in_file);
		}
		else {
			warn("'%c' found in node name", chr);
			break;
		}
	}
	(void)ungetchr(chr, in_file);
	*name = NULL;
	if (size > 0)
		size += default_size;
	return size;
}

/*
 * name_quick_parse(path_name, name) will quickly parse Path_Name and store
 * the result into Name.
 */
void
name_quick_parse(path_name, name)
	char		*path_name;	/* Full name string */
	Name		name;		/* Place to store parsed name */
{
	register char	chr;		/* Temporary character */
	register char	*full_pointer;	/* Pointer into full name */
	register Name	name_pointer;	/* Pointer into name */
	char		temp[MAX_STRING]; /* Temporary name */
	register char	*temp_pointer;	/* Pointer into temporary name */

	/* Build up the name. */
	full_pointer = path_name;
	if (*full_pointer++ != SEP_CHR){
		warn("'%s' does not start with '%c'.", path_name, SEP_CHR);
		name[0] = NULL;
		return;
	}
	name_pointer = name;
	while (True){
		temp_pointer = &temp[0];
		while (True){
			chr = *full_pointer++;
			if ((chr == SEP_CHR) || (chr == '\0'))
				break;
			if (chr_letter(chr) || chr_digit(chr))
				*temp_pointer++ = chr;
			else {
				warn("'%c' is not permitted in %s",
							    chr, path_name);
				name[0] = NULL;
				return;
			}
		}
		*temp_pointer = '\0';
		*name_pointer++ = symbol_lookup(&temp[0]);
		if (chr == '\0')
			break;
	}
	*name_pointer = NULL;
}

/*
 * name_unparse(name, data) will write the string corresponding to Name
 * into Data.  If Data is NULL, a new string will be allocated.
 */
char *
name_unparse(name, data)
	register Name	name;		/* Name to unparse */
	register char	*data;		/* Data to unparse */
{
	register int	size;		/* Size of string */
	register Name	temp;		/* Temporary name */

	if (name == NULL){
		if (data == NULL)
			data = hash_get_memory(2);
		(void)strcpy(data, SEP_STR);
		return data;
	}
	if (data == NULL){
		size = 0;
		temp = name;
		while (*temp != NULL)
			size += strlen(*temp++) + 1;
		data = hash_get_memory(size + 1);
	}
	data[0] = '\0';
	while (*name != NULL){
		(void)strcat(data, SEP_STR);
		(void)strcat(data, *name++);
	}
	return data;
}

/*
 * node_create() will create and return an empty node.
 */
static Node
node_create()
{
	register Node	node;	/* New node */

	node = (Node)hash_get_memory(sizeof *node);
	node->child = NULL;
	node->default_value = DEFAULTS_UNDEFINED;
	node->deleted = False;
	node->file = False;
	node->name = NULL;
	node->next = NULL;
	node->parent = NULL;
	node->private = False;
	node->value = DEFAULTS_UNDEFINED;
	return node;
}

/*
 * node_delete(node) will cause Node and its descendentes to be "deleted".
 * The nodes will only be marked as deleted.  No storage will be deallocated.
 */
void
node_delete(node)
	register Node	node;	/* Node to delete */
{
	node->deleted = True;
	for (node = node->child; node != NULL; node = node->next)
		node_delete(node);
}

/*
 * node_delete_private(node) will cause Node and its descendentes to be
 * "deleted".  The nodes will only be marked as deleted.  No storage will be
 * deallocated.
 */
void
node_delete_private(node)
	register Node	node;	/* Node to delete */
{
	
	if (node->private)
		node->deleted = True;
	for (node = node->child; node != NULL; node = node->next)
		node_delete_private(node);
}

/*
 * node_find_name(name, multiple, status) will return the node associated with
 * Name from the defaults database.  The important side effect of this routine
 * is that it makes for sure that all the nodes between Name and the root node
 * both exist and are properly threaded together.  If Multiple is TRUE,
 * multiple lookups will be performed to prefixes.
 */
/*ARGSUSED*/
Node
node_find_name(name, multiple, status)
	register Name	name;		/* Name to lookup/enter */
	Bool		multiple;	/* TRUE => multiple prefix lookups */
	int		*status;	/* Status flag */
{
	register int	length;		/* Name length */
	register Node	next;		/* Next node at same level */
	register Node	node;		/* Node that is looked up */
	char		path_name[MAX_STRING]; /* Path name */
	Node		parent;		/* Parent node */
	Symbol		symbol;		/* Node symbol */

	if (status != NULL){
		(void)name_unparse(name, path_name);
		warn("Status is non-NULL in %s", path_name);
	}

	if (defaults == NULL)
		defaults_init(True);

	if (defaults->test_mode)
		return NULL;

	/* The root node is special. */
	if (name[0] == NULL)
		return defaults->root;

	/* Just return it if it is already in the Nodes table. */
	read_lazy(name);
	node = (Node)hash_lookup(defaults->nodes, (caddr_t)name);
	if (node != NULL){
		node->deleted = False;
		return node;
	}

	/* Get the parent node. */
	length = name_length(name);
	symbol = name[length - 1];
	name[length - 1] = NULL;
	parent = node_find_name(name, False, status);
	name[length - 1] = symbol;

	/* Create the new node. */
	node = node_create();
	name = name_copy(name);
	node->name = name;
	node->parent = parent;

	/* Thread this node onto the end of the parent next list. */
	next = parent->child;
	if (next == NULL)
		parent->child = node;
	else {
		while (next->next != NULL)
			next = next->next;
		next->next = node;
	}

	/* Insert the node into the Nodes hash table. */
	(void)hash_insert(defaults->nodes, name, node);
	return node;
}