Importing from X.Org indiviual releases

1 files changed, 571 insertions, 0 deletions

diff --git a/app/xfs/difs/resource.c b/app/xfs/difs/resource.c
new file mode 100644
index 000000000..42227fea8
--- /dev/null
+++ b/app/xfs/difs/resource.c
@@ -0,0 +1,571 @@
+/* $Xorg: resource.c,v 1.4 2001/02/09 02:05:42 xorgcvs Exp $ */
+/*
+Copyright 1987, 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.
+ * Copyright 1990, 1991 Network Computing Devices;
+ * Portions Copyright 1987 by Digital Equipment Corporation 
+ *
+ * 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, and that the names of Network Computing Devices,
+ * or Digital not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  Network Computing Devices, or Digital
+ * make no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * NETWORK COMPUTING DEVICES, AND DIGITAL DISCLAIM ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES, OR 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.
+ *
+ * %W%	%G%
+ *
+ */
+/* $XFree86: xc/programs/xfs/difs/resource.c,v 3.8tsi Exp $ */
+/*
+ *      a resource is a 32 bit quantity.  the upper 12 bits are client id.
+ *      client provides a 19 bit resource id. this is "hashed" by me by
+ *      taking the 10 lower bits and xor'ing with the mid 10 bits.
+ *
+ *      It is sometimes necessary for the server to create an ID that looks
+ *      like it belongs to a client.  This ID, however,  must not be one
+ *      the client actually can create, or we have the potential for conflict.
+ *      The 20th bit of the ID is resevered for the server's use for this
+ *      purpose.  By setting CLIENT_ID(id) to the client, the SERVER_BIT to
+ *      1, and an otherwise unused ID in the low 19 bits, we can create a
+ *      resource "owned" by the client.
+ *
+ *      The following IDs are currently reserved for siccing on the client:
+ *      1 - allocated color to be freed when the client dies
+ */
+
+#include <X11/fonts/FS.h>
+#include "misc.h"
+#include "os.h"
+#include "fsresource.h"
+#include "clientstr.h"
+#include "dispatch.h"
+#include "globals.h"
+
+static void rebuild_table(int client);
+
+#define INITBUCKETS 64
+#define INITHASHSIZE 6
+#define MAXHASHSIZE 11
+
+typedef struct _Resource {
+    struct _Resource *next;
+    FSID        id;
+    RESTYPE     type;
+    pointer     value;
+}           ResourceRec, *ResourcePtr;
+
+#define NullResource ((ResourcePtr)NULL)
+
+typedef struct _ClientResource {
+    ResourcePtr *resources;
+    int         elements;
+    int         buckets;
+    int         hashsize;	/* log(2)(buckets) */
+    FSID        fakeID;
+    FSID	endFakeID;
+    FSID        expectID;
+}           ClientResourceRec;
+
+static RESTYPE lastResourceType;
+#ifdef NOTYET
+static RESTYPE lastResourceClass;
+#endif
+static RESTYPE TypeMask;
+
+typedef int (*DeleteType) (void *, FSID);
+
+extern int  CloseClientFont(ClientPtr, FSID);
+
+static DeleteType *DeleteFuncs = (DeleteType *) NULL;
+
+#ifdef NOTYET
+RESTYPE
+CreateNewResourceType(DeleteType deleteFunc)
+{
+    RESTYPE     next = lastResourceType + 1;
+    DeleteType *funcs;
+
+    if (next & lastResourceClass)
+	return 0;
+    funcs = (DeleteType *) fsrealloc(DeleteFuncs,
+				     (next + 1) * sizeof(DeleteType));
+    if (!funcs)
+	return 0;
+    lastResourceType = next;
+    DeleteFuncs = funcs;
+    DeleteFuncs[next] = deleteFunc;
+    return next;
+}
+
+RESTYPE
+CreateNewResourceClass(void)
+{
+    RESTYPE     next = lastResourceClass >> 1;
+
+    if (next & lastResourceType)
+	return 0;
+    lastResourceClass = next;
+    TypeMask = next - 1;
+    return next;
+}
+
+#endif				/* NOTYET */
+
+ClientResourceRec clientTable[MAXCLIENTS];
+
+/*****************
+ * InitClientResources
+ *    When a new client is created, call this to allocate space
+ *    in resource table
+ *****************/
+
+int
+NoneDeleteFunc (void *ptr, FSID id)
+{
+    return FSSuccess;
+}
+
+Bool
+InitClientResources(ClientPtr client)
+{
+    register int i,
+                j;
+
+    if (client == serverClient) {
+	lastResourceType = RT_LASTPREDEF;
+#ifdef NOTYET
+	lastResourceClass = RC_LASTPREDEF;
+#endif
+	TypeMask = RC_LASTPREDEF - 1;
+	if (DeleteFuncs)
+	    fsfree(DeleteFuncs);
+	DeleteFuncs = (DeleteType *) fsalloc((lastResourceType + 1) *
+					     sizeof(DeleteType));
+	if (!DeleteFuncs)
+	    return FALSE;
+	DeleteFuncs[RT_NONE & TypeMask] = NoneDeleteFunc;
+	DeleteFuncs[RT_FONT & TypeMask] = (DeleteType)CloseClientFont;
+	DeleteFuncs[RT_AUTHCONT & TypeMask] = (DeleteType)DeleteAuthCont;
+    }
+    clientTable[i = client->index].resources =
+	(ResourcePtr *) fsalloc(INITBUCKETS * sizeof(ResourcePtr));
+    if (!clientTable[i].resources)
+	return FALSE;
+    clientTable[i].buckets = INITBUCKETS;
+    clientTable[i].elements = 0;
+    clientTable[i].hashsize = INITHASHSIZE;
+    clientTable[i].fakeID =  SERVER_BIT;
+    clientTable[i].endFakeID = (clientTable[i].fakeID | RESOURCE_ID_MASK) + 1;
+    for (j = 0; j < INITBUCKETS; j++) {
+	clientTable[i].resources[j] = NullResource;
+    }
+    return TRUE;
+}
+
+static int
+hash(int client, FSID id)
+{
+    id &= RESOURCE_ID_MASK;
+    switch (clientTable[client].hashsize) {
+    case 6:
+	return ((int) (0x03F & (id ^ (id >> 6) ^ (id >> 12))));
+    case 7:
+	return ((int) (0x07F & (id ^ (id >> 7) ^ (id >> 13))));
+    case 8:
+	return ((int) (0x0FF & (id ^ (id >> 8) ^ (id >> 16))));
+    case 9:
+	return ((int) (0x1FF & (id ^ (id >> 9))));
+    case 10:
+	return ((int) (0x3FF & (id ^ (id >> 10))));
+    case 11:
+	return ((int) (0x7FF & (id ^ (id >> 11))));
+    }
+    return -1;
+}
+
+
+static Font
+AvailableID(
+    register int client,
+    register FSID id,
+    register FSID maxid,
+    register FSID goodid)
+{
+    register ResourcePtr res;
+
+    if ((goodid >= id) && (goodid <= maxid))
+	return goodid;
+    for (; id <= maxid; id++)
+    {
+	res = clientTable[client].resources[hash(client, id)];
+	while (res && (res->id != id))
+	    res = res->next;
+	if (!res)
+	    return id;
+    }
+    return 0;
+}
+
+/*
+ * Return the next usable fake client ID.
+ *
+ * Normally this is just the next one in line, but if we've used the last
+ * in the range, we need to find a new range of safe IDs to avoid
+ * over-running another client.
+ */
+
+FSID
+FakeClientID(int client)
+{
+    register FSID id, maxid;
+    register ResourcePtr *resp;
+    register ResourcePtr res;
+    register int i;
+    FSID goodid;
+
+    id = clientTable[client].fakeID++;
+    if (id != clientTable[client].endFakeID)
+	return id;
+    id = ((Mask)client << CLIENTOFFSET) | SERVER_BIT;
+    maxid = id | RESOURCE_ID_MASK;
+    goodid = 0;
+    for (resp = clientTable[client].resources, i = clientTable[client].buckets;
+	 --i >= 0;)
+    {
+	for (res = *resp++; res; res = res->next)
+	{
+	    if ((res->id < id) || (res->id > maxid))
+		continue;
+	    if (((res->id - id) >= (maxid - res->id)) ?
+		(goodid = AvailableID(client, id, res->id - 1, goodid)) :
+		!(goodid = AvailableID(client, res->id + 1, maxid, goodid)))
+		maxid = res->id - 1;
+	    else
+		id = res->id + 1;
+	}
+    }
+    if (id > maxid) {
+	if (!client)
+	    FatalError("FakeClientID: server internal ids exhausted\n");
+	MarkClientException(clients[client]);
+	id = ((Mask)client << CLIENTOFFSET) | (SERVER_BIT * 3);
+	maxid = id | RESOURCE_ID_MASK;
+    }
+    clientTable[client].fakeID = id + 1;
+    clientTable[client].endFakeID = maxid + 1;
+    return id;
+}
+
+Bool
+AddResource(
+    int         cid,
+    FSID        id,
+    RESTYPE     type,
+    pointer     value)
+{
+    register ClientResourceRec *rrec;
+    register ResourcePtr res,
+               *head;
+
+    rrec = &clientTable[cid];
+    if (!rrec->buckets) {
+	ErrorF("AddResource(%x, %x, %x), client=%d \n",
+	       id, type, value, cid);
+	FatalError("client not in use\n");
+    }
+    if ((rrec->elements >= 4 * rrec->buckets) &&
+	    (rrec->hashsize < MAXHASHSIZE))
+	rebuild_table(cid);
+    head = &rrec->resources[hash(cid, id)];
+    res = (ResourcePtr) fsalloc(sizeof(ResourceRec));
+    if (!res) {
+	(*DeleteFuncs[type & TypeMask]) (value, id);
+	return FALSE;
+    }
+    res->next = *head;
+    res->id = id;
+    res->type = type;
+    res->value = value;
+    *head = res;
+    rrec->elements++;
+    if (!(id & SERVER_BIT) && (id >= rrec->expectID))
+	rrec->expectID = id + 1;
+    return TRUE;
+}
+
+static void
+rebuild_table(int client)
+{
+    register int j;
+    register ResourcePtr res,
+                next;
+    ResourcePtr **tails,
+               *resources;
+    register ResourcePtr **tptr,
+               *rptr;
+
+    /*
+     * For now, preserve insertion order, since some ddx layers depend on
+     * resources being free in the opposite order they are added.
+     */
+
+    j = 2 * clientTable[client].buckets;
+    tails = (ResourcePtr **) ALLOCATE_LOCAL(j * sizeof(ResourcePtr *));
+    if (!tails)
+	return;
+    resources = (ResourcePtr *) fsalloc(j * sizeof(ResourcePtr));
+    if (!resources) {
+	DEALLOCATE_LOCAL(tails);
+	return;
+    }
+    for (rptr = resources, tptr = tails; --j >= 0; rptr++, tptr++) {
+	*rptr = NullResource;
+	*tptr = rptr;
+    }
+    clientTable[client].hashsize++;
+    for (j = clientTable[client].buckets,
+	    rptr = clientTable[client].resources;
+	    --j >= 0;
+	    rptr++) {
+	for (res = *rptr; res; res = next) {
+	    next = res->next;
+	    res->next = NullResource;
+	    tptr = &tails[hash(client, res->id)];
+	    **tptr = res;
+	    *tptr = &res->next;
+	}
+    }
+    DEALLOCATE_LOCAL(tails);
+    clientTable[client].buckets *= 2;
+    fsfree(clientTable[client].resources);
+    clientTable[client].resources = resources;
+}
+
+void
+FreeResource(
+    int         cid,
+    FSID        id,
+    RESTYPE     skipDeleteFuncType)
+{
+    register ResourcePtr res;
+    register ResourcePtr *prev,
+               *head;
+    register int *eltptr;
+    int         elements;
+    Bool        gotOne = FALSE;
+
+    if (clientTable[cid].buckets) {
+	head = &clientTable[cid].resources[hash(cid, id)];
+	eltptr = &clientTable[cid].elements;
+
+	prev = head;
+	while ((res = *prev) != (ResourcePtr) 0) {
+	    if (res->id == id) {
+		RESTYPE     rtype = res->type;
+
+		*prev = res->next;
+		elements = --*eltptr;
+		if (rtype != skipDeleteFuncType)
+		    (*DeleteFuncs[rtype & TypeMask]) (res->value, res->id);
+		fsfree(res);
+		if (*eltptr != elements)
+		    prev = head;/* prev may no longer be valid */
+		gotOne = TRUE;
+	    } else
+		prev = &res->next;
+	}
+    }
+    if (!gotOne)
+	FatalError("freeing resource id=%X which isn't there\n", id);
+}
+
+#ifdef NOTYET
+void
+FreeResourceByType(
+    int         cid,
+    FSID        id,
+    RESTYPE     type,
+    Bool        skipFree)
+{
+    register ResourcePtr res;
+    register ResourcePtr *prev,
+               *head;
+
+    if (clientTable[cid].buckets) {
+	head = &clientTable[cid].resources[hash(cid, id)];
+
+	prev = head;
+	while (res = *prev) {
+	    if (res->id == id && res->type == type) {
+		*prev = res->next;
+		if (!skipFree)
+		    (*DeleteFuncs[type & TypeMask]) (res->value, res->id);
+		fsfree(res);
+		break;
+	    } else
+		prev = &res->next;
+	}
+    }
+}
+
+/*
+ * Change the value associated with a resource id.  Caller
+ * is responsible for "doing the right thing" with the old
+ * data
+ */
+
+Bool
+ChangeResourceValue(
+    int         cid,
+    FSID        id,
+    RESTYPE     rtype,
+    pointer     value)
+{
+    register ResourcePtr res;
+
+    if (clientTable[cid].buckets) {
+	res = clientTable[cid].resources[hash(cid, id)];
+
+	for (; res; res = res->next)
+	    if ((res->id == id) && (res->type == rtype)) {
+		res->value = value;
+		return TRUE;
+	    }
+    }
+    return FALSE;
+}
+
+#endif				/* NOTYET */
+
+void
+FreeClientResources(ClientPtr client)
+{
+    register ResourcePtr *resources;
+    register ResourcePtr this;
+    int         j;
+
+    /*
+     * This routine shouldn't be called with a null client, but just in case
+     * ...
+     */
+
+    if (!client)
+	return;
+
+    resources = clientTable[client->index].resources;
+    for (j = 0; j < clientTable[client->index].buckets; j++) {
+	/*
+	 * It may seem silly to update the head of this resource list as we
+	 * delete the members, since the entire list will be deleted any way,
+	 * but there are some resource deletion functions "FreeClientPixels"
+	 * for one which do a LookupID on another resource id (a Colormap id
+	 * in this case), so the resource list must be kept valid up to the
+	 * point that it is deleted, so every time we delete a resource, we
+	 * must update the head, just like in free_resource. I hope that this
+	 * doesn't slow down mass deletion appreciably. PRH
+	 */
+
+	ResourcePtr *head;
+
+	head = &resources[j];
+
+	for (this = *head; this; this = *head) {
+	    RESTYPE     rtype = this->type;
+
+	    *head = this->next;
+	    (*DeleteFuncs[rtype & TypeMask]) (this->value, this->id);
+	    fsfree(this);
+	}
+    }
+    fsfree(clientTable[client->index].resources);
+    clientTable[client->index].buckets = 0;
+}
+
+void
+FreeAllResources(void)
+{
+    int         i;
+
+    for (i = 0; i < currentMaxClients; i++) {
+	if (clientTable[i].buckets)
+	    FreeClientResources(clients[i]);
+    }
+}
+
+/*
+ *  lookup_id_by_type returns the object with the given id and type, else NULL.
+ */
+pointer
+LookupIDByType(
+    int         cid,
+    FSID        id,
+    RESTYPE     rtype)
+{
+    register ResourcePtr res;
+
+    if (clientTable[cid].buckets) {
+	res = clientTable[cid].resources[hash(cid, id)];
+
+	for (; res; res = res->next)
+	    if ((res->id == id) && (res->type == rtype))
+		return res->value;
+    }
+    return (pointer) NULL;
+}
+
+#ifdef NOTYET
+/*
+ *  lookup_ID_by_class returns the object with the given id and any one of the
+ *  given classes, else NULL.
+ */
+pointer
+LookupIDByClass(
+    FSID        id,
+    RESTYPE     classes)
+{
+    int         cid;
+    register ResourcePtr res;
+
+    if (((cid = CLIENT_ID(id)) < MAXCLIENTS) && clientTable[cid].buckets) {
+	res = clientTable[cid].resources[hash(cid, id)];
+
+	for (; res; res = res->next)
+	    if ((res->id == id) && (res->type & classes))
+		return res->value;
+    }
+    return (pointer) NULL;
+}
+
+#endif				/* NOTYET */