Synchronised line endinge with release branch

1 files changed, 2660 insertions, 2660 deletions

diff --git a/libX11/src/Xrm.c b/libX11/src/Xrm.c
index 7dff61e68..53467aedc 100644
--- a/libX11/src/Xrm.c
+++ b/libX11/src/Xrm.c
@@ -1,2660 +1,2660 @@
-

-/***********************************************************

-Copyright 1987, 1988, 1990 by Digital Equipment Corporation, Maynard

-

-                        All Rights Reserved

-

-Permission to use, copy, modify, and distribute this software and its

-documentation for any purpose and without fee is hereby granted,

-provided that the above copyright notice appear in all copies and that

-both that copyright notice and this permission notice appear in

-supporting documentation, and that the name Digital not be

-used in advertising or publicity pertaining to distribution of the

-software without specific, written prior permission.

-

-DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

-ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

-DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

-ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

-ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

-SOFTWARE.

-

-******************************************************************/

-/*

-

-Copyright 1987, 1988, 1990, 1998  The Open Group

-

-Permission to use, copy, modify, distribute, and sell this software and its

-documentation for any purpose is hereby granted without fee, provided that

-the above copyright notice appear in all copies and that both that

-copyright notice and this permission notice appear in supporting

-documentation.

-

-The above copyright notice and this permission notice shall be included

-in all copies or substantial portions of the Software.

-

-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

-IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR

-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

-OTHER DEALINGS IN THE SOFTWARE.

-

-Except as contained in this notice, the name of The Open Group shall

-not be used in advertising or otherwise to promote the sale, use or

-other dealings in this Software without prior written authorization

-from The Open Group.

-

-*/

-

-#ifdef HAVE_CONFIG_H

-#include <config.h>

-#endif

-#include	<stdio.h>

-#include	<ctype.h>

-#include	"Xlibint.h"

-#include	<X11/Xresource.h>

-#include	"Xlcint.h"

-#ifdef XTHREADS

-#include	"locking.h"

-#endif

-#include	<X11/Xos.h>

-#include	<sys/stat.h>

-#include "Xresinternal.h"

-#include "Xresource.h"

-

-/*

-

-These Xrm routines allow very fast lookup of resources in the resource

-database.  Several usage patterns are exploited:

-

-(1) Widgets get a lot of resources at one time.  Rather than look up each from

-scratch, we can precompute the prioritized list of database levels once, then

-search for each resource starting at the beginning of the list.

-

-(2) Many database levels don't contain any leaf resource nodes.  There is no

-point in looking for resources on a level that doesn't contain any.  This

-information is kept on a per-level basis.

-

-(3) Sometimes the widget instance tree is structured such that you get the same

-class name repeated on the fully qualified widget name.  This can result in the

-same database level occuring multiple times on the search list.  The code below

-only checks to see if you get two identical search lists in a row, rather than

-look back through all database levels, but in practice this removes all

-duplicates I've ever observed.

-

-Joel McCormack

-

-*/

-

-/*

-

-The Xrm representation has been completely redesigned to substantially reduce

-memory and hopefully improve performance.

-

-The database is structured into two kinds of tables: LTables that contain

-only values, and NTables that contain only other tables.

-

-Some invariants:

-

-The next pointer of the top-level node table points to the top-level leaf

-table, if any.

-

-Within an LTable, for a given name, the tight value always precedes the

-loose value, and if both are present the loose value is always right after

-the tight value.

-

-Within an NTable, all of the entries for a given name are contiguous,

-in the order tight NTable, loose NTable, tight LTable, loose LTable.

-

-Bob Scheifler

-

-*/

-

-static XrmQuark XrmQString, XrmQANY;

-

-typedef	Bool (*DBEnumProc)(

-    XrmDatabase*	/* db */,

-    XrmBindingList	/* bindings */,

-    XrmQuarkList	/* quarks */,

-    XrmRepresentation*	/* type */,

-    XrmValue*		/* value */,

-    XPointer		/* closure */

-);

-

-typedef struct _VEntry {

-    struct _VEntry	*next;		/* next in chain */

-    XrmQuark		name;		/* name of this entry */

-    unsigned int	tight:1;	/* 1 if it is a tight binding */

-    unsigned int	string:1;	/* 1 if type is String */

-    unsigned int	size:30;	/* size of value */

-} VEntryRec, *VEntry;

-

-

-typedef struct _DEntry {

-    VEntryRec		entry;		/* entry */

-    XrmRepresentation	type;		/* representation type */

-} DEntryRec, *DEntry;

-

-/* the value is right after the structure */

-#define StringValue(ve) (XPointer)((ve) + 1)

-#define RepType(ve) ((DEntry)(ve))->type

-/* the value is right after the structure */

-#define DataValue(ve) (XPointer)(((DEntry)(ve)) + 1)

-#define RawValue(ve) (char *)((ve)->string ? StringValue(ve) : DataValue(ve))

-

-typedef struct _NTable {

-    struct _NTable	*next;		/* next in chain */

-    XrmQuark		name;		/* name of this entry */

-    unsigned int	tight:1;	/* 1 if it is a tight binding */

-    unsigned int	leaf:1;		/* 1 if children are values */

-    unsigned int	hasloose:1;	/* 1 if has loose children */

-    unsigned int	hasany:1;	/* 1 if has ANY entry */

-    unsigned int	pad:4;		/* unused */

-    unsigned int	mask:8;		/* hash size - 1 */

-    unsigned int	entries:16;	/* number of children */

-} NTableRec, *NTable;

-

-/* the buckets are right after the structure */

-#define NodeBuckets(ne) ((NTable *)((ne) + 1))

-#define NodeHash(ne,q) NodeBuckets(ne)[(q) & (ne)->mask]

-

-/* leaf tables have an extra level of indirection for the buckets,

- * so that resizing can be done without invalidating a search list.

- * This is completely ugly, and wastes some memory, but the Xlib

- * spec doesn't really specify whether invalidation is OK, and the

- * old implementation did not invalidate.

- */

-typedef struct _LTable {

-    NTableRec		table;

-    VEntry		*buckets;

-} LTableRec, *LTable;

-

-#define LeafHash(le,q) (le)->buckets[(q) & (le)->table.mask]

-

-/* An XrmDatabase just holds a pointer to the first top-level table.

- * The type name is no longer descriptive, but better to not change

- * the Xresource.h header file.  This type also gets used to define

- * XrmSearchList, which is a complete crock, but we'll just leave it

- * and caste types as required.

- */

-typedef struct _XrmHashBucketRec {

-    NTable table;

-    XPointer mbstate;

-    XrmMethods methods;

-#ifdef XTHREADS

-    LockInfoRec linfo;

-#endif

-} XrmHashBucketRec;

-

-/* closure used in get/put resource */

-typedef struct _VClosure {

-    XrmRepresentation	*type;		/* type of value */

-    XrmValuePtr		value;		/* value itself */

-} VClosureRec, *VClosure;

-

-/* closure used in get search list */

-typedef struct _SClosure {

-    LTable		*list;		/* search list */

-    int			idx;		/* index of last filled element */

-    int			limit;		/* maximum index */

-} SClosureRec, *SClosure;

-

-/* placed in XrmSearchList to indicate next table is loose only */

-#define LOOSESEARCH ((LTable)1)

-

-/* closure used in enumerate database */

-typedef struct _EClosure {

-    XrmDatabase db;			/* the database */

-    DBEnumProc proc;			/* the user proc */

-    XPointer closure;			/* the user closure */

-    XrmBindingList bindings;		/* binding list */

-    XrmQuarkList quarks;		/* quark list */

-    int mode;				/* XrmEnum<kind> */

-} EClosureRec, *EClosure;

-

-/* types for typecasting ETable based functions to NTable based functions */

-typedef Bool (*getNTableSProcp)(

-    NTable              table,

-    XrmNameList         names,

-    XrmClassList        classes,

-    SClosure            closure);

-typedef Bool (*getNTableVProcp)(

-    NTable              table,

-    XrmNameList         names,

-    XrmClassList        classes,

-    VClosure            closure);

-typedef Bool (*getNTableEProcp)(

-    NTable              table,

-    XrmNameList         names,

-    XrmClassList        classes,

-    register int        level,

-    EClosure            closure);

-

-/* predicate to determine when to resize a hash table */

-#define GrowthPred(n,m) ((unsigned)(n) > (((m) + 1) << 2))

-

-#define GROW(prev) \

-    if (GrowthPred((*prev)->entries, (*prev)->mask)) \

-	GrowTable(prev)

-

-/* pick a reasonable value for maximum depth of resource database */

-#define MAXDBDEPTH 100

-

-/* macro used in get/search functions */

-

-/* find an entry named ename, with leafness given by leaf */

-#define NFIND(ename) \

-    q = ename; \

-    entry = NodeHash(table, q); \

-    while (entry && entry->name != q) \

-	entry = entry->next; \

-    if (leaf && entry && !entry->leaf) { \

-	entry = entry->next; \

-	if (entry && !entry->leaf) \

-	    entry = entry->next; \

-	if (entry && entry->name != q) \

-	    entry = (NTable)NULL; \

-    }

-

-/* resourceQuarks keeps track of what quarks have been associated with values

- * in all LTables.  If a quark has never been used in an LTable, we don't need

- * to bother looking for it.

- */

-

-static unsigned char *resourceQuarks = (unsigned char *)NULL;

-static XrmQuark maxResourceQuark = -1;

-

-/* determines if a quark has been used for a value in any database */

-#define IsResourceQuark(q)  ((q) > 0 && (q) <= maxResourceQuark && \

-			     resourceQuarks[(q) >> 3] & (1 << ((q) & 7)))

-

-typedef unsigned char XrmBits;

-

-#define BSLASH  ((XrmBits) (1 << 5))

-#define NORMAL	((XrmBits) (1 << 4))

-#define EOQ	((XrmBits) (1 << 3))

-#define SEP	((XrmBits) (1 << 2))

-#define ENDOF	((XrmBits) (1 << 1))

-#define SPACE	(NORMAL|EOQ|SEP|(XrmBits)0)

-#define RSEP	(NORMAL|EOQ|SEP|(XrmBits)1)

-#define EOS	(EOQ|SEP|ENDOF|(XrmBits)0)

-#define EOL	(EOQ|SEP|ENDOF|(XrmBits)1)

-#define BINDING	(NORMAL|EOQ)

-#define ODIGIT	(NORMAL|(XrmBits)1)

-

-#define next_char(ch,str) xrmtypes[(unsigned char)((ch) = *(++(str)))]

-#define next_mbchar(ch,len,str) xrmtypes[(unsigned char)(ch = (*db->methods->mbchar)(db->mbstate, str, &len), str += len, ch)]

-

-#define is_space(bits)		((bits) == SPACE)

-#define is_EOQ(bits)		((bits) & EOQ)

-#define is_EOF(bits)		((bits) == EOS)

-#define is_EOL(bits)		((bits) & ENDOF)

-#define is_binding(bits)	((bits) == BINDING)

-#define is_odigit(bits)		((bits) == ODIGIT)

-#define is_separator(bits)	((bits) & SEP)

-#define is_nonpcs(bits)		(!(bits))

-#define is_normal(bits)		((bits) & NORMAL)

-#define is_simple(bits)		((bits) & (NORMAL|BSLASH))

-#define is_special(bits)	((bits) & (ENDOF|BSLASH))

-

-/* parsing types */

-static XrmBits const xrmtypes[256] = {

-    EOS,0,0,0,0,0,0,0,

-    0,SPACE,EOL,0,0,

-#if defined(WIN32) || defined(__UNIXOS2__)

-                    EOL,	/* treat CR the same as LF, just in case */

-#else

-                    0,

-#endif

-                      0,0,

-    0,0,0,0,0,0,0,0,

-    0,0,0,0,0,0,0,0,

-    SPACE,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,

-    NORMAL,NORMAL,BINDING,NORMAL,NORMAL,NORMAL,BINDING,NORMAL,

-    ODIGIT,ODIGIT,ODIGIT,ODIGIT,ODIGIT,ODIGIT,ODIGIT,ODIGIT,

-    NORMAL,NORMAL,RSEP,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,

-    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,

-    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,

-    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,

-    NORMAL,NORMAL,NORMAL,NORMAL,BSLASH,NORMAL,NORMAL,NORMAL,

-    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,

-    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,

-    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,

-    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,0

-    /* The rest will be automatically initialized to zero. */

-};

-

-void XrmInitialize(void)

-{

-    XrmQString = XrmPermStringToQuark("String");

-    XrmQANY = XrmPermStringToQuark("?");

-}

-

-XrmDatabase XrmGetDatabase(

-    Display *display)

-{

-    XrmDatabase retval;

-    LockDisplay(display);

-    retval = display->db;

-    UnlockDisplay(display);

-    return retval;

-}

-

-void XrmSetDatabase(

-    Display *display,

-    XrmDatabase database)

-{

-    LockDisplay(display);

-    /* destroy database if set up imlicitely by XGetDefault() */

-    if (display->db && (display->flags & XlibDisplayDfltRMDB)) {

-	XrmDestroyDatabase(display->db);

-	display->flags &= ~XlibDisplayDfltRMDB;

-    }

-    display->db = database;

-    UnlockDisplay(display);

-}

-

-void

-XrmStringToQuarkList(

-    register _Xconst char  *name,

-    register XrmQuarkList quarks)   /* RETURN */

-{

-    register XrmBits		bits;

-    register Signature  	sig = 0;

-    register char       	ch, *tname;

-    register int 		i = 0;

-

-    if ((tname = (char *)name)) {

-	tname--;

-	while (!is_EOF(bits = next_char(ch, tname))) {

-	    if (is_binding (bits)) {

-		if (i) {

-		    /* Found a complete name */

-		    *quarks++ = _XrmInternalStringToQuark(name,tname - name,

-							  sig, False);

-		    i = 0;

-		    sig = 0;

-		}

-		name = tname+1;

-	    }

-	    else {

-		sig = (sig << 1) + ch; /* Compute the signature. */

-		i++;

-	    }

-	}

-	*quarks++ = _XrmInternalStringToQuark(name, tname - name, sig, False);

-    }

-    *quarks = NULLQUARK;

-}

-

-void

-XrmStringToBindingQuarkList(

-    register _Xconst char   *name,

-    register XrmBindingList bindings,   /* RETURN */

-    register XrmQuarkList   quarks)     /* RETURN */

-{

-    register XrmBits		bits;

-    register Signature  	sig = 0;

-    register char       	ch, *tname;

-    register XrmBinding 	binding;

-    register int 		i = 0;

-

-    if ((tname = (char *)name)) {

-	tname--;

-	binding = XrmBindTightly;

-	while (!is_EOF(bits = next_char(ch, tname))) {

-	    if (is_binding (bits)) {

-		if (i) {

-		    /* Found a complete name */

-		    *bindings++ = binding;

-		    *quarks++ = _XrmInternalStringToQuark(name, tname - name,

-							  sig, False);

-

-		    i = 0;

-		    sig = 0;

-		    binding = XrmBindTightly;

-		}

-		name = tname+1;

-

-		if (ch == '*')

-		    binding = XrmBindLoosely;

-	    }

-	    else {

-		sig = (sig << 1) + ch; /* Compute the signature. */

-		i++;

-	    }

-	}

-	*bindings = binding;

-	*quarks++ = _XrmInternalStringToQuark(name, tname - name, sig, False);

-    }

-    *quarks = NULLQUARK;

-}

-

-#ifdef DEBUG

-

-static void PrintQuarkList(

-    XrmQuarkList    quarks,

-    FILE	    *stream)

-{

-    Bool	    firstNameSeen;

-

-    for (firstNameSeen = False; *quarks; quarks++) {

-	if (firstNameSeen) {

-	    (void) fprintf(stream, ".");

-	}

-	firstNameSeen = True;

-	(void) fputs(XrmQuarkToString(*quarks), stream);

-    }

-} /* PrintQuarkList */

-

-#endif /* DEBUG */

-

-

-/*

- * Fallback methods for Xrm parsing.

- * Simulate a C locale. No state needed here.

- */

-

-static void

-c_mbnoop(

-    XPointer state)

-{

-}

-

-static char

-c_mbchar(

-    XPointer state,

-    const char *str,

-    int *lenp)

-{

-    *lenp = 1;

-    return *str;

-}

-

-static const char *

-c_lcname(

-    XPointer state)

-{

-    return "C";

-}

-

-static const XrmMethodsRec mb_methods = {

-    c_mbnoop,	/* mbinit */

-    c_mbchar,	/* mbchar */

-    c_mbnoop,	/* mbfinish */

-    c_lcname,	/* lcname */

-    c_mbnoop	/* destroy */

-};

-

-

-static XrmDatabase NewDatabase(void)

-{

-    register XrmDatabase db;

-

-    db = (XrmDatabase) Xmalloc(sizeof(XrmHashBucketRec));

-    if (db) {

-	_XCreateMutex(&db->linfo);

-	db->table = (NTable)NULL;

-	db->mbstate = (XPointer)NULL;

-	db->methods = _XrmInitParseInfo(&db->mbstate);

-	if (!db->methods)

-	    db->methods = &mb_methods;

-    }

-    return db;

-}

-

-/* move all values from ftable to ttable, and free ftable's buckets.

- * ttable is quaranteed empty to start with.

- */

-static void MoveValues(

-    LTable ftable,

-    register LTable ttable)

-{

-    register VEntry fentry, nfentry;

-    register VEntry *prev;

-    register VEntry *bucket;

-    register VEntry tentry;

-    register int i;

-

-    for (i = ftable->table.mask, bucket = ftable->buckets; i >= 0; i--) {

-	for (fentry = *bucket++; fentry; fentry = nfentry) {

-	    prev = &LeafHash(ttable, fentry->name);

-	    tentry = *prev;

-	    *prev = fentry;

-	    /* chain on all with same name, to preserve invariant order */

-	    while ((nfentry = fentry->next) && nfentry->name == fentry->name)

-		fentry = nfentry;

-	    fentry->next = tentry;

-	}

-    }

-    Xfree((char *)ftable->buckets);

-}

-

-/* move all tables from ftable to ttable, and free ftable.

- * ttable is quaranteed empty to start with.

- */

-static void MoveTables(

-    NTable ftable,

-    register NTable ttable)

-{

-    register NTable fentry, nfentry;

-    register NTable *prev;

-    register NTable *bucket;

-    register NTable tentry;

-    register int i;

-

-    for (i = ftable->mask, bucket = NodeBuckets(ftable); i >= 0; i--) {

-	for (fentry = *bucket++; fentry; fentry = nfentry) {

-	    prev = &NodeHash(ttable, fentry->name);

-	    tentry = *prev;

-	    *prev = fentry;

-	    /* chain on all with same name, to preserve invariant order */

-	    while ((nfentry = fentry->next) && nfentry->name == fentry->name)

-		fentry = nfentry;

-	    fentry->next = tentry;

-	}

-    }

-    Xfree((char *)ftable);

-}

-

-/* grow the table, based on current number of entries */

-static void GrowTable(

-    NTable *prev)

-{

-    register NTable table;

-    register int i;

-

-    table = *prev;

-    i = table->mask;

-    if (i == 255) /* biggest it gets */

-	return;

-    while (i < 255 && GrowthPred(table->entries, i))

-	i = (i << 1) + 1;

-    i++; /* i is now the new size */

-    if (table->leaf) {

-	register LTable ltable;

-	LTableRec otable;

-

-	ltable = (LTable)table;

-	/* cons up a copy to make MoveValues look symmetric */

-	otable = *ltable;

-	ltable->buckets = Xcalloc(i, sizeof(VEntry));

-	if (!ltable->buckets) {

-	    ltable->buckets = otable.buckets;

-	    return;

-	}

-	ltable->table.mask = i - 1;

-	MoveValues(&otable, ltable);

-    } else {

-	register NTable ntable;

-

-	ntable = Xcalloc(1, sizeof(NTableRec) + (i * sizeof(NTable)));

-	if (!ntable)

-	    return;

-	*ntable = *table;

-	ntable->mask = i - 1;

-	*prev = ntable;

-	MoveTables(table, ntable);

-    }

-}

-

-/* merge values from ftable into *pprev, destroy ftable in the process */

-static void MergeValues(

-    LTable ftable,

-    NTable *pprev,

-    Bool override)

