Imported nx-X11-3.1.0-1.tar.gznx-X11/3.1.0-1

Summary: Imported nx-X11-3.1.0-1.tar.gz
Keywords:

Imported nx-X11-3.1.0-1.tar.gz
into Git repository

1 files changed, 1134 insertions, 0 deletions

diff --git a/nx-X11/lib/dps/dpsXclient.c b/nx-X11/lib/dps/dpsXclient.c
new file mode 100644
index 000000000..212030ecc
--- /dev/null
+++ b/nx-X11/lib/dps/dpsXclient.c
@@ -0,0 +1,1134 @@
+/*
+ * dpsXclient.c -- Implementation of the Display PostScript Client Library.
+ *
+ * (c) Copyright 1988-1994 Adobe Systems Incorporated.
+ * All rights reserved.
+ * 
+ * Permission to use, copy, modify, distribute, and sublicense this software
+ * and its documentation for any purpose and without fee is hereby granted,
+ * provided that the above copyright notices appear in all copies and that
+ * both those copyright notices and this permission notice appear in
+ * supporting documentation and that the name of Adobe Systems Incorporated
+ * not be used in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.  No trademark license
+ * to use the Adobe trademarks is hereby granted.  If the Adobe trademark
+ * "Display PostScript"(tm) is used to describe this software, its
+ * functionality or for any other purpose, such use shall be limited to a
+ * statement that this software works in conjunction with the Display
+ * PostScript system.  Proper trademark attribution to reflect Adobe's
+ * ownership of the trademark shall be given whenever any such reference to
+ * the Display PostScript system is made.
+ * 
+ * ADOBE MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THE SOFTWARE FOR
+ * ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
+ * ADOBE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NON- INFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO EVENT SHALL ADOBE BE LIABLE
+ * TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE, STRICT LIABILITY OR ANY OTHER ACTION ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  ADOBE WILL NOT
+ * PROVIDE ANY TRAINING OR OTHER SUPPORT FOR THE SOFTWARE.
+ * 
+ * Adobe, PostScript, and Display PostScript are trademarks of Adobe Systems
+ * Incorporated which may be registered in certain jurisdictions
+ * 
+ * Author:  Adobe Systems Incorporated
+ */
+/* $XFree86$ */
+
+#include <stdlib.h>
+#include <unistd.h>	/* sleep() */
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifdef VMS
+/* Xlib does not like UNIX defined to any value under VMS. */
+#undef UNIX
+#include <decw$include/X.h>
+#include <decw$include/Xlib.h>
+
+#else /* VMS */
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#endif /* VMS */
+
+#include "DPS/XDPSlib.h"
+#include "DPS/XDPS.h"
+
+#include "publictypes.h"
+#include "DPS/dpsclient.h"
+#include "dpsprivate.h"
+
+#include "dpsXpriv.h"
+#include "DPS/dpsXclient.h"
+
+#include "dpsdict.h"
+#include "DPS/dpsexcept.h"
+
+#include "dpsXint.h"
+
+static DPSPrivContext FindPrivContext (
+  Display  *	dpy,
+  long int	cid)
+{
+  DPSPrivSpace ss;
+  DPSPrivContext cc;
+
+  for (ss = spaces;  ss != NIL;  ss = ss->next)
+    for (cc = ss->firstContext;  cc != NIL;  cc = cc->next)
+      if (cc->cid == cid && ((XDPSPrivContext) cc->wh)->dpy == dpy)
+	return (cc);
+  return (NIL);
+}
+
+DPSContext XDPSFindContext (
+  Display  *	dpy,
+  int		cid)
+{
+  return ((DPSContext) FindPrivContext (dpy, cid));
+}
+
+DPSContext DPSContextFromContextID(
+  DPSContext ctxt,
+  int contextID,
+  DPSTextProc textProc,
+  DPSErrorProc errorProc)
+{
+  DPSPrivSpace ss;
+  Display *dpy = ((XDPSPrivContext) ((DPSPrivContext) ctxt)->wh)->dpy;
+  DPSPrivContext c, cc = FindPrivContext (dpy, contextID);
+  DPSPrivContext oldc = (DPSPrivContext)ctxt;
+  
+  if (cc != NIL) return (DPSContext)cc;
+
+  c = (DPSPrivContext)DPScalloc(sizeof(DPSPrivContextRec), 1);
+  if (!c) return NIL;
+  *c = *oldc;
+  ss = (DPSPrivSpace)c->space;
+  
+  if (textProc) c->textProc = textProc;
+  if (errorProc) c->errorProc = errorProc;
+
+  c->eofReceived = false;
+  c->cid = contextID;
+  c->buf = c->outBuf = c->objBuf = NIL;
+  c->chainParent = c->chainChild = NIL;
+  
+  c->nBufChars = c->nOutBufChars = c->nObjBufChars = 0;
+
+  c->next = ss->firstContext;
+  DPSAssert(c->next != c);
+  ss->firstContext = c;
+
+  /* Note: there's no way to determine whether the new context id was obtained
+  ** as a result of a fork operation or from another application.  so, it must
+  ** be assumed that the application is the creator of the new context.
+  ** Otherwise, it would have called the XDPSContextFromSharedID.
+  */
+  c->creator = true;
+  c->zombie = false;
+  c->numstringOffsets = NULL;
+
+  DPSIncludePrivContext(
+    (XDPSPrivContext) c->wh, (DPSContext)c, c->cid, ss->sid, DPSclientPrintProc);
+
+  return (DPSContext)c;
+}
+
+boolean DPSPrivateCheckWait(
+    DPSContext ctxt)
+{
+    DPSPrivContext cc = (DPSPrivContext) ctxt;
+
+    if (!cc->creator || cc->zombie) {
+	DPSSafeSetLastNameIndex(ctxt);
+	if (cc->errorProc != NIL) {
+	    (*cc->errorProc) (ctxt, cc->zombie ? dps_err_deadContext :
+			                         dps_err_invalidAccess,
+			      (unsigned long) ctxt, 0);
+	}
+	return true;
+    }
+    return false;
+}
+
+static void procFlushContext(
+  DPSContext ctxt)
+{
+  DPSPrivContext c = (DPSPrivContext) ctxt;
+  XDPSLFlush (((XDPSPrivContext) c->wh)->dpy);
+  if (ctxt->chainChild != NIL) DPSFlushContext(ctxt->chainChild);
+}
+
+/* ARGSUSED */
+static Bool FindDPSEvent(
+  Display *dpy,
+  XEvent *event,
+  char *arg)
+{
+  return XDPSIsDPSEvent(event);
+}
+
+static void procAwaitReturnValues(DPSContext ctxt)
+{
+  DPSPrivContext c = (DPSPrivContext)ctxt;
+ 
+  XDPSPrivContext xwh = (XDPSPrivContext) c->wh;
+  XEvent ev;
+
+  /* Output currently goes only to creator! */
+  if (!c->creator)
+    {
+    DPSSafeSetLastNameIndex(ctxt);
+    c->resultTable = NIL;
+    c->resultTableLength = 0;
+    if (c->errorProc != NIL)
+      (*c->errorProc) (ctxt, dps_err_invalidAccess, 0, 0);
+    return;
+    }
+  if (c->resultTable != NIL)
+    {
+    DPSCheckInitClientGlobals();
+
+    if (XDPSLGetWrapWaitingFlag(xwh->dpy)) {
+	DPSSafeSetLastNameIndex(ctxt);
+	c->resultTable = NIL;
+	c->resultTableLength = 0;
+	if (c->errorProc != NIL)
+		(*c->errorProc) (ctxt, dps_err_recursiveWait,
+				 (unsigned long) xwh->dpy, 0);
+	return;
+    }
+    XDPSLSetWrapWaitingFlag(xwh->dpy, True);
+
+  DURING
+    DPSFlushContext(ctxt);
+    while (c->resultTable != NIL)
+      {
+      /* We may block indefinitely if the context is frozen or it
+	 somehow needs more input. */
+      if (c->zombie)
+	{
+	DPSSafeSetLastNameIndex(ctxt);
+	c->resultTable = NIL;
+	c->resultTableLength = 0;
+	if (c->errorProc != NIL)
+	  (*c->errorProc) (ctxt, dps_err_deadContext, (unsigned long) c, 0);
+	XDPSLSetWrapWaitingFlag(xwh->dpy, False);
+	E_RTRN_VOID;
+	}
+      
+      /* Someone could conceivably change the event delivery mode in the
+	 middle of this...best to check every time */
+
+      if (XDPSLGetPassEventsFlag(xwh->dpy)) {
+	  XIfEvent(xwh->dpy, &ev, FindDPSEvent, (char *) NULL);
+	  if (!XDPSDispatchEvent(&ev)) DPSCantHappen();
+      } else DPSSendPostScript((XDPSPrivContext) c->wh, DPSclientPrintProc,
+			       c->cid, NIL, 0, NIL);
+    }
+  HANDLER
+    XDPSLSetWrapWaitingFlag(xwh->dpy, False);
+    RERAISE;
+  END_HANDLER
+
+  XDPSLSetWrapWaitingFlag(xwh->dpy, False);
+
+  }
+
+ /* update space's name map.
+       space->lastNameIndex is the highest index known to be known to the
+	 server for this space.
+       c->lastNameIndex is the highest index sent so far to the context
+ */
+
+  if (((DPSPrivSpace)(c->space))->lastNameIndex < c->lastNameIndex)
+    ((DPSPrivSpace)(c->space))->lastNameIndex = c->lastNameIndex;
+}
+
+void DPSinnerProcWriteData(
+  DPSContext ctxt,
+  char *buf,
+  unsigned int count)
+{
+  DPSPrivContext c = (DPSPrivContext) ctxt;
+  
+  /* ASSERT: safe to call with chain */
+
+  /* No local buffering */
+  DPSSendPostScript ((XDPSPrivContext) c->wh, DPSclientPrintProc,
+		     c->cid, buf, count, NIL);
+} /* DPSinnerProcWriteData */
+
+static void procResetContext(DPSContext ctxt)
+{
+  DPSPrivContext c = (DPSPrivContext) ctxt;
+  int currStatus;
+  register XDPSPrivContext xwh = (XDPSPrivContext) c->wh;
+  int retries = 0;
+  int backoff = 2;
+  
+  /* First make sure context isn't frozen, try to unfreeze. */
+
+#define DPS_SLEEP_SECS 2
+
+  while((currStatus = XDPSLGetStatus(xwh->dpy, xwh->cxid)) == PSFROZEN)
+    {
+    XDPSLNotifyContext(xwh->dpy, xwh->cxid, PSUNFREEZE);
+    sleep(DPS_SLEEP_SECS);
+      /* Okay if context is PSRUNNING, since the EOF will
+         be handled at the next PSNEEDSINPUT */
+    }
+
+  /* Remove events from Xlib Qs before sending the reset request. */
+  XDPSForceEvents (xwh->dpy);
+  
+  if (currStatus == PSSTATUSERROR)
+    /* +++ report error? */;
+  else  /* Didn't become zombie. */
+    {
+    currStatus = 0;
+    XDPSLReset(xwh->dpy, xwh->cxid);
+    XDPSLFlush(xwh->dpy);
+    /* Be optmistic for the first try. Assume the app set up a status mask
+       correctly, we should get a status event without asking the
+       server for status. */
+    
+    XDPSForceEvents(xwh->dpy);
+    currStatus = c->statusFromEvent;
+
+    while (currStatus != PSNEEDSINPUT && currStatus != PSZOMBIE)
+      {
+      if (currStatus == PSFROZEN)
+          XDPSLNotifyContext(xwh->dpy, xwh->cxid, PSUNFREEZE);
+      if (retries > backoff)
+        {
+        /* Optimism failed.  App probably didn't set up a status mask.
+           Ask the server for status. */
+        currStatus = XDPSLGetStatus(xwh->dpy, xwh->cxid);
+        retries = 0;
+        backoff = (backoff > 30) ? 2 : backoff + 1;
+        continue;
+        }
+      else
+        ++retries;
+      sleep(DPS_SLEEP_SECS);
+      XDPSForceEvents(xwh->dpy);
+      currStatus = c->statusFromEvent;
+      }
+    }
+  
+  c->eofReceived = false;
+}
+
+void DPSPrivateDestroyContext(DPSContext ctxt)
+{
+  DPSPrivContext c = (DPSPrivContext)ctxt;
+  DPSPrivSpace s = (DPSPrivSpace) c->space;
+
+  if (c->creator)
+    DPSSendTerminate((XDPSPrivContext) c->wh, c->cid, DPSclientPrintProc);
+  else 
+    XDPSSetStatusMask(ctxt, 0, XDPSL_ALL_EVENTS, 0);  /* Stop status events */
+  /* Don't free the space's wh out from under it */
+  if (c->wh != s->wh) free(c->wh);
+}
+
+void DPSPrivateDestroySpace(DPSSpace space)
+{
+    DPSPrivSpace ss = (DPSPrivSpace) space;
+
+    if (ss->creator) DPSSendDestroySpace((XDPSPrivContext) ss->wh, ss->sid,
+					 DPSclientPrintProc);
+
+    free (ss->wh);
+}
+
+boolean DPSCheckShared(DPSPrivContext ctxt)
+{
+  return ctxt->creator == false && ctxt->resultTable != NIL;
+  /* let procAwaitReturnValues generate error */
+}
+
+/* ARGSUSED */
+void DPSServicePostScript(boolean (*returnControl)(void))
+{
+} /* DPSServicePostScript */
+
+void DPSHandleBogusError(DPSContext ctxt, char *prefix, char *suffix)
+{
+    char *buf = "bogus error output from context";
+    DPSDefaultPrivateHandler(ctxt, dps_err_warning,
+			     (long unsigned int)buf, 0, prefix, suffix);
+}
+
+void DPSDefaultPrivateHandler(
+  DPSContext ctxt,
+  DPSErrorCode errorCode,
+  long unsigned int arg1,
+  long unsigned int arg2,
+  char *prefix,
+  char *suffix)
+{
+
+  DPSTextProc textProc = DPSGetCurrentTextBackstop();
+
+  switch (errorCode) {
+    case dps_err_invalidAccess:
+      if (textProc != NIL)
+	{
+	char m[100];
+	(void) sprintf (m, "%sInvalid context access.%s", prefix, suffix);
+	(*textProc) (ctxt, m, strlen (m));
+	}
+	break;
+    case dps_err_encodingCheck:
+      if (textProc != NIL)
+	{
+	char m[100];
+	(void) sprintf (m, "%sInvalid name/program encoding: %d/%d.%s",
+			prefix, (int) arg1, (int) arg2, suffix);
+	(*textProc) (ctxt, m, strlen (m));
+	}
+	break;
+    case dps_err_closedDisplay:
+      if (textProc != NIL)
+	{
+	char m[100];
+	(void) sprintf (m, "%sBroken display connection %d.%s",
+			prefix, (int) arg1, suffix);
+	(*textProc) (ctxt, m, strlen (m));
+	}
+	break;
+    case dps_err_deadContext:
+      if (textProc != NIL)
+	{
+	char m[100];
+	(void) sprintf (m, "%sDead context 0x0%x.%s", prefix,
+			(int) arg1, suffix);
+	(*textProc) (ctxt, m, strlen (m));
+	}
+	break;
+    case dps_err_warning:
+      if (textProc != NIL)
+        {
+        char *warn = (char *)arg1;
+        char *msg = "%% DPS Client Library Warning:\n   ";
+        (*textProc)(ctxt, msg, strlen(msg));
+        (*textProc)(ctxt, warn, strlen(warn));
+        msg = "\n";
+        (*textProc)(ctxt, msg, strlen(msg));
+        /* flush convention */
+        (*textProc)(ctxt, msg, 0);
+        }
+        break;
+    case dps_err_fatal:
+      if (textProc != NIL)
+        {
+        char *fatal = (char *)arg1;
+        char *msg = "%% DPS Client Library Fatal Internal Error:\n   ";
+        (*textProc)(ctxt, msg, strlen(msg));
+        (*textProc)(ctxt, fatal, strlen(fatal));
+        msg = ".\nAborting ...\n";
+        (*textProc)(ctxt, msg, strlen(msg));
+        /* flush convention */
+        (*textProc)(ctxt, msg, 0);
+        abort();
+        }
+        break;
+    case dps_err_recursiveWait:
+      if (textProc != NIL)
+	{
+	char m[100];
+	(void) sprintf (m,
+			"%sRecursive wait for return values, display 0x%x.%s",
+			prefix, (int) arg1, suffix);
+	(*textProc) (ctxt, m, strlen (m));
+	}
+	break;
+  }
+}
+
+void DPSInitPrivateSpaceFields(DPSPrivSpace s)
+{
+    s->creator = true;
+}
+
+void DPSInitPrivateContextFields(DPSPrivContext c, DPSPrivSpace s)
+{
+    c->creator = true;
+    c->zombie = false;
+    if (!s->creator) {
+	c->procs = XDPSconvProcs;
+	c->nameEncoding = dps_strings;
+    }
+}
+
+void  DPSInitPrivateTextContextFields(DPSPrivContext c, DPSPrivSpace s)
+{
+    c->creator = true;
+    c->zombie = false;
+    c->space = (DPSSpace) s;
+    c->next = s->firstContext;
+    s->firstContext = c;
+}
+  
+long int DPSLastUserObjectIndex = 0;
+
+long int DPSNewUserObjectIndex (void)
+{
+  return (DPSLastUserObjectIndex++);
+}
+
+void XDPSSetProcs (void)
+{
+  DPSCheckInitClientGlobals ();
+  if (!textCtxProcs)
+    {
+    textCtxProcs = (DPSProcs) DPScalloc (sizeof (DPSProcsRec), 1);
+    DPSInitCommonTextContextProcs(textCtxProcs);
+    DPSInitSysNames();
+    }
+  if (!ctxProcs)
+    {
+    ctxProcs = (DPSProcs) DPScalloc (sizeof (DPSProcsRec), 1);
+    DPSInitCommonContextProcs(ctxProcs);
+    DPSInitPrivateContextProcs(ctxProcs);
+    }
+  if (!XDPSconvProcs)
+    XDPSconvProcs = (DPSProcs) DPScalloc (sizeof (DPSProcsRec), 1);
+  if (!XDPSrawProcs)
+    XDPSrawProcs = ctxProcs;
+  *XDPSconvProcs = *ctxProcs;
+  XDPSconvProcs->BinObjSeqWrite = textCtxProcs->BinObjSeqWrite;
+  XDPSconvProcs->WriteStringChars = textCtxProcs->WriteStringChars;
+  XDPSconvProcs->WritePostScript = textCtxProcs->WritePostScript;
+  XDPSconvProcs->WriteNumString = textCtxProcs->WriteNumString;
+}
+
+void DPSInitPrivateContextProcs(DPSProcs p)
+{
+    p->FlushContext = procFlushContext;
+    p->ResetContext = procResetContext;
+    p->AwaitReturnValues = procAwaitReturnValues;
+}
+
+DPSContext XDPSCreateSimpleContext (
+  Display	*dpy,
+  Drawable	draw,
+  GC		gc,
+  int		x,
+  int		y,
+  DPSTextProc	textProc,
+  DPSErrorProc	errorProc,
+  DPSSpace	space)
+{
+  XDPSPrivContext xwh = XDPSCreatePrivContextRec (dpy, draw, gc, x, y,
+  						  0, DefaultStdCMap,
+						  DefaultStdCMap, 0, false);
+  DPSContext newCtxt;
+  
+  if (xwh == NIL)
+    return (NIL);
+  else
+    {
+    newCtxt = DPSCreateContext ((char *) xwh, textProc, errorProc, space);
+    if (newCtxt == NIL)
+      free ((char *) xwh);
+    return (newCtxt);
+    }
+}
+
+
+DPSContext XDPSCreateContext (
+  Display		*dpy,
+  Drawable		draw,
+  GC			gc,
+  int			x,
+  int			y,
+  unsigned int		eventmask,
+  XStandardColormap	*grayramp,
+  XStandardColormap	*ccube,
+  int			actual,
+  DPSTextProc		textProc,
+  DPSErrorProc		errorProc,
+  DPSSpace		space)
+{
+  XDPSPrivContext xwh = XDPSCreatePrivContextRec (dpy, draw, gc, x, y,
+  						  eventmask, grayramp,
+						  ccube, actual, false);
+  DPSContext newCtxt;
+  
+  if (xwh == NIL)
+    return (NIL);
+  else
+    {
+    newCtxt = DPSCreateContext ((char *) xwh, textProc, errorProc, space);
+    if (newCtxt == NIL)
+      free ((char *) xwh);
+    return (newCtxt);
+    }
+}
+
+DPSContext XDPSCreateSecureContext (
+  Display		*dpy,
+  Drawable		draw,
+  GC			gc,
+  int			x,
+  int			y,
+  unsigned int		eventmask,
+  XStandardColormap	*grayramp,
+  XStandardColormap	*ccube,
+  int			actual,
+  DPSTextProc		textProc,
+  DPSErrorProc		errorProc,
+  DPSSpace		space)
+{
+  XDPSPrivContext xwh = XDPSCreatePrivContextRec (dpy, draw, gc, x, y,
+  						  eventmask, grayramp,
+						  ccube, actual, true);
+  DPSContext newCtxt;
+  
+  if (xwh == NIL)
+    return (NIL);
+  else
+    {
+    newCtxt = DPSCreateContext ((char *) xwh, textProc, errorProc, space);
+    if (newCtxt == NIL)
+      free ((char *) xwh);
+    return (newCtxt);
+    }
+}
+
+
+DPSContext XDPSContextFromSharedID (dpy, cid, textProc, errorProc)
+  Display	  *dpy;
+  ContextPSID	  cid;
+  DPSTextProc	  textProc;
+  DPSErrorProc	  errorProc;
+{
+  DPSPrivContext	c;
+  DPSPrivSpace		s; 
+  ContextXID		cxid;
+  SpaceXID		sxid;
+  XDPSPrivContext	xwh;
+
+  if (DPSInitialize () != 0)
+    return (NIL);
+
+  c = FindPrivContext (dpy, cid);
+  if (c != NIL)
+    return ((DPSContext) c);
+
+  xwh = XDPSCreatePrivContextRec (dpy, 0, 0, 0, 0, 0, NIL, NIL, 0, false);
+  if (xwh == NIL)
+    return (NIL);
+  else if (XDPSLIDFromContext (dpy, cid, &cxid, &sxid) != 1)
+    {
+    free ((char *) xwh);
+    return (NIL);
+    }
+  xwh->cxid = cxid;
+
+  if (spaceProcs == NIL)
+    {
+    spaceProcs = (DPSSpaceProcs) DPScalloc (sizeof (DPSSpaceProcsRec), 1);
+    DPSInitCommonSpaceProcs(spaceProcs);
+    }
+
+  s = spaces;
+  while (s != NIL)
+    if ((SpaceXID)s->sid == sxid && ((XDPSPrivContext) s->wh)->dpy == dpy)
+      break;
+    else
+      s = s->next;
+
+  if (s == NIL)	  /* Create new space record. */
+    {
+    s = (DPSPrivSpace) DPScalloc (sizeof (DPSPrivSpaceRec), 1);
+    s->procs = spaceProcs;
+    s->lastNameIndex = -1;
+    s->sid = sxid;
+    s->wh = (char *) xwh;
+    s->creator = false;
+    s->next = spaces;
+    spaces = s;
+    }
+
+  c = (DPSPrivContext) DPScalloc (sizeof (DPSPrivContextRec), 1);
+  c->space = (DPSSpace) s;
+  c->procs = XDPSconvProcs;
+  c->textProc = textProc;
+  c->errorProc = errorProc;
+  c->programEncoding = DPSDefaultProgramEncoding;
+  c->nameEncoding = dps_strings;
+  c->next = s->firstContext;
+  s->firstContext = c;
+  c->lastNameIndex = s->lastNameIndex;
+  c->cid = cid;
+  c->numstringOffsets = NULL;
+  c->creator = false;
+  c->zombie = false;
+  c->numFormat = XDPSNumFormat (dpy);
+  c->wh = (char *) xwh;
+  
+  xwh->ctxt = (DPSContext) c;
+
+  return ((DPSContext) c);
+}
+
+
+void DPSChangeEncoding (ctxt, newProgEncoding, newNameEncoding)
+  DPSContext	     ctxt;
+  DPSProgramEncoding newProgEncoding;
+  DPSNameEncoding    newNameEncoding;
+{
+  if (ctxt->programEncoding != newProgEncoding ||
+      ctxt->nameEncoding != newNameEncoding)
+    {
+      DPSPrivContext cc = (DPSPrivContext) ctxt;
+      DPSPrivSpace   ss = (DPSPrivSpace) (cc->space);
+      
+      if ((!cc->creator || !ss->creator) && newNameEncoding != dps_strings)
+	{
+	DPSSafeSetLastNameIndex(ctxt);
+	if (cc->errorProc != NIL)
+	  (*cc->errorProc) (ctxt, dps_err_encodingCheck,
+			    (unsigned long) newNameEncoding,
+			    (unsigned long) newProgEncoding);
+	return;
+	}
+      if (ctxt->procs == textCtxProcs)
+        {
+        ctxt->programEncoding = newProgEncoding;
+        ctxt->nameEncoding = newNameEncoding;
+        }
+      else
+        XDPSSetContextEncoding (ctxt, newProgEncoding, newNameEncoding);
+    }
+}
+
+
+DPSSpace XDPSSpaceFromSharedID (dpy, sid)
+  Display	*dpy;
+  SpaceXID	sid;
+{
+  DPSPrivSpace		s;
+  XDPSPrivContext	xwh;
+
+  if (DPSInitialize () != 0)
+    return (NIL);
+
+  if (spaceProcs == NIL)
+    {
+    spaceProcs = (DPSSpaceProcs) DPScalloc (sizeof (DPSSpaceProcsRec), 1);
+    DPSInitCommonSpaceProcs(spaceProcs);
+    }
+
+  s = spaces;
+  while (s != NIL)
+    if ((SpaceXID)s->sid == sid && ((XDPSPrivContext) s->wh)->dpy == dpy)
+      break;
+    else
+      s = s->next;
+
+  if (s == NIL)	  /* Create new space record. */
+    {
+    xwh = XDPSCreatePrivContextRec (dpy, 0, 0, 0, 0, 0, NIL, NIL, 0, false);
+    if (xwh == NIL)
+      return (NIL);
+
+    s = (DPSPrivSpace) DPScalloc (sizeof (DPSPrivSpaceRec), 1);
+    s->procs = spaceProcs;
+    s->lastNameIndex = -1;
+    s->sid = sid;
+    s->wh = (char *) xwh;
+    s->creator = false;
+    s->next = spaces;
+    spaces = s;
+    }
+
+  return ((DPSSpace) s);
+}
+
+
+void XDPSUnfreezeContext (ctxt)
+  DPSContext ctxt;
+{
+  XDPSPrivContext wh = (XDPSPrivContext) (((DPSPrivContext) ctxt)->wh);
+  
+  if (wh != NIL && wh->cxid != 0)
+    XDPSSendUnfreeze (wh->dpy, wh->cxid);
+}
+
+
+ContextXID XDPSXIDFromContext (Pdpy, ctxt)
+  Display    **Pdpy;
+  DPSContext ctxt;
+{
+  XDPSPrivContext  xwh = (XDPSPrivContext) (((DPSPrivContext) ctxt)->wh);
+  
+  if (xwh == NIL || xwh->cxid == 0)
+    {
+    *Pdpy = NULL;
+    return (0);
+    }
+  else
+    {
+    *Pdpy = xwh->dpy;
+    return (xwh->cxid);
+    }
+}
+
+
+SpaceXID XDPSXIDFromSpace (Pdpy, space)
+  Display    **Pdpy;
+  DPSSpace   space;
+{
+  DPSPrivSpace	   ss = (DPSPrivSpace) space;
+  XDPSPrivContext  xwh = (XDPSPrivContext) ss->wh;
+  
+  if (xwh != NIL && xwh->dpy != NULL)
+    {
+    *Pdpy = xwh->dpy;
+    return (ss->sid);
+    }
+  else
+    {
+    *Pdpy = NULL;
+    return (0);
+    }
+}
+
+
+DPSContext XDPSContextFromXID (dpy, cxid)
+  Display    *dpy;
+  ContextXID cxid;
+{
+  DPSPrivContext c;
+  DPSPrivSpace	 ss;
+  
+  for (ss = spaces;  ss != NIL;  ss = ss->next)
+    if (((XDPSPrivContext) ss->wh)->dpy == dpy)
+      for (c = ss->firstContext;  c != NIL;  c = c->next)
+	if (((XDPSPrivContext) c->wh)->cxid == cxid)
+	  return ((DPSContext) c);
+
+  return (NIL);
+}
+
+
+DPSSpace XDPSSpaceFromXID (dpy, sxid)
+  Display    *dpy;
+  SpaceXID   sxid;
+{
+  DPSPrivSpace  ss;
+  
+  for (ss = spaces;  ss != NIL;  ss = ss->next)
+    if ((SpaceXID)ss->sid == sxid && ((XDPSPrivContext) ss->wh)->dpy == dpy)
+      return ((DPSSpace) ss);
+
+  return (NIL);
+}
+
+
+XDPSStatusProc XDPSRegisterStatusProc (ctxt, statusProc)
+  DPSContext	 ctxt;
+  XDPSStatusProc statusProc;
+{
+  DPSPrivContext c = (DPSPrivContext) ctxt;
+  XDPSStatusProc old = c->statusProc;
+  
+  if (c->wh != NIL) c->statusProc = statusProc;
+  return old;
+}
+
+
+XDPSReadyProc XDPSRegisterReadyProc (ctxt, readyProc)
+  DPSContext	 ctxt;
+  XDPSReadyProc readyProc;
+{
+  DPSPrivContext c = (DPSPrivContext) ctxt;
+  XDPSReadyProc old = c->readyProc;
+  
+  if (c->wh != NIL) c->readyProc = readyProc;
+  return old;
+}
+
+
+void XDPSSetStatusMask(ctxt, enableMask, disableMask, nextMask)
+  DPSContext ctxt;
+  unsigned long enableMask, disableMask, nextMask;
+{
+  XDPSPrivContext xwh = (XDPSPrivContext) (((DPSPrivContext) ctxt)->wh);
+  
+  if (xwh != NIL && xwh->cxid != 0)
+    XDPSLSetStatusMask(xwh->dpy, xwh->cxid, enableMask, disableMask, nextMask);
+}
+
+
+int XDPSGetContextStatus(ctxt)
+  DPSContext ctxt;
+{
+  DPSPrivContext  c = (DPSPrivContext) ctxt;
+  XDPSPrivContext xwh = (XDPSPrivContext) c->wh;
+  
+  if (xwh != NIL && xwh->cxid != 0)
+    return (XDPSLGetStatus(xwh->dpy, xwh->cxid));
+  else
+    return (0);
+}
+
+void XDPSNotifyWhenReady(ctxt, i0, i1, i2, i3)
+    DPSContext ctxt;
+    int i0, i1, i2, i3;
+{
+    DPSPrivContext  c = (DPSPrivContext) ctxt;
+    XDPSPrivContext xwh = (XDPSPrivContext) c->wh;
+    int i[4];
+
+    i[0] = i0;
+    i[1] = i1;
+    i[2] = i2;
+    i[3] = i3;
+    
+    XDPSLNotifyWhenReady(xwh->dpy, xwh->cxid, i);
+}
+
+void XDPSStatusEventHandler (e)
+  XDPSLStatusEvent *e;
+{
+  DPSPrivContext  c = (DPSPrivContext) XDPSContextFromXID(e->display, e->cxid);
+  
+  if (c == NIL)
+    return;
+  
+  c->statusFromEvent = e->status;
+  if (e->status == PSZOMBIE)
+    {
+    c->zombie = true;
+    if (c->resultTable != NIL)  /* Currently waiting for results */
+      XDPSQuitBlocking = true;
+    }
+  
+  if (c->statusProc != NIL)
+    (*(c->statusProc)) ((DPSContext) c, e->status);
+}
+
+void XDPSReadyEventHandler (e)
+  XDPSLReadyEvent *e;
+{
+  DPSPrivContext  c = (DPSPrivContext) XDPSContextFromXID(e->display, e->cxid);
+  
+  if (c == NIL)
+    return;
+  
+  if (c->readyProc != NIL)
+    (*(c->readyProc)) ((DPSContext) c, e->val);
+}
+
+
+
+void DPSWarnProc(
+    DPSContext ctxt,
+    char *msg)
+{
+    DPSErrorProc ep;
+
+    if (DPSInitialize() != 0) return;
+    ep = DPSGetCurrentErrorBackstop();
+    if (ep == NULL) ep = DPSDefaultErrorProc;
+    (*ep)(ctxt, dps_err_warning, (long unsigned int)msg, 0);
+}
+
+void DPSFatalProc(
+    DPSContext ctxt,
+    char *msg)
+{
+    DPSErrorProc ep;
+
+    if (DPSInitialize() != 0) return;
+    ep = DPSGetCurrentErrorBackstop();
+    if (ep == NULL) ep = DPSDefaultErrorProc;
+    (*ep)(ctxt, dps_err_fatal, (long unsigned int)msg, 0);
+}
+
+void DPSCantHappen(void)
+{
+  static int locked = 0;
+  char *msg = "assertion failure or DPSCantHappen";
+  if (locked > 0) abort();
+  ++locked;
+  DPSFatalProc((DPSContext)NULL, msg);
+  /* Fatal proc shouldn't return, but client can override and do anything. */
+  --locked;
+}
+
+
+/* Procedures for delayed event dispatching */
+
+DPSEventDelivery XDPSSetEventDelivery(
+    Display *dpy,
+    DPSEventDelivery newMode)
+{
+    Bool old = XDPSLGetPassEventsFlag(dpy);
+
+    switch (newMode) {
+	case dps_event_pass_through:
+	    XDPSLSetPassEventsFlag(dpy, True);
+	    break;
+	case dps_event_internal_dispatch:
+	    XDPSLSetPassEventsFlag(dpy, False);
+	    break;
+	default:
+	    break;
+    }
+
+    if (old) return dps_event_pass_through;
+    else return dps_event_internal_dispatch;
+}
+
+Bool XDPSIsStatusEvent(
+    XEvent *event,
+    DPSContext *ctxt,
+    int *status)
+{
+    Display *d = event->xany.display;
+    XExtCodes *c = XDPSLGetCodes(d);
+    XDPSLStatusEvent *se = (XDPSLStatusEvent *) event;
+
+    if (c == NULL) return False;	/* Not inited on that display;
+					   must be False */
+
+    if (!c->first_event)		/* Check CSDPS first */
+        {
+	if (XDPSLGetCSDPSFakeEventType(d, event) == csdps_status)
+	    {				/* Check CSDPS first */
+	    XDPSLGetCSDPSStatus(d, event, (void **)ctxt, status);
+	    return True;
+	    }
+	else
+	    return False;
+	}
+
+    if (event->type != c->first_event + PSEVENTSTATUS) return False;
+
+    if (ctxt != NULL) *ctxt = XDPSContextFromXID(d, se->cxid);
+    if (status != NULL) *status = se->status;
+    return True;
+}
+
+Bool XDPSIsOutputEvent(
+    XEvent *event)
+{
+    Display *d = event->xany.display;
+    XExtCodes *c = XDPSLGetCodes(d);
+    CSDPSFakeEventTypes t;
+
+    if (c == NULL) return False;	/* Not inited on that display;
+					   must be False */
+
+    if (!c->first_event)		/* Check CSDPS first */
+        {
+	if ((t = XDPSLGetCSDPSFakeEventType(d, event)) == csdps_output
+	  || t == csdps_output_with_len)
+	    return True;
+	else
+	    return False;
+        }
+
+    return event->type == c->first_event + PSEVENTOUTPUT;
+}
+
+Bool XDPSIsDPSEvent(
+    XEvent *event)
+{
+    Display *d = event->xany.display;
+    XExtCodes *c = XDPSLGetCodes(d);
+
+    if (c == NULL) return False;	/* Not inited on that display;
+					   must be False */
+
+    if (!c->first_event)		/* Check CSDPS first */
+        {
+	if (XDPSLGetCSDPSFakeEventType(d, event) != csdps_not)
+	    return True;
+	else
+	    return False;
+	}
+
+    return event->type >= c->first_event &&
+	   event->type <  c->first_event + NPSEVENTS;
+}
+
+Bool XDPSDispatchEvent(
+    XEvent *event)
+{
+    Display *d = event->xany.display;
+    XExtCodes *c = XDPSLGetCodes(d);
+    CSDPSFakeEventTypes t;
+
+    if (c == NULL) return False;	/* Not inited on that display;
+					   must be False */
+
+    if (!c->first_event)		/* Check CSDPS first */
+        {
+	if ((t = XDPSLGetCSDPSFakeEventType(d, event)) != csdps_not) 
+	    return(XDPSLDispatchCSDPSFakeEvent(d, event, t));
+	else
+	    return False;
+        }
+
+    if (event->type == c->first_event + PSEVENTSTATUS) {
+	XDPSLCallStatusEventHandler(d, event);
+    } else if (event->type == c->first_event + PSEVENTOUTPUT) {
+	XDPSLCallOutputEventHandler(d, event);
+    } else if (event->type == c->first_event + PSEVENTREADY) {
+	XDPSLCallReadyEventHandler(d, event);
+    } else return False;
+    return True;
+}
+
+/* L2-DPS/PROTO 9 addition */
+Bool XDPSIsReadyEvent(
+    XEvent *event,
+    DPSContext *ctxt,
+    int *val)
+{
+    Display *d = event->xany.display;
+    XExtCodes *c = XDPSLGetCodes(d);
+    XDPSLReadyEvent *re = (XDPSLReadyEvent *) event;
+
+    if (c == NULL) return False;        /* Not inited on that display;
+                                           must be False */
+
+    if (!c->first_event)		/* Check CSDPS first */
+        {
+	if (XDPSLGetCSDPSFakeEventType(d, event) == csdps_ready)
+	    {
+	    XDPSLGetCSDPSReady(d, event, (void **)ctxt, val);
+	    return True;
+	    }
+	else
+	    return False;
+	}
+
+    if (event->type != c->first_event + PSEVENTREADY) return False;
+
+    if (ctxt != NULL) *ctxt = XDPSContextFromXID(d, re->cxid);
+    if (val != NULL) {
+        val[0] = re->val[0];
+        val[1] = re->val[1];
+        val[2] = re->val[2];
+        val[4] = re->val[3];
+    }
+    return True;
+}
+
+int XDPSGetProtocolVersion(
+    Display *dpy)
+{
+    return XDPSLGetVersion(dpy);
+}