/*
 * $XConsortium: Quarks.c,v 1.13 88/09/19 13:55:48 jim Exp $
 */

/***********************************************************
Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
and the Massachusetts Institute of Technology, Cambridge, Massachusetts.

                        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 names of Digital or MIT 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.

******************************************************************/

#include "Xlibint.h"
#include "Xresource.h"

extern void bcopy();


typedef long Signature;

static XrmQuark nextQuark = 1;	/* next available quark number */
static XrmString *quarkToStringTable = NULL;
static int maxQuarks = 0;	/* max names in current quarkToStringTable */
#define QUARKQUANTUM 600;	/* how much to extend quarkToStringTable by */


/* Permanent memory allocation */

#define NEVERFREETABLESIZE 8180
static char *neverFreeTable = NULL;
static int  neverFreeTableSize = 0;

char *Xpermalloc(length)
    unsigned int length;
{
    char *ret;

#ifdef WORD64
    /* round to nearest 8-byte boundary */
    length = (length + 7) & (~7);
#else
    /* round to nearest 4-byte boundary */
    length = (length + 3) & (~3);
#endif /* WORD64 */
    if (neverFreeTableSize < length) {
	neverFreeTableSize =
	    (length > NEVERFREETABLESIZE ? length : NEVERFREETABLESIZE);
	neverFreeTable = Xmalloc(neverFreeTableSize);
    }
    ret = neverFreeTable;
    neverFreeTable += length;
    neverFreeTableSize -= length;
    return(ret);
}


typedef struct _NodeRec *Node;
typedef struct _NodeRec {
    Node 	next;
    Signature	sig;
    XrmQuark	quark;
    XrmString	name;
} NodeRec;

#define HASHTABLESIZE 1024
#define HASHTABLEMASK 1023
static Node nodeTable[HASHTABLESIZE];



/* predefined quarks */

/* Representation types */

XrmQuark  XrmQBoolean;
XrmQuark  XrmQColor;
XrmQuark  XrmQCursor;
XrmQuark  XrmQDims;
XrmQuark  XrmQDisplay;
XrmQuark  XrmQFile;
XrmQuark  XrmQFont;
XrmQuark  XrmQFontStruct;
XrmQuark  XrmQGeometry;
XrmQuark  XrmQInt;
XrmQuark  XrmQPixel;
XrmQuark  XrmQPixmap;
XrmQuark  XrmQPointer;
XrmQuark  XrmQString;
XrmQuark  XrmQWindow;

/* "Enumeration" constants */

XrmQuark  XrmQEfalse;
XrmQuark  XrmQEno;
XrmQuark  XrmQEoff;
XrmQuark  XrmQEon;
XrmQuark  XrmQEtrue;
XrmQuark  XrmQEyes;


static XrmAllocMoreQuarkToStringTable()
{
    unsigned	size;

    maxQuarks += QUARKQUANTUM;
    size = (unsigned) maxQuarks * sizeof(XrmString);
    if (quarkToStringTable == (XrmString *)NULL)
	quarkToStringTable = (XrmString *) Xmalloc(size);
    else
	quarkToStringTable =
		(XrmString *) Xrealloc((char *) quarkToStringTable, size);
}

XrmQuark XrmStringToQuark(name)
    register XrmString name;
{
    register Signature 	sig = 0;
    register Signature	scale = 27;
    register XrmString	tname;
    register Node	np;
    register XrmString	npn;
    	     Node	*hashp;
	     unsigned	strLength;

    if (name == NULL)
	return (NULLQUARK);

    /* Compute string signature (sparse 32-bit hash value) */
    for (tname = name; *tname != '\0'; tname++) {
	sig = sig*scale + (unsigned int) *tname;
    }
    strLength = tname - name + 1;

    /* Look for string in hash table */
    hashp = &nodeTable[sig & HASHTABLEMASK];
    for (np = *hashp; np != NULL; np = np->next) {
	if (np->sig == sig) {
	    for (npn=np->name, tname = name;
	     ((scale = *tname) != 0) && (scale == *npn); ++tname, ++npn) {};
	    if (scale == *npn) {
	        return np->quark;
	    }
	}
    }

    /* Not found, add string to hash table */
    np = (Node) Xpermalloc(sizeof(NodeRec));
    np->next = *hashp;
    *hashp = np;
    np->sig = sig;
    bcopy(name, (np->name = Xpermalloc(strLength)), (int) strLength);
    np->quark = nextQuark;

    if (nextQuark >= maxQuarks)
	XrmAllocMoreQuarkToStringTable();

    quarkToStringTable[nextQuark] = np->name;
    ++nextQuark;
    return np->quark;
}

extern XrmQuark XrmUniqueQuark()
{
    XrmQuark quark;

    quark = nextQuark;
    if (nextQuark >= maxQuarks)
	XrmAllocMoreQuarkToStringTable();
    quarkToStringTable[nextQuark] = NULLSTRING;
    ++nextQuark;
    return (quark);
}


XrmString XrmQuarkToString(quark)
    XrmQuark quark;
{
    if (quark <= 0 || quark >= nextQuark)
    	return NULLSTRING;
    return quarkToStringTable[quark];
}