-{

-    register VEntry fentry, tentry;

-    register VEntry *prev;

-    register LTable ttable;

-    VEntry *bucket;

-    int i;

-    register XrmQuark q;

-

-    ttable = (LTable)*pprev;

-    if (ftable->table.hasloose)

-	ttable->table.hasloose = 1;

-    for (i = ftable->table.mask, bucket = ftable->buckets;

-	 i >= 0;

-	 i--, bucket++) {

-	for (fentry = *bucket; fentry; ) {

-	    q = fentry->name;

-	    prev = &LeafHash(ttable, q);

-	    tentry = *prev;

-	    while (tentry && tentry->name != q)

-		tentry = *(prev = &tentry->next);

-	    /* note: test intentionally uses fentry->name instead of q */

-	    /* permits serendipitous inserts */

-	    while (tentry && tentry->name == fentry->name) {

-		/* if tentry is earlier, skip it */

-		if (!fentry->tight && tentry->tight) {

-		    tentry = *(prev = &tentry->next);

-		    continue;

-		}

-		if (fentry->tight != tentry->tight) {

-		    /* no match, chain in fentry */

-		    *prev = fentry;

-		    prev = &fentry->next;

-		    fentry = *prev;

-		    *prev = tentry;

-		    ttable->table.entries++;

-		} else if (override) {

-		    /* match, chain in fentry, splice out and free tentry */

-		    *prev = fentry;

-		    prev = &fentry->next;

-		    fentry = *prev;

-		    *prev = tentry->next;

-		    /* free the overridden entry */

-		    Xfree((char *)tentry);

-		    /* get next tentry */

-		    tentry = *prev;

-		} else {

-		    /* match, discard fentry */

-		    prev = &tentry->next;

-		    tentry = fentry; /* use as a temp var */

-		    fentry = fentry->next;

-		    /* free the overpowered entry */

-		    Xfree((char *)tentry);

-		    /* get next tentry */

-		    tentry = *prev;

-		}

-		if (!fentry)

-		    break;

-	    }

-	    /* at this point, tentry cannot match any fentry named q */

-	    /* chain in all bindings together, preserve invariant order */

-	    while (fentry && fentry->name == q) {

-		*prev = fentry;

-		prev = &fentry->next;

-		fentry = *prev;

-		*prev = tentry;

-		ttable->table.entries++;

-	    }

-	}

-    }

-    Xfree((char *)ftable->buckets);

-    Xfree((char *)ftable);

-    /* resize if necessary, now that we're all done */

-    GROW(pprev);

-}

-

-/* merge tables from ftable into *pprev, destroy ftable in the process */

-static void MergeTables(

-    NTable ftable,

-    NTable *pprev,

-    Bool override)

-{

-    register NTable fentry, tentry;

-    NTable nfentry;

-    register NTable *prev;

-    register NTable ttable;

-    NTable *bucket;

-    int i;

-    register XrmQuark q;

-

-    ttable = *pprev;

-    if (ftable->hasloose)

-	ttable->hasloose = 1;

-    if (ftable->hasany)

-	ttable->hasany = 1;

-    for (i = ftable->mask, bucket = NodeBuckets(ftable);

-	 i >= 0;

-	 i--, bucket++) {

-	for (fentry = *bucket; fentry; ) {

-	    q = fentry->name;

-	    prev = &NodeHash(ttable, q);

-	    tentry = *prev;

-	    while (tentry && tentry->name != q)

-		tentry = *(prev = &tentry->next);

-	    /* note: test intentionally uses fentry->name instead of q */

-	    /* permits serendipitous inserts */

-	    while (tentry && tentry->name == fentry->name) {

-		/* if tentry is earlier, skip it */

-		if ((fentry->leaf && !tentry->leaf) ||

-		    (!fentry->tight && tentry->tight &&

-		     (fentry->leaf || !tentry->leaf))) {

-		    tentry = *(prev = &tentry->next);

-		    continue;

-		}

-		nfentry = fentry->next;

-		if (fentry->leaf != tentry->leaf ||

-		    fentry->tight != tentry->tight) {

-		    /* no match, just chain in */

-		    *prev = fentry;

-		    *(prev = &fentry->next) = tentry;

-		    ttable->entries++;

-		} else {

-		    if (fentry->leaf)

-			MergeValues((LTable)fentry, prev, override);

-		    else

-			MergeTables(fentry, prev, override);

-		    /* bump to next tentry */

-		    tentry = *(prev = &(*prev)->next);

-		}

-		/* bump to next fentry */

-		fentry = nfentry;

-		if (!fentry)

-		    break;

-	    }

-	    /* at this point, tentry cannot match any fentry named q */

-	    /* chain in all bindings together, preserve invariant order */

-	    while (fentry && fentry->name == q) {

-		*prev = fentry;

-		prev = &fentry->next;

-		fentry = *prev;

-		*prev = tentry;

-		ttable->entries++;

-	    }

-	}

-    }

-    Xfree((char *)ftable);

-    /* resize if necessary, now that we're all done */

-    GROW(pprev);

-}

-

-void XrmCombineDatabase(

-    XrmDatabase	from, XrmDatabase *into,

-    Bool override)

-{

-    register NTable *prev;

-    register NTable ftable, ttable, nftable;

-

-    if (!*into) {

-	*into = from;

-    } else if (from) {

-	_XLockMutex(&from->linfo);

-	_XLockMutex(&(*into)->linfo);

-	if ((ftable = from->table)) {

-	    prev = &(*into)->table;

-	    ttable = *prev;

-	    if (!ftable->leaf) {

-		nftable = ftable->next;

-		if (ttable && !ttable->leaf) {

-		    /* both have node tables, merge them */

-		    MergeTables(ftable, prev, override);

-		    /* bump to into's leaf table, if any */

-		    ttable = *(prev = &(*prev)->next);

-		} else {

-		    /* into has no node table, link from's in */

-		    *prev = ftable;

-		    *(prev = &ftable->next) = ttable;

-		}

-		/* bump to from's leaf table, if any */

-		ftable = nftable;

-	    } else {

-		/* bump to into's leaf table, if any */

-		if (ttable && !ttable->leaf)

-		    ttable = *(prev = &ttable->next);

-	    }

-	    if (ftable) {

-		/* if into has a leaf, merge, else insert */

-		if (ttable)

-		    MergeValues((LTable)ftable, prev, override);

-		else

-		    *prev = ftable;

-	    }

-	}

-	(from->methods->destroy)(from->mbstate);

-	_XUnlockMutex(&from->linfo);

-	_XFreeMutex(&from->linfo);

-	Xfree((char *)from);

-	_XUnlockMutex(&(*into)->linfo);

-    }

-}

-

-void XrmMergeDatabases(

-    XrmDatabase	from, XrmDatabase *into)

-{

-    XrmCombineDatabase(from, into, True);

-}

-

-/* store a value in the database, overriding any existing entry */

-static void PutEntry(

-    XrmDatabase		db,

-    XrmBindingList	bindings,

-    XrmQuarkList	quarks,

-    XrmRepresentation	type,

-    XrmValuePtr		value)

-{

-    register NTable *pprev, *prev;

-    register NTable table;

-    register XrmQuark q;

-    register VEntry *vprev;

-    register VEntry entry;

-    NTable *nprev, *firstpprev;

-

-#define NEWTABLE(q,i) \

-    table = (NTable)Xmalloc(sizeof(LTableRec)); \

-    if (!table) \

-	return; \

-    table->name = q; \

-    table->hasloose = 0; \

-    table->hasany = 0; \

-    table->mask = 0; \

-    table->entries = 0; \

-    if (quarks[i]) { \

-	table->leaf = 0; \

-	nprev = NodeBuckets(table); \

-    } else { \

-	table->leaf = 1; \

-	if (!(nprev = (NTable *)Xmalloc(sizeof(VEntry *)))) {\

-	    Xfree(table); \

-	    return; \

-        } \

-	((LTable)table)->buckets = (VEntry *)nprev; \

-    } \

-    *nprev = (NTable)NULL; \

-    table->next = *prev; \

-    *prev = table

-

-    if (!db || !*quarks)

-	return;

-    table = *(prev = &db->table);

-    /* if already at leaf, bump to the leaf table */

-    if (!quarks[1] && table && !table->leaf)

-	table = *(prev = &table->next);

-    pprev = prev;

-    if (!table || (quarks[1] && table->leaf)) {

-	/* no top-level node table, create one and chain it in */

-	NEWTABLE(NULLQUARK,1);

-	table->tight = 1; /* arbitrary */

-	prev = nprev;

-    } else {

-	/* search along until we need a value */

-	while (quarks[1]) {

-	    q = *quarks;

-	    table = *(prev = &NodeHash(table, q));

-	    while (table && table->name != q)

-		table = *(prev = &table->next);

-	    if (!table)

-		break; /* not found */

-	    if (quarks[2]) {

-		if (table->leaf)

-		    break; /* not found */

-	    } else {

-		if (!table->leaf) {

-		    /* bump to leaf table, if any */

-		    table = *(prev = &table->next);

-		    if (!table || table->name != q)

-			break; /* not found */

-		    if (!table->leaf) {

-			/* bump to leaf table, if any */

-			table = *(prev = &table->next);

-			if (!table || table->name != q)

-			    break; /* not found */

-		    }

-		}

-	    }

-	    if (*bindings == XrmBindTightly) {

-		if (!table->tight)

-		    break; /* not found */

-	    } else {

-		if (table->tight) {

-		    /* bump to loose table, if any */

-		    table = *(prev = &table->next);

-		    if (!table || table->name != q ||

-			!quarks[2] != table->leaf)

-			break; /* not found */

-		}

-	    }

-	    /* found that one, bump to next quark */

-	    pprev = prev;

-	    quarks++;

-	    bindings++;

-	}

-	if (!quarks[1]) {

-	    /* found all the way to a leaf */

-	    q = *quarks;

-	    entry = *(vprev = &LeafHash((LTable)table, q));

-	    while (entry && entry->name != q)

-		entry = *(vprev = &entry->next);

-	    /* if want loose and have tight, bump to next entry */

-	    if (entry && *bindings == XrmBindLoosely && entry->tight)

-		entry = *(vprev = &entry->next);

-	    if (entry && entry->name == q &&

-		(*bindings == XrmBindTightly) == entry->tight) {

-		/* match, need to override */

-		if ((type == XrmQString) == entry->string &&

-		    entry->size == value->size) {

-		    /* update type if not String, can be different */

-		    if (!entry->string)

-			RepType(entry) = type;

-		    /* identical size, just overwrite value */

-		    memcpy(RawValue(entry), (char *)value->addr, value->size);

-		    return;

-		}

-		/* splice out and free old entry */

-		*vprev = entry->next;

-		Xfree((char *)entry);

-		(*pprev)->entries--;

-	    }

-	    /* this is where to insert */

-	    prev = (NTable *)vprev;

-	}

-    }

-    /* keep the top table, because we may have to grow it */

-    firstpprev = pprev;

-    /* iterate until we get to the leaf */

-    while (quarks[1]) {

-	/* build a new table and chain it in */

-	NEWTABLE(*quarks,2);

-	if (*quarks++ == XrmQANY)

-	    (*pprev)->hasany = 1;

-	if (*bindings++ == XrmBindTightly) {

-	    table->tight = 1;

-	} else {

-	    table->tight = 0;

-	    (*pprev)->hasloose = 1;

-	}

-	(*pprev)->entries++;

-	pprev = prev;

-	prev = nprev;

-    }

-    /* now allocate the value entry */

-    entry = (VEntry)Xmalloc(((type == XrmQString) ?

-			     sizeof(VEntryRec) : sizeof(DEntryRec)) +

-			    value->size);

-    if (!entry)

-	return;

-    entry->name = q = *quarks;

-    if (*bindings == XrmBindTightly) {

-	entry->tight = 1;

-    } else {

-	entry->tight = 0;

-	(*pprev)->hasloose = 1;

-    }

-    /* chain it in, with a bit of type cast ugliness */

-    entry->next = *((VEntry *)prev);

-    *((VEntry *)prev) = entry;

-    entry->size = value->size;

-    if (type == XrmQString) {

-	entry->string = 1;

-    } else {

-	entry->string = 0;

-	RepType(entry) = type;

-    }

-    /* save a copy of the value */

-    memcpy(RawValue(entry), (char *)value->addr, value->size);

-    (*pprev)->entries++;

-    /* this is a new leaf, need to remember it for search lists */

-    if (q > maxResourceQuark) {

-	unsigned oldsize = (maxResourceQuark + 1) >> 3;

-	unsigned size = ((q | 0x7f) + 1) >> 3; /* reallocate in chunks */

-	if (resourceQuarks) {

-	    unsigned char *prevQuarks = resourceQuarks;

-

-	    resourceQuarks = (unsigned char *)Xrealloc((char *)resourceQuarks,

-						       size);

-	    if (!resourceQuarks) {

-		Xfree(prevQuarks);

-	    }

-	} else

-	    resourceQuarks = (unsigned char *)Xmalloc(size);

-	if (resourceQuarks) {

-	    bzero((char *)&resourceQuarks[oldsize], size - oldsize);

-	    maxResourceQuark = (size << 3) - 1;

-	} else {

-	    maxResourceQuark = -1;

-	}

-    }

-    if (q > 0 && resourceQuarks)

-	resourceQuarks[q >> 3] |= 1 << (q & 0x7);

-    GROW(firstpprev);

-

-#undef NEWTABLE

-}

-

-void XrmQPutResource(

-    XrmDatabase		*pdb,

-    XrmBindingList      bindings,

-    XrmQuarkList	quarks,

-    XrmRepresentation	type,

-    XrmValuePtr		value)

-{

-    if (!*pdb) *pdb = NewDatabase();

-    _XLockMutex(&(*pdb)->linfo);

-    PutEntry(*pdb, bindings, quarks, type, value);

-    _XUnlockMutex(&(*pdb)->linfo);

-}

-

-void

-XrmPutResource(

-    XrmDatabase     *pdb,

-    _Xconst char    *specifier,

-    _Xconst char    *type,

-    XrmValuePtr	    value)

-{

-    XrmBinding	    bindings[MAXDBDEPTH+1];

-    XrmQuark	    quarks[MAXDBDEPTH+1];

-

-    if (!*pdb) *pdb = NewDatabase();

-    _XLockMutex(&(*pdb)->linfo);

-    XrmStringToBindingQuarkList(specifier, bindings, quarks);

-    PutEntry(*pdb, bindings, quarks, XrmStringToQuark(type), value);

-    _XUnlockMutex(&(*pdb)->linfo);

-}

-

-void

-XrmQPutStringResource(

-    XrmDatabase     *pdb,

-    XrmBindingList  bindings,

-    XrmQuarkList    quarks,

-    _Xconst char    *str)

-{

-    XrmValue	value;

-

-    if (!*pdb) *pdb = NewDatabase();

-    value.addr = (XPointer) str;

-    value.size = strlen(str)+1;

-    _XLockMutex(&(*pdb)->linfo);

-    PutEntry(*pdb, bindings, quarks, XrmQString, &value);

-    _XUnlockMutex(&(*pdb)->linfo);

-}

-

-/*	Function Name: GetDatabase

- *	Description: Parses a string and stores it as a database.

- *	Arguments: db - the database.

- *                 str - a pointer to the string containing the database.

- *                 filename - source filename, if any.

- *                 doall - whether to do all lines or just one

- */

-

-/*

- * This function is highly optimized to inline as much as possible.

- * Be very careful with modifications, or simplifications, as they

- * may adversely affect the performance.

- *

- * Chris Peterson, MIT X Consortium		5/17/90.

- */

-

-/*

- * Xlib spec says max 100 quarks in a lookup, will stop and return if

- * return if any single production's lhs has more than 100 components.

- */

-#define QLIST_SIZE 100

-

-/*

- * This should be big enough to handle things like the XKeysymDB or biggish

- * ~/.Xdefaults or app-defaults files. Anything bigger will be allocated on

- * the heap.

- */

-#define DEF_BUFF_SIZE 8192

-

-static void GetIncludeFile(

-    XrmDatabase db,

-    _Xconst char *base,

-    _Xconst char *fname,

-    int fnamelen);

-

-static void GetDatabase(

-    XrmDatabase db,

-    _Xconst register char *str,

-    _Xconst char *filename,

-    Bool doall)

-{

-    char *rhs;

-    char *lhs, lhs_s[DEF_BUFF_SIZE];

-    XrmQuark quarks[QLIST_SIZE + 1];	/* allow for a terminal NullQuark */

-    XrmBinding bindings[QLIST_SIZE + 1];

-

-    register char *ptr;

-    register XrmBits bits = 0;

-    register char c;

-    register Signature sig;

-    register char *ptr_max;

-    register int num_quarks;

-    register XrmBindingList t_bindings;

-

-    int len, alloc_chars;

-    unsigned long str_len;

-    XrmValue value;

-    Bool only_pcs;

-    Bool dolines;

-

-    if (!db)

-	return;

-

-    /*

-     * if strlen (str) < DEF_BUFF_SIZE allocate buffers on the stack for

-     * speed otherwise malloc the buffer. From a buffer overflow standpoint

-     * we can be sure that neither: a) a component on the lhs, or b) a

-     * value on the rhs, will be longer than the overall length of str,

-     * i.e. strlen(str).

-     *

-     * This should give good performance when parsing "*foo: bar" type

-     * databases as might be passed with -xrm command line options; but

-     * with larger databases, e.g. .Xdefaults, app-defaults, or KeysymDB

-     * files, the size of the buffers will be overly large. One way

-     * around this would be to double-parse each production with a resulting

-     * performance hit. In any event we can be assured that a lhs component

-     * name or a rhs value won't be longer than str itself.

-     */

-

-    str_len = strlen (str);

-    if (DEF_BUFF_SIZE > str_len) lhs = lhs_s;

-    else if ((lhs = (char*) Xmalloc (str_len)) == NULL)

-	return;

-

-    alloc_chars = DEF_BUFF_SIZE < str_len ? str_len : DEF_BUFF_SIZE;

-    if ((rhs = (char*) Xmalloc (alloc_chars)) == NULL) {

-	if (lhs != lhs_s) Xfree (lhs);

-	return;

-    }

-

-    (*db->methods->mbinit)(db->mbstate);

-    str--;

-    dolines = True;

-    while (!is_EOF(bits) && dolines) {

-	dolines = doall;

-

-	/*

-	 * First: Remove extra whitespace.

-	 */

-

-	do {

-	    bits = next_char(c, str);

-	} while is_space(bits);

-

-	/*

-	 * Ignore empty lines.

-	 */

-

-	if (is_EOL(bits))

-	    continue;		/* start a new line. */

-

-	/*

-	 * Second: check the first character in a line to see if it is

-	 * "!" signifying a comment, or "#" signifying a directive.

-	 */

-

-	if (c == '!') { /* Comment, spin to next newline */

-	    while (is_simple(bits = next_char(c, str))) {}

-	    if (is_EOL(bits))

-		continue;

-	    while (!is_EOL(bits = next_mbchar(c, len, str))) {}

-	    str--;

-	    continue;		/* start a new line. */

-	}

-

-	if (c == '#') { /* Directive */

-	    /* remove extra whitespace */

-	    only_pcs = True;

-	    while (is_space(bits = next_char(c, str))) {};

-	    /* only "include" directive is currently defined */

-	    if (!strncmp(str, "include", 7)) {

-		str += (7-1);

-		/* remove extra whitespace */

-		while (is_space(bits = next_char(c, str))) {};

-		/* must have a starting " */

-		if (c == '"') {

-		    _Xconst char *fname = str+1;

-		    len = 0;

-		    do {

-			if (only_pcs) {

-			    bits = next_char(c, str);

-			    if (is_nonpcs(bits))

-				only_pcs = False;

-			}

-			if (!only_pcs)

-			    bits = next_mbchar(c, len, str);

-		    } while (c != '"' && !is_EOL(bits));

-		    /* must have an ending " */

-		    if (c == '"')

-			GetIncludeFile(db, filename, fname, str - len - fname);

-		}

-	    }

-	    /* spin to next newline */

-	    if (only_pcs) {

-		while (is_simple(bits))

-		    bits = next_char(c, str);

-		if (is_EOL(bits))

-		    continue;

-	    }

-	    while (!is_EOL(bits))

-		bits = next_mbchar(c, len, str);

-	    str--;

-	    continue;		/* start a new line. */

-	}

-

-	/*

-	 * Third: loop through the LHS of the resource specification

-	 * storing characters and converting this to a Quark.

-	 */

-

-	num_quarks = 0;

-	t_bindings = bindings;

-

-	sig = 0;

-	ptr = lhs;

-	*t_bindings = XrmBindTightly;

-	for(;;) {

-	    if (!is_binding(bits)) {

-		while (!is_EOQ(bits)) {

-		    *ptr++ = c;

-		    sig = (sig << 1) + c; /* Compute the signature. */

-		    bits = next_char(c, str);

-		}

-

-		quarks[num_quarks++] =

-			_XrmInternalStringToQuark(lhs, ptr - lhs, sig, False);

-

-		if (num_quarks > QLIST_SIZE) {

-		    Xfree(rhs);

-		    if (lhs != lhs_s) Xfree (lhs);

-		    (*db->methods->mbfinish)(db->mbstate);

-		    return;

-		}

-

-		if (is_separator(bits))  {

-		    if (!is_space(bits))

-			break;

-

-		    /* Remove white space */

-		    do {

-			*ptr++ = c;

-			sig = (sig << 1) + c; /* Compute the signature. */

-		    } while (is_space(bits = next_char(c, str)));

-

-		    /*

-		     * The spec doesn't permit it, but support spaces

-		     * internal to resource name/class

-		     */

-

-		    if (is_separator(bits))

-			break;

-		    num_quarks--;

-		    continue;

-		}

-

-		if (c == '.')

-		    *(++t_bindings) = XrmBindTightly;

-		else

-		    *(++t_bindings) = XrmBindLoosely;

-

-		sig = 0;

-		ptr = lhs;

-	    }

-	    else {

-		/*

-		 * Magic unspecified feature #254.

-		 *

-		 * If two separators appear with no Text between them then

-		 * ignore them.

-		 *

-		 * If anyone of those separators is a '*' then the binding

-		 * will be loose, otherwise it will be tight.

-		 */

-

-		if (c == '*')

-		    *t_bindings = XrmBindLoosely;

-	    }

-

-	    bits = next_char(c, str);

-	}

-

-	quarks[num_quarks] = NULLQUARK;

-

-	/*

-	 * Make sure that there is a ':' in this line.

-	 */

-

-	if (c != ':') {

-	    char oldc;

-

-	    /*

-	     * A parsing error has occured, toss everything on the line

-	     * a new_line can still be escaped with a '\'.

-	     */

-

-	    while (is_normal(bits))

-		bits = next_char(c, str);

-	    if (is_EOL(bits))

-		continue;

-	    bits = next_mbchar(c, len, str);

-	    do {

-		oldc = c;

-		bits = next_mbchar(c, len, str);

-	    } while (c && (c != '\n' || oldc == '\\'));

-	    str--;

-	    continue;

-	}

-

-	/*

-	 * I now have a quark and binding list for the entire left hand

-	 * side.  "c" currently points to the ":" separating the left hand

-	 * side for the right hand side.  It is time to begin processing

-	 * the right hand side.

-	 */

-

-	/*

-	 * Fourth: Remove more whitespace

-	 */

-

-	for(;;) {

-	    if (is_space(bits = next_char(c, str)))

-		continue;

-	    if (c != '\\')

-		break;

-	    bits = next_char(c, str);

-	    if (c == '\n')

-		continue;

-	    str--;

-	    bits = BSLASH;

-	    c = '\\';

-	    break;

-	}

-

-	/*

-	 * Fifth: Process the right hand side.

-	 */

-

-	ptr = rhs;

-	ptr_max = ptr + alloc_chars - 4;

-	only_pcs = True;

-	len = 1;

-

-	for(;;) {

-

-	    /*

-	     * Tight loop for the normal case:  Non backslash, non-end of value

-	     * character that will fit into the allocated buffer.

-	     */

-

-	    if (only_pcs) {

-		while (is_normal(bits) && ptr < ptr_max) {

-		    *ptr++ = c;

-		    bits = next_char(c, str);

-		}

-		if (is_EOL(bits))

-		    break;

-		if (is_nonpcs(bits)) {

-		    only_pcs = False;

-		    bits = next_mbchar(c, len, str);

-		}

-	    }

-	    while (!is_special(bits) && ptr + len <= ptr_max) {

-		len = -len;

-		while (len)

-		    *ptr++ = str[len++];

-		if (*str == '\0') {

-		    bits = EOS;

-		    break;

-		}

-		bits = next_mbchar(c, len, str);

-	    }

-

-	    if (is_EOL(bits)) {

-		str--;

-		break;

-	    }

-

-	    if (c == '\\') {

-		/*

-		 * We need to do some magic after a backslash.

-		 */

-		Bool read_next = True;

-

-		if (only_pcs) {

-		    bits = next_char(c, str);

-		    if (is_nonpcs(bits))

-			only_pcs = False;

-		}

-		if (!only_pcs)

-		    bits = next_mbchar(c, len, str);

-

-		if (is_EOL(bits)) {

-		    if (is_EOF(bits))

-			continue;

-		} else if (c == 'n') {

-		    /*

-		     * "\n" means insert a newline.

-		     */

-		    *ptr++ = '\n';

-		} else if (c == '\\') {

-		    /*

-		     * "\\" completes to just one backslash.

-		     */

-		    *ptr++ = '\\';

-		} else {

-		    /*

-		     * pick up to three octal digits after the '\'.

-		     */

-		    char temp[3];

-		    int count = 0;

-		    while (is_odigit(bits) && count < 3) {

-			temp[count++] = c;

-			if (only_pcs) {

-			    bits = next_char(c, str);

-			    if (is_nonpcs(bits))

-				only_pcs = False;

-			}

-			if (!only_pcs)

-			    bits = next_mbchar(c, len, str);

-		    }

-

-		    /*

-		     * If we found three digits then insert that octal code

-		     * into the value string as a character.

-		     */

-

-		    if (count == 3) {

-			*ptr++ = (unsigned char) ((temp[0] - '0') * 0100 +

-						  (temp[1] - '0') * 010 +

-						  (temp[2] - '0'));

-		    }

-		    else {

-			int tcount;

-

-			/*

-			 * Otherwise just insert those characters into the

-			 * string, since no special processing is needed on

-			 * numerics we can skip the special processing.

-			 */

-

-			for (tcount = 0; tcount < count; tcount++) {

-			    *ptr++ = temp[tcount]; /* print them in

-						      the correct order */

-			}

-		    }

-		    read_next = False;

-		}

-		if (read_next) {

-		    if (only_pcs) {

-			bits = next_char(c, str);

-			if (is_nonpcs(bits))

-			    only_pcs = False;

-		    }

-		    if (!only_pcs)

-			bits = next_mbchar(c, len, str);

-		}

-	    }

-

-	    /*

-	     * It is important to make sure that there is room for at least

-	     * four more characters in the buffer, since I can add that

-	     * many characters into the buffer after a backslash has occured.

-	     */

-

-	    if (ptr + len > ptr_max) {

-		char * temp_str;

-

-		alloc_chars += BUFSIZ/10;

-		temp_str = Xrealloc(rhs, sizeof(char) * alloc_chars);

-

-		if (!temp_str) {

-		    Xfree(rhs);

-		    if (lhs != lhs_s) Xfree (lhs);

-		    (*db->methods->mbfinish)(db->mbstate);

-		    return;

-		}

-

-		ptr = temp_str + (ptr - rhs); /* reset pointer. */

-		rhs = temp_str;

-		ptr_max = rhs + alloc_chars - 4;

-	    }

-	}

-

-	/*

-	 * Lastly: Terminate the value string, and store this entry

-	 * 	   into the database.

-	 */

-

-	*ptr++ = '\0';

-

-	/* Store it in database */

-	value.size = ptr - rhs;

-	value.addr = (XPointer) rhs;

-

-	PutEntry(db, bindings, quarks, XrmQString, &value);

-    }

-

-    if (lhs != lhs_s) Xfree (lhs);

-    Xfree (rhs);

-

-    (*db->methods->mbfinish)(db->mbstate);

-}

-

-void

-XrmPutStringResource(

-    XrmDatabase *pdb,

-    _Xconst char*specifier,

-    _Xconst char*str)

-{

-    XrmValue	value;

-    XrmBinding	bindings[MAXDBDEPTH+1];

-    XrmQuark	quarks[MAXDBDEPTH+1];

-

-    if (!*pdb) *pdb = NewDatabase();

-    XrmStringToBindingQuarkList(specifier, bindings, quarks);

-    value.addr = (XPointer) str;

-    value.size = strlen(str)+1;

-    _XLockMutex(&(*pdb)->linfo);

-    PutEntry(*pdb, bindings, quarks, XrmQString, &value);

-    _XUnlockMutex(&(*pdb)->linfo);

-}

-

-

-void

-XrmPutLineResource(

-    XrmDatabase *pdb,

-    _Xconst char*line)

-{

-    if (!*pdb) *pdb = NewDatabase();

-    _XLockMutex(&(*pdb)->linfo);

-    GetDatabase(*pdb, line, (char *)NULL, False);

-    _XUnlockMutex(&(*pdb)->linfo);

-}

-

-XrmDatabase

-XrmGetStringDatabase(

-    _Xconst char    *data)

-{

-    XrmDatabase     db;

-

-    db = NewDatabase();

-    _XLockMutex(&db->linfo);

-    GetDatabase(db, data, (char *)NULL, True);

-    _XUnlockMutex(&db->linfo);

-    return db;

-}

-

-/*	Function Name: ReadInFile

- *	Description: Reads the file into a buffer.

- *	Arguments: filename - the name of the file.

- *	Returns: An allocated string containing the contents of the file.

- */

-

-static char *

-ReadInFile(_Xconst char *filename)

-{

-    register int fd, size;

-    char * filebuf;

-

-#ifdef __UNIXOS2__

-    filename = __XOS2RedirRoot(filename);

-#endif

-

-    /*

-     * MS-Windows and OS/2 note: Default open mode includes O_TEXT

-     */

-    if ( (fd = _XOpenFile (filename, O_RDONLY)) == -1 )

-	return (char *)NULL;

-

-    /*

-     * MS-Windows and OS/2 note: depending on how the sources are

-     * untarred, the newlines in resource files may or may not have

-     * been expanded to CRLF. Either way the size returned by fstat

-     * is sufficient to read the file into because in text-mode any

-     * CRLFs in a file will be converted to newlines (LF) with the

-     * result that the number of bytes actually read with be <=

-     * to the size returned by fstat.

-     */

-    {

-	struct stat status_buffer;

-	if ( (fstat(fd, &status_buffer)) == -1 ) {

-	    close (fd);

-	    return (char *)NULL;

-	} else

-	    size = status_buffer.st_size;

-    }

-

-    if (!(filebuf = Xmalloc(size + 1))) { /* leave room for '\0' */

-	close(fd);

-	return (char *)NULL;

-    }

-    size = read (fd, filebuf, size);

-

-#ifdef __UNIXOS2__

-    { /* kill CRLF */

-      int i,k;

-      for (i=k=0; i<size; i++)

-	if (filebuf[i] != 0x0d) {

-	   filebuf[k++] = filebuf[i];

-	}

-	filebuf[k] = 0;

-    }

-#endif

-

-    if (size < 0) {

-	close (fd);

-	Xfree(filebuf);

-	return (char *)NULL;

-    }

-    close (fd);

-

-    filebuf[size] = '\0';	/* NULL terminate it. */

-    return filebuf;

-}

-

-static void

-GetIncludeFile(

-    XrmDatabase db,

-    _Xconst char *base,

-    _Xconst char *fname,

-    int fnamelen)

-{

-    int len;

-    char *str;

-    char realfname[BUFSIZ];

-

-    if (fnamelen <= 0 || fnamelen >= BUFSIZ)

-	return;

-    if (*fname != '/' && base && (str = strrchr(base, '/'))) {

-	len = str - base + 1;

-	if (len + fnamelen >= BUFSIZ)

-	    return;

-	strncpy(realfname, base, len);

-	strncpy(realfname + len, fname, fnamelen);

-	realfname[len + fnamelen] = '\0';

-    } else {

-	strncpy(realfname, fname, fnamelen);

-	realfname[fnamelen] = '\0';

-    }

-    if (!(str = ReadInFile(realfname)))

-	return;

-    GetDatabase(db, str, realfname, True);

-    Xfree(str);

-}

-

-XrmDatabase

-XrmGetFileDatabase(

-    _Xconst char    *filename)

-{

-    XrmDatabase db;

-    char *str;

-

-    if (!(str = ReadInFile(filename)))

-	return (XrmDatabase)NULL;

-

-    db = NewDatabase();

-    _XLockMutex(&db->linfo);

-    GetDatabase(db, str, filename, True);

-    _XUnlockMutex(&db->linfo);

-    Xfree(str);

-    return db;

-}

-

-Status

-XrmCombineFileDatabase(

-    _Xconst char    *filename,

-    XrmDatabase     *target,

-    Bool             override)

-{

-    XrmDatabase db;

-    char *str;

-

-    if (!(str = ReadInFile(filename)))

-	return 0;

-    if (override) {

-	db = *target;

-	if (!db)

-	    *target = db = NewDatabase();

-    } else

-	db = NewDatabase();

-    _XLockMutex(&db->linfo);

-    GetDatabase(db, str, filename, True);

-    _XUnlockMutex(&db->linfo);

-    Xfree(str);

-    if (!override)

-	XrmCombineDatabase(db, target, False);

-    return 1;

-}

-

-/* call the user proc for every value in the table, arbitrary order.

- * stop if user proc returns True.  level is current depth in database.

- */

-/*ARGSUSED*/

-static Bool EnumLTable(

-    LTable		table,

-    XrmNameList		names,

-    XrmClassList 	classes,

-    register int	level,

-    register EClosure	closure)

-{

-    register VEntry *bucket;

-    register int i;

-    register VEntry entry;

-    XrmValue value;

-    XrmRepresentation type;

-    Bool tightOk;

-

-    closure->bindings[level] = (table->table.tight ?

-				XrmBindTightly : XrmBindLoosely);

-    closure->quarks[level] = table->table.name;

-    level++;

-    tightOk = !*names;

-    closure->quarks[level + 1] = NULLQUARK;

-    for (i = table->table.mask, bucket = table->buckets;

-	 i >= 0;

-	 i--, bucket++) {

-	for (entry = *bucket; entry; entry = entry->next) {

-	    if (entry->tight && !tightOk)

-		continue;

-	    closure->bindings[level] = (entry->tight ?

-					XrmBindTightly : XrmBindLoosely);

-	    closure->quarks[level] = entry->name;

-	    value.size = entry->size;

-	    if (entry->string) {

-		type = XrmQString;

-		value.addr = StringValue(entry);

-	    } else {

-		type = RepType(entry);

-		value.addr = DataValue(entry);

-	    }

-	    if ((*closure->proc)(&closure->db, closure->bindings+1,

-				 closure->quarks+1, &type, &value,

-				 closure->closure))

-		return True;

-	}

-    }

-    return False;

-}

-

-static Bool EnumAllNTable(

-    NTable		table,

-    register int	level,

-    register EClosure	closure)

-{

-    register NTable *bucket;

-    register int i;

-    register NTable entry;

-    XrmQuark empty = NULLQUARK;

-

-    if (level >= MAXDBDEPTH)

-	return False;

-    for (i = table->mask, bucket = NodeBuckets(table);

-	 i >= 0;

-	 i--, bucket++) {

-	for (entry = *bucket; entry; entry = entry->next) {

-	    if (entry->leaf) {

-		if (EnumLTable((LTable)entry, &empty, &empty, level, closure))

-		    return True;

-	    } else {

-		closure->bindings[level] = (entry->tight ?

-					    XrmBindTightly : XrmBindLoosely);

-		closure->quarks[level] = entry->name;

-		if (EnumAllNTable(entry, level+1, closure))

-		    return True;

-	    }

-	}

-    }

-    return False;

-}

-

-/* recurse on every table in the table, arbitrary order.

- * stop if user proc returns True.  level is current depth in database.

- */

-static Bool EnumNTable(

-    NTable		table,

-    XrmNameList		names,

-    XrmClassList 	classes,

-    register int	level,

-    register EClosure	closure)

-{

-    register NTable	entry;

-    register XrmQuark	q;

-    register unsigned int leaf;

-    Bool (*get)(

-            NTable		table,

-            XrmNameList		names,

-            XrmClassList 	classes,

-            register int	level,

-            EClosure		closure);

-    Bool bilevel;

-

-/* find entries named ename, leafness leaf, tight or loose, and call get */

-#define ITIGHTLOOSE(ename) \

-    NFIND(ename); \

-    if (entry) { \

-	if (leaf == entry->leaf) { \

-	    if (!leaf && !entry->tight && entry->next && \

-		entry->next->name == q && entry->next->tight && \

-		(bilevel || entry->next->hasloose) && \

-		EnumLTable((LTable)entry->next, names+1, classes+1, \

-			   level, closure)) \

-		return True; \

-	    if ((*get)(entry, names+1, classes+1, level, closure)) \

-		return True; \

-	    if (entry->tight && (entry = entry->next) && \

-		entry->name == q && leaf == entry->leaf && \

-		(*get)(entry, names+1, classes+1, level, closure)) \

-		return True; \

-	} else if (entry->leaf) { \

-	    if ((bilevel || entry->hasloose) && \

-		EnumLTable((LTable)entry, names+1, classes+1, level, closure))\

-		return True; \

-	    if (entry->tight && (entry = entry->next) && \

-		entry->name == q && (bilevel || entry->hasloose) && \

-		EnumLTable((LTable)entry, names+1, classes+1, level, closure))\

-		return True; \

-	} \

-    }

-

-/* find entries named ename, leafness leaf, loose only, and call get */

-#define ILOOSE(ename) \

-    NFIND(ename); \

-    if (entry && entry->tight && (entry = entry->next) && entry->name != q) \

-	entry = (NTable)NULL; \

-    if (entry) { \

-	if (leaf == entry->leaf) { \

-	    if ((*get)(entry, names+1, classes+1, level, closure)) \

-		return True; \

-	} else if (entry->leaf && (bilevel || entry->hasloose)) { \

-	    if (EnumLTable((LTable)entry, names+1, classes+1, level, closure))\

-		return True; \

-	} \

-    }

-

-    if (level >= MAXDBDEPTH)

-	return False;

-    closure->bindings[level] = (table->tight ?

-				XrmBindTightly : XrmBindLoosely);

-    closure->quarks[level] = table->name;

-    level++;

-    if (!*names) {

-	if (EnumAllNTable(table, level, closure))

-	    return True;

-    } else {

-	if (names[1] || closure->mode == XrmEnumAllLevels) {

-	    get = EnumNTable; /* recurse */

-	    leaf = 0;

-	    bilevel = !names[1];

-	} else {

-	    get = (getNTableEProcp)EnumLTable; /* bottom of recursion */

-	    leaf = 1;

-	    bilevel = False;

-	}

-	if (table->hasloose && closure->mode == XrmEnumAllLevels) {

-	    NTable *bucket;

-	    int i;

-	    XrmQuark empty = NULLQUARK;

-

-	    for (i = table->mask, bucket = NodeBuckets(table);

-		 i >= 0;

-		 i--, bucket++) {

-		q = NULLQUARK;

-		for (entry = *bucket; entry; entry = entry->next) {

-		    if (!entry->tight && entry->name != q &&

-			entry->name != *names && entry->name != *classes) {

-			q = entry->name;

-			if (entry->leaf) {

-			    if (EnumLTable((LTable)entry, &empty, &empty,

-					   level, closure))

-				return True;

-			} else {

-			    if (EnumNTable(entry, &empty, &empty,

-					   level, closure))

-				return True;

-			}

-		    }

-		}

-	    }

-	}

-

-	ITIGHTLOOSE(*names);   /* do name, tight and loose */

-	ITIGHTLOOSE(*classes); /* do class, tight and loose */

-	if (table->hasany) {

-	    ITIGHTLOOSE(XrmQANY); /* do ANY, tight and loose */

-	}

-	if (table->hasloose) {

-	    while (1) {

-		names++;

-		classes++;

-		if (!*names)

-		    break;

-		if (!names[1] && closure->mode != XrmEnumAllLevels) {

-		    get = (getNTableEProcp)EnumLTable; /* bottom of recursion */

-		    leaf = 1;

-		}

-		ILOOSE(*names);   /* loose names */

-		ILOOSE(*classes); /* loose classes */

-		if (table->hasany) {

-		    ILOOSE(XrmQANY); /* loose ANY */

-		}

-	    }

-	    names--;

-	    classes--;

-	}

-    }

-    /* now look for matching leaf nodes */

-    entry = table->next;

-    if (!entry)

-	return False;

-    if (entry->leaf) {

-	if (entry->tight && !table->tight)

-	    entry = entry->next;

-    } else {

-	entry = entry->next;

-	if (!entry || !entry->tight)

-	    return False;

-    }

-    if (!entry || entry->name != table->name)

-	return False;

-    /* found one */

-    level--;

-    if ((!*names || entry->hasloose) &&

-	EnumLTable((LTable)entry, names, classes, level, closure))

-	return True;

-    if (entry->tight && entry == table->next && (entry = entry->next) &&

-	entry->name == table->name && (!*names || entry->hasloose))

-	return EnumLTable((LTable)entry, names, classes, level, closure);

-    return False;

-

-#undef ITIGHTLOOSE

-#undef ILOOSE

-}

-

-/* call the proc for every value in the database, arbitrary order.

- * stop if the proc returns True.

- */

-Bool XrmEnumerateDatabase(

-    XrmDatabase		db,

-    XrmNameList		names,

-    XrmClassList	classes,

-    int			mode,

-    DBEnumProc		proc,

-    XPointer		closure)

-{

-    XrmBinding  bindings[MAXDBDEPTH+2];

-    XrmQuark	quarks[MAXDBDEPTH+2];

-    register NTable table;

-    EClosureRec	eclosure;

-    Bool retval = False;

-

-    if (!db)

-	return False;

-    _XLockMutex(&db->linfo);

-    eclosure.db = db;

-    eclosure.proc = proc;

-    eclosure.closure = closure;

-    eclosure.bindings = bindings;

-    eclosure.quarks = quarks;

-    eclosure.mode = mode;

-    table = db->table;

-    if (table && !table->leaf && !*names && mode == XrmEnumOneLevel)

-	table = table->next;

-    if (table) {

-	if (!table->leaf)

-	    retval = EnumNTable(table, names, classes, 0, &eclosure);

-	else

-	    retval = EnumLTable((LTable)table, names, classes, 0, &eclosure);

-    }

-    _XUnlockMutex(&db->linfo);

-    return retval;

-}

-

-static void PrintBindingQuarkList(

-    XrmBindingList      bindings,

-    XrmQuarkList	quarks,

-    FILE		*stream)

-{

-    Bool	firstNameSeen;

-

-    for (firstNameSeen = False; *quarks; bindings++, quarks++) {

-	if (*bindings == XrmBindLoosely) {

-	    (void) fprintf(stream, "*");

-	} else if (firstNameSeen) {

-	    (void) fprintf(stream, ".");

-	}

-	firstNameSeen = True;

-	(void) fputs(XrmQuarkToString(*quarks), stream);

-    }

-}

-

-/* output out the entry in correct file syntax */

-/*ARGSUSED*/

-static Bool DumpEntry(

-    XrmDatabase		*db,

-    XrmBindingList      bindings,

-    XrmQuarkList	quarks,

-    XrmRepresentation   *type,

-    XrmValuePtr		value,

-    XPointer		data)

-{

-    FILE			*stream = (FILE *)data;

-    register unsigned int	i;

-    register char		*s;

-    register char		c;

-

-    if (*type != XrmQString)

-	(void) putc('!', stream);

-    PrintBindingQuarkList(bindings, quarks, stream);

-    s = value->addr;

-    i = value->size;

-    if (*type == XrmQString) {

-	(void) fputs(":\t", stream);

-	if (i)

-	    i--;

-    }

-    else

-	(void) fprintf(stream, "=%s:\t", XrmRepresentationToString(*type));

-    if (i && (*s == ' ' || *s == '\t'))

-	(void) putc('\\', stream); /* preserve leading whitespace */

-    while (i--) {

-	c = *s++;

-	if (c == '\n') {

-	    if (i)

-		(void) fputs("\\n\\\n", stream);

-	    else

-		(void) fputs("\\n", stream);

-	} else if (c == '\\')

-	    (void) fputs("\\\\", stream);

-	else if ((c < ' ' && c != '\t') ||

-		 ((unsigned char)c >= 0x7f && (unsigned char)c < 0xa0))

-	    (void) fprintf(stream, "\\%03o", (unsigned char)c);

-	else

-	    (void) putc(c, stream);

-    }

-    (void) putc('\n', stream);

-    return ferror(stream) != 0;

-}

-

-#ifdef DEBUG

-

-void PrintTable(

-    NTable table,

-    FILE *file)

-{

-    XrmBinding  bindings[MAXDBDEPTH+1];

-    XrmQuark	quarks[MAXDBDEPTH+1];

-    EClosureRec closure;

-    XrmQuark	empty = NULLQUARK;

-

-    closure.db = (XrmDatabase)NULL;

-    closure.proc = DumpEntry;

-    closure.closure = (XPointer)file;

-    closure.bindings = bindings;

-    closure.quarks = quarks;

-    closure.mode = XrmEnumAllLevels;

-    if (table->leaf)

-	EnumLTable((LTable)table, &empty, &empty, 0, &closure);

-    else

-	EnumNTable(table, &empty, &empty, 0, &closure);

-}

-

-#endif /* DEBUG */

-

-void

-XrmPutFileDatabase(

-    XrmDatabase db,

-    _Xconst char *fileName)

-{

-    FILE	*file;

-    XrmQuark empty = NULLQUARK;

-

-    if (!db) return;

-    if (!(file = fopen(fileName, "w"))) return;

-    if (XrmEnumerateDatabase(db, &empty, &empty, XrmEnumAllLevels,

-			     DumpEntry, (XPointer) file))

-	unlink((char *)fileName);

-    fclose(file);

-}

-

-/* macros used in get/search functions */

-

-/* find entries named ename, leafness leaf, tight or loose, and call get */

-#define GTIGHTLOOSE(ename,looseleaf) \

-    NFIND(ename); \

-    if (entry) { \

-	if (leaf == entry->leaf) { \

-	    if (!leaf && !entry->tight && entry->next && \

-		entry->next->name == q && entry->next->tight && \

-		entry->next->hasloose && \

-		looseleaf((LTable)entry->next, names+1, classes+1, closure)) \

-		return True; \

-	    if ((*get)(entry, names+1, classes+1, closure)) \

-		return True; \

-	    if (entry->tight && (entry = entry->next) && \

-		entry->name == q && leaf == entry->leaf && \

-		(*get)(entry, names+1, classes+1, closure)) \

-		return True; \

-	} else if (entry->leaf) { \

-	    if (entry->hasloose && \

-		looseleaf((LTable)entry, names+1, classes+1, closure)) \

-		return True; \

-	    if (entry->tight && (entry = entry->next) && \

-		entry->name == q && entry->hasloose && \

-		looseleaf((LTable)entry, names+1, classes+1, closure)) \

-		return True; \

-	} \

-    }

-

-/* find entries named ename, leafness leaf, loose only, and call get */

-#define GLOOSE(ename,looseleaf) \

-    NFIND(ename); \

-    if (entry && entry->tight && (entry = entry->next) && entry->name != q) \

-	entry = (NTable)NULL; \

-    if (entry) { \

-	if (leaf == entry->leaf) { \

-	    if ((*get)(entry, names+1, classes+1, closure)) \

-		return True; \

-	} else if (entry->leaf && entry->hasloose) { \

-	    if (looseleaf((LTable)entry, names+1, classes+1, closure)) \

-		return True; \

-	} \

-    }

-

-/* add tight/loose entry to the search list, return True if list is full */

-/*ARGSUSED*/

-static Bool AppendLEntry(

-    LTable		table,

-    XrmNameList		names,

-    XrmClassList 	classes,

-    register SClosure	closure)

-{

-    /* check for duplicate */

-    if (closure->idx >= 0 && closure->list[closure->idx] == table)

-	return False;

-    if (closure->idx == closure->limit)

-	return True;

-    /* append it */

-    closure->idx++;

-    closure->list[closure->idx] = table;

-    return False;

-}

-

-/* add loose entry to the search list, return True if list is full */

-/*ARGSUSED*/

-static Bool AppendLooseLEntry(

-    LTable		table,

-    XrmNameList		names,

-    XrmClassList 	classes,

-    register SClosure	closure)

-{

-    /* check for duplicate */

-    if (closure->idx >= 0 && closure->list[closure->idx] == table)

-	return False;

-    if (closure->idx >= closure->limit - 1)

-	return True;

-    /* append it */

-    closure->idx++;

-    closure->list[closure->idx] = LOOSESEARCH;

-    closure->idx++;

-    closure->list[closure->idx] = table;

-    return False;

-}

-

-/* search for a leaf table */

-static Bool SearchNEntry(

-    NTable		table,

-    XrmNameList		names,

-    XrmClassList 	classes,

-    SClosure		closure)

-{

-    register NTable	entry;

-    register XrmQuark	q;

-    register unsigned int leaf;

-    Bool		(*get)(

-            NTable		table,

-            XrmNameList		names,

-            XrmClassList 	classes,

-            SClosure		closure);

-

-    if (names[1]) {

-	get = SearchNEntry; /* recurse */

-	leaf = 0;

-    } else {

-	get = (getNTableSProcp)AppendLEntry; /* bottom of recursion */

-	leaf = 1;

-    }

-    GTIGHTLOOSE(*names, AppendLooseLEntry);   /* do name, tight and loose */

-    GTIGHTLOOSE(*classes, AppendLooseLEntry); /* do class, tight and loose */

-    if (table->hasany) {

-	GTIGHTLOOSE(XrmQANY, AppendLooseLEntry); /* do ANY, tight and loose */

-    }

-    if (table->hasloose) {

-	while (1) {

-	    names++;

-	    classes++;

-	    if (!*names)

-		break;

-	    if (!names[1]) {

-		get = (getNTableSProcp)AppendLEntry; /* bottom of recursion */

-		leaf = 1;

-	    }

-	    GLOOSE(*names, AppendLooseLEntry);   /* loose names */

-	    GLOOSE(*classes, AppendLooseLEntry); /* loose classes */

-	    if (table->hasany) {

-		GLOOSE(XrmQANY, AppendLooseLEntry); /* loose ANY */

-	    }

-	}

-    }

-    /* now look for matching leaf nodes */

-    entry = table->next;

-    if (!entry)

-	return False;

-    if (entry->leaf) {

-	if (entry->tight && !table->tight)

-	    entry = entry->next;

-    } else {

-	entry = entry->next;

-	if (!entry || !entry->tight)

-	    return False;

-    }

-    if (!entry || entry->name != table->name)

-	return False;

-    /* found one */

-    if (entry->hasloose &&

-	AppendLooseLEntry((LTable)entry, names, classes, closure))

-	return True;

-    if (entry->tight && entry == table->next && (entry = entry->next) &&

-	entry->name == table->name && entry->hasloose)

-	return AppendLooseLEntry((LTable)entry, names, classes, closure);

-    return False;

-}

-

-Bool XrmQGetSearchList(

-    XrmDatabase     db,

-    XrmNameList	    names,

-    XrmClassList    classes,

-    XrmSearchList   searchList,	/* RETURN */

-    int		    listLength)

-{

-    register NTable	table;

-    SClosureRec		closure;

-

-    if (listLength <= 0)

-	return False;

-    closure.list = (LTable *)searchList;

-    closure.idx = -1;

-    closure.limit = listLength - 2;

-    if (db) {

-	_XLockMutex(&db->linfo);

-	table = db->table;

-	if (*names) {

-	    if (table && !table->leaf) {

-		if (SearchNEntry(table, names, classes, &closure)) {

-		    _XUnlockMutex(&db->linfo);

-		    return False;

-		}

-	    } else if (table && table->hasloose &&

-		       AppendLooseLEntry((LTable)table, names, classes,

-					 &closure)) {

-		_XUnlockMutex(&db->linfo);

-		return False;

-	    }

-	} else {

-	    if (table && !table->leaf)

-		table = table->next;

-	    if (table &&

-		AppendLEntry((LTable)table, names, classes, &closure)) {

-		_XUnlockMutex(&db->linfo);

-		return False;

-	    }

-	}

-	_XUnlockMutex(&db->linfo);

-    }

-    closure.list[closure.idx + 1] = (LTable)NULL;

-    return True;

-}

-

-Bool XrmQGetSearchResource(

-	     XrmSearchList	searchList,

-    register XrmName		name,

-    register XrmClass		class,

-    	     XrmRepresentation	*pType,  /* RETURN */

-    	     XrmValue		*pValue) /* RETURN */

-{

-    register LTable *list;

-    register LTable table;

-    register VEntry entry = NULL;

-    int flags;

-

-/* find tight or loose entry */

-#define VTIGHTLOOSE(q) \

-    entry = LeafHash(table, q); \

-    while (entry && entry->name != q) \

-	entry = entry->next; \

-    if (entry) \

-	break

-

-/* find loose entry */

-#define VLOOSE(q) \

-    entry = LeafHash(table, q); \

-    while (entry && entry->name != q) \

-	entry = entry->next; \

-    if (entry) { \

-	if (!entry->tight) \

-	    break; \

-	if ((entry = entry->next) && entry->name == q) \

-	    break; \

-    }

-

-    list = (LTable *)searchList;

-    /* figure out which combination of name and class we need to search for */

-    flags = 0;

-    if (IsResourceQuark(name))

-	flags = 2;

-    if (IsResourceQuark(class))

-	flags |= 1;

-    if (!flags) {

-	/* neither name nor class has ever been used to name a resource */

-	table = (LTable)NULL;

-    } else if (flags == 3) {

-	/* both name and class */

-	while ((table = *list++)) {

-	    if (table != LOOSESEARCH) {

-		VTIGHTLOOSE(name);  /* do name, tight and loose */

-		VTIGHTLOOSE(class); /* do class, tight and loose */

-	    } else {

-		table = *list++;

-		VLOOSE(name);  /* do name, loose only */

-		VLOOSE(class); /* do class, loose only */

-	    }

-	}

-    } else {

-	/* just one of name or class */

-	if (flags == 1)

-	    name = class;

-	while ((table = *list++)) {

-	    if (table != LOOSESEARCH) {

-		VTIGHTLOOSE(name); /* tight and loose */

-	    } else {

-		table = *list++;

-		VLOOSE(name); /* loose only */

-	    }

-	}

-    }

-    if (table) {

-	/* found a match */

-	if (entry->string) {

-	    *pType = XrmQString;

-	    pValue->addr = StringValue(entry);

-	} else {

-	    *pType = RepType(entry);

-	    pValue->addr = DataValue(entry);

-	}

-	pValue->size = entry->size;

-	return True;

-    }

-    *pType = NULLQUARK;

-    pValue->addr = (XPointer)NULL;

-    pValue->size = 0;

-    return False;

-

-#undef VTIGHTLOOSE

-#undef VLOOSE

-}

-

-/* look for a tight/loose value */

-static Bool GetVEntry(

-    LTable		table,

-    XrmNameList		names,

-    XrmClassList 	classes,

-    VClosure		closure)

-{

-    register VEntry entry;

-    register XrmQuark q;

-

-    /* try name first */

-    q = *names;

-    entry = LeafHash(table, q);

-    while (entry && entry->name != q)

-	entry = entry->next;

-    if (!entry) {

-	/* not found, try class */

-	q = *classes;

-	entry = LeafHash(table, q);

-	while (entry && entry->name != q)

-	    entry = entry->next;

-	if (!entry)

-	    return False;

-    }

-    if (entry->string) {

-	*closure->type = XrmQString;

-	closure->value->addr = StringValue(entry);

-    } else {

-	*closure->type = RepType(entry);

-	closure->value->addr = DataValue(entry);

-    }

-    closure->value->size = entry->size;

-    return True;

-}

-

-/* look for a loose value */

-static Bool GetLooseVEntry(

-    LTable		table,

-    XrmNameList		names,

-    XrmClassList 	classes,

-    VClosure		closure)

-{

-    register VEntry	entry;

-    register XrmQuark	q;

-

-#define VLOOSE(ename) \

-    q = ename; \

-    entry = LeafHash(table, q); \

-    while (entry && entry->name != q) \

-	entry = entry->next; \

-    if (entry && entry->tight && (entry = entry->next) && entry->name != q) \

-	entry = (VEntry)NULL;

-

-    /* bump to last component */

-    while (names[1]) {

-	names++;

-	classes++;

-    }

-    VLOOSE(*names);  /* do name, loose only */

-    if (!entry) {

-	VLOOSE(*classes); /* do class, loose only */

-	if (!entry)

-	    return False;

-    }

-    if (entry->string) {

-	*closure->type = XrmQString;

-	closure->value->addr = StringValue(entry);

-    } else {

-	*closure->type = RepType(entry);

-	closure->value->addr = DataValue(entry);

-    }

-    closure->value->size = entry->size;

-    return True;

-

-#undef VLOOSE

-}

-

-/* recursive search for a value */

-static Bool GetNEntry(

-    NTable		table,

-    XrmNameList		names,

-    XrmClassList 	classes,

-    VClosure		closure)

-{

-    register NTable	entry;

-    register XrmQuark	q;

-    register unsigned int leaf;

-    Bool		(*get)(

-            NTable              table,

-            XrmNameList         names,

-            XrmClassList        classes,

-            VClosure            closure);

-    NTable		otable;

-

-    if (names[2]) {

-	get = GetNEntry; /* recurse */

-	leaf = 0;

-    } else {

-	get = (getNTableVProcp)GetVEntry; /* bottom of recursion */

-	leaf = 1;

-    }

-    GTIGHTLOOSE(*names, GetLooseVEntry);   /* do name, tight and loose */

-    GTIGHTLOOSE(*classes, GetLooseVEntry); /* do class, tight and loose */

-    if (table->hasany) {

-	GTIGHTLOOSE(XrmQANY, GetLooseVEntry); /* do ANY, tight and loose */

-    }

-    if (table->hasloose) {

-	while (1) {

-	    names++;

-	    classes++;

-	    if (!names[1])

-		break;

-	    if (!names[2]) {

-		get = (getNTableVProcp)GetVEntry; /* bottom of recursion */

-		leaf = 1;

-	    }

-	    GLOOSE(*names, GetLooseVEntry);   /* do name, loose only */

-	    GLOOSE(*classes, GetLooseVEntry); /* do class, loose only */

-	    if (table->hasany) {

-		GLOOSE(XrmQANY, GetLooseVEntry); /* do ANY, loose only */

-	    }

-	}

-    }

-    /* look for matching leaf tables */

-    otable = table;

-    table = table->next;

-    if (!table)

-	return False;

-    if (table->leaf) {

-	if (table->tight && !otable->tight)

-	    table = table->next;

-    } else {

-	table = table->next;

-	if (!table || !table->tight)

-	    return False;

-    }

-    if (!table || table->name != otable->name)

-	return False;

-    /* found one */

-    if (table->hasloose &&

-	GetLooseVEntry((LTable)table, names, classes, closure))

-	return True;

-    if (table->tight && table == otable->next) {

-	table = table->next;

-	if (table && table->name == otable->name && table->hasloose)

-	    return GetLooseVEntry((LTable)table, names, classes, closure);

-    }

-    return False;

-}

-

-Bool XrmQGetResource(

-    XrmDatabase         db,

-    XrmNameList		names,

-    XrmClassList 	classes,

-    XrmRepresentation	*pType,  /* RETURN */

-    XrmValuePtr		pValue)  /* RETURN */

-{

-    register NTable table;

-    VClosureRec closure;

-

-    if (db && *names) {

-	_XLockMutex(&db->linfo);

-	closure.type = pType;

-	closure.value = pValue;

-	table = db->table;

-	if (names[1]) {

-	    if (table && !table->leaf) {

-		if (GetNEntry(table, names, classes, &closure)) {

-		    _XUnlockMutex(&db->linfo);

-		    return True;

-		}

-	    } else if (table && table->hasloose &&

-		    GetLooseVEntry((LTable)table, names, classes, &closure)) {

-		_XUnlockMutex (&db->linfo);

-		return True;

-	    }

-	} else {

-	    if (table && !table->leaf)

-		table = table->next;

-	    if (table && GetVEntry((LTable)table, names, classes, &closure)) {

-		_XUnlockMutex(&db->linfo);

-		return True;

-	    }

-	}

-	_XUnlockMutex(&db->linfo);

-    }

-    *pType = NULLQUARK;

-    pValue->addr = (XPointer)NULL;

-    pValue->size = 0;

-    return False;

-}

-

-Bool

-XrmGetResource(XrmDatabase db, _Xconst char *name_str, _Xconst char *class_str,

-	       XrmString *pType_str, XrmValuePtr pValue)

-{

-    XrmName		names[MAXDBDEPTH+1];

-    XrmClass		classes[MAXDBDEPTH+1];

-    XrmRepresentation   fromType;

-    Bool		result;

-

-    XrmStringToNameList(name_str, names);

-    XrmStringToClassList(class_str, classes);

-    result = XrmQGetResource(db, names, classes, &fromType, pValue);

-    (*pType_str) = XrmQuarkToString(fromType);

-    return result;

-}

-

-/* destroy all values, plus table itself */

-static void DestroyLTable(

-    LTable table)

-{

-    register int i;

-    register VEntry *buckets;

-    register VEntry entry, next;

-

-    buckets = table->buckets;

-    for (i = table->table.mask; i >= 0; i--, buckets++) {

-	for (next = *buckets; (entry = next); ) {

-	    next = entry->next;

-	    Xfree((char *)entry);

-	}

-    }

-    Xfree((char *)table->buckets);

-    Xfree((char *)table);

-}

-

-/* destroy all contained tables, plus table itself */

-static void DestroyNTable(

-    NTable table)

-{

-    register int i;

-    register NTable *buckets;

-    register NTable entry, next;

-

-    buckets = NodeBuckets(table);

-    for (i = table->mask; i >= 0; i--, buckets++) {

-	for (next = *buckets; (entry = next); ) {

-	    next = entry->next;

-	    if (entry->leaf)

-		DestroyLTable((LTable)entry);

-	    else

-		DestroyNTable(entry);

-	}

-    }

-    Xfree((char *)table);

-}

-

-const char *

-XrmLocaleOfDatabase(

-    XrmDatabase db)

-{

-    const char* retval;

-    _XLockMutex(&db->linfo);

-    retval = (*db->methods->lcname)(db->mbstate);

-    _XUnlockMutex(&db->linfo);

-    return retval;

-}

-

-void XrmDestroyDatabase(

-    XrmDatabase   db)

-{

-    register NTable table, next;

-

-    if (db) {

-	_XLockMutex(&db->linfo);

-	for (next = db->table; (table = next); ) {

-	    next = table->next;

-	    if (table->leaf)

-		DestroyLTable((LTable)table);

-	    else

-		DestroyNTable(table);

-	}

-	_XUnlockMutex(&db->linfo);

-	_XFreeMutex(&db->linfo);

-	(*db->methods->destroy)(db->mbstate);

-	Xfree((char *)db);

-    }

-}

+
+/***********************************************************
+Copyright 1987, 1988, 1990 by Digital Equipment Corporation, Maynard
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+******************************************************************/
+/*
+
+Copyright 1987, 1988, 1990, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall
+not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization
+from The Open Group.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include	<stdio.h>
+#include	<ctype.h>
+#include	"Xlibint.h"
+#include	<X11/Xresource.h>
+#include	"Xlcint.h"
+#ifdef XTHREADS
+#include	"locking.h"
+#endif
+#include	<X11/Xos.h>
+#include	<sys/stat.h>
+#include "Xresinternal.h"
+#include "Xresource.h"
+
+/*
+
+These Xrm routines allow very fast lookup of resources in the resource
+database.  Several usage patterns are exploited:
+
+(1) Widgets get a lot of resources at one time.  Rather than look up each from
+scratch, we can precompute the prioritized list of database levels once, then
+search for each resource starting at the beginning of the list.
+
+(2) Many database levels don't contain any leaf resource nodes.  There is no
+point in looking for resources on a level that doesn't contain any.  This
+information is kept on a per-level basis.
+
+(3) Sometimes the widget instance tree is structured such that you get the same
+class name repeated on the fully qualified widget name.  This can result in the
+same database level occuring multiple times on the search list.  The code below
+only checks to see if you get two identical search lists in a row, rather than
+look back through all database levels, but in practice this removes all
+duplicates I've ever observed.
+
+Joel McCormack
+
+*/
+
+/*
+
+The Xrm representation has been completely redesigned to substantially reduce
+memory and hopefully improve performance.
+
+The database is structured into two kinds of tables: LTables that contain
+only values, and NTables that contain only other tables.
+
+Some invariants:
+
+The next pointer of the top-level node table points to the top-level leaf
+table, if any.
+
+Within an LTable, for a given name, the tight value always precedes the
+loose value, and if both are present the loose value is always right after
+the tight value.
+
+Within an NTable, all of the entries for a given name are contiguous,
+in the order tight NTable, loose NTable, tight LTable, loose LTable.
+
+Bob Scheifler
+
+*/
+
+static XrmQuark XrmQString, XrmQANY;
+
+typedef	Bool (*DBEnumProc)(
+    XrmDatabase*	/* db */,
+    XrmBindingList	/* bindings */,
+    XrmQuarkList	/* quarks */,
+    XrmRepresentation*	/* type */,
+    XrmValue*		/* value */,
+    XPointer		/* closure */
+);
+
+typedef struct _VEntry {
+    struct _VEntry	*next;		/* next in chain */
+    XrmQuark		name;		/* name of this entry */
+    unsigned int	tight:1;	/* 1 if it is a tight binding */
+    unsigned int	string:1;	/* 1 if type is String */
+    unsigned int	size:30;	/* size of value */
+} VEntryRec, *VEntry;
+
+
+typedef struct _DEntry {
+    VEntryRec		entry;		/* entry */
+    XrmRepresentation	type;		/* representation type */
+} DEntryRec, *DEntry;
+
+/* the value is right after the structure */
+#define StringValue(ve) (XPointer)((ve) + 1)
+#define RepType(ve) ((DEntry)(ve))->type
+/* the value is right after the structure */
+#define DataValue(ve) (XPointer)(((DEntry)(ve)) + 1)
+#define RawValue(ve) (char *)((ve)->string ? StringValue(ve) : DataValue(ve))
+
+typedef struct _NTable {
+    struct _NTable	*next;		/* next in chain */
+    XrmQuark		name;		/* name of this entry */
+    unsigned int	tight:1;	/* 1 if it is a tight binding */
+    unsigned int	leaf:1;		/* 1 if children are values */
+    unsigned int	hasloose:1;	/* 1 if has loose children */
+    unsigned int	hasany:1;	/* 1 if has ANY entry */
+    unsigned int	pad:4;		/* unused */
+    unsigned int	mask:8;		/* hash size - 1 */
+    unsigned int	entries:16;	/* number of children */
+} NTableRec, *NTable;
+
+/* the buckets are right after the structure */
+#define NodeBuckets(ne) ((NTable *)((ne) + 1))
+#define NodeHash(ne,q) NodeBuckets(ne)[(q) & (ne)->mask]
+
+/* leaf tables have an extra level of indirection for the buckets,
+ * so that resizing can be done without invalidating a search list.
+ * This is completely ugly, and wastes some memory, but the Xlib
+ * spec doesn't really specify whether invalidation is OK, and the
+ * old implementation did not invalidate.
+ */
+typedef struct _LTable {
+    NTableRec		table;
+    VEntry		*buckets;
+} LTableRec, *LTable;
+
+#define LeafHash(le,q) (le)->buckets[(q) & (le)->table.mask]
+
+/* An XrmDatabase just holds a pointer to the first top-level table.
+ * The type name is no longer descriptive, but better to not change
+ * the Xresource.h header file.  This type also gets used to define
+ * XrmSearchList, which is a complete crock, but we'll just leave it
+ * and caste types as required.
+ */
+typedef struct _XrmHashBucketRec {
+    NTable table;
+    XPointer mbstate;
+    XrmMethods methods;
+#ifdef XTHREADS
+    LockInfoRec linfo;
+#endif
+} XrmHashBucketRec;
+
+/* closure used in get/put resource */
+typedef struct _VClosure {
+    XrmRepresentation	*type;		/* type of value */
+    XrmValuePtr		value;		/* value itself */
+} VClosureRec, *VClosure;
+
+/* closure used in get search list */
+typedef struct _SClosure {
+    LTable		*list;		/* search list */
+    int			idx;		/* index of last filled element */
+    int			limit;		/* maximum index */
+} SClosureRec, *SClosure;
+
+/* placed in XrmSearchList to indicate next table is loose only */
+#define LOOSESEARCH ((LTable)1)
+
+/* closure used in enumerate database */
+typedef struct _EClosure {
+    XrmDatabase db;			/* the database */
+    DBEnumProc proc;			/* the user proc */
+    XPointer closure;			/* the user closure */
+    XrmBindingList bindings;		/* binding list */
+    XrmQuarkList quarks;		/* quark list */
+    int mode;				/* XrmEnum<kind> */
+} EClosureRec, *EClosure;
+
+/* types for typecasting ETable based functions to NTable based functions */
+typedef Bool (*getNTableSProcp)(
+    NTable              table,
+    XrmNameList         names,
+    XrmClassList        classes,
+    SClosure            closure);
+typedef Bool (*getNTableVProcp)(
+    NTable              table,
+    XrmNameList         names,
+    XrmClassList        classes,
+    VClosure            closure);
+typedef Bool (*getNTableEProcp)(
+    NTable              table,
+    XrmNameList         names,
+    XrmClassList        classes,
+    register int        level,
+    EClosure            closure);
+
+/* predicate to determine when to resize a hash table */
+#define GrowthPred(n,m) ((unsigned)(n) > (((m) + 1) << 2))
+
+#define GROW(prev) \
+    if (GrowthPred((*prev)->entries, (*prev)->mask)) \
+	GrowTable(prev)
+
+/* pick a reasonable value for maximum depth of resource database */
+#define MAXDBDEPTH 100
+
+/* macro used in get/search functions */
+
+/* find an entry named ename, with leafness given by leaf */
+#define NFIND(ename) \
+    q = ename; \
+    entry = NodeHash(table, q); \
+    while (entry && entry->name != q) \
+	entry = entry->next; \
+    if (leaf && entry && !entry->leaf) { \
+	entry = entry->next; \
+	if (entry && !entry->leaf) \
+	    entry = entry->next; \
+	if (entry && entry->name != q) \
+	    entry = (NTable)NULL; \
+    }
+
+/* resourceQuarks keeps track of what quarks have been associated with values
+ * in all LTables.  If a quark has never been used in an LTable, we don't need
+ * to bother looking for it.
+ */
+
+static unsigned char *resourceQuarks = (unsigned char *)NULL;
+static XrmQuark maxResourceQuark = -1;
+
+/* determines if a quark has been used for a value in any database */
+#define IsResourceQuark(q)  ((q) > 0 && (q) <= maxResourceQuark && \
+			     resourceQuarks[(q) >> 3] & (1 << ((q) & 7)))
+
+typedef unsigned char XrmBits;
+
+#define BSLASH  ((XrmBits) (1 << 5))
+#define NORMAL	((XrmBits) (1 << 4))
+#define EOQ	((XrmBits) (1 << 3))
+#define SEP	((XrmBits) (1 << 2))
+#define ENDOF	((XrmBits) (1 << 1))
+#define SPACE	(NORMAL|EOQ|SEP|(XrmBits)0)
+#define RSEP	(NORMAL|EOQ|SEP|(XrmBits)1)
+#define EOS	(EOQ|SEP|ENDOF|(XrmBits)0)
+#define EOL	(EOQ|SEP|ENDOF|(XrmBits)1)
+#define BINDING	(NORMAL|EOQ)
+#define ODIGIT	(NORMAL|(XrmBits)1)
+
+#define next_char(ch,str) xrmtypes[(unsigned char)((ch) = *(++(str)))]
+#define next_mbchar(ch,len,str) xrmtypes[(unsigned char)(ch = (*db->methods->mbchar)(db->mbstate, str, &len), str += len, ch)]
+
+#define is_space(bits)		((bits) == SPACE)
+#define is_EOQ(bits)		((bits) & EOQ)
+#define is_EOF(bits)		((bits) == EOS)
+#define is_EOL(bits)		((bits) & ENDOF)
+#define is_binding(bits)	((bits) == BINDING)
+#define is_odigit(bits)		((bits) == ODIGIT)
+#define is_separator(bits)	((bits) & SEP)
+#define is_nonpcs(bits)		(!(bits))
+#define is_normal(bits)		((bits) & NORMAL)
+#define is_simple(bits)		((bits) & (NORMAL|BSLASH))
+#define is_special(bits)	((bits) & (ENDOF|BSLASH))
+
+/* parsing types */
+static XrmBits const xrmtypes[256] = {
+    EOS,0,0,0,0,0,0,0,
+    0,SPACE,EOL,0,0,
+#if defined(WIN32) || defined(__UNIXOS2__)
+                    EOL,	/* treat CR the same as LF, just in case */
+#else
+                    0,
+#endif
+                      0,0,
+    0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,
+    SPACE,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,
+    NORMAL,NORMAL,BINDING,NORMAL,NORMAL,NORMAL,BINDING,NORMAL,
+    ODIGIT,ODIGIT,ODIGIT,ODIGIT,ODIGIT,ODIGIT,ODIGIT,ODIGIT,
+    NORMAL,NORMAL,RSEP,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,
+    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,
+    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,
+    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,
+    NORMAL,NORMAL,NORMAL,NORMAL,BSLASH,NORMAL,NORMAL,NORMAL,
+    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,
+    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,
+    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,
+    NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,NORMAL,0
+    /* The rest will be automatically initialized to zero. */
+};
+
+void XrmInitialize(void)
+{
+    XrmQString = XrmPermStringToQuark("String");
+    XrmQANY = XrmPermStringToQuark("?");
+}
+
+XrmDatabase XrmGetDatabase(
+    Display *display)
+{
+    XrmDatabase retval;
+    LockDisplay(display);
+    retval = display->db;
+    UnlockDisplay(display);
+    return retval;
+}
+
+void XrmSetDatabase(
+    Display *display,
+    XrmDatabase database)
+{
+    LockDisplay(display);
+    /* destroy database if set up imlicitely by XGetDefault() */
+    if (display->db && (display->flags & XlibDisplayDfltRMDB)) {
+	XrmDestroyDatabase(display->db);
+	display->flags &= ~XlibDisplayDfltRMDB;
+    }
+    display->db = database;
+    UnlockDisplay(display);
+}
+
+void
+XrmStringToQuarkList(
+    register _Xconst char  *name,
+    register XrmQuarkList quarks)   /* RETURN */
+{
+    register XrmBits		bits;
+    register Signature  	sig = 0;
+    register char       	ch, *tname;
+    register int 		i = 0;
+
+    if ((tname = (char *)name)) {
+	tname--;
+	while (!is_EOF(bits = next_char(ch, tname))) {
+	    if (is_binding (bits)) {
+		if (i) {
+		    /* Found a complete name */
+		    *quarks++ = _XrmInternalStringToQuark(name,tname - name,
+							  sig, False);
+		    i = 0;
+		    sig = 0;
+		}
+		name = tname+1;
+	    }
+	    else {
+		sig = (sig << 1) + ch; /* Compute the signature. */
+		i++;
+	    }
+	}
+	*quarks++ = _XrmInternalStringToQuark(name, tname - name, sig, False);
+    }
+    *quarks = NULLQUARK;
+}
+
+void
+XrmStringToBindingQuarkList(
+    register _Xconst char   *name,
+    register XrmBindingList bindings,   /* RETURN */
+    register XrmQuarkList   quarks)     /* RETURN */
+{
+    register XrmBits		bits;
+    register Signature  	sig = 0;
+    register char       	ch, *tname;
+    register XrmBinding 	binding;
+    register int 		i = 0;
+
+    if ((tname = (char *)name)) {
+	tname--;
+	binding = XrmBindTightly;
+	while (!is_EOF(bits = next_char(ch, tname))) {
+	    if (is_binding (bits)) {
+		if (i) {
+		    /* Found a complete name */
+		    *bindings++ = binding;
+		    *quarks++ = _XrmInternalStringToQuark(name, tname - name,
+							  sig, False);
+
+		    i = 0;
+		    sig = 0;
+		    binding = XrmBindTightly;
+		}
+		name = tname+1;
+
+		if (ch == '*')
+		    binding = XrmBindLoosely;
+	    }
+	    else {
+		sig = (sig << 1) + ch; /* Compute the signature. */
+		i++;
+	    }
+	}
+	*bindings = binding;
+	*quarks++ = _XrmInternalStringToQuark(name, tname - name, sig, False);
+    }
+    *quarks = NULLQUARK;
+}
+
+#ifdef DEBUG
+
+static void PrintQuarkList(
+    XrmQuarkList    quarks,
+    FILE	    *stream)
+{
+    Bool	    firstNameSeen;
+
+    for (firstNameSeen = False; *quarks; quarks++) {
+	if (firstNameSeen) {
+	    (void) fprintf(stream, ".");
+	}
+	firstNameSeen = True;
+	(void) fputs(XrmQuarkToString(*quarks), stream);
+    }
+} /* PrintQuarkList */
+
+#endif /* DEBUG */
+
+
+/*
+ * Fallback methods for Xrm parsing.
+ * Simulate a C locale. No state needed here.
+ */
+
+static void
+c_mbnoop(
+    XPointer state)
+{
+}
+
+static char
+c_mbchar(
+    XPointer state,
+    const char *str,
+    int *lenp)
+{
+    *lenp = 1;
+    return *str;
+}
+
+static const char *
+c_lcname(
+    XPointer state)
+{
+    return "C";
+}
+
+static const XrmMethodsRec mb_methods = {
+    c_mbnoop,	/* mbinit */
+    c_mbchar,	/* mbchar */
+    c_mbnoop,	/* mbfinish */
+    c_lcname,	/* lcname */
+    c_mbnoop	/* destroy */
+};
+
+
+static XrmDatabase NewDatabase(void)
+{
+    register XrmDatabase db;
+
+    db = (XrmDatabase) Xmalloc(sizeof(XrmHashBucketRec));
+    if (db) {
+	_XCreateMutex(&db->linfo);
+	db->table = (NTable)NULL;
+	db->mbstate = (XPointer)NULL;
+	db->methods = _XrmInitParseInfo(&db->mbstate);
+	if (!db->methods)
+	    db->methods = &mb_methods;
+    }
+    return db;
+}
+
+/* move all values from ftable to ttable, and free ftable's buckets.
+ * ttable is quaranteed empty to start with.
+ */
+static void MoveValues(
+    LTable ftable,
+    register LTable ttable)
+{
+    register VEntry fentry, nfentry;
+    register VEntry *prev;
+    register VEntry *bucket;
+    register VEntry tentry;
+    register int i;
+
+    for (i = ftable->table.mask, bucket = ftable->buckets; i >= 0; i--) {
+	for (fentry = *bucket++; fentry; fentry = nfentry) {
+	    prev = &LeafHash(ttable, fentry->name);
+	    tentry = *prev;
+	    *prev = fentry;
+	    /* chain on all with same name, to preserve invariant order */
+	    while ((nfentry = fentry->next) && nfentry->name == fentry->name)
+		fentry = nfentry;
+	    fentry->next = tentry;
+	}
+    }
+    Xfree((char *)ftable->buckets);
+}
+
+/* move all tables from ftable to ttable, and free ftable.
+ * ttable is quaranteed empty to start with.
+ */
+static void MoveTables(
+    NTable ftable,
+    register NTable ttable)
+{
+    register NTable fentry, nfentry;
+    register NTable *prev;
+    register NTable *bucket;
+    register NTable tentry;
+    register int i;
+
+    for (i = ftable->mask, bucket = NodeBuckets(ftable); i >= 0; i--) {
+	for (fentry = *bucket++; fentry; fentry = nfentry) {
+	    prev = &NodeHash(ttable, fentry->name);
+	    tentry = *prev;
+	    *prev = fentry;
+	    /* chain on all with same name, to preserve invariant order */
+	    while ((nfentry = fentry->next) && nfentry->name == fentry->name)
+		fentry = nfentry;
+	    fentry->next = tentry;
+	}
+    }
+    Xfree((char *)ftable);
+}
+
+/* grow the table, based on current number of entries */
+static void GrowTable(
+    NTable *prev)
+{
+    register NTable table;
+    register int i;
+
+    table = *prev;
+    i = table->mask;
+    if (i == 255) /* biggest it gets */
+	return;
+    while (i < 255 && GrowthPred(table->entries, i))
+	i = (i << 1) + 1;
+    i++; /* i is now the new size */
+    if (table->leaf) {
+	register LTable ltable;
+	LTableRec otable;
+
+	ltable = (LTable)table;
+	/* cons up a copy to make MoveValues look symmetric */
+	otable = *ltable;
+	ltable->buckets = Xcalloc(i, sizeof(VEntry));
+	if (!ltable->buckets) {
+	    ltable->buckets = otable.buckets;
+	    return;
+	}
+	ltable->table.mask = i - 1;
+	MoveValues(&otable, ltable);
+    } else {
+	register NTable ntable;
+
+	ntable = Xcalloc(1, sizeof(NTableRec) + (i * sizeof(NTable)));
+	if (!ntable)
+	    return;
+	*ntable = *table;
+	ntable->mask = i - 1;
+	*prev = ntable;
+	MoveTables(table, ntable);
+    }
+}
+
+/* merge values from ftable into *pprev, destroy ftable in the process */
+static void MergeValues(
+    LTable ftable,
+    NTable *pprev,
+    Bool override)
+{
+    register VEntry fentry, tentry;
+    register VEntry *prev;
+    register LTable ttable;
+    VEntry *bucket;
+    int i;
+    register XrmQuark q;
+
+    ttable = (LTable)*pprev;
+    if (ftable->table.hasloose)
+	ttable->table.hasloose = 1;
+    for (i = ftable->table.mask, bucket = ftable->buckets;
+	 i >= 0;
+	 i--, bucket++) {
+	for (fentry = *bucket; fentry; ) {
+	    q = fentry->name;
+	    prev = &LeafHash(ttable, q);
+	    tentry = *prev;
+	    while (tentry && tentry->name != q)
+		tentry = *(prev = &tentry->next);
+	    /* note: test intentionally uses fentry->name instead of q */
+	    /* permits serendipitous inserts */
+	    while (tentry && tentry->name == fentry->name) {
+		/* if tentry is earlier, skip it */
+		if (!fentry->tight && tentry->tight) {
+		    tentry = *(prev = &tentry->next);
+		    continue;
+		}
+		if (fentry->tight != tentry->tight) {
+		    /* no match, chain in fentry */
+		    *prev = fentry;
+		    prev = &fentry->next;
+		    fentry = *prev;
+		    *prev = tentry;
+		    ttable->table.entries++;
+		} else if (override) {
+		    /* match, chain in fentry, splice out and free tentry */
+		    *prev = fentry;
+		    prev = &fentry->next;
+		    fentry = *prev;
+		    *prev = tentry->next;
+		    /* free the overridden entry */
+		    Xfree((char *)tentry);
+		    /* get next tentry */
+		    tentry = *prev;
+		} else {
+		    /* match, discard fentry */
+		    prev = &tentry->next;
+		    tentry = fentry; /* use as a temp var */
+		    fentry = fentry->next;
+		    /* free the overpowered entry */
+		    Xfree((char *)tentry);
+		    /* get next tentry */
+		    tentry = *prev;
+		}
+		if (!fentry)
+		    break;
+	    }
+	    /* at this point, tentry cannot match any fentry named q */
+	    /* chain in all bindings together, preserve invariant order */
+	    while (fentry && fentry->name == q) {
+		*prev = fentry;
+		prev = &fentry->next;
+		fentry = *prev;
+		*prev = tentry;
+		ttable->table.entries++;
+	    }
+	}
+    }
+    Xfree((char *)ftable->buckets);
+    Xfree((char *)ftable);
+    /* resize if necessary, now that we're all done */
+    GROW(pprev);
+}
+
+/* merge tables from ftable into *pprev, destroy ftable in the process */
+static void MergeTables(
+    NTable ftable,
+    NTable *pprev,
+    Bool override)
+{
+    register NTable fentry, tentry;
+    NTable nfentry;
+    register NTable *prev;
+    register NTable ttable;
+    NTable *bucket;
+    int i;
+    register XrmQuark q;
+
+    ttable = *pprev;
+    if (ftable->hasloose)
+	ttable->hasloose = 1;
+    if (ftable->hasany)
+	ttable->hasany = 1;
+    for (i = ftable->mask, bucket = NodeBuckets(ftable);
+	 i >= 0;
+	 i--, bucket++) {
+	for (fentry = *bucket; fentry; ) {
+	    q = fentry->name;
+	    prev = &NodeHash(ttable, q);
+	    tentry = *prev;
+	    while (tentry && tentry->name != q)
+		tentry = *(prev = &tentry->next);
+	    /* note: test intentionally uses fentry->name instead of q */
+	    /* permits serendipitous inserts */
+	    while (tentry && tentry->name == fentry->name) {
+		/* if tentry is earlier, skip it */
+		if ((fentry->leaf && !tentry->leaf) ||
+		    (!fentry->tight && tentry->tight &&
+		     (fentry->leaf || !tentry->leaf))) {
+		    tentry = *(prev = &tentry->next);
+		    continue;
+		}
+		nfentry = fentry->next;
+		if (fentry->leaf != tentry->leaf ||
+		    fentry->tight != tentry->tight) {
+		    /* no match, just chain in */
+		    *prev = fentry;
+		    *(prev = &fentry->next) = tentry;
+		    ttable->entries++;
+		} else {
+		    if (fentry->leaf)
+			MergeValues((LTable)fentry, prev, override);
+		    else
+			MergeTables(fentry, prev, override);
+		    /* bump to next tentry */
+		    tentry = *(prev = &(*prev)->next);
+		}
+		/* bump to next fentry */
+		fentry = nfentry;
+		if (!fentry)
+		    break;
+	    }
+	    /* at this point, tentry cannot match any fentry named q */
+	    /* chain in all bindings together, preserve invariant order */
+	    while (fentry && fentry->name == q) {
+		*prev = fentry;
+		prev = &fentry->next;
+		fentry = *prev;
+		*prev = tentry;
+		ttable->entries++;
+	    }
+	}
+    }
+    Xfree((char *)ftable);
+    /* resize if necessary, now that we're all done */
+    GROW(pprev);
+}
+
+void XrmCombineDatabase(
+    XrmDatabase	from, XrmDatabase *into,
+    Bool override)
+{
+    register NTable *prev;
+    register NTable ftable, ttable, nftable;
+
+    if (!*into) {
+	*into = from;
+    } else if (from) {
+	_XLockMutex(&from->linfo);
+	_XLockMutex(&(*into)->linfo);
+	if ((ftable = from->table)) {
+	    prev = &(*into)->table;
+	    ttable = *prev;
+	    if (!ftable->leaf) {
+		nftable = ftable->next;
+		if (ttable && !ttable->leaf) {
+		    /* both have node tables, merge them */
+		    MergeTables(ftable, prev, override);
+		    /* bump to into's leaf table, if any */
+		    ttable = *(prev = &(*prev)->next);
+		} else {
+		    /* into has no node table, link from's in */
+		    *prev = ftable;
+		    *(prev = &ftable->next) = ttable;
+		}
+		/* bump to from's leaf table, if any */
+		ftable = nftable;
+	    } else {
+		/* bump to into's leaf table, if any */
+		if (ttable && !ttable->leaf)
+		    ttable = *(prev = &ttable->next);
+	    }
+	    if (ftable) {
+		/* if into has a leaf, merge, else insert */
+		if (ttable)
+		    MergeValues((LTable)ftable, prev, override);
+		else
+		    *prev = ftable;
+	    }
+	}
+	(from->methods->destroy)(from->mbstate);
+	_XUnlockMutex(&from->linfo);
+	_XFreeMutex(&from->linfo);
+	Xfree((char *)from);
+	_XUnlockMutex(&(*into)->linfo);
+    }
+}
+
+void XrmMergeDatabases(
+    XrmDatabase	from, XrmDatabase *into)
+{
+    XrmCombineDatabase(from, into, True);
+}
+
+/* store a value in the database, overriding any existing entry */
+static void PutEntry(
+    XrmDatabase		db,
+    XrmBindingList	bindings,
+    XrmQuarkList	quarks,
+    XrmRepresentation	type,
+    XrmValuePtr		value)
+{
+    register NTable *pprev, *prev;
+    register NTable table;
+    register XrmQuark q;
+    register VEntry *vprev;
+    register VEntry entry;
+    NTable *nprev, *firstpprev;
+
+#define NEWTABLE(q,i) \
+    table = (NTable)Xmalloc(sizeof(LTableRec)); \
+    if (!table) \
+	return; \
+    table->name = q; \
+    table->hasloose = 0; \
+    table->hasany = 0; \
+    table->mask = 0; \
+    table->entries = 0; \
+    if (quarks[i]) { \
+	table->leaf = 0; \
+	nprev = NodeBuckets(table); \
+    } else { \
+	table->leaf = 1; \
+	if (!(nprev = (NTable *)Xmalloc(sizeof(VEntry *)))) {\
+	    Xfree(table); \
+	    return; \
+        } \
+	((LTable)table)->buckets = (VEntry *)nprev; \
+    } \
+    *nprev = (NTable)NULL; \
+    table->next = *prev; \
+    *prev = table
+
+    if (!db || !*quarks)
+	return;
+    table = *(prev = &db->table);
+    /* if already at leaf, bump to the leaf table */
+    if (!quarks[1] && table && !table->leaf)
+	table = *(prev = &table->next);
+    pprev = prev;
+    if (!table || (quarks[1] && table->leaf)) {
+	/* no top-level node table, create one and chain it in */
+	NEWTABLE(NULLQUARK,1);
+	table->tight = 1; /* arbitrary */
+	prev = nprev;
+    } else {
+	/* search along until we need a value */
+	while (quarks[1]) {
+	    q = *quarks;
+	    table = *(prev = &NodeHash(table, q));
+	    while (table && table->name != q)
+		table = *(prev = &table->next);
+	    if (!table)
+		break; /* not found */
+	    if (quarks[2]) {
+		if (table->leaf)
+		    break; /* not found */
+	    } else {
+		if (!table->leaf) {
+		    /* bump to leaf table, if any */
+		    table = *(prev = &table->next);
+		    if (!table || table->name != q)
+			break; /* not found */
+		    if (!table->leaf) {
+			/* bump to leaf table, if any */
+			table = *(prev = &table->next);
+			if (!table || table->name != q)
+			    break; /* not found */
+		    }
+		}
+	    }
+	    if (*bindings == XrmBindTightly) {
+		if (!table->tight)
+		    break; /* not found */
+	    } else {
+		if (table->tight) {
+		    /* bump to loose table, if any */
+		    table = *(prev = &table->next);
+		    if (!table || table->name != q ||
+			!quarks[2] != table->leaf)
+			break; /* not found */
+		}
+	    }
+	    /* found that one, bump to next quark */
+	    pprev = prev;
+	    quarks++;
+	    bindings++;
+	}
+	if (!quarks[1]) {
+	    /* found all the way to a leaf */
+	    q = *quarks;
+	    entry = *(vprev = &LeafHash((LTable)table, q));
+	    while (entry && entry->name != q)
+		entry = *(vprev = &entry->next);
+	    /* if want loose and have tight, bump to next entry */
+	    if (entry && *bindings == XrmBindLoosely && entry->tight)
+		entry = *(vprev = &entry->next);
+	    if (entry && entry->name == q &&
+		(*bindings == XrmBindTightly) == entry->tight) {
+		/* match, need to override */
+		if ((type == XrmQString) == entry->string &&
+		    entry->size == value->size) {
+		    /* update type if not String, can be different */
+		    if (!entry->string)
+			RepType(entry) = type;
+		    /* identical size, just overwrite value */
+		    memcpy(RawValue(entry), (char *)value->addr, value->size);
+		    return;
+		}
+		/* splice out and free old entry */
+		*vprev = entry->next;
+		Xfree((char *)entry);
+		(*pprev)->entries--;
+	    }
+	    /* this is where to insert */
+	    prev = (NTable *)vprev;
+	}
+    }
+    /* keep the top table, because we may have to grow it */
+    firstpprev = pprev;
+    /* iterate until we get to the leaf */
+    while (quarks[1]) {
+	/* build a new table and chain it in */
+	NEWTABLE(*quarks,2);
+	if (*quarks++ == XrmQANY)
+	    (*pprev)->hasany = 1;
+	if (*bindings++ == XrmBindTightly) {
+	    table->tight = 1;
+	} else {
+	    table->tight = 0;
+	    (*pprev)->hasloose = 1;
+	}
+	(*pprev)->entries++;
+	pprev = prev;
+	prev = nprev;
+    }
+    /* now allocate the value entry */
+    entry = (VEntry)Xmalloc(((type == XrmQString) ?
+			     sizeof(VEntryRec) : sizeof(DEntryRec)) +
+			    value->size);
+    if (!entry)
+	return;
+    entry->name = q = *quarks;
+    if (*bindings == XrmBindTightly) {
+	entry->tight = 1;
+    } else {
+	entry->tight = 0;
+	(*pprev)->hasloose = 1;
+    }
+    /* chain it in, with a bit of type cast ugliness */
+    entry->next = *((VEntry *)prev);
+    *((VEntry *)prev) = entry;
+    entry->size = value->size;
+    if (type == XrmQString) {
+	entry->string = 1;
+    } else {
+	entry->string = 0;
+	RepType(entry) = type;
+    }
+    /* save a copy of the value */
+    memcpy(RawValue(entry), (char *)value->addr, value->size);
+    (*pprev)->entries++;
+    /* this is a new leaf, need to remember it for search lists */
+    if (q > maxResourceQuark) {
+	unsigned oldsize = (maxResourceQuark + 1) >> 3;
+	unsigned size = ((q | 0x7f) + 1) >> 3; /* reallocate in chunks */
+	if (resourceQuarks) {
+	    unsigned char *prevQuarks = resourceQuarks;
+
+	    resourceQuarks = (unsigned char *)Xrealloc((char *)resourceQuarks,
+						       size);
+	    if (!resourceQuarks) {
+		Xfree(prevQuarks);
+	    }
+	} else
+	    resourceQuarks = (unsigned char *)Xmalloc(size);
+	if (resourceQuarks) {
+	    bzero((char *)&resourceQuarks[oldsize], size - oldsize);
+	    maxResourceQuark = (size << 3) - 1;
+	} else {
+	    maxResourceQuark = -1;
+	}
+    }
+    if (q > 0 && resourceQuarks)
+	resourceQuarks[q >> 3] |= 1 << (q & 0x7);
+    GROW(firstpprev);
+
+#undef NEWTABLE
+}
+
+void XrmQPutResource(
+    XrmDatabase		*pdb,
+    XrmBindingList      bindings,
+    XrmQuarkList	quarks,
+    XrmRepresentation	type,
+    XrmValuePtr		value)
+{
+    if (!*pdb) *pdb = NewDatabase();
+    _XLockMutex(&(*pdb)->linfo);
+    PutEntry(*pdb, bindings, quarks, type, value);
+    _XUnlockMutex(&(*pdb)->linfo);
+}
+
+void
+XrmPutResource(
+    XrmDatabase     *pdb,
+    _Xconst char    *specifier,
+    _Xconst char    *type,
+    XrmValuePtr	    value)
+{
+    XrmBinding	    bindings[MAXDBDEPTH+1];
+    XrmQuark	    quarks[MAXDBDEPTH+1];
+
+    if (!*pdb) *pdb = NewDatabase();
+    _XLockMutex(&(*pdb)->linfo);
+    XrmStringToBindingQuarkList(specifier, bindings, quarks);
+    PutEntry(*pdb, bindings, quarks, XrmStringToQuark(type), value);
+    _XUnlockMutex(&(*pdb)->linfo);
+}
+
+void
+XrmQPutStringResource(
+    XrmDatabase     *pdb,
+    XrmBindingList  bindings,
+    XrmQuarkList    quarks,
+    _Xconst char    *str)
+{
+    XrmValue	value;
+
+    if (!*pdb) *pdb = NewDatabase();
+    value.addr = (XPointer) str;
+    value.size = strlen(str)+1;
+    _XLockMutex(&(*pdb)->linfo);
+    PutEntry(*pdb, bindings, quarks, XrmQString, &value);
+    _XUnlockMutex(&(*pdb)->linfo);
+}
+
+/*	Function Name: GetDatabase
+ *	Description: Parses a string and stores it as a database.
+ *	Arguments: db - the database.
+ *                 str - a pointer to the string containing the database.
+ *                 filename - source filename, if any.
+ *                 doall - whether to do all lines or just one
+ */
+
+/*
+ * This function is highly optimized to inline as much as possible.
+ * Be very careful with modifications, or simplifications, as they
+ * may adversely affect the performance.
+ *
+ * Chris Peterson, MIT X Consortium		5/17/90.
+ */
+
+/*
+ * Xlib spec says max 100 quarks in a lookup, will stop and return if
+ * return if any single production's lhs has more than 100 components.
+ */
+#define QLIST_SIZE 100
+
+/*
+ * This should be big enough to handle things like the XKeysymDB or biggish
+ * ~/.Xdefaults or app-defaults files. Anything bigger will be allocated on
+ * the heap.
+ */
+#define DEF_BUFF_SIZE 8192
+
+static void GetIncludeFile(
+    XrmDatabase db,
+    _Xconst char *base,
+    _Xconst char *fname,
+    int fnamelen);
+
+static void GetDatabase(
+    XrmDatabase db,
+    _Xconst register char *str,
+    _Xconst char *filename,
+    Bool doall)
+{
+    char *rhs;
+    char *lhs, lhs_s[DEF_BUFF_SIZE];
+    XrmQuark quarks[QLIST_SIZE + 1];	/* allow for a terminal NullQuark */
+    XrmBinding bindings[QLIST_SIZE + 1];
+
+    register char *ptr;
+    register XrmBits bits = 0;
+    register char c;
+    register Signature sig;
+    register char *ptr_max;
+    register int num_quarks;
+    register XrmBindingList t_bindings;
+
+    int len, alloc_chars;
+    unsigned long str_len;
+    XrmValue value;
+    Bool only_pcs;
+    Bool dolines;
+
+    if (!db)
+	return;
+
+    /*
+     * if strlen (str) < DEF_BUFF_SIZE allocate buffers on the stack for
+     * speed otherwise malloc the buffer. From a buffer overflow standpoint
+     * we can be sure that neither: a) a component on the lhs, or b) a
+     * value on the rhs, will be longer than the overall length of str,
+     * i.e. strlen(str).
+     *
+     * This should give good performance when parsing "*foo: bar" type
+     * databases as might be passed with -xrm command line options; but
+     * with larger databases, e.g. .Xdefaults, app-defaults, or KeysymDB
+     * files, the size of the buffers will be overly large. One way
+     * around this would be to double-parse each production with a resulting
+     * performance hit. In any event we can be assured that a lhs component
+     * name or a rhs value won't be longer than str itself.
+     */
+
+    str_len = strlen (str);
+    if (DEF_BUFF_SIZE > str_len) lhs = lhs_s;
+    else if ((lhs = (char*) Xmalloc (str_len)) == NULL)
+	return;
+
+    alloc_chars = DEF_BUFF_SIZE < str_len ? str_len : DEF_BUFF_SIZE;
+    if ((rhs = (char*) Xmalloc (alloc_chars)) == NULL) {
+	if (lhs != lhs_s) Xfree (lhs);
+	return;
+    }
+
+    (*db->methods->mbinit)(db->mbstate);
+    str--;
+    dolines = True;
+    while (!is_EOF(bits) && dolines) {
+	dolines = doall;
+
+	/*
+	 * First: Remove extra whitespace.
+	 */
+
+	do {
+	    bits = next_char(c, str);
+	} while is_space(bits);
+
+	/*
+	 * Ignore empty lines.
+	 */
+
+	if (is_EOL(bits))
+	    continue;		/* start a new line. */
+
+	/*
+	 * Second: check the first character in a line to see if it is
+	 * "!" signifying a comment, or "#" signifying a directive.
+	 */
+
+	if (c == '!') { /* Comment, spin to next newline */
+	    while (is_simple(bits = next_char(c, str))) {}
+	    if (is_EOL(bits))
+		continue;
+	    while (!is_EOL(bits = next_mbchar(c, len, str))) {}
+	    str--;
+	    continue;		/* start a new line. */
+	}
+
+	if (c == '#') { /* Directive */
+	    /* remove extra whitespace */
+	    only_pcs = True;
+	    while (is_space(bits = next_char(c, str))) {};
+	    /* only "include" directive is currently defined */
+	    if (!strncmp(str, "include", 7)) {
+		str += (7-1);
+		/* remove extra whitespace */
+		while (is_space(bits = next_char(c, str))) {};
+		/* must have a starting " */
+		if (c == '"') {
+		    _Xconst char *fname = str+1;
+		    len = 0;
+		    do {
+			if (only_pcs) {
+			    bits = next_char(c, str);
+			    if (is_nonpcs(bits))
+				only_pcs = False;
+			}
+			if (!only_pcs)
+			    bits = next_mbchar(c, len, str);
+		    } while (c != '"' && !is_EOL(bits));
+		    /* must have an ending " */
+		    if (c == '"')
+			GetIncludeFile(db, filename, fname, str - len - fname);
+		}
+	    }
+	    /* spin to next newline */
+	    if (only_pcs) {
+		while (is_simple(bits))
+		    bits = next_char(c, str);
+		if (is_EOL(bits))
+		    continue;
+	    }
+	    while (!is_EOL(bits))
+		bits = next_mbchar(c, len, str);
+	    str--;
+	    continue;		/* start a new line. */
+	}
+
+	/*
+	 * Third: loop through the LHS of the resource specification
+	 * storing characters and converting this to a Quark.
+	 */
+
+	num_quarks = 0;
+	t_bindings = bindings;
+
+	sig = 0;
+	ptr = lhs;
+	*t_bindings = XrmBindTightly;
+	for(;;) {
+	    if (!is_binding(bits)) {
+		while (!is_EOQ(bits)) {
+		    *ptr++ = c;
+		    sig = (sig << 1) + c; /* Compute the signature. */
+		    bits = next_char(c, str);
+		}
+
+		quarks[num_quarks++] =
+			_XrmInternalStringToQuark(lhs, ptr - lhs, sig, False);
+
+		if (num_quarks > QLIST_SIZE) {
+		    Xfree(rhs);
+		    if (lhs != lhs_s) Xfree (lhs);
+		    (*db->methods->mbfinish)(db->mbstate);
+		    return;
+		}
+
+		if (is_separator(bits))  {
+		    if (!is_space(bits))
+			break;
+
+		    /* Remove white space */
+		    do {
+			*ptr++ = c;
+			sig = (sig << 1) + c; /* Compute the signature. */
+		    } while (is_space(bits = next_char(c, str)));
+
+		    /*
+		     * The spec doesn't permit it, but support spaces
+		     * internal to resource name/class
+		     */
+
+		    if (is_separator(bits))
+			break;
+		    num_quarks--;
+		    continue;
+		}
+
+		if (c == '.')
+		    *(++t_bindings) = XrmBindTightly;
+		else
+		    *(++t_bindings) = XrmBindLoosely;
+
+		sig = 0;
+		ptr = lhs;
+	    }
+	    else {
+		/*
+		 * Magic unspecified feature #254.
+		 *
+		 * If two separators appear with no Text between them then
+		 * ignore them.
+		 *
+		 * If anyone of those separators is a '*' then the binding
+		 * will be loose, otherwise it will be tight.
+		 */
+
+		if (c == '*')
+		    *t_bindings = XrmBindLoosely;
+	    }
+
+	    bits = next_char(c, str);
+	}
+
+	quarks[num_quarks] = NULLQUARK;
+
+	/*
+	 * Make sure that there is a ':' in this line.
+	 */
+
+	if (c != ':') {
+	    char oldc;
+
+	    /*
+	     * A parsing error has occured, toss everything on the line
+	     * a new_line can still be escaped with a '\'.
+	     */
+
+	    while (is_normal(bits))
+		bits = next_char(c, str);
+	    if (is_EOL(bits))
+		continue;
+	    bits = next_mbchar(c, len, str);
+	    do {
+		oldc = c;
+		bits = next_mbchar(c, len, str);
+	    } while (c && (c != '\n' || oldc == '\\'));
+	    str--;
+	    continue;
+	}
+
+	/*
+	 * I now have a quark and binding list for the entire left hand
+	 * side.  "c" currently points to the ":" separating the left hand
+	 * side for the right hand side.  It is time to begin processing
+	 * the right hand side.
+	 */
+
+	/*
+	 * Fourth: Remove more whitespace
+	 */
+
+	for(;;) {
+	    if (is_space(bits = next_char(c, str)))
+		continue;
+	    if (c != '\\')
+		break;
+	    bits = next_char(c, str);
+	    if (c == '\n')
+		continue;
+	    str--;
+	    bits = BSLASH;
+	    c = '\\';
+	    break;
+	}
+
+	/*
+	 * Fifth: Process the right hand side.
+	 */
+
+	ptr = rhs;
+	ptr_max = ptr + alloc_chars - 4;
+	only_pcs = True;
+	len = 1;
+
+	for(;;) {
+
+	    /*
+	     * Tight loop for the normal case:  Non backslash, non-end of value
+	     * character that will fit into the allocated buffer.
+	     */
+
+	    if (only_pcs) {
+		while (is_normal(bits) && ptr < ptr_max) {
+		    *ptr++ = c;
+		    bits = next_char(c, str);
+		}
+		if (is_EOL(bits))
+		    break;
+		if (is_nonpcs(bits)) {
+		    only_pcs = False;
+		    bits = next_mbchar(c, len, str);
+		}
+	    }
+	    while (!is_special(bits) && ptr + len <= ptr_max) {
+		len = -len;
+		while (len)
+		    *ptr++ = str[len++];
+		if (*str == '\0') {
+		    bits = EOS;
+		    break;
+		}
+		bits = next_mbchar(c, len, str);
+	    }
+
+	    if (is_EOL(bits)) {
+		str--;
+		break;
+	    }
+
+	    if (c == '\\') {
+		/*
+		 * We need to do some magic after a backslash.
+		 */
+		Bool read_next = True;
+
+		if (only_pcs) {
+		    bits = next_char(c, str);
+		    if (is_nonpcs(bits))
+			only_pcs = False;
+		}
+		if (!only_pcs)
+		    bits = next_mbchar(c, len, str);
+
+		if (is_EOL(bits)) {
+		    if (is_EOF(bits))
+			continue;
+		} else if (c == 'n') {
+		    /*
+		     * "\n" means insert a newline.
+		     */
+		    *ptr++ = '\n';
+		} else if (c == '\\') {
+		    /*
+		     * "\\" completes to just one backslash.
+		     */
+		    *ptr++ = '\\';
+		} else {
+		    /*
+		     * pick up to three octal digits after the '\'.
+		     */
+		    char temp[3];
+		    int count = 0;
+		    while (is_odigit(bits) && count < 3) {
+			temp[count++] = c;
+			if (only_pcs) {
+			    bits = next_char(c, str);
+			    if (is_nonpcs(bits))
+				only_pcs = False;
+			}
+			if (!only_pcs)
+			    bits = next_mbchar(c, len, str);
+		    }
+
+		    /*
+		     * If we found three digits then insert that octal code
+		     * into the value string as a character.
+		     */
+
+		    if (count == 3) {
+			*ptr++ = (unsigned char) ((temp[0] - '0') * 0100 +
+						  (temp[1] - '0') * 010 +
+						  (temp[2] - '0'));
+		    }
+		    else {
+			int tcount;
+
+			/*
+			 * Otherwise just insert those characters into the
+			 * string, since no special processing is needed on
+			 * numerics we can skip the special processing.
+			 */
+
+			for (tcount = 0; tcount < count; tcount++) {
+			    *ptr++ = temp[tcount]; /* print them in
+						      the correct order */
+			}
+		    }
+		    read_next = False;
+		}
+		if (read_next) {
+		    if (only_pcs) {
+			bits = next_char(c, str);
+			if (is_nonpcs(bits))
+			    only_pcs = False;
+		    }
+		    if (!only_pcs)
+			bits = next_mbchar(c, len, str);
+		}
+	    }
+
+	    /*
+	     * It is important to make sure that there is room for at least
+	     * four more characters in the buffer, since I can add that
+	     * many characters into the buffer after a backslash has occured.
+	     */
+
+	    if (ptr + len > ptr_max) {
+		char * temp_str;
+
+		alloc_chars += BUFSIZ/10;
+		temp_str = Xrealloc(rhs, sizeof(char) * alloc_chars);
+
+		if (!temp_str) {
+		    Xfree(rhs);
+		    if (lhs != lhs_s) Xfree (lhs);
+		    (*db->methods->mbfinish)(db->mbstate);
+		    return;
+		}
+
+		ptr = temp_str + (ptr - rhs); /* reset pointer. */
+		rhs = temp_str;
+		ptr_max = rhs + alloc_chars - 4;
+	    }
+	}
+
+	/*
+	 * Lastly: Terminate the value string, and store this entry
+	 * 	   into the database.
+	 */
+
+	*ptr++ = '\0';
+
+	/* Store it in database */
+	value.size = ptr - rhs;
+	value.addr = (XPointer) rhs;
+
+	PutEntry(db, bindings, quarks, XrmQString, &value);
+    }
+
+    if (lhs != lhs_s) Xfree (lhs);
+    Xfree (rhs);
+
+    (*db->methods->mbfinish)(db->mbstate);
+}
+
+void
+XrmPutStringResource(
+    XrmDatabase *pdb,
+    _Xconst char*specifier,
+    _Xconst char*str)
+{
+    XrmValue	value;
+    XrmBinding	bindings[MAXDBDEPTH+1];
+    XrmQuark	quarks[MAXDBDEPTH+1];
+
+    if (!*pdb) *pdb = NewDatabase();
+    XrmStringToBindingQuarkList(specifier, bindings, quarks);
+    value.addr = (XPointer) str;
+    value.size = strlen(str)+1;
+    _XLockMutex(&(*pdb)->linfo);
+    PutEntry(*pdb, bindings, quarks, XrmQString, &value);
+    _XUnlockMutex(&(*pdb)->linfo);
+}
+
+
+void
+XrmPutLineResource(
+    XrmDatabase *pdb,
+    _Xconst char*line)
+{
+    if (!*pdb) *pdb = NewDatabase();
+    _XLockMutex(&(*pdb)->linfo);
+    GetDatabase(*pdb, line, (char *)NULL, False);
+    _XUnlockMutex(&(*pdb)->linfo);
+}
+
+XrmDatabase
+XrmGetStringDatabase(
+    _Xconst char    *data)
+{
+    XrmDatabase     db;
+
+    db = NewDatabase();
+    _XLockMutex(&db->linfo);
+    GetDatabase(db, data, (char *)NULL, True);
+    _XUnlockMutex(&db->linfo);
+    return db;
+}
+
+/*	Function Name: ReadInFile
+ *	Description: Reads the file into a buffer.
+ *	Arguments: filename - the name of the file.
+ *	Returns: An allocated string containing the contents of the file.
+ */
+
+static char *
+ReadInFile(_Xconst char *filename)
+{
+    register int fd, size;
+    char * filebuf;
+
+#ifdef __UNIXOS2__
+    filename = __XOS2RedirRoot(filename);
+#endif
+
+    /*
+     * MS-Windows and OS/2 note: Default open mode includes O_TEXT
+     */
+    if ( (fd = _XOpenFile (filename, O_RDONLY)) == -1 )
+	return (char *)NULL;
+
+    /*
+     * MS-Windows and OS/2 note: depending on how the sources are
+     * untarred, the newlines in resource files may or may not have
+     * been expanded to CRLF. Either way the size returned by fstat
+     * is sufficient to read the file into because in text-mode any
+     * CRLFs in a file will be converted to newlines (LF) with the
+     * result that the number of bytes actually read with be <=
+     * to the size returned by fstat.
+     */
+    {
+	struct stat status_buffer;
+	if ( (fstat(fd, &status_buffer)) == -1 ) {
+	    close (fd);
+	    return (char *)NULL;
+	} else
+	    size = status_buffer.st_size;
+    }
+
+    if (!(filebuf = Xmalloc(size + 1))) { /* leave room for '\0' */
+	close(fd);
+	return (char *)NULL;
+    }
+    size = read (fd, filebuf, size);
+
+#ifdef __UNIXOS2__
+    { /* kill CRLF */
+      int i,k;
+      for (i=k=0; i<size; i++)
+	if (filebuf[i] != 0x0d) {
+	   filebuf[k++] = filebuf[i];
+	}
+	filebuf[k] = 0;
+    }
+#endif
+
+    if (size < 0) {
+	close (fd);
+	Xfree(filebuf);
+	return (char *)NULL;
+    }
+    close (fd);
+
+    filebuf[size] = '\0';	/* NULL terminate it. */
+    return filebuf;
+}
+
+static void
+GetIncludeFile(
+    XrmDatabase db,
+    _Xconst char *base,
+    _Xconst char *fname,
+    int fnamelen)
+{
+    int len;
+    char *str;
+    char realfname[BUFSIZ];
+
+    if (fnamelen <= 0 || fnamelen >= BUFSIZ)
+	return;
+    if (*fname != '/' && base && (str = strrchr(base, '/'))) {
+	len = str - base + 1;
+	if (len + fnamelen >= BUFSIZ)
+	    return;
+	strncpy(realfname, base, len);
+	strncpy(realfname + len, fname, fnamelen);
+	realfname[len + fnamelen] = '\0';
+    } else {
+	strncpy(realfname, fname, fnamelen);
+	realfname[fnamelen] = '\0';
+    }
+    if (!(str = ReadInFile(realfname)))
+	return;
+    GetDatabase(db, str, realfname, True);
+    Xfree(str);
+}
+
+XrmDatabase
+XrmGetFileDatabase(
+    _Xconst char    *filename)
+{
+    XrmDatabase db;
+    char *str;
+
+    if (!(str = ReadInFile(filename)))
+	return (XrmDatabase)NULL;
+
+    db = NewDatabase();
+    _XLockMutex(&db->linfo);
+    GetDatabase(db, str, filename, True);
+    _XUnlockMutex(&db->linfo);
+    Xfree(str);
+    return db;
+}
+
+Status
+XrmCombineFileDatabase(
+    _Xconst char    *filename,
+    XrmDatabase     *target,
+    Bool             override)
+{
+    XrmDatabase db;
+    char *str;
+
+    if (!(str = ReadInFile(filename)))
+	return 0;
+    if (override) {
+	db = *target;
+	if (!db)
+	    *target = db = NewDatabase();
+    } else
+	db = NewDatabase();
+    _XLockMutex(&db->linfo);
+    GetDatabase(db, str, filename, True);
+    _XUnlockMutex(&db->linfo);
+    Xfree(str);
+    if (!override)
+	XrmCombineDatabase(db, target, False);
+    return 1;
+}
+
+/* call the user proc for every value in the table, arbitrary order.
+ * stop if user proc returns True.  level is current depth in database.
+ */
+/*ARGSUSED*/
+static Bool EnumLTable(
+    LTable		table,
+    XrmNameList		names,
+    XrmClassList 	classes,
+    register int	level,
+    register EClosure	closure)
+{
+    register VEntry *bucket;
+    register int i;
+    register VEntry entry;
+    XrmValue value;
+    XrmRepresentation type;
+    Bool tightOk;
+
+    closure->bindings[level] = (table->table.tight ?
+				XrmBindTightly : XrmBindLoosely);
+    closure->quarks[level] = table->table.name;
+    level++;
+    tightOk = !*names;
+    closure->quarks[level + 1] = NULLQUARK;
+    for (i = table->table.mask, bucket = table->buckets;
+	 i >= 0;
+	 i--, bucket++) {
+	for (entry = *bucket; entry; entry = entry->next) {
+	    if (entry->tight && !tightOk)
+		continue;
+	    closure->bindings[level] = (entry->tight ?
+					XrmBindTightly : XrmBindLoosely);
+	    closure->quarks[level] = entry->name;
+	    value.size = entry->size;
+	    if (entry->string) {
+		type = XrmQString;
+		value.addr = StringValue(entry);
+	    } else {
+		type = RepType(entry);
+		value.addr = DataValue(entry);
+	    }
+	    if ((*closure->proc)(&closure->db, closure->bindings+1,
+				 closure->quarks+1, &type, &value,
+				 closure->closure))
+		return True;
+	}
+    }
+    return False;
+}
+
+static Bool EnumAllNTable(
+    NTable		table,
+    register int	level,
+    register EClosure	closure)
+{
+    register NTable *bucket;
+    register int i;
+    register NTable entry;
+    XrmQuark empty = NULLQUARK;
+
+    if (level >= MAXDBDEPTH)
+	return False;
+    for (i = table->mask, bucket = NodeBuckets(table);
+	 i >= 0;
+	 i--, bucket++) {
+	for (entry = *bucket; entry; entry = entry->next) {
+	    if (entry->leaf) {
+		if (EnumLTable((LTable)entry, &empty, &empty, level, closure))
+		    return True;
+	    } else {
+		closure->bindings[level] = (entry->tight ?
+					    XrmBindTightly : XrmBindLoosely);
+		closure->quarks[level] = entry->name;
+		if (EnumAllNTable(entry, level+1, closure))
+		    return True;
+	    }
+	}
+    }
+    return False;
+}
+
+/* recurse on every table in the table, arbitrary order.
+ * stop if user proc returns True.  level is current depth in database.
+ */
+static Bool EnumNTable(
+    NTable		table,
+    XrmNameList		names,
+    XrmClassList 	classes,
+    register int	level,
+    register EClosure	closure)
+{
+    register NTable	entry;
+    register XrmQuark	q;
+    register unsigned int leaf;
+    Bool (*get)(
+            NTable		table,
+            XrmNameList		names,
+            XrmClassList 	classes,
+            register int	level,
+            EClosure		closure);
+    Bool bilevel;
+
+/* find entries named ename, leafness leaf, tight or loose, and call get */
+#define ITIGHTLOOSE(ename) \
+    NFIND(ename); \
+    if (entry) { \
+	if (leaf == entry->leaf) { \
+	    if (!leaf && !entry->tight && entry->next && \
+		entry->next->name == q && entry->next->tight && \
+		(bilevel || entry->next->hasloose) && \
+		EnumLTable((LTable)entry->next, names+1, classes+1, \
+			   level, closure)) \
+		return True; \
+	    if ((*get)(entry, names+1, classes+1, level, closure)) \
+		return True; \
+	    if (entry->tight && (entry = entry->next) && \
+		entry->name == q && leaf == entry->leaf && \
+		(*get)(entry, names+1, classes+1, level, closure)) \
+		return True; \
+	} else if (entry->leaf) { \
+	    if ((bilevel || entry->hasloose) && \
+		EnumLTable((LTable)entry, names+1, classes+1, level, closure))\
+		return True; \
+	    if (entry->tight && (entry = entry->next) && \
+		entry->name == q && (bilevel || entry->hasloose) && \
+		EnumLTable((LTable)entry, names+1, classes+1, level, closure))\
+		return True; \
+	} \
+    }
+
+/* find entries named ename, leafness leaf, loose only, and call get */
+#define ILOOSE(ename) \
+    NFIND(ename); \
+    if (entry && entry->tight && (entry = entry->next) && entry->name != q) \
+	entry = (NTable)NULL; \
+    if (entry) { \
+	if (leaf == entry->leaf) { \
+	    if ((*get)(entry, names+1, classes+1, level, closure)) \
+		return True; \
+	} else if (entry->leaf && (bilevel || entry->hasloose)) { \
+	    if (EnumLTable((LTable)entry, names+1, classes+1, level, closure))\
+		return True; \
+	} \
+    }
+
+    if (level >= MAXDBDEPTH)
+	return False;
+    closure->bindings[level] = (table->tight ?
+				XrmBindTightly : XrmBindLoosely);
+    closure->quarks[level] = table->name;
+    level++;
+    if (!*names) {
+	if (EnumAllNTable(table, level, closure))
+	    return True;
+    } else {
+	if (names[1] || closure->mode == XrmEnumAllLevels) {
+	    get = EnumNTable; /* recurse */
+	    leaf = 0;
+	    bilevel = !names[1];
+	} else {
+	    get = (getNTableEProcp)EnumLTable; /* bottom of recursion */
+	    leaf = 1;
+	    bilevel = False;
+	}
+	if (table->hasloose && closure->mode == XrmEnumAllLevels) {
+	    NTable *bucket;
+	    int i;
+	    XrmQuark empty = NULLQUARK;
+
+	    for (i = table->mask, bucket = NodeBuckets(table);
+		 i >= 0;
+		 i--, bucket++) {
+		q = NULLQUARK;
+		for (entry = *bucket; entry; entry = entry->next) {
+		    if (!entry->tight && entry->name != q &&
+			entry->name != *names && entry->name != *classes) {
+			q = entry->name;
+			if (entry->leaf) {
+			    if (EnumLTable((LTable)entry, &empty, &empty,
+					   level, closure))
+				return True;
+			} else {
+			    if (EnumNTable(entry, &empty, &empty,
+					   level, closure))
+				return True;
+			}
+		    }
+		}
+	    }
+	}
+
+	ITIGHTLOOSE(*names);   /* do name, tight and loose */
+	ITIGHTLOOSE(*classes); /* do class, tight and loose */
+	if (table->hasany) {
+	    ITIGHTLOOSE(XrmQANY); /* do ANY, tight and loose */
+	}
+	if (table->hasloose) {
+	    while (1) {
+		names++;
+		classes++;
+		if (!*names)
+		    break;
+		if (!names[1] && closure->mode != XrmEnumAllLevels) {
+		    get = (getNTableEProcp)EnumLTable; /* bottom of recursion */
+		    leaf = 1;
+		}
+		ILOOSE(*names);   /* loose names */
+		ILOOSE(*classes); /* loose classes */
+		if (table->hasany) {
+		    ILOOSE(XrmQANY); /* loose ANY */
+		}
+	    }
+	    names--;
+	    classes--;
+	}
+    }
+    /* now look for matching leaf nodes */
+    entry = table->next;
+    if (!entry)
+	return False;
+    if (entry->leaf) {
+	if (entry->tight && !table->tight)
+	    entry = entry->next;
+    } else {
+	entry = entry->next;
+	if (!entry || !entry->tight)
+	    return False;
+    }
+    if (!entry || entry->name != table->name)
+	return False;
+    /* found one */
+    level--;
+    if ((!*names || entry->hasloose) &&
+	EnumLTable((LTable)entry, names, classes, level, closure))
+	return True;
+    if (entry->tight && entry == table->next && (entry = entry->next) &&
+	entry->name == table->name && (!*names || entry->hasloose))
+	return EnumLTable((LTable)entry, names, classes, level, closure);
+    return False;
+
+#undef ITIGHTLOOSE
+#undef ILOOSE
+}
+
+/* call the proc for every value in the database, arbitrary order.
+ * stop if the proc returns True.
+ */
+Bool XrmEnumerateDatabase(
+    XrmDatabase		db,
+    XrmNameList		names,
+    XrmClassList	classes,
+    int			mode,
+    DBEnumProc		proc,
+    XPointer		closure)
+{
+    XrmBinding  bindings[MAXDBDEPTH+2];
+    XrmQuark	quarks[MAXDBDEPTH+2];
+    register NTable table;
+    EClosureRec	eclosure;
+    Bool retval = False;
+
+    if (!db)
+	return False;
+    _XLockMutex(&db->linfo);
+    eclosure.db = db;
+    eclosure.proc = proc;
+    eclosure.closure = closure;
+    eclosure.bindings = bindings;
+    eclosure.quarks = quarks;
+    eclosure.mode = mode;
+    table = db->table;
+    if (table && !table->leaf && !*names && mode == XrmEnumOneLevel)
+	table = table->next;
+    if (table) {
+	if (!table->leaf)
+	    retval = EnumNTable(table, names, classes, 0, &eclosure);
+	else
+	    retval = EnumLTable((LTable)table, names, classes, 0, &eclosure);
+    }
+    _XUnlockMutex(&db->linfo);
+    return retval;
+}
+
+static void PrintBindingQuarkList(
+    XrmBindingList      bindings,
+    XrmQuarkList	quarks,
+    FILE		*stream)
+{
+    Bool	firstNameSeen;
+
+    for (firstNameSeen = False; *quarks; bindings++, quarks++) {
+	if (*bindings == XrmBindLoosely) {
+	    (void) fprintf(stream, "*");
+	} else if (firstNameSeen) {
+	    (void) fprintf(stream, ".");
+	}
+	firstNameSeen = True;
+	(void) fputs(XrmQuarkToString(*quarks), stream);
+    }
+}
+
+/* output out the entry in correct file syntax */
+/*ARGSUSED*/
+static Bool DumpEntry(
+    XrmDatabase		*db,
+    XrmBindingList      bindings,
+    XrmQuarkList	quarks,
+    XrmRepresentation   *type,
+    XrmValuePtr		value,
+    XPointer		data)
+{
+    FILE			*stream = (FILE *)data;
+    register unsigned int	i;
+    register char		*s;
+    register char		c;
+
+    if (*type != XrmQString)
+	(void) putc('!', stream);
+    PrintBindingQuarkList(bindings, quarks, stream);
+    s = value->addr;
+    i = value->size;
+    if (*type == XrmQString) {
+	(void) fputs(":\t", stream);
+	if (i)
+	    i--;
+    }
+    else
+	(void) fprintf(stream, "=%s:\t", XrmRepresentationToString(*type));
+    if (i && (*s == ' ' || *s == '\t'))
+	(void) putc('\\', stream); /* preserve leading whitespace */
+    while (i--) {
+	c = *s++;
+	if (c == '\n') {
+	    if (i)
+		(void) fputs("\\n\\\n", stream);
+	    else
+		(void) fputs("\\n", stream);
+	} else if (c == '\\')
+	    (void) fputs("\\\\", stream);
+	else if ((c < ' ' && c != '\t') ||
+		 ((unsigned char)c >= 0x7f && (unsigned char)c < 0xa0))
+	    (void) fprintf(stream, "\\%03o", (unsigned char)c);
+	else
+	    (void) putc(c, stream);
+    }
+    (void) putc('\n', stream);
+    return ferror(stream) != 0;
+}
+
+#ifdef DEBUG
+
+void PrintTable(
+    NTable table,
+    FILE *file)
+{
+    XrmBinding  bindings[MAXDBDEPTH+1];
+    XrmQuark	quarks[MAXDBDEPTH+1];
+    EClosureRec closure;
+    XrmQuark	empty = NULLQUARK;
+
+    closure.db = (XrmDatabase)NULL;
+    closure.proc = DumpEntry;
+    closure.closure = (XPointer)file;
+    closure.bindings = bindings;
+    closure.quarks = quarks;
+    closure.mode = XrmEnumAllLevels;
+    if (table->leaf)
+	EnumLTable((LTable)table, &empty, &empty, 0, &closure);
+    else
+	EnumNTable(table, &empty, &empty, 0, &closure);
+}
+
+#endif /* DEBUG */
+
+void
+XrmPutFileDatabase(
+    XrmDatabase db,
+    _Xconst char *fileName)
+{
+    FILE	*file;
+    XrmQuark empty = NULLQUARK;
+
+    if (!db) return;
+    if (!(file = fopen(fileName, "w"))) return;
+    if (XrmEnumerateDatabase(db, &empty, &empty, XrmEnumAllLevels,
+			     DumpEntry, (XPointer) file))
+	unlink((char *)fileName);
+    fclose(file);
+}
+
+/* macros used in get/search functions */
+
+/* find entries named ename, leafness leaf, tight or loose, and call get */
+#define GTIGHTLOOSE(ename,looseleaf) \
+    NFIND(ename); \
+    if (entry) { \
+	if (leaf == entry->leaf) { \
+	    if (!leaf && !entry->tight && entry->next && \
+		entry->next->name == q && entry->next->tight && \
+		entry->next->hasloose && \
+		looseleaf((LTable)entry->next, names+1, classes+1, closure)) \
+		return True; \
+	    if ((*get)(entry, names+1, classes+1, closure)) \
+		return True; \
+	    if (entry->tight && (entry = entry->next) && \
+		entry->name == q && leaf == entry->leaf && \
+		(*get)(entry, names+1, classes+1, closure)) \
+		return True; \
+	} else if (entry->leaf) { \
+	    if (entry->hasloose && \
+		looseleaf((LTable)entry, names+1, classes+1, closure)) \
+		return True; \
+	    if (entry->tight && (entry = entry->next) && \
+		entry->name == q && entry->hasloose && \
+		looseleaf((LTable)entry, names+1, classes+1, closure)) \
+		return True; \
+	} \
+    }
+
+/* find entries named ename, leafness leaf, loose only, and call get */
+#define GLOOSE(ename,looseleaf) \
+    NFIND(ename); \
+    if (entry && entry->tight && (entry = entry->next) && entry->name != q) \
+	entry = (NTable)NULL; \
+    if (entry) { \
+	if (leaf == entry->leaf) { \
+	    if ((*get)(entry, names+1, classes+1, closure)) \
+		return True; \
+	} else if (entry->leaf && entry->hasloose) { \
+	    if (looseleaf((LTable)entry, names+1, classes+1, closure)) \
+		return True; \
+	} \
+    }
+
+/* add tight/loose entry to the search list, return True if list is full */
+/*ARGSUSED*/
+static Bool AppendLEntry(
+    LTable		table,
+    XrmNameList		names,
+    XrmClassList 	classes,
+    register SClosure	closure)
+{
+    /* check for duplicate */
+    if (closure->idx >= 0 && closure->list[closure->idx] == table)
+	return False;
+    if (closure->idx == closure->limit)
+	return True;
+    /* append it */
+    closure->idx++;
+    closure->list[closure->idx] = table;
+    return False;
+}
+
+/* add loose entry to the search list, return True if list is full */
+/*ARGSUSED*/
+static Bool AppendLooseLEntry(
+    LTable		table,
+    XrmNameList		names,
+    XrmClassList 	classes,
+    register SClosure	closure)
+{
+    /* check for duplicate */
+    if (closure->idx >= 0 && closure->list[closure->idx] == table)
+	return False;
+    if (closure->idx >= closure->limit - 1)
+	return True;
+    /* append it */
+    closure->idx++;
+    closure->list[closure->idx] = LOOSESEARCH;
+    closure->idx++;
+    closure->list[closure->idx] = table;
+    return False;
+}
+
+/* search for a leaf table */
+static Bool SearchNEntry(
+    NTable		table,
+    XrmNameList		names,
+    XrmClassList 	classes,
+    SClosure		closure)
+{
+    register NTable	entry;
+    register XrmQuark	q;
+    register unsigned int leaf;
+    Bool		(*get)(
+            NTable		table,
+            XrmNameList		names,
+            XrmClassList 	classes,
+            SClosure		closure);
+
+    if (names[1]) {
+	get = SearchNEntry; /* recurse */
+	leaf = 0;
+    } else {
+	get = (getNTableSProcp)AppendLEntry; /* bottom of recursion */
+	leaf = 1;
+    }
+    GTIGHTLOOSE(*names, AppendLooseLEntry);   /* do name, tight and loose */
+    GTIGHTLOOSE(*classes, AppendLooseLEntry); /* do class, tight and loose */
+    if (table->hasany) {
+	GTIGHTLOOSE(XrmQANY, AppendLooseLEntry); /* do ANY, tight and loose */
+    }
+    if (table->hasloose) {
+	while (1) {
+	    names++;
+	    classes++;
+	    if (!*names)
+		break;
+	    if (!names[1]) {
+		get = (getNTableSProcp)AppendLEntry; /* bottom of recursion */
+		leaf = 1;
+	    }
+	    GLOOSE(*names, AppendLooseLEntry);   /* loose names */
+	    GLOOSE(*classes, AppendLooseLEntry); /* loose classes */
+	    if (table->hasany) {
+		GLOOSE(XrmQANY, AppendLooseLEntry); /* loose ANY */
+	    }
+	}
+    }
+    /* now look for matching leaf nodes */
+    entry = table->next;
+    if (!entry)
+	return False;
+    if (entry->leaf) {
+	if (entry->tight && !table->tight)
+	    entry = entry->next;
+    } else {
+	entry = entry->next;
+	if (!entry || !entry->tight)
+	    return False;
+    }
+    if (!entry || entry->name != table->name)
+	return False;
+    /* found one */
+    if (entry->hasloose &&
+	AppendLooseLEntry((LTable)entry, names, classes, closure))
+	return True;
+    if (entry->tight && entry == table->next && (entry = entry->next) &&
+	entry->name == table->name && entry->hasloose)
+	return AppendLooseLEntry((LTable)entry, names, classes, closure);
+    return False;
+}
+
+Bool XrmQGetSearchList(
+    XrmDatabase     db,
+    XrmNameList	    names,
+    XrmClassList    classes,
+    XrmSearchList   searchList,	/* RETURN */
+    int		    listLength)
+{
+    register NTable	table;
+    SClosureRec		closure;
+
+    if (listLength <= 0)
+	return False;
+    closure.list = (LTable *)searchList;
+    closure.idx = -1;
+    closure.limit = listLength - 2;
+    if (db) {
+	_XLockMutex(&db->linfo);
+	table = db->table;
+	if (*names) {
+	    if (table && !table->leaf) {
+		if (SearchNEntry(table, names, classes, &closure)) {
+		    _XUnlockMutex(&db->linfo);
+		    return False;
+		}
+	    } else if (table && table->hasloose &&
+		       AppendLooseLEntry((LTable)table, names, classes,
+					 &closure)) {
+		_XUnlockMutex(&db->linfo);
+		return False;
+	    }
+	} else {
+	    if (table && !table->leaf)
+		table = table->next;
+	    if (table &&
+		AppendLEntry((LTable)table, names, classes, &closure)) {
+		_XUnlockMutex(&db->linfo);
+		return False;
+	    }
+	}
+	_XUnlockMutex(&db->linfo);
+    }
+    closure.list[closure.idx + 1] = (LTable)NULL;
+    return True;
+}
+
+Bool XrmQGetSearchResource(
+	     XrmSearchList	searchList,
+    register XrmName		name,
+    register XrmClass		class,
+    	     XrmRepresentation	*pType,  /* RETURN */
+    	     XrmValue		*pValue) /* RETURN */
+{
+    register LTable *list;
+    register LTable table;
+    register VEntry entry = NULL;
+    int flags;
+
+/* find tight or loose entry */
+#define VTIGHTLOOSE(q) \
+    entry = LeafHash(table, q); \
+    while (entry && entry->name != q) \
+	entry = entry->next; \
+    if (entry) \
+	break
+
+/* find loose entry */
+#define VLOOSE(q) \
+    entry = LeafHash(table, q); \
+    while (entry && entry->name != q) \
+	entry = entry->next; \
+    if (entry) { \
+	if (!entry->tight) \
+	    break; \
+	if ((entry = entry->next) && entry->name == q) \
+	    break; \
+    }
+
+    list = (LTable *)searchList;
+    /* figure out which combination of name and class we need to search for */
+    flags = 0;
+    if (IsResourceQuark(name))
+	flags = 2;
+    if (IsResourceQuark(class))
+	flags |= 1;
+    if (!flags) {
+	/* neither name nor class has ever been used to name a resource */
+	table = (LTable)NULL;
+    } else if (flags == 3) {
+	/* both name and class */
+	while ((table = *list++)) {
+	    if (table != LOOSESEARCH) {
+		VTIGHTLOOSE(name);  /* do name, tight and loose */
+		VTIGHTLOOSE(class); /* do class, tight and loose */
+	    } else {
+		table = *list++;
+		VLOOSE(name);  /* do name, loose only */
+		VLOOSE(class); /* do class, loose only */
+	    }
+	}
+    } else {
+	/* just one of name or class */
+	if (flags == 1)
+	    name = class;
+	while ((table = *list++)) {
+	    if (table != LOOSESEARCH) {
+		VTIGHTLOOSE(name); /* tight and loose */
+	    } else {
+		table = *list++;
+		VLOOSE(name); /* loose only */
+	    }
+	}
+    }
+    if (table) {
+	/* found a match */
+	if (entry->string) {
+	    *pType = XrmQString;
+	    pValue->addr = StringValue(entry);
+	} else {
+	    *pType = RepType(entry);
+	    pValue->addr = DataValue(entry);
+	}
+	pValue->size = entry->size;
+	return True;
+    }
+    *pType = NULLQUARK;
+    pValue->addr = (XPointer)NULL;
+    pValue->size = 0;
+    return False;
+
+#undef VTIGHTLOOSE
+#undef VLOOSE
+}
+
+/* look for a tight/loose value */
+static Bool GetVEntry(
+    LTable		table,
+    XrmNameList		names,
+    XrmClassList 	classes,
+    VClosure		closure)
+{
+    register VEntry entry;
+    register XrmQuark q;
+
+    /* try name first */
+    q = *names;
+    entry = LeafHash(table, q);
+    while (entry && entry->name != q)
+	entry = entry->next;
+    if (!entry) {
+	/* not found, try class */
+	q = *classes;
+	entry = LeafHash(table, q);
+	while (entry && entry->name != q)
+	    entry = entry->next;
+	if (!entry)
+	    return False;
+    }
+    if (entry->string) {
+	*closure->type = XrmQString;
+	closure->value->addr = StringValue(entry);
+    } else {
+	*closure->type = RepType(entry);
+	closure->value->addr = DataValue(entry);
+    }
+    closure->value->size = entry->size;
+    return True;
+}
+
+/* look for a loose value */
+static Bool GetLooseVEntry(
+    LTable		table,
+    XrmNameList		names,
+    XrmClassList 	classes,
+    VClosure		closure)
+{
+    register VEntry	entry;
+    register XrmQuark	q;
+
+#define VLOOSE(ename) \
+    q = ename; \
+    entry = LeafHash(table, q); \
+    while (entry && entry->name != q) \
+	entry = entry->next; \
+    if (entry && entry->tight && (entry = entry->next) && entry->name != q) \
+	entry = (VEntry)NULL;
+
+    /* bump to last component */
+    while (names[1]) {
+	names++;
+	classes++;
+    }
+    VLOOSE(*names);  /* do name, loose only */
+    if (!entry) {
+	VLOOSE(*classes); /* do class, loose only */
+	if (!entry)
+	    return False;
+    }
+    if (entry->string) {
+	*closure->type = XrmQString;
+	closure->value->addr = StringValue(entry);
+    } else {
+	*closure->type = RepType(entry);
+	closure->value->addr = DataValue(entry);
+    }
+    closure->value->size = entry->size;
+    return True;
+
+#undef VLOOSE
+}
+
+/* recursive search for a value */
+static Bool GetNEntry(
+    NTable		table,
+    XrmNameList		names,
+    XrmClassList 	classes,
+    VClosure		closure)
+{
+    register NTable	entry;
+    register XrmQuark	q;
+    register unsigned int leaf;
+    Bool		(*get)(
+            NTable              table,
+            XrmNameList         names,
+            XrmClassList        classes,
+            VClosure            closure);
+    NTable		otable;
+
+    if (names[2]) {
+	get = GetNEntry; /* recurse */
+	leaf = 0;
+    } else {
+	get = (getNTableVProcp)GetVEntry; /* bottom of recursion */
+	leaf = 1;
+    }
+    GTIGHTLOOSE(*names, GetLooseVEntry);   /* do name, tight and loose */
+    GTIGHTLOOSE(*classes, GetLooseVEntry); /* do class, tight and loose */
+    if (table->hasany) {
+	GTIGHTLOOSE(XrmQANY, GetLooseVEntry); /* do ANY, tight and loose */
+    }
+    if (table->hasloose) {
+	while (1) {
+	    names++;
+	    classes++;
+	    if (!names[1])
+		break;
+	    if (!names[2]) {
+		get = (getNTableVProcp)GetVEntry; /* bottom of recursion */
+		leaf = 1;
+	    }
+	    GLOOSE(*names, GetLooseVEntry);   /* do name, loose only */
+	    GLOOSE(*classes, GetLooseVEntry); /* do class, loose only */
+	    if (table->hasany) {
+		GLOOSE(XrmQANY, GetLooseVEntry); /* do ANY, loose only */
+	    }
+	}
+    }
+    /* look for matching leaf tables */
+    otable = table;
+    table = table->next;
+    if (!table)
+	return False;
+    if (table->leaf) {
+	if (table->tight && !otable->tight)
+	    table = table->next;
+    } else {
+	table = table->next;
+	if (!table || !table->tight)
+	    return False;
+    }
+    if (!table || table->name != otable->name)
+	return False;
+    /* found one */
+    if (table->hasloose &&
+	GetLooseVEntry((LTable)table, names, classes, closure))
+	return True;
+    if (table->tight && table == otable->next) {
+	table = table->next;
+	if (table && table->name == otable->name && table->hasloose)
+	    return GetLooseVEntry((LTable)table, names, classes, closure);
+    }
+    return False;
+}
+
+Bool XrmQGetResource(
+    XrmDatabase         db,
+    XrmNameList		names,
+    XrmClassList 	classes,
+    XrmRepresentation	*pType,  /* RETURN */
+    XrmValuePtr		pValue)  /* RETURN */
+{
+    register NTable table;
+    VClosureRec closure;
+
+    if (db && *names) {
+	_XLockMutex(&db->linfo);
+	closure.type = pType;
+	closure.value = pValue;
+	table = db->table;
+	if (names[1]) {
+	    if (table && !table->leaf) {
+		if (GetNEntry(table, names, classes, &closure)) {
+		    _XUnlockMutex(&db->linfo);
+		    return True;
+		}
+	    } else if (table && table->hasloose &&
+		    GetLooseVEntry((LTable)table, names, classes, &closure)) {
+		_XUnlockMutex (&db->linfo);
+		return True;
+	    }
+	} else {
+	    if (table && !table->leaf)
+		table = table->next;
+	    if (table && GetVEntry((LTable)table, names, classes, &closure)) {
+		_XUnlockMutex(&db->linfo);
+		return True;
+	    }
+	}
+	_XUnlockMutex(&db->linfo);
+    }
+    *pType = NULLQUARK;
+    pValue->addr = (XPointer)NULL;
+    pValue->size = 0;
+    return False;
+}
+
+Bool
+XrmGetResource(XrmDatabase db, _Xconst char *name_str, _Xconst char *class_str,
+	       XrmString *pType_str, XrmValuePtr pValue)
+{
+    XrmName		names[MAXDBDEPTH+1];
+    XrmClass		classes[MAXDBDEPTH+1];
+    XrmRepresentation   fromType;
+    Bool		result;
+
+    XrmStringToNameList(name_str, names);
+    XrmStringToClassList(class_str, classes);
+    result = XrmQGetResource(db, names, classes, &fromType, pValue);
+    (*pType_str) = XrmQuarkToString(fromType);
+    return result;
+}
+
+/* destroy all values, plus table itself */
+static void DestroyLTable(
+    LTable table)
+{
+    register int i;
+    register VEntry *buckets;
+    register VEntry entry, next;
+
+    buckets = table->buckets;
+    for (i = table->table.mask; i >= 0; i--, buckets++) {
+	for (next = *buckets; (entry = next); ) {
+	    next = entry->next;
+	    Xfree((char *)entry);
+	}
+    }
+    Xfree((char *)table->buckets);
+    Xfree((char *)table);
+}
+
+/* destroy all contained tables, plus table itself */
+static void DestroyNTable(
+    NTable table)
+{
+    register int i;
+    register NTable *buckets;
+    register NTable entry, next;
+
+    buckets = NodeBuckets(table);
+    for (i = table->mask; i >= 0; i--, buckets++) {
+	for (next = *buckets; (entry = next); ) {
+	    next = entry->next;
+	    if (entry->leaf)
+		DestroyLTable((LTable)entry);
+	    else
+		DestroyNTable(entry);
+	}
+    }
+    Xfree((char *)table);
+}
+
+const char *
+XrmLocaleOfDatabase(
+    XrmDatabase db)
+{
+    const char* retval;
+    _XLockMutex(&db->linfo);
+    retval = (*db->methods->lcname)(db->mbstate);
+    _XUnlockMutex(&db->linfo);
+    return retval;
+}
+
+void XrmDestroyDatabase(
+    XrmDatabase   db)
+{
+    register NTable table, next;
+
+    if (db) {
+	_XLockMutex(&db->linfo);
+	for (next = db->table; (table = next); ) {
+	    next = table->next;
+	    if (table->leaf)
+		DestroyLTable((LTable)table);
+	    else
+		DestroyNTable(table);
+	}
+	_XUnlockMutex(&db->linfo);
+	_XFreeMutex(&db->linfo);
+	(*db->methods->destroy)(db->mbstate);
+	Xfree((char *)db);
+    }
+}