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

79 files changed, 22673 insertions, 0 deletions

diff --git a/nx-X11/lib/dps/DPSCAP.h b/nx-X11/lib/dps/DPSCAP.h
new file mode 100644
index 000000000..cb36016c2
--- /dev/null
+++ b/nx-X11/lib/dps/DPSCAP.h
@@ -0,0 +1,77 @@
+/*
+ * DPSCAP.h -- CAP constants, analogous to X.h
+ *  		 
+ * (c) Copyright 1990-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
+ */
+
+#ifndef _DPSCAP_h
+#define _DPSCAP_h
+
+/* DPSCAPConnSetup functional hint flags */
+
+#define DPSCAPNONEFLAG		0x0000
+
+/* Values for DPSCAPNotify */
+
+#define DPSCAPNOTE_GRAB		0
+#define DPSCAPNOTE_UNGRAB	1
+#define DPSCAPNOTE_FREEGC	2
+#define DPSCAPNOTE_SYNC		3
+#define DPSCAPNOTE_PAUSE	4
+
+/* Minor opcodes for CAP errors */
+
+#define DPSCAPDEADLOCK		0
+
+/* Pnames for ClientMessage type atoms */
+
+
+#define DPSCAP_TYPE_PSOUTPUT	 "_ADOBE_DPSCAP_TYPE_PSOUTPUT"
+#define DPSCAP_TYPE_PSOUTPUT_LEN "_ADOBE_DPSCAP_TYPE_PSOUTPUT_WITH_LEN"
+#define DPSCAP_TYPE_PSSTATUS	 "_ADOBE_DPSCAP_TYPE_PSSTATUS"
+#define DPSCAP_TYPE_NOOP	 "_ADOBE_DPSCAP_TYPE_NOOP"
+#define DPSCAP_TYPE_SYNC	 "_ADOBE_DPSCAP_TYPE_SYNC"
+#define DPSCAP_TYPE_XERROR	 "_ADOBE_DPSCAP_TYPE_XERROR"
+#define DPSCAP_TYPE_PSREADY	 "_ADOBE_DPSCAP_TYPE_PSREADY"
+#define DPSCAP_TYPE_RESUME       "_ADOBE_DPSCAP_TYPE_RESUME"
+
+#define DPSCAP_ATOMS		8
+
+/* Translate argument names for X_CAPSetArg, see dpsNXargs.h */
+
+#define DPSCAP_ARG_SMALLFONTS	1
+#define DPSCAP_ARG_PIXMEM	2
+
+#endif /* _DPSCAP_h */
diff --git a/nx-X11/lib/dps/DPSCAPClient.h b/nx-X11/lib/dps/DPSCAPClient.h
new file mode 100644
index 000000000..803acf3ed
--- /dev/null
+++ b/nx-X11/lib/dps/DPSCAPClient.h
@@ -0,0 +1,139 @@
+/*
+ * DPSCAPClient.h -- DPSCAP client definitions
+ *		 
+ * (c) Copyright 1990-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
+ */
+
+#ifndef DPSCAPCLIENT_H
+#define DPSCAPCLIENT_H 1
+
+#include "DPSCAP.h"
+#include "DPSCAPproto.h"
+#include <X11/Xlib.h>
+#ifndef Xmalloc
+#endif
+#include <DPS/XDPSlib.h>
+
+/* === DEFINES === */
+
+#ifndef _NFILE
+#define _NFILE 128
+#endif
+
+#define DPSCAPFAILED		-1
+#define DPSCAPSUCCESS		0
+
+#define DPSGCBITS \
+(GCPlaneMask|GCSubwindowMode|GCClipXOrigin|GCClipYOrigin|GCClipMask)
+
+/* === TYPEDEFS === */
+
+typedef enum {
+  dpscap_nopad,
+  dpscap_pad,
+  dpscap_insert,
+  dpscap_append
+} DPSCAPIOFlags;
+
+typedef struct _t_DPSCAPData {
+  struct _t_DPSCAPData *next;
+  Display *dpy;
+  /* shadow connection to agent */
+  Display *agent;		/* Dummy display structure is agent */
+  char *otherConnID;		/* VMS AST? */
+  XExtCodes *codes;
+  XExtData *extData;		/* Back pointer for clearing private */
+  Atom typePSOutput;
+  Atom typePSOutputWithLen;
+  Atom typePSStatus;
+  Atom typeNoop;
+  Atom typeSync;
+  Atom typeXError;
+  Atom typePSReady;             /* L2-DPS/PROTO 9 addition */
+  Atom typeResume;
+  unsigned long saveseq;
+  int dpscapVersion;
+  Window agentWindow;
+} DPSCAPDataRec, *DPSCAPData;
+
+typedef struct {
+  struct _t_DPSCAPData *head;	/* list of active agent connections */
+  char *defaultAgentName;	/* settable agent name */
+  char *map[_NFILE];		/* map DPY_NUMBER to agent name */
+} DPSCAPGlobalsRec, *DPSCAPGlobals;
+
+/* === GLOBALS === */
+
+extern DPSCAPGlobals gCSDPS;
+
+/* === PUBLIC PROCS === */
+
+extern int CSDPSInit(Display * /* dpy */, int * /* numberType */, char ** /* floatingName */);
+
+extern XExtData **CSDPSHeadOfDpyExt(Display * /* dpy */);
+
+/* === SUPPORT PROCS === */
+
+extern void DPSCAPChangeGC(Display * /* agent */, GC /* gc */, unsigned long /* valuemask */, XGCValues * /* values */);
+
+extern DPSCAPData DPSCAPCreate(Display * /* dpy */, Display * /* agent */);
+
+extern int DPSCAPDestroy(XExtData * /* extData */);
+
+extern XExtData * DPSCAPOpenAgent(Display * /* dpy */, char * /* trueDisplayName */);
+
+extern void DPSCAPRead(DPSCAPData /* my */, char * /* buf */, unsigned /* len */, DPSCAPIOFlags /* includePad */);
+
+extern void DPSCAPStartUp(void);
+
+extern void DPSCAPWrite(Display * /* my */, char * /* buf */, unsigned /* len */, DPSCAPIOFlags /* writePad */, DPSCAPIOFlags /* bufMode */);
+
+/* ext callback hooks */
+
+extern int DPSCAPCloseDisplayProc(Display * /* dpy */, XExtCodes * /* codes */);
+
+extern int DPSCAPGrabServerProc(Display * /* dpy */, XExtCodes * /* codes */);
+
+extern int DPSCAPUngrabServerProc(Display * /* dpy */, XExtCodes * /* codes */);
+
+extern void DPSCAPCloseAgent(Display * /* agent */);
+
+extern int DPSCAPCopyGCProc(Display * /* dpy */, GC /* gc */, XExtCodes * /* codes */);
+
+extern int DPSCAPFreeGCProc(Display * /* pdpy */, GC /* gc */, XExtCodes * /* codes */);
+
+extern int DPSCAPFlushGCProc(Display * /* dpy */, GC /* gc */, XExtCodes * /* codes */);
+
+#endif /* DPSCAPCLIENT_H */
diff --git a/nx-X11/lib/dps/DPSCAPproto.h b/nx-X11/lib/dps/DPSCAPproto.h
new file mode 100644
index 000000000..e35487b2b
--- /dev/null
+++ b/nx-X11/lib/dps/DPSCAPproto.h
@@ -0,0 +1,180 @@
+/*
+ * DPSCAPproto.h -- CAP requests constants and alignment values,
+ *  		  analgous to Xproto.h
+ * 		 
+ * (c) Copyright 1991-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
+ */
+
+
+#ifndef _DPSCAPproto_h
+#define _DPSCAPproto_h
+
+/* === DEFINITIONS === */
+
+#define DPSCAPPROTOVERSION	3
+#define DPSCAPPROTOVERSION_2	2
+
+#define CSDPSPORT		6016 /* add agent instance number */
+#define DPS_NX_SERV_NAME	"dpsnx" /* name to look up in /etc/services */
+
+/* Request Opcodes */
+
+#define DPSCAPOPCODEBASE	126
+#define DPSXOPCODEBASE		125
+
+#define X_CAPFlushAgent		1
+#define X_CAPNotify		2
+#define X_CAPSetArg		3
+
+/* === REQUESTS === */
+
+typedef struct _CAPConnSetup {
+    BYTE byteorder;		/* #x42 MSB, #x6C LSB */
+    BYTE dpscapVersion;		/* proto version of connecting client */
+    CARD16 flags B16;		/* functional hint flags */
+    CARD32 libraryversion B32;	/* as for XPSInit */
+    CARD16 authProtoNameLength B16;	/* in bytes */
+    CARD16 authProtoDataLength B16;	/* in bytes */
+    CARD16 displayStringLength B16;	/* in bytes */
+    CARD16 nodeStringLength B16;	/* in bytes */
+    CARD16 transportStringLength B16;	/* in bytes */
+    CARD16 display B16;		/* Display number */
+    CARD16 screen B16;		/* Screen number */
+    CARD16 reserved B16;
+    CARD32 clientWindow B32;	/* window for ClientMessage */
+} xCAPConnSetupReq;
+#define sz_xCAPConnSetupReq	28
+
+typedef struct {
+    BYTE success;
+    BYTE reasonLength;
+    CARD16 additionalLength B16;
+} xCAPConnReplyPrefix;
+#define sz_xCAPConnReplyPrefix	4
+
+typedef struct _CAPConnFailed {
+    BYTE success;		/* failed = 0, success = 1 */
+    BYTE reasonLength;		/* in bytes if failed, ignore if success */
+    CARD16 additionalLength B16;/* quadbytes ADDITIONAL length */
+    CARD32 serverVersion B32;	/* as for XPSInit */
+    CARD8 dpscapVersion;	/* proto version of agent */
+    CARD8 pad;
+    CARD16 reserved B16;
+} xCAPConnFailed;
+#define sz_xCAPConnFailed	12
+
+typedef struct _CAPConnSuccess {
+    BYTE success;		/* failed = 0, success = 1 */
+    BYTE reasonLength;		/* in bytes if failed, ignore if success */
+    CARD16 additionalLength B16;/* quadbytes ADDITIONAL length */
+    CARD32 serverVersion B32;	/* as for XPSInit */
+    CARD8 dpscapVersion;	/* proto version of agent */
+    CARD8 reserved;
+    CARD16 flagsUsed B16;	/* mask of functional hint flags used */
+    CARD32 preferredNumberFormat B32;	/* as for XPSInit */
+    CARD32 floatingNameLength B32;	/* as for XPSInit */
+    CARD32 agentWindow B32;     /* client sends messages to this window */
+} xCAPConnSuccess;
+#define sz_xCAPConnSuccess	24
+
+typedef struct _CAPFlushAgent {
+    CARD8 reqType;		/* always DPSCAPOPCODEBASE */
+    CARD8 type;			/* always X_CAPFlushAgent */
+    CARD16 length B16;		/* quadbyte length of request */
+    CARD32 cxid B32;		/* context XID */
+} xCAPFlushAgentReq;
+#define sz_xCAPFlushAgentReq	8
+
+typedef struct _CAPNotify {
+    CARD8 reqType;		/* always DPSCAPOPCODEBASE */
+    CARD8 type;			/* always X_CAPNotify */
+    CARD16 length B16;		/* quadbyte length of request */
+    CARD32 cxid B32;		/* context XID */
+    CARD32 notification B32;	/* notify code */
+    CARD32 data B32;		/* data word */
+    CARD32 extra B32;		/* extra word */
+} xCAPNotifyReq;
+#define sz_xCAPNotifyReq	20
+
+typedef struct _CAPSetArg {
+    CARD8 reqType;		/* always DPSCAPOPCODEBASE */
+    CARD8 type;			/* always X_CAPNotify */
+    CARD16 length B16;		/* quadbyte length of request */
+    CARD32 arg B32;		/* argument type */
+    CARD32 val B32;		/* value */
+} xCAPSetArgReq;
+#define sz_xCAPSetArgReq	12
+
+/* === ERRORS === */
+
+typedef struct _DPSCAPError {
+    BYTE type;			/* always 0 */
+    BYTE errorCode;		/* always 255 */
+    CARD16 sequenceNumber B16;	/* the nth request from this client */
+    CARD8 subLength;		/* how much of 21 bytes are used */
+    CARD8 unused;
+    CARD16 reserved B16;
+    CARD16 minorOpcode B16;
+    CARD8 majorOpcode;		/* always 0 */
+    BYTE subData1;
+    CARD32 subData2 B32;
+    CARD32 subData3 B32;
+    CARD32 subData4 B32;
+    CARD32 subData5 B32;
+    CARD32 subData6 B32;
+    CARD32 subData7 B32;
+} xDPSCAPError;
+
+/* === EVENTS === */
+
+/* Events sent from agent to client via XSendEvent */
+
+#define DPSCAP_OUTPUT_OVERHEAD		4
+#define DPSCAP_BYTESPEROUTPUTEVENT	(20 - DPSCAP_OUTPUT_OVERHEAD)
+#define DPSCAP_DATA_LEN			(DPSCAP_BYTESPEROUTPUTEVENT-1)
+
+typedef struct {
+    CARD32 cxid;
+    CARD8 data[DPSCAP_BYTESPEROUTPUTEVENT];
+} DPSCAPOutputEvent;
+
+typedef struct {
+    BYTE status;
+    BYTE unused;
+    CARD16 sequenceNumber;
+    CARD32 cxid;
+} DPSCAPStatusEvent;
+
+#endif /* _DPSCAPproto_h */
diff --git a/nx-X11/lib/dps/Imakefile b/nx-X11/lib/dps/Imakefile
new file mode 100644
index 000000000..119b3429e
--- /dev/null
+++ b/nx-X11/lib/dps/Imakefile
@@ -0,0 +1,265 @@
+XCOMM $XFree86: xc/lib/dps/Imakefile,v 1.16tsi Exp $
+
+#define DoNormalLib NormalLibDps
+#define DoSharedLib SharedLibDps
+#define DoExtraLib SharedLibDps
+#define DoDebugLib DebugLibDps
+#define DoProfileLib ProfileLibDps
+#define LibName dps
+#define SoRev SODPSREV
+#define IncSubdir DPS
+
+#ifdef SharedDPSReqs
+REQUIREDLIBS = SharedDPSReqs
+#endif
+
+XCOMM  The Client Library uses definitions just like Xlib for network
+XCOMM  capabilities, such as TCPCONN, UNIXCONN, and DNETCONN.  See
+XCOMM  csconndi.c and csopendi.c
+
+XCOMM The connection code should be rewritten to use xtrans.  The STREAMSCONN
+XCOMM code here needs work.  For now force ConnectionFlags to be
+XCOMM  -DTCPCONN -DUNIXCONN
+
+#undef ConnectionFlags
+#define ConnectionFlags -DTCPCONN -DUNIXCONN
+
+        DEFINES = -DXDPS -DCSDPS ConnectionFlags
+            CAT = cat
+            SED = sed
+            AWK = awk
+           SORT = sort
+         PSWRAP = PsWrap
+
+COMMONOBJECTFILES = \
+	dpsclient.o\
+	dpsprintf.o\
+	dpsexcept.o\
+	dpsdict.o\
+	dpsabbrev.o
+
+COMMONSOURCEFILES = \
+	dpsclient.c\
+	dpsprintf.c\
+	dpsexcept.c\
+	dpsdict.c\
+	dpsabbrev.c
+
+XOBJECTFILES = \
+	dpsXclient.o\
+	dpssysnames.o\
+	dpsXpriv.o\
+	XDPS.o\
+	dpsXtdisp.o\
+	dpsXcmu.o
+
+XSOURCEFILES = \
+	dpsXclient.c\
+	dpssysnames.c\
+	dpsXpriv.c\
+	XDPS.c\
+	dpsXtdisp.c\
+	dpsXcmu.c
+
+XCSDPSOBJECTFILES = \
+	cslibext.o\
+	csopendi.o\
+	csconndi.o\
+	csstartNX.o\
+	csfindNX.o\
+	cslibint.o
+
+XCSDPSSOURCEFILES = \
+	cslibext.c\
+	csopendi.c\
+	csconndi.c\
+	csstartNX.c\
+	csfindNX.c\
+	cslibint.c
+
+DPSOPSOBJECTS = \
+    dpsclrops.o\
+    dpsctrlops.o\
+    dpsctxtops.o\
+    dpsdataops.o\
+    dpsfontops.o\
+    dpsgsttops.o\
+    dpsioops.o\
+    dpsmathops.o\
+    dpsmtrxops.o\
+    dpsmiscops.o\
+    dpspntops.o\
+    dpspathops.o\
+    dpssysops.o\
+    dpswinops.o\
+    dpsopstack.o\
+    dpsXops.o\
+    dpsl2ops.o
+
+PSOPSOBJECTS = \
+    psclrops.o\
+    psctrlops.o\
+    psctxtops.o\
+    psdataops.o\
+    psfontops.o\
+    psgsttops.o\
+    psioops.o\
+    psmathops.o\
+    psmtrxops.o\
+    psmiscops.o\
+    pspntops.o\
+    pspathops.o\
+    pssysops.o\
+    pswinops.o\
+    psopstack.o\
+    psXops.o\
+    psl2ops.o
+
+DPSOPSHEADERFILES = \
+    dpsclrops.h\
+    dpsctrlops.h\
+    dpsctxtops.h\
+    dpsdataops.h\
+    dpsfontops.h\
+    dpsgsttops.h\
+    dpsioops.h\
+    dpsmathops.h\
+    dpsmtrxops.h\
+    dpsmiscops.h\
+    dpsopstack.h\
+    dpspntops.h\
+    dpspathops.h\
+    dpssysops.h\
+    dpswinops.h\
+    dpsXops.h\
+    dpsl2ops.h
+
+PSOPSHEADERFILES = \
+    psclrops.h\
+    psctrlops.h\
+    psctxtops.h\
+    psdataops.h\
+    psfontops.h\
+    psgsttops.h\
+    psioops.h\
+    psmathops.h\
+    psmtrxops.h\
+    psmiscops.h\
+    pspntops.h\
+    pspathops.h\
+    pssysops.h\
+    pswinops.h\
+    psopstack.h\
+    psXops.h\
+    psl2ops.h
+
+DPSOPSCFILES = \
+    dpsclrops.c\
+    dpsctrlops.c\
+    dpsctxtops.c\
+    dpsdataops.c\
+    dpsfontops.c\
+    dpsgsttops.c\
+    dpsioops.c\
+    dpsmathops.c\
+    dpsmtrxops.c\
+    dpsmiscops.c\
+    dpsopstack.c\
+    dpspntops.c\
+    dpspathops.c\
+    dpssysops.c\
+    dpswinops.c\
+    dpsXops.c\
+    dpsl2ops.c
+
+PSOPSCFILES = \
+    psclrops.c\
+    psctrlops.c\
+    psctxtops.c\
+    psdataops.c\
+    psfontops.c\
+    psgsttops.c\
+    psioops.c\
+    psmathops.c\
+    psmtrxops.c\
+    psmiscops.c\
+    pspntops.c\
+    pspathops.c\
+    pssysops.c\
+    pswinops.c\
+    psopstack.c\
+    psXops.c\
+    psl2ops.c
+
+/*
+ * hv: HEADERS must be here, otherwise IncSubdir-triggered BuildIncludes
+ * will fail on systems without ln cmd
+ */
+HEADERS = psops.h dpsops.h
+
+all:: $(HEADERS)
+
+includes:: $(DPSOPSCFILES) $(PSOPSCFILES) $(HEADERS)
+
+$(DPSOPSCFILES) $(PSOPSCFILES): HostProgramTargetName($(PSWRAP))
+
+SRCS = \
+	${COMMONSOURCEFILES} \
+	${XSOURCEFILES} \
+	${XCSDPSSOURCEFILES} \
+	${DPSOPSCFILES} \
+	${PSOPSCFILES}
+
+OBJS = \
+	${COMMONOBJECTFILES} \
+	${XOBJECTFILES} \
+	${XCSDPSOBJECTFILES} \
+	${DPSOPSOBJECTS} \
+	${PSOPSOBJECTS}
+
+DERIVED_FILES = $(DPSOPSHEADERFILES) $(PSOPSHEADERFILES) \
+		$(DPSOPSCFILES) $(PSOPSCFILES)
+
+#include <Library.tmpl>
+
+.SUFFIXES: .psw .h
+
+.psw.c : HostProgramTargetName($(PSWRAP))
+	RunProgram(PSWRAP,-a -o $*.c -h $*.h $<)
+
+.psw.h : HostProgramTargetName($(PSWRAP))
+	RunProgram(PSWRAP,-a -h $*.h $< > /dev/null)
+
+HostProgramTargetName($(PSWRAP)):
+	@echo "checking $@ over in $(PSWRAPSRC) first..."; \
+	test -d $(PSWRAPSRC) && cd $(PSWRAPSRC) && $(MAKE) pswraponly; \
+	echo "okay, continuing in $(CURRENT_DIR)"
+
+includes :: $(HEADERS)
+depend :: $(DPSOPSCFILES) $(PSOPSCFILES)
+
+psops.h : $(PSOPSHEADERFILES)
+	RemoveFile($@)
+	${CAT} $(PSOPSHEADERFILES) |\
+	    ${SED} -e '/^$$/D' -e '/#/D' -e '/^\//D'\
+		-e '/^   gener/D' -e '/^.\//D' |\
+	    ${SORT} > .sort
+	${AWK} '/;/ {print; printf("\n");}' .sort > .ttt
+	${CAT} psname.txt header.txt psifdef.txt .ttt psendif.txt > psops.h
+	RemoveFiles(.sort .ttt .attt)
+
+dpsops.h : psops.h $(DPSOPSHEADERFILES)
+	RemoveFile($@)
+	${CAT} $(DPSOPSHEADERFILES) |\
+	    ${SED} -e '/^$$/D' -e '/#/D' -e '/^\//D'\
+		-e '/^   gener/D' -e '/^.\//D' |\
+	    ${SORT} > .sort
+	${AWK} '/;/ {print; printf("\n");}' .sort > .ttt
+	${CAT} dpsname.txt header.txt dpsifdef.txt .ttt dpsendif.txt > dpsops.h
+	RemoveFiles(.sort .ttt .attt)
+
+clean ::
+	${RM} $(DERIVED_FILES) .sort .ttt .att psops.h dpsops.h *%
+
+DependTarget()
+
diff --git a/nx-X11/lib/dps/XDPS.c b/nx-X11/lib/dps/XDPS.c
new file mode 100644
index 000000000..5b1614e4c
--- /dev/null
+++ b/nx-X11/lib/dps/XDPS.c
@@ -0,0 +1,2235 @@
+/*
+ * XDPS.c -- implementation of low-level Xlib routines for XDPS extension
+ *
+ * (c) Copyright 1989-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: xc/lib/dps/XDPS.c,v 1.4tsi Exp $ */
+
+#define NEED_EVENTS
+#define NEED_REPLIES
+
+#include <stdio.h>
+/* Include this first so that Xasync.h, included from Xlibint.h, can find
+   the definition of NOFILE */
+#include <stdlib.h>
+#include <sys/param.h>
+#include <X11/Xlibint.h>
+#include <X11/Xatom.h>
+#include <X11/Xutil.h>
+
+#include "DPS/XDPS.h"
+#include "DPS/XDPSproto.h"
+#include "DPS/XDPSlib.h"
+#include "DPS/dpsNXargs.h"
+
+#include "cslibint.h"
+#include "dpsassert.h"
+#include "DPSCAPClient.h"
+
+#include "publictypes.h"
+#include "dpsXpriv.h"
+
+/* === DEFINITIONS === */
+
+#ifndef _NFILE
+#define DPSMAXDISPLAYS 128
+#else
+#define DPSMAXDISPLAYS _NFILE
+#endif /* _NFILE */
+
+#define MajorOpCode(dpy)	(Codes[DPY_NUMBER(dpy)] ?		\
+				 Codes[DPY_NUMBER(dpy)]->major_opcode : \
+				 Punt())
+
+#define DPSCAP_INITCTXTS	4  /* per display */
+
+/* === TYPES === */
+
+typedef Status (*PSCMProc)(Display *, XEvent *, xEvent *);
+
+typedef struct {
+    char passEvents;
+    char wrapWaiting;
+    char syncMask;      /* CSDPS only */
+    char debugMask;     /* CSDPS only */
+} DPSDisplayFlags;
+
+/* For now DPSDisplayFlags is no larger than a pointer.  Revisit this if the
+   structure grows. */
+
+typedef int (*GenericProcPtrReturnsInt)(Display *);
+
+typedef struct _t_DPSCAPPausedContextData {
+    struct _t_DPSCAPPausedContextData *next;
+    Bool paused;
+    ContextXID cxid;
+    unsigned int seqnum;
+} DPSCAPPausedContextData;
+
+typedef struct {
+    char showSmallSizes;
+    char pixMem;
+} DPSCAPAgentArgs;
+
+typedef struct {
+    void (*Flush)(Display *);
+    int (*Read)(Display*, char*, long);
+    void (*ReadPad)(Display*, char*, long);
+    Status (*Reply)(Display*, xReply*, int, Bool);
+    void (*Send)(Display*, _Xconst char*, long);
+} XDPSLIOProcs;
+
+/* === GLOBALS === */
+
+/* For debugging, allows client to force the library to use an agent */
+int gForceCSDPS = 0;
+
+/* Force all DPS NX protocol requests to flush if CSDPS */
+int gAutoFlush = 1;
+
+/* Force all NX XDPSLGiveInputs to flush independent of gAutoFlush */
+int gForceFlush = 1;
+
+/* Quick check for any paused contexts */
+int gTotalPaused = 0;
+
+/* === LOCALS === */
+
+/* Common stuff */
+static XExtCodes *Codes[DPSMAXDISPLAYS];
+static int version[DPSMAXDISPLAYS];
+static XDPSLEventHandler StatusProc[DPSMAXDISPLAYS];
+static DPSDisplayFlags displayFlags[DPSMAXDISPLAYS];
+static XDPSLEventHandler TextProc = NULL;
+static XDPSLEventHandler ReadyProc[DPSMAXDISPLAYS]; /* L2-DPS/PROTO 9 */
+static int NumberType[DPSMAXDISPLAYS];  /* Garbage okay after dpy closed */
+static char *FloatingName[DPSMAXDISPLAYS];  /* Garbage okay after dpy closed */
+
+/* CSDPS stuff */
+static Display *ShuntMap[DPSMAXDISPLAYS];
+static PSCMProc ClientMsgProc[DPSMAXDISPLAYS];
+static GenericProcPtrReturnsInt AfterProcs[DPSMAXDISPLAYS];
+static DPSCAPPausedContextData *PausedPerDisplay[DPSMAXDISPLAYS];
+static DPSCAPAgentArgs AgentArgs[DPSMAXDISPLAYS];
+static unsigned int LastXRequest[DPSMAXDISPLAYS];
+static int GCFlushMode[DPSMAXDISPLAYS];
+
+#ifdef VMS
+static Display *dpys[DPSMAXDISPLAYS];
+static nextDpy = 0;
+#endif /* VMS */
+
+static void DPSCAPInitGC(Display *dpy, Display *agent, GC gc);
+static Status DPSCAPClientMessageProc(Display *dpy, XEvent *re, xEvent *event);
+static int DPSCAPAfterProc(Display *xdpy);
+static unsigned int DPSCAPSetPause(Display *xdpy, ContextXID cxid);
+static Bool DPSCAPResumeContext(Display *xdpy, ContextXID cxid);
+static Bool WaitForSyncProc(Display *xdpy, XEvent *event, char *arg);
+
+static XDPSLIOProcs xlProcs = {  /* Use these for DPS/X extension */
+    _XFlush,
+    _XRead,
+    _XReadPad,
+    _XReply,
+    _XSend
+    };
+
+static XDPSLIOProcs nxlProcs = { /* Use these for NX */
+    N_XFlush,
+    N_XRead,
+    N_XReadPad,
+    N_XReply,
+    N_XSend
+    };
+
+/* === MACROS === */
+
+#define IFNXSETCALL(a, x) call = ((a) != (x)) ? &nxlProcs : &xlProcs
+
+/* === PRIVATE PROCS === */
+
+static int Punt(void)
+{
+    DPSFatalProc(NULL, "Extension has not been initialized");
+    exit(1);
+}
+
+#ifdef VMS
+/* This is a terribly inefficient way to find a per-display index, but we
+   need it till we get dpy->fd fixed in VMS%%%%%*/
+static int FindDpyNum(Display *dpy)
+{
+int i;
+for (i=0; dpys[i] != dpy ; i++)
+    {
+    if (i == nextDpy)
+        {
+        dpys[nextDpy++]=dpy;
+        break;
+        }
+    }
+return i;
+}
+#define DPY_NUMBER(dpy)         FindDpyNum(dpy)
+#else /* VMS */
+#define DPY_NUMBER(dpy)		((dpy)->fd)
+#endif /* VMS */
+
+/* === PROCEDURES === */
+
+/* ARGSUSED */
+void
+XDPSLSetTextEventHandler(Display *dpy, XDPSLEventHandler proc)
+{
+    TextProc = proc;
+}
+
+/* ARGSUSED */
+void
+XDPSLCallOutputEventHandler(Display *dpy, XEvent *event)
+{
+    (*TextProc)(event);
+}
+
+void
+XDPSLSetStatusEventHandler(Display *dpy, XDPSLEventHandler proc)
+{
+    StatusProc[DPY_NUMBER(dpy)] = proc;
+}
+
+void
+XDPSLCallStatusEventHandler(Display *dpy, XEvent *event)
+{
+    (*(StatusProc[DPY_NUMBER(dpy)]))(event);
+}
+
+/* Added for L2-DPS/PROTO 9 */
+void
+XDPSLSetReadyEventHandler(Display *dpy, XDPSLEventHandler proc)
+{
+    ReadyProc[DPY_NUMBER(dpy)] = proc;
+}
+
+/* Added for L2-DPS/PROTO 9 */
+void
+XDPSLCallReadyEventHandler(Display *dpy, XEvent *event)
+{
+    (*(ReadyProc[DPY_NUMBER(dpy)]))(event);
+}
+
+/* Added for L2-DPS/PROTO 9 */
+int
+XDPSLGetVersion(Display *dpy)
+{
+    return(version[DPY_NUMBER(dpy)]);
+}
+/* See CSDPS additions for XDPSLSetVersion */
+
+void
+XDPSLInitDisplayFlags(Display *dpy)
+{
+    int d = DPY_NUMBER(dpy);
+    displayFlags[d].wrapWaiting = False;
+
+    /* Instead of explicitly setting the pass-event flag, rely upon the fact
+       that it gets initialized to 0 by the compiler.  This means that you
+       can set the event delivery mode on a display before creating any
+       contexts, which is a Good Thing */
+}
+
+XExtCodes *XDPSLGetCodes(Display *dpy)
+{
+    return Codes[DPY_NUMBER(dpy)];
+}
+
+/* ARGSUSED */
+static int
+CloseDisplayProc(Display *dpy, XExtCodes *codes)
+{
+    /* This proc is for native DPS/X only, not CSDPS */
+    Codes[DPY_NUMBER(dpy)] = NULL;
+    /* Clear list */
+    XDPSPrivZapDpy(dpy);
+#ifdef VMS
+    dpys[DPY_NUMBER(dpy)] = NULL;
+ /*%%%%Temp till we fix dpy->fd*/
+#endif /* VMS */
+    return 0;	/* return-value is ignored */
+}
+
+Bool
+XDPSLGetPassEventsFlag(Display *dpy)
+{
+    return displayFlags[DPY_NUMBER(dpy)].passEvents;
+}
+
+void
+XDPSLSetPassEventsFlag(Display *dpy, Bool flag)
+{
+    displayFlags[DPY_NUMBER(dpy)].passEvents = flag;
+}
+
+Bool
+XDPSLGetWrapWaitingFlag(Display *dpy)
+{
+    return displayFlags[DPY_NUMBER(dpy)].wrapWaiting;
+}
+
+void
+XDPSLSetWrapWaitingFlag(Display *dpy, Bool flag)
+{
+    displayFlags[DPY_NUMBER(dpy)].wrapWaiting = flag;
+}
+
+static Status 
+ConvertOutputEvent(Display *dpy, XEvent *ce, xEvent *we)
+{
+    register PSOutputEvent *wireevent = (PSOutputEvent *) we;
+    register XDPSLOutputEvent *clientevent = (XDPSLOutputEvent *) ce;
+    
+    clientevent->type = wireevent->type & 0x7f;
+    clientevent->serial = _XSetLastRequestRead(dpy,
+					       (xGenericReply *)wireevent);
+    clientevent->send_event = (wireevent->type & 0x80) != 0;
+    clientevent->display = dpy;
+    clientevent->cxid = wireevent->cxid;
+    clientevent->length = wireevent->length;
+    bcopy((char *) wireevent->data, clientevent->data, wireevent->length);
+    if (TextProc && !XDPSLGetPassEventsFlag(dpy)) {
+	(*TextProc)((XEvent *) clientevent);
+	return False;
+    }
+    return True;
+}
+
+static Status 
+ConvertStatusEvent(Display *dpy, XEvent *ce, xEvent *we)
+{
+    register PSStatusEvent *wireevent = (PSStatusEvent *) we;
+    register XDPSLStatusEvent *clientevent = (XDPSLStatusEvent *) ce;
+    
+    clientevent->type = wireevent->type & 0x7f;
+    clientevent->serial = _XSetLastRequestRead(dpy,
+					       (xGenericReply *)wireevent);
+    clientevent->send_event = (wireevent->type & 0x80) != 0;
+    clientevent->display = dpy;
+    clientevent->cxid = wireevent->cxid;
+    clientevent->status = wireevent->status;
+    if (StatusProc[DPY_NUMBER(dpy)] && !XDPSLGetPassEventsFlag(dpy)) {
+	(*(StatusProc[DPY_NUMBER(dpy)]))((XEvent *) clientevent);
+	return False;
+    }
+    return True;
+}
+
+/* Added for L2-DPS/PROTO 9 */
+static Status
+ConvertReadyEvent(Display *dpy, XEvent *ce, xEvent *we)
+{
+    register PSReadyEvent *wireevent = (PSReadyEvent *) we;
+    register XDPSLReadyEvent *clientevent = (XDPSLReadyEvent *) ce;
+    
+    clientevent->type = wireevent->type & 0x7f;
+    clientevent->serial = _XSetLastRequestRead(dpy,
+					       (xGenericReply *)wireevent);
+    clientevent->send_event = (wireevent->type & 0x80) != 0;
+    clientevent->display = dpy;
+    clientevent->cxid = wireevent->cxid;
+    clientevent->val[0] = wireevent->val1;
+    clientevent->val[1] = wireevent->val2;
+    clientevent->val[2] = wireevent->val3;
+    clientevent->val[3] = wireevent->val4;
+    if (ReadyProc[DPY_NUMBER(dpy)] && !XDPSLGetPassEventsFlag(dpy)) {
+	(*(ReadyProc[DPY_NUMBER(dpy)]))((XEvent *) clientevent);
+	return False;
+    }
+    return True;
+}
+
+/* Added for L2-DPS/PROTO 9 */
+/* ARGSUSED */
+
+static int
+CatchBadMatch(Display *dpy, xError *err, XExtCodes *codes, int *ret_code)
+{
+    if (err->errorCode == BadMatch)
+        {
+	*ret_code = 0;
+	return 1;  /* suppress error */
+	}
+    else
+        {
+	*ret_code = 1;
+	return 0;  /* pass error along */
+	}
+}
+
+
+int
+XDPSLInit(
+    Display *dpy,
+    int *numberType,		/* RETURN */
+    char **floatingName)	/* RETURN: CALLER MUST NOT MODIFY OR FREE! */
+{
+    XExtCodes *codes = (XExtCodes *)NULL;
+    register xPSInitReq *req;
+    xPSInitReply rep;
+    char *ptr;
+    int first_event;
+    
+    {
+        char *ddt;
+
+        if ((ddt = getenv("DPSNXOVER")) != NULL) {
+            gForceCSDPS = (*ddt == 't' || *ddt == 'T');
+            if (gForceCSDPS)
+                DPSWarnProc(NULL, "*** USING DPS NX ***");
+        }
+    }
+    
+    if ((codes = Codes[DPY_NUMBER(dpy)]) != NULL) {
+	if (numberType)
+	    *numberType = NumberType[DPY_NUMBER(dpy)];
+	if (floatingName)
+	    *floatingName = FloatingName[DPY_NUMBER(dpy)];
+	return codes->first_event;
+    } else {
+        if (gForceCSDPS)
+            goto try_dps_nx;
+	codes = XInitExtension(dpy, DPSNAME);
+	if (codes == NULL) {
+	    /* try DEC UWS 2.2 server */
+	    codes = XInitExtension(dpy, DECDPSNAME);
+try_dps_nx:
+            if (codes == NULL) {
+                int myNumberType;
+		char *myFloatingName;
+		
+	        first_event = CSDPSInit(dpy, &myNumberType, &myFloatingName);
+		NumberType[DPY_NUMBER(dpy)] = myNumberType;
+		FloatingName[DPY_NUMBER(dpy)] = myFloatingName;
+		if (numberType)
+		    *numberType = myNumberType;
+		if (floatingName)
+		    *floatingName = myFloatingName;
+		return first_event;
+	    }
+	}
+	Codes[DPY_NUMBER(dpy)] = codes;
+	ShuntMap[DPY_NUMBER(dpy)] = dpy;
+	/* set procs for native DPS/X */
+	XESetCloseDisplay(dpy, codes->extension, CloseDisplayProc);
+	XESetWireToEvent(dpy, codes->first_event + PSEVENTOUTPUT,
+			 ConvertOutputEvent);
+	XESetWireToEvent(dpy, codes->first_event + PSEVENTSTATUS,
+			 ConvertStatusEvent);
+	XESetWireToEvent(dpy, codes->first_event + PSEVENTREADY,
+			 ConvertReadyEvent);
+	first_event = codes->first_event;
+    }
+
+    /* We have to handle a BadMatch error, in the case where
+       the client has a later (higher) version of
+       the protocol than the server */
+    {
+    int (*oldErrorProc)(Display*, xError*, XExtCodes*, int*);
+    int libVersion;
+    Bool doneIt;
+    
+    XSync(dpy, False);
+    LockDisplay(dpy);
+    oldErrorProc = XESetError(dpy, codes->extension, CatchBadMatch);
+    libVersion = DPSPROTOCOLVERSION;
+    doneIt = False;
+    while (libVersion >= DPSPROTO_OLDEST)
+        {
+	GetReq(PSInit, req);
+	req->reqType = MajorOpCode(dpy);
+	req->dpsReqType = X_PSInit;
+	req->libraryversion = libVersion;
+        if (_XReply(dpy, (xReply *) &rep, 0, xFalse))
+	    {
+	    doneIt = True;
+	    break;
+	    }
+	/* otherwise, try previous version */
+	--libVersion;
+        }
+    oldErrorProc = XESetError(dpy, codes->extension, oldErrorProc);
+    if (!doneIt)
+        {
+	DPSFatalProc(NULL, "Incompatible protocol versions");
+	exit(1);	
+	}
+	
+    /* NOTE *************************************************
+       We made a boo-boo in the 1007.2 and earlier versions of
+       our X server glue code.  Instead of sending a
+       BadMatch error if the client's version is newer (higher)
+       than the server's, it just replies with success.  We
+       could test for that situation here by looking at
+       rep.serverversion, but it turns out that we don't need
+       to do anything special.  Since rep.serverversion gets
+       assigned to our version[] array, it is as if we handled
+       the BadMatch correctly.  Just for safety's sake, we'll
+       do some bulletproofing here instead. 
+       Fixes 2ps_xdps BUG #6 */
+       
+    else if (rep.serverversion < DPSPROTO_OLDEST 
+      || rep.serverversion > DPSPROTOCOLVERSION)
+        {
+	DPSFatalProc(NULL, "Server replied with bogus version");
+	exit(1);	
+	}
+    }
+
+    version[DPY_NUMBER(dpy)] = rep.serverversion;
+    NumberType[DPY_NUMBER(dpy)] = rep.preferredNumberFormat;
+    if (numberType)
+	*numberType = rep.preferredNumberFormat;
+
+    ptr = (char *) Xmalloc(rep.floatingNameLength + 1);
+    _XReadPad(dpy, ptr, rep.floatingNameLength);
+    ptr[rep.floatingNameLength] = 0;
+    FloatingName[DPY_NUMBER(dpy)] = ptr;
+    if (floatingName)
+	*floatingName = ptr;
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    return first_event;
+}
+
+
+
+
+static void CopyColorMapsIntoCreateContextReq(
+    xPSCreateContextReq *req,
+    XStandardColormap *colorcube,
+    XStandardColormap *grayramp)
+{
+    req->cmap = 0;
+    if (colorcube != NULL) {
+        req->cmap = colorcube->colormap;
+	req->redmax = colorcube->red_max;
+	req->redmult = colorcube->red_mult;
+	req->greenmax = colorcube->green_max;
+	req->greenmult = colorcube->green_mult;
+	req->bluemax = colorcube->blue_max;
+	req->bluemult = colorcube->blue_mult;
+	req->colorbase = colorcube->base_pixel;
+    }
+    else {
+	req->redmult = 0;
+	/* The rest of this shouldn't be necessary, but there are some
+	   servers out there that erroneously check the other fields
+	   even when redmult is 0 */
+        req->redmax = 0;
+        req->greenmult = 0;
+        req->greenmax = 0;
+        req->bluemult = 0;
+        req->bluemax = 0;
+        req->colorbase = 0;
+    }
+
+    if (grayramp != NULL) {
+	req->cmap = grayramp->colormap;
+	req->graymax = grayramp->red_max;
+	req->graymult = grayramp->red_mult;
+	req->graybase = grayramp->base_pixel;
+    }
+    else req->graymult = 0;
+}
+
+
+
+
+
+
+/* ARGSUSED */
+ContextXID
+XDPSLCreateContextAndSpace(
+    register Display *xdpy,
+    Drawable draw,
+    GC gc,
+    int x, int y,
+    unsigned int eventMask,
+    XStandardColormap *grayRamp,
+    XStandardColormap *colorCube,
+    unsigned int actual,
+    ContextPSID *cpsid,		/* RETURN */
+    SpaceXID *sxid,		/* RETURN */
+    Bool secure)                /* Added for L2-DPS/PROTO 9 */
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    ContextXID cxid;
+    register xPSCreateContextReq *req;  /* Same struct for CreateSecureContext */
+    xPSCreateContextReply rep;
+    XStandardColormap defColorcube, defGrayramp;
+    XStandardColormap *requestCube, *requestRamp;
+    int index;
+    XDPSLIOProcs *call;
+    
+    if (grayRamp == NULL && colorCube == NULL) return(None);
+
+    if (secure && version[dpyix] < DPSPROTO_V09)
+        return(None);                 /* No secure contexts before PROTO 9 */
+
+    /* Index gets encoded as follows:
+     *
+     *  0  grayRamp = Default,	   colorCube = Default
+     *  1  grayRamp = non-Default, colorcube = Default
+     *  2  grayRamp = Default,	   colorcube = non-Default
+     *  3  grayRamp = non-Default, colorcube = non-Default
+     *
+     */
+    index = ((grayRamp == DefaultStdCMap || grayRamp == NULL) ? 0 : 1) +
+	(colorCube == DefaultStdCMap ? 0 : 2);
+
+    switch (index)
+	{
+	default:
+	case 0: /* Both are default */
+	    XDPSGetDefaultColorMaps(xdpy, (Screen *) NULL, draw,
+				    &defColorcube, &defGrayramp);
+	    requestCube = &defColorcube;
+	    requestRamp = &defGrayramp;
+	    break;
+
+	case 1: /* gray specified, Color default */
+	    XDPSGetDefaultColorMaps(xdpy, (Screen *) NULL, draw,
+				    &defColorcube, (XStandardColormap *) NULL);
+	    requestCube = &defColorcube;
+	    requestRamp = grayRamp;
+	    break;
+
+	case 2: /* gray default, Color specified */
+	    XDPSGetDefaultColorMaps(xdpy, (Screen *) NULL, draw,
+				    (XStandardColormap *) NULL, &defGrayramp);
+	    requestCube = colorCube;
+	    requestRamp = &defGrayramp;
+	    break;
+
+	case 3: /* Both specified */
+	    requestCube = colorCube;
+	    requestRamp = grayRamp;
+	    break;
+	}
+
+    if (gc != NULL)
+        XDPSLFlushGC(xdpy, gc);
+    if (dpy != xdpy)
+        {
+        int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* Don't worry about pauses here, since we are just
+	   now creating the context! */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSCreateContext, req);
+    CopyColorMapsIntoCreateContextReq(req, requestCube, requestRamp);
+
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = (secure) ? X_PSCreateSecureContext : X_PSCreateContext;
+    req->x = x;
+    req->y = y;
+    req->drawable = draw;
+    req->gc = (gc != NULL) ? XGContextFromGC(gc) : None;
+    cxid = req->cxid = XAllocID(xdpy);
+    req->sxid = XAllocID(xdpy);	  
+    if (sxid)
+	*sxid = req->sxid;
+    req->eventmask = 0;		/* %%% */
+    req->actual = actual;
+    IFNXSETCALL(dpy, xdpy);
+    (void) (*call->Reply) (dpy, (xReply *)&rep, 0, xTrue);
+
+    if (cpsid)
+	*cpsid = (int)rep.cpsid;
+
+    UnlockDisplay(dpy);
+    /* If the context creation succeeded and we are CSDPS, send GC values */    
+    if (rep.cpsid && xdpy != dpy && gc != NULL)
+        {
+        DPSCAPInitGC(xdpy, dpy, gc);
+        }
+    SyncHandle();
+    
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+    return (cxid);
+}
+
+
+/* ARGSUSED */
+ContextXID
+XDPSLCreateContext(
+    register Display *xdpy,
+    SpaceXID sxid,
+    Drawable draw,
+    GC gc,
+    int x, int y,
+    unsigned int eventMask,
+    XStandardColormap *grayRamp,
+    XStandardColormap *colorCube,
+    unsigned int actual,
+    ContextPSID *cpsid,		/* RETURN */
+    Bool secure)                /* L2-DPS/PROTO 9 addition */
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSCreateContextReq *req;
+    xPSCreateContextReply rep;
+    ContextXID cxid;			/* RETURN */
+    XStandardColormap defColorcube, defGrayramp;
+    XStandardColormap *requestCube, *requestRamp;
+    int index;
+    XDPSLIOProcs *call;
+
+    if (secure && version[dpyix] < DPSPROTO_V09)
+        return(None);                /* No secure contexts before PROTO 9 */
+
+    /* Index gets encoded as follows:
+     *
+     *  0  grayRamp = Default,	   colorCube = Default
+     *  1  grayRamp = non-Default, colorcube = Default
+     *  2  grayRamp = Default,	   colorcube = non-Default
+     *  3  grayRamp = non-Default, colorcube = non-Default
+     *
+     *  Note that only the first or last case should ever happen.
+     */
+    index = ((grayRamp == DefaultStdCMap) ? 0 : 1) +
+	((colorCube == DefaultStdCMap) ? 0 : 2);
+
+    switch (index)
+	{
+	default:
+	case 0: /* Both are default */
+	    XDPSGetDefaultColorMaps(xdpy, (Screen *) NULL, draw,
+				    &defColorcube, &defGrayramp);
+	    requestCube = &defColorcube;
+	    requestRamp = &defGrayramp;
+	    break;
+
+	case 1: /* gray specified, Color default */
+	    XDPSGetDefaultColorMaps(xdpy, (Screen *) NULL, draw,
+				    &defColorcube, (XStandardColormap *) NULL);
+	    requestCube = &defColorcube;
+	    requestRamp = grayRamp;
+	    break;
+
+	case 2: /* gray default, Color specified */
+	    XDPSGetDefaultColorMaps(xdpy, (Screen *) NULL, draw,
+				    (XStandardColormap *) NULL, &defGrayramp);
+	    requestCube = colorCube;
+	    requestRamp = &defGrayramp;
+	    break;
+
+	case 3: /* Both specified */
+	    requestCube = colorCube;
+	    requestRamp = grayRamp;
+	    break;
+	}
+
+
+    if (gc != NULL)
+        XDPSLFlushGC(xdpy, gc);
+    if (dpy != xdpy)
+        {
+        int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* Don't worry about pauses here, since we are
+	   just now creating this context! */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSCreateContext, req);
+    CopyColorMapsIntoCreateContextReq(req, requestCube, requestRamp);
+
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = (secure) ? X_PSCreateSecureContext : X_PSCreateContext;
+    req->x = x;
+    req->y = y;
+    req->drawable = draw;
+    req->gc = (gc != NULL) ? XGContextFromGC(gc) : None;
+    cxid = req->cxid = XAllocID(xdpy);
+    req->sxid = sxid;
+    req->actual = actual;
+
+    IFNXSETCALL(dpy, xdpy);
+    (void) (*call->Reply) (dpy, (xReply *)&rep, 0, xTrue);
+    if (cpsid)
+	*cpsid = (int)rep.cpsid;
+
+    UnlockDisplay(dpy);
+    /* If the context creation succeeded and we are CSDPS, send GC values */
+    if (rep.cpsid && xdpy != dpy && gc != NULL)
+        {
+        DPSCAPInitGC(xdpy, dpy, gc);
+        }
+
+    SyncHandle();
+    
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+    return cxid;
+}
+
+SpaceXID
+XDPSLCreateSpace(Display *xdpy)
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSCreateSpaceReq *req;
+    SpaceXID sxid;
+
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSCreateSpace, req);
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = X_PSCreateSpace;
+    sxid = req->sxid = XAllocID(xdpy);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+    return sxid;
+}
+
+
+
+/*
+ * I'm not sure how portable my coalescing code is, so I've provided the
+ * below define.  If it turns out this code just breaks somewhere, you
+ * can simply undefine COALESCEGIVEINPUT, and then everything will work
+ * (but slower).  6/16/89 (tw)
+ */
+
+#define COALESCEGIVEINPUT
+
+void
+XDPSLGiveInput(Display *xdpy, ContextXID cxid, char *data, int length)
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSGiveInputReq *req;
+    Bool didFlush = False;
+
+    if (dpy != xdpy)
+        {
+        register int syncMask = displayFlags[dpyix].syncMask;
+	
+	if (syncMask & DPSCAP_SYNCMASK_RECONCILE)
+	    {
+	    XDPSLReconcileRequests(xdpy, cxid);
+	    didFlush = True;
+	    }
+	
+	/* If this context got paused, no matter how, ignore
+	   mode and resume it */
+	if (gTotalPaused && DPSCAPResumeContext(xdpy, cxid))
+	    {
+	    /* xdpy was flushed by DPSCAPResumeContext */
+	    if (!didFlush)
+	        {
+	        N_XFlush(dpy);
+		didFlush = True;
+		}
+	    }
+	else if (syncMask & DPSCAP_SYNCMASK_SYNC)
+	    {
+	    didFlush = True;
+            XSync(xdpy, False);
+	    }
+        }
+    LockDisplay(dpy);
+    
+#ifdef COALESCEGIVEINPUT
+    req = (xPSGiveInputReq *) dpy->last_req;
+    if (req->reqType == MajorOpCode(xdpy)
+	  && req->dpsReqType == X_PSGiveInput
+	  && req->cxid == cxid
+	  && dpy->bufptr + length + 3 < dpy->bufmax) {
+	bcopy(data, ((char *) req) + sizeof(xPSGiveInputReq) + req->nunits,
+	      length);
+	req->nunits += length;
+	req->length = (sizeof(xPSGiveInputReq) + req->nunits + 3) >> 2;
+	dpy->bufptr = dpy->last_req + sizeof(xPSGiveInputReq) +
+	    ((req->nunits + 3) & ~3);
+    } else
+#endif /* COALESCEGIVEINPUT */
+    {
+        int flushOnce = 1;
+	int maxedOutLen = xdpy->max_request_size - sizeof(xPSGiveInputReq) - 4;
+	int nunits;
+	
+	/* We have the rare opportunity to chop up a buffer that is larger
+	   than the max request size into separate requests, unlike
+	   most other X requests (such as DrawText).  The -4 is to
+	   force these maxed out requests to be less than the maximum
+	   padding that would ever be needed, and to minimize padding
+	   in the case where the input buffer is several times
+	   larger than max request length. */
+	   
+        nunits = maxedOutLen;
+	do {
+	    if (length < maxedOutLen)
+	        nunits = length;  /* Normal size block */
+	    NXMacroGetReq(PSGiveInput, req);
+	    req->reqType = MajorOpCode(xdpy);
+	    req->dpsReqType = X_PSGiveInput;
+	    req->cxid = cxid;
+	    req->nunits = nunits;
+	    req->length += ((nunits + 3) >> 2);
+	    if (dpy != xdpy) {
+	        if (flushOnce && !didFlush) {
+		    LockDisplay(xdpy);
+		    _XFlush(xdpy);
+		    UnlockDisplay(xdpy);
+		    flushOnce = 0;
+		}
+	        NXProcData(dpy, (char *) data, nunits);
+	    } else
+	        {Data(dpy, (char *) data, nunits);}
+	    data += nunits;
+	    length -= nunits;
+	} while (length);
+    }
+
+    /* In the NX case (didFlush is always False for the non-NX case),
+       the xdpy may have been flushed, but there is stuff left
+       buffered in dpy (NX connection).  We can't leave the stuff
+       there, since we may never call a DPS routine again.  Until
+       we can be notified about xdpy being flushed, we have to
+       clear out the dpy buffer after we cleared out the xdpy
+       buffer (didFlush == True). */
+
+    if (dpy != xdpy
+      && dpy->bufptr != dpy->buffer
+      && (gForceFlush || didFlush))
+	N_XFlush(dpy);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+}
+
+
+int
+XDPSLGetStatus(Display *xdpy, ContextXID cxid)
+{
+    int dpyix;
+    Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSGetStatusReq *req;
+    xPSGetStatusReply rep;
+    XDPSLIOProcs *call;
+    
+    if (dpy != xdpy)
+        {
+        register int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* ASSERT: There is no reason to pause the context for this
+	   request, so just sync. */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSGetStatus, req);
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = X_PSGetStatus;
+    req->cxid = cxid;
+    req->notifyIfChange = 0;
+
+    IFNXSETCALL(dpy, xdpy);
+    if (! (*call->Reply)(dpy, (xReply *)&rep, 0, xTrue))
+	rep.status = PSSTATUSERROR;
+    UnlockDisplay(dpy);
+    SyncHandle();
+    /* For CSDPS, guarantee that status events arrive just like DPS/X */
+    if (dpy != xdpy)
+        {
+	XDPSLSync(xdpy);
+	LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+	}
+    return (int) rep.status;
+}
+
+void
+XDPSLDestroySpace(Display *xdpy, SpaceXID sxid)
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSDestroySpaceReq *req;
+
+    if (dpy != xdpy)
+        {
+        int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* ASSERT: There is no reason to pause the context for this
+	   request, so just sync. */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSDestroySpace, req);
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = X_PSDestroySpace;
+    req->sxid = sxid;
+
+    if (gAutoFlush && dpy != xdpy)
+        {
+        N_XFlush(dpy);
+        }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+}
+
+
+void
+XDPSLReset(Display *xdpy, ContextXID cxid) 
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSResetReq *req;
+
+    if (dpy != xdpy)
+        {
+        register int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* ASSERT: There is no reason to pause the context for this
+	   request, so just sync. */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSReset, req);
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = X_PSReset;
+    req->cxid = cxid;
+
+    if (gAutoFlush && dpy != xdpy)
+        {
+        N_XFlush(dpy);
+        }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+}
+
+void
+XDPSLNotifyContext(
+    Display *xdpy, 
+    ContextXID cxid, 
+    int ntype)		  /* should this be an enum?? %%% */
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSNotifyContextReq *req;
+
+    if (dpy != xdpy)
+        {
+        register int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* ASSERT: There is no reason to pause the context for this
+	   request, so just sync. */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSNotifyContext, req);
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = X_PSNotifyContext;
+    req->cxid = cxid;
+    req->notifyType = ntype;
+    
+    if (dpy != xdpy)
+        {
+        N_XFlush(dpy);  /* THIS IS CRITICAL TO AVOID HANGING! */
+        }
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    if (dpy != xdpy)
+        {
+        if (ntype == PSKILL)
+            XDPSLCleanContext(xdpy, cxid);
+	LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+	}
+}
+
+
+ContextXID
+XDPSLCreateContextFromID(
+    Display *xdpy, 
+    ContextPSID cpsid, 
+    SpaceXID *sxid)		/* RETURN */
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSCreateContextFromIDReq *req;
+    xPSCreateContextFromIDReply rep;
+    ContextXID cxid;
+    XDPSLIOProcs *call;
+
+    if (dpy != xdpy)
+        {
+        int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* ASSERT: There is no reason to pause the context for this
+	   request, so just sync. */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSCreateContextFromID, req);
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = X_PSCreateContextFromID;
+    req->cpsid = cpsid;
+    cxid = req->cxid = XAllocID(xdpy);
+    
+    IFNXSETCALL(dpy, xdpy);
+    (void) (*call->Reply) (dpy, (xReply *)&rep, 0, xTrue);
+    if (sxid)
+	*sxid = (int)rep.sxid;
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+    return(cxid);
+}
+
+
+/* Returns 1 on success, 0 on failure (cpsid not a valid context). */
+
+Status
+XDPSLIDFromContext(
+    Display *xdpy,
+    ContextPSID cpsid, 
+    ContextXID *cxid,			/* RETURN */
+    SpaceXID *sxid)			/* RETURN */
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSXIDFromContextReq *req;
+    xPSXIDFromContextReply rep;
+    XDPSLIOProcs *call;
+
+    if (dpy != xdpy)
+        {
+        int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* ASSERT: There is no reason to pause the context for this
+	   request, so just sync. */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSXIDFromContext, req);
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = X_PSXIDFromContext;
+    req->cpsid = cpsid;
+    
+    IFNXSETCALL(dpy, xdpy);
+    (void) (*call->Reply) (dpy, (xReply *)&rep, 0, xTrue);
+    *sxid = (int)rep.sxid;
+    *cxid = (int)rep.cxid;
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+    return((Status)(*sxid != None && *cxid != None));
+}
+
+
+ContextPSID
+XDPSLContextFromXID(Display *xdpy, ContextXID cxid)
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSContextFromXIDReq *req;
+    xPSContextFromXIDReply rep;
+    XDPSLIOProcs *call;
+
+    if (dpy != xdpy)
+        {
+        int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* ASSERT: There is no reason to pause the context for this
+	   request, so just sync. */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSContextFromXID, req);
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = X_PSContextFromXID;
+    req->cxid = cxid;
+    
+    IFNXSETCALL(dpy, xdpy);
+    (void) (*call->Reply) (dpy, (xReply *)&rep, 0, xTrue);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+    return (int)rep.cpsid;
+}
+
+
+void
+XDPSLSetStatusMask(
+    Display *xdpy,
+    ContextXID cxid,
+    unsigned int enableMask,
+    unsigned int disableMask,
+    unsigned int nextMask)
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSSetStatusMaskReq *req;
+
+    if (dpy != xdpy)
+        {
+        register int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* ASSERT: There is no reason to pause the context for this
+	   request, so just sync. */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSSetStatusMask, req);
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = X_PSSetStatusMask;
+    req->cxid = cxid;
+    req->enableMask = enableMask;
+    req->disableMask = disableMask;
+    req->nextMask = nextMask;
+
+    if (gAutoFlush && dpy != xdpy)
+        {
+        N_XFlush(dpy);
+        }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+}
+
+
+#ifdef VMS
+/*
+ * _XReadPad - Read bytes from the socket taking into account incomplete
+ * reads.  If the number of bytes is not 0 mod 32, read additional pad
+ * bytes. This routine may have to be reworked if int < long.
+ */
+ 
+/* This is really in xlib, but is not in the sharable image transfer vector
+ * so I am copying it here for now.  BF
+
+The following notice applies only to the functions
+_XReadPad and XFlush
+
+Copyright 1985, 1986, 1987, 1988, 1989 by the
+Massachusetts Institute of Technology
+
+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 name of M.I.T. not be used in advertising or
+publicity pertaining to distribution of the software without specific,
+written prior permission.  M.I.T. makes no representations about the
+suitability of this software for any purpose.  It is provided "as is"
+without express or implied warranty.
+
+*/  
+void
+_XReadPad (Display *dpy, char *data, long size)
+{
+	static int padlength[4] = {0,3,2,1};
+	register long bytes_read;
+	char pad[3];
+ 
+	CheckLock(dpy);
+	if (size == 0) return;
+	_XRead( dpy, data, size );
+	if ( padlength[size & 3] ) {
+	    _XRead( dpy, pad, padlength[size & 3] );
+	}
+
+}
+#endif /* VMS */
+
+/* _____________ LEVEL 2 DPS/PROTOCOL 9 ADDITIONS _____________ */
+
+void
+XDPSLNotifyWhenReady(
+    Display *xdpy,
+    ContextXID cxid,
+    int val[4])
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xPSNotifyWhenReadyReq *req;
+
+    if (version[dpyix] < DPSPROTO_V09)
+        {
+	DPSWarnProc(NULL, "Attempted use of XDPSLNotifyWhenReady with incompatible server ignored");
+        return;                                   /* PROTO 9 or later only */
+	}
+	
+    if (dpy != xdpy)
+        {
+        register int syncMask = displayFlags[dpyix].syncMask;
+        
+	if (syncMask & DPSCAP_SYNCMASK_RECONCILE)
+	    XDPSLReconcileRequests(xdpy, cxid);
+	
+	/* If this context got paused, no matter how, ignore
+	   mode and resume it */
+	if (gTotalPaused && DPSCAPResumeContext(xdpy, cxid))
+	    {
+	    /* xdpy was flushed by DPSCAPResumeContext */
+	    if (gAutoFlush)
+	        N_XFlush(dpy);
+	    }
+	else if (syncMask & DPSCAP_SYNCMASK_SYNC)
+            XSync(xdpy, False);
+        }
+    LockDisplay(dpy);
+
+    NXMacroGetReq(PSNotifyWhenReady, req);
+    req->reqType = MajorOpCode(xdpy);
+    req->dpsReqType = X_PSNotifyWhenReady;
+    req->cxid = cxid;
+    req->val1 = val[0];
+    req->val2 = val[1];
+    req->val3 = val[2];
+    req->val4 = val[3];
+
+    if (gAutoFlush && dpy != xdpy)
+        {
+        N_XFlush(dpy);
+        }
+    UnlockDisplay(dpy);
+    SyncHandle();
+    if (dpy != xdpy)
+        LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+}
+
+XDPSLPSErrors
+XDPSLTestErrorCode(Display *dpy, int ecode)
+{
+    XExtCodes *c = XDPSLGetCodes(dpy);
+
+    if (c == NULL)
+        return not_pserror;
+
+    switch (ecode - c->first_error)
+        {
+	case PSERRORBADCONTEXT: return(pserror_badcontext);
+	case PSERRORBADSPACE: return(pserror_badspace);
+	case PSERRORABORT: 
+	    if (version[DPY_NUMBER(dpy)] < DPSPROTO_V09)
+	        return(not_pserror);
+	    else
+	        return(pserror_abort);
+	default: return(not_pserror);
+        }
+}
+
+/* _____________ CLIENT SIDE DPS ADDITIONS _____________ */
+
+/* === NEW HOOKS INTO XDPS === */
+
+void
+XDPSLSetVersion(Display *dpy, unsigned ver)
+{
+    version[DPY_NUMBER(dpy)] = ver;
+}
+
+void
+XDPSLSetCodes(Display *dpy, XExtCodes *codes)
+{
+    Codes[DPY_NUMBER(dpy)] = codes;
+}
+
+Display *
+XDPSLGetShunt(Display *dpy_in)
+{
+    return(ShuntMap[DPY_NUMBER(dpy_in)]);
+}
+
+void
+XDPSLSetShunt(Display *dpy_in, Display *dpy_out)
+{
+    ShuntMap[DPY_NUMBER(dpy_in)] = dpy_out;
+}
+
+int
+XDPSLGetSyncMask(Display *dpy)
+{
+    return (int)displayFlags[DPY_NUMBER(dpy)].syncMask;
+}
+
+void
+XDPSLSetSyncMask(Display *dpy, int mask)
+{
+    displayFlags[DPY_NUMBER(dpy)].syncMask = (char)mask;
+    gForceFlush = (mask & DPSCAP_SYNCMASK_RECONCILE);
+}
+
+void
+XDPSLFlush(Display *xdpy)
+{
+    register Display *dpy = ShuntMap[DPY_NUMBER(xdpy)];
+
+    _XFlush(xdpy);
+    if (dpy != xdpy)
+        N_XFlush(dpy);
+}
+
+void
+XDPSLSyncGCClip(Display *xdpy, GC gc)
+{
+    register unsigned long oldDirty;
+    register int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+
+    /* We DON'T want to notice all gc changes, just the clip */
+    oldDirty = gc->dirty;
+    gc->dirty = (GCClipXOrigin|GCClipYOrigin);
+    XDPSLFlushGC(xdpy, gc);
+    gc->dirty = oldDirty;
+    if (dpy == xdpy || gNXSyncGCMode != 1) /* 1 means sync always */
+        {
+	/* For DPS NX and SLOW mode, flushing the gc cache has
+	the side-effect of synching agent and server connections.
+	So, to have consistent behavior, we sync for the DPS/X
+	or FAST cases too. */
+	
+	if (GCFlushMode[dpyix] == XDPSNX_GC_UPDATES_FAST
+	  || dpy == xdpy)
+	    XDPSLSync(xdpy);
+	}
+}
+
+
+#ifdef VMS
+void
+XDPSLSetDisplay(Display *dpy)
+{
+    dpys[DPY_NUMBER(dpy)] = dpy;
+}
+#endif /* VMS */
+
+char *
+XDPSLSetAgentName(Display *dpy, char *name, int deflt)
+{
+    char *old;
+    
+    if (gCSDPS == NULL)
+        DPSCAPStartUp();
+    if (deflt)
+        {
+        old = gCSDPS->defaultAgentName;
+        gCSDPS->defaultAgentName = name;
+        }
+    else
+        {
+        old = gCSDPS->map[DPY_NUMBER(dpy)];
+        gCSDPS->map[DPY_NUMBER(dpy)] = name;
+        }
+    return(old);
+} 
+
+
+void
+XDPSLSetClientMessageHandler(Display *dpy)
+{
+    if (dpy == NULL) return;
+    ClientMsgProc[DPY_NUMBER(dpy)] = XESetWireToEvent(
+      dpy,
+      ClientMessage,
+      DPSCAPClientMessageProc);
+}
+
+void
+XDPSLSetAfterProc(Display *xdpy)
+{
+    if (xdpy == NULL) return;
+    AfterProcs[DPY_NUMBER(xdpy)] = (GenericProcPtrReturnsInt)
+      XSetAfterFunction(xdpy, DPSCAPAfterProc);
+    /* +++ Consider using agent->synchandler to store old proc */
+}
+
+
+CSDPSFakeEventTypes
+XDPSLGetCSDPSFakeEventType(Display *dpy, XEvent *event)
+{
+    XExtCodes *codes = Codes[DPY_NUMBER(dpy)];
+    XExtData *extData;
+    DPSCAPData my;
+    
+    if (event->type != ClientMessage || codes == NULL)
+        return(csdps_not);
+    extData = XFindOnExtensionList(
+      CSDPSHeadOfDpyExt(dpy),
+      codes->extension);
+    if (!extData)
+        return(csdps_not);
+    my = (DPSCAPData) extData->private_data;
+    
+    if (event->xclient.message_type == my->typePSOutput)
+        return(csdps_output);
+    if (event->xclient.message_type == my->typePSOutputWithLen)
+        return(csdps_output_with_len);
+    if (event->xclient.message_type == my->typePSStatus)
+        return(csdps_status);
+    if (event->xclient.message_type == my->typeNoop)
+        return(csdps_noop);
+    if (event->xclient.message_type == my->typePSReady)
+        return(csdps_ready);
+    return(csdps_not);
+}
+
+Bool
+XDPSLDispatchCSDPSFakeEvent(
+    Display *dpy,
+    XEvent *event,
+    CSDPSFakeEventTypes t)
+{
+    register XDPSLOutputEvent *oce;
+    register DPSCAPOutputEvent *oev;
+    XDPSLOutputEvent fakeOutput;
+    XExtCodes *codes = Codes[DPY_NUMBER(dpy)];
+
+    if (codes == NULL)
+        return(False);
+
+    /* Fake up an event in the client's format.  Bypasses
+       extension wire-to-event conversion */
+    switch (t)
+        {
+        case csdps_output:
+            oce = &fakeOutput;
+	    oev = (DPSCAPOutputEvent *)event->xclient.data.b;
+	    oce->length = DPSCAP_BYTESPEROUTPUTEVENT;
+	    goto samo_samo;
+	case csdps_output_with_len:
+	    oce = &fakeOutput;
+	    oev = (DPSCAPOutputEvent *)event->xclient.data.b;
+	    oce->length = oev->data[DPSCAP_DATA_LEN];
+samo_samo:
+	    oce->type = codes->first_event + PSEVENTOUTPUT;
+	    oce->serial = event->xclient.serial;
+	    oce->send_event = True;  /* ??? */
+	    oce->display = dpy;
+	    oce->cxid = oev->cxid;
+	    bcopy((char *) oev->data, oce->data, oce->length);
+	    XDPSLCallOutputEventHandler(dpy, (XEvent *) oce);
+	    break;
+	case csdps_status:
+	    {
+	    register XDPSLStatusEvent *sce;
+	    register DPSCAPStatusEvent *sev;
+	    XDPSLStatusEvent fakeStatus;
+
+	    sev = (DPSCAPStatusEvent *)event->xclient.data.b;
+	    sce = &fakeStatus;
+	    sce->type = codes->first_event + PSEVENTSTATUS;
+	    sce->serial = event->xclient.serial;
+	    sce->send_event = True;  /* ??? */
+	    sce->display = dpy;
+	    sce->status = sev->status;
+	    sce->cxid = sev->cxid;
+	    XDPSLCallStatusEventHandler(dpy, (XEvent *) sce);
+	    break;
+	    }
+	case csdps_ready:                      /* L2-DPS/PROTO 9 addition */
+	    {
+	    register XDPSLReadyEvent *rce;
+	    XDPSLReadyEvent fakeReady;
+	    
+	    rce = &fakeReady;
+	    rce->type = codes->first_event + PSEVENTREADY;
+	    rce->serial = event->xclient.serial;
+	    rce->send_event = True;
+	    rce->display = dpy;
+	    rce->cxid = event->xclient.data.l[0];
+	    rce->val[0] = event->xclient.data.l[1];
+	    rce->val[1] = event->xclient.data.l[2];
+	    rce->val[2] = event->xclient.data.l[3];
+	    rce->val[3] = event->xclient.data.l[4];
+	    XDPSLCallReadyEventHandler(dpy, (XEvent *) rce);
+	    break;
+	    }
+	default:
+	    return(False);
+        }
+    return(True);
+}
+
+void
+XDPSLGetCSDPSStatus(
+    Display *xdpy,
+    XEvent *event,
+    void **ret_ctxt,
+    int *ret_status)
+{
+    register DPSCAPStatusEvent *sev;
+
+    /* Assert: event is ClientMessage with typePSStatus */
+    sev = (DPSCAPStatusEvent *)event->xclient.data.b;
+   
+    if (ret_ctxt != NULL) 
+        *ret_ctxt = XDPSContextFromXID(xdpy, sev->cxid);
+    if (ret_status != NULL)
+        *ret_status = sev->status;
+}
+
+void
+XDPSLGetCSDPSReady(
+    Display *xdpy,
+    XEvent *event,
+    void **ret_ctxt,
+    int *ret_val)
+{
+    /* Assert: event is ClientMessage with typePSReady */
+   
+    if (ret_ctxt != NULL) 
+        *ret_ctxt = 
+	  XDPSContextFromXID(xdpy, (ContextXID)event->xclient.data.l[0]);
+    if (ret_val != NULL)
+        {
+	ret_val[0] = event->xclient.data.l[1];
+	ret_val[1] = event->xclient.data.l[2];
+	ret_val[2] = event->xclient.data.l[3];
+	ret_val[3] = event->xclient.data.l[4];
+	}
+}
+
+void
+XDPSLCAPNotify(
+    Display *xdpy, 
+    ContextXID cxid, 
+    unsigned int ntype,		  /* should this be an enum?? %%% */
+    unsigned int data,
+    unsigned int extra)
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    register xCAPNotifyReq *req;
+    
+    if (dpy == xdpy) return;
+    
+    /* We _have_ to sync client and server here in order to guarantee
+       correct execution sequencing.  We call this procedure alot
+       to keep track of GC's going away, so this is a major 
+       performance hit. */
+    if (ntype == DPSCAPNOTE_FREEGC)   
+        XSync(xdpy, False);
+
+    LockDisplay(dpy);
+
+    NXMacroGetReq(CAPNotify, req);
+    req->reqType = DPSCAPOPCODEBASE;
+    req->type = X_CAPNotify;
+    req->cxid = cxid;
+    req->notification = ntype;
+    req->data = data;
+    req->extra = extra;
+    
+    if (gAutoFlush)
+        N_XFlush(dpy);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+}
+
+void
+XDPSLSync(Display *xdpy)
+{
+    register Display *dpy = ShuntMap[DPY_NUMBER(xdpy)];
+    
+    if (dpy == xdpy)
+        {
+        /* DPS/X */
+        XSync(dpy, False);
+        }
+    else
+        {
+        /* CSDPS */
+        XEvent event;
+        DPSCAPData my;
+        XExtData *extData;
+        XExtCodes *codes = Codes[DPY_NUMBER(xdpy)];
+
+	if (codes == NULL)
+	    return;
+	/* Get private data */
+	extData = XFindOnExtensionList(
+	  CSDPSHeadOfDpyExt(xdpy),
+	  codes->extension);
+	if (!extData)
+	    return;
+        my = (DPSCAPData) extData->private_data;
+        my->saveseq = XNextRequest(dpy)-1;
+	/* first send notification to agent */
+	XDPSLCAPNotify(xdpy, 0, DPSCAPNOTE_SYNC, my->saveseq, 0);
+#ifdef XXX
+fprintf(stderr, "\nXDPSLSync(DPSCAPNOTE_SYNC) sending ... ");
+#endif
+        _XFlush(xdpy);
+	N_XFlush(dpy);
+#ifdef XXX
+fprintf(stderr, "sent.\nWaiting for reply ... ");
+#endif
+	/* agent should send a ClientMessage, so wait for it */
+	XIfEvent(xdpy, &event, WaitForSyncProc, (char *) my);
+
+#ifdef XXX
+fprintf(stderr, "received.\n");
+#endif
+	/* now client, agent, and server are synchronized */
+        }
+}
+
+void
+XDPSLReconcileRequests(Display *xdpy, ContextXID cxid)
+{
+    int dpyix;
+    unsigned int seqnum;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+
+    if (dpy == xdpy)
+        return;  /* No-op for DPS/X */
+
+    /* Get the sequence number and set the pause flag
+       IFF we are sure that some X protocol has occurred
+       since the last time we did a DPS request.  This
+       minimizes pause/resume requests */
+    
+    if (LastXRequest[dpyix] == XNextRequest(xdpy)-1)
+        {
+	if (gAutoFlush)
+	    N_XFlush(dpy);  /* This is what XDPSLCAPNotify would do */
+        return;
+	}
+    else
+        seqnum = DPSCAPSetPause(xdpy, cxid);
+    
+    /* Pause the context specified. */
+    XDPSLCAPNotify(xdpy, cxid, DPSCAPNOTE_PAUSE, seqnum, 0);
+    
+    /* We don't even need to flush.  All we have to do is make
+       sure that the notify request is queued before any
+       DPS requests that follow. */
+}
+
+Status
+XDPSLSetAgentArg(Display *xdpy, int arg, int val)
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    CARD32 capArg;
+    register xCAPSetArgReq *req;
+    
+    if (dpy == xdpy)
+        return(Success);  /* No-op for DPS/X */
+
+    /* dpy will be NIL if we haven't opened a connection yet,
+       but that's okay since we need to save the value anyway. */
+    
+    if (dpy)
+        {
+        int syncMask = displayFlags[dpyix].syncMask;
+        
+	/* ASSERT: There is no reason to pause the context for this
+	   request, so just sync. */
+        if (syncMask & (DPSCAP_SYNCMASK_SYNC|DPSCAP_SYNCMASK_RECONCILE))
+            XSync(xdpy, False);
+        }
+
+    switch (arg)
+        {
+	case AGENT_ARG_SMALLFONTS:
+	    AgentArgs[dpyix].showSmallSizes = val;
+	    capArg = DPSCAP_ARG_SMALLFONTS;
+	    break;
+	case AGENT_ARG_PIXMEM:
+	    AgentArgs[dpyix].pixMem = val;
+	    capArg = DPSCAP_ARG_PIXMEM;
+	    break;
+	default:
+	    return(!Success);
+	}
+    if (!dpy)
+        return(Success);
+
+    LockDisplay(dpy);
+
+    NXMacroGetReq(CAPSetArg, req);
+    req->reqType = DPSCAPOPCODEBASE;
+    req->type = X_CAPSetArg;
+    req->arg = capArg;
+    req->val = val;
+    
+    if (gAutoFlush)
+        N_XFlush(dpy);
+
+    UnlockDisplay(dpy);
+    SyncHandle();
+    LastXRequest[dpyix] = XNextRequest(xdpy)-1;
+    return(Success);
+}
+
+
+void
+XDPSLCleanAll(xdpy)
+    register Display *xdpy;
+{
+    /* Clean up all state associated with dpy */
+    register DPSCAPPausedContextData *slot;
+    int dpyix = DPY_NUMBER(xdpy);
+
+    /* Clean up paused context list */
+    for (slot = PausedPerDisplay[dpyix]; slot; slot = PausedPerDisplay[dpyix])
+        {
+	PausedPerDisplay[dpyix] = slot->next;
+	Xfree(slot);
+	}
+
+    /* Clear agent args */
+    AgentArgs[dpyix].showSmallSizes = 0;
+    AgentArgs[dpyix].pixMem = 0;
+}
+
+void
+XDPSLUpdateAgentArgs(xdpy)
+    register Display *xdpy;
+{
+    int dpyix = DPY_NUMBER(xdpy);
+    
+    if (AgentArgs[dpyix].showSmallSizes)
+        XDPSLSetAgentArg(xdpy, AGENT_ARG_SMALLFONTS, AgentArgs[dpyix].showSmallSizes);
+    if (AgentArgs[dpyix].pixMem)
+        XDPSLSetAgentArg(xdpy, AGENT_ARG_PIXMEM, AgentArgs[dpyix].pixMem);
+}
+
+void 
+XDPSLCleanContext(xdpy, cxid)
+    Display *xdpy;
+    ContextXID cxid;
+{
+    /* Clean up all state associated with cxid on this dpy */
+    register DPSCAPPausedContextData *slot, *prev;
+    int dpyix = DPY_NUMBER(xdpy);
+    
+    /* If this is DPS/X, then slot will never have been initialized.
+       See XDPSLNotifyContext */
+
+    /* Clean up paused context list */
+    prev = (DPSCAPPausedContextData *)NULL;
+    for (slot = PausedPerDisplay[dpyix]; slot; prev = slot, slot = slot->next)
+        {
+	if (slot->cxid != cxid)
+	    continue;
+	if (!prev)
+	    PausedPerDisplay[dpyix] = slot->next;
+	else
+	    prev->next = slot->next;
+	Xfree(slot);
+	break;
+	}
+}
+
+/* DPS NX 2.0 */
+void
+XDPSLSetGCFlushMode(dpy, value)
+    Display *dpy;
+    int value;
+{
+    int dpyix;
+    register Display *agent = ShuntMap[dpyix = DPY_NUMBER(dpy)];
+
+    if (value != XDPSNX_GC_UPDATES_SLOW && value != XDPSNX_GC_UPDATES_FAST)
+        {
+	DPSWarnProc(NULL, "DPS NX: Bogus GC flush mode.\n");
+        return;
+	}
+    /* 0 means no NX */
+    GCFlushMode[dpyix] = (agent == dpy) ? 0 : value;
+}
+
+int
+XDPSLGetGCFlushMode(dpy)
+    Display *dpy;
+{
+    return(GCFlushMode[DPY_NUMBER(dpy)]);
+}
+
+void
+XDPSLFlushGC(xdpy, gc)
+    Display *xdpy;
+    GC gc;
+{
+    int dpyix;
+    register Display *dpy = ShuntMap[dpyix = DPY_NUMBER(xdpy)];
+    
+    if (!gc->dirty) return;
+
+    if (GCFlushMode[dpyix] == XDPSNX_GC_UPDATES_FAST)
+        {
+	XGCValues vals;
+	static unsigned long valuemask = DPSGCBITS & ~(GCClipMask);
+	
+	/* Okay to call Xlib, since dpy isn't locked */
+	DPSAssertWarn(XGetGCValues(xdpy, gc, valuemask, &vals),
+	      NULL, "DPS NX: XGetGCValues returned False\n");
+	vals.clip_mask = gc->values.clip_mask;
+	LockDisplay(dpy);
+	DPSCAPChangeGC(dpy, gc, DPSGCBITS, &vals);
+	UnlockDisplay(dpy);
+	SyncHandle();
+	}
+     /* Fall thru.  Either the GCFlushMode is SLOW, which means
+        we will DPSCAPChangeGC as a side-effect of FlushGC when
+	the GC hook is called, or we just did it in the FAST case. */
+     FlushGC(xdpy, gc);
+     XDPSLFlush(xdpy);
+}
+
+/* === PRIVATE CSDPS PROCS === */
+
+static Status
+DPSCAPClientMessageProc(
+    Display *dpy,
+    XEvent *re,
+    xEvent *event)
+{
+    register XDPSLOutputEvent *oce;
+    register DPSCAPOutputEvent *oev;
+    XDPSLOutputEvent fakeOutput;
+    XExtCodes *codes = Codes[DPY_NUMBER(dpy)];
+    PSCMProc oldProc = ClientMsgProc[DPY_NUMBER(dpy)];
+
+    if (codes != NULL)
+        {
+        /* Get private data */
+        XExtData *extData = XFindOnExtensionList(
+	  CSDPSHeadOfDpyExt(dpy),
+          codes->extension);
+        DPSCAPData my;
+        
+        /* There's no extension, or there is an extension but we are
+           passing events uninterpreted, so just pass it along 
+           unless it is a DPSCAP error. */
+           
+        if (!extData)
+            goto pass_the_buck;
+        my = (DPSCAPData) extData->private_data;
+        if (XDPSLGetPassEventsFlag(dpy) && 
+            (event->u.clientMessage.u.l.type != my->typeXError))
+            goto pass_the_buck;
+
+	/* Fake up a DPS extension event and handle it transparently,
+	   without going through the Xlib event queue */
+	
+	if (event->u.clientMessage.u.b.type == my->typePSOutput)
+	    {
+	    oce = &fakeOutput;
+	    oce->length = DPSCAP_BYTESPEROUTPUTEVENT;
+	    oev = (DPSCAPOutputEvent *)event->u.clientMessage.u.b.bytes;
+	    goto common_stuff;
+	    }
+	else if (event->u.clientMessage.u.b.type == my->typePSOutputWithLen)
+	    {
+	    oce = &fakeOutput;
+	    oev = (DPSCAPOutputEvent *)event->u.clientMessage.u.b.bytes;
+	    oce->length = oev->data[DPSCAP_DATA_LEN];
+common_stuff:
+	    oce->type = codes->first_event + PSEVENTOUTPUT;
+	    oce->serial = _XSetLastRequestRead(dpy, (xGenericReply *)event);
+	    oce->send_event = True;  /* ??? */
+	    oce->display = dpy;
+	    oce->cxid = oev->cxid;
+	    bcopy((char *) oev->data, oce->data, oce->length);
+	    /* We've converted the event, give it to DPS */
+	    if (TextProc)
+		(*TextProc)((XEvent *) oce);
+	    return(False);
+	    }
+	else if (event->u.clientMessage.u.b.type == my->typePSStatus)
+	    {
+	    register XDPSLStatusEvent *sce;
+	    register DPSCAPStatusEvent *sev;
+	    XDPSLStatusEvent fakeStatus;
+
+	    sev = (DPSCAPStatusEvent *)event->u.clientMessage.u.b.bytes;
+	    sce = &fakeStatus;
+	    sce->type = codes->first_event + PSEVENTSTATUS;
+	    sce->serial = _XSetLastRequestRead(dpy, (xGenericReply *)event);
+	    sce->send_event = True; /* ??? */
+	    sce->display = dpy;
+	    sce->cxid = sev->cxid;
+	    sce->status = sev->status;
+	    /* We've converted the event, give it to DPS */
+	    if (StatusProc[DPY_NUMBER(dpy)]) 
+		(*(StatusProc[DPY_NUMBER(dpy)]))((XEvent *) sce);
+	    return(False);
+	    }
+	else if (event->u.clientMessage.u.l.type == my->typeXError)
+	    {
+	    xError err;
+	    register xError *e = &err;
+	    
+	    e->type = X_Error;
+	    e->errorCode = event->u.clientMessage.u.l.longs0;
+	    e->sequenceNumber =  event->u.u.sequenceNumber;
+	    e->resourceID = event->u.clientMessage.u.l.longs3;
+	    e->minorCode = event->u.clientMessage.u.l.longs2;
+	    e->majorCode = event->u.clientMessage.u.l.longs1;
+	    /* Smash the wire event here, before going off deep end */
+	    event->u.clientMessage.u.l.type = my->typeNoop;
+	    /* Jump! */
+	    return(_XError(dpy, e));
+	    }
+	else if (event->u.clientMessage.u.l.type == my->typePSReady)
+	    /* L2-DPS/PROTO 9 addition */
+	    {
+	    register XDPSLReadyEvent *rce;
+	    XDPSLReadyEvent fakeReady;
+	    
+	    rce = &fakeReady;
+	    rce->type = codes->first_event + PSEVENTREADY;
+	    rce->serial = _XSetLastRequestRead(dpy, (xGenericReply *)event);
+	    rce->send_event = True;
+	    rce->display = dpy;
+	    rce->cxid = event->u.clientMessage.u.l.longs0;
+	    rce->val[0] = event->u.clientMessage.u.l.longs1;
+	    rce->val[1] = event->u.clientMessage.u.l.longs2;
+	    rce->val[2] = event->u.clientMessage.u.l.longs3;
+	    rce->val[3] = event->u.clientMessage.u.l.longs4;
+	    XDPSLCallReadyEventHandler(dpy, (XEvent *) rce);
+	    return(False);
+	    }
+	}
+    
+    /* Put the event on the queue, so that Xlib is happy */
+pass_the_buck:    
+    return(oldProc(dpy, re, event));
+}
+
+
+static void
+DPSCAPInitGC(Display *dpy, Display *agent, GC gc)
+{
+    XGCValues values;
+    unsigned long valuemask = DPSGCBITS & ~(GCClipMask);
+    
+    /* Okay to call Xlib, since dpy isn't locked */
+    DPSAssertWarn(XGetGCValues(dpy, gc, valuemask, &values),
+         NULL, "DPS NX: XGetGCValues returned False\n");
+    values.clip_mask = gc->values.clip_mask;
+    DPSCAPChangeGC(agent, gc, DPSGCBITS, &values);
+    SyncHandle();
+    XDPSLSync(dpy);
+}
+
+
+/* ARGSUSED */
+
+static Bool
+WaitForSyncProc(Display *xdpy, XEvent *event, char *arg)
+{
+    DPSCAPData my = (DPSCAPData)arg;
+    
+    if ((event->type & 0x7F) == ClientMessage 
+	&& event->xclient.message_type == my->typeSync
+	&& event->xclient.data.l[0] == (long) my->saveseq) {
+      return(True);
+    } else {
+      return(False);
+    }
+}
+
+
+static int
+DPSCAPAfterProc(Display *xdpy)
+{
+    register Display *dpy = ShuntMap[DPY_NUMBER(xdpy)];
+    GenericProcPtrReturnsInt proc;
+    
+    if (dpy != (Display *)NULL && dpy != xdpy)
+        {
+        LockDisplay(dpy);
+        N_XFlush(dpy);
+        UnlockDisplay(dpy);
+        LockDisplay(xdpy);
+        _XFlush(xdpy);
+        UnlockDisplay(xdpy);
+        }
+    if ((proc = AfterProcs[DPY_NUMBER(xdpy)]) != NULL)
+        return((*proc)(xdpy));
+    else
+        return(0);
+}
+
+
+static unsigned int
+DPSCAPSetPause(Display *xdpy, ContextXID cxid)
+{
+    register DPSCAPPausedContextData *slot;
+    int dpyix;
+    unsigned int ret;
+
+    /* Find or create slot */
+    
+    slot = PausedPerDisplay[dpyix = DPY_NUMBER(xdpy)];
+    if (!slot)
+        {
+	slot = (DPSCAPPausedContextData *)
+	  Xcalloc(1, sizeof(DPSCAPPausedContextData));
+	PausedPerDisplay[dpyix] = slot;
+	goto common_code;
+	/* IMPLICATION: it is okay to fall through common_code
+	   and do test_ret. */
+	}
+    while (1)
+        if (slot->cxid == cxid)
+	    {
+	    if (!slot->paused)
+	        {
+	        slot->paused = True;
+		++gTotalPaused;
+		}
+	    /* Back-to-back pauses get different sequence numbers */
+	    ret = ++slot->seqnum;
+	    goto test_ret;
+	    }
+	else if (slot->next) slot = slot->next;
+	else break;
+    /* cxid wasn't found, so add it */
+    /* ASSERT: slot points to last record of the list */
+    slot->next = (DPSCAPPausedContextData *)
+      Xcalloc(1, sizeof(DPSCAPPausedContextData));
+    slot = slot->next;
+common_code:
+    slot->paused = True;
+    ++gTotalPaused;
+    slot->cxid = cxid;
+    ret = ++slot->seqnum;
+test_ret:
+    if (!ret)
+        {
+	DPSWarnProc(NULL, "Pause sequence wrapped around!");
+	}
+    return(ret);
+}
+
+static Bool
+DPSCAPResumeContext(Display *xdpy, ContextXID cxid)
+{
+    register DPSCAPPausedContextData *slot;
+    int dpyix = DPY_NUMBER(xdpy);
+
+    /* Try to match cxid to list of paused contexts */
+    for (slot = PausedPerDisplay[dpyix]; slot; slot = slot->next)
+        if (slot->cxid == cxid && slot->paused)
+	    {
+	    /* Send resume event */
+	    register XClientMessageEvent *ee;
+	    XEvent e;
+	    XExtData *extData;
+	    DPSCAPData my;
+	    XExtCodes *codes = Codes[dpyix];
+    
+	    extData = XFindOnExtensionList(
+		CSDPSHeadOfDpyExt(xdpy),
+		codes->extension);
+	    if (!extData)
+		return(False);
+	    my = (DPSCAPData) extData->private_data;
+
+	    ee = &e.xclient;
+	    ee->type = ClientMessage;
+	    ee->display = xdpy;
+	    ee->window = my->agentWindow;
+	    ee->format = 32;
+	    ee->message_type = my->typeResume;
+	    ee->data.l[0] = cxid;
+	    ee->data.l[1] = slot->seqnum;
+	    (void) XSendEvent(
+	      xdpy,
+	      my->agentWindow,
+	      False,
+	      NoEventMask,
+	      &e);
+	    XFlush(xdpy);
+	    /* Turn off flag */
+	    slot->paused = False;
+	    --gTotalPaused;
+	    return(True);
+	    }
+    /* Fall thru */
+    return(False);
+}
diff --git a/nx-X11/lib/dps/Xlibnet.h b/nx-X11/lib/dps/Xlibnet.h
new file mode 100644
index 000000000..f86c3542b
--- /dev/null
+++ b/nx-X11/lib/dps/Xlibnet.h
@@ -0,0 +1,284 @@
+/* $XConsortium: Xlibnet.h,v 1.18 91/07/23 19:01:27 rws Exp $ */
+
+/*
+Copyright 1991 Massachusetts Institute of Technology
+
+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 name of M.I.T. not be used in advertising or
+publicity pertaining to distribution of the software without specific,
+written prior permission.  M.I.T. makes no representations about the
+suitability of this software for any purpose.  It is provided "as is"
+without express or implied warranty.
+*/
+/* $XFree86: xc/lib/dps/Xlibnet.h,v 1.6 2001/06/30 22:41:44 tsi Exp $ */
+/*
+ * Xlibnet.h - Xlib networking include files for UNIX Systems.
+ */
+
+#ifndef X_UNIX_PATH
+#ifdef hpux
+#define X_UNIX_PATH "/usr/spool/sockets/X11/"
+#define OLD_UNIX_PATH "/tmp/.X11-unix/X"
+#else
+#define X_UNIX_PATH "/tmp/.X11-unix/X"
+#endif
+#endif /* X_UNIX_PATH */
+
+#ifdef STREAMSCONN
+#ifdef SYSV
+/*
+ * UNIX System V Release 3.2
+ */
+#define BytesReadable(fd,ptr) (_XBytesReadable ((fd), (ptr)))
+#define MALLOC_0_RETURNS_NULL
+#include <sys/ioctl.h>
+
+#endif /* SYSV */
+#ifdef SVR4
+/*
+ * TLI (Streams-based) networking
+ */
+#define BytesReadable(fd,ptr) (_XBytesReadable ((fd), (ptr)))
+#include <sys/uio.h>		/* define struct iovec */
+
+#endif /* SVR4 */
+#else /* not STREAMSCONN */
+/*
+ * socket-based systems
+ */
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <netdb.h>
+#include <sys/uio.h>	/* needed for XlibInt.c */
+#ifdef SVR4
+#include <sys/filio.h>
+#endif
+
+#if defined(i386) && defined(SYSV)
+#if !defined(__SCO__)
+#include <net/errno.h>
+#endif
+#include <sys/stropts.h>
+#define BytesReadable(fd,ptr) ioctl((fd), I_NREAD, (ptr))
+#else
+#define BytesReadable(fd, ptr) ioctl ((fd), FIONREAD, (ptr))
+#endif
+
+#endif /* STREAMSCONN else */
+
+/*
+ * If your BytesReadable correctly detects broken connections, then
+ * you should NOT define XCONN_CHECK_FREQ.
+ */
+#define XCONN_CHECK_FREQ 256
+
+#ifndef X_NOT_POSIX
+#ifdef _POSIX_SOURCE
+#include <limits.h>
+#else
+#define _POSIX_SOURCE
+#include <limits.h>
+#undef _POSIX_SOURCE
+#endif
+#endif
+#ifndef OPEN_MAX
+#ifdef SVR4
+#define OPEN_MAX 256
+#else
+#include <sys/param.h>
+#ifndef OPEN_MAX
+#ifdef NOFILE
+#define OPEN_MAX NOFILE
+#else
+#if !defined(__UNIXOS2__) && !defined(__QNX__)
+#define OPEN_MAX NOFILES_MAX
+#else
+#define OPEN_MAX 256
+#endif
+#endif
+#endif
+#endif
+#endif
+
+#if OPEN_MAX > 256
+#undef OPEN_MAX
+#define OPEN_MAX 256
+#endif
+
+/* Adobe additions */
+#ifdef MSKCNT
+#undef MSKCNT
+#endif
+#ifdef BITMASK
+#undef BITMASK
+#endif
+#ifdef MASKIDX
+#undef MASKIDX
+#endif
+
+#define MSKCNT ((OPEN_MAX + 31) / 32)
+
+#if (MSKCNT==1)
+#define BITMASK(i) (1 << (i))
+#define MASKIDX(i) 0
+#endif
+#if (MSKCNT>1)
+#define BITMASK(i) (1 << ((i) & 31))
+#define MASKIDX(i) ((i) >> 5)
+#endif
+
+#define MASKWORD(buf, i) buf[MASKIDX(i)]
+#define BITSET(buf, i) MASKWORD(buf, i) |= BITMASK(i)
+#define BITCLEAR(buf, i) MASKWORD(buf, i) &= ~BITMASK(i)
+#define GETBIT(buf, i) (MASKWORD(buf, i) & BITMASK(i))
+
+/* Adobe additions */
+#ifdef COPYBITS
+#undef COPYBITS
+#undef CLEARBITS 
+#undef MASKANDSETBITS 
+#undef ORBITS 
+#undef UNSETBITS
+#endif
+
+#if (MSKCNT==1)
+#define COPYBITS(src, dst) dst[0] = src[0]
+#define CLEARBITS(buf) buf[0] = 0
+#define MASKANDSETBITS(dst, b1, b2) dst[0] = (b1[0] & b2[0])
+#define ORBITS(dst, b1, b2) dst[0] = (b1[0] | b2[0])
+#define UNSETBITS(dst, b1) (dst[0] &= ~b1[0])
+#define _XANYSET(src) (src[0])
+#endif
+#if (MSKCNT==2)
+#define COPYBITS(src, dst) { dst[0] = src[0]; dst[1] = src[1]; }
+#define CLEARBITS(buf) { buf[0] = 0; buf[1] = 0; }
+#define MASKANDSETBITS(dst, b1, b2)  {\
+		      dst[0] = (b1[0] & b2[0]);\
+		      dst[1] = (b1[1] & b2[1]); }
+#define ORBITS(dst, b1, b2)  {\
+		      dst[0] = (b1[0] | b2[0]);\
+		      dst[1] = (b1[1] | b2[1]); }
+#define UNSETBITS(dst, b1) {\
+                      dst[0] &= ~b1[0]; \
+                      dst[1] &= ~b1[1]; }
+#define _XANYSET(src) (src[0] || src[1])
+#endif
+#if (MSKCNT==3)
+#define COPYBITS(src, dst) { dst[0] = src[0]; dst[1] = src[1]; \
+			     dst[2] = src[2]; }
+#define CLEARBITS(buf) { buf[0] = 0; buf[1] = 0; buf[2] = 0; }
+#define MASKANDSETBITS(dst, b1, b2)  {\
+		      dst[0] = (b1[0] & b2[0]);\
+		      dst[1] = (b1[1] & b2[1]);\
+		      dst[2] = (b1[2] & b2[2]); }
+#define ORBITS(dst, b1, b2)  {\
+		      dst[0] = (b1[0] | b2[0]);\
+		      dst[1] = (b1[1] | b2[1]);\
+		      dst[2] = (b1[2] | b2[2]); }
+#define UNSETBITS(dst, b1) {\
+                      dst[0] &= ~b1[0]; \
+                      dst[1] &= ~b1[1]; \
+                      dst[2] &= ~b1[2]; }
+#define _XANYSET(src) (src[0] || src[1] || src[2])
+#endif
+#if (MSKCNT==4)
+#define COPYBITS(src, dst) dst[0] = src[0]; dst[1] = src[1]; \
+			   dst[2] = src[2]; dst[3] = src[3]
+#define CLEARBITS(buf) buf[0] = 0; buf[1] = 0; buf[2] = 0; buf[3] = 0
+#define MASKANDSETBITS(dst, b1, b2)  \
+                      dst[0] = (b1[0] & b2[0]);\
+                      dst[1] = (b1[1] & b2[1]);\
+                      dst[2] = (b1[2] & b2[2]);\
+                      dst[3] = (b1[3] & b2[3])
+#define ORBITS(dst, b1, b2)  \
+                      dst[0] = (b1[0] | b2[0]);\
+                      dst[1] = (b1[1] | b2[1]);\
+                      dst[2] = (b1[2] | b2[2]);\
+                      dst[3] = (b1[3] | b2[3])
+#define UNSETBITS(dst, b1) \
+                      dst[0] &= ~b1[0]; \
+                      dst[1] &= ~b1[1]; \
+                      dst[2] &= ~b1[2]; \
+                      dst[3] &= ~b1[3]
+#define _XANYSET(src) (src[0] || src[1] || src[2] || src[3])
+#endif
+
+#if (MSKCNT>4)
+#define COPYBITS(src, dst) bcopy((char *) src, (char *) dst,\
+				 MSKCNT*sizeof(long))
+#define CLEARBITS(buf) bzero((char *) buf, MSKCNT*sizeof(long))
+#define MASKANDSETBITS(dst, b1, b2)  \
+		      { int cri;			\
+			for (cri=MSKCNT; --cri>=0; )	\
+		          dst[cri] = (b1[cri] & b2[cri]); }
+#define ORBITS(dst, b1, b2)  \
+		      { int cri;			\
+		      for (cri=MSKCNT; --cri>=0; )	\
+		          dst[cri] = (b1[cri] | b2[cri]); }
+#define UNSETBITS(dst, b1) \
+		      { int cri;			\
+		      for (cri=MSKCNT; --cri>=0; )	\
+		          dst[cri] &= ~b1[cri];  }
+/*
+ * If MSKCNT>4, then _XANYSET is a routine defined in XlibInt.c.
+ *
+ * #define _XANYSET(src) (src[0] || src[1] || src[2] || src[3] || src[4] ...)
+ */
+extern int N_XANYSET(unsigned long *);
+#endif
+
+/*
+ *	ReadvFromServer and WritevToSever use struct iovec, normally found
+ *	in Berkeley systems in <sys/uio.h>.  See the readv(2) and writev(2)
+ *	manual pages for details.
+ *
+ *	struct iovec {
+ *		caddr_t iov_base;
+ *		int iov_len;
+ *	};
+ */
+#if defined(USG) && !defined(CRAY) && !defined(umips) && !defined(MOTOROLA)
+struct iovec {
+    caddr_t iov_base;
+    int iov_len;
+};
+#endif /* USG */
+
+
+#ifdef STREAMSCONN
+#include "Xstreams.h"
+
+extern char _XsTypeOfStream[];
+extern Xstream _XsStream[];
+
+#define ReadFromServer(dpy, data, size) \
+	(*_XsStream[_XsTypeOfStream[dpy]].ReadFromStream)((dpy), (data), (size), \
+						     BUFFERING)
+#define WriteToServer(dpy, bufind, size) \
+	(*_XsStream[_XsTypeOfStream[dpy]].WriteToStream)((dpy), (bufind), (size))
+
+#else /* else not STREAMSCONN */
+
+/*
+ * bsd can read from sockets directly
+ */
+#define ReadFromServer(dpy, data, size) read((dpy), (data), (size))
+#define WriteToServer(dpy, bufind, size) write((dpy), (bufind), (size))
+
+#endif /* STREAMSCONN */
+
+
+#ifndef USL_COMPAT
+#if !defined(USG) || defined(MOTOROLA) || \
+	defined(__SCO__) || (!(defined(SYSV) && defined(i386))) || \
+	defined(__UNIXWARE__)
+#define _XReadV readv
+#define _XWriteV writev
+#endif
+#endif /* !USL_COMPAT */
+
+#define ReadvFromServer(dpy, iov, iovcnt) _XReadV((dpy), (iov), (iovcnt))
+#define WritevToServer(dpy, iov, iovcnt) _XWriteV((dpy), (iov), (iovcnt))
diff --git a/nx-X11/lib/dps/Xstreams.h b/nx-X11/lib/dps/Xstreams.h
new file mode 100644
index 000000000..a7419131b
--- /dev/null
+++ b/nx-X11/lib/dps/Xstreams.h
@@ -0,0 +1,218 @@
+/* $XConsortium: Xstreams.h,v 1.6 91/07/19 23:22:53 gildea Exp $ */
+/*	Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */
+/*	Copyright (c) 1988 AT&T */
+/*	  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 of AT&T or USL not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  AT&T and USL make no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * AT&T and USL DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
+ * NO EVENT SHALL AT&T or USL 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.
+ */
+/* $XFree86$ */
+
+
+#ifndef _XSTREAMS_H_
+#define _XSTREAMS_H_
+/*
+ Xstreams.h (C header file)
+	Acc: 575304412 Tue Apr 26 09:46:52 1988
+	Mod: 574017273 Tue Apr 26 12:14:33 1988
+	Sta: 574017273 Tue Apr 26 12:14:33 1988
+	Owner: 2011
+	Group: 1985
+	Permissions: 644
+*/
+/*
+	START USER STAMP AREA
+*/
+/*
+	END USER STAMP AREA
+*/
+
+
+
+#define	MEM_ALLIGN(ptr) ((((unsigned) (ptr + 3)) >> 2) << 2)
+
+#define	CONNECT_TIMEOUT		60
+#define	MAX_AUTO_BUF_LEN	256
+#define	MAX_DISP_DIGITS		20
+#define	MAX_NETS	8
+
+typedef struct _host {
+	char	host_name[32];
+	int	host_len;
+	struct _host *next;
+} HOST;
+
+/*
+ * Structure for handling multiple connection requests on the same stream.
+ */
+
+struct listenCall {
+	struct t_call *CurrentCall;
+	struct listenCall *NextCall;
+};
+
+struct listenQue {
+	struct listenCall *QueHead;
+	struct listenCall *QueTail;
+};
+
+#define EMPTY(p)	(p->QueHead == (struct listenCall *) NULL)
+
+
+typedef struct {
+	int	flags;
+	char	type;
+	int	display;
+	char	*inputbuf;
+	int	buflen;
+	int	bufptr;
+	int	msglen;
+	} IOBUFFER;
+
+typedef struct {
+	int	_nnets;
+#ifdef SVR4
+	struct netconfig *_net[MAX_NETS];
+#else
+	char	*_net[MAX_NETS];
+#endif
+        struct listenQue FreeList[MAX_NETS];
+	struct listenQue PendingQue[MAX_NETS];
+	int	_npeers;
+	char	**_peer;
+	int	*_peerlen;
+	HOST	*_validhosts;
+	} networkInfo;
+
+
+typedef struct _Xstream {
+	int	(*SetupTheListener)();
+	int	(*ConnectNewClient)();
+	int	(*CallTheListener)();
+	int	(*ReadFromStream)();
+	int	(*BytesCanBeRead)();
+	int	(*WriteToStream)();
+	int	(*CloseStream)();
+	int	(*CreateAddress)();
+	union ext {
+		int	(*NameServer)();
+		networkInfo *NetInfo;
+		} u;	
+	} Xstream;
+
+/* old shared libraries have the names already fixed */
+#ifdef USL_COMPAT
+#define _XsStream		xstream
+#define _XReadV			_readv
+#define _XWriteV		_writev
+#define _XSelect 		XSelect
+#define _XsErrorCall		ErrorCall		
+#define	_XsSetupLocalStream	SetupLocalStream
+#define	_XsConnectLocalClient	ConnectLocalClient
+#define	_XsOpenSpServer		OpenSpServer
+#define	_XsReadLocalStream	ReadLocalStream
+#define	_XsConnectTliClient	ConnectTliClient
+#define _XsSetupTliStrean	SetupTliStream
+#define _XsCallTliServer	CallTliServer
+#define	_XsCallLocalServer	CallLocalServer
+#define _XsTypeOfStream		TypeOfStream
+#ifdef SVR4
+#define	_XsSetupNamedStream	SetupNamedStream
+#define _XsSetupSpStream	SetupSpStream
+#endif /* SVR4 */
+#endif /* USL_COMPAT */
+
+extern Xstream _XsStream[];
+
+#define NO_BUFFERING	0
+#define BUFFERING	1
+
+/* Network services */
+
+#define OpenDaemonConnection	0
+#define	PEER_NAME		1
+#define	PEER_ALLOC		2
+#define	PEER_FREE		3
+#define	ConvertNetAddrToName	4
+#define	ConvertNameToNetAddr	5
+#define	ConvertNameToTliCall	6
+#define	ConvertTliCallToName	7
+#define	ConvertNameToTliBind	8
+
+#define	UNAME_LENGTH	14
+
+#define X_LOCAL_STREAM	0
+#define X_NAMED_STREAM	1
+/* Enhanced Application Compatibility Support */
+#define X_SP_STREAM	2
+/* End Enhanced Application Compatibility Support */
+
+#define X_TLI_STREAM	3
+#define CLOSED_STREAM	-1
+
+/*
+	The following are defined in X.h. Any changes to FamilyUname
+	should take X.h into consideration.
+*/
+		/* protocol families */
+
+		/*
+
+		#define FamilyInternet		0
+		#define FamilyDECnet		1
+		#define FamilyChaos		2
+
+		*/
+
+#define FamilyUname	3
+
+#define X_TCP_PORT		6000
+
+#define NAMED_LISTENER "/dev/X/Nserver"
+#define LOCAL_LISTENER "/dev/X/server"
+/* Enhanced Application Compatibility Support */
+/* End Enhanced Application Compatibility Support */
+
+#define	NAME_SERVER_NODE "/dev/X/nameserver"
+#define XNETSPECDIR	"lib/net"
+#define XROOTDIR "/usr/X"
+
+#define	MAX_SIMUL_TLI_CALLS	20
+
+#define SetupNetworkInfo()   _XsStream[X_LOCAL_STREAM].u.NetInfo = &Network; \
+	_XsStream[X_NAMED_STREAM].u.NetInfo = &Network; \
+/* Enhanced Application Compatibility Support */ \
+/* End Enhanced Application Compatibility Support */ \
+	_XsStream[X_TLI_STREAM].u.NameServer = nameserver
+
+#define NetworkInfo (_XsStream[X_LOCAL_STREAM].u.NetInfo)
+#define GetNetworkInfo (*_XsStream[X_TLI_STREAM].u.NameServer)
+#define validhosts _XsStream[X_LOCAL_STREAM].u.NetInfo->_validhosts
+
+/*
+ *	header of messages sent by X to the nameserver 
+ *      1st int: the size of the entire message.
+ *	2nd int: the size of the header itself.
+ *  	3rd int: the service number.
+ *      4th int: the display number.
+ * 	5th int: the length of the network name.
+ */
+ 
+#define HEADERSIZE	(5*sizeof(int))
+#endif /* _XSTREAMS_H_ */
diff --git a/nx-X11/lib/dps/csconndi.c b/nx-X11/lib/dps/csconndi.c
new file mode 100644
index 000000000..64205f8dc
--- /dev/null
+++ b/nx-X11/lib/dps/csconndi.c
@@ -0,0 +1,839 @@
+/*
+ * csconndi.c -- low level connection maker for CSDPS
+ * 
+ * (c) Copyright 1990-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
+ * 
+ * Portions Copyright 1989 Massachusetts Institute of Technology
+ *
+ * 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 name of M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *  
+ * Author:  Adobe Systems Incorporated and MIT X Consortium
+ */
+/* $XFree86: xc/lib/dps/csconndi.c,v 1.11tsi Exp $ */
+
+#if defined(sun) && !defined(SVR4)
+#define memmove(t,f,c) bcopy(f,t,c)
+#endif
+
+#define NEED_EVENTS
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <X11/Xos.h>
+/* Include this first so that Xasync.h, included from Xlibint.h, can find
+   the definition of NOFILE */
+#include <sys/param.h>
+#include <X11/Xlibint.h>
+#include "Xlibnet.h"		/* New for R5, delete for R4 */
+#include <arpa/inet.h>
+
+#ifndef hpux	/* HP doesn't include Xauth.h :-( */
+#include <X11/Xauth.h>
+#else
+#define FamilyLocal (256)
+#endif
+
+#include <ctype.h>
+#ifdef DNETCONN
+#include <netdnet/dn.h>
+#include <netdnet/dnetdb.h>
+#endif
+
+#include <netdb.h>
+
+#include "DPSCAPproto.h"
+#include "cslibint.h"
+#include "dpsassert.h"
+
+#if defined(hpux) || defined(AIXV3)
+#define SELECT_TYPE int *
+#else
+#define SELECT_TYPE fd_set *
+#endif
+
+#ifndef _XANYSET
+#define _XANYSET N_XANYSET
+#endif /* _XANYSET */
+
+#ifndef X_CONNECTION_RETRIES		/* number retries on ECONNREFUSED */
+#define X_CONNECTION_RETRIES 5
+#endif
+
+#define CONN_PARAMS char *, int , int , int *, int *, char **
+
+#ifdef DNETCONN
+static int MakeDECnetConnection(CONN_PARAMS);
+#endif
+#ifdef UNIXCONN
+static int MakeUNIXSocketConnection(CONN_PARAMS);
+#endif
+#ifdef TCPCONN
+static int MakeTCPConnection(CONN_PARAMS);
+#endif
+#ifdef STREAMSCONN
+extern int _XMakeStreamsConnection(CONN_PARAMS);
+#endif
+
+/* This global controls the size of the output socket buffer.  Zero
+   means to use the system default size. */
+int gNXSndBufSize = 0;
+
+static char *copystring (char *src, int len)
+{
+    char *dst = Xmalloc (len + 1);
+
+    if (dst) {
+	strncpy (dst, src, len);
+	dst[len] = '\0';
+    }
+
+    return dst;
+}
+
+
+/* 
+ * Attempts to connect to agent, given name. Returns file descriptor
+ * (network socket) or -1 if connection fails.  Names may be of the
+ * following format:
+ *
+ *     [hostname] : [:] agentnumber
+ *
+ * The second colon indicates a DECnet style name.  No hostname is interpretted
+ * as the most efficient local connection to a server on the same machine.  
+ * This is usually:
+ *
+ *     o  shared memory
+ *     o  local stream
+ *     o  UNIX domain socket
+ *     o  TCP to local host
+ */
+ 
+int 
+DPSCAPConnect(
+    char *display_name,
+    char **fullnamep,			/* RETURN */
+    int *dpynump,			/* RETURN */
+    int *familyp,			/* RETURN */
+    int *saddrlenp,			/* RETURN */
+    char **saddrp)			/* RETURN, freed by caller */
+{
+    char *lastp, *p;			/* char pointers */
+    char *phostname = NULL;		/* start of host of display */
+    char *pdpynum = NULL;		/* start of dpynum of display */
+    char *pscrnum = NULL;		/* start of screen of display */
+    Bool dnet = False;			/* if true, then DECnet format */
+    int iagent;				/* required display number */
+    int (*connfunc)(CONN_PARAMS);	/* method to create connection */
+    int fd = -1;			/* file descriptor to return */
+    int len;				/* length tmp variable */
+
+    p = display_name;
+
+    *saddrlenp = 0;			/* set so that we can clear later */
+    *saddrp = NULL;
+
+    /*
+     * Step 1, find the hostname.  This is delimited by the required 
+     * first colon.
+     */
+    for (lastp = p; *p && *p != ':'; p++) ;
+    if (!*p) return -1;		/* must have a colon */
+
+    if (p != lastp) {		/* no hostname given */
+	phostname = copystring (lastp, p - lastp);
+	if (!phostname) goto bad;	/* no memory */
+    }
+
+
+    /*
+     * Step 2, see if this is a DECnet address by looking for the optional
+     * second colon.
+     */
+    if (p[1] == ':') {			/* then DECnet format */
+	dnet = True;
+	p++;
+    }
+
+    /*
+     * see if we're allowed to have a DECnet address
+     */
+#ifndef DNETCONN
+    if (dnet) goto bad;
+#endif
+
+    
+    /*
+     * Step 3, find the port number.  This field is required.
+     * Zero is acceptable as a port number, meaning use the default.
+     */
+
+    for (lastp = ++p; *p && isascii(*p) && isdigit(*p); p++) ;
+    if ((p == lastp) ||			/* required field */
+	(*p != '\0' && *p != '.') ||	/* invalid non-digit terminator */
+	!(pdpynum = copystring (lastp, p - lastp)))  /* no memory */
+      goto bad;
+    iagent = atoi (pdpynum);
+
+
+    /*
+     * At this point, we know the following information:
+     *
+     *     phostname                hostname string or NULL
+     *     iagent                   agent port number
+     *     dnet                     DECnet boolean
+     * 
+     * We can now decide which transport to use based on the ConnectionFlags
+     * build parameter the hostname string.  If phostname is NULL or equals
+     * the string "local", then choose the best transport.  If phostname
+     * is "unix", then choose BSD UNIX domain sockets (if configured).
+     *
+     * First, choose default transports:  DECnet else (TCP or STREAMS)
+     */
+
+
+#ifdef DNETCONN
+    if (dnet)
+      connfunc = MakeDECnetConnection;
+    else
+#endif
+#ifdef TCPCONN
+      connfunc = MakeTCPConnection;
+#else
+#ifdef STREAMSCONN
+      connfunc = _XMakeStreamsConnection;
+#else
+      connfunc = NULL;
+#endif
+#endif
+
+#ifdef UNIXCONN
+    /*
+     * Now that the defaults have been established, see if we have any 
+     * special names that we have to override:
+     *
+     *     :N         =>     if UNIXCONN then unix-domain-socket
+     *     ::N        =>     if UNIXCONN then unix-domain-socket
+     *     unix:N     =>     if UNIXCONN then unix-domain-socket
+     *
+     * Note that if UNIXCONN isn't defined, then we can use the default
+     * transport connection function set above.
+     */
+    if (!phostname) {
+	connfunc = MakeUNIXSocketConnection;
+    }
+    else if (strcmp (phostname, "unix") == 0) {
+	connfunc = MakeUNIXSocketConnection;
+    }
+#endif
+    if (!connfunc)
+	goto bad;
+
+
+#ifdef UNIXCONN
+#define LOCALCONNECTION (!phostname || connfunc == MakeUNIXSocketConnection)
+#else
+#define LOCALCONNECTION (!phostname)
+#endif
+
+    if (LOCALCONNECTION) {
+	/*
+	 * Get the auth info for local hosts so that it doesn't have to be
+	 * repeated everywhere; the particular values in these fields are
+	 * not part of the protocol.
+	 */
+	char hostnamebuf[256];
+	int len = N_XGetHostname (hostnamebuf, sizeof hostnamebuf);
+
+	*familyp = FamilyLocal;
+	if (len > 0) {
+	    *saddrp = Xmalloc (len + 1);
+	    if (*saddrp) {
+		strcpy (*saddrp, hostnamebuf);
+		*saddrlenp = len;
+	    } else {
+		*saddrlenp = 0;
+	    }
+	}
+    }
+#undef LOCALCONNECTION
+
+#ifndef ultrix
+    /* Ultrix has a nasty bug in getservbyname(); if the name passed to
+       it is not in the services list it seg faults!  *sigh*  So, we
+       don't ever look in the services info for ultrix... */
+    if (iagent == 0) {		/* find service default, if one's defined */
+      struct servent *serventInfo;
+      
+      if ((serventInfo = getservbyname(DPS_NX_SERV_NAME,
+      				       (char *) NULL)) != NULL) {
+	if (strcmp("tcp", serventInfo->s_proto) != 0) {
+	  DPSWarnProc(NULL, "Services database specifies a protocol other than tcp.  Using default port.\n");
+	} else 			/* extract the port number */
+          iagent = ntohs(serventInfo->s_port);
+      }
+    }
+#endif /* ultrix */    
+    /*
+     * Make the connection, also need to get the auth address info for
+     * non-local connections.  Do retries in case server host has hit its
+     * backlog (which, unfortunately, isn't distinguishable from there not
+     * being a server listening at all, which is why we have to not retry
+     * too many times).
+     */
+    if ((fd = (*connfunc) (phostname, iagent, X_CONNECTION_RETRIES,
+			   familyp, saddrlenp, saddrp)) < 0)
+      goto bad;
+
+
+    /*
+     * Set the connection non-blocking since we use select() to block; also
+     * set close-on-exec so that programs that fork() doesn't get confused.
+     */
+#ifdef FIOSNBIO
+    {
+	int arg = 1;
+	ioctl (fd, FIOSNBIO, &arg);
+    }
+#else
+#if defined(O_NONBLOCK)
+    (void) fcntl (fd, F_SETFL, O_NONBLOCK);
+#elif defined(FNDELAY)
+    (void) fcntl (fd, F_SETFL, FNDELAY);
+#else
+    (void) fcntl (fd, F_SETFL, O_NDELAY);
+#endif /* O_NONBLOCK/FNDELAY */
+#endif /* FIOSNBIO */
+
+    (void) fcntl (fd, F_SETFD, 1);
+
+
+    /*
+     * Build the expanded display name:
+     *
+     *     [host] : [:] agent \0
+     */
+    len = ((phostname ? strlen(phostname) : 0) + 1 + (dnet ? 1 : 0) +
+	   strlen(pdpynum) + 1);
+    *fullnamep = (char *) Xmalloc (len);
+    if (!*fullnamep) goto bad;
+
+    sprintf (*fullnamep, "%s%s%d",
+	     (phostname ? phostname : ""), (dnet ? "::" : ":"),
+	     iagent);
+
+    *dpynump = iagent;
+    if (phostname) Xfree (phostname);
+    if (pdpynum) Xfree (pdpynum);
+    if (pscrnum) Xfree (pscrnum);
+    return fd;
+
+
+    /*
+     * error return; make sure everything is cleaned up.
+     */
+  bad:
+    if (fd >= 0) (void) close (fd);
+    if (*saddrp) {
+	Xfree (*saddrp);
+	*saddrp = NULL;
+    }
+    *saddrlenp = 0;
+    if (phostname) Xfree (phostname);
+    if (pdpynum) Xfree (pdpynum);
+    return -1;
+
+}
+
+
+/*****************************************************************************
+ *                                                                           *
+ *			   Make Connection Routines                          *
+ *                                                                           *
+ *****************************************************************************/
+
+#ifdef DNETCONN				/* stupid makedepend */
+#define NEED_BSDISH
+#endif
+#ifdef UNIXCONN
+#define NEED_BSDISH
+#endif
+#ifdef TCPCONN
+#define NEED_BSDISH
+#endif
+
+#ifdef NEED_BSDISH			/* makedepend can't handle #if */
+/*
+ * 4.2bsd-based systems
+ */
+#include <sys/socket.h>
+
+#ifndef hpux
+#ifdef apollo			/* nest if(n)defs because makedepend is broken */
+#ifndef NO_TCP_H
+#include <netinet/tcp.h>
+#endif /* NO_TCP_H */
+#else  /* apollo */
+#include <netinet/tcp.h>
+#endif /* apollo */
+#endif
+#endif /* NEED_BSDISH */
+
+
+#ifdef DNETCONN
+static int MakeDECnetConnection (phostname, iagent, retries,
+				 familyp, saddrlenp, saddrp)
+    char *phostname;
+    int iagent;
+    int retries;
+    int *familyp;			/* RETURN */
+    int *saddrlenp;			/* RETURN */
+    char **saddrp;			/* RETURN */
+{
+    int fd;
+    char objname[20];
+    extern int dnet_conn();
+    struct dn_naddr *dnaddrp, dnaddr;
+    struct nodeent *np;
+
+    if (!phostname) phostname = "0";
+
+    /*
+     * build the target object name.
+     */
+    sprintf (objname, "DPS$EXECUTIVE_%d", iagent);
+
+    /*
+     * Attempt to open the DECnet connection, return -1 if fails; ought to
+     * do some retries here....
+     */
+    if ((fd = dnet_conn (phostname, objname, SOCK_STREAM, 0, 0, 0, 0)) < 0) {
+	return -1;
+    }
+
+    *familyp = FamilyDECnet;
+    if (dnaddrp = dnet_addr (phostname)) {  /* stolen from xhost */
+	dnaddr = *dnaddrp;
+    } else {
+	if ((np = getnodebyname (phostname)) == NULL) {
+	    (void) close (fd);
+	    return -1;
+	}
+	dnaddr.a_len = np->n_length;
+	memmove(dnaddr.a_addr, np->n_addr, np->n_length);
+    }
+
+    *saddrlenp = sizeof (struct dn_naddr);
+    *saddrp = Xmalloc (*saddrlenp);
+    if (!*saddrp) {
+	(void) close (fd);
+	return -1;
+    }
+    memmove (*saddrp, (char *)&dnaddr, *saddrlenp);
+    return fd;
+}
+#endif /* DNETCONN */
+
+
+#ifdef UNIXCONN
+
+#ifndef X_NO_SYS_UN
+#include <sys/un.h>
+#endif
+
+#ifndef CSDPS_UNIX_PATH
+#ifdef hpux
+#define CSDPS_UNIX_DIR      "/usr/spool/sockets/DPSNX"
+#define CSDPS_UNIX_PATH     "/usr/spool/sockets/DPSNX/"
+#else
+#define CSDPS_UNIX_DIR      "/tmp/.DPSNX-unix"
+#define CSDPS_UNIX_PATH     "/tmp/.DPSNX-unix/AGENT"
+#endif
+#endif
+
+static int MakeUNIXSocketConnection (
+    char *phostname,
+    int iagent,
+    int retries,
+    int *familyp,			/* RETURN */
+    int *saddrlenp,			/* RETURN */
+    char **saddrp)			/* RETURN */
+{
+    struct sockaddr_un unaddr;		/* UNIX socket data block */
+    struct sockaddr *addr;		/* generic socket pointer */
+    int addrlen;			/* length of addr */
+    int fd;				/* socket file descriptor */
+    int port = (iagent == 0) ? CSDPSPORT : iagent;
+
+    unaddr.sun_family = AF_UNIX;
+    sprintf (unaddr.sun_path, "%s_%d", CSDPS_UNIX_PATH, port);
+
+    addr = (struct sockaddr *) &unaddr;
+    addrlen = strlen(unaddr.sun_path) + sizeof(unaddr.sun_family);
+
+    /*
+     * Open the network connection.
+     */
+    do {
+	if ((fd = socket ((int) addr->sa_family, SOCK_STREAM, 0)) < 0) {
+	    return -1;
+	}
+
+        if (gNXSndBufSize > 0)
+	    setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char *) &gNXSndBufSize, sizeof(gNXSndBufSize));
+
+	if (connect (fd, addr, addrlen) < 0) {
+	    int olderrno = errno;
+	    (void) close (fd);
+	    if (olderrno != ENOENT || retries <= 0) {
+		errno = olderrno;
+		return -1;
+	    }
+	    sleep (1);
+	} else {
+	    break;
+	}
+    } while (retries-- > 0);
+
+    /*
+     * Don't need to get auth info since we're local
+     */
+    return fd;
+}
+#endif /* UNIXCONN */
+
+
+#ifdef TCPCONN
+static int MakeTCPConnection (
+    char *phostname,
+    int iagent,
+    int retries,
+    int *familyp,			/* RETURN */
+    int *saddrlenp,			/* RETURN */
+    char **saddrp)			/* RETURN */
+{
+    char hostnamebuf[256];		/* tmp space */
+    unsigned long hostinetaddr;		/* result of inet_addr of arpa addr */
+    struct sockaddr_in inaddr;		/* IP socket */
+    struct sockaddr *addr;		/* generic socket pointer */
+    int addrlen;			/* length of addr */
+    struct hostent *hp;			/* entry in hosts table */
+    char *cp;				/* character pointer iterator */
+    int fd;				/* file descriptor to return */
+    int len;				/* length tmp variable */
+
+#define INVALID_INETADDR ((unsigned long) -1)
+
+    if (!phostname) {
+	hostnamebuf[0] = '\0';
+	(void) N_XGetHostname (hostnamebuf, sizeof hostnamebuf);
+	phostname = hostnamebuf;
+    }
+
+    /*
+     * if numeric host name then try to parse it as such; do the number
+     * first because some systems return garbage instead of INVALID_INETADDR
+     */
+    if (isascii(phostname[0]) && isdigit(phostname[0])) {
+	hostinetaddr = inet_addr (phostname);
+    } else {
+	hostinetaddr = INVALID_INETADDR;
+    }
+
+    /*
+     * try numeric
+     */
+    if (hostinetaddr == INVALID_INETADDR) {
+	if ((hp = gethostbyname(phostname)) == NULL) {
+	    /* No such host! */
+	    return -1;
+	}
+	if (hp->h_addrtype != AF_INET) {  /* is IP host? */
+	    /* Not an Internet host! */
+	    return -1;
+	}
+ 
+	/* Set up the socket data. */
+	inaddr.sin_family = hp->h_addrtype;
+#if defined(CRAY) && defined(OLDTCP)
+	/* Only Cray UNICOS3 and UNICOS4 will define this */
+	{
+	    long t;
+	    memmove ((char *)&t, (char *)hp->h_addr, sizeof(t));
+	    inaddr.sin_addr = t;
+	}
+#else
+	memmove ((char *)&inaddr.sin_addr, (char *)hp->h_addr, 
+	       sizeof(inaddr.sin_addr));
+#endif /* CRAY and OLDTCP */
+    } else {
+#if defined(CRAY) && defined(OLDTCP)
+	/* Only Cray UNICOS3 and UNICOS4 will define this */
+	inaddr.sin_addr = hostinetaddr;
+#else
+	inaddr.sin_addr.s_addr = hostinetaddr;
+#endif /* CRAY and OLDTCP */
+	inaddr.sin_family = AF_INET;
+    }
+
+    addr = (struct sockaddr *) &inaddr;
+    addrlen = sizeof (struct sockaddr_in);
+    inaddr.sin_port = (iagent == 0) ? CSDPSPORT : iagent;
+    inaddr.sin_port = htons (inaddr.sin_port);	/* may be funky macro */
+
+
+    /*
+     * Open the network connection.
+     */
+    do {
+	if ((fd = socket ((int) addr->sa_family, SOCK_STREAM, 0)) < 0) {
+	    return -1;
+	}
+
+	/*
+	 * turn off TCP coalescence
+	 */
+#ifdef TCP_NODELAY
+	{
+	    int tmp = 1;
+	    setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, (char *)&tmp, sizeof (int));
+	}
+#endif
+        if (gNXSndBufSize > 0)
+	    len = setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char *) &gNXSndBufSize, sizeof(gNXSndBufSize));
+
+	/*
+	 * connect to the socket; if there is no X server or if the backlog has
+	 * been reached, then ECONNREFUSED will be returned.
+	 */
+	if (connect (fd, addr, addrlen) < 0) {
+	    int olderrno = errno;
+	    (void) close (fd);
+	    if (olderrno != ECONNREFUSED || retries <= 0) {
+		errno = olderrno;
+		return -1;
+	    }
+	    sleep (1);
+	} else {
+	    break;
+	}
+    } while (retries-- > 0);
+
+
+    /*
+     * Success!  So, save the auth information
+     */
+#ifdef CRAY
+#ifdef OLDTCP
+    len = sizeof(inaddr.sin_addr);
+#else
+    len = SIZEOF_in_addr;
+#endif /* OLDTCP */
+    cp = (char *) &inaddr.sin_addr;
+#else /* else not CRAY */
+    len = sizeof(inaddr.sin_addr.s_addr);
+    cp = (char *) &inaddr.sin_addr.s_addr;
+#endif /* CRAY */
+
+    /*
+     * We are special casing the BSD hack localhost address
+     * 127.0.0.1, since this address shouldn't be copied to
+     * other machines.  So, we simply omit generating the auth info
+     * since we set it to the local machine before calling this routine!
+     */
+    if (!((len == 4) && (cp[0] == 127) && (cp[1] == 0) &&
+	  (cp[2] == 0) && (cp[3] == 1))) {
+	*saddrp = Xmalloc (len);
+	if (*saddrp) {
+	    *saddrlenp = len;
+	    memmove (*saddrp, cp, len);
+	    *familyp = FamilyInternet;
+	} else {
+	    *saddrlenp = 0;
+	}
+    }
+
+    return fd;
+}
+#undef INVALID_INETADDR
+#endif /* TCPCONN */
+
+
+/*****************************************************************************
+ *                                                                           *
+ *			  Connection Utility Routines                        *
+ *                                                                           *
+ *****************************************************************************/
+
+/* 
+ * Disconnect from server.
+ */
+
+int N_XDisconnectDisplay (int server)
+{
+    (void) close(server);
+    return 0;
+}
+
+
+#include <stddef.h>
+/*
+ * This is an OS dependent routine which:
+ * 1) returns as soon as the connection can be written on....
+ * 2) if the connection can be read, must enqueue events and handle errors,
+ * until the connection is writable.
+ */
+void N_XWaitForWritable(Display *dpy)
+{
+    unsigned long r_mask[MSKCNT];
+    unsigned long w_mask[MSKCNT];
+    int nfound;
+
+    CLEARBITS(r_mask);
+    CLEARBITS(w_mask);
+
+    while (1) {
+	BITSET(r_mask, dpy->fd);
+        BITSET(w_mask, dpy->fd);
+
+	do {
+	    nfound = select (dpy->fd + 1, (SELECT_TYPE) r_mask,
+			     (SELECT_TYPE) w_mask, (SELECT_TYPE) NULL,
+			     (struct timeval *) NULL);
+	    if (nfound < 0 && errno != EINTR)
+		_XIOError(dpy);
+	} while (nfound <= 0);
+
+	if (_XANYSET(r_mask)) {
+	    char buf[BUFSIZE];
+	    long pend_not_register;
+	    register long pend;
+	    register xEvent *ev;
+
+	    /* find out how much data can be read */
+	    if (BytesReadable(dpy->fd, (char *) &pend_not_register) < 0)
+		_XIOError(dpy);
+	    pend = pend_not_register;
+
+	    /* must read at least one xEvent; if none is pending, then
+	       we'll just block waiting for it */
+	    if (pend < SIZEOF(xEvent)) pend = SIZEOF(xEvent);
+		
+	    /* but we won't read more than the max buffer size */
+	    if (pend > BUFSIZE) pend = BUFSIZE;
+
+	    /* round down to an integral number of XReps */
+	    pend = (pend / SIZEOF(xEvent)) * SIZEOF(xEvent);
+
+	    N_XRead (dpy, buf, pend);
+
+	    /* no space between comma and type or else macro will die */
+	    STARTITERATE (ev,xEvent, buf, (pend > 0),
+			  (pend -= SIZEOF(xEvent))) {
+		if (ev->u.u.type == X_Error)
+		    _XError (dpy, (xError *) ev);
+		else		/* it's an event packet; die */
+		    DPSFatalProc((DPSContext)0, "N_XWaitForWritable read bogus X event");
+	    }
+	    ENDITERATE
+	}
+	if (_XANYSET(w_mask))
+	    return;
+    }
+}
+
+
+void N_XWaitForReadable(Display *dpy)
+{
+    unsigned long r_mask[MSKCNT];
+    int result;
+	
+    CLEARBITS(r_mask);
+    do {
+	BITSET(r_mask, dpy->fd);
+	result = select(dpy->fd + 1, (SELECT_TYPE) r_mask, (SELECT_TYPE) NULL,
+			(SELECT_TYPE) NULL, (struct timeval *) NULL);
+	if (result == -1 && errno != EINTR) _XIOError(dpy);
+    } while (result <= 0);
+}
+
+#ifdef XXX
+
+static int padlength[4] = {0, 3, 2, 1};	 /* make sure auth is multiple of 4 */
+
+_XSendClientPrefix (
+     Display *dpy,
+     xConnClientPrefix *client,		/* contains count for auth_* */
+     char *auth_proto,			/* NOT null-terminated */
+     char char *auth_string)		/* NOT null-terminated */
+{
+    int auth_length = client->nbytesAuthProto;
+    int auth_strlen = client->nbytesAuthString;
+    char padbuf[3];			/* for padding to 4x bytes */
+    int pad;
+    struct iovec iovarray[5], *iov = iovarray;
+    int niov = 0;
+
+#define add_to_iov(b,l) \
+	  { iov->iov_base = (b); iov->iov_len = (l); iov++, niov++; }
+
+    add_to_iov ((caddr_t) client, SIZEOF(xConnClientPrefix));
+
+    /*
+     * write authorization protocol name and data
+     */
+    if (auth_length > 0) {
+	add_to_iov (auth_proto, auth_length);
+	pad = padlength [auth_length & 3];
+	if (pad) add_to_iov (padbuf, pad);
+    }
+    if (auth_strlen > 0) {
+	add_to_iov (auth_string, auth_strlen);
+	pad = padlength [auth_strlen & 3];
+	if (pad) add_to_iov (padbuf, pad);
+    }
+
+#undef add_to_iov
+
+    (void) WritevToServer (dpy->fd, iovarray, niov);
+    return;
+}
+
+#endif /* XXX */
diff --git a/nx-X11/lib/dps/csfindNX.c b/nx-X11/lib/dps/csfindNX.c
new file mode 100644
index 000000000..63b40acbc
--- /dev/null
+++ b/nx-X11/lib/dps/csfindNX.c
@@ -0,0 +1,657 @@
+/*
+ * csfindNX.c  -- DPSCAP client Xlib extension hookup
+ *
+ * (c) Copyright 1992-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: xc/lib/dps/csfindNX.c,v 1.7tsi Exp $ */
+
+#include <sys/param.h>				/* for MAXHOSTNAMELEN */
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>		/* getuid() */
+#include <string.h>
+#include <pwd.h>
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xlibint.h>
+#include <X11/Xatom.h>
+#include <X11/Xresource.h>
+
+#include "csfindNX.h"
+#include "dpsNXprops.h"
+#include "Xlibnet.h"
+#include "DPS/dpsXclient.h"
+#include "DPS/dpsNXargs.h"
+#include <DPS/XDPSlib.h>
+
+#include "dpsassert.h"
+#include "cslibint.h"
+
+/* ---Defines--- */
+
+#define CANTSTARTAGENT "Unable to start agent.\n"
+
+/* ---Types--- */
+
+typedef struct {
+  Window id;
+  int willingness;
+} Agent, *AgentIdList;
+
+/* ---Globals--- */
+
+static char *XDPSLNXHost = NULL;
+static int XDPSLNXPort = 0;	/* default port to be used */
+static int XDPSLNXTrans = XDPSNX_TRANS_UNIX;
+static int gXDPSNXLaunchedAgentTrans = XDPSNX_USE_BEST;
+static int gXDPSNXLaunchedAgentPort = XDPSNX_USE_BEST;
+static char *gXDPSNXExecObj = XDPSNX_DEFAULT_EXEC_NAME; /* NX object file */
+static char **gXDPSNXExecArgs = NULL; /* the args for gXDPSNXExecObj */
+static Bool gWasAgentSet = False;
+static Bool gXDPSNXAutoLaunch = False;
+unsigned char gXDPSNXErrorCode;
+extern int gNXSndBufSize;  /* Output buffer size, zero means default */
+
+static char *getHomeDir(char *);
+
+/* ---Private Functions--- */
+
+static int
+TmpErrorHandler(
+     Display *dpy,
+     XErrorEvent *err)
+{
+  gXDPSNXErrorCode = err->error_code;
+  return 0;
+}
+
+
+static int
+GetProperty(
+     Display *dpy,
+     Window w,
+     Atom prop,
+     Atom type,
+     unsigned long *nitems,	/* IN: if non-null then RETURN val */
+     char **data)		/* RETURN */
+{
+  long largest_len = ((((unsigned long) -1) >> 1) / 4);
+  Atom actual_type;
+  int actual_format;
+  unsigned long actual_number;
+  unsigned long remaining;
+
+  if (type == None) return(!Success); /* We need to have a type */
+  if ((XGetWindowProperty(dpy, w, prop, 0, largest_len, False, type, 
+			 &actual_type, &actual_format, &actual_number,
+			 &remaining, (unsigned char **) data) == Success)
+      && (actual_type == type)) {
+    if (nitems != NULL) *nitems = actual_number;
+    return(Success);
+  } else {
+    if (*nitems != 0) {		/* if data returned, clean up */
+      XFree(*data);
+      *data = NULL;		/* is this necessary? */
+      *nitems = 0;
+    }
+    return(!Success);
+  }
+}
+
+
+/*
+  GetAgentIdList returns a list of agents advertising on the passed display (dpy),
+  and it returns the number of agents in the list in the parameter nAgents.
+  The returned list is sorted in most to least willing order.
+  GetAgentIdList assumes that it has exclusive access to the server associated with
+  dpy (ie. it assumes that the caller has done an XGrabServer).
+  */
+static AgentIdList
+GetAgentIdList(
+     Display *dpy,
+     unsigned long *nAgents)	/* RETURN: number of agents in list */
+{
+  Atom serverListAtom = XInternAtom(dpy, XDPSNX_BILLBOARD_PROP, True);
+  Window  *agents = NULL;
+  AgentIdList agentList = NULL;
+  int (*oldErrorHandler)(Display *, XErrorEvent *) = 0; /* the current error handler */
+  unsigned long i, current;
+
+  if (serverListAtom == None) { /* Servers registered on dpy */
+    goto failed;
+  }
+
+  XSync(dpy, False);		/* force processing of pending requests */
+
+  if (GetProperty(dpy, RootWindow(dpy, DefaultScreen(dpy)),
+		  serverListAtom, XA_WINDOW, nAgents,
+		  (char **) &agents) != Success) {
+    goto failed;
+  }
+
+  if ((agentList = (AgentIdList)
+       Xcalloc(*nAgents, (unsigned) sizeof(Agent))) == NULL)
+    goto failed;
+
+  /* let's go through the list and figure out which servers  are okay */
+  oldErrorHandler = XSetErrorHandler(TmpErrorHandler);    
+  current = 0;
+  for (i=0; i < *nAgents; i++) {
+    unsigned long len;
+    int *agentWillingness;
+    unsigned long k;
+
+    for (k=0; k < i; k++) /* Search for duplicate ids */
+      if (agents[i] == agents[k]) { /* uh oh... */
+	agents[i] = None;
+	break;
+      }
+    if (k == i)	{		/* No duplicate ids */
+      if (GetProperty(dpy, agents[i],
+		      XInternAtom(dpy, XDPSNX_WILLINGNESS_PROP, True),
+		      XA_INTEGER, &len, (char **) &agentWillingness)
+	  != Success) {
+	/* Assume that Agent i is dead... */
+	/* reap the agent */
+	agents[i] = None;
+	gXDPSNXErrorCode = None;
+      } else {
+	unsigned long j = 0;
+	
+	/* insert the agents into agentList in "most to least willing" order */
+	while ((j < current) && (agentList[j].willingness > *agentWillingness))
+	  j++;
+	if (j < current)
+	  (void) bcopy((char *) &agentList[j], (char *) &agentList[j+1],
+		       sizeof(Agent) * (*nAgents - j - 1));
+	agents[current] = agents[i];
+	agentList[j].id = agents[current++];
+	agentList[j].willingness = *agentWillingness;
+	XFree(agentWillingness);
+      }
+    }
+  }
+  (void) XSetErrorHandler(oldErrorHandler);
+  oldErrorHandler = NULL;
+  if (*nAgents != current) {	/* agent list changed */
+    if (current > 0) {		/* are there living ones? */
+      *nAgents = current;
+      /* write the list  back out onto the root window */
+      (void) XChangeProperty(dpy, RootWindow(dpy, DefaultScreen(dpy)),
+		      serverListAtom, XA_WINDOW, 32,
+		      PropModeReplace, (unsigned char *) agents, *nAgents);
+    } else {
+      (void) XDeleteProperty(dpy, RootWindow(dpy, DefaultScreen(dpy)),
+			     serverListAtom);
+      goto failed;
+    }
+  }
+  (void) XFree(agents);
+  return(agentList);
+
+ failed:
+  if (agents != NULL) XFree(agents);
+  if (agentList != NULL) XFree(agentList);
+  if (oldErrorHandler != NULL) (void) XSetErrorHandler(oldErrorHandler);
+  *nAgents = 0;
+  return(NULL);
+}
+
+
+static int
+XDPSNXOnDisplay(
+     Display *dpy,
+     char *licenseMethod,
+     char **host,
+     int *transport,
+     int *port)
+{
+  unsigned long nAgents = 0;
+  AgentIdList agentList = NULL;
+  Bool match = False;
+  unsigned long i = 0;
+  int status = !Success;
+
+#ifdef DPSLNKL
+  extern unsigned ANXKFunc();
+#endif /* DPSLNKL */
+
+  (void) XGrabServer(dpy);	/* Can we do this later? */
+  if ((agentList = GetAgentIdList(dpy, &nAgents)) == NULL)
+    goto cleanup;
+  /* NOTE: agentList was sorted most to least willing by GetAgentIdList */
+  if (agentList[i].willingness <= 0) { /* Is there a willing agent? */
+    DPSWarnProc(NULL, "Found agent(s) for display, but none willing to accept connections.\n");
+    goto cleanup;
+  }
+  
+#ifdef DPSLNKL
+  /* Masterkey bypass code */
+  if (ANXKFunc() != 0) {
+    /* We have a willing agent and the client has masterkeys so... */
+    match = True;
+  } else			/* Search for appropriate agent */
+#endif /* DPSLNKL */
+  {
+    /* need to get licensing info from dpy */
+    Atom desiredLicenseMethod, openLicenseMethod;
+    char openLicenseString[256];
+
+    (void) sprintf(openLicenseString, "%s:%d",
+                   LICENSE_METHOD_OPEN,
+		   OPEN_LICENSE_VERSION);
+    openLicenseMethod = XInternAtom(dpy, openLicenseString, True);
+
+    if (licenseMethod != NULL)
+      desiredLicenseMethod = XInternAtom(dpy, licenseMethod, True);
+    else
+      desiredLicenseMethod = None;
+
+    if ((desiredLicenseMethod != None) || (openLicenseMethod != None)) {
+      for (i=0;
+	   (i < nAgents) && (agentList[i].willingness > 0) && (match == False);
+	   i++) {
+	Atom *licenseMethods = NULL;
+	unsigned long nMethods;
+	unsigned long j;
+	
+	if (GetProperty(dpy, agentList[i].id,
+			XInternAtom(dpy, XDPSNX_LICENSE_METHOD_PROP, True),
+			XA_ATOM,
+			&nMethods, (char **) &licenseMethods) != Success)
+	  goto cleanup;
+	
+	/*
+	  Check to see if the agent supports either our desired license method or
+	  if it is an open service.
+	 */
+	j = 0;
+	while((j < nMethods)
+	      && (licenseMethods[j] != desiredLicenseMethod)
+	      && (licenseMethods[j] != openLicenseMethod)) j++;
+	if (j < nMethods) {	/* We found one */
+	  match = True;
+	  break;
+	}
+	(void) XFree(licenseMethods);
+      }
+    }
+  }
+  
+  if (match) {			/* We had a match on license method */
+    TransportInfo *transInfo;
+    
+    if (GetProperty(dpy, agentList[i].id,
+		    XInternAtom(dpy, XDPSNX_TRANSPORT_INFO_PROP, True),
+		    XA_INTEGER, NULL, (char **) &transInfo) != Success) {
+      goto cleanup;
+    } else {			/* We got one! */
+      *transport = transInfo->transport;
+      *port = transInfo->port;
+      match = True;
+      XFree(transInfo);
+    }
+    if (GetProperty(dpy, agentList[i].id,
+		    XInternAtom(dpy, XDPSNX_HOST_NAME_PROP, True), XA_STRING,
+		    NULL, (char **) host) == Success) {
+      status = Success;
+      /* 
+       * If transport is TCP, but we are on the same host as the agent then 
+       * trade-up to the more efficient UNIX transport...
+       */
+      if (*transport == XDPSNX_TRANS_TCP) {
+        char hostname[MAXHOSTNAMELEN];
+	(void) N_XGetHostname(hostname, MAXHOSTNAMELEN);
+        if (strcmp(hostname, *host) == 0)
+	  *transport = XDPSNX_TRANS_UNIX;
+      }
+    }
+  }
+ /*
+  * Exit Clauses: status inited to FAILURE.  Therefore cleanup "assumes"
+  * a failure unless noted otherwise.
+  */
+ cleanup:
+  (void) XUngrabServer(dpy);
+  (void) XDPSLFlush(dpy);		/* Flush the ungrab */
+  if (agentList != NULL) XFree(agentList);
+  return(status);
+}
+
+
+static int
+ParseAgentString(
+     char *string,
+     char **hostname,		/* RETURN */
+     int *transport,		/* RETURN */
+     int *port)			/* RETURN */
+{
+  int dnet = 0;
+  Bool transportSpecified = False;
+  char namebuf[255];
+  char *p;
+  
+  (void) strncpy(namebuf, string, strlen(string)+1);
+  p = &namebuf[0];
+  /*
+   * Step 1, find the hostname.  This is delimited by a required colon.
+   */
+  for (; *p && *p != ':'; p++);
+  if (!*p) return(!Success);	/* There must be a colon */
+  
+  if (*(p+1) == ':') {
+    dnet++;
+    *(p++) = '\0';
+  }
+  *(p++) = '\0';
+
+  /* 
+   * Step 2, get the port number.  It follows the colon(s)
+   */ 
+  if (*p == '\0')		/* No port number specified... */
+    return(!Success);
+
+  *port = atoi(p);
+  
+  /*
+   * Step 3, transport?
+   */
+  if (namebuf[0] == '\0') {	/* no transport/hostname specified... */
+    if (dnet)
+      (void) strcpy(namebuf, "0");
+    else {			/* no hostname, so must be UNIX */
+      *hostname = NULL;
+      *transport = XDPSNX_TRANS_UNIX;
+      return(Success);
+    }
+  } else {
+    /* find the delimiting '/' */
+    for (p = &namebuf[0]; *p && *p != '/'; p++);
+    if (*p == '/') {
+      transportSpecified = True;
+      *p = '\0';
+      p++;
+    } else			/* no transport specified */
+      p = &namebuf[0];
+    if ((*hostname = (char *) Xmalloc(strlen(p))) == NULL)
+      return(!Success);		/* can't alloc space for hostname */
+    (void) strcpy(*hostname, p);
+
+    /* identify protocol */
+    if (dnet)
+      *transport = XDPSNX_TRANS_DECNET;
+    else if (transportSpecified) {
+      if (strcmp(namebuf, "unix") == 0)
+        *transport = XDPSNX_TRANS_UNIX;
+      else 			/* assume tcp */
+        *transport = XDPSNX_TRANS_TCP;
+    } else 
+      *transport = XDPSNX_TRANS_TCP;
+  }
+  return(Success);
+}
+
+static int
+FindXDPSNXInXrmDatabase(
+     Display *dpy,
+     char **host,
+     int *transport,
+     int *port)
+{
+  XrmDatabase rDB = NULL;	/* for merged database */
+  XrmDatabase serverDB;
+  char filenamebuf[1024];
+  char *filename = &filenamebuf[0];
+  char *env, *str_type;
+  char name[255];
+  XrmValue value;
+  int retVal = !Success;
+
+  XrmInitialize();
+  (void) strcpy(name, "/usr/lib/X11/app-defaults/");
+  (void) strcat(name, XDPSNX_X_CLASS_NAME);
+  
+  /* try to get application defaults file, if there is any */
+  XrmMergeDatabases(XrmGetFileDatabase(name), &rDB);
+
+  /* try to merge the server defaults.  if not defined then use .Xdefaults */
+  if (XResourceManagerString(dpy) != NULL) {
+    serverDB = XrmGetStringDatabase(XResourceManagerString(dpy));
+  } else {			/* use the .Xdefaults */
+    (void) getHomeDir(filename);
+    (void) strcat(filename, "/.Xdefaults");
+    
+    serverDB = XrmGetFileDatabase(filename);
+  }
+  XrmMergeDatabases(serverDB, &rDB);
+ 
+  /* try the XENVIRONMENT file, or if not defined, then .Xdefaults */
+  if ((env = getenv("XENVIRONMENT")) == NULL) {
+    int len;
+    env = getHomeDir(filename);
+    (void) strcat(filename, "/.Xdefaults-");
+    len = strlen(env);
+    (void) gethostname(env+len, 1024-len);
+  }
+  XrmMergeDatabases(XrmGetFileDatabase(env), &rDB);
+
+  /* Now that the database is built, try to extract the values we want. */
+
+  if (XrmGetResource(rDB, XDPSNX_X_RESOURCE, XDPSNX_X_CLASS_NAME, &str_type,
+		     &value) == True) {
+    retVal = ParseAgentString((char *) value.addr, host, transport, port);
+  }
+  (void) XrmDestroyDatabase(rDB);
+  return(retVal);
+}
+
+
+static char *
+getHomeDir(char *dest)
+{
+  register char *ptr;
+
+  if ((ptr = getenv("HOME")) != NULL) {
+    (void) strcpy(dest, ptr);
+  } else {
+    struct passwd *pw;
+
+    if ((ptr = getenv("USER")) != NULL) {
+      pw = getpwnam(ptr);
+    } else {
+      pw = getpwuid(getuid());
+    }
+    if (pw) {
+      (void) strcpy(dest, pw->pw_dir);
+    } else {
+      *dest = ' ';
+    }
+  }
+  return (dest);
+}
+
+
+
+/* ---Public Functions--- */
+
+int gForceLaunchHack = 0;   /* Undocumented way to force autolaunch */
+
+XDPSNXFindNXResult
+XDPSNXFindNX(
+     Display *dpy,
+     char *licenseMethod,
+     char **host,
+     int *transport,
+     int *port)
+{
+  char *agentenv;
+  
+  if (gForceLaunchHack)
+    return(findnx_not_found);
+
+  if (gWasAgentSet) {			/* check if client set up host */
+    *host = XDPSLNXHost;
+    *transport = XDPSLNXTrans;
+    *port = XDPSLNXPort;
+    return(findnx_found);
+  /* check DPSNXHOST environment variable */
+  } else if ((agentenv = getenv(AGENT_ENV_VAR)) != NULL) { 
+    int status = ParseAgentString(agentenv, host, transport, port);
+    if (status != Success) {
+      DPSWarnProc((DPSContext) NULL, "Illegal syntax for DPSNXHOST");
+      return(findnx_error);
+    } else return(findnx_found);
+  /* check advertisements... */
+  } else if (XDPSNXOnDisplay(dpy, licenseMethod, host, transport, port) ==
+	     Success) {
+    return(findnx_found);
+  /* check XrmDatabase */
+  } else if (FindXDPSNXInXrmDatabase(dpy, host, transport, port) == Success) {
+    return(findnx_found);
+  }
+  /* Nada */
+  return(findnx_not_found);
+}
+
+
+Status
+XDPSNXSetClientArg(int arg, void *value)
+{
+  Display *dpy;
+  
+  if (arg == XDPSNX_AGENT) {
+    gWasAgentSet = True;
+    return(ParseAgentString(value,
+			    &XDPSLNXHost, &XDPSLNXTrans, &XDPSLNXPort));
+  }
+  else if (arg == XDPSNX_EXEC_FILE) {
+    if ((gXDPSNXExecObj = Xmalloc(strlen((char *) value) + 1)) == NULL) {
+      return(!Success);
+    }
+    gXDPSNXExecObj = strcpy(gXDPSNXExecObj, (char *) value);
+  } else if (arg == XDPSNX_EXEC_ARGS) {
+    int i;
+    char **cpp, **execInfo;
+
+    execInfo = (char **) value;
+    for(cpp = execInfo, i = 1; *cpp != NULL; i++, cpp++); /* count */
+    gXDPSNXExecArgs = (char **) Xcalloc(i, sizeof(char *));
+    if (gXDPSNXExecArgs == NULL) return(!Success);
+    for(cpp = gXDPSNXExecArgs; *execInfo != NULL;
+	execInfo++, cpp++) {
+      /* copy each entry */
+      if ((*cpp = Xmalloc(strlen(*execInfo) + 1)) == NULL)
+	return(!Success);
+      *cpp = strcpy(*cpp, *execInfo);
+    }
+  } else if (arg == XDPSNX_AUTO_LAUNCH) {
+    gXDPSNXAutoLaunch = (Bool)(long) value;
+  } else if (arg == XDPSNX_LAUNCHED_AGENT_TRANS) {
+    gXDPSNXLaunchedAgentTrans = (long) value;
+  } else if (arg == XDPSNX_LAUNCHED_AGENT_PORT) {
+    gXDPSNXLaunchedAgentPort = (long) value;
+  } else if (arg == XDPSNX_REQUEST_XSYNC) {
+    dpy = (Display *) value;
+    if (dpy == (Display *)NULL)
+        return(Success);
+    XDPSLSetSyncMask(dpy, DPSCAP_SYNCMASK_SYNC);
+  } else if (arg == XDPSNX_REQUEST_RECONCILE) {
+    dpy = (Display *) value;
+    if (dpy == (Display *)NULL)
+        return(Success);
+    XDPSLSetSyncMask(dpy, DPSCAP_SYNCMASK_RECONCILE);
+  } else if (arg == XDPSNX_REQUEST_BUFFER) {
+    dpy = (Display *) value;
+    if (dpy == (Display *)NULL)
+        return(Success);
+    XDPSLSetSyncMask(dpy, DPSCAP_SYNCMASK_BUFFER);
+  } else if (arg == XDPSNX_GC_UPDATES_SLOW) {
+    dpy = (Display *) value;
+    if (dpy == (Display *)NULL)
+        return(Success);
+    XDPSLSetGCFlushMode(dpy, XDPSNX_GC_UPDATES_SLOW);
+  } else if (arg == XDPSNX_GC_UPDATES_FAST) {
+    dpy = (Display *) value;
+    if (dpy == (Display *)NULL)
+        return(Success);
+    XDPSLSetGCFlushMode(dpy, XDPSNX_GC_UPDATES_FAST);
+  } else if (arg == XDPSNX_SEND_BUF_SIZE) {
+    int i = (long)value;
+    if (i >= 4096 && i <= 65536) gNXSndBufSize = i;
+  }
+  return(Success);
+}
+
+
+void
+XDPSGetNXArg(int arg, void **value)
+{
+  static char agentBuffer[255];
+  
+  if (arg == XDPSNX_AGENT) {
+    switch(XDPSLNXTrans) {
+    case XDPSNX_TRANS_UNIX:
+      (void) sprintf(agentBuffer, "unix/");
+      break;
+    case XDPSNX_TRANS_TCP:
+      (void) sprintf(agentBuffer, "tcp/");
+      break;
+    case XDPSNX_TRANS_DECNET:
+      (void) sprintf(agentBuffer, "decnet/");
+      break;
+    default:
+      DPSWarnProc(NULL, "Unknown transport passed to XDPSGetNXArg ignored.\n");
+      agentBuffer[0] = '\0';
+      break;
+    }
+    (void) strcat(agentBuffer, XDPSLNXHost);
+    (void) strcat(agentBuffer,
+		  (XDPSLNXTrans == XDPSNX_TRANS_DECNET ? "::" : ":"));
+    (void) sprintf(&agentBuffer[strlen(agentBuffer)], "%d", XDPSLNXPort);
+    *value = (void *) agentBuffer;
+  }
+  else if (arg == XDPSNX_EXEC_FILE) {
+    *value = (void *) gXDPSNXExecObj;
+  } else if (arg == XDPSNX_EXEC_ARGS) {
+    *value = (void *) gXDPSNXExecArgs;
+  } else if (arg == XDPSNX_AUTO_LAUNCH) {
+    *value = (void *) (long)gXDPSNXAutoLaunch;
+  } else if (arg == XDPSNX_LAUNCHED_AGENT_TRANS) {
+    *value = (void *) (long)gXDPSNXLaunchedAgentTrans;
+  } else if (arg == XDPSNX_LAUNCHED_AGENT_PORT) {
+    *value = (void *) (long)gXDPSNXLaunchedAgentPort;
+  }
+}
diff --git a/nx-X11/lib/dps/csfindNX.h b/nx-X11/lib/dps/csfindNX.h
new file mode 100644
index 000000000..f5bf3bdc9
--- /dev/null
+++ b/nx-X11/lib/dps/csfindNX.h
@@ -0,0 +1,93 @@
+/*
+ * csfindNX.h
+ *
+ * (c) Copyright 1992-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
+ */
+
+#ifndef CSFINDNX_H
+#define CSFINDNX_H
+
+
+/* ---DEFINES--- */
+
+#define XDPSNX_DEFAULT_EXEC_NAME "dpsnx.agent"
+
+/* ---TYPES--- */
+
+typedef enum {
+  findnx_found,
+  findnx_not_found,
+  findnx_error
+} XDPSNXFindNXResult;
+
+
+/* ---Functions--- */
+
+extern XDPSNXFindNXResult
+XDPSNXFindNX (
+		   Display *dpy, /* Display client wants to attach to */
+		   char *licenseMethod,     /* license method client speaks */
+		   char **host,	           /* RETURN: Agent host name */
+		   int *transport,         /* RETURN: Agent transport */
+		   int *port);	           /* RETURN: Agent's port    */
+     /*
+      * Find an agent for this client that will service display dpy.
+      * The licenseMethod arg. specifies the type of licensing that the client
+      * is capable of speaking.  A (char *) NULL, means that it can handle
+      * any type (i.e. master key in lock & key).
+      * Return values indicates success in finding an agent.
+      * Success: host, transport, and port indicate where the agent is.
+      * !Success: the values of host, transport, and port are undefined.
+      * The client of the call is responsible for freeing the space (XFree())
+      * allocated for the host name string.
+      */
+
+
+extern void
+XDPSGetNXArg (
+		   int arg,	        /* Argument to be retrieved */
+		   void **value);	   /* value of the argument */
+     /*
+       Gets the value of the given argument.  Returns the value in val.  If the
+       value will fit in val (ie, a Bool) then the value is placed there,
+       otherwise a pointer to the value is placed there.  It is assumed that
+       the caller will know the correct type.  The types of arguments are
+       detailed with the argument definitions in dpsNXargs.h.
+       NOTE: the caller should NOT modify any values returned via pointer.
+       XDPSGetNXArg does not copy the data, rather it returns a pointer to the
+       internally held structure.
+      */
+
+#endif  /* CSFINDNX_H */
diff --git a/nx-X11/lib/dps/cslibext.c b/nx-X11/lib/dps/cslibext.c
new file mode 100644
index 000000000..831f0ad65
--- /dev/null
+++ b/nx-X11/lib/dps/cslibext.c
@@ -0,0 +1,762 @@
+/*
+ *  cslibext.c -- DPSCAP client Xlib extension hookup
+ *
+ * (c) Copyright 1991-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: xc/lib/dps/cslibext.c,v 1.4tsi Exp $ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <sys/param.h>		/* for MAXHOSTNAMELEN */
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xlibint.h>
+#include "cslibint.h"
+#include <DPS/XDPS.h>
+#include <DPS/XDPSproto.h>
+#include <DPS/dpsXclient.h>
+#include <DPS/dpsNXargs.h>
+#include "DPSCAPClient.h"
+#include "dpsassert.h"
+#include <DPS/XDPSlib.h>
+
+#include "publictypes.h"
+#include "dpsXpriv.h"
+
+/* === DEFINES === */
+
+#define DPSNXSYNCGCMODE_FLUSH	0
+#define DPSNXSYNCGCMODE_SYNC	1
+#define DPSNXSYNCGCMODE_DELAYED	2
+#define DPSNXSYNCGCMODE_DEFAULT	DPSNXSYNCGCMODE_DELAYED
+
+/* === GLOBALS === */
+
+DPSCAPGlobals gCSDPS = NULL;
+
+#ifdef DPSLNKL
+#define ANXCYAN
+#define ANXMAGENTA
+#define ANXYELLOW
+#define ANXBLACK
+#define ANXSPOT
+#include "dpslnkl.inc"
+#endif /* DPSLNKL */
+
+int gNXSyncGCMode = DPSNXSYNCGCMODE_DEFAULT;
+
+/* === PUBLIC PROCS === */
+
+#ifdef MAHALO
+static int
+DPSCAPFlushAfterProc(Display *agent)
+{
+    LockDisplay(agent);
+    N_XFlush(agent);
+    UnlockDisplay(agent);
+}
+#endif
+
+int
+CSDPSInit(
+    Display *dpy,
+    int *numberType,		/* RETURN */
+    char **floatingName)	/* RETURN */
+{
+    register Display *agent;
+    register xCAPConnReplyPrefix *p;
+    register char *c;
+    DPSCAPData my;
+    xCAPConnSetupReq setup;
+    union {
+        xCAPConnSuccess good;
+        xCAPConnFailed bad;
+    } reply;
+    XExtData *extData;
+    XExtCodes *codes;
+    int indian;
+    int rest;
+    Window clientWindow;
+    char fullDisplayName[MAXHOSTNAMELEN+10];
+
+    if (gCSDPS == NULL)
+        DPSCAPStartUp();
+
+    /* To fix dps-nx #68, Motif too slow on HP */
+    if ((c = getenv("DPSNXGCMODE")) != 0)
+        {
+	gNXSyncGCMode = atoi(c);
+	if (gNXSyncGCMode < DPSNXSYNCGCMODE_FLUSH
+	  || gNXSyncGCMode > DPSNXSYNCGCMODE_DELAYED)
+	    gNXSyncGCMode = DPSNXSYNCGCMODE_DEFAULT;
+	}
+
+    /* We may have already called this routine via XDPSExtensionPresent,
+       so don't do it again! */
+
+    if ((codes = XDPSLGetCodes(dpy))
+        && (agent = XDPSLGetShunt(dpy))
+        && agent != dpy
+	&& codes->major_opcode == DPSXOPCODEBASE)
+        return(DPSCAPSUCCESS);
+
+    /* Try to create a window for ClientMessage communication */
+
+    clientWindow = XCreateSimpleWindow(
+      dpy,
+      DefaultRootWindow(dpy),
+      0, 0,
+      1, 1,
+      0,
+      BlackPixel(dpy, DefaultScreen(dpy)),
+      WhitePixel(dpy, DefaultScreen(dpy)));
+    if (clientWindow == None)
+        return(DPSCAPFAILED);
+
+    /* Try to open a connection to an agent */
+
+    if ((extData = DPSCAPOpenAgent(dpy, fullDisplayName)) == NULL)
+        {
+        XDestroyWindow(dpy, clientWindow);
+        return(DPSCAPFAILED);
+        }
+
+    /* DPSCAPOpenAgent only partially fills in extData, so finish it */
+
+    codes = XAddExtension(dpy);
+    codes->major_opcode = DPSXOPCODEBASE;
+    codes->first_event = 0;  /* REQUIRED */
+    codes->first_error = FirstExtensionError;
+    extData->number = codes->extension;
+    extData->free_private = DPSCAPDestroy;
+    my = (DPSCAPData) extData->private_data;
+    my->codes = codes;
+    agent = my->agent;
+    /* +++ Is this all we have to do here? */
+
+    /* Send opening handshake */
+
+    indian = 1;
+    if (*(char *) &indian)
+        setup.byteorder = 'l';
+    else
+    	setup.byteorder = 'B';
+    setup.dpscapVersion = DPSCAPPROTOVERSION;
+    setup.flags = DPSCAPNONEFLAG;
+    setup.libraryversion = DPSPROTOCOLVERSION;
+    setup.authProtoNameLength = 0;
+    setup.authProtoDataLength = 0;
+    setup.displayStringLength = strlen(fullDisplayName);
+    setup.nodeStringLength = 0;
+    setup.transportStringLength = 0;
+    setup.display = 0;
+    setup.screen = 0;
+    setup.reserved = 0;
+    setup.clientWindow = clientWindow;
+
+#ifndef DPSLNKL
+    DPSCAPWrite(agent, (char *)&setup, sizeof(xCAPConnSetupReq), dpscap_nopad,dpscap_insert);
+    DPSCAPWrite(agent, fullDisplayName, setup.displayStringLength, dpscap_pad, dpscap_append);
+    N_XFlush(agent);
+#else /* DPSLNKL */
+    if (CSDPSConfirmDisplay(agent, dpy, &setup, &reply, fullDisplayName) == 1)
+        {
+	p = (xCAPConnReplyPrefix *)&reply.good;
+        goto skip_read;
+	}
+    /* Read normal reply */
+#endif /* DPSLNKL */
+
+    /* Read common reply prefix */
+
+    p = (xCAPConnReplyPrefix *)&reply.good;
+    N_XRead(agent, (char *)p, (long)sizeof(xCAPConnReplyPrefix));
+#ifdef DPSLNKL
+skip_read:
+#endif
+    if (!p->success)
+        {
+	char mbuf[512];
+        /* read the rest */
+        c = (char *)&reply.bad.serverVersion;
+        N_XRead(agent, c, sz_xCAPConnFailed - sz_xCAPConnReplyPrefix);
+	sprintf(mbuf, "DPS NX: connection to \"%s\" refused by agent.", DisplayString(agent));
+	DPSWarnProc(NULL, mbuf);
+        c = (char *)Xmalloc(reply.bad.reasonLength);
+        if (!c) return(DPSCAPFAILED);
+        N_XReadPad(agent, c, (long)reply.bad.reasonLength);
+	if (!reply.bad.reasonLength)
+	    sprintf(mbuf, "DPS NX: (no reason given)\n");
+	else
+            {
+	    strcpy(mbuf, "DPS NX: ");
+	    strncat(mbuf, c, reply.bad.reasonLength);
+	    mbuf[reply.bad.reasonLength+7] = '\0';
+	    }
+	DPSWarnProc(NULL, mbuf);
+        Xfree(c);
+        DPSCAPDestroy(extData);
+        Xfree(extData);
+        XDestroyWindow(dpy, clientWindow);
+        return(DPSCAPFAILED);
+        }
+
+    /* read the rest of the fixed length reply */
+    c = (char *)&reply.good.serverVersion;
+    rest = sizeof(xCAPConnSuccess) - sizeof(xCAPConnReplyPrefix);
+    N_XRead(agent, c, rest);
+
+    /* verify */
+
+    if (reply.good.serverVersion < DPSPROTOCOLVERSION)
+        {
+	/* Fine, we downgrade the client */
+	char qbuf[256];
+	sprintf(qbuf, "NX: server version %ld older than expected %d, client will downgrade", (long)reply.good.serverVersion, DPSPROTOCOLVERSION);
+	DPSWarnProc(NULL, qbuf);
+	}
+    my->dpscapVersion = reply.good.dpscapVersion;
+    if (my->dpscapVersion < DPSCAPPROTOVERSION)
+        {
+	/* Fine, we downgrade the client */
+	char kbuf[256];
+	sprintf(kbuf, "NX: agent version %d older than expected %d, client will downgrade", my->dpscapVersion, DPSCAPPROTOVERSION);
+	DPSWarnProc(NULL, kbuf);
+#ifdef XXX
+        /* Saving this code as a reminder about what needs to be
+	   cleaned up if we exit here */
+        DPSCAPDestroy(extData);
+        Xfree(extData);
+        XDestroyWindow(clientWindow);
+        return(DPSCAPFAILED);
+#endif
+	}
+
+    if (numberType)
+        *numberType = reply.good.preferredNumberFormat;
+
+    /* read additional data */
+
+    c = (char *)Xmalloc(reply.good.floatingNameLength + 1);
+    N_XReadPad(agent, c, reply.good.floatingNameLength);
+    c[reply.good.floatingNameLength] = 0;
+    if (floatingName)
+	*floatingName = c;
+    else
+	Xfree(c);
+
+    /* set library extension data */
+
+    XDPSLSetVersion(agent, reply.good.serverVersion);
+    XDPSLSetVersion(dpy, reply.good.serverVersion);
+    XDPSLSetShunt(dpy, agent);
+    XDPSLSetCodes(dpy, codes);
+    if (XDPSLGetSyncMask(dpy) == DPSCAP_SYNCMASK_NONE)
+        XDPSLSetSyncMask(dpy, DPSCAP_SYNCMASK_DFLT);
+    my->agentWindow = reply.good.agentWindow;
+    XDPSLSetGCFlushMode(dpy, XDPSNX_GC_UPDATES_SLOW); /* default */
+
+    /* Hook my extension data on the dpy */
+
+    my->extData = extData;
+    XAddToExtensionList(CSDPSHeadOfDpyExt(dpy), extData);
+    (void) XESetCloseDisplay(dpy, codes->extension, DPSCAPCloseDisplayProc);
+    (void) XESetCopyGC(dpy, codes->extension, DPSCAPCopyGCProc);
+    (void) XESetFreeGC(dpy, codes->extension, DPSCAPFreeGCProc);
+    (void) XESetFlushGC(dpy, codes->extension, DPSCAPFlushGCProc);
+    XDPSLSetClientMessageHandler(dpy);
+
+    /* Chain my data on global list */
+
+    my->next = gCSDPS->head;
+    gCSDPS->head = my;
+
+#ifdef MAHALO
+    /* Set function that is called after every Xlib protocol proc */
+    XDPSLSetAfterProc(dpy);
+
+    /* All CSDPS protocol is auto-flushed */
+    (void) XSetAfterFunction(agent, DPSCAPFlushAfterProc);
+#endif /* MAHALO */
+
+    /* set agent arguments, if needed */
+    /* must follow setting of ShuntMap at least, so safest to
+       do here when everything has been setup */
+    XDPSLUpdateAgentArgs(dpy);
+
+    return(DPSCAPSUCCESS);
+}
+
+
+XExtData **
+CSDPSHeadOfDpyExt(
+   Display *dpy)
+{
+   XEDataObject object;
+
+   object.display = dpy;
+   return(XEHeadOfExtensionList(object));
+}
+
+void
+XDPSSyncGCClip(
+    register Display *dpy,
+    register GC gc)
+{
+    /* The primary utility of this function is for DPS NX correctness,
+       but it also helps DPS/X do less work in tracking GC changes. */
+    XDPSLSyncGCClip(dpy, gc);
+}
+
+void
+XDPSReconcileRequests(
+    register DPSContext ctxt)
+{
+    Display *dpy;
+    register ContextXID cxid;
+    register DPSContext curCtxt;
+
+    for (curCtxt = ctxt; curCtxt; curCtxt = curCtxt->chainChild)
+        {
+	cxid = XDPSXIDFromContext(&dpy, curCtxt);
+	if (dpy == (Display *)NULL || cxid == None)
+	    break;  /* Skip text contexts */
+	XDPSLReconcileRequests(dpy, cxid);
+        }
+}
+
+Status
+XDPSNXSetAgentArg(
+    Display *dpy,
+    int arg, int val)
+{
+    if (!dpy || arg >= 0 || arg < AGENTLASTARG)
+        return(!Success);
+    else
+        return(XDPSLSetAgentArg(dpy, arg, val));
+}
+
+/* New for DPS NX 2.0 */
+void
+XDPSFlushGC(
+    Display *dpy,
+    GC gc)
+{
+    if (dpy && gc)
+        XDPSLFlushGC(dpy, gc);
+}
+
+/* === SUPPORT PROCS === */
+
+void
+DPSCAPChangeGC(
+    register Display *agent,
+    GC gc,
+    unsigned long valuemask,
+    XGCValues *values)
+{
+    register xChangeGCReq *req;
+    unsigned long oldDirty = gc->dirty;
+
+    /* ASSERT: called from within LockDisplay section */
+
+    /* Always include the clip_mask */
+    valuemask |= GCClipMask;
+    /* +++ HACK!  Hide the gc->rects flag in arc_mode */
+    valuemask |= GCArcMode;
+    valuemask &= (1L << (GCLastBit + 1)) - 1;
+
+    /* Stupid macro insists on Display being called 'dpy' */
+    {
+    Display *dpy = agent;
+    Display *xdpy = (Display *)NULL;
+    NXMacroGetReq(ChangeGC, req);
+    }
+    req->gc = XGContextFromGC(gc);
+    gc->dirty = req->mask = valuemask;
+    {
+/* Derived from MIT XCrGC.c, _XGenerateGCList:
+Copyright 1985, 1986, 1987, 1988, 1989 by the
+Massachusetts Institute of Technology
+
+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 name of M.I.T. not be used in advertising or
+publicity pertaining to distribution of the software without specific,
+written prior permission.  M.I.T. makes no representations about the
+suitability of this software for any purpose.  It is provided "as is"
+without express or implied warranty.
+*/
+    /* Warning!  This code assumes that "unsigned int" is 32-bits wide */
+
+    unsigned int vals[32];
+    register unsigned int *value = vals;
+    long nvalues;
+    register XGCValues *gv = values;
+    register unsigned long dirty = gc->dirty;
+
+    /*
+     * Note: The order of these tests are critical; the order must be the
+     * same as the GC mask bits in the word.
+     */
+    if (dirty & GCFunction)          *value++ = gv->function;
+    if (dirty & GCPlaneMask)         *value++ = gv->plane_mask;
+    if (dirty & GCForeground)        *value++ = gv->foreground;
+    if (dirty & GCBackground)        *value++ = gv->background;
+    if (dirty & GCLineWidth)         *value++ = gv->line_width;
+    if (dirty & GCLineStyle)         *value++ = gv->line_style;
+    if (dirty & GCCapStyle)          *value++ = gv->cap_style;
+    if (dirty & GCJoinStyle)         *value++ = gv->join_style;
+    if (dirty & GCFillStyle)         *value++ = gv->fill_style;
+    if (dirty & GCFillRule)          *value++ = gv->fill_rule;
+    if (dirty & GCTile)              *value++ = gv->tile;
+    if (dirty & GCStipple)           *value++ = gv->stipple;
+    if (dirty & GCTileStipXOrigin)   *value++ = gv->ts_x_origin;
+    if (dirty & GCTileStipYOrigin)   *value++ = gv->ts_y_origin;
+    if (dirty & GCFont)              *value++ = gv->font;
+    if (dirty & GCSubwindowMode)     *value++ = gv->subwindow_mode;
+    if (dirty & GCGraphicsExposures) *value++ = gv->graphics_exposures;
+    if (dirty & GCClipXOrigin)       *value++ = gv->clip_x_origin;
+    if (dirty & GCClipYOrigin)       *value++ = gv->clip_y_origin;
+    if (dirty & GCClipMask)          *value++ = gv->clip_mask;
+    if (dirty & GCDashOffset)        *value++ = gv->dash_offset;
+    if (dirty & GCDashList)          *value++ = gv->dashes;
+    /* +++ HACK!  Hide gc->rects flag in GCArcMode */
+    if (dirty & GCArcMode)           *value++ = gc->rects;
+
+    req->length += (nvalues = value - vals);
+
+    /*
+     * note: Data is a macro that uses its arguments multiple
+     * times, so "nvalues" is changed in a separate assignment
+     * statement
+     */
+
+    nvalues <<= 2;
+    Data32 (agent, (long *) vals, nvalues);
+    }
+
+    gc->dirty = oldDirty;
+
+    /* ASSERT: SyncHandle called by caller */
+}
+
+
+DPSCAPData
+DPSCAPCreate(
+    Display *dpy, Display *agent)
+{
+    register DPSCAPData my = (DPSCAPData)Xcalloc(1, sizeof(DPSCAPDataRec));
+
+    if (my == (DPSCAPData)NULL) return(NULL);
+    my->dpy = dpy;
+    my->agent = agent;
+    my->typePSOutput = XInternAtom(
+      dpy,
+      DPSCAP_TYPE_PSOUTPUT,
+      False);
+    my->typePSOutputWithLen = XInternAtom(
+      dpy,
+      DPSCAP_TYPE_PSOUTPUT_LEN,
+      False);
+    my->typePSStatus = XInternAtom(
+      dpy,
+      DPSCAP_TYPE_PSSTATUS,
+      False);
+    my->typeNoop = XInternAtom(
+      dpy,
+      DPSCAP_TYPE_NOOP,
+      False);
+    my->typeSync = XInternAtom(
+      dpy,
+      DPSCAP_TYPE_SYNC,
+      False);
+    my->typeXError = XInternAtom(
+      dpy,
+      DPSCAP_TYPE_XERROR,
+      False);
+    my->typePSReady = XInternAtom(
+      dpy,
+      DPSCAP_TYPE_PSREADY,
+      False);
+    my->typeResume = XInternAtom(
+      dpy,
+      DPSCAP_TYPE_RESUME,
+      False);
+    return(my);
+}
+
+int
+DPSCAPDestroy(
+    XExtData *extData)
+{
+    register DPSCAPData my = (DPSCAPData) extData->private_data;
+    register DPSCAPData n;
+
+    if (my == (DPSCAPData)NULL) return(0);
+    DPSCAPCloseAgent(my->agent);
+    my->agent = NULL;
+    /* my->extData->private_data = NIL; ???? +++ */
+    if (my == gCSDPS->head)
+        gCSDPS->head = my->next;
+    else for (n = gCSDPS->head; n != NULL; n = n->next)
+        if (n->next == my)
+            {
+            n->next = my->next;
+            break;
+            }
+    Xfree(my);
+    /* extData freed by caller (e.g., _XFreeExtData) */
+    return(0);
+}
+
+void
+DPSCAPStartUp(void)
+{
+    gCSDPS = (DPSCAPGlobals)Xcalloc(1, sizeof(DPSCAPGlobalsRec));
+}
+
+
+static unsigned char padAdd[] = {0, 3, 2, 1};
+
+void
+DPSCAPWrite(
+    Display *agent,
+    char *buf,
+    unsigned len,
+    DPSCAPIOFlags writePad,
+    DPSCAPIOFlags bufMode)
+{
+    int pad = padAdd[len & 3];
+    unsigned fullLen = (writePad == dpscap_pad) ? len + pad  : len;
+
+    if (agent->bufptr + fullLen > agent->bufmax)
+        N_XFlush(agent);
+    if (agent->max_request_size && fullLen > agent->max_request_size)
+        {
+	DPSWarnProc(NULL, "DPS Client Library: request length exceeds max request size. Truncated.\n");
+	len = agent->max_request_size;
+	pad = 0;
+	}
+    if (bufMode == dpscap_insert)
+        {
+        agent->last_req = agent->bufptr;
+        agent->request++;
+        }
+    bcopy(buf, agent->bufptr, len);
+    agent->bufptr += len;
+    if (writePad == dpscap_pad && pad)
+        {
+        bcopy((char *) padAdd, agent->bufptr, pad);
+        agent->bufptr += pad;
+        }
+}
+
+
+/* === EXT CALLBACK HOOKS === */
+
+int
+DPSCAPCloseDisplayProc(
+    Display *dpy,
+    XExtCodes *codes)
+{
+#ifdef CSDPS
+    fprintf(stderr, "NX: Closing agent \"%s\"\n", dpy->display_name);
+#endif
+
+    /* Although it seems that we should free codes here, we can't
+       because Xlib owns the storage */
+
+    XDPSLSetShunt(dpy, (Display *) NULL);
+    XDPSLSetCodes(dpy, (XExtCodes *) NULL);
+    XDPSLSetSyncMask(dpy, DPSCAP_SYNCMASK_NONE);
+    XDPSLCleanAll(dpy);
+    XDPSPrivZapDpy(dpy);
+    return(0);
+}
+
+
+int
+DPSCAPCopyGCProc(
+    Display *dpy,
+    GC gc,
+    XExtCodes *codes)
+{
+    XGCValues values;
+    DPSCAPData my;
+    XExtData *extData = XFindOnExtensionList(
+      CSDPSHeadOfDpyExt(dpy),
+      codes->extension);
+
+    if (extData)
+        my = (DPSCAPData) extData->private_data;
+    else
+        return(0);
+
+    /* We change the GC unconditionally, since friggin' XCopyGC
+       clears the dirty bits of the values that are copied! */
+
+    DPSAssertWarn(XGetGCValues(dpy, gc, DPSGCBITS & ~(GCClipMask), &values),
+	NULL, "DPS NX: XGetGCValues returned False\n");
+    values.clip_mask = gc->values.clip_mask;
+    DPSCAPChangeGC(my->agent, gc, DPSGCBITS, &values);
+    /* We have to make sure that the agent completely processes
+	the change to the GC.  If we allow the agent to update the
+	GC in its own sweet time, the stupid client may delete the
+	GC after the agent has already queued a request to, e.g.,
+	copy the GC, but before the request is flushed. */
+    XDPSLSync(dpy);
+    return(1);
+}
+
+int
+DPSCAPFreeGCProc(
+    Display *pdpy,
+    GC gc,
+    XExtCodes *codes)
+{
+    register xCAPNotifyReq *req;
+    DPSCAPData my;
+    Display *dpy = pdpy;  /* Stupid macros insists on Display being 'dpy' */
+    XExtData *extData = XFindOnExtensionList(
+      CSDPSHeadOfDpyExt(dpy),
+      codes->extension);
+
+    if (extData)
+        my = (DPSCAPData) extData->private_data;
+    else
+        return(0);
+
+    /* Notify the agent that the client deleted a GC.  Let the
+       agent figure out if it cares. */
+
+    /* ASSERT: called from within LockDisplay section */
+
+    dpy = my->agent;
+    if (dpy == (Display *)NULL || dpy == pdpy)
+        return(0);
+
+    /* May need to sync changes to GC */
+    if (gNXSyncGCMode == DPSNXSYNCGCMODE_DELAYED)
+        XDPSLSync(pdpy);
+
+    {
+    Display *xdpy = pdpy;			    /* pdpy is X server */
+    NXMacroGetReq(CAPNotify, req);
+    }
+    req->reqType = DPSCAPOPCODEBASE;
+    req->type = X_CAPNotify;
+    req->cxid = 0;
+    req->notification = DPSCAPNOTE_FREEGC;
+    req->data = XGContextFromGC(gc);
+    req->extra = 0;
+    /* Guarantee that everyone sees GC go away */
+    XSync(pdpy, False);                             /* pdpy is X server */
+    if (gNXSyncGCMode == DPSNXSYNCGCMODE_FLUSH)
+        {
+        LockDisplay(dpy);                           /* dpy means agent here */
+        N_XFlush(dpy);
+        UnlockDisplay(dpy);
+	}
+    else
+        XDPSLSync(pdpy);
+
+    /* ASSERT: SynchHandle called by caller */
+    return(1);
+}
+
+#ifdef CSDPSDEBUG
+static unsigned int gcCountFlushedClean = 0;
+static unsigned int gcCountFlushedDirty = 0;
+#endif /* CSDPSDEBUG */
+
+int
+DPSCAPFlushGCProc(
+    Display *dpy,
+    GC gc,
+    XExtCodes *codes)
+{
+    XGCValues values;
+    DPSCAPData my;
+    XExtData *extData;
+#ifdef CSDPSDEBUG
+    unsigned long int dirty;
+#endif /* CSDPSDEBUG */
+
+    /* When GC is created, it is flushed with no dirty bits set,
+       so we have to notice that situation. */
+
+    if (gc->dirty)
+        {
+	if (XDPSLGetGCFlushMode(dpy) == XDPSNX_GC_UPDATES_FAST
+	   || !(gc->dirty & DPSGCBITS))
+	    return(0);
+	}
+    extData = XFindOnExtensionList(CSDPSHeadOfDpyExt(dpy), codes->extension);
+    if (extData)
+        my = (DPSCAPData) extData->private_data;
+    else
+        return(0);
+    /* HERE IF (gc->dirty & DPSGCBITS || !gc->dirty) */
+#ifdef CSDPSDEBUG
+    dirty = gc->dirty;
+#endif /* CSDPSDEBUG */
+    DPSAssertWarn(XGetGCValues(dpy, gc, DPSGCBITS & ~(GCClipMask), &values),
+	NULL, "NX: XGetGCValues returned False\n");
+    values.clip_mask = gc->values.clip_mask;
+    /* Must guarantee that gc change is registered by X server
+       before notification is sent to agent. */
+    XSync(dpy, False);
+    DPSCAPChangeGC(my->agent, gc, DPSGCBITS, &values);
+    /* We have to make sure that the agent completely processes
+       the change to the GC.  If we allow the agent to update the
+       GC in its own sweet time, the stupid client may delete the
+       GC after the agent has already queued a request to, e.g.,
+       copy the GC, but before the request is flushed. */
+    if (gNXSyncGCMode == DPSNXSYNCGCMODE_SYNC)
+        XDPSLSync(dpy);
+    else
+        XDPSLFlush(dpy);
+#ifdef CSDPSDEBUG
+    if (dirty)
+        ++gcCountFlushedDirty;
+    else
+        ++gcCountFlushedClean;
+#endif /* CSDPSDEBUG */
+    return(1);
+}
diff --git a/nx-X11/lib/dps/cslibint.c b/nx-X11/lib/dps/cslibint.c
new file mode 100644
index 000000000..84d7b753e
--- /dev/null
+++ b/nx-X11/lib/dps/cslibint.c
@@ -0,0 +1,1910 @@
+/*
+ * cslibint.c -- low level I/O
+ *
+ * (c) Copyright 1993-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
+ * 
+ * Portions Copyright 1985, 1986, 1987  Massachusetts Institute of Technology
+ * 
+ * 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 name of M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *  
+ * Author:  Adobe Systems Incorporated and MIT X Consortium
+ */
+/* $XFree86: xc/lib/dps/cslibint.c,v 1.4tsi Exp $ */
+
+/*
+ *	XlibInternal.c - Internal support routines for the C subroutine
+ *	interface library (Xlib) to the X Window System Protocol V11.0.
+ */
+#define NEED_EVENTS
+#define NEED_REPLIES
+
+#include <X11/Xlibint.h>
+#include <X11/Xos.h>
+#include "Xlibnet.h"
+#include <stdio.h>
+
+#include "dpsassert.h"
+#include "cslibint.h"
+
+static void _EatData32 (Display *dpy, unsigned long n);
+
+/* check for both EAGAIN and EWOULDBLOCK, because some supposedly POSIX
+ * systems are broken and return EWOULDBLOCK when they should return EAGAIN
+ */
+#if defined(EAGAIN) && defined(EWOULDBLOCK)
+#define ETEST(err) (err == EAGAIN || err == EWOULDBLOCK)
+#else
+#ifdef EAGAIN
+#define ETEST(err) (err == EAGAIN)
+#else
+#define ETEST(err) (err == EWOULDBLOCK)
+#endif
+#endif
+
+#ifdef LACHMAN
+#ifdef EMSGSIZE
+#undef EMSGSIZE
+#endif
+#define EMSGSIZE ERANGE
+#endif
+
+#if defined(SVR4) && defined(sun)
+#define SUNSYSV 1
+#endif
+
+/*
+ * The following routines are internal routines used by Xlib for protocol
+ * packet transmission and reception.
+ *
+ * XIOError(Display *) will be called if any sort of system call error occurs.
+ * This is assumed to be a fatal condition, i.e., XIOError should not return.
+ *
+ * XError(Display *, XErrorEvent *) will be called whenever an X_Error event is
+ * received.  This is not assumed to be a fatal condition, i.e., it is
+ * acceptable for this procedure to return.  However, XError should NOT
+ * perform any operations (directly or indirectly) on the DISPLAY.
+ *
+ * Routines declared with a return type of 'Status' return 0 on failure,
+ * and non 0 on success.  Routines with no declared return type don't 
+ * return anything.  Whenever possible routines that create objects return
+ * the object they have created.
+ */
+
+extern _XQEvent *_qfree;
+
+static int padlength[4] = {0, 3, 2, 1};
+    /* lookup table for adding padding bytes to data that is read from
+    	or written to the X socket.  */
+
+static xReq _dummy_request = {
+	0, 0, 0
+};
+/*
+ * N_XFlush - Flush the X request buffer.  If the buffer is empty, no
+ * action is taken.  This routine correctly handles incremental writes.
+ * This routine may have to be reworked if int < long.
+ */
+void N_XFlush (Display *dpy)
+{
+	register long size, todo;
+	register int write_stat;
+	register char *bufindex;
+	
+	if (!dpy) return;
+
+	if (dpy->flags & XlibDisplayIOError) return;
+
+	size = todo = dpy->bufptr - dpy->buffer;
+	bufindex = dpy->bufptr = dpy->buffer;
+	/*
+	 * While write has not written the entire buffer, keep looping
+	 * until the entire buffer is written.  bufindex will be incremented
+	 * and size decremented as buffer is written out.
+	 */
+	while (size) {
+	    errno = 0;
+	    write_stat = WriteToServer(dpy->fd, bufindex, (int) todo);
+	    if (write_stat >= 0) {
+		size -= write_stat;
+		todo = size;
+		bufindex += write_stat;
+	    } else if (ETEST(errno)) {
+		N_XWaitForWritable(dpy);
+#ifdef SUNSYSV
+	    } else if (errno == 0) {
+		N_XWaitForWritable(dpy);
+#endif
+#ifdef EMSGSIZE
+	    } else if (errno == EMSGSIZE) {
+		if (todo > 1) 
+		  todo >>= 1;
+		else
+		  N_XWaitForWritable(dpy);
+#endif
+	    } else if (errno != EINTR) {
+		/* Write failed! */
+		/* errno set by write system call. */
+		_XIOError(dpy);
+	    }
+	}
+	dpy->last_req = (char *)&_dummy_request;
+}
+
+#ifdef NEEDFORNX
+
+int
+_XEventsQueued (Display *dpy, int mode)
+{
+	register int len;
+	int pend;
+	char buf[BUFSIZE];
+	register xReply *rep;
+	
+	if (mode == QueuedAfterFlush)
+	{
+	    _XFlush(dpy);
+	    if (dpy->qlen)
+		return(dpy->qlen);
+	}
+	if (dpy->flags & XlibDisplayIOError) return(dpy->qlen);
+	if (BytesReadable(dpy->fd, (char *) &pend) < 0)
+	    _XIOError(dpy);
+#ifdef XCONN_CHECK_FREQ
+	/* This is a crock, required because FIONREAD or equivalent is
+	 * not guaranteed to detect a broken connection.
+	 */
+	if (!pend && !dpy->qlen && ++dpy->conn_checker >= XCONN_CHECK_FREQ)
+	{
+	    unsigned long r_mask[MSKCNT];
+	    static struct timeval zero_time;
+
+	    dpy->conn_checker = 0;
+	    CLEARBITS(r_mask);
+	    BITSET(r_mask, dpy->fd);
+	    if (pend = select(dpy->fd + 1, (int *)r_mask, NULL, NULL,
+			      &zero_time))
+	    {
+		if (pend > 0)
+		{
+		    if (BytesReadable(dpy->fd, (char *) &pend) < 0)
+			_XIOError(dpy);
+		    /* we should not get zero, if we do, force a read */
+		    if (!pend)
+			pend = SIZEOF(xReply);
+		}
+		else if (pend < 0 && errno != EINTR)
+		    _XIOError(dpy);
+	    }
+	}
+#endif /* XCONN_CHECK_FREQ */
+	if (!(len = pend))
+	    return(dpy->qlen);	/* _XFlush can enqueue events */
+      /* Force a read if there is not enough data.  Otherwise,
+       * a select() loop at a higher-level will spin undesirably,
+       * and we've seen at least one OS that appears to not update
+       * the result from FIONREAD once it has returned nonzero.
+       */
+	if (len < SIZEOF(xReply))
+	    len = SIZEOF(xReply);
+	else if (len > BUFSIZE)
+	    len = BUFSIZE;
+	len /= SIZEOF(xReply);
+	pend = len * SIZEOF(xReply);
+#ifdef XCONN_CHECK_FREQ
+	dpy->conn_checker = 0;
+#endif
+	_XRead (dpy, buf, (long) pend);
+
+	/* no space between comma and type or else macro will die */
+	STARTITERATE (rep,xReply, buf, (len > 0), len--) {
+	    if (rep->generic.type == X_Error)
+		_XError(dpy, (xError *)rep);
+	    else   /* must be an event packet */
+		_XEnq(dpy, (xEvent *) rep);
+	}
+	ENDITERATE
+	return(dpy->qlen);
+}
+
+/* _XReadEvents - Flush the output queue,
+ * then read as many events as possible (but at least 1) and enqueue them
+ */
+void _XReadEvents(Display *dpy)
+{
+	char buf[BUFSIZE];
+	long pend_not_register; /* because can't "&" a register variable */
+	register long pend;
+	register xEvent *ev;
+	Bool not_yet_flushed = True;
+
+	do {
+	    /* find out how much data can be read */
+	    if (BytesReadable(dpy->fd, (char *) &pend_not_register) < 0)
+	    	_XIOError(dpy);
+	    pend = pend_not_register;
+
+	    /* must read at least one xEvent; if none is pending, then
+	       we'll just flush and block waiting for it */
+	    if (pend < SIZEOF(xEvent)) {
+	    	pend = SIZEOF(xEvent);
+		/* don't flush until we block the first time */
+		if (not_yet_flushed) {
+		    int qlen = dpy->qlen;
+		    _XFlush (dpy);
+		    if (qlen != dpy->qlen) return;
+		    not_yet_flushed = False;
+		}
+	    }
+		
+	    /* but we won't read more than the max buffer size */
+	    if (pend > BUFSIZE)
+	    	pend = BUFSIZE;
+
+	    /* round down to an integral number of XReps */
+	    pend = (pend / SIZEOF(xEvent)) * SIZEOF(xEvent);
+
+	    _XRead (dpy, buf, pend);
+
+	    /* no space between comma and type or else macro will die */
+	    STARTITERATE (ev,xEvent, buf, (pend > 0),
+			  pend -= SIZEOF(xEvent)) {
+		if (ev->u.u.type == X_Error)
+		    _XError (dpy, (xError *) ev);
+		else  /* it's an event packet; enqueue it */
+		    _XEnq (dpy, ev);
+	    }
+	    ENDITERATE
+	} while (dpy->head == NULL);
+}
+
+#endif /* NEEDFORNX */
+
+/* 
+ * N_XRead - Read bytes from the socket taking into account incomplete
+ * reads.  This routine may have to be reworked if int < long.
+ */
+int N_XRead (Display *dpy, char *data, long size)
+{
+	register long bytes_read;
+
+        if (!dpy) return 0;
+	if ((dpy->flags & XlibDisplayIOError) || size == 0) return 0;
+	errno = 0;
+	while ((bytes_read = ReadFromServer(dpy->fd, data, (int)size))
+		!= size) {
+
+	    	if (bytes_read > 0) {
+		    size -= bytes_read;
+		    data += bytes_read;
+		    }
+		else if (ETEST(errno)) {
+		    N_XWaitForReadable(dpy);
+		    errno = 0;
+		}
+#ifdef SUNSYSV
+		else if (errno == 0) {
+		    N_XWaitForReadable(dpy);
+		}
+#endif
+		else if (bytes_read == 0) {
+		    /* Read failed because of end of file! */
+		    errno = EPIPE;
+		    _XIOError(dpy);
+		    }
+
+		else  /* bytes_read is less than 0; presumably -1 */ {
+		    /* If it's a system call interrupt, it's not an error. */
+		    if (errno != EINTR)
+		    	_XIOError(dpy);
+		    }
+	    	 }
+	return 0;
+}
+
+#ifdef WORD64
+
+/*
+ * XXX This is a *really* stupid way of doing this....
+ * PACKBUFFERSIZE must be a multiple of 4.
+ */
+
+#define PACKBUFFERSIZE 4096
+
+
+/*
+ * _XRead32 - Read bytes from the socket unpacking each 32 bits
+ *            into a long (64 bits on a CRAY computer).
+ * 
+ */
+static void _doXRead32 (Display *dpy, long *data, long size, char *packbuffer)
+{
+ long *lpack,*lp;
+ long mask32 = 0x00000000ffffffff;
+ long maskw, nwords, i, bits;
+
+        _XReadPad (dpy, packbuffer, size);
+
+        lp = data;
+        lpack = (long *) packbuffer;
+        nwords = size >> 2;
+        bits = 32;
+
+        for(i=0;i<nwords;i++){
+            maskw = mask32 << bits;
+           *lp++ = ( *lpack & maskw ) >> bits;
+            bits = bits ^32;
+            if(bits){
+               lpack++;
+            }
+        }
+}
+
+void _XRead32 (Display *dpy, long *data, long len)
+{
+    char packbuffer[PACKBUFFERSIZE];
+    unsigned nunits = PACKBUFFERSIZE >> 2;
+
+    for (; len > PACKBUFFERSIZE; len -= PACKBUFFERSIZE, data += nunits) {
+	_doXRead32 (dpy, data, PACKBUFFERSIZE, packbuffer);
+    }
+    if (len) _doXRead32 (dpy, data, len, packbuffer);
+}
+
+
+
+/*
+ * _XRead16 - Read bytes from the socket unpacking each 16 bits
+ *            into a long (64 bits on a CRAY computer).
+ *
+ */
+static void _doXRead16 (Display *dpy, short *data, long size, char *packbuffer)
+{
+	long *lpack,*lp;
+	long mask16 = 0x000000000000ffff;
+	long maskw, nwords, i, bits;
+
+        _XRead(dpy,packbuffer,size);	/* don't do a padded read... */
+
+        lp = (long *) data;
+        lpack = (long *) packbuffer;
+        nwords = size >> 1;  /* number of 16 bit words to be unpacked */
+        bits = 48;
+        for(i=0;i<nwords;i++){
+            maskw = mask16 << bits;
+           *lp++ = ( *lpack & maskw ) >> bits;
+            bits -= 16;
+            if(bits < 0){
+               lpack++;
+               bits = 48;
+            }
+        }
+}
+
+void _XRead16 (Display *dpy, short *data, long len)
+{
+    char packbuffer[PACKBUFFERSIZE];
+    unsigned nunits = PACKBUFFERSIZE >> 1;
+
+    for (; len > PACKBUFFERSIZE; len -= PACKBUFFERSIZE, data += nunits) {
+	_doXRead16 (dpy, data, PACKBUFFERSIZE, packbuffer);
+    }
+    if (len) _doXRead16 (dpy, data, len, packbuffer);
+}
+
+void _XRead16Pad (Display *dpy, short *data, long size)
+{
+    int slop = (size & 3);
+    short slopbuf[3];
+
+    _XRead16 (dpy, data, size);
+    if (slop > 0) {
+	_XRead16 (dpy, slopbuf, 4 - slop);
+    }
+}
+#endif /* WORD64 */
+
+
+/*
+ * N_XReadPad - Read bytes from the socket taking into account incomplete
+ * reads.  If the number of bytes is not 0 mod 32, read additional pad
+ * bytes. This routine may have to be reworked if int < long.
+ */
+void N_XReadPad (Display *dpy, char *data, long size)
+{
+    	register long bytes_read;
+	struct iovec iov[2];
+	char pad[3];
+
+        if (!dpy) return;
+	if ((dpy->flags & XlibDisplayIOError) || size == 0) return;
+	iov[0].iov_len = (int)size;
+	iov[0].iov_base = data;
+	/* 
+	 * The following hack is used to provide 32 bit long-word
+	 * aligned padding.  The [1] vector is of length 0, 1, 2, or 3,
+	 * whatever is needed.
+	 */
+
+	iov[1].iov_len = padlength[size & 3];
+	iov[1].iov_base = pad;
+	size += iov[1].iov_len;
+	errno = 0;
+	while ((bytes_read = ReadvFromServer (dpy->fd, iov, 2)) != size) {
+
+	    if (bytes_read > 0) {
+		size -= bytes_read;
+		if (iov[0].iov_len < bytes_read) {
+		    iov[1].iov_len += iov[0].iov_len - bytes_read;
+		    iov[1].iov_base =
+			(char *)iov[1].iov_base + bytes_read - iov[0].iov_len;
+		    iov[0].iov_len = 0;
+		}
+	    	else {
+		    iov[0].iov_len -= bytes_read;
+	    	    iov[0].iov_base = (char *)iov[0].iov_base + bytes_read;
+	    	}
+	    }
+	    else if (ETEST(errno)) {
+		N_XWaitForReadable(dpy);
+		errno = 0;
+	    }
+#ifdef SUNSYSV
+	    else if (errno == 0) {
+		N_XWaitForReadable(dpy);
+	    }
+#endif
+	    else if (bytes_read == 0) {
+		/* Read failed because of end of file! */
+		errno = EPIPE;
+		_XIOError(dpy);
+		}
+	    
+	    else  /* bytes_read is less than 0; presumably -1 */ {
+		/* If it's a system call interrupt, it's not an error. */
+		if (errno != EINTR)
+		    _XIOError(dpy);
+		}
+	    }
+}
+
+/*
+ * N_XSend - Flush the buffer and send the client data. 32 bit word aligned
+ * transmission is used, if size is not 0 mod 4, extra bytes are transmitted.
+ * This routine may have to be reworked if int < long;
+ */
+void N_XSend (Display *dpy, _Xconst char *data, long size)
+{
+	struct iovec iov[3];
+	static char pad[3] = {0, 0, 0};
+           /* XText8 and XText16 require that the padding bytes be zero! */
+
+	long skip = 0;
+	long dpybufsize = (dpy->bufptr - dpy->buffer);
+	long padsize = padlength[size & 3];
+	long total = dpybufsize + size + padsize;
+	long todo = total;
+
+	if (dpy->flags & XlibDisplayIOError) return;
+
+	/*
+	 * There are 3 pieces that may need to be written out:
+	 *
+	 *     o  whatever is in the display buffer
+	 *     o  the data passed in by the user
+	 *     o  any padding needed to 32bit align the whole mess
+	 *
+	 * This loop looks at all 3 pieces each time through.  It uses skip
+	 * to figure out whether or not a given piece is needed.
+	 */
+	while (total) {
+	    long before = skip;		/* amount of whole thing written */
+	    long remain = todo;		/* amount to try this time, <= total */
+	    int i = 0;
+	    long len;
+
+	    /* You could be very general here and have "in" and "out" iovecs
+	     * and write a loop without using a macro, but what the heck.  This
+	     * translates to:
+	     *
+	     *     how much of this piece is new?
+	     *     if more new then we are trying this time, clamp
+	     *     if nothing new
+	     *         then bump down amount already written, for next piece
+	     *         else put new stuff in iovec, will need all of next piece
+	     *
+	     * Note that todo had better be at least 1 or else we'll end up
+	     * writing 0 iovecs.
+	     */
+#define InsertIOV(pointer, length) \
+	    len = (length) - before; \
+	    if (len > remain) \
+		len = remain; \
+	    if (len <= 0) { \
+		before = (-len); \
+	    } else { \
+		iov[i].iov_len = len; \
+		iov[i].iov_base = (pointer) + before; \
+		i++; \
+		remain -= len; \
+		before = 0; \
+	    }
+
+	    InsertIOV (dpy->buffer, dpybufsize)
+	    InsertIOV ((char *)data, size)
+	    InsertIOV (pad, padsize)
+    
+	    errno = 0;
+	    if ((len = WritevToServer(dpy->fd, iov, i)) >= 0) {
+		skip += len;
+		total -= len;
+		todo = total;
+	    } else if (ETEST(errno)) {
+		N_XWaitForWritable(dpy);
+#ifdef SUNSYSV
+	    } else if (errno == 0) {
+		N_XWaitForWritable(dpy);
+#endif
+#ifdef EMSGSIZE
+	    } else if (errno == EMSGSIZE) {
+		if (todo > 1) 
+		  todo >>= 1;
+		else 
+		  N_XWaitForWritable(dpy);
+#endif
+	    } else if (errno != EINTR) {
+		_XIOError(dpy);
+	    }
+	}
+
+	dpy->bufptr = dpy->buffer;
+	dpy->last_req = (char *) & _dummy_request;
+	return;
+}
+
+#ifdef NEEDFORNX
+/*
+ * _XAllocID - normal resource ID allocation routine.  A client
+ * can roll his own and instatantiate it if he wants, but must
+ * follow the rules.
+ */
+XID _XAllocID(Display *dpy)
+{
+   XID id;
+
+   id = dpy->resource_id << dpy->resource_shift;
+   if (id <= dpy->resource_mask) {
+       dpy->resource_id++;
+       return (dpy->resource_base + id);
+   }
+   if (id != 0x10000000) {
+       (void) fprintf(stderr,
+		      "Xlib: resource ID allocation space exhausted!\n");
+       id = 0x10000000;
+       dpy->resource_id = id >> dpy->resource_shift;
+   }
+   return id;
+}
+
+/*
+ * The hard part about this is that we only get 16 bits from a reply.  Well,
+ * then, we have three values that will march along, with the following
+ * invariant:
+ *	dpy->last_request_read <= rep->sequenceNumber <= dpy->request
+ * The right choice for rep->sequenceNumber is the largest that
+ * still meets these constraints.
+ */
+
+unsigned long
+_XSetLastRequestRead(Display *dpy, xGenericReply *rep)
+{
+    register unsigned long	newseq, lastseq;
+
+    /*
+     * KeymapNotify has no sequence number, but is always guaranteed
+     * to immediately follow another event, except when generated via
+     * SendEvent (hmmm).
+     */
+    if ((rep->type & 0x7f) == KeymapNotify)
+	return(dpy->last_request_read);
+
+    newseq = (dpy->last_request_read & ~((unsigned long)0xffff)) |
+	     rep->sequenceNumber;
+    lastseq = dpy->last_request_read;
+    while (newseq < lastseq) {
+	newseq += 0x10000;
+	if (newseq > dpy->request) {
+	    (void) fprintf (stderr, 
+	    "Xlib:  sequence lost (0x%lx > 0x%lx) in reply type 0x%x!\n",
+	                           newseq, dpy->request, 
+				   (unsigned int) rep->type);
+	    newseq -= 0x10000;
+	    break;
+	}
+    }
+
+    dpy->last_request_read = newseq;
+    return(newseq);
+}
+
+#endif /* NEEDFORNX */
+
+/*
+ * N_XReply - Wait for a reply packet and copy its contents into the
+ * specified rep.  Mean while we must handle error and event packets that
+ * we may encounter.
+ */
+Status N_XReply (
+    Display *dpy,
+    xReply *rep,
+    int extra,		/* number of 32-bit words expected after the reply */
+    Bool discard)	/* should I discard data following "extra" words? */
+{
+    /* Pull out the serial number now, so that (currently illegal) requests
+     * generated by an error handler don't confuse us.
+     */
+    unsigned long cur_request = dpy->request;
+
+    if (dpy->flags & XlibDisplayIOError) return (0);
+
+    N_XFlush(dpy);
+    while (1) {
+	N_XRead(dpy, (char *)rep, (long)SIZEOF(xReply));
+	switch ((int)rep->generic.type) {
+
+	    case X_Reply:
+	        /* Reply received.  Fast update for synchronous replies,
+		 * but deal with multiple outstanding replies.
+		 */
+	        if (rep->generic.sequenceNumber == (cur_request & 0xffff))
+		    dpy->last_request_read = cur_request;
+		else
+		    (void) _XSetLastRequestRead(dpy, &rep->generic);
+		if (extra == 0) {
+		    if (discard && (rep->generic.length > 0))
+		       /* unexpectedly long reply! */
+		       _EatData32 (dpy, rep->generic.length);
+		    return (1);
+		    }
+		if ((unsigned) extra == rep->generic.length) {
+		    /* 
+		     * Read the extra data into storage immediately following
+		     * the GenericReply structure. 
+		     */
+		    N_XRead (dpy, (char *) (NEXTPTR(rep,xReply)),
+			    ((long)extra) << 2);
+		    return (1);
+		    }
+		if ((unsigned) extra < rep->generic.length) {
+		    /* Actual reply is longer than "extra" */
+		    N_XRead (dpy, (char *) (NEXTPTR(rep,xReply)),
+			    ((long)extra) << 2);
+		    if (discard)
+		        _EatData32 (dpy, rep->generic.length - extra);
+		    return (1);
+		    }
+		/* 
+		 *if we get here, then extra > rep->generic.length--meaning we
+		 * read a reply that's shorter than we expected.  This is an 
+		 * error,  but we still need to figure out how to handle it...
+		 */
+		N_XRead (dpy, (char *) (NEXTPTR(rep,xReply)),
+			((long) rep->generic.length) << 2);
+		_XIOError (dpy);
+		return (0);
+
+    	    case X_Error:
+	    	{
+	        register _XExtension *ext;
+		register Bool ret = False;
+		int ret_code;
+		xError *err = (xError *) rep;
+		unsigned long serial;
+
+		serial = _XSetLastRequestRead(dpy, (xGenericReply *)rep);
+		/* 
+		 * we better see if there is an extension who may
+		 * want to suppress the error.
+		 */
+		for (ext = dpy->ext_procs; !ret && ext; ext = ext->next) {
+		    if (ext->error) 
+		       ret = (*ext->error)(dpy, err, &ext->codes, &ret_code);
+		}
+		if (!ret) {
+		    _XError(dpy, err);
+		    ret_code = 0;
+		}
+		if (serial == cur_request)
+		    return(ret_code);
+		}
+		break;
+	    default:
+		/* There should never be any events on this connection! */
+		DPSFatalProc(NULL, "N_XReply read bogus X event");
+		break;
+	    }
+	}
+}   
+
+
+/* Read and discard "n" 8-bit bytes of data */
+
+static void
+N_XEatData (Display *dpy, unsigned long n)
+{
+#define SCRATCHSIZE 2048
+    char buf[SCRATCHSIZE];
+
+    while (n > 0) {
+	register long bytes_read = (n > SCRATCHSIZE) ? SCRATCHSIZE : n;
+	N_XRead (dpy, buf, bytes_read);
+	n -= bytes_read;
+    }
+#undef SCRATCHSIZE
+}
+
+
+/* Read and discard "n" 32-bit words. */
+
+static void _EatData32 (Display *dpy, unsigned long n)
+{
+    N_XEatData (dpy, n << 2);
+}
+
+
+#ifdef NEEDFORNX
+/*
+ * _XEnq - Place event packets on the display's queue.
+ * note that no squishing of move events in V11, since there
+ * is pointer motion hints....
+ */
+void _XEnq (Display *dpy, xEvent *event)
+{
+	register _XQEvent *qelt;
+
+/*NOSTRICT*/
+	if (qelt = _qfree) {
+		/* If _qfree is non-NULL do this, else malloc a new one. */
+		_qfree = qelt->next;
+	}
+	else if ((qelt = 
+	    (_XQEvent *) Xmalloc((unsigned)sizeof(_XQEvent))) == NULL) {
+		/* Malloc call failed! */
+		errno = ENOMEM;
+		_XIOError(dpy);
+	}
+	qelt->next = NULL;
+	/* go call through display to find proper event reformatter */
+	if ((*dpy->event_vec[event->u.u.type & 0177])(dpy, &qelt->event, event)) {
+	    if (dpy->tail)	dpy->tail->next = qelt;
+	    else 		dpy->head = qelt;
+    
+	    dpy->tail = qelt;
+	    dpy->qlen++;
+	} else {
+	    /* ignored, or stashed away for many-to-one compression */
+	    qelt->next = _qfree;
+	    _qfree = qelt;
+	}
+}
+/*
+ * EventToWire in separate file in that often not needed.
+ */
+#endif /* NEEDFORNX */
+
+/*ARGSUSED*/
+Bool
+N_XUnknownWireEvent(
+	Display *dpy,	/* pointer to display structure */
+	XEvent *re,	/* pointer to where event should be reformatted */
+	xEvent *event)	/* wire protocol event */
+{
+        char mbuf[256];
+	
+	sprintf(mbuf, "NX: unhandled wire event %d, agent = %lx", re->type, (long)dpy);
+	DPSWarnProc(NULL, mbuf);
+	return(False);
+}
+
+/*ARGSUSED*/
+Status
+N_XUnknownNativeEvent(
+	Display *dpy,	/* pointer to display structure */
+	XEvent *re,	/* pointer to where event should be reformatted */
+	xEvent *event)	/* wire protocol event */
+{
+        char mbuf[256];
+	
+	sprintf(mbuf, "NX: unhandled native event %d, agent = %lx", re->type, (long)dpy);
+	DPSWarnProc(NULL, mbuf);
+	return(0);
+}
+
+#ifdef NEEDFORNX
+/*
+ * reformat a wire event into an XEvent structure of the right type.
+ */
+Bool
+_XWireToEvent(
+	Display *dpy,	/* pointer to display structure */
+	XEvent *re,	/* pointer to where event should be reformatted */
+	xEvent *event)	/* wire protocol event */
+{
+
+	re->type = event->u.u.type & 0x7f;
+	((XAnyEvent *)re)->serial = _XSetLastRequestRead(dpy,
+					(xGenericReply *)event);
+	((XAnyEvent *)re)->send_event = ((event->u.u.type & 0x80) != 0);
+	((XAnyEvent *)re)->display = dpy;
+	
+	/* Ignore the leading bit of the event type since it is set when a
+		client sends an event rather than the server. */
+
+	switch (event-> u.u.type & 0177) {
+	      case KeyPress:
+	      case KeyRelease:
+	        {
+			register XKeyEvent *ev = (XKeyEvent*) re;
+			ev->root 	= event->u.keyButtonPointer.root;
+			ev->window 	= event->u.keyButtonPointer.event;
+			ev->subwindow 	= event->u.keyButtonPointer.child;
+			ev->time 	= event->u.keyButtonPointer.time;
+			ev->x 		= cvtINT16toInt(event->u.keyButtonPointer.eventX);
+			ev->y 		= cvtINT16toInt(event->u.keyButtonPointer.eventY);
+			ev->x_root 	= cvtINT16toInt(event->u.keyButtonPointer.rootX);
+			ev->y_root 	= cvtINT16toInt(event->u.keyButtonPointer.rootY);
+			ev->state	= event->u.keyButtonPointer.state;
+			ev->same_screen	= event->u.keyButtonPointer.sameScreen;
+			ev->keycode 	= event->u.u.detail;
+		}
+	      	break;
+	      case ButtonPress:
+	      case ButtonRelease:
+	        {
+			register XButtonEvent *ev =  (XButtonEvent *) re;
+			ev->root 	= event->u.keyButtonPointer.root;
+			ev->window 	= event->u.keyButtonPointer.event;
+			ev->subwindow 	= event->u.keyButtonPointer.child;
+			ev->time 	= event->u.keyButtonPointer.time;
+			ev->x 		= cvtINT16toInt(event->u.keyButtonPointer.eventX);
+			ev->y 		= cvtINT16toInt(event->u.keyButtonPointer.eventY);
+			ev->x_root 	= cvtINT16toInt(event->u.keyButtonPointer.rootX);
+			ev->y_root 	= cvtINT16toInt(event->u.keyButtonPointer.rootY);
+			ev->state	= event->u.keyButtonPointer.state;
+			ev->same_screen	= event->u.keyButtonPointer.sameScreen;
+			ev->button 	= event->u.u.detail;
+		}
+	        break;
+	      case MotionNotify:
+	        {
+			register XMotionEvent *ev =   (XMotionEvent *)re;
+			ev->root 	= event->u.keyButtonPointer.root;
+			ev->window 	= event->u.keyButtonPointer.event;
+			ev->subwindow 	= event->u.keyButtonPointer.child;
+			ev->time 	= event->u.keyButtonPointer.time;
+			ev->x 		= cvtINT16toInt(event->u.keyButtonPointer.eventX);
+			ev->y 		= cvtINT16toInt(event->u.keyButtonPointer.eventY);
+			ev->x_root 	= cvtINT16toInt(event->u.keyButtonPointer.rootX);
+			ev->y_root 	= cvtINT16toInt(event->u.keyButtonPointer.rootY);
+			ev->state	= event->u.keyButtonPointer.state;
+			ev->same_screen	= event->u.keyButtonPointer.sameScreen;
+			ev->is_hint 	= event->u.u.detail;
+		}
+	        break;
+	      case EnterNotify:
+	      case LeaveNotify:
+		{
+			register XCrossingEvent *ev   = (XCrossingEvent *) re;
+			ev->root	= event->u.enterLeave.root;
+			ev->window	= event->u.enterLeave.event;
+			ev->subwindow	= event->u.enterLeave.child;
+			ev->time	= event->u.enterLeave.time;
+			ev->x		= cvtINT16toInt(event->u.enterLeave.eventX);
+			ev->y		= cvtINT16toInt(event->u.enterLeave.eventY);
+			ev->x_root	= cvtINT16toInt(event->u.enterLeave.rootX);
+			ev->y_root	= cvtINT16toInt(event->u.enterLeave.rootY);
+			ev->state	= event->u.enterLeave.state;
+			ev->mode	= event->u.enterLeave.mode;
+			ev->same_screen = (event->u.enterLeave.flags & 
+				ELFlagSameScreen) && True;
+			ev->focus	= (event->u.enterLeave.flags &
+			  	ELFlagFocus) && True;
+			ev->detail	= event->u.u.detail;
+		}
+		  break;
+	      case FocusIn:
+	      case FocusOut:
+		{
+			register XFocusChangeEvent *ev = (XFocusChangeEvent *) re;
+			ev->window 	= event->u.focus.window;
+			ev->mode	= event->u.focus.mode;
+			ev->detail	= event->u.u.detail;
+		}
+		  break;
+	      case KeymapNotify:
+		{
+			register XKeymapEvent *ev = (XKeymapEvent *) re;
+			ev->window	= dpy->current;
+			bcopy ((char *)((xKeymapEvent *) event)->map,
+			       &ev->key_vector[1], 
+			       sizeof (((xKeymapEvent *) event)->map));
+		}
+		break;
+	      case Expose:
+		{
+			register XExposeEvent *ev = (XExposeEvent *) re;
+			ev->window	= event->u.expose.window;
+			ev->x		= event->u.expose.x;
+			ev->y		= event->u.expose.y;
+			ev->width	= event->u.expose.width;
+			ev->height	= event->u.expose.height;
+			ev->count	= event->u.expose.count;
+		}
+		break;
+	      case GraphicsExpose:
+		{
+		    register XGraphicsExposeEvent *ev =
+			(XGraphicsExposeEvent *) re;
+		    ev->drawable	= event->u.graphicsExposure.drawable;
+		    ev->x		= event->u.graphicsExposure.x;
+		    ev->y		= event->u.graphicsExposure.y;
+		    ev->width		= event->u.graphicsExposure.width;
+		    ev->height		= event->u.graphicsExposure.height;
+		    ev->count		= event->u.graphicsExposure.count;
+		    ev->major_code	= event->u.graphicsExposure.majorEvent;
+		    ev->minor_code	= event->u.graphicsExposure.minorEvent;
+		}
+		break;
+	      case NoExpose:
+		{
+		    register XNoExposeEvent *ev = (XNoExposeEvent *) re;
+		    ev->drawable	= event->u.noExposure.drawable;
+		    ev->major_code	= event->u.noExposure.majorEvent;
+		    ev->minor_code	= event->u.noExposure.minorEvent;
+		}
+		break;
+	      case VisibilityNotify:
+		{
+		    register XVisibilityEvent *ev = (XVisibilityEvent *) re;
+		    ev->window		= event->u.visibility.window;
+		    ev->state		= event->u.visibility.state;
+		}
+		break;
+	      case CreateNotify:
+		{
+		    register XCreateWindowEvent *ev =
+			 (XCreateWindowEvent *) re;
+		    ev->window		= event->u.createNotify.window;
+		    ev->parent		= event->u.createNotify.parent;
+		    ev->x		= cvtINT16toInt(event->u.createNotify.x);
+		    ev->y		= cvtINT16toInt(event->u.createNotify.y);
+		    ev->width		= event->u.createNotify.width;
+		    ev->height		= event->u.createNotify.height;
+		    ev->border_width	= event->u.createNotify.borderWidth;
+		    ev->override_redirect	= event->u.createNotify.override;
+		}
+		break;
+	      case DestroyNotify:
+		{
+		    register XDestroyWindowEvent *ev =
+				(XDestroyWindowEvent *) re;
+		    ev->window		= event->u.destroyNotify.window;
+		    ev->event		= event->u.destroyNotify.event;
+		}
+		break;
+	      case UnmapNotify:
+		{
+		    register XUnmapEvent *ev = (XUnmapEvent *) re;
+		    ev->window		= event->u.unmapNotify.window;
+		    ev->event		= event->u.unmapNotify.event;
+		    ev->from_configure	= event->u.unmapNotify.fromConfigure;
+		}
+		break;
+	      case MapNotify:
+		{
+		    register XMapEvent *ev = (XMapEvent *) re;
+		    ev->window		= event->u.mapNotify.window;
+		    ev->event		= event->u.mapNotify.event;
+		    ev->override_redirect	= event->u.mapNotify.override;
+		}
+		break;
+	      case MapRequest:
+		{
+		    register XMapRequestEvent *ev = (XMapRequestEvent *) re;
+		    ev->window		= event->u.mapRequest.window;
+		    ev->parent		= event->u.mapRequest.parent;
+		}
+		break;
+	      case ReparentNotify:
+		{
+		    register XReparentEvent *ev = (XReparentEvent *) re;
+		    ev->event		= event->u.reparent.event;
+		    ev->window		= event->u.reparent.window;
+		    ev->parent		= event->u.reparent.parent;
+		    ev->x		= cvtINT16toInt(event->u.reparent.x);
+		    ev->y		= cvtINT16toInt(event->u.reparent.y);
+		    ev->override_redirect	= event->u.reparent.override;
+		}
+		break;
+	      case ConfigureNotify:
+		{
+		    register XConfigureEvent *ev = (XConfigureEvent *) re;
+		    ev->event	= event->u.configureNotify.event;
+		    ev->window	= event->u.configureNotify.window;
+		    ev->above	= event->u.configureNotify.aboveSibling;
+		    ev->x	= cvtINT16toInt(event->u.configureNotify.x);
+		    ev->y	= cvtINT16toInt(event->u.configureNotify.y);
+		    ev->width	= event->u.configureNotify.width;
+		    ev->height	= event->u.configureNotify.height;
+		    ev->border_width  = event->u.configureNotify.borderWidth;
+		    ev->override_redirect = event->u.configureNotify.override;
+		}
+		break;
+	      case ConfigureRequest:
+		{
+		    register XConfigureRequestEvent *ev =
+		        (XConfigureRequestEvent *) re;
+		    ev->window		= event->u.configureRequest.window;
+		    ev->parent		= event->u.configureRequest.parent;
+		    ev->above		= event->u.configureRequest.sibling;
+		    ev->x		= cvtINT16toInt(event->u.configureRequest.x);
+		    ev->y		= cvtINT16toInt(event->u.configureRequest.y);
+		    ev->width		= event->u.configureRequest.width;
+		    ev->height		= event->u.configureRequest.height;
+		    ev->border_width	= event->u.configureRequest.borderWidth;
+		    ev->value_mask	= event->u.configureRequest.valueMask;
+		    ev->detail  	= event->u.u.detail;
+		}
+		break;
+	      case GravityNotify:
+		{
+		    register XGravityEvent *ev = (XGravityEvent *) re;
+		    ev->window		= event->u.gravity.window;
+		    ev->event		= event->u.gravity.event;
+		    ev->x		= cvtINT16toInt(event->u.gravity.x);
+		    ev->y		= cvtINT16toInt(event->u.gravity.y);
+		}
+		break;
+	      case ResizeRequest:
+		{
+		    register XResizeRequestEvent *ev =
+			(XResizeRequestEvent *) re;
+		    ev->window		= event->u.resizeRequest.window;
+		    ev->width		= event->u.resizeRequest.width;
+		    ev->height		= event->u.resizeRequest.height;
+		}
+		break;
+	      case CirculateNotify:
+		{
+		    register XCirculateEvent *ev = (XCirculateEvent *) re;
+		    ev->window		= event->u.circulate.window;
+		    ev->event		= event->u.circulate.event;
+		    ev->place		= event->u.circulate.place;
+		}
+		break;
+	      case CirculateRequest:
+		{
+		    register XCirculateRequestEvent *ev =
+		        (XCirculateRequestEvent *) re;
+		    ev->window		= event->u.circulate.window;
+		    ev->parent		= event->u.circulate.event;
+		    ev->place		= event->u.circulate.place;
+		}
+		break;
+	      case PropertyNotify:
+		{
+		    register XPropertyEvent *ev = (XPropertyEvent *) re;
+		    ev->window		= event->u.property.window;
+		    ev->atom		= event->u.property.atom;
+		    ev->time		= event->u.property.time;
+		    ev->state		= event->u.property.state;
+		}
+		break;
+	      case SelectionClear:
+		{
+		    register XSelectionClearEvent *ev =
+			 (XSelectionClearEvent *) re;
+		    ev->window		= event->u.selectionClear.window;
+		    ev->selection	= event->u.selectionClear.atom;
+		    ev->time		= event->u.selectionClear.time;
+		}
+		break;
+	      case SelectionRequest:
+		{
+		    register XSelectionRequestEvent *ev =
+		        (XSelectionRequestEvent *) re;
+		    ev->owner		= event->u.selectionRequest.owner;
+		    ev->requestor	= event->u.selectionRequest.requestor;
+		    ev->selection	= event->u.selectionRequest.selection;
+		    ev->target		= event->u.selectionRequest.target;
+		    ev->property	= event->u.selectionRequest.property;
+		    ev->time		= event->u.selectionRequest.time;
+		}
+		break;
+	      case SelectionNotify:
+		{
+		    register XSelectionEvent *ev = (XSelectionEvent *) re;
+		    ev->requestor	= event->u.selectionNotify.requestor;
+		    ev->selection	= event->u.selectionNotify.selection;
+		    ev->target		= event->u.selectionNotify.target;
+		    ev->property	= event->u.selectionNotify.property;
+		    ev->time		= event->u.selectionNotify.time;
+		}
+		break;
+	      case ColormapNotify:
+		{
+		    register XColormapEvent *ev = (XColormapEvent *) re;
+		    ev->window		= event->u.colormap.window;
+		    ev->colormap	= event->u.colormap.colormap;
+		    ev->new		= event->u.colormap.new;
+		    ev->state		= event->u.colormap.state;
+	        }
+		break;
+	      case ClientMessage:
+		{
+		   register int i;
+		   register XClientMessageEvent *ev 
+		   			= (XClientMessageEvent *) re;
+		   ev->window		= event->u.clientMessage.window;
+		   ev->format		= event->u.u.detail;
+		   switch (ev->format) {
+			case 8:	
+			   ev->message_type = event->u.clientMessage.u.b.type;
+			   for (i = 0; i < 20; i++) 	
+			     ev->data.b[i] = event->u.clientMessage.u.b.bytes[i];
+			   break;
+			case 16:
+			   ev->message_type = event->u.clientMessage.u.s.type;
+			   ev->data.s[0] = cvtINT16toShort(event->u.clientMessage.u.s.shorts0);
+			   ev->data.s[1] = cvtINT16toShort(event->u.clientMessage.u.s.shorts1);
+			   ev->data.s[2] = cvtINT16toShort(event->u.clientMessage.u.s.shorts2);
+			   ev->data.s[3] = cvtINT16toShort(event->u.clientMessage.u.s.shorts3);
+			   ev->data.s[4] = cvtINT16toShort(event->u.clientMessage.u.s.shorts4);
+			   ev->data.s[5] = cvtINT16toShort(event->u.clientMessage.u.s.shorts5);
+			   ev->data.s[6] = cvtINT16toShort(event->u.clientMessage.u.s.shorts6);
+			   ev->data.s[7] = cvtINT16toShort(event->u.clientMessage.u.s.shorts7);
+			   ev->data.s[8] = cvtINT16toShort(event->u.clientMessage.u.s.shorts8);
+			   ev->data.s[9] = cvtINT16toShort(event->u.clientMessage.u.s.shorts9);
+			   break;
+			case 32:
+			   ev->message_type = event->u.clientMessage.u.l.type;
+			   ev->data.l[0] = cvtINT32toLong(event->u.clientMessage.u.l.longs0);
+			   ev->data.l[1] = cvtINT32toLong(event->u.clientMessage.u.l.longs1);
+			   ev->data.l[2] = cvtINT32toLong(event->u.clientMessage.u.l.longs2);
+			   ev->data.l[3] = cvtINT32toLong(event->u.clientMessage.u.l.longs3);
+			   ev->data.l[4] = cvtINT32toLong(event->u.clientMessage.u.l.longs4);
+			   break;
+			default: /* XXX should never occur */
+				break;
+		    }
+	        }
+		break;
+	      case MappingNotify:
+		{
+		   register XMappingEvent *ev = (XMappingEvent *)re;
+		   ev->window		= 0;
+		   ev->first_keycode 	= event->u.mappingNotify.firstKeyCode;
+		   ev->request 		= event->u.mappingNotify.request;
+		   ev->count 		= event->u.mappingNotify.count;
+		}
+		break;
+	      default:
+		return(_XUnknownWireEvent(dpy, re, event));
+	}
+	return(True);
+}
+
+
+#ifndef USL_SHARELIB
+
+static char *_SysErrorMsg (int n)
+{
+    extern char *sys_errlist[];
+    extern int sys_nerr;
+    char *s = ((n >= 0 && n < sys_nerr) ? sys_errlist[n] : "unknown error");
+
+    return (s ? s : "no such error");
+}
+
+#endif 	/* USL sharedlibs in don't define for SVR3.2 */
+
+
+/*
+ * _XDefaultIOError - Default fatal system error reporting routine.  Called 
+ * when an X internal system error is encountered.
+ */
+_XDefaultIOError (Display *dpy)
+{
+	(void) fprintf (stderr, 
+	 "XIO:  fatal IO error %d (%s) on X server \"%s\"\r\n",
+			errno, _SysErrorMsg (errno), DisplayString (dpy));
+	(void) fprintf (stderr, 
+	 "      after %lu requests (%lu known processed) with %d events remaining.\r\n",
+			NextRequest(dpy) - 1, LastKnownRequestProcessed(dpy),
+			QLength(dpy));
+
+	if (errno == EPIPE) {
+	    (void) fprintf (stderr,
+	 "      The connection was probably broken by a server shutdown or KillClient.\r\n");
+	}
+	exit(1);
+}
+
+
+static int _XPrintDefaultError (Display *dpy, XErrorEvent *event, FILE *fp)
+{
+    char buffer[BUFSIZ];
+    char mesg[BUFSIZ];
+    char number[32];
+    char *mtype = "XlibMessage";
+    register _XExtension *ext = (_XExtension *)NULL;
+    _XExtension *bext = (_XExtension *)NULL;
+    XGetErrorText(dpy, event->error_code, buffer, BUFSIZ);
+    XGetErrorDatabaseText(dpy, mtype, "XError", "X Error", mesg, BUFSIZ);
+    (void) fprintf(fp, "%s:  %s\n  ", mesg, buffer);
+    XGetErrorDatabaseText(dpy, mtype, "MajorCode", "Request Major code %d", 
+	mesg, BUFSIZ);
+    (void) fprintf(fp, mesg, event->request_code);
+    if (event->request_code < 128) {
+	sprintf(number, "%d", event->request_code);
+	XGetErrorDatabaseText(dpy, "XRequest", number, "", buffer, BUFSIZ);
+    } else {
+	for (ext = dpy->ext_procs;
+	     ext && (ext->codes.major_opcode != event->request_code);
+	     ext = ext->next)
+	  ;
+	if (ext)
+	    strcpy(buffer, ext->name);
+	else
+	    buffer[0] = '\0';
+    }
+    (void) fprintf(fp, " (%s)\n", buffer);
+    if (event->request_code >= 128) {
+	XGetErrorDatabaseText(dpy, mtype, "MinorCode", "Request Minor code %d",
+			      mesg, BUFSIZ);
+	fputs("  ", fp);
+	(void) fprintf(fp, mesg, event->minor_code);
+	if (ext) {
+	    sprintf(mesg, "%s.%d", ext->name, event->minor_code);
+	    XGetErrorDatabaseText(dpy, "XRequest", mesg, "", buffer, BUFSIZ);
+	    (void) fprintf(fp, " (%s)", buffer);
+	}
+	fputs("\n", fp);
+    }
+    if (event->error_code >= 128) {
+	/* kludge, try to find the extension that caused it */
+	buffer[0] = '\0';
+	for (ext = dpy->ext_procs; ext; ext = ext->next) {
+	    if (ext->error_string) 
+		(*ext->error_string)(dpy, event->error_code, &ext->codes,
+				     buffer, BUFSIZ);
+	    if (buffer[0]) {
+		bext = ext;
+		break;
+	    }
+	    if (ext->codes.first_error &&
+		ext->codes.first_error < event->error_code &&
+		(!bext || ext->codes.first_error > bext->codes.first_error))
+		bext = ext;
+	}    
+	if (bext)
+	    sprintf(buffer, "%s.%d", bext->name,
+		    event->error_code - bext->codes.first_error);
+	else
+	    strcpy(buffer, "Value");
+	XGetErrorDatabaseText(dpy, mtype, buffer, "", mesg, BUFSIZ);
+	if (mesg[0]) {
+	    fputs("  ", fp);
+	    (void) fprintf(fp, mesg, event->resourceid);
+	    fputs("\n", fp);
+	}
+	/* let extensions try to print the values */
+	for (ext = dpy->ext_procs; ext; ext = ext->next) {
+	    if (ext->error_values)
+		(*ext->error_values)(dpy, event, fp);
+	}
+    } else if ((event->error_code == BadWindow) ||
+	       (event->error_code == BadPixmap) ||
+	       (event->error_code == BadCursor) ||
+	       (event->error_code == BadFont) ||
+	       (event->error_code == BadDrawable) ||
+	       (event->error_code == BadColor) ||
+	       (event->error_code == BadGC) ||
+	       (event->error_code == BadIDChoice) ||
+	       (event->error_code == BadValue) ||
+	       (event->error_code == BadAtom)) {
+	if (event->error_code == BadValue)
+	    XGetErrorDatabaseText(dpy, mtype, "Value", "Value 0x%x",
+				  mesg, BUFSIZ);
+	else if (event->error_code == BadAtom)
+	    XGetErrorDatabaseText(dpy, mtype, "AtomID", "AtomID 0x%x",
+				  mesg, BUFSIZ);
+	else
+	    XGetErrorDatabaseText(dpy, mtype, "ResourceID", "ResourceID 0x%x",
+				  mesg, BUFSIZ);
+	fputs("  ", fp);
+	(void) fprintf(fp, mesg, event->resourceid);
+	fputs("\n", fp);
+    }
+    XGetErrorDatabaseText(dpy, mtype, "ErrorSerial", "Error Serial #%d", 
+			  mesg, BUFSIZ);
+    fputs("  ", fp);
+    (void) fprintf(fp, mesg, event->serial);
+    XGetErrorDatabaseText(dpy, mtype, "CurrentSerial", "Current Serial #%d",
+			  mesg, BUFSIZ);
+    fputs("\n  ", fp);
+    (void) fprintf(fp, mesg, dpy->request);
+    fputs("\n", fp);
+    if (event->error_code == BadImplementation) return 0;
+    return 1;
+}
+
+int _XDefaultError(Display *dpy, XErrorEvent *event)
+{
+    if (_XPrintDefaultError (dpy, event, stderr) == 0) return 0;
+    exit(1);
+    /*NOTREACHED*/
+}
+
+/*ARGSUSED*/
+Bool _XDefaultWireError(Display *display, XErrorEvent *he, xError *we)
+{
+    return True;
+}
+
+/*
+ * _XError - prepare to upcall user protocol error handler
+ */
+int _XError (Display *dpy, xError *rep)
+{
+    /* 
+     * X_Error packet encountered!  We need to unpack the error before
+     * giving it to the user.
+     */
+    XEvent event; /* make it a large event */
+
+    event.xerror.display = dpy;
+    event.xerror.type = X_Error;
+    event.xerror.serial = _XSetLastRequestRead(dpy, (xGenericReply *)rep);
+    event.xerror.resourceid = rep->resourceID;
+    event.xerror.error_code = rep->errorCode;
+    event.xerror.request_code = rep->majorCode;
+    event.xerror.minor_code = rep->minorCode;
+    if (dpy->error_vec &&
+	!(*dpy->error_vec[rep->errorCode])(dpy, &event.xerror, rep))
+	return 0;
+    if (_XErrorFunction != NULL) {
+      	return ((*_XErrorFunction)(dpy, &event));	/* upcall */
+    } else {
+	return _XDefaultError(dpy, &event);
+    }
+}
+    
+/*
+ * _XIOError - call user connection error handler and exit
+ */
+int _XIOError (Display *dpy)
+{
+    dpy->flags |= XlibDisplayIOError;
+    if (_XIOErrorFunction != NULL)
+	(*_XIOErrorFunction)(dpy);
+    else
+	_XDefaultIOError(dpy);
+    exit (1);
+}
+
+
+/*
+ * This routine can be used to (cheaply) get some memory within a single
+ * Xlib routine for scratch space.  It is reallocated from the same place
+ * each time, unless the library needs a large scratch space.
+ */
+char *_XAllocScratch (Display *dpy, unsigned long nbytes)
+{
+	if (nbytes > dpy->scratch_length) {
+	    if (dpy->scratch_buffer) Xfree (dpy->scratch_buffer);
+	    if (dpy->scratch_buffer = Xmalloc((unsigned) nbytes))
+		dpy->scratch_length = nbytes;
+	    else dpy->scratch_length = 0;
+	}
+	return (dpy->scratch_buffer);
+}
+
+/*
+ * Given a visual id, find the visual structure for this id on this display.
+ */
+Visual *_XVIDtoVisual (Display *dpy, VisualID id)
+{
+	register int i, j, k;
+	register Screen *sp;
+	register Depth *dp;
+	register Visual *vp;
+	for (i = 0; i < dpy->nscreens; i++) {
+		sp = &dpy->screens[i];
+		for (j = 0; j < sp->ndepths; j++) {
+			dp = &sp->depths[j];
+			/* if nvisuals == 0 then visuals will be NULL */
+			for (k = 0; k < dp->nvisuals; k++) {
+				vp = &dp->visuals[k];
+				if (vp->visualid == id) return (vp);
+			}
+		}
+	}
+	return (NULL);
+}
+
+void XFree (void *data)
+{
+	Xfree (data);
+}
+
+#ifdef _XNEEDBCOPYFUNC
+void _Xbcopy(char *b1, char *b2, length)
+{
+    if (b1 < b2) {
+	b2 += length;
+	b1 += length;
+	while (length--)
+	    *--b2 = *--b1;
+    } else {
+	while (length--)
+	    *b2++ = *b1++;
+    }
+}
+#endif
+
+#endif /* NEEDFORNX */
+
+void NXProcData (Display *dpy, char *data, long len)
+{
+	if (dpy->bufptr + (len) <= dpy->bufmax) {
+		bcopy(data, dpy->bufptr, (int)len);
+		dpy->bufptr += ((len) + 3) & ~3;
+	} else {
+		N_XSend(dpy, data, len);
+	}
+}
+
+
+#ifdef WORD64
+
+/*
+ * XXX This is a *really* stupid way of doing this.  It should just use 
+ * dpy->bufptr directly, taking into account where in the word it is.
+ */
+
+/*
+ * Data16 - Place 16 bit data in the buffer.
+ *
+ * "dpy" is a pointer to a Display.
+ * "data" is a pointer to the data.
+ * "len" is the length in bytes of the data.
+ */
+
+static void
+doData16(Display *dpy, short *data, unsigned len, char *packbuffer)
+{
+    long *lp,*lpack;
+    long i, nwords,bits;
+    long mask16 = 0x000000000000ffff;
+
+        lp = (long *)data;
+        lpack = (long *)packbuffer;
+
+/*  nwords is the number of 16 bit values to be packed,
+ *  the low order 16 bits of each word will be packed
+ *  into 64 bit words
+ */
+        nwords = len >> 1;
+        bits = 48;
+
+        for(i=0;i<nwords;i++){
+	   if (bits == 48) *lpack = 0;
+           *lpack ^= (*lp & mask16) << bits;
+           bits -= 16 ;
+           lp++;
+           if(bits < 0){
+               lpack++;
+               bits = 48;
+           }
+        }
+        Data(dpy, packbuffer, len);
+}
+
+void
+Data16 (Display *dpy, short *data, unsigned len)
+{
+    char packbuffer[PACKBUFFERSIZE];
+    unsigned nunits = PACKBUFFERSIZE >> 1;
+
+    for (; len > PACKBUFFERSIZE; len -= PACKBUFFERSIZE, data += nunits) {
+	doData16 (dpy, data, PACKBUFFERSIZE, packbuffer);
+    }
+    if (len) doData16 (dpy, data, len, packbuffer);
+}
+
+/*
+ * Data32 - Place 32 bit data in the buffer.
+ *
+ * "dpy" is a pointer to a Display.
+ * "data" is a pointer to the data.
+ * "len" is the length in bytes of the data.
+ */
+
+static doData32 (Display *dpy, long *data, unsigned len, char *packbuffer)
+{
+    long *lp,*lpack;
+    long i,bits,nwords;
+    long mask32 = 0x00000000ffffffff;
+
+        lpack = (long *) packbuffer;
+        lp = data;
+
+/*  nwords is the number of 32 bit values to be packed
+ *  the low order 32 bits of each word will be packed
+ *  into 64 bit words
+ */
+        nwords = len >> 2;
+        bits = 32;
+
+        for(i=0;i<nwords;i++){
+	   if (bits == 32) *lpack = 0;
+           *lpack ^= (*lp & mask32) << bits;
+           bits = bits ^32;
+           lp++;
+           if(bits)
+              lpack++;
+        }
+        Data(dpy, packbuffer, len);
+}
+
+Data32 (Display *dpy, long *data, unsigned len)
+{
+    char packbuffer[PACKBUFFERSIZE];
+    unsigned nunits = PACKBUFFERSIZE >> 2;
+
+    for (; len > PACKBUFFERSIZE; len -= PACKBUFFERSIZE, data += nunits) {
+	doData32 (dpy, data, PACKBUFFERSIZE, packbuffer);
+    }
+    if (len) doData32 (dpy, data, len, packbuffer);
+}
+
+#endif /* WORD64 */
+
+
+#ifdef NEEDFORNX
+
+/*
+ * _XFreeQ - free the queue of events, called by XCloseDisplay
+ */
+
+void _XFreeQ (void)
+{
+    register _XQEvent *qelt = _qfree;
+  
+    while (qelt) {
+	register _XQEvent *qnxt = qelt->next;
+	Xfree ((char *) qelt);
+	qelt = qnxt;
+    }
+    _qfree = NULL;
+    return;
+}
+#endif /* NEEDFORNX */
+
+/* Make sure this produces the same string as DefineLocal/DefineSelf in xdm.
+ * Otherwise, Xau will not be able to find your cookies in the Xauthority file.
+ *
+ * Note: POSIX says that the ``nodename'' member of utsname does _not_ have
+ *       to have sufficient information for interfacing to the network,
+ *       and so, you may be better off using gethostname (if it exists).
+ */
+
+#if (defined(_POSIX_SOURCE) && !defined(AIXV3)) || defined(hpux) || defined(USG) || defined(SVR4)
+#define NEED_UTSNAME
+#include <sys/utsname.h>
+#endif
+
+/*
+ * N_XGetHostname - similar to gethostname but allows special processing.
+ */
+int N_XGetHostname (char *buf, int maxlen)
+{
+    int len;
+
+#ifdef NEED_UTSNAME
+    struct utsname name;
+
+    uname (&name);
+    len = strlen (name.nodename);
+    if (len >= maxlen) len = maxlen - 1;
+    strncpy (buf, name.nodename, len);
+    buf[len] = '\0';
+#else
+    buf[0] = '\0';
+    (void) gethostname (buf, maxlen);
+    buf [maxlen - 1] = '\0';
+    len = strlen(buf);
+#endif /* NEED_UTSNAME */
+    return len;
+}
+
+#ifdef NEEDFORNX
+/*
+ * _XScreenOfWindow - get the Screen of a given window
+ */
+
+Screen *_XScreenOfWindow (Display *dpy, Window w)
+{
+    register int i;
+    Window root;
+    int x, y;				/* dummy variables */
+    unsigned int width, height, bw, depth;  /* dummy variables */
+
+    if (XGetGeometry (dpy, w, &root, &x, &y, &width, &height,
+		      &bw, &depth) == False) {
+	return None;
+    }
+    for (i = 0; i < ScreenCount (dpy); i++) {	/* find root from list */
+	if (root == RootWindow (dpy, i)) {
+	    return ScreenOfDisplay (dpy, i);
+	}
+    }
+    return NULL;
+}
+#endif /* NEEDFORNX */
+
+#if (MSKCNT > 4)
+/*
+ * This is a macro if MSKCNT <= 4
+ */
+int
+N_XANYSET(unsigned long *src)
+{
+    int i;
+
+    for (i=0; i<MSKCNT; i++)
+	if (src[ i ])
+	    return (1);
+    return (0);
+}
+#endif
+
+#ifdef NEEDFORNX  
+#ifdef CRAY
+/*
+ * Cray UniCOS does not have readv and writev so we emulate
+ */
+#include <sys/socket.h>
+
+int _XReadV (int fd, struct iovec *iov, int iovcnt)
+{
+	struct msghdr hdr;
+
+	hdr.msg_iov = iov;
+	hdr.msg_iovlen = iovcnt;
+	hdr.msg_accrights = 0;
+	hdr.msg_accrightslen = 0;
+	hdr.msg_name = 0;
+	hdr.msg_namelen = 0;
+
+	return (recvmsg (fd, &hdr, 0));
+}
+
+int _XWriteV (int fd, struct iovec *iov, int iovcnt)
+{
+	struct msghdr hdr;
+
+	hdr.msg_iov = iov;
+	hdr.msg_iovlen = iovcnt;
+	hdr.msg_accrights = 0;
+	hdr.msg_accrightslen = 0;
+	hdr.msg_name = 0;
+	hdr.msg_namelen = 0;
+
+	return (sendmsg (fd, &hdr, 0));
+}
+
+#endif /* CRAY */
+
+#if defined(SYSV) && defined(i386) && !defined(STREAMSCONN)
+/*
+ * SYSV/386 does not have readv so we emulate
+ */
+#include <sys/uio.h>
+
+int _XReadV (int fd, struct iovec *iov, int iovcnt)
+{
+    int i, len, total;
+    char *base;
+
+    errno = 0;
+    for (i=0, total=0;  i<iovcnt;  i++, iov++) {
+	len = iov->iov_len;
+	base = iov->iov_base;
+	while (len > 0) {
+	    register int nbytes;
+	    nbytes = read(fd, base, len);
+	    if (nbytes < 0 && total == 0)  return -1;
+	    if (nbytes <= 0)  return total;
+	    errno = 0;
+	    len   -= nbytes;
+	    total += nbytes;
+	    base  += nbytes;
+	}
+    }
+    return total;
+}
+
+#endif /* SYSV && i386 && !STREAMSCONN */
+
+#ifdef STREAMSCONN
+/*
+ * Copyright 1988, 1989 AT&T, Inc.
+ *
+ * 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 of AT&T not be used in advertising
+ * or publicity pertaining to distribution of the software without specific,
+ * written prior permission.  AT&T makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * AT&T DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL AT&T
+ * 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.
+ *
+ */
+
+/*
+ iovec.c (C source file)
+	Acc: 575557389 Mon Mar 28 08:03:09 1988
+	Mod: 575557397 Mon Mar 28 08:03:17 1988
+	Sta: 575557397 Mon Mar 28 08:03:17 1988
+	Owner: 2011
+	Group: 1985
+	Permissions: 664
+*/
+/*
+	START USER STAMP AREA
+*/
+/*
+	END USER STAMP AREA
+*/
+
+
+extern char _XsTypeofStream[];
+extern Xstream _XsStream[];
+
+#define MAX_WORKAREA 4096
+static char workarea[MAX_WORKAREA];
+
+
+
+int
+_XReadV (int fd, struct iovec v[], int n)
+{
+	int i, rc, len, size = 0;
+	char * buf = workarea;
+	char * p;
+
+	if (n <= 0 || n > 16)
+	{
+		errno = EINVAL;
+		return (-1);
+	}
+	for (i = 0; i < n; ++i)
+	{
+		if ((len = v[i].iov_len) < 0 || v[i].iov_base == NULL)
+		{
+			errno = EINVAL;
+			return (-1);
+		}
+		size += len;
+	}
+	if ((size > MAX_WORKAREA) && ((buf = malloc (size)) == NULL))
+	{
+		errno = EINVAL;
+		return (-1);
+	}
+	if((rc = (*_XsStream[_XsTypeOfStream[fd]].ReadFromStream)(fd, buf, size,
+							     BUFFERING))> 0)
+	{
+		for (i = 0, p = buf; i < n; ++i)
+		{
+			memcpy (v[i].iov_base, p, len = v[i].iov_len);
+			p += len;
+		}
+	}
+	if (size > MAX_WORKAREA)
+		free (buf);
+
+	return (rc);
+}
+
+int
+_XWriteV (int fd, struct iovec v[], int n)
+{
+	int i, rc, len, size = 0;
+	char * buf = workarea;
+	char * p;
+
+	if (n <= 0 || n > 16)
+	{
+		errno = EINVAL;
+		return (-1);
+	}
+	for (i = 0; i < n; ++i)
+	{
+		if ((len = v[i].iov_len) < 0 || v[i].iov_base == NULL)
+		{
+			errno = EINVAL;
+			return (-1);
+		}
+		size += len;
+	}
+
+	if ((size > MAX_WORKAREA) && ((buf = malloc (size)) == NULL))
+	{
+		errno = EINVAL;
+		return (-1);
+	}
+	for (i = 0, p = buf; i < n; ++i)
+	{
+		memcpy (p, v[i].iov_base, len = v[i].iov_len);
+		p += len;
+	}
+	rc = (*_XsStream[_XsTypeOfStream[fd]].WriteToStream)(fd, buf, size);
+
+	if (size > MAX_WORKAREA)
+		free (buf);
+
+	return (rc);
+}
+
+
+
+#endif /* STREAMSCONN */
+#endif /* NEEDFORNX */
diff --git a/nx-X11/lib/dps/cslibint.h b/nx-X11/lib/dps/cslibint.h
new file mode 100644
index 000000000..b16770504
--- /dev/null
+++ b/nx-X11/lib/dps/cslibint.h
@@ -0,0 +1,302 @@
+/*
+ * cslibint.h -- low level I/O
+ *
+ * (c) Copyright 1993-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
+ * 
+ * Portions Copyright 1984, 1985, 1987, 1989  Massachusetts Institute of
+ * Technology
+ * 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 name of M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *  
+ * Author:  Adobe Systems Incorporated and MIT X Consortium
+ */
+/* $XFree86: xc/lib/dps/cslibint.h,v 1.3 2001/06/30 22:41:44 tsi Exp $ */
+ 
+/*
+ *	XlibInternal.h - Header definition and support file for the internal
+ *	support routines (XlibInternal) used by the C subroutine interface
+ *	library (Xlib) to the X Window System.
+ *
+ *	Warning, there be dragons here....
+ */
+
+#ifndef _CSLIBINT_H
+#define _CSLIBINT_H
+
+#include <X11/Xlibint.h>
+#include <X11/Xutil.h>
+
+/* For SYSV, no gethostname, so fake it */
+#include <sys/param.h>
+#if defined(__SCO__)
+/* SCO systems define MAXHOSTNAMELEN here */
+#include <sys/socket.h>
+#endif
+
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN 64
+#endif
+
+
+/* === MACROS === */
+
+/*
+ * GetReq - Get the next avilable X request packet in the buffer and
+ * return it. 
+ *
+ * "name" is the name of the request, e.g. CreatePixmap, OpenFont, etc.
+ * "req" is the name of the request pointer.
+ *
+ */
+
+#if !defined(UNIXCPP)
+#define NXMacroGetReq(name, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
+	    {if (dpy != xdpy) N_XFlush(dpy); else _XFlush(dpy);}\
+	req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
+	req->reqType = X_##name;\
+	req->length = (SIZEOF(x##name##Req))>>2;\
+	dpy->bufptr += SIZEOF(x##name##Req);\
+	dpy->request++
+
+#else  /* non-ANSI C uses empty comment instead of "##" for token concatenation */
+#define NXMacroGetReq(name, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(x/**/name/**/Req)) > dpy->bufmax)\
+	    {if (dpy != xdpy) N_XFlush(dpy); else _XFlush(dpy);}\
+	req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
+	req->reqType = X_/**/name;\
+	req->length = (SIZEOF(x/**/name/**/Req))>>2;\
+	dpy->bufptr += SIZEOF(x/**/name/**/Req);\
+	dpy->request++
+#endif
+
+#ifdef NEEDFORNX
+
+/* GetReqExtra is the same as GetReq, but allocates "n" additional
+   bytes after the request. "n" must be a multiple of 4!  */
+
+#if !defined(UNIXCPP)
+#define GetReqExtra(name, n, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(x##name##Req) + n) > dpy->bufmax)\
+		_XFlush(dpy);\
+	req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
+	req->reqType = X_##name;\
+	req->length = (SIZEOF(x##name##Req) + n)>>2;\
+	dpy->bufptr += SIZEOF(x##name##Req) + n;\
+	dpy->request++
+#else
+#define GetReqExtra(name, n, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(x/**/name/**/Req) + n) > dpy->bufmax)\
+		_XFlush(dpy);\
+	req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
+	req->reqType = X_/**/name;\
+	req->length = (SIZEOF(x/**/name/**/Req) + n)>>2;\
+	dpy->bufptr += SIZEOF(x/**/name/**/Req) + n;\
+	dpy->request++
+#endif
+
+
+/*
+ * GetResReq is for those requests that have a resource ID 
+ * (Window, Pixmap, GContext, etc.) as their single argument.
+ * "rid" is the name of the resource. 
+ */
+
+#if !defined(UNIXCPP)
+#define GetResReq(name, rid, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(xResourceReq)) > dpy->bufmax)\
+	    _XFlush(dpy);\
+	req = (xResourceReq *) (dpy->last_req = dpy->bufptr);\
+	req->reqType = X_##name;\
+	req->length = 2;\
+	req->id = (rid);\
+	dpy->bufptr += SIZEOF(xResourceReq);\
+	dpy->request++
+#else
+#define GetResReq(name, rid, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(xResourceReq)) > dpy->bufmax)\
+	    _XFlush(dpy);\
+	req = (xResourceReq *) (dpy->last_req = dpy->bufptr);\
+	req->reqType = X_/**/name;\
+	req->length = 2;\
+	req->id = (rid);\
+	dpy->bufptr += SIZEOF(xResourceReq);\
+	dpy->request++
+#endif
+
+/*
+ * GetEmptyReq is for those requests that have no arguments
+ * at all. 
+ */
+#if !defined(UNIXCPP)
+#define GetEmptyReq(name, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(xReq)) > dpy->bufmax)\
+	    _XFlush(dpy);\
+	req = (xReq *) (dpy->last_req = dpy->bufptr);\
+	req->reqType = X_##name;\
+	req->length = 1;\
+	dpy->bufptr += SIZEOF(xReq);\
+	dpy->request++
+#else
+#define GetEmptyReq(name, req) \
+        WORD64ALIGN\
+	if ((dpy->bufptr + SIZEOF(xReq)) > dpy->bufmax)\
+	    _XFlush(dpy);\
+	req = (xReq *) (dpy->last_req = dpy->bufptr);\
+	req->reqType = X_/**/name;\
+	req->length = 1;\
+	dpy->bufptr += SIZEOF(xReq);\
+	dpy->request++
+#endif
+
+
+#define SyncHandle() \
+	if (dpy->synchandler) (*dpy->synchandler)(dpy)
+
+#define FlushGC(dpy, gc) \
+	if ((gc)->dirty) _XFlushGCCache((dpy), (gc))
+/*
+ * Data - Place data in the buffer and pad the end to provide
+ * 32 bit word alignment.  Transmit if the buffer fills.
+ *
+ * "dpy" is a pointer to a Display.
+ * "data" is a pinter to a data buffer.
+ * "len" is the length of the data buffer.
+ * we can presume buffer less than 2^16 bytes, so bcopy can be used safely.
+ */
+#ifndef DataRoutineIsProcedure
+#define Data(dpy, data, len) \
+	if (dpy->bufptr + (len) <= dpy->bufmax) {\
+		bcopy(data, dpy->bufptr, (int)len);\
+		dpy->bufptr += ((len) + 3) & ~3;\
+	} else\
+		_XSend(dpy, data, len)
+#endif /* DataRoutineIsProcedure */
+
+
+/* Allocate bytes from the buffer.  No padding is done, so if
+ * the length is not a multiple of 4, the caller must be
+ * careful to leave the buffer aligned after sending the
+ * current request.
+ *
+ * "type" is the type of the pointer being assigned to.
+ * "ptr" is the pointer being assigned to.
+ * "n" is the number of bytes to allocate.
+ *
+ * Example: 
+ *    xTextElt *elt;
+ *    BufAlloc (xTextElt *, elt, nbytes)
+ */
+
+#define BufAlloc(type, ptr, n) \
+    if (dpy->bufptr + (n) > dpy->bufmax) \
+        _XFlush (dpy); \
+    ptr = (type) dpy->bufptr; \
+    dpy->bufptr += (n);
+
+/*
+ * provide emulation routines for smaller architectures
+ */
+#ifndef WORD64
+#define Data16(dpy, data, len) Data((dpy), (char *)(data), (len))
+#define Data32(dpy, data, len) Data((dpy), (char *)(data), (len))
+#define _XRead16Pad(dpy, data, len) _XReadPad((dpy), (char *)(data), (len))
+#define _XRead16(dpy, data, len) _XRead((dpy), (char *)(data), (len))
+#define _XRead32(dpy, data, len) _XRead((dpy), (char *)(data), (len))
+#endif /* not WORD64 */
+
+#define PackData16(dpy,data,len) Data16 (dpy, data, len)
+#define PackData32(dpy,data,len) Data32 (dpy, data, len)
+
+/* Xlib manual is bogus */
+#define PackData(dpy,data,len) PackData16 (dpy, data, len)
+
+
+
+#endif /* NEEDFORNX */
+
+#if !defined(STARTITERATE) && !defined(WORD64)
+
+#define STARTITERATE(tpvar,type,start,endcond,decr) \
+  for (tpvar = (type *) start; endcond; tpvar++, decr) {
+#define ENDITERATE }
+
+#endif /* STARTITERATE */
+
+
+#ifndef WORD64
+#undef Data32
+#define Data32(dpy, data, len) NXProcData((dpy), (char *)(data), (len))
+#endif /* not WORD64 */
+
+extern int gNXSyncGCMode;
+
+/* extension hooks */
+
+extern Bool N_XUnknownWireEvent(Display *, XEvent *, xEvent *);
+extern Status N_XReply(Display *, xReply *, int, Bool);
+extern Status N_XUnknownNativeEvent(Display *, XEvent *, xEvent *);
+extern int DPSCAPConnect( char *, char **, int *, int *, int *, char **);
+extern int N_XDisconnectDisplay(int);
+extern int N_XGetHostname (char *, int);
+extern int N_XRead(Display*, char *, long);
+extern void NXProcData (Display *, char *, long);
+extern void N_XFlush(Display *);
+extern void N_XReadPad(Display*, char *, long);
+extern void N_XSend(Display *, _Xconst char *, long);
+extern void N_XWaitForReadable(Display *);
+extern void N_XWaitForWritable(Display *);
+
+extern void XDPSGetDefaultColorMaps(
+    Display *dpy,
+    Screen *screen,
+    Drawable drawable,
+    XStandardColormap *colorCube,
+    XStandardColormap *grayRamp);
+
+#endif /* _CSLIBINT_H */
+
diff --git a/nx-X11/lib/dps/csopendi.c b/nx-X11/lib/dps/csopendi.c
new file mode 100644
index 000000000..c0eb1d373
--- /dev/null
+++ b/nx-X11/lib/dps/csopendi.c
@@ -0,0 +1,567 @@
+/*
+ * csopendi.c -- open connection to CSDPS agent
+ *
+ * (c) Copyright 1990-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
+ * 
+ * Portions Copyright    Massachusetts Institute of Technology    1985, 1986
+ * 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 name of M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *  
+ * Author:  Adobe Systems Incorporated and MIT X Consortium
+ */
+/* $XFree86$ */
+ 
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/param.h>		/* for MAXHOSTNAMELEN */
+#define NEED_EVENTS
+#include <X11/Xlibint.h>
+#include <X11/Xos.h>
+#include "cslibint.h"
+#ifdef XXX
+#include <X11/Xauth.h>
+#include <X11/Xatom.h>
+
+extern int _Xdebug;
+extern Display *_XHeadOfDisplayList;
+
+#ifndef lint
+static int lock;	/* get rid of ifdefs when locking implemented */
+#endif
+
+#endif /* XXX */
+
+#include <X11/X.h>
+#include <X11/Xproto.h>
+
+#include "DPSCAPClient.h"
+#include <DPS/dpsXclient.h>
+#include <DPS/dpsNXargs.h>
+#include "dpsassert.h"
+#include "dpsNXprops.h"
+#include "csfindNX.h"
+#include "csstartNX.h"
+
+#ifdef DPSLNKL
+#include "dpslnkl.inc"
+#endif /* DPSLNKL */
+
+
+/* +++ Someday make this common with XDPS.c version */
+#define DPY_NUMBER(dpy) ((dpy)->fd)
+
+static xReq _dummy_request = {
+	0, 0, 0
+};
+
+static void OutOfMemory (Display *);
+
+#ifdef XXX
+/*
+ * First, a routine for setting authorization data
+ */
+static int xauth_namelen = 0;
+static char *xauth_name = NULL;	 /* NULL means use default mechanism */
+static int xauth_datalen = 0;
+static char *xauth_data = NULL;	 /* NULL means get default data */
+
+void XSetAuthorization (char *name, int namelen, char *data, int datalen)
+{
+    char *tmpname, *tmpdata;
+
+    if (xauth_name) Xfree (xauth_name);	 /* free any existing data */
+    if (xauth_data) Xfree (xauth_data);
+
+    xauth_name = xauth_data = NULL;	/* mark it no longer valid */
+    xauth_namelen = xauth_datalen = 0;
+
+    if (namelen < 0) namelen = 0;	/* check for bogus inputs */
+    if (datalen < 0) datalen = 0;	/* maybe should return? */
+
+    if (namelen > 0)  {			/* try to allocate space */
+	tmpname = Xmalloc ((unsigned) namelen);
+	if (!tmpname) return;
+	bcopy (name, tmpname, namelen);
+    } else {
+	tmpname = NULL;
+    }
+
+    if (datalen > 0)  {
+	tmpdata = Xmalloc ((unsigned) datalen);
+	if (!tmpdata) {
+	    if (tmpname) (void) Xfree (tmpname);
+	    return;
+	}
+	bcopy (data, tmpdata, datalen);
+    } else {
+	tmpdata = NULL;
+    }
+
+    xauth_name = tmpname;		/* and store the suckers */
+    xauth_namelen = namelen;
+    xauth_data = tmpdata;
+    xauth_datalen = datalen;
+    return;
+}
+
+#endif /* XXX */
+
+/* 
+ * Connects to a server, creates a Display object and returns a pointer to
+ * the newly created Display back to the caller.
+ */
+XExtData * 
+DPSCAPOpenAgent(Display *dpy, char *trueDisplayName)
+{
+	register Display *agent;
+	char *agentHost = (char *)NULL;
+	register int i;
+	char display_name[256];	        /* pointer to display name */
+	char licMethBuf[256];
+	char *licMeth = licMethBuf;
+	char *fullname = NULL;
+	int idisplay;
+	char *server_addr = NULL;
+	int server_addrlen = 0;
+	int conn_family;
+	int transport, port;
+	XExtData *ext;
+	DPSCAPData my;
+	char hostname[MAXHOSTNAMELEN];
+
+/*
+ * Find an agent to talk to.
+ */
+#ifdef DPSLNKL
+	extern unsigned ANXPFunc();
+#ifdef PSUSEPN
+	(void) sprintf(licMeth, "%s%s:%d",
+		       LICENSE_METHOD_PREFIX,
+		       ANXVENDOR, /* From dpslnkl.inc */
+		       ANXPFunc());
+#else /* PSUSEPN */
+	(void) sprintf(licMeth, "%s%s",
+                       LICENSE_METHOD_PREFIX,
+                       ANXVENDOR); /* From dpslnkl.inc */
+#endif /* PSUSEPN */	
+#else /* DPSLNKL */
+	licMeth = NULL;		/* We want an open service */
+#endif /* DPSLNKL */	
+	(void) N_XGetHostname(hostname, MAXHOSTNAMELEN);
+	switch(XDPSNXFindNX(dpy, licMeth, &agentHost, &transport, &port)) {
+	case findnx_not_found: {
+	    /* try to start-up an NX? */
+	    Bool autoLaunch;
+    
+	    XDPSGetNXArg(XDPSNX_AUTO_LAUNCH, (void **) &autoLaunch);
+	    if (autoLaunch == True) {
+	    int requestedTrans;
+	    int requestedPort = 0;
+	    char **args = NULL;
+	    char *additionalArgs[2];
+	    char transportArg[256];
+    
+	    (void) DPSWarnProc(NULL, "Auto-launching DPS NX agent.");
+	    XDPSGetNXArg(XDPSNX_LAUNCHED_AGENT_TRANS, (void **) &requestedTrans);
+	    if (requestedTrans == XDPSNX_USE_BEST) {
+		XDPSNXSetClientArg(XDPSNX_LAUNCHED_AGENT_TRANS,
+			    (void *)XDPSNX_TRANS_UNIX);
+		requestedTrans = XDPSNX_TRANS_UNIX;
+	    }
+	    /* cons-up an arg. to pass to Agent we are forking */
+    
+	    additionalArgs[1] = (char *) NULL;
+	    additionalArgs[0] = transportArg;
+	    XDPSGetNXArg(XDPSNX_LAUNCHED_AGENT_PORT, (void **) &requestedPort);
+	    if (requestedPort == XDPSNX_USE_BEST) {
+		requestedPort = XDPSNXRecommendPort(requestedTrans);
+		if (requestedPort < 0) {
+		DPSWarnProc(NULL, "Auto-launcher can't get a port.");
+		return(NULL);
+		}
+	    }
+	    (void) sprintf(transportArg, "%s/%d",
+			    (requestedTrans == XDPSNX_TRANS_DECNET ?
+			    "dec" : "tcp"),
+			    requestedPort);
+	    args = additionalArgs;
+	    /* ASSERT: first argument in additionalArgs must be
+		transport/port, unless agent changes to take this
+		anywhere */
+	    if (StartXDPSNX(args) != Success) {
+	        char tb[256], *fs, **as;
+                (void) XDPSGetNXArg(XDPSNX_EXEC_FILE, (void **) &fs);
+                (void) XDPSGetNXArg(XDPSNX_EXEC_ARGS, (void **) &as);
+		(void) sprintf(tb, "FAILED to auto-launch:\n    %s", fs);
+		if (as != NULL)
+		    for (; *as != NULL; as++) {
+		        if ((int) (strlen(*as) + 1 + (i = strlen(tb))) > 256-1) {
+			    if (i > 256-1-4)
+			        strcpy(&(tb[256-1-1-4]), " ...");
+			    else
+			        strcat(tb, " ...");
+			    break;
+			}
+			(void) strcat(tb, " ");
+		        (void) strcat(tb, *as);
+		    }
+	        DPSWarnProc(NULL, tb);
+		return(NULL);
+	    } else {
+		(void) sprintf(display_name, "%s%s%d", hostname,
+				(requestedTrans == XDPSNX_TRANS_DECNET ?
+				"::" : ":"),
+				requestedPort);
+	    }
+	    } else {		/* autoLaunch != True */
+	    return(NULL);
+	    }
+	  }
+          break;
+	case findnx_found: {	/* XDPSNXFindNX() == Success */
+	    (void) sprintf(display_name, "%s%s%d",
+			 (transport == XDPSNX_TRANS_UNIX ?
+			  "unix" : agentHost),
+			 (transport == XDPSNX_TRANS_DECNET ? "::" : ":"),
+			 port);
+	    /* Free agentHost later */
+	  }
+          break;
+	case findnx_error:
+          return(NULL);
+	  break;
+	default:
+          DPSFatalProc(NULL, "Illegal value returned by XDPSNXFindNX");
+	  break;
+      }
+
+
+/*
+ * Attempt to allocate a display structure. Return NULL if allocation fails.
+ */
+	if ((agent = (Display *)Xcalloc(1, sizeof(Display))) == NULL) {
+		return(NULL);
+	}
+
+/*
+ * Call the Connect routine to get the network socket. If -1 is returned, the
+ * connection failed. The connect routine will set fullname to point to the
+ * expanded name.
+ */
+
+	if ((agent->fd = DPSCAPConnect(display_name, &fullname, &idisplay,
+					 &conn_family,
+					 &server_addrlen, &server_addr)) < 0) {
+		Xfree ((char *) agent);
+		return(NULL);
+	}
+#ifdef XXX
+/*
+ * Look up the authorization protocol name and data if necessary.
+ */
+	if (xauth_name && xauth_data) {
+	    conn_auth_namelen = xauth_namelen;
+	    conn_auth_name = xauth_name;
+	    conn_auth_datalen = xauth_datalen;
+	    conn_auth_data = xauth_data;
+	} else {
+	    char dpynumbuf[40];		/* big enough to hold 2^64 and more */
+	    (void) sprintf (dpynumbuf, "%d", idisplay);
+
+	    authptr = XauGetAuthByAddr ((unsigned short) conn_family,
+					(unsigned short) server_addrlen,
+					server_addr,
+					(unsigned short) strlen (dpynumbuf),
+					dpynumbuf,
+					(unsigned short) xauth_namelen,
+					xauth_name);
+	    if (authptr) {
+		conn_auth_namelen = authptr->name_length;
+		conn_auth_name = (char *)authptr->name;
+		conn_auth_datalen = authptr->data_length;
+		conn_auth_data = (char *)authptr->data;
+	    } else {
+		conn_auth_namelen = 0;
+		conn_auth_name = NULL;
+		conn_auth_datalen = 0;
+		conn_auth_data = NULL;
+	    }
+	}
+#ifdef HASDES
+	/*
+	 * build XDM-AUTHORIZATION-1 data
+	 */
+	if (conn_auth_namelen == 19 &&
+	    !strncmp (conn_auth_name, "XDM-AUTHORIZATION-1", 19))
+	{
+	    static char    encrypted_data[192/8];
+	    int	    i, j;
+	    struct sockaddr_in	in_addr;
+	    int	    addrlen;
+	    long    now;
+
+	    j = 0;
+	    for (i = 0; i < 8; i++)
+	    {
+		encrypted_data[j] = conn_auth_data[i];
+		j++;
+	    }
+	    addrlen = sizeof (in_addr);
+	    getsockname (dpy->fd, (struct sockaddr *) &in_addr, &addrlen);
+	    if (in_addr.sin_family == 2)
+	    {
+		encrypted_data[j] = in_addr.sin_addr.s_net; j++;
+		encrypted_data[j] = in_addr.sin_addr.s_host; j++;
+		encrypted_data[j] = in_addr.sin_addr.s_lh; j++;
+		encrypted_data[j] = in_addr.sin_addr.s_impno; j++;
+		encrypted_data[j] = (in_addr.sin_port >> 8) & 0xff; j++;
+		encrypted_data[j] = (in_addr.sin_port) & 0xff; j++;
+	    }
+	    else
+	    {
+		encrypted_data[j] = 0xff; j++;
+		encrypted_data[j] = 0xff; j++;
+		encrypted_data[j] = 0xff; j++;
+		encrypted_data[j] = 0xff; j++;
+		i = getpid ();
+		encrypted_data[j] = (i >> 8) & 0xff; j++;
+		encrypted_data[j] = (i) & 0xff; j++;
+	    }
+	    time (&now);
+	    for (i = 3; i >= 0; i--)
+	    {
+		encrypted_data[j] = (now >> (i * 8)) & 0xff;
+		j++;
+	    }
+	    XdmcpEncrypt (encrypted_data, conn_auth_data + 8,
+			  encrypted_data, 192/8);
+	    conn_auth_data = encrypted_data;
+	    conn_auth_datalen = 192 / 8;
+	}
+#endif /* HASDES */
+	if (server_addr) (void) Xfree (server_addr);
+
+#endif /* XXX */
+
+/*
+ * We succeeded at authorization, so let us move the data into
+ * the display structure.
+ */
+	agent->lock_meaning	= NoSymbol;
+#ifdef XXX
+	/* this field is not present in post X11R5 */	
+	agent->current		= None;
+#endif	
+	agent->event_vec[X_Error] = N_XUnknownWireEvent;
+	agent->event_vec[X_Reply] = N_XUnknownWireEvent;
+	agent->wire_vec[X_Error]  = N_XUnknownNativeEvent;
+	agent->wire_vec[X_Reply]  = N_XUnknownNativeEvent;
+	for (i = KeyPress; i < 128; i++) {
+	    agent->event_vec[i] = N_XUnknownWireEvent;
+	    agent->wire_vec[i] 	= N_XUnknownNativeEvent;
+	}
+	agent->cursor_font	= None;
+	agent->last_req = (char *)&_dummy_request;
+
+	/* Salt away the host:display string for later use.
+	   Storage owned by agent, Xmalloc'd by connection
+	   call above */
+	agent->display_name = fullname;
+ 
+	/* Set up the output buffers. */
+	if ((agent->bufptr = agent->buffer = Xmalloc(BUFSIZE)) == NULL) {
+	        OutOfMemory (dpy);
+		return(NULL);
+	}
+	agent->bufmax = agent->buffer + BUFSIZE;
+
+
+    /* Create extension data */
+
+    my = DPSCAPCreate(dpy, agent);
+    if (my == (DPSCAPData)NULL)
+        {
+        OutOfMemory(agent);
+        return(NULL);
+        }
+    ext = (XExtData *)Xcalloc(1, sizeof(XExtData));
+    ext->private_data = (char *)my;
+    
+    /* Parse names to get true display name */
+    if (agentHost && strcmp(hostname, agentHost))
+        {
+	register char *s, *p;
+	char *dxname;
+	char nametmp[MAXHOSTNAMELEN];
+	/* Agent is not on the same host as client, so fix
+	   up the stupid abbreviations used for the display,
+	   and whoever came up with the syntax should be shot. */
+	dxname = DisplayString(dpy);
+	for (s = dxname, p = nametmp; *s; ++s)
+	    if (*s == ':')
+	       break;
+	    else
+	       *p++ = *s;
+	*p = '\0';
+	if (nametmp[0] == '\0' 
+	  || !strcmp(nametmp, "unix") 
+	  || !strcmp(nametmp, "localhost"))
+	    {
+	    strcpy(trueDisplayName, hostname);
+	    if (*s)
+	        strcat(trueDisplayName, s);
+	    else
+	        strcat(trueDisplayName, ":0.0");
+	    }
+	else
+	    strcpy(trueDisplayName, dxname);
+	}
+    else
+        strcpy(trueDisplayName, DisplayString(dpy));
+    if (agentHost)
+        Xfree(agentHost);
+    return(ext);
+}
+
+
+/* OutOfMemory is called if malloc fails.  XOpenDisplay returns NULL
+   after this returns. */
+
+static void OutOfMemory (Display *dpy)
+{
+    DPSCAPCloseAgent(dpy);
+}
+
+#ifdef NEEDFORNX
+/* XFreeDisplayStructure frees all the storage associated with a 
+ * Display.  It is used by XOpenDisplay if it runs out of memory,
+ * and also by XCloseDisplay.   It needs to check whether all pointers
+ * are non-NULL before dereferencing them, since it may be called
+ * by XOpenDisplay before the Display structure is fully formed.
+ * XOpenDisplay must be sure to initialize all the pointers to NULL
+ * before the first possible call on this.
+ */
+
+static void
+_XFreeDisplayStructure(register Display *dpy)
+{
+	if (dpy->screens) {
+	    register int i;
+
+            for (i = 0; i < dpy->nscreens; i++) {
+		Screen *sp = &dpy->screens[i];
+
+		if (sp->depths) {
+		   register int j;
+
+		   for (j = 0; j < sp->ndepths; j++) {
+			Depth *dp = &sp->depths[j];
+
+			if (dp->visuals) {
+			   register int k;
+
+			   for (k = 0; k < dp->nvisuals; k++)
+			     _XFreeExtData (dp->visuals[k].ext_data);
+			   Xfree ((char *) dp->visuals);
+			   }
+			}
+
+		   Xfree ((char *) sp->depths);
+		   }
+
+		_XFreeExtData (sp->ext_data);
+		}
+
+	    Xfree ((char *)dpy->screens);
+	    }
+	
+	if (dpy->pixmap_format) {
+	    register int i;
+
+	    for (i = 0; i < dpy->nformats; i++)
+	      _XFreeExtData (dpy->pixmap_format[i].ext_data);
+            Xfree ((char *)dpy->pixmap_format);
+	    }
+
+	if (dpy->display_name)
+	   Xfree (dpy->display_name);
+	if (dpy->vendor)
+	   Xfree (dpy->vendor);
+
+        if (dpy->buffer)
+	   Xfree (dpy->buffer);
+	if (dpy->atoms)
+	   Xfree ((char *) dpy->atoms);
+	if (dpy->keysyms)
+	   Xfree ((char *) dpy->keysyms);
+	if (dpy->modifiermap)
+	   XFreeModifiermap(dpy->modifiermap);
+	if (dpy->xdefaults)
+	   Xfree (dpy->xdefaults);
+	if (dpy->key_bindings)
+	   _XFreeKeyBindings(dpy);
+
+	while (dpy->ext_procs) {
+	    _XExtension *ext = dpy->ext_procs;
+	    dpy->ext_procs = ext->next;
+	    if (ext->name)
+		Xfree (ext->name);
+	    Xfree ((char *)ext);
+	}
+
+	_XFreeExtData (dpy->ext_data);
+        
+	Xfree ((char *)dpy);
+}
+#endif /* NEEDFORNX */
+
+
+
+void
+DPSCAPCloseAgent(Display *agent)
+{
+    if (!agent) return;
+    N_XDisconnectDisplay(agent->fd);
+    if (agent->display_name)
+        Xfree(agent->display_name);
+    if (agent->buffer)
+        Xfree(agent->buffer);
+    Xfree((char *)agent);
+}
diff --git a/nx-X11/lib/dps/csstartNX.c b/nx-X11/lib/dps/csstartNX.c
new file mode 100644
index 000000000..0db2cbe5b
--- /dev/null
+++ b/nx-X11/lib/dps/csstartNX.c
@@ -0,0 +1,237 @@
+/*
+  csstartNX.c
+
+ * (c) Copyright 1992-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: xc/lib/dps/csstartNX.c,v 1.6 2001/10/28 03:32:43 tsi Exp $ */
+
+#include <sys/param.h>
+#include <X11/X.h>
+#include <X11/Xlibint.h>
+#include <sys/wait.h>
+#include <DPS/dpsNXargs.h>
+#include <sys/socket.h>
+#include <errno.h>
+#include <X11/Xos.h>
+
+#include "DPSCAPproto.h"
+#include "Xlibnet.h"            /* New for R5, delete for R4 */
+#include "dpsassert.h"
+#include "csfindNX.h"
+#include "csstartNX.h"
+
+/* ---Defines--- */
+
+#include <stddef.h>
+  
+#define DOZETIME 1              /* time to wait for agent to start up (sec) */
+
+#define BASE_TCP_PORT CSDPSPORT
+
+#ifndef CSDPSMAXPORT
+#define CSDPSMAXPORT 16
+#endif
+
+#ifndef SO_REUSEADDR
+#define SO_REUSEADDR 1
+#endif
+
+/* ---Globals--- */
+
+pid_t gSecretAgentPID = 0;	/* PID of launched agent *Shh!* Not public! */
+
+/* ---Private Functions--- */
+
+static int
+TryTCP(void)
+{
+    struct sockaddr_in insock;
+    int request;
+    unsigned short port, startPort = 0;
+    struct servent *serventInfo;
+    int okay;
+
+#ifndef ultrix
+    /* Ultrix has a nasty bug in getservbyname().  If the name passed
+       to it doesn't exist in the services list it will seg. fault...
+       * sigh *  */
+    if ((serventInfo = getservbyname(DPS_NX_SERV_NAME,
+    					(char *) 0)) != 0)
+        if (strcmp("tcp", serventInfo->s_proto) == 0) {
+	  startPort = ntohs(serventInfo->s_port);
+	}
+    /* So, for Ultrix we just default to the default default port :-) */ 
+#endif /* ultrix */
+    if (startPort == 0) startPort = BASE_TCP_PORT;
+    if ((request = socket (AF_INET, SOCK_STREAM, 0)) < 0) 
+    {
+	DPSWarnProc(NULL, "Creating TCP socket while recommending port\n");
+	return -1;
+    } 
+#ifdef SO_REUSEADDR
+    /* Necesary to restart the server without a reboot */
+    {
+	int one = 1;
+	setsockopt(request, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(int));
+    }
+    /* What the hell is all this?  I'll tell you.  We don't know
+       a prioi what port is free, so we try to bind to each
+       in sequence and return the one that works. */
+#if !defined(AIXV3)
+    {
+      struct linger lingere;
+      
+      lingere.l_onoff = 0;		/* off */
+      lingere.l_linger = 0;		/* don't */
+      if(setsockopt(request, SOL_SOCKET, SO_LINGER, (char *)&lingere,
+        sizeof(struct linger)) != 0)
+      DPSWarnProc(NULL,
+		  "Couldn't set TCP SO_DONTLINGER while recommending port.");
+    }
+#endif /* AIXV3 */
+#endif /* SO_REUSEADDR */
+    bzero((char *)&insock, sizeof (insock));
+    insock.sin_family = AF_INET;
+    insock.sin_addr.s_addr = htonl(INADDR_ANY);
+    okay = 0;
+    
+    for (port = startPort; (int) port < (int) startPort + CSDPSMAXPORT; port++)
+    {
+    int result;
+    insock.sin_port = htons(port);
+    
+    errno = 0;
+    result = bind(request, (struct sockaddr *) &insock, sizeof (insock));
+    if (result < 0)
+        {
+	if (errno != EADDRINUSE)
+	    {
+	    DPSWarnProc(NULL, "Binding TCP socket while recommending port.\n");
+	    close(request);
+	    return -1;
+	    }
+	continue;
+	}
+    else
+        {
+        /* We have a good port number */
+        okay = 1;
+	break;
+	}
+    }
+    close(request);
+    return (okay) ? port : -1;
+}
+
+/* ---Functions--- */
+
+int
+XDPSNXRecommendPort(int transport)
+{
+    int ret;
+    
+    switch (transport)
+        {
+	case XDPSNX_TRANS_UNIX:
+	    /* If the TCP socket exists, we just assume the UNIX one
+	       is there too.  FALL THRU! */
+	case XDPSNX_TRANS_TCP: /* TCP */
+	    ret = TryTCP();
+	    break;
+	default: ret = -1;
+	}
+    return(ret);
+}
+
+int
+StartXDPSNX(char **additionalArgs)
+{
+  char **args, **cpp;
+  pid_t childPid;
+  int argc = 1;			/* 1, args[0]:=path, args[1]:=null */
+  int i = 0;
+  int status = Success;		/* assume we'll succeed */
+  char *execObj, **execArgs;
+
+  (void) XDPSGetNXArg(XDPSNX_EXEC_FILE, (void **) &execObj);
+  if (execObj == 0) return (!Success);
+
+  /* Create the argv list for the execl() call */
+  (void) XDPSGetNXArg(XDPSNX_EXEC_ARGS, (void **) &execArgs);
+  if (execArgs != 0)
+    for(cpp = execArgs; *cpp != 0; cpp++, argc++); /* count args. */
+  if (additionalArgs != 0)	/* add on the add-on args. */
+    for(cpp = additionalArgs; *cpp != 0; cpp++, argc++); 
+
+  args = (char **) Xmalloc(sizeof(char *) * (argc+1));
+  if (args == 0)
+    return(!Success);
+  args[argc] = 0;		/* cap end of args */
+  args[i++] = execObj;
+  if (additionalArgs != 0)
+    for(cpp = additionalArgs; *cpp != 0; cpp++, i++) args[i] = *cpp;
+  if (execArgs != 0)
+    for(cpp = execArgs; *cpp != 0; cpp++, i++) args[i] = *cpp;
+
+  /* now try to start up the agent... */
+  if ((childPid = fork()) != -1) {
+    if (childPid == 0) {	/* Child process */
+#ifndef __UNIXOS2__
+      if (setsid() < 0)
+        DPSWarnProc(NULL, "Agent unable to create session.  Continuing...\n");
+#endif
+
+      /* Try to start the agent */
+      if (execvp(args[0], args) < 0) { /* Error!! */
+	exit(1);		/* This is OKAY, we're the child here */
+      }
+      /* SHOULD NEVER REACH HERE */
+    } else {			/* Parent (NX Client) */
+      (void) sleep(DOZETIME);
+      /* if decmips, pray that we hesitate long enough for the child... */
+      /* Check on child (NX Agent) */
+      if (waitpid(childPid, NULL, WNOHANG) != 0) {
+	/* Server terminated or stopped; don't care, result is same... */
+	status = !Success;
+      } else {			/* we think the agent started okay */
+	gSecretAgentPID = childPid; /* set secret global */
+      }
+    }
+  } else {			/* Error in fork */
+    status = !Success;
+  }
+  if (args != 0) (void) XFree(args);
+  return(status);
+}
diff --git a/nx-X11/lib/dps/csstartNX.h b/nx-X11/lib/dps/csstartNX.h
new file mode 100644
index 000000000..5e80e60aa
--- /dev/null
+++ b/nx-X11/lib/dps/csstartNX.h
@@ -0,0 +1,67 @@
+/*
+ * csstartNX.h     -- handles fork()/execl() for starting  DPSNX from dps lib
+ *
+ * (c) Copyright 1992-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
+ */
+
+#ifndef CSSTARTNX_H
+#define CSSTARTNX_H
+
+#include <X11/Xlib.h>
+
+/* ---Globals--- */
+
+extern Bool gStartXDPSNXIsPresent;
+        /*
+	 * Indicates whether the function "StartXDPSNX" is live or just
+	 * a stubbed out version.
+	 */
+
+/* ---Functions--- */
+
+extern int StartXDPSNX (char **additionalArgs);
+     /*
+      * StartXDPSNX attempts to fork and exec the object file specified by
+      * the DPSSetNXArg argument "DPSNXEXEC".  It passes as arguments to the
+      * object file the DPSSetNXArg argument "DPSNXEXECARGS" with the
+      * additionalArgs (if there are any) appended.
+      * RETURNS:
+      *   StartXDPSNX will return Success if it believes that the child has
+      * started correctly.  Otherwise it returns !Success
+      */
+
+extern int XDPSNXRecommendPort(int transport);
+
+#endif	/* CSSTARTNX_H */
diff --git a/nx-X11/lib/dps/dps-def.cpp b/nx-X11/lib/dps/dps-def.cpp
new file mode 100644
index 000000000..d88841d66
--- /dev/null
+++ b/nx-X11/lib/dps/dps-def.cpp
@@ -0,0 +1,991 @@
+LIBRARY Dps
+VERSION LIBRARY_VERSION
+EXPORTS
+DPSAddContextExtensionRec
+DPSAwaitReturnValues
+DPSBinObjSeqWrite
+DPSChainContext
+DPSCheckInitClientGlobals
+DPSCheckRaiseError
+DPSCreateContext
+DPSCreateTextContext
+DPSDefaultErrorProc
+DPSDestroyContext
+DPSDestroySpace
+DPSFlushContext
+DPSGenerateExtensionRecID
+DPSGetContextExtensionRec
+DPSGetContextType
+DPSGetCurrentContext
+DPSGetCurrentErrorBackstop
+DPSGetCurrentTextBackstop
+DPSInitCommonContextProcs
+DPSInitCommonSpaceProcs
+DPSInitCommonTextContextProcs
+DPSInitialize
+DPSInterruptContext
+DPSKnownContext
+DPSKnownSpace
+DPSMapNames
+DPSNameFromIndex
+DPSPrivCurrentContext
+DPSRemoveContextExtensionRec
+DPSResetContext
+DPSSafeSetLastNameIndex
+DPSSetAbbrevMode
+DPSSetContext
+DPSSetErrorBackstop
+DPSSetNumStringConversion
+DPSSetResultTable
+DPSSetTextBackstop
+DPSSetWh
+DPSSetWrapSynchronization
+DPSSuppressBinaryConversion
+DPSUnchainContext
+DPSUpdateNameMap
+DPSWaitContext
+DPSWriteData
+DPSWriteNumString
+DPSWritePostScript
+DPSWriteStringChars
+DPSWriteTypedObjectArray
+DPScalloc
+DPSclientPrintProc
+DPSPrintf
+DPSRaise
+DPSCreatePSWDict
+DPSDestroyPSWDict
+DPSMakeAtom
+DPSWDictEnter
+DPSWDictLookup
+DPSWDictRemove
+DPSFetchAbbrevList
+DPSGetOperatorAbbrev
+DPSGetSysnameAbbrev
+DPSCantHappen
+DPSChangeEncoding
+DPSCheckShared
+DPSContextFromContextID
+DPSDefaultPrivateHandler
+DPSFatalProc
+DPSHandleBogusError
+DPSInitPrivateContextFields
+DPSInitPrivateContextProcs
+DPSInitPrivateSpaceFields
+DPSInitPrivateTextContextFields
+DPSNewUserObjectIndex
+DPSPrivateCheckWait
+DPSPrivateDestroyContext
+DPSPrivateDestroySpace
+DPSServicePostScript
+DPSWarnProc
+DPSinnerProcWriteData
+XDPSContextFromSharedID
+XDPSContextFromXID
+XDPSCreateContext
+XDPSCreateSecureContext
+XDPSCreateSimpleContext
+XDPSDispatchEvent
+XDPSFindContext
+XDPSGetContextStatus
+XDPSGetProtocolVersion
+XDPSIsDPSEvent
+XDPSIsOutputEvent
+XDPSIsReadyEvent
+XDPSIsStatusEvent
+XDPSNotifyWhenReady
+XDPSReadyEventHandler
+XDPSRegisterReadyProc
+XDPSRegisterStatusProc
+XDPSSetEventDelivery
+XDPSSetProcs
+XDPSSetStatusMask
+XDPSSpaceFromSharedID
+XDPSSpaceFromXID
+XDPSStatusEventHandler
+XDPSUnfreezeContext
+XDPSXIDFromContext
+XDPSXIDFromSpace
+DPSInitSysNames
+DPSCreatePrivContext
+DPSDefaultTextBackstop
+DPSIncludePrivContext
+DPSInitClient
+DPSOutOfMemory
+DPSSendDestroySpace
+DPSSendEOF
+DPSSendInterrupt
+DPSSendPostScript
+DPSSendTerminate
+XDPSCreatePrivContextRec
+XDPSForceEvents
+XDPSNumFormat
+XDPSPrivZapDpy
+XDPSSendUnfreeze
+XDPSSetContextEncoding
+XDPSLCAPNotify
+XDPSLCallOutputEventHandler
+XDPSLCallReadyEventHandler
+XDPSLCallStatusEventHandler
+XDPSLCleanAll
+XDPSLCleanContext
+XDPSLContextFromXID
+XDPSLCreateContext
+XDPSLCreateContextAndSpace
+XDPSLCreateContextFromID
+XDPSLCreateSpace
+XDPSLDestroySpace
+XDPSLDispatchCSDPSFakeEvent
+XDPSLFlush
+XDPSLFlushGC
+XDPSLGetCSDPSFakeEventType
+XDPSLGetCSDPSReady
+XDPSLGetCSDPSStatus
+XDPSLGetCodes
+XDPSLGetGCFlushMode
+XDPSLGetPassEventsFlag
+XDPSLGetShunt
+XDPSLGetStatus
+XDPSLGetSyncMask
+XDPSLGetVersion
+XDPSLGetWrapWaitingFlag
+XDPSLGiveInput
+XDPSLIDFromContext
+XDPSLInit
+XDPSLInitDisplayFlags
+XDPSLNotifyContext
+XDPSLNotifyWhenReady
+XDPSLReconcileRequests
+XDPSLReset
+XDPSLSetAfterProc
+XDPSLSetAgentArg
+XDPSLSetAgentName
+XDPSLSetClientMessageHandler
+XDPSLSetCodes
+XDPSLSetGCFlushMode
+XDPSLSetPassEventsFlag
+XDPSLSetReadyEventHandler
+XDPSLSetShunt
+XDPSLSetStatusEventHandler
+XDPSLSetStatusMask
+XDPSLSetSyncMask
+XDPSLSetTextEventHandler
+XDPSLSetVersion
+XDPSLSetWrapWaitingFlag
+XDPSLSync
+XDPSLSyncGCClip
+XDPSLTestErrorCode
+XDPSLUpdateAgentArgs
+XDPSSetXtEventDispatching
+;XDPSCreateStandardColormaps
+XDPSGetDefaultColorMaps
+CSDPSHeadOfDpyExt
+CSDPSInit
+DPSCAPChangeGC
+DPSCAPCloseDisplayProc
+DPSCAPCopyGCProc
+DPSCAPCreate
+DPSCAPDestroy
+DPSCAPFlushGCProc
+DPSCAPFreeGCProc
+DPSCAPStartUp
+DPSCAPWrite
+XDPSFlushGC
+XDPSNXSetAgentArg
+XDPSReconcileRequests
+XDPSSyncGCClip
+DPSCAPCloseAgent
+DPSCAPOpenAgent
+DPSCAPConnect
+N_XDisconnectDisplay
+N_XWaitForReadable
+N_XWaitForWritable
+StartXDPSNX
+XDPSNXRecommendPort
+XDPSGetNXArg
+XDPSNXFindNX
+XDPSNXSetClientArg
+NXProcData
+N_XANYSET
+N_XFlush
+N_XGetHostname
+N_XRead
+N_XReadPad
+N_XReply
+N_XSend
+N_XUnknownNativeEvent
+N_XUnknownWireEvent
+DPScolorimage
+DPScurrentblackgeneration
+DPScurrentcmykcolor
+DPScurrentcolorscreen
+DPScurrentcolortransfer
+DPScurrentundercolorremoval
+DPSsetblackgeneration
+DPSsetcmykcolor
+DPSsetcolorscreen
+DPSsetcolortransfer
+DPSsetundercolorremoval
+DPSeq
+DPSexit
+DPSfalse
+DPSfor
+DPSforall
+DPSge
+DPSgt
+DPSif
+DPSifelse
+DPSle
+DPSloop
+DPSlt
+DPSne
+DPSnot
+DPSor
+DPSrepeat
+DPSstop
+DPSstopped
+DPStrue
+DPSUserObjects
+DPScondition
+DPScurrentcontext
+DPScurrentobjectformat
+DPSdefineusername
+DPSdefineuserobject
+DPSdetach
+DPSexecuserobject
+DPSfork
+DPSjoin
+DPSlock
+DPSmonitor
+DPSnotify
+DPSsetobjectformat
+DPSsetvmthreshold
+DPSundefineuserobject
+DPSwait
+DPSyield
+DPSaload
+DPSanchorsearch
+DPSarray
+DPSastore
+DPSbegin
+DPSclear
+DPScleartomark
+DPScopy
+DPScount
+DPScounttomark
+DPScvi
+DPScvlit
+DPScvn
+DPScvr
+DPScvrs
+DPScvs
+DPScvx
+DPSdef
+DPSdict
+DPSdictstack
+DPSdup
+DPSend
+DPSexch
+DPSexecstack
+DPSexecuteonly
+DPSget
+DPSgetinterval
+DPSindex
+DPSknown
+DPSlength
+DPSload
+DPSmark
+DPSmatrix
+DPSmaxlength
+DPSnoaccess
+DPSnull
+DPSpackedarray
+DPSpop
+DPSput
+DPSputinterval
+DPSrcheck
+DPSreadonly
+DPSroll
+DPSscheck
+DPSsearch
+DPSshareddict
+DPSstatusdict
+DPSstore
+DPSstring
+DPSstringwidth
+DPSsystemdict
+DPSuserdict
+DPSwcheck
+DPSwhere
+DPSxcheck
+DPSFontDirectory
+DPSISOLatin1Encoding
+DPSSharedFontDirectory
+DPSStandardEncoding
+DPScachestatus
+DPScurrentcacheparams
+DPScurrentfont
+DPSdefinefont
+DPSfindfont
+DPSmakefont
+DPSscalefont
+DPSselectfont
+DPSsetcachedevice
+DPSsetcachelimit
+DPSsetcacheparams
+DPSsetcharwidth
+DPSsetfont
+DPSundefinefont
+DPSconcat
+DPScurrentdash
+DPScurrentflat
+DPScurrentgray
+DPScurrentgstate
+DPScurrenthalftone
+DPScurrenthalftonephase
+DPScurrenthsbcolor
+DPScurrentlinecap
+DPScurrentlinejoin
+DPScurrentlinewidth
+DPScurrentmatrix
+DPScurrentmiterlimit
+DPScurrentpoint
+DPScurrentrgbcolor
+DPScurrentscreen
+DPScurrentstrokeadjust
+DPScurrenttransfer
+DPSdefaultmatrix
+DPSgrestore
+DPSgrestoreall
+DPSgsave
+DPSgstate
+DPSinitgraphics
+DPSinitmatrix
+DPSrotate
+DPSscale
+DPSsetdash
+DPSsetflat
+DPSsetgray
+DPSsetgstate
+DPSsethalftone
+DPSsethalftonephase
+DPSsethsbcolor
+DPSsetlinecap
+DPSsetlinejoin
+DPSsetlinewidth
+DPSsetmatrix
+DPSsetmiterlimit
+DPSsetrgbcolor
+DPSsetscreen
+DPSsetstrokeadjust
+DPSsettransfer
+DPStranslate
+DPSbytesavailable
+DPSclosefile
+DPScurrentfile
+DPSdeletefile
+DPSecho
+DPSequals
+DPSequalsequals
+DPSfile
+DPSfilenameforall
+DPSfileposition
+DPSflush
+DPSflushfile
+DPSprint
+DPSprintobject
+DPSpstack
+DPSread
+DPSreadhexstring
+DPSreadline
+DPSreadstring
+DPSrenamefile
+DPSresetfile
+DPSsetfileposition
+DPSstack
+DPSstatus
+DPStoken
+DPSwrite
+DPSwritehexstring
+DPSwriteobject
+DPSwritestring
+DPSabs
+DPSadd
+DPSand
+DPSatan
+DPSbitshift
+DPSceiling
+DPScos
+DPSdiv
+DPSexp
+DPSfloor
+DPSidiv
+DPSln
+DPSlog
+DPSmod
+DPSmul
+DPSneg
+DPSround
+DPSsin
+DPSsqrt
+DPSsub
+DPStruncate
+DPSxor
+DPSconcatmatrix
+DPSdtransform
+DPSidentmatrix
+DPSidtransform
+DPSinvertmatrix
+DPSitransform
+DPStransform
+DPSbanddevice
+DPSframedevice
+DPSnulldevice
+DPSrenderbands
+DPSashow
+DPSawidthshow
+DPScopypage
+DPSeofill
+DPSerasepage
+DPSfill
+DPSimage
+DPSimagemask
+DPSkshow
+DPSrectfill
+DPSrectstroke
+DPSshow
+DPSshowpage
+DPSstroke
+DPSstrokepath
+DPSueofill
+DPSufill
+DPSustroke
+DPSustrokepath
+DPSwidthshow
+DPSxshow
+DPSxyshow
+DPSyshow
+DPSarc
+DPSarcn
+DPSarct
+DPSarcto
+DPScharpath
+DPSclip
+DPSclippath
+DPSclosepath
+DPScurveto
+DPSeoclip
+DPSeoviewclip
+DPSflattenpath
+DPSinitclip
+DPSinitviewclip
+DPSlineto
+DPSmoveto
+DPSnewpath
+DPSpathbbox
+DPSpathforall
+DPSrcurveto
+DPSrectclip
+DPSrectviewclip
+DPSreversepath
+DPSrlineto
+DPSrmoveto
+DPSsetbbox
+DPSsetucacheparams
+DPSuappend
+DPSucache
+DPSucachestatus
+DPSupath
+DPSviewclip
+DPSviewclippath
+DPSbind
+DPScleardictstack
+DPScountdictstack
+DPScountexecstack
+DPScurrentdict
+DPScurrentpacking
+DPScurrentshared
+DPSdeviceinfo
+DPSerrordict
+DPSexec
+DPSprompt
+DPSquit
+DPSrand
+DPSrealtime
+DPSrestore
+DPSrrand
+DPSrun
+DPSsave
+DPSsetpacking
+DPSsetshared
+DPSsrand
+DPSstart
+DPStype
+DPSundef
+DPSusertime
+DPSversion
+DPSvmreclaim
+DPSvmstatus
+DPSineofill
+DPSinfill
+DPSinstroke
+DPSinueofill
+DPSinufill
+DPSinustroke
+DPSwtranslation
+DPSgetboolean
+DPSgetchararray
+DPSgetfloat
+DPSgetfloatarray
+DPSgetint
+DPSgetintarray
+DPSgetstring
+DPSsendboolean
+DPSsendchararray
+DPSsendfloat
+DPSsendfloatarray
+DPSsendint
+DPSsendintarray
+DPSsendstring
+DPSclientXready
+DPSclientsync
+DPScurrentXdrawingfunction
+DPScurrentXgcdrawable
+DPScurrentXgcdrawablecolor
+DPScurrentXoffset
+DPSsetXdrawingfunction
+DPSsetXgcdrawable
+DPSsetXgcdrawablecolor
+DPSsetXoffset
+DPSsetXrgbactual
+DPSGlobalFontDirectory
+DPScshow
+DPScurrentcolor
+DPScurrentcolorrendering
+DPScurrentcolorspace
+DPScurrentdevparams
+DPScurrentglobal
+DPScurrentoverprint
+DPScurrentpagedevice
+DPScurrentsystemparams
+DPScurrentuserparams
+DPSdefineresource
+DPSexecform
+DPSfilter
+DPSfindencoding
+DPSfindresource
+DPSgcheck
+DPSglobaldict
+DPSglyphshow
+DPSlanguagelevel
+DPSleftbracket
+DPSleftleft
+DPSmakepattern
+DPSproduct
+DPSresourceforall
+DPSresourcestatus
+DPSrevision
+DPSrightbracket
+DPSrightright
+DPSrootfont
+DPSserialnumber
+DPSsetcolor
+DPSsetcolorrendering
+DPSsetcolorspace
+DPSsetdevparams
+DPSsetglobal
+DPSsetoverprint
+DPSsetpagedevice
+DPSsetpattern
+DPSsetsystemparams
+DPSsetuserparams
+DPSstartjob
+DPSundefineresource
+PScolorimage
+PScurrentblackgeneration
+PScurrentcmykcolor
+PScurrentcolorscreen
+PScurrentcolortransfer
+PScurrentundercolorremoval
+PSsetblackgeneration
+PSsetcmykcolor
+PSsetcolorscreen
+PSsetcolortransfer
+PSsetundercolorremoval
+PSeq
+PSexit
+PSfalse
+PSfor
+PSforall
+PSge
+PSgt
+PSif
+PSifelse
+PSle
+PSloop
+PSlt
+PSne
+PSnot
+PSor
+PSrepeat
+PSstop
+PSstopped
+PStrue
+PSUserObjects
+PScondition
+PScurrentcontext
+PScurrentobjectformat
+PSdefineusername
+PSdefineuserobject
+PSdetach
+PSexecuserobject
+PSfork
+PSjoin
+PSlock
+PSmonitor
+PSnotify
+PSsetobjectformat
+PSsetvmthreshold
+PSundefineuserobject
+PSwait
+PSyield
+PSaload
+PSanchorsearch
+PSarray
+PSastore
+PSbegin
+PSclear
+PScleartomark
+PScopy
+PScount
+PScounttomark
+PScvi
+PScvlit
+PScvn
+PScvr
+PScvrs
+PScvs
+PScvx
+PSdef
+PSdict
+PSdictstack
+PSdup
+PSend
+PSexch
+PSexecstack
+PSexecuteonly
+PSget
+PSgetinterval
+PSindex
+PSknown
+PSlength
+PSload
+PSmark
+PSmatrix
+PSmaxlength
+PSnoaccess
+PSnull
+PSpackedarray
+PSpop
+PSput
+PSputinterval
+PSrcheck
+PSreadonly
+PSroll
+PSscheck
+PSsearch
+PSshareddict
+PSstatusdict
+PSstore
+PSstring
+PSstringwidth
+PSsystemdict
+PSuserdict
+PSwcheck
+PSwhere
+PSxcheck
+PSFontDirectory
+PSISOLatin1Encoding
+PSSharedFontDirectory
+PSStandardEncoding
+PScachestatus
+PScurrentcacheparams
+PScurrentfont
+PSdefinefont
+PSfindfont
+PSmakefont
+PSscalefont
+PSselectfont
+PSsetcachedevice
+PSsetcachelimit
+PSsetcacheparams
+PSsetcharwidth
+PSsetfont
+PSundefinefont
+PSconcat
+PScurrentdash
+PScurrentflat
+PScurrentgray
+PScurrentgstate
+PScurrenthalftone
+PScurrenthalftonephase
+PScurrenthsbcolor
+PScurrentlinecap
+PScurrentlinejoin
+PScurrentlinewidth
+PScurrentmatrix
+PScurrentmiterlimit
+PScurrentpoint
+PScurrentrgbcolor
+PScurrentscreen
+PScurrentstrokeadjust
+PScurrenttransfer
+PSdefaultmatrix
+PSgrestore
+PSgrestoreall
+PSgsave
+PSgstate
+PSinitgraphics
+PSinitmatrix
+PSrotate
+PSscale
+PSsetdash
+PSsetflat
+PSsetgray
+PSsetgstate
+PSsethalftone
+PSsethalftonephase
+PSsethsbcolor
+PSsetlinecap
+PSsetlinejoin
+PSsetlinewidth
+PSsetmatrix
+PSsetmiterlimit
+PSsetrgbcolor
+PSsetscreen
+PSsetstrokeadjust
+PSsettransfer
+PStranslate
+PSbytesavailable
+PSclosefile
+PScurrentfile
+PSdeletefile
+PSecho
+PSequals
+PSequalsequals
+PSfile
+PSfilenameforall
+PSfileposition
+PSflush
+PSflushfile
+PSprint
+PSprintobject
+PSpstack
+PSread
+PSreadhexstring
+PSreadline
+PSreadstring
+PSrenamefile
+PSresetfile
+PSsetfileposition
+PSstack
+PSstatus
+PStoken
+PSwrite
+PSwritehexstring
+PSwriteobject
+PSwritestring
+PSabs
+PSadd
+PSand
+PSatan
+PSbitshift
+PSceiling
+PScos
+PSdiv
+PSexp
+PSfloor
+PSidiv
+PSln
+PSlog
+PSmod
+PSmul
+PSneg
+PSround
+PSsin
+PSsqrt
+PSsub
+PStruncate
+PSxor
+PSconcatmatrix
+PSdtransform
+PSidentmatrix
+PSidtransform
+PSinvertmatrix
+PSitransform
+PStransform
+PSbanddevice
+PSframedevice
+PSnulldevice
+PSrenderbands
+PSashow
+PSawidthshow
+PScopypage
+PSeofill
+PSerasepage
+PSfill
+PSimage
+PSimagemask
+PSkshow
+PSrectfill
+PSrectstroke
+PSshow
+PSshowpage
+PSstroke
+PSstrokepath
+PSueofill
+PSufill
+PSustroke
+PSustrokepath
+PSwidthshow
+PSxshow
+PSxyshow
+PSyshow
+PSarc
+PSarcn
+PSarct
+PSarcto
+PScharpath
+PSclip
+PSclippath
+PSclosepath
+PScurveto
+PSeoclip
+PSeoviewclip
+PSflattenpath
+PSinitclip
+PSinitviewclip
+PSlineto
+PSmoveto
+PSnewpath
+PSpathbbox
+PSpathforall
+PSrcurveto
+PSrectclip
+PSrectviewclip
+PSreversepath
+PSrlineto
+PSrmoveto
+PSsetbbox
+PSsetucacheparams
+PSuappend
+PSucache
+PSucachestatus
+PSupath
+PSviewclip
+PSviewclippath
+PSbind
+PScleardictstack
+PScountdictstack
+PScountexecstack
+PScurrentdict
+PScurrentpacking
+PScurrentshared
+PSdeviceinfo
+PSerrordict
+PSexec
+PSprompt
+PSquit
+PSrand
+PSrealtime
+PSrestore
+PSrrand
+PSrun
+PSsave
+PSsetpacking
+PSsetshared
+PSsrand
+PSstart
+PStype
+PSundef
+PSusertime
+PSversion
+PSvmreclaim
+PSvmstatus
+PSineofill
+PSinfill
+PSinstroke
+PSinueofill
+PSinufill
+PSinustroke
+PSwtranslation
+PSgetboolean
+PSgetchararray
+PSgetfloat
+PSgetfloatarray
+PSgetint
+PSgetintarray
+PSgetstring
+PSsendboolean
+PSsendchararray
+PSsendfloat
+PSsendfloatarray
+PSsendint
+PSsendintarray
+PSsendstring
+PSclientXready
+PSclientsync
+PScurrentXdrawingfunction
+PScurrentXgcdrawable
+PScurrentXgcdrawablecolor
+PScurrentXoffset
+PSsetXdrawingfunction
+PSsetXgcdrawable
+PSsetXgcdrawablecolor
+PSsetXoffset
+PSsetXrgbactual
+PSGlobalFontDirectory
+PScshow
+PScurrentcolor
+PScurrentcolorrendering
+PScurrentcolorspace
+PScurrentdevparams
+PScurrentglobal
+PScurrentoverprint
+PScurrentpagedevice
+PScurrentsystemparams
+PScurrentuserparams
+PSdefineresource
+PSexecform
+PSfilter
+PSfindencoding
+PSfindresource
+PSgcheck
+PSglobaldict
+PSglyphshow
+PSlanguagelevel
+PSleftbracket
+PSleftleft
+PSmakepattern
+PSproduct
+PSresourceforall
+PSresourcestatus
+PSrevision
+PSrightbracket
+PSrightright
+PSrootfont
+PSserialnumber
+PSsetcolor
+PSsetcolorrendering
+PSsetcolorspace
+PSsetdevparams
+PSsetglobal
+PSsetoverprint
+PSsetpagedevice
+PSsetpattern
+PSsetsystemparams
+PSsetuserparams
+PSstartjob
+PSundefineresource
+
+/* $XFree86$ */
diff --git a/nx-X11/lib/dps/dpsNXprops.h b/nx-X11/lib/dps/dpsNXprops.h
new file mode 100644
index 000000000..c3a8e8d39
--- /dev/null
+++ b/nx-X11/lib/dps/dpsNXprops.h
@@ -0,0 +1,90 @@
+/*
+ * dpsNXprops.h
+ *
+ * (c) Copyright 1992-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$ */
+
+#ifndef DPSNXPROPS_H
+#define DPSNXPROPS_H
+
+
+/* ---DEFINES--- */
+
+/* --- X Window Properties --- */
+
+#define XDPSNX_BILLBOARD_PROP "_ADOBE_DPS_NX_BILLBOARD" /* On dpy root win */
+
+/* Following are per Agent window properties */
+
+#define XDPSNX_WILLINGNESS_PROP     "_ADOBE_DPS_NX_WILLINGNESS_PROP"
+#define XDPSNX_LICENSE_METHOD_PROP  "_ADOBE_DPS_NX_LICENSE_METHODS_PROP"
+#define XDPSNX_TRANSPORT_INFO_PROP  "_ADOBE_DPS_NX_TRANSPORT_INFO_PROP"
+#define XDPSNX_HOST_NAME_PROP       "_ADOBE_DPS_NX_HOST_NAME_PROP"
+
+#define XDPSNX_X_CLASS_NAME         "XDPSNX"
+#define XDPSNX_X_RESOURCE           "xdpsnx.agenthost"
+#define XDPSNX_X_CLASS              "XDPSNX.AgentHost"
+
+#define AGENT_ENV_VAR               "DPSNXHOST"
+
+
+/* - Predefined Willingness Prop. Values.  Range: [0, 100] - */
+
+#define XDPSNX_MAX_WILLINGNESS 100
+#define XDPSNX_NOT_WILLING     0 /* 0:= agent wishes to "refuses" service to
+				    new clients */
+#define XDPSNX_MIN_WILLINGNESS 1 /* 1:= agent may delegate a client's request
+				    for a connection to another "more willing"
+				    agent */
+
+/* ---Predefined License Method Values--- */
+
+#define LICENSE_METHOD_PREFIX "_ADOBE_DPS_NX_LICENSE_LOCK_&_KEY_"
+#define LICENSE_METHOD_OPEN   "_ADOBE_DPS_NX_LICENSE_OPEN_SERVICE"
+#define OPEN_LICENSE_VERSION 1
+
+#include <stddef.h>
+  
+
+/* ---Types--- */
+
+typedef struct {
+  int transport;
+  int port;
+} TransportInfo;
+
+
+#endif	/* DPSNXPROPS_H */
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);
+}
diff --git a/nx-X11/lib/dps/dpsXcmu.c b/nx-X11/lib/dps/dpsXcmu.c
new file mode 100644
index 000000000..502649d51
--- /dev/null
+++ b/nx-X11/lib/dps/dpsXcmu.c
@@ -0,0 +1,1602 @@
+/*
+ * dpsXcmu.c -- Simple color management/allocation utility
+ *
+ * (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
+ * 
+ * Portions Copyright 1989 by the Massachusetts Institute of Technology
+ *
+ * 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 of M.I.T. not be used in advertising
+ * or publicity pertaining to distribution of the software without specific, 
+ * written prior permission. M.I.T. makes no representations about the 
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
+ * 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.
+ *
+ * Author: Adobe Systems Incorporated and Donna Converse, MIT X Consortium
+ */
+/* $XFree86: xc/lib/dps/dpsXcmu.c,v 1.4 2000/09/26 15:56:59 tsi Exp $ */
+
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/Xresource.h>
+#include <X11/Xos.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <pwd.h>
+
+#include "dpsassert.h"
+#include "cslibint.h"
+
+/* Defines for standard colormap routines */
+
+#define PrivSort qsort
+#include <stddef.h>
+
+static char redsName[] = "reds";
+static char greensName[] = "greens";
+static char bluesName[] = "blues";
+static char graysName[] = "grays";
+
+/* Database containing DPS default color cube values */
+
+typedef struct _dpyRec {
+    Display *dpy;
+    XrmDatabase db;
+    Atom XA_GRAY_DEFAULT_MAP;
+    struct _dpyRec *next;
+} DpyRec;
+
+static DpyRec *dpyRec = NULL;
+static DpyRec *curDpyRec;
+static DpyRec *FindDpyRec(Display *);
+
+typedef struct {
+    unsigned long *pixels;
+    int npixels;
+} PixelRec;
+
+static Bool AllocateColor(Display *, Colormap, XColor *);
+static Bool AllocateColormap(Display *, XStandardColormap *, XVisualInfo *, int *, PixelRec *, int *, int *, unsigned long);
+static Bool CheckCube(XColor *, XColor *, XStandardColormap *);
+static Bool CubicCube(XStandardColormap *);
+static Bool GetColorCubeFromProperty(Display *, XVisualInfo *, XStandardColormap *, XStandardColormap **, int *);
+static Bool GetGrayRampFromProperty(Display *, XVisualInfo *, XStandardColormap *, XStandardColormap **, int *);
+Status XDPSCreateStandardColormaps(Display *, Drawable, Visual *, int, int, int, int, XStandardColormap *, XStandardColormap *, Bool);
+static Status contiguous(unsigned long *, int, int *, unsigned long, int *, int *);
+static XVisualInfo *PickCorrectVisual(Display *, XVisualInfo *, int, Colormap);
+static int FindRampSize(XColor *, XColor *);
+static long NumColors(char *, char *, char *);
+static void AllocateColorCube(Display *, XVisualInfo *, XStandardColormap *, PixelRec *);
+static void AllocateGrayRamp(Display *, XVisualInfo *, XStandardColormap *, XStandardColormap *, PixelRec *);
+static void ColorValuesFromMask(unsigned long, unsigned long *, unsigned long *);
+static void CreateDefaultsDb(Display *);
+static void DefineProperty(Display *, XStandardColormap *, XVisualInfo *, XStandardColormap *, int, Atom);
+static void FindStaticColorCube(Display *, XVisualInfo *, XStandardColormap *);
+static void FindStaticGrayRamp(Display *, XVisualInfo *, XStandardColormap *, XStandardColormap *);
+static void GetDatabaseValues(Display *, XVisualInfo *, XStandardColormap *, XStandardColormap *);
+static void GetHomeDir(char *);
+static void SetRamp(XColor *, XColor *, int, int *, unsigned long *);
+static void ShrinkMapToFit(XStandardColormap *, int *, XVisualInfo *);
+static void UseGrayCorners(XStandardColormap *, XStandardColormap *);
+static void UseGrayDiagonal(XStandardColormap *, XStandardColormap *);
+
+#define SCALE 65535
+#undef ABS
+#define ABS(x) ((x) < 0 ? -(x) : (x))
+
+void XDPSGetDefaultColorMaps(
+    Display *dpy,
+    Screen *screen,
+    Drawable drawable,
+    XStandardColormap *colorCube,
+    XStandardColormap *grayRamp)
+{
+    Window root;
+    Visual *visual;
+    XStandardColormap g;
+
+    /* If there is a screen specified, use it; otherwise use the drawable */
+
+    if (screen == NULL) {
+        if (drawable == None || ScreenCount(dpy) == 1) {
+            root = DefaultRootWindow(dpy);
+            screen = DefaultScreenOfDisplay(dpy);
+        } else {
+            /* Have to get the root for this drawable */
+            int x, y;
+            int i;
+            unsigned int width, height, bwidth, depth;
+            if (!XGetGeometry(dpy, drawable, &root, &x, &y, &width, &height,
+                              &bwidth, &depth)) root = DefaultRootWindow(dpy);
+            for (i = 0;
+                 i < ScreenCount(dpy) && root != RootWindow(dpy, i);
+                 i++) {}
+            screen = ScreenOfDisplay(dpy, i);
+        }
+    } else root = RootWindowOfScreen(screen);
+
+    if (grayRamp == NULL) grayRamp = &g;
+
+    visual = DefaultVisualOfScreen(screen);
+    grayRamp->colormap = DefaultColormapOfScreen(screen);
+    if (colorCube != NULL) colorCube->colormap = grayRamp->colormap;
+
+    (void) XDPSCreateStandardColormaps(dpy, root, visual,
+				       0, 0, 0, 0, colorCube, grayRamp, True);
+}
+
+Status XDPSCreateStandardColormaps(
+    Display *dpy,
+    Drawable drawable,
+    Visual *visual,
+    int reds, int greens, int blues, int grays,
+    XStandardColormap *colorCube,
+    XStandardColormap *grayRamp,
+    Bool retain)
+{
+    XVisualInfo vtemp, *vinfo;
+    int nvis;
+    XStandardColormap *propCube = NULL, *propRamp = NULL;
+    int nPropCube = 0, nPropRamp = 0;
+    Bool gotCube = False, gotRamp;
+    PixelRec pixels;
+
+    if (grayRamp == NULL) return 0;
+    if (colorCube != NULL &&
+	colorCube->colormap != grayRamp->colormap) return 0;
+
+    if (dpy == NULL || (drawable == None && visual == NULL)) return 0;
+
+    if (visual == NULL) {
+	XWindowAttributes attr;
+	if (XGetWindowAttributes(dpy, drawable, &attr) == 0) return 0;
+	visual = attr.visual;
+    }
+
+    if (grayRamp->colormap == None && drawable == None) return 0;
+
+    curDpyRec = FindDpyRec(dpy);
+    if (curDpyRec == NULL) return 0;
+
+    vtemp.visualid = XVisualIDFromVisual(visual);
+    vinfo = XGetVisualInfo(dpy, VisualIDMask, &vtemp, &nvis);
+    if (nvis == 0) return 0;
+
+    if (nvis > 1) {
+	vinfo = PickCorrectVisual(dpy, vinfo, nvis, grayRamp->colormap);
+    }
+    if (vinfo == NULL) return 0;
+
+    if (grays <= 1) grayRamp->red_max = 0;
+    else grayRamp->red_max = grays - 1;
+
+    if (colorCube != NULL) {
+	if (reds <= 1) colorCube->red_max = 0;
+	else colorCube->red_max = reds - 1;
+	if (greens <= 1) colorCube->green_max = 0;
+	else colorCube->green_max = greens - 1;
+	if (blues <= 1) colorCube->blue_max = 0;
+	else colorCube->blue_max = blues - 1;
+    }
+
+    if ((vinfo->class == StaticGray || vinfo->class == GrayScale) &&
+	colorCube != NULL) {
+	/* Can't do a color cube in a gray visual! */
+	colorCube->red_max = colorCube->green_max = colorCube->blue_max =
+	colorCube->red_mult = colorCube->green_mult = colorCube->blue_mult =
+	colorCube->base_pixel = 0;
+	colorCube = NULL;
+    }
+
+    if (retain) {
+	Display *newDpy = XOpenDisplay(XDisplayString(dpy));
+	if (newDpy == NULL) retain = False;
+	else dpy = newDpy;
+	XGrabServer(dpy);
+    }
+
+    if (grayRamp->colormap == None) {
+	grayRamp->colormap = XCreateColormap(dpy, drawable, vinfo->visual,
+					     AllocNone);
+	if (colorCube != NULL) colorCube->colormap = grayRamp->colormap;
+    }
+
+    if (colorCube != NULL) {
+	gotCube = GetColorCubeFromProperty(dpy, vinfo, colorCube,
+					   &propCube, &nPropCube);
+    }
+    gotRamp = GetGrayRampFromProperty(dpy, vinfo, grayRamp,
+				      &propRamp, &nPropRamp);
+
+    if (!gotRamp || (colorCube != NULL && !gotCube)) {
+	/* Couldn't find at least one thing we wanted, so let's look in the
+	   database */
+
+	GetDatabaseValues(dpy, vinfo, colorCube, grayRamp);
+
+	pixels.pixels = NULL;
+	pixels.npixels = 0;
+
+	if (colorCube != NULL) {
+	    if (colorCube->red_max != 0) {
+		AllocateColorCube(dpy, vinfo, colorCube, &pixels);
+	    }
+	    if (colorCube->red_max == 0) {
+		colorCube->green_max = colorCube->blue_max = 
+		colorCube->red_mult = colorCube->green_mult =
+		colorCube->blue_mult = 0;
+	    }
+	}
+
+	if (grayRamp->red_max != 0) {
+	    AllocateGrayRamp(dpy, vinfo, grayRamp, colorCube, &pixels);
+	}
+
+	if (pixels.pixels != NULL) {
+	    if (pixels.npixels != 0) {
+		XFreeColors(dpy, grayRamp->colormap,
+			    pixels.pixels, pixels.npixels, 0);
+	    }
+	    free((char *) pixels.pixels);
+	}
+
+	if (retain) {
+	    Pixmap p;
+
+	    /* Create something to put in killid field so the entries can
+	       be deleted sometime */
+	    p = XCreatePixmap(dpy, RootWindow(dpy, vinfo->screen), 1, 1, 1);
+	    if (colorCube != NULL && !gotCube && colorCube->red_max != 0) {
+		colorCube->visualid = vinfo->visualid;
+		colorCube->killid = p;
+		DefineProperty(dpy, colorCube, vinfo, propCube, nPropCube,
+			       XA_RGB_DEFAULT_MAP);
+	    }
+	    if (!gotRamp && grayRamp->red_max != 0) {
+		grayRamp->visualid = vinfo->visualid;
+		grayRamp->killid = p;
+		DefineProperty(dpy, grayRamp, vinfo, propRamp, nPropRamp,
+			       (vinfo->class == GrayScale ? XA_RGB_GRAY_MAP :
+				curDpyRec->XA_GRAY_DEFAULT_MAP));
+	    }
+	    XSetCloseDownMode(dpy, RetainTemporary);
+	}
+    }
+
+    if (grayRamp->red_max == 0) {
+	/* Use special magic values.  If this is a default colormap,
+	   the server recognizes a gray ramp with red_max=1, red_mult=1,
+	   base_pixel=0 to mean a 2 gray ramp with BlackPixel being 
+	   the lowest intensity gray and WhitePixel being the highest
+           intensity gray.  If it's not a default colormap, then the
+	   server will either generate a BadValue error, or just happily
+	   use pixel values 0 and 1; either is better than the alternative,
+	   silently converting into a null device. */
+	grayRamp->red_max = 1;
+	grayRamp->red_mult = 1;
+	grayRamp->base_pixel = 0;
+    }
+
+    if (retain) {
+	XUngrabServer(dpy);
+	XCloseDisplay(dpy);
+    }
+    if (propCube != NULL) XFree((void *) propCube);
+    if (propRamp != NULL) XFree((void *) propRamp);
+    XFree((void *) vinfo);
+    return 1;
+}
+
+static DpyRec *FindDpyRec(Display *dpy)
+{
+    DpyRec *d;
+
+    for (d = dpyRec; d != NULL; d = d->next) {
+	if (d->dpy == dpy) return d;
+    }
+  
+    d = (DpyRec *) malloc(sizeof(DpyRec));
+    if (d == NULL) return NULL;
+    d->XA_GRAY_DEFAULT_MAP = XInternAtom(dpy, "DEFAULT_GRAY", False);
+    d->db = NULL;
+    d->next = dpyRec;
+    dpyRec = d;
+    return d;
+}
+
+static XVisualInfo *PickCorrectVisual(
+    Display *dpy,
+    XVisualInfo *vlist,
+    int n,
+    Colormap cmap)
+{
+    register int i;
+    register int screen_number;
+    Bool def_cmap = False;
+
+    /* A visual id may be valid on multiple screens.  Also, there may 
+     * be multiple visuals with identical visual ids at different depths.  
+     * If the colormap is the Default Colormap, use the Default Visual.
+     * Otherwise, arbitrarily, use the deepest visual.
+     */
+
+    for (screen_number = ScreenCount(dpy); --screen_number >= 0; /**/) {
+	if (cmap == DefaultColormap(dpy, screen_number)) {
+	    def_cmap = True;
+	    break;
+	}
+    }
+
+    if (def_cmap) {
+	for (i = 0; i < n; i++, vlist++) {
+	    if (vlist->visual == DefaultVisual(dpy, screen_number)) {
+		return vlist;
+	    }
+	}
+	return NULL;	/* Visual does not match colormap */
+    } else {
+	int maxdepth = 0;
+	XVisualInfo *v = 0;
+
+	for (i = 0; i < n; i++, vlist++) {
+	    if (vlist->depth > maxdepth) {
+		maxdepth = vlist->depth;
+		v = vlist;
+	    }
+	}
+	return v;
+    }
+}
+
+/* Do some rudimentary checking of the properties to avoid obviously bad ones.
+   How did they get there, anyway? */
+
+static Bool ValidCube(
+    XStandardColormap *c,
+    XVisualInfo *vinfo)
+{
+    unsigned long max = 1 << vinfo->depth;
+    unsigned long pixel;
+
+    if (c->red_max < 1 || c->green_max < 1 || c->blue_max < 1) return False;
+    if (c->base_pixel > max) return False;
+    pixel = (c->red_max * c->red_mult + c->green_max * c->green_mult +
+	     c->blue_max * c->blue_mult + c->base_pixel) & 0xFFFFFFFF;
+    if (pixel > max) return False;
+
+    return True;
+}
+
+static Bool ValidRamp(
+    XStandardColormap *c,
+    XVisualInfo *vinfo)
+{
+    unsigned long max = 1 << vinfo->depth;
+    unsigned long pixel;
+
+    if (c->red_max < 1) return False;
+    if (c->base_pixel > max) return False;
+    pixel = (c->red_max * c->red_mult + c->base_pixel) & 0xFFFFFFFF;
+    if (pixel > max) return False;
+
+    return True;
+}
+
+static Bool GetColorCubeFromProperty(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *colorCube,
+    XStandardColormap **cube,
+    int *ncube)
+{
+    int gotCube;
+    int i;
+    register XStandardColormap *c;
+
+    gotCube = XGetRGBColormaps(dpy, RootWindow(dpy, vinfo->screen), cube,
+			       ncube, XA_RGB_DEFAULT_MAP);
+    
+    if (gotCube) {
+	/* Try to find a match with the visual */
+	c = *cube;
+	for (i = 0; i < *ncube; i++) {
+	    if (c->colormap == colorCube->colormap &&
+		c->visualid == vinfo->visualid &&
+		ValidCube(c, vinfo)) {
+		colorCube->red_max = c->red_max;
+		colorCube->red_mult = c->red_mult;
+		colorCube->green_max = c->green_max;
+		colorCube->green_mult = c->green_mult;
+		colorCube->blue_max = c->blue_max;
+		colorCube->blue_mult = c->blue_mult;
+		colorCube->base_pixel = c->base_pixel;
+		colorCube->visualid = c->visualid;
+		colorCube->killid = c->killid;
+		break;
+	    }
+	    c++;
+	}
+	if (i == *ncube) gotCube = False;
+    }
+    return gotCube;
+}
+
+static Bool GetGrayRampFromProperty(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *grayRamp,
+    XStandardColormap **ramp,
+    int *nramp)
+{
+    int gotRamp;
+    int i;
+    Atom grayAtom;
+    register XStandardColormap *c;
+
+    if (vinfo->class == GrayScale) grayAtom = XA_RGB_GRAY_MAP;
+    else grayAtom = curDpyRec->XA_GRAY_DEFAULT_MAP;
+
+    gotRamp = XGetRGBColormaps(dpy, RootWindow(dpy, vinfo->screen), ramp,
+			       nramp, grayAtom);
+    
+    if (gotRamp) {
+	/* Try to find a match with the visual */
+	c = *ramp;
+	for (i = 0; i < *nramp; i++) {
+	    if (c->colormap == grayRamp->colormap &&
+		c->visualid == vinfo->visualid &&
+		ValidRamp(c, vinfo)) {
+		grayRamp->red_max = c->red_max;
+		grayRamp->red_mult = c->red_mult;
+		grayRamp->base_pixel = c->base_pixel;
+		grayRamp->visualid = c->visualid;
+		grayRamp->killid = c->killid;
+		break;
+	    }
+	    c++;
+	}
+	if (i == *nramp) gotRamp = False;
+    }
+    return gotRamp;
+}
+
+static void GetDatabaseValues(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *colorCube,
+    XStandardColormap *grayRamp)
+{
+    char *class, *depth;
+    char namePrefix[40], classPrefix[40];
+    unsigned long max;
+    XStandardColormap fakeCube;
+
+    switch (vinfo->class) {
+	default:
+        case StaticGray:  class = "StaticGray."; break;
+        case GrayScale:   class = "GrayScale."; break;
+        case StaticColor: class = "StaticColor."; break;
+        case PseudoColor: class = "PseudoColor."; break;
+        case TrueColor:   class = "TrueColor."; break;
+        case DirectColor: class = "DirectColor."; break;
+    }
+
+    if      (vinfo->depth >= 24) depth = "24.";
+    else if (vinfo->depth >= 12) depth = "12.";
+    else if (vinfo->depth >= 8) depth = "8.";
+    else if (vinfo->depth >= 4) depth = "4.";
+    else if (vinfo->depth >= 2) depth = "2.";
+    else depth = "1.";
+
+    (void) strcpy(namePrefix, "dpsColorCube.");
+    (void) strcat(strcat(namePrefix, class), depth);
+    (void) strcpy(classPrefix, "DPSColorCube.");
+    (void) strcat(strcat(classPrefix, class), depth);
+
+    CreateDefaultsDb(dpy);
+
+    if (colorCube == NULL && vinfo->class == TrueColor) {
+	/* We'll need the color cube information to compute the gray ramp,
+	   even if it wasn't asked for, so make colorCube point to a
+	   temporary structure */
+	colorCube = &fakeCube;
+    }
+
+    if (colorCube != NULL) {
+	switch (vinfo->class) {
+	    case StaticGray:
+	    case GrayScale:
+	        /* We can't do a color cube for these visuals */
+		break;
+
+	    case TrueColor:
+		/* Rewrite whatever was there before with real values */
+		ColorValuesFromMask(vinfo->red_mask, &colorCube->red_max,
+				    &colorCube->red_mult);
+		ColorValuesFromMask(vinfo->green_mask, &colorCube->green_max,
+				    &colorCube->green_mult);
+		ColorValuesFromMask(vinfo->blue_mask, &colorCube->blue_max,
+				    &colorCube->blue_mult);
+		colorCube->base_pixel = 0;
+		break;
+
+	    case DirectColor:
+		/* Get the mults from the masks; ignore maxes */
+		ColorValuesFromMask(vinfo->red_mask, &max,
+				    &colorCube->red_mult);
+		ColorValuesFromMask(vinfo->green_mask, &max,
+				    &colorCube->green_mult);
+		ColorValuesFromMask(vinfo->blue_mask, &max,
+				    &colorCube->blue_mult);
+		/* Get the maxes from the database */
+		if (colorCube->red_max == 0) {
+		    colorCube->red_max =
+			    NumColors(namePrefix, classPrefix, redsName) - 1;
+		}
+		if (colorCube->green_max == 0) {
+		    colorCube->green_max =
+			    NumColors(namePrefix, classPrefix, greensName) - 1;
+		}
+		if (colorCube->blue_max == 0) {
+		    colorCube->blue_max =
+			    NumColors(namePrefix, classPrefix, bluesName) - 1;
+		}
+		colorCube->base_pixel = 0;
+		break;
+
+	    case PseudoColor:
+		if (colorCube->red_max == 0) {
+		    colorCube->red_max =
+			    NumColors(namePrefix, classPrefix, redsName) - 1;
+		}
+		if (colorCube->green_max == 0) {
+		    colorCube->green_max =
+			    NumColors(namePrefix, classPrefix, greensName) - 1;
+		}
+		if (colorCube->blue_max == 0) {
+		    colorCube->blue_max =
+			    NumColors(namePrefix, classPrefix, bluesName) - 1;
+		}
+		colorCube->red_mult = (colorCube->green_max + 1) *
+			(colorCube->blue_max + 1);
+		colorCube->green_mult = colorCube->blue_max + 1;
+		colorCube->blue_mult = 1;
+		break;
+
+	    case StaticColor:
+		FindStaticColorCube(dpy, vinfo, colorCube);
+		break;
+	}
+    }
+
+    switch (vinfo->class) {
+	case GrayScale:
+	case PseudoColor:
+	case DirectColor:
+	    if (grayRamp->red_max == 0) {
+		grayRamp->red_max =
+			NumColors(namePrefix, classPrefix, graysName) - 1;
+	    }
+	    grayRamp->red_mult = 1;
+	    break;
+
+	case TrueColor:
+	    /* If the color cube is truly a cube, use its diagonal.  Otherwise
+	       were SOL and have to use a two-element ramp. */
+	    if (CubicCube(colorCube)) UseGrayDiagonal(colorCube, grayRamp);
+	    else UseGrayCorners(colorCube, grayRamp);
+	    break;
+
+	case StaticColor:
+	case StaticGray:
+	    FindStaticGrayRamp(dpy, vinfo, grayRamp, colorCube);
+	    break;
+    }
+}
+
+static Bool CubicCube(XStandardColormap *cube)
+{
+    return cube->red_max == cube->green_max && cube->red_max ==
+	    cube->blue_max;
+}
+
+static void UseGrayDiagonal(XStandardColormap *cube, XStandardColormap *ramp)
+{
+    ramp->red_max = cube->red_max;
+    ramp->red_mult = cube->red_mult + cube->green_mult + cube->blue_mult;
+    ramp->base_pixel = cube->base_pixel;
+}
+
+static void UseGrayCorners(XStandardColormap *cube, XStandardColormap *ramp)
+{
+    ramp->red_max = 1;
+    ramp->red_mult = (cube->red_max + 1) * (cube->green_max + 1) *
+	    (cube->blue_max + 1) - 1;
+    if (* (int *) &(cube->red_mult) < 0) ramp->red_mult *= -1;
+    ramp->base_pixel = cube->base_pixel;
+}
+
+static void ColorValuesFromMask(
+    unsigned long	mask,
+    unsigned long	*maxColor,
+    unsigned long	*mult)
+{
+    *mult = 1;
+    while ((mask & 1) == 0) {
+	*mult <<= 1;
+	mask >>= 1;
+    }
+    *maxColor = mask;
+}
+
+/* 
+Resource definitions for default color cube / gray ramp sizes
+are based on visual class and depth. Working from least choices
+to most, here's motivation for the defaults:
+
+If unspecified, default is 0 values for red, green, and blue,
+and 2 (black and white) for grays. This covers StaticGray, StaticColor,
+and depths less than 4 of the other visual classes.
+
+If we have a choice, we try to allocate a gray ramp with an odd number
+of colors; this is so 50% gray can be rendered without dithering.
+In general we don't want to allocate a large cube (even when many
+colormap entries are available) because allocation of each entry
+requires a round-trip to the server (entries allocated read-only
+via XAllocColor).
+
+For GrayScale, any depth less than 4 is treated as monochrome.
+
+PseudoColor depth 4 we try for a 2x2x2 cube with the gray ramp on
+the diagonal. Depth 8 uses a 4x4x4 cube with a separate 9 entry
+gray ramp. Depth 12 uses a 6x6x5 "cube" with a separate 17 entry gray
+ramp. The cube is non-symmetrical; we don't want to use the diagonal
+for a gray ramp and we can get by with fewer blues than reds or greens.
+
+For DirectColor, allocating a gray ramp separate from the color cube
+is wasteful of map entries, so we specify a symmetrical cube and
+share the diagonal entries for the gray ramp. 
+
+For TrueColor, # color shades is set equal to the # shades / primary;
+we don't actually allocate map entries, but it's handy to be able to
+do the resource lookup blindly and get the right value.
+*/
+
+static char dpsDefaults[] = "\
+*reds: 0\n\
+*greens: 0\n\
+*blues: 0\n\
+*grays: 2\n\
+\
+*GrayScale.4.grays: 9\n\
+*GrayScale.8.grays: 17\n\
+\
+*PseudoColor.4.reds: 2\n\
+*PseudoColor.4.greens: 2\n\
+*PseudoColor.4.blues: 2\n\
+*PseudoColor.4.grays: 2\n\
+*PseudoColor.8.reds: 4\n\
+*PseudoColor.8.greens: 4\n\
+*PseudoColor.8.blues: 4\n\
+*PseudoColor.8.grays: 9\n\
+*PseudoColor.12.reds: 6\n\
+*PseudoColor.12.greens: 6\n\
+*PseudoColor.12.blues: 5\n\
+*PseudoColor.12.grays: 17\n\
+\
+*DirectColor.8.reds: 4\n\
+*DirectColor.8.greens: 4\n\
+*DirectColor.8.blues: 4\n\
+*DirectColor.8.grays: 4\n\
+*DirectColor.12.reds: 6\n\
+*DirectColor.12.greens: 6\n\
+*DirectColor.12.blues: 6\n\
+*DirectColor.12.grays: 6\n\
+*DirectColor.24.reds: 7\n\
+*DirectColor.24.greens: 7\n\
+*DirectColor.24.blues: 7\n\
+*DirectColor.24.grays: 7\n\
+\
+*TrueColor.12.reds: 16\n\
+*TrueColor.12.greens: 16\n\
+*TrueColor.12.blues: 16\n\
+*TrueColor.12.grays: 16\n\
+*TrueColor.24.reds: 256\n\
+*TrueColor.24.greens: 256\n\
+*TrueColor.24.blues: 256\n\
+*TrueColor.24.grays: 256\n\
+";
+
+static XrmDatabase defaultDB = NULL;
+
+static void CreateDefaultsDb(Display *dpy)
+{
+    char home[256], *dpyDefaults;
+
+    if (defaultDB == NULL) defaultDB = XrmGetStringDatabase(dpsDefaults);
+
+    if (curDpyRec->db != NULL) return;
+
+    dpyDefaults = XResourceManagerString(dpy);
+    if (dpyDefaults != NULL) {
+	curDpyRec->db = XrmGetStringDatabase(dpyDefaults);
+    } 
+
+    if (curDpyRec->db == NULL) {
+	GetHomeDir(home);
+	strcpy(home, "/.Xdefaults");
+	curDpyRec->db = XrmGetFileDatabase(home);
+    }
+}
+
+static void GetHomeDir(char *buf)
+{
+#ifndef X_NOT_POSIX
+     uid_t uid;
+#else
+     int uid;
+     extern int getuid();
+#ifndef SYSV386
+     extern struct passwd *getpwuid(), *getpwnam();
+#endif
+#endif
+     struct passwd *pw;
+     static char *ptr = NULL;
+
+     if (ptr == NULL) {
+        if (!(ptr = getenv("HOME"))) {
+            if ((ptr = getenv("USER")) != 0) pw = getpwnam(ptr);
+            else {
+                uid = getuid();
+                pw = getpwuid(uid);
+            }
+            if (pw) ptr = pw->pw_dir;
+            else {
+                ptr = NULL;
+                *buf = '\0';
+            }
+        }
+     }
+
+     if (ptr)
+        (void) strcpy(buf, ptr);
+
+     buf += strlen(buf);
+     *buf = '/';
+     buf++;
+     *buf = '\0';
+     return;
+}
+
+static long NumColors(char *namePrefix, char *classPrefix, char *color)
+{
+    char name[40], class[40];
+    XrmValue rtnValue;
+    char *rtnType;
+    long value;
+
+    (void) strcpy(name, namePrefix);
+    (void) strcpy(class, classPrefix);
+    if (! XrmGetResource(curDpyRec->db, strcat(name, color), 
+			 strcat(class, color), &rtnType, &rtnValue)) {
+	if (! XrmGetResource(defaultDB, name, class, &rtnType, &rtnValue)) {
+	    /* This should never happen, as our defaults cover all cases */
+	    return 0;
+	}
+    }
+
+    /* Resource value is number of shades of specified color.  If value
+       is not an integer, atoi returns 0, so we return 0. If value
+       is less than 2, it is invalid (need at least 2 shades of a color).
+       Explicitly setting 0 is ok for colors (means to not use a color
+       cube) but merits a warning for gray. */
+
+    if (strcmp(rtnValue.addr, "0") == 0 && strcmp(color, "grays") != 0) {
+	return 0;
+    }
+
+    value = atol(rtnValue.addr);
+    if (value < 2) {
+	char mbuf[512];
+	sprintf(mbuf, "%% Value '%s' is invalid for %s resource\n",
+		rtnValue.addr, name);
+	DPSWarnProc(NULL, mbuf);
+    }
+    return value;
+}
+
+/* Query the entire colormap in the static color case, then try to find
+   a color cube.  Check pairs of black and white cells trying to find
+   a cube between them and take the first one you find. */
+
+static void FindStaticColorCube(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *colorCube)
+{
+    XColor *ramp, *black, *white, *altBlack, *altWhite;
+    int i, entries;
+
+    entries = 1 << vinfo->depth;
+    ramp = (XColor *) calloc(entries, sizeof(XColor));
+
+    if (ramp == NULL) {
+	colorCube->red_max = 0;
+	return;
+    }
+
+    /* Query the colormap */
+    for (i = 0; i < entries; i++) ramp[i].pixel = i;
+    XQueryColors(dpy, colorCube->colormap, ramp, entries);
+
+    /* Find the white and black entries */
+
+    black = white = altBlack = altWhite = NULL;
+    for (i = 0; i < entries; i++) {
+	if (ramp[i].flags != (DoRed | DoBlue | DoGreen)) continue;
+	if (ramp[i].red == 0 && ramp[i].blue == 0 &&
+	    ramp[i].green == 0) {
+	    if (black == NULL) black = ramp+i;
+	    else if (altBlack == NULL) altBlack = ramp+i;
+	} else if (ramp[i].red == SCALE && ramp[i].blue == SCALE &&
+		   ramp[i].green == SCALE) {
+	    if (white == NULL) white = ramp+i;
+	    else if (altWhite == NULL) altWhite = ramp+i;
+	}
+    }
+
+    if (black == NULL || white == NULL) {
+	colorCube->red_max = 0;
+	free(ramp);
+	return;
+    }
+
+    /* Look for cubes between pairs of black & white */
+    if (!CheckCube(black, white, colorCube) &&
+	!CheckCube(altBlack, white, colorCube) &&
+	!CheckCube(black, altWhite, colorCube) &&
+	!CheckCube(altBlack, altWhite, colorCube)) {
+	colorCube->red_max = 0;
+    }
+
+    free(ramp);
+}
+
+#define R 1
+#define G 2
+#define B 4
+#define C 8
+#define M 16
+#define Y 32
+
+#define SMALLSCALE 255
+#define CheckColor(color,r,g,b) ((((color)->red >> 8) == (r) * SMALLSCALE) && \
+	(((color)->green >> 8) == (g) * SMALLSCALE) && \
+	(((color)->blue >> 8) == (b) * SMALLSCALE))
+
+static Bool CheckCube(
+    XColor *black,
+    XColor *white,
+    XStandardColormap *cube)
+{
+    int r = 0, g = 0, b = 0, c = 0, m = 0, y = 0, k, w;
+    XColor *color;
+    unsigned int found = 0;
+    int small, middle, large;
+    int smallMult, smallMax, middleMult, middleMax, largeMult, largeMax;
+    Bool backwards = False;
+    int mult = 1;
+    XStandardColormap test;	/* Test cube */
+    int i;
+    int size;
+
+    if (black == NULL || white == NULL) return False;
+
+    k = black->pixel;
+    w = white->pixel - k;
+
+    size = ABS(w);
+    if (w < 0) {
+	backwards = True;
+	mult = -1;
+    }
+
+    for (i = 1; i < size; i++) {
+	color = black + i*mult;
+	if (color->flags != (DoRed | DoBlue | DoGreen)) return False;
+
+	/* If black or white is in the middle of the cube, can't work */
+	if (CheckColor(color, 0, 0, 0)) return False;
+	if (CheckColor(color, 1, 1, 1)) return False;
+
+	/* Check for red, green, blue, cyan, magenta, and yellow */
+	if (CheckColor(color, 1, 0, 0)) {r = color->pixel-k; found |= R;}
+	else if (CheckColor(color, 0, 1, 0)) {g = color->pixel-k; found |= G;}
+	else if (CheckColor(color, 0, 0, 1)) {b = color->pixel-k; found |= B;}
+	else if (CheckColor(color, 0, 1, 1)) {c = color->pixel-k; found |= C;}
+	else if (CheckColor(color, 1, 0, 1)) {m = color->pixel-k; found |= M;}
+	else if (CheckColor(color, 1, 1, 0)) {y = color->pixel-k; found |= Y;}
+    }
+
+    /* If any color is missing no cube is possible */
+    if (found != (R | G | B | C | M | Y)) return False;
+
+    /* Next test.  Make sure B + G = C, R + B = M, R + G = Y,
+       and R + G + B = W */
+    if (b + g != c) return False;
+    if (r + b != m) return False;
+    if (r + g != y) return False;
+    if (r + g + b != w) return False;
+
+    /* Looking good!  Compensate for backwards cubes */
+    if (backwards) {
+	w = ABS(w);
+	r = ABS(r);
+	g = ABS(g);
+	b = ABS(b);
+    }
+
+    /* Find the smallest, middle, and largest difference */
+    if (r < b && b < g) {
+	small = r; middle = b; large = g;
+    } else if (r < g && g < b) {
+	small = r; middle = g; large = b;
+    } else if (b < r && r < g) {
+	small = b; middle = r; large = g;
+    } else if (b < g && g < r) {
+	small = b; middle = g; large = r;
+    } else if (g < r && r < b) {
+	small = g; middle = r; large = b;
+    } else {
+	small = g; middle = b; large = r;
+    }
+
+    /* The smallest must divide the middle, and the middle the large */
+    if ((middle % (small + 1)) != 0) return False;
+    if ((large % (small + middle + 1)) != 0) return False;
+
+    /* OK, we believe we have a cube.  Compute the description */
+    smallMult = 1;
+    smallMax = small;
+    middleMult = small + 1;
+    middleMax = middle / middleMult;
+    largeMult = small + middle + 1;
+    largeMax = large / largeMult;
+	
+    if (small == r) {
+	test.red_max = smallMax; test.red_mult = smallMult;
+	if (middle == b) {
+	    test.blue_max = middleMax; test.blue_mult = middleMult;
+	    test.green_max = largeMax; test.green_mult = largeMult;
+	} else {
+	    test.green_max = middleMax; test.green_mult = middleMult;
+	    test.blue_max = largeMax; test.blue_mult = largeMult;
+	}
+    } else if (small == g) {
+	test.green_max = smallMax; test.green_mult = smallMult;
+	if (middle == b) {
+	    test.blue_max = middleMax; test.blue_mult = middleMult;
+	    test.red_max = largeMax; test.red_mult = largeMult;
+	} else {
+	    test.red_max = middleMax; test.red_mult = middleMult;
+	    test.blue_max = largeMax; test.blue_mult = largeMult;
+	}
+    } else {	/* small == b */
+	test.blue_max = smallMax; test.blue_mult = smallMult;
+	if (middle == r) {
+	    test.red_max = middleMax; test.red_mult = middleMult;
+	    test.green_max = largeMax; test.green_mult = largeMult;
+	} else {
+	    test.green_max = middleMax; test.green_mult = middleMult;
+	    test.red_max = largeMax; test.red_mult = largeMult;
+	}
+    }
+    
+    /* Re-compensate for backwards cube */
+    if (backwards) {
+	test.red_mult *= -1;
+	test.green_mult *= -1;
+	test.blue_mult *= -1;
+    }
+
+    /* Finally, test the hypothesis!  The answer must be correct within 1
+       bit.  Only look at the top 8 bits; the others are too noisy */
+
+    for (i = 1; i < size; i++) {
+#define calc(i, max, mult) ((((i / test.mult) % \
+			      (test.max + 1)) * SCALE) / test.max)
+	r = ((unsigned short) calc(i, red_max, red_mult) >> 8) -
+		(black[i*mult].red >> 8);
+	g = ((unsigned short) calc(i, green_max, green_mult) >> 8) -
+		(black[i*mult].green >> 8);
+	b = ((unsigned short) calc(i, blue_max, blue_mult) >> 8) -
+		(black[i*mult].blue >> 8);
+#undef calc
+	if (ABS(r) > 2 || ABS(g) > 2 || ABS(b) > 2) return False;
+    }
+    cube->red_max = test.red_max;
+    cube->red_mult = test.red_mult;
+    cube->green_max = test.green_max;
+    cube->green_mult = test.green_mult;
+    cube->blue_max = test.blue_max;
+    cube->blue_mult = test.blue_mult;
+    cube->base_pixel = k;
+    return True;
+}
+
+#undef R
+#undef G
+#undef B
+#undef C
+#undef M
+#undef Y
+
+/* Query the entire colormap in the static gray case, then try to find
+   a gray ramp.  This handles there being 2 white or black entries
+   in the colormap and finds the longest linear ramp between pairs of
+   white and black.  If there is a color cube, also check its diagonal and
+   use its corners if we need to */
+
+static void FindStaticGrayRamp(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *grayRamp,
+    XStandardColormap *colorCube)
+{
+    XColor *ramp, *black, *white, *altBlack, *altWhite;
+    int i, r0, r1, r2, r3, size, entries, redMult;
+    unsigned long base;
+
+    entries = 1 << vinfo->depth;
+    ramp = (XColor *) calloc(entries, sizeof(XColor));
+
+    if (ramp == NULL) {
+	grayRamp->red_max = 0;
+	return;
+    }
+
+    /* Query the colormap */
+    for (i = 0; i < entries; i++) ramp[i].pixel = i;
+    XQueryColors(dpy, grayRamp->colormap, ramp, entries);
+
+    /* Find the white and black entries */
+
+    black = white = altBlack = altWhite = NULL;
+    for (i = 0; i < entries; i++) {
+	if (ramp[i].flags != (DoRed | DoBlue | DoGreen)) continue;
+	if (CheckColor(ramp+i, 0, 0, 0)) {
+	    if (black == NULL) black = ramp+i;
+	    else if (altBlack == NULL) altBlack = ramp+i;
+	} else if (CheckColor(ramp+i, 1, 1, 1)) {
+	    if (white == NULL) white = ramp+i;
+	    else if (altWhite == NULL) altWhite = ramp+i;
+	}
+    }
+
+    if (black == NULL || white == NULL) {
+	grayRamp->red_max = 0;
+	free(ramp);
+	return;
+    }
+
+    /* Find out how large a ramp exists between pairs of black & white */
+    r0 = FindRampSize(black, white);
+    r1 = FindRampSize(altBlack, white);
+    r2 = FindRampSize(black, altWhite);
+    r3 = FindRampSize(altBlack, altWhite);
+
+    size = r0;
+    if (r1 > size) size = r1;
+    if (r2 > size) size = r2;
+    if (r3 > size) size = r3;
+    if (size == r0) SetRamp(black, white, size, &redMult, &base);
+    else if (size == r1) SetRamp(altBlack, white, size, &redMult, &base);
+    else if (size == r2) SetRamp(black, altWhite, size, &redMult, &base);
+    else if (size == r3) SetRamp(altBlack, altWhite, size, &redMult, &base);
+
+    if (colorCube != NULL && CubicCube(colorCube) &&
+	colorCube->red_max > size) {
+	UseGrayDiagonal(colorCube, grayRamp);
+    } else {
+	grayRamp->red_max = size;
+	grayRamp->red_mult = redMult;
+	grayRamp->base_pixel = base;
+    }
+
+    free(ramp);
+}
+
+static int FindRampSize(XColor *black, XColor *white)
+{
+    XColor *c;
+    int r;
+    int mult = 1;
+    int i, size;
+
+    if (black == NULL || white == NULL) return 0;
+    size = ABS(white - black);
+
+    /* See if we have a backwards ramp */
+    if (black > white) mult = -1;
+
+    /* See if all cells between black and white are linear, to within 1 bit.
+       Only look at the high order 8 bits */
+
+    for (i = 1; i < size; i++) {
+	c = &black[i*mult];
+	if (c->red != c->blue || c->red != c->green) return 1;
+	r = ((unsigned short) ((i * SCALE) / size) >> 8) - (c->red >> 8);
+	if (ABS(r) > 2) return 1;
+    }
+    return size;
+}
+
+static void SetRamp(
+    XColor *black,
+    XColor *white,
+    int size,
+    int *mult,
+    unsigned long *base)
+{
+    *base = black->pixel;
+    *mult = (white - black) / size;
+}
+
+#define lowbit(x) ((x) & (~(x) + 1))
+
+static unsigned long shiftdown(unsigned long x)
+{
+    while ((x & 1) == 00) {
+	x = x >> 1;
+    }
+    return x;
+}
+
+static void AllocateColorCube(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *colorCube,
+    PixelRec *pixels)
+{
+    int count, first, remain, n, j;
+    unsigned long i;
+    Colormap cmap = colorCube->colormap;
+    unsigned long delta;
+    XColor color;
+
+    /* We do no allocation for TrueColor or StaticColor */
+    if (vinfo->class == TrueColor || vinfo->class == StaticColor) return;
+
+    if (vinfo->class == DirectColor) {
+	if ((i = shiftdown(vinfo->red_mask)) > colorCube->red_max)
+		colorCube->red_max = i;
+	if ((i = shiftdown(vinfo->green_mask)) > colorCube->green_max)
+		colorCube->green_max = i;
+	if ((i = shiftdown(vinfo->blue_mask)) > colorCube->blue_max)
+		colorCube->blue_max = i;
+
+	/* We only handle symmetric DirectColor */
+	count = colorCube->red_max + 1;
+	if (colorCube->blue_max + 1 < count) count = colorCube->blue_max + 1;
+	if (colorCube->green_max + 1 < count) count = colorCube->green_max + 1;
+	colorCube->red_max = colorCube->blue_max = colorCube->green_max =
+		count - 1;
+
+	delta = lowbit(vinfo->red_mask) + lowbit(vinfo->green_mask) +
+		lowbit(vinfo->blue_mask);
+    } else {
+	count = (colorCube->red_max + 1) * (colorCube->blue_max + 1) *
+		(colorCube->green_max + 1);
+	delta = 1;
+    }
+
+    colorCube->base_pixel = 0; /* temporary, may change */
+
+    pixels->pixels = (unsigned long *) calloc(vinfo->colormap_size,
+					      sizeof(unsigned long));
+    if (pixels->pixels == NULL) {
+	colorCube->red_max = 0;
+	return;
+    }
+
+    if (!AllocateColormap(dpy, colorCube, vinfo, &count, pixels,
+			  &first, &remain, delta)) {
+	free((char *) pixels->pixels);
+	pixels->pixels = NULL;
+	colorCube->red_max = 0;
+	return;
+    }
+
+    colorCube->base_pixel = pixels->pixels[first];
+    color.flags = DoRed | DoGreen | DoBlue;
+
+    /* Define colors */
+    for (n = 0, j = 0; j < count; ++j, n += delta) {
+	color.pixel = n + pixels->pixels[first];
+	if (vinfo->class == PseudoColor) {
+#define calc(i, max, mult) ((((i / colorCube->mult) % \
+			      (colorCube->max + 1)) * SCALE) / colorCube->max)
+	    color.red = (unsigned short) calc(n, red_max, red_mult);
+	    color.green = (unsigned short) calc(n, green_max, green_mult);
+	    color.blue = (unsigned short) calc(n, blue_max, blue_mult);
+#undef calc
+	} else {
+	    color.red = color.green = color.blue =
+		    (j * SCALE) / colorCube->red_max;
+	}
+	if (!AllocateColor(dpy, cmap, &color)) {
+	    XFreeColors(dpy, cmap, pixels->pixels, count+first+remain, 0);
+	    free((char *) pixels->pixels);
+	    pixels->pixels = NULL;
+	    colorCube->red_max = 0;
+	    return;
+	}
+    }
+
+    /* Smush down unused pixels, if any */
+
+    for (j = 0; j < remain; j++) {
+	pixels->pixels[first+j] = pixels->pixels[first+count+j];
+    }
+    pixels->npixels -= count;
+}
+
+static void AllocateGrayRamp(
+    Display *dpy,
+    XVisualInfo *vinfo,
+    XStandardColormap *grayRamp,
+    XStandardColormap *colorCube,
+    PixelRec *pixels)
+{
+    int count, first, remain, n, i;
+    Colormap cmap = grayRamp->colormap;
+    XColor color;
+    unsigned long delta;
+
+    /* Allocate cells in read/write visuals only */
+    if (vinfo->class != PseudoColor && vinfo->class != GrayScale &&
+	vinfo->class != DirectColor) return;
+
+    if (vinfo->class == DirectColor) {
+	delta = lowbit(vinfo->red_mask) + lowbit(vinfo->green_mask) +
+		lowbit(vinfo->blue_mask);
+    } else delta = 1;
+
+    /* First of all see if there's a usable gray ramp in the color cube */
+
+    if (colorCube != NULL) {
+	if (CubicCube(colorCube)) {
+	    if (colorCube->red_max >= grayRamp->red_max) {
+		/* diagonal is long enough!  use it */
+		UseGrayDiagonal(colorCube, grayRamp);
+		return;
+	    }
+	}
+    }
+
+    grayRamp->base_pixel = 0; /* temporary, may change */
+
+    count = grayRamp->red_max + 1;
+
+    if (pixels->pixels == NULL) {
+	pixels->pixels = (unsigned long *) calloc(vinfo->colormap_size,
+						  sizeof(unsigned long));
+	if (pixels->pixels == NULL) {
+	    grayRamp->red_max = 0;
+	    return;
+	}
+    }
+
+    if (!AllocateColormap(dpy, grayRamp, vinfo, &count, pixels,
+			  &first, &remain, delta)) {
+	/* Last gasp:  try any diagonal or the corners of the color cube */
+	if (colorCube != NULL) {
+	    if (CubicCube(colorCube)) UseGrayDiagonal(colorCube, grayRamp);
+	    else UseGrayCorners(colorCube, grayRamp);
+	} else {
+	    grayRamp->red_max = 0;
+	}
+	return;
+    }
+
+    grayRamp->base_pixel = pixels->pixels[first];
+    color.flags = DoRed | DoGreen | DoBlue;
+
+    /* Define colors */
+    for (n = 0, i = 0; i < count; ++i, n += delta) {
+	color.pixel = n + pixels->pixels[first];
+	color.red = (unsigned short)((n * SCALE) / (grayRamp->red_max));
+	color.green = color.red;
+	color.blue = color.red;
+
+	if (!AllocateColor(dpy, cmap, &color)) {
+	    /* Don't need to free pixels here; we'll do it on return */
+	    grayRamp->red_max = 0;
+	    return;
+	}
+    }
+
+    /* Smush down unused pixels, if any */
+
+    for (i = 0; i < remain; i++) {
+	pixels->pixels[first+i] = pixels->pixels[first+count+i];
+    }
+    pixels->npixels -= count;
+}
+
+static int compare(const void *a1, const void *a2)
+{
+    register unsigned long *e1 = (unsigned long *) a1,
+			   *e2 = (unsigned long *) a2;
+
+    if (*e1 < *e2)	return -1;
+    if (*e1 > *e2)	return 1;
+    return 0;
+}
+
+static Bool AllocateColormap(
+    Display *dpy,
+    XStandardColormap *map,
+    XVisualInfo *vinfo,
+    int *count,
+    PixelRec *pixels,
+    int *first, int *remain,
+    unsigned long delta)
+{
+    Colormap cmap = map->colormap;
+    int npixels, ok, i;
+    Bool success = False;
+
+    if (pixels->npixels == 0) {
+	/* First try to allocate the entire colormap */
+	npixels = vinfo->colormap_size;
+	ok = XAllocColorCells(dpy, cmap, 1, NULL, 0, pixels->pixels, npixels);
+	if (ok) success = True;
+	else {
+	    int total;
+	    int top, mid = 0;
+
+	    /* If it's a gray ramp or direct color we need at least 2;
+	       others 8 */
+	    if (map->blue_max == 0 || vinfo->class == DirectColor) total = 2;
+	    else total = 8;
+
+	    /* Allocate all available cells, using binary backoff */
+	    top = vinfo->colormap_size - 1;
+	    while (total <= top) {
+		mid = total + ((top - total + 1) / 2);
+		ok = XAllocColorCells(dpy, cmap, 1, NULL, 0,
+				      pixels->pixels, mid);
+		if (ok) {
+		    if (mid == top) {
+			success = True;
+			break;
+		    } else {
+			XFreeColors(dpy, cmap, pixels->pixels, mid, 0);
+			total = mid;
+		    }
+		} else top = mid - 1;
+	    }
+	    if (success) npixels = mid;
+	    else npixels = 0;
+	}
+    } else {
+	/* We must be in the gray ramp case, so we need at least 2 entries */
+	npixels = pixels->npixels;
+	if (map->blue_max != 0 || npixels >= 2) success = True;
+    }
+
+    if (success) {
+	/* Avoid pessimal case by testing to see if already sorted */
+	for (i = 0; i < npixels-1; ++i) {
+	    if (pixels->pixels[i] != pixels->pixels[i+1]-1) break;
+	}
+
+	if (i < npixels-1) {
+	    PrivSort((char *)pixels->pixels, npixels,
+		     sizeof(unsigned long), compare);
+	}
+    
+	if (!contiguous(pixels->pixels, npixels, count, delta,
+			first, remain)) {
+	    /* If there are enough free cells, shrink the map to fit.
+	       Otherwise fail; we'll free the pixels later */
+	    if (((map->blue_max == 0 || vinfo->class == DirectColor) &&
+		 *count >= 2) || *count >=8) {
+		ShrinkMapToFit(map, count, vinfo);
+		*remain = npixels - *first - *count;
+	    } else success = False;
+	}
+    }
+
+    pixels->npixels = npixels;
+    return success;
+}
+
+static Bool contiguous(
+    unsigned long	pixels[],	/* specifies allocated pixels */
+    int			npixels,	/* specifies count of alloc'd pixels */
+    int			*ncolors,	/* specifies needed sequence length
+					   If not available, returns max 
+					   available contiguous sequence */
+    unsigned long	delta,
+    int			*first,		/* returns first index of sequence */
+    int			*rem)		/* returns first index after sequence,
+					 * or 0, if none follow */
+{
+    register int i = 1;		/* walking index into the pixel array */
+    register int count = 1;	/* length of sequence discovered so far */
+    int max = 1;		/* longest sequence we found */
+    int maxstart = 0;
+
+    *first = 0;
+    while (count < *ncolors && i < npixels) {
+	if (pixels[i-1] + delta == pixels[i]) count++;
+	else {
+	    if (count > max) {
+		max = count;
+		maxstart = *first;
+	    }
+	    count = 1;
+	    *first = i;
+	}
+	i++;
+    }
+    if (i == npixels && count > max) {
+	max = count;
+	maxstart = *first;
+    }
+    *rem = npixels - i;
+    if (count != *ncolors) {
+	*ncolors = max;
+	*first = maxstart;
+	return False;
+    } return True;
+}
+
+static Bool AllocateColor(
+    Display *dpy,
+    Colormap cmap,
+    XColor *color)
+{
+    unsigned long pix = color->pixel;
+    XColor request;
+    int ok;
+
+    request = *color;
+
+    /* Free RW, Alloc RO, if fails, try RW */
+    XFreeColors(dpy, cmap, &pix, 1, 0);
+    ok = XAllocColor(dpy, cmap, &request);
+
+    /* If the pixel we get back isn't the request one, probably RO
+       White or Black, so shove it in RW so our cube is correct.
+       If alloc fails, try RW. */
+
+    if (!ok || request.pixel != color->pixel) {
+	ok = XAllocColorCells(dpy, cmap, 0, NULL, 0, &pix, 1);
+
+	if (pix != color->pixel) XFreeColors(dpy, cmap, &pix, 1, 0);
+	if (!ok || pix != color->pixel) {
+	    return False;
+	}
+	request = *color;
+	XStoreColor(dpy, cmap, &request);
+    }
+    return True;
+}
+
+static void ShrinkMapToFit(
+    XStandardColormap *map,
+    int *space,
+    XVisualInfo *vinfo)
+{
+    if (map->blue_max == 0) map->red_max = *space - 1;
+    else if (vinfo->class == DirectColor) {
+	if (map->red_max > *space - 1) map->red_max = *space - 1;
+	if (map->green_max > *space - 1) map->green_max = *space - 1;
+	if (map->blue_max > *space - 1) map->blue_max = *space - 1;
+    } else {
+	int which = 2;
+	while ((map->red_max + 1) * (map->green_max + 1) *
+	       (map->blue_max + 1) > *space) {
+	    if (which == 0) {
+		if (map->red_max > 1) map->red_max--;
+		which = 1;
+	    } else if (which == 1) {
+		if (map->green_max > 1) map->green_max--;
+		which = 2;
+	    } else {
+		if (map->blue_max > 1) map->blue_max--;
+		which = 0;
+	    }
+	}
+	*space = (map->red_max + 1) * (map->green_max + 1) *
+		(map->blue_max + 1);
+
+	map->red_mult = (map->green_max + 1) * (map->blue_max + 1);
+	map->green_mult = map->blue_max + 1;
+	map->blue_mult = 1;
+    }
+}
+
+static void DefineProperty(
+    Display *dpy,
+    XStandardColormap *map,
+    XVisualInfo *vinfo,
+    XStandardColormap *prop,
+    int nProp,
+    Atom atom)
+{
+    XStandardColormap *copy;
+    int i;
+
+    if (nProp == 0) {
+	XSetRGBColormaps(dpy, RootWindow(dpy, vinfo->screen), map, 1, atom);
+	return;
+    }
+
+    copy = (XStandardColormap *) calloc(nProp+1, sizeof(XStandardColormap));
+
+    /* Hm.  If I can't allocate the list, is it better to just put our
+       property on, or to leave the ones there?  I'll guess the latter... */
+    if (copy == NULL) return;
+
+    if (vinfo->visual == DefaultVisual(dpy, vinfo->screen) &&
+	map->colormap == DefaultColormap(dpy, vinfo->screen)) {
+	/* Put new entry first; it's more likely to be useful */
+	for (i = 0; i < nProp; i++) copy[i+1] = prop[i];
+	i = 0;
+    } else {
+	/* Put it at the end */
+	for (i = 0; i < nProp; i++) copy[i] = prop[i];
+	/* i = nProp; (it does already) */
+    }
+
+    copy[i] = *map;
+    XSetRGBColormaps(dpy, RootWindow(dpy, vinfo->screen), copy, nProp+1, atom);
+    
+    free((void *) copy);
+}
diff --git a/nx-X11/lib/dps/dpsXint.h b/nx-X11/lib/dps/dpsXint.h
new file mode 100644
index 000000000..08c4d233a
--- /dev/null
+++ b/nx-X11/lib/dps/dpsXint.h
@@ -0,0 +1,104 @@
+/*
+ * dpsXint.h	-- internal definitions to dpsXclient.c
+ *
+ * (c) Copyright 1989-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
+ */
+
+#ifndef DPSXINT_H
+#define DPSXINT_H
+
+#include <X11/X.h>
+#include <DPS/dpsXclient.h>
+
+/* The first part of this structure is generic; the last part is
+   implementation-specific. */
+
+typedef struct _t_DPSPrivContextRec {
+  char *priv;
+  DPSSpace space;
+  DPSProgramEncoding programEncoding;
+  DPSNameEncoding nameEncoding;
+  DPSProcs procs;
+  DPSTextProc textProc;
+  DPSErrorProc errorProc;
+  DPSResults resultTable;
+  unsigned int resultTableLength;
+  struct _t_DPSContextRec *chainParent, *chainChild;
+  unsigned int contextFlags;
+  DPSContextExtensionRec *extension;
+  
+  struct _t_DPSPrivContextRec *next;
+  integer lastNameIndex, cid;
+  boolean eofReceived;
+  char *wh;
+  char *buf, *outBuf, *objBuf;
+  integer nBufChars, nOutBufChars, nObjBufChars;
+  DPSNumFormat numFormat;
+  boolean resyncing;	/* Error has occurred and waiting ResetContext */
+  int *numstringOffsets;	/* see comment below */
+
+/* Everthing after this is XDPS-specific */
+
+  boolean creator;	/* Did this app. create the context? */
+  int statusFromEvent;  /* Latest status reported by an event during reset. */
+  XDPSStatusProc statusProc;
+  boolean zombie;    /* To avoid DPSAwaitReturnValues */
+  XDPSReadyProc readyProc;
+} DPSPrivContextRec, *DPSPrivContext;
+
+/* The numstringOffsets field lists offsets of encoded number strings in
+   the current buffer.  If non NULL, the first entry contains the size of
+   the allocated offset buffer and the second entry contains the next
+   available offset entry for use. */
+
+/* The first part of this structure is generic; the last part is
+   implementation-specific. */
+
+typedef struct _t_DPSPrivSpaceRec {
+  DPSSpaceProcs procs;
+  
+  struct _t_DPSPrivSpaceRec *next;
+  long int lastNameIndex, sid;
+  char *wh; /* KLUDGE to support DPSSendDestroySpace */
+  DPSPrivContext firstContext;
+
+/* Everthing after this is XDPS-specific */
+
+  boolean  creator;	/* Did this app. create the space? */
+} DPSPrivSpaceRec, *DPSPrivSpace;
+
+#include "dpsint.h"
+
+#endif /* DPSXINT_H */
diff --git a/nx-X11/lib/dps/dpsXops.psw b/nx-X11/lib/dps/dpsXops.psw
new file mode 100644
index 000000000..a14335739
--- /dev/null
+++ b/nx-X11/lib/dps/dpsXops.psw
@@ -0,0 +1,80 @@
+/* dpsXops.psw
+ *
+ * (c) Copyright 1991-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
+ */
+
+defineps DPSclientsync(DPSContext ctxt)
+	clientsync
+endps
+
+defineps DPScurrentXgcdrawable(DPSContext ctxt | int *gc, *draw, *x, *y)
+	currentXgcdrawable y x draw gc
+endps
+
+defineps DPScurrentXgcdrawablecolor(DPSContext ctxt | int *gc, *draw, *x, *y, colorInfo[12])
+	currentXgcdrawablecolor colorInfo y x draw gc
+endps
+
+defineps DPScurrentXoffset(DPSContext ctxt | int *x, *y)
+	currentXoffset y x
+endps
+
+defineps DPSsetXgcdrawable(DPSContext ctxt; int gc, draw, x, y)
+	gc draw x y setXgcdrawable
+endps
+
+defineps DPSsetXgcdrawablecolor(DPSContext ctxt; int gc, draw, x, y, colorInfo[12])
+	gc draw x y colorInfo setXgcdrawablecolor
+endps
+
+defineps DPSsetXoffset(DPSContext ctxt; int x, y)
+	x y setXoffset
+endps
+
+defineps DPSsetXrgbactual(DPSContext ctxt; float r, g, b | boolean *success)
+	r g b setXrgbactual success
+endps
+
+defineps DPSclientXready(DPSContext ctxt; int i0, i1, i2, i3)
+	[ i0 i1 i2 i3 ] clientXready
+endps
+
+defineps DPSsetXdrawingfunction(DPSContext ctxt; int function)
+	function setXdrawingfunction
+endps
+
+defineps DPScurrentXdrawingfunction(DPSContext ctxt | int *function)
+	currentXdrawingfunction function
+endps
diff --git a/nx-X11/lib/dps/dpsXpriv.c b/nx-X11/lib/dps/dpsXpriv.c
new file mode 100644
index 000000000..c0f12545c
--- /dev/null
+++ b/nx-X11/lib/dps/dpsXpriv.c
@@ -0,0 +1,534 @@
+/*
+ * dpsXpriv.c
+ *
+ * (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: xc/lib/dps/dpsXpriv.c,v 1.7 2002/03/05 21:50:14 herrb Exp $ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+#ifdef GC
+#undef GC
+#endif /* GC */
+
+#ifdef VMS
+/* Xlib does not like UNIX defined to any value under VMS. */
+#undef UNIX
+#include <decw$include/X.h>
+#include <decw$include/Xproto.h>
+#include <decw$include/Xlib.h>
+#include <decw$include/Xutil.h>
+#else /* VMS */
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#endif /* VMS */
+#include "DPS/XDPSlib.h"
+#include "DPS/XDPS.h"
+#include "dpsprivate.h"
+#include "DPS/dpsconfig.h"
+#include "publictypes.h"
+#include "dpsXpriv.h"
+#include "DPS/dpsXclient.h"
+#include "DPS/dpsexcept.h"
+#include "dpsassert.h"
+
+#ifdef ISC
+#include <sys/bsdtypes.h>
+#endif
+
+#ifdef __QNX__
+#include <sys/select.h>
+#endif
+
+#if defined(hpux) || defined(AIXV3)
+#define SELECT_TYPE int *
+#else
+#define SELECT_TYPE fd_set *
+#endif
+
+typedef struct _RegstDPY
+  {
+  Display		*dpy;
+  int			firstEvent;
+  struct _RegstDPY	*next;
+  unsigned char	ctxtTokenType;  /* establish for each context. */
+  unsigned char	prefTokenType;  /* ...of the server. */
+  } RegstDPYRec, *PRegstDPY;
+
+
+/* XDPSContextTimedOut is set to true by the BlockForEvent routine
+   when expected return values are not received within a certain
+   amount of time.  In this case, BlockForEvent will return and the
+   higher callers may take appropriate action to avoid deadlocks. */
+int	XDPSContextTimedOut = false;  /* Unimplemented */
+DPSProcs XDPSconvProcs = NIL;
+DPSProcs XDPSrawProcs = NIL;
+
+/* XDPSQuitBlocking is set to false by the BlockForEvent routine and
+   becomes true if either a zombie status event or an output event
+   is received for the context waiting for return values.  */
+int	XDPSQuitBlocking = false;
+
+
+static DPSClientPrintProc clientPrintProc = NIL;
+static PRegstDPY	   firstDPY = NIL;
+/* operands for "setobjectformat" if we must agree with server. */
+static char		   *format_operands[] = {"1", "2", "3", "4"};
+
+
+
+static PRegstDPY IsRegistered (
+  register Display	*dpy)
+{
+  register PRegstDPY	rdpy;
+  
+  for (rdpy = firstDPY;  rdpy != NIL;  rdpy = rdpy->next)
+    if (rdpy->dpy == dpy)
+      return (rdpy);
+  return (NIL);
+}
+
+
+void XDPSPrivZapDpy(
+  register Display *dpy)
+{
+  register PRegstDPY rdpy, prev = NIL;
+  
+  for (rdpy = firstDPY; rdpy != NIL; prev = rdpy,rdpy = rdpy->next)
+    if (rdpy->dpy == dpy)
+      {
+      if (prev == NIL)
+          firstDPY = rdpy->next;
+      else
+          prev->next = rdpy->next;
+      break;
+      }
+  free(rdpy);
+}
+
+
+/* ARGSUSED */
+static int UsuallyFalse (
+  Display *dpy,
+  XEvent  *event,
+  char    *arg)
+{
+  return((event->type & 0x7F) == X_Error);
+}
+
+void XDPSForceEvents (
+  Display *dpy)
+{
+  XEvent event;
+  
+  while (XCheckIfEvent (dpy, &event, UsuallyFalse, (char *) NULL)) {
+      int (*proc)(Display *, XErrorEvent *) = XSetErrorHandler(NULL);
+      (void) XSetErrorHandler(proc);
+      if (proc != 0 && event.type < 256)
+	      (void)(*proc)(dpy, &event.xerror);
+  }
+}
+
+
+static void OutputEventHandler (
+  register XDPSLOutputEvent *event)
+{
+  PRegstDPY rdpy;
+  register DPSContext ctxt;
+  
+  if ((rdpy = IsRegistered (event->display)) == NIL ||
+      rdpy->firstEvent != event->type)
+    return;
+
+  ctxt = XDPSContextFromXID (event->display, event->cxid);
+  if (ctxt != NIL)
+    {
+    if (ctxt->resultTable != NIL)
+      XDPSQuitBlocking = true;
+    (*clientPrintProc) (ctxt, event->data, event->length);
+    }
+}
+
+
+static int BlockForEvent (
+    Display *dpy)
+{
+    fd_set readfds;
+  
+    XDPSQuitBlocking = false;
+    /* XDPSQuitBlocking becomes true if a zombie status event or
+       any output event is received by the status event handler for
+       the currently-awaiting-results context. */
+    while (1) {
+	FD_SET(ConnectionNumber(dpy), &readfds);
+	if (select (ConnectionNumber(dpy)+1, (SELECT_TYPE) &readfds,
+		    (SELECT_TYPE) NULL, (SELECT_TYPE) NULL,
+		    (struct timeval *) NULL) < 0) {
+	    if (errno == EINTR) {
+		/* Ignore interrupt signals */
+		errno = 0;
+		continue;
+	    }
+	    return (-1);  /* Broken connection (errno == EBADF) */
+	} else {
+	    XDPSForceEvents (dpy);
+	    if (XDPSQuitBlocking) break;
+	    XNoOp(dpy);
+	    /* The noop is necessary to force proper behavior when the
+	       connection goes away - listen carefully! When the dpy
+	       connection is closed, the above select returns indicating
+	       activity on the connection. We call XDPSForceEvents, which
+	       calls XCheckIfEvent, which ultimately may call XFlush
+	       (if there are no events queued). The XNoOp call puts
+	       a message in the outgoing queue, so that XFlush is forced
+	       to write on the connection. When it tries to write, the
+	       error condition will be noted and XIOError will be called,
+	       usually causing the application to terminate. Note that
+	       the error won't happen until the second time thru this
+	       loop, but that's ok. */
+	}
+    }
+    return (0);
+}
+
+
+void XDPSSetContextEncoding (
+  DPSContext	     ctxt,
+  DPSProgramEncoding progEncoding,
+  DPSNameEncoding    nameEncoding) 
+{
+  /* This routine should not be called if ctxt is a text context */
+  
+  if ((nameEncoding != dps_indexed && nameEncoding != dps_strings) ||
+      (progEncoding != dps_ascii && progEncoding != dps_encodedTokens &&
+       progEncoding != dps_binObjSeq))
+    {
+    if (ctxt->errorProc != NIL) 
+      (*ctxt->errorProc) (ctxt, dps_err_encodingCheck,
+			  nameEncoding, progEncoding);
+    return;
+    }
+  else if (progEncoding == dps_ascii || progEncoding == dps_encodedTokens ||
+	   nameEncoding == dps_strings)
+    ctxt->procs = XDPSconvProcs;
+  else
+    ctxt->procs = XDPSrawProcs;
+
+  ctxt->nameEncoding = nameEncoding;
+  ctxt->programEncoding = progEncoding;
+}
+
+
+/* ARGSUSED */
+void DPSDefaultTextBackstop (ctxt, buf, count)
+  DPSContext	    ctxt;
+  char		    *buf;
+  long unsigned int count;
+{
+  if (buf == NULL || count == 0)
+      {
+      (void) fflush(stdout);
+      return;
+      }
+  (void) fwrite (buf, sizeof (char), count, stdout);
+  (void) fflush (stdout);
+}
+
+/* ARGSUSED */
+void DPSInitClient(
+  DPSTextProc	textProc,
+  void		(*releaseProc) (char *, char *))
+{
+  DPSAssert (releaseProc != NIL);
+  XDPSSetProcs ();
+  DPSSetTextBackstop (DPSDefaultTextBackstop);
+  DPSSetErrorBackstop (DPSDefaultErrorProc);
+}
+
+
+DPSNumFormat XDPSNumFormat (
+  Display *dpy)
+{
+  PRegstDPY	rdpy;
+  
+  if ((rdpy = IsRegistered (dpy)) == NIL)
+    return ((DPSNumFormat) -1);
+  else
+    return ((rdpy->ctxtTokenType < DPS_HI_NATIVE) ? dps_ieee : dps_native);
+}
+
+XDPSPrivContext XDPSCreatePrivContextRec (
+  Display		*dpy,
+  Drawable		drawable,
+  GC			gc,
+  int			x,
+  int			y,
+  unsigned int		eventmask,
+  XStandardColormap	*grayramp,
+  XStandardColormap	*ccube,
+  int			actual,
+  int			secure)
+{
+  int			event_base;
+  int			token_type;		/* From server. */
+  char			*num_format_name;	/* From server. */
+  PRegstDPY		rdpy;
+  XDPSPrivContext	wh;
+
+  if (DPSInitialize() != 0) return(NULL);
+  if ((rdpy = IsRegistered (dpy)) == NIL)
+    {
+    /* DPS extension on this dpy? */
+    event_base = XDPSLInit (dpy, &token_type, &num_format_name);
+    if (event_base >= 0 &&
+	(rdpy = (PRegstDPY) calloc (sizeof (RegstDPYRec), 1)))
+      {
+      XDPSLSetTextEventHandler (dpy, (XDPSLEventHandler) OutputEventHandler);
+      XDPSLSetStatusEventHandler (dpy, (XDPSLEventHandler) XDPSStatusEventHandler);
+      XDPSLSetReadyEventHandler (dpy, (XDPSLEventHandler) XDPSReadyEventHandler);
+      XDPSLInitDisplayFlags(dpy);
+      rdpy->dpy = dpy;
+      rdpy->firstEvent = event_base;
+      rdpy->next = firstDPY;
+
+      rdpy->prefTokenType = (unsigned char) token_type;
+      
+      if (strcmp (num_format_name, DPS_FORMATNAME) == 0)
+	rdpy->ctxtTokenType = DPS_DEF_TOKENTYPE;
+      else
+	/* Everybody must talk ieee! */
+#if SWAPBITS
+	rdpy->ctxtTokenType = DPS_LO_IEEE;
+#else /* SWAPBITS */
+	rdpy->ctxtTokenType = DPS_HI_IEEE;
+#endif /* SWAPBITS */
+      
+      firstDPY = rdpy;
+      }
+    else
+      return (NULL);
+    }
+  
+  if ((wh = (XDPSPrivContext) calloc (sizeof (XDPSPrivContextRec), 1)) != 0)
+    {
+    wh->dpy = dpy;
+    wh->drawable = drawable;
+    wh->gc = gc;
+    wh->x = x;
+    wh->y = y;
+    wh->eventmask = eventmask;
+    wh->grayramp = grayramp;
+    wh->ccube = ccube;
+    wh->actual = actual;
+    wh->newObjFormat = format_operands[rdpy->ctxtTokenType - DPS_HI_IEEE];
+    wh->secure = secure;
+    return (wh);
+    }
+  else
+    return (NULL);
+}
+
+
+DPSNumFormat DPSCreatePrivContext (
+  XDPSPrivContext	wh,
+  DPSContext		ctxt,
+  ContextPSID		*cidP,
+  SpaceXID		*sxidP,
+  boolean		newSpace,
+  DPSClientPrintProc	printProc)
+{
+  PRegstDPY		rdpy;
+  
+  if (clientPrintProc == NIL)
+    clientPrintProc = printProc;
+  
+  if ((rdpy = IsRegistered (wh->dpy)) == NIL)
+    return ((DPSNumFormat) -1);
+    
+  if (newSpace || sxidP == NIL)
+    wh->cxid = XDPSLCreateContextAndSpace (wh->dpy, wh->drawable, wh->gc,
+					   wh->x, wh->y, wh->eventmask,
+					   wh->grayramp, wh->ccube,
+					   wh->actual, cidP, sxidP,
+                                           wh->secure); /* L2-DPS/PROTO 9 */
+  else
+    wh->cxid = XDPSLCreateContext (wh->dpy, *sxidP, wh->drawable, wh->gc,
+				   wh->x, wh->y, wh->eventmask,
+				   wh->grayramp, wh->ccube, wh->actual, cidP,
+				   wh->secure); /* L2-DPS/PROTO 9 */
+  if (wh->cxid == None) return((DPSNumFormat) -1);
+  wh->ctxt = ctxt;
+  if (wh->newObjFormat != NIL)
+    {
+    XDPSLGiveInput (wh->dpy, wh->cxid, wh->newObjFormat, 1);
+    XDPSLGiveInput (wh->dpy, wh->cxid, " setobjectformat\n", 17);
+    }
+
+  if (rdpy->ctxtTokenType != DPS_DEF_TOKENTYPE)
+    ctxt->procs = XDPSconvProcs;
+  return ((rdpy->ctxtTokenType < DPS_HI_NATIVE) ? dps_ieee : dps_native);
+}
+
+
+void DPSIncludePrivContext (
+  XDPSPrivContext	wh,
+  DPSContext		ctxt,
+  ContextPSID		cid,
+  SpaceXID		sxid,
+  DPSClientPrintProc	printProc)
+{
+  XDPSPrivContext	newWh;
+  SpaceXID		space;
+  
+  if (clientPrintProc == NIL)
+    clientPrintProc = printProc;
+  
+  newWh = (XDPSPrivContext) calloc (sizeof (XDPSPrivContextRec), 1);
+  if (!newWh) DPSOutOfMemory();
+  *newWh = *wh;
+  if (IsRegistered (wh->dpy) != NIL)
+    {
+    newWh->cxid = XDPSLCreateContextFromID (wh->dpy, cid, &space);
+    DPSAssertWarn (space == sxid, ctxt, "attempting context from context ID from different space");
+    newWh->ctxt = ctxt;
+    /* Did we have to change object format for parent context? */
+    /* Note: the child context must inherit the object format of
+	     its parent.  When this happens in the server there
+	     will be no need for the following code segment. */
+    if (wh->newObjFormat != NIL)   /* Yes, do it for the child too. */
+      {
+      XDPSLGiveInput (wh->dpy, newWh->cxid, wh->newObjFormat, 1);
+      XDPSLGiveInput (wh->dpy, newWh->cxid, " setobjectformat\n", 17);
+      }
+    }
+  else
+    {
+    newWh->cxid = 0;  /* Must not refer to a good context. */
+    newWh->ctxt = NIL;
+    }
+
+  (void) DPSSetWh (ctxt, (char *) newWh);
+}
+
+/* ARGSUSED */
+void DPSSendPostScript (
+  register XDPSPrivContext	wh,
+  DPSClientPrintProc		printProc,
+  ContextPSID			cid,
+  char				*buffer,
+  long int			count,
+  boolean			(*returnControl)(void))
+{
+    boolean blocking = buffer == NIL;
+
+    if (IsRegistered (wh->dpy) == NIL)
+        (*printProc) (wh->ctxt, NIL, 0);
+    else {
+	if (count > 0)
+	    XDPSLGiveInput (wh->dpy, wh->cxid, buffer, count);
+  
+	if (blocking) {
+	    XDPSLFlush (wh->dpy);
+	    if (BlockForEvent (wh->dpy) < 0 && wh->ctxt->errorProc != NIL) {
+		(*(wh->ctxt->errorProc)) (wh->ctxt, dps_err_closedDisplay,
+					  ConnectionNumber(wh->dpy),
+					  0);
+	    }
+	}
+	DPSCheckRaiseError(wh->ctxt);
+    }
+}
+
+
+/* ARGSUSED */
+void DPSSendInterrupt (
+  XDPSPrivContext	wh,
+  ContextPSID		cid,
+  DPSClientPrintProc	printProc)
+{
+  XDPSLNotifyContext (wh->dpy, wh->cxid, PSINTERRUPT);
+}
+
+
+/* ARGSUSED */
+void DPSSendEOF (
+  XDPSPrivContext	wh,
+  ContextPSID		cid,
+  DPSClientPrintProc	printProc)
+{
+  XDPSLReset (wh->dpy, wh->cxid);
+}
+
+
+/* ARGSUSED */
+void DPSSendTerminate (
+  XDPSPrivContext	wh,
+  ContextPSID		cid,
+  DPSClientPrintProc	printProc)
+{
+  XDPSLNotifyContext (wh->dpy, wh->cxid, PSKILL);
+}
+
+
+void XDPSSendUnfreeze (
+  Display    *dpy,
+  ContextXID cxid)
+{
+  XDPSLNotifyContext (dpy, cxid, PSUNFREEZE);
+}
+
+
+/* ARGSUSED */
+void DPSSendDestroySpace(
+  XDPSPrivContext	wh,
+  SpaceXID		sxid,
+  DPSClientPrintProc	printProc)
+{
+  XDPSLDestroySpace (wh->dpy, sxid);
+}
+
+
+void DPSOutOfMemory (void)
+{
+  DPSFatalProc(NULL, "DPS Client Library Error:  Out of memory.\n");
+  exit (1);
+}
diff --git a/nx-X11/lib/dps/dpsXpriv.h b/nx-X11/lib/dps/dpsXpriv.h
new file mode 100644
index 000000000..56b25b757
--- /dev/null
+++ b/nx-X11/lib/dps/dpsXpriv.h
@@ -0,0 +1,187 @@
+/*
+ * dpsXpriv.h -- client lib internal impl interface for the X version
+ *
+ * (c) Copyright 1989-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
+ */
+
+#ifndef DPSXPRIVATE_H
+#define DPSXPRIVATE_H
+
+#ifdef VMS
+#include <decw$include/X.h>
+#include <decw$include/Xlib.h>
+#include <decw$include/Xutil.h>
+#else /* VMS */
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#endif /* VMS */
+
+#include <DPS/XDPSlib.h>
+#include "DPS/dpsclient.h"
+#include "dpsprivate.h"
+#include "DPS/dpsXclient.h"
+#include "publictypes.h"
+
+/* typedefs */
+
+typedef struct _t_XDPSPrivContextRec
+  {
+  Display		*dpy;
+  Drawable		drawable;
+  GC			gc;
+  int			x;
+  int			y;
+  unsigned int		eventmask;
+  XStandardColormap	*grayramp;
+  XStandardColormap	*ccube;
+  int			actual;
+  DPSContext		ctxt;	/* Points back to its context */
+  ContextXID		cxid;
+  char			*newObjFormat;	/* This is the object format that a */
+					/* new context must use for sending */
+					/* BOS's to the client.  If the     */
+					/* server and client have the same  */
+					/* number formats then this will be */
+					/* null.			    */
+  int			secure;
+  } XDPSPrivContextRec, *XDPSPrivContext;
+
+
+extern DPSProcs XDPSconvProcs;
+extern DPSProcs XDPSrawProcs;
+extern int	XDPSQuitBlocking;
+
+
+extern XDPSPrivContext XDPSCreatePrivContextRec (
+  Display	    * /* dpy */,
+  Drawable	      /* drawable */,
+  GC		      /* gc */,
+  int		      /* x */,
+  int		      /* y */,
+  unsigned int	      /* eventmask */,
+  XStandardColormap * /* grayramp */,
+  XStandardColormap * /* ccube */,
+  int		      /* actual */,
+  int		      /* secure */);
+  
+  /* See if dpy supports the DPS extension.  If not, return NULL.  If so,
+     it sets up a private context object that is used for creating
+     contexts and spaces. */
+
+extern DPSNumFormat DPSCreatePrivContext(
+  XDPSPrivContext	/* wh */,
+  DPSContext		/* ctxt */,
+  ContextPSID *		/* cidP */,
+  SpaceXID *		/* sxidP */,
+  boolean		/* newSpace */,
+  DPSClientPrintProc	/* printProc */);
+  /* returns -1 if server can't create the context */
+
+extern void DPSIncludePrivContext(
+  XDPSPrivContext	/* wh */,
+  DPSContext		/* ctxt */,
+  ContextPSID		/* cid */,
+  SpaceXID		/* sxid */,
+  DPSClientPrintProc	/* printProc */);
+
+extern void DPSSendPostScript(
+  XDPSPrivContext	/* wh */,
+  DPSClientPrintProc	/* printProc */,
+  ContextPSID		/* cid */,
+  char			* /* buffer */,
+  long int		/* count */,
+  boolean		(* /* returnControl */)(void));
+
+extern void DPSSendInterrupt(
+  XDPSPrivContext	/* wh */,
+  ContextPSID		/* cid */,
+  DPSClientPrintProc	/* printProc */);
+
+extern void DPSSendEOF(
+  XDPSPrivContext	/* wh */,
+  ContextPSID		/* cid */,
+  DPSClientPrintProc	/* printProc */);
+
+extern void DPSSendTerminate(
+  XDPSPrivContext	/* wh */,
+  ContextPSID		/* cid */,
+  DPSClientPrintProc	/* printProc */);
+
+extern void XDPSPrivZapDpy(
+  Display *		/* dpy */);
+
+extern DPSNumFormat XDPSNumFormat (Display * /* dpy */);
+
+  /* Determine the number format for server over the "dpy" connection. */
+
+extern void XDPSSetProcs (void);
+
+  /* Set pointers to raw and conversion context procs. */
+
+extern void XDPSSetContextEncoding (
+  DPSContext /* ctxt */,
+  DPSProgramEncoding /* progEncoding */,
+  DPSNameEncoding /* nameEncoding */);
+  
+  /* Sets context's program and name encodings to new values. */
+
+extern void XDPSStatusEventHandler (XDPSLStatusEvent * /* event */);
+
+  /* Is registered with Xlib and is called when a dps status event is
+     received.  It determines what context the event belongs to and,
+     if that context has a status event handler, calls its handler
+     passing it the status type. */
+
+extern void XDPSReadyEventHandler (XDPSLReadyEvent * /* event */);
+
+  /* Is registered with Xlib and is called when a dps ready event is
+     received.  It determines what context the event belongs to and,
+     if that context has a status event handler, calls its handler
+     passing it the ready data. */
+
+extern void XDPSForceEvents (Display * /* dpy */);
+
+  /* Forces processing of events that are pending over the 'dpy'
+     connection.  This causes DPS events to be handled by their handlers. */
+
+extern void XDPSSendUnfreeze (Display * /* dpy */, ContextXID /* cxid */);
+
+extern void DPSSendDestroySpace(
+		XDPSPrivContext /* wh */,
+		SpaceXID /* sxid */,
+		DPSClientPrintProc /* printProc */);
+
+#endif /* DPSXPRIVATE_H */
diff --git a/nx-X11/lib/dps/dpsXtdisp.c b/nx-X11/lib/dps/dpsXtdisp.c
new file mode 100644
index 000000000..d778a3245
--- /dev/null
+++ b/nx-X11/lib/dps/dpsXtdisp.c
@@ -0,0 +1,109 @@
+/*
+ * dpsXtdisp.c
+ *
+ * (c) Copyright 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
+ */
+
+#include <X11/Intrinsic.h>
+
+#if XtSpecificationRelease < 6
+
+#include "dpsassert.h"
+
+void XDPSSetXtEventDispatching(Display *dpy)
+{
+    DPSFatalProc(NULL, "Attempt to use XDPSSetXtEventDispatching with pre-R6 Intrinsics\n");
+    exit(1);
+}
+
+#else
+
+#include <DPS/XDPSlib.h>
+#include <DPS/dpsXclient.h>
+
+typedef struct _DpyProcRec {
+    Display *dpy;
+    XtEventDispatchProc oldproc;
+    struct _DpyProcRec *next;
+} DpyProcRec;
+
+static DpyProcRec *dpyProcList = NULL;
+
+static Boolean NXDispatcher(XEvent *event)
+{
+    DpyProcRec *d;
+
+    if (XDPSDispatchEvent(event)) return True;
+
+    for (d = dpyProcList; d != NULL && d->dpy != event->xany.display;
+	 d = d->next) {}
+    if (d != NULL) return (*(d->oldproc))(event);
+    else return False;
+}
+	
+void XDPSSetXtEventDispatching(Display *dpy)
+{
+    int codes;
+    XExtCodes *c;
+
+    codes = XDPSLInit(dpy, (int *) NULL, (char **) NULL);
+
+    if (codes == -1) return; 	/* No extension or NX, so nothing to do */
+    else {
+	(void) XDPSSetEventDelivery(dpy, dps_event_pass_through);
+	c = XDPSLGetCodes(dpy);
+
+	/* First check for NX */
+	if (!c->first_event) {
+	    DpyProcRec *d = XtNew(DpyProcRec);
+	    d->dpy = dpy;
+	    d->next = dpyProcList;
+	    d->oldproc =
+		    XtSetEventDispatcher(dpy, ClientMessage, NXDispatcher);
+	    dpyProcList = d;
+
+	} else {
+	    /* Extension */
+	    (void) XtSetEventDispatcher(dpy, c->first_event + PSEVENTSTATUS,
+				(XtEventDispatchProc) XDPSDispatchEvent);
+	    (void) XtSetEventDispatcher(dpy, c->first_event + PSEVENTOUTPUT,
+				(XtEventDispatchProc) XDPSDispatchEvent);
+	    (void) XtSetEventDispatcher(dpy, c->first_event + PSEVENTREADY,
+				(XtEventDispatchProc) XDPSDispatchEvent);
+	}
+    }
+}
+
+#endif
diff --git a/nx-X11/lib/dps/dpsabbrev.c b/nx-X11/lib/dps/dpsabbrev.c
new file mode 100644
index 000000000..20b3ef713
--- /dev/null
+++ b/nx-X11/lib/dps/dpsabbrev.c
@@ -0,0 +1,360 @@
+/*
+ * dpsabbrev.c -- Implementation of Client Library abbrev mode
+ *
+ * (c) Copyright 1993-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 <string.h>
+#include "publictypes.h"
+#include "DPS/dpsclient.h"
+#include "dpsprivate.h"
+
+static DPSAbbrevRec abbrev[] = {
+    {1, "add", "!+"},
+    {10, "ashow", "!a"}, 
+    {12, "awidthshow", "!A"}, 
+    {13, "begin", "!B"}, 
+    {14, "bind", "!b"}, 
+    {20, "clip", "!CL"}, 
+    {22, "closepath", "!c"}, 
+    {23, "concat", "!CC"}, 
+    {25, "copy", "!CP"},
+    {39, "currentmatrix", "!CM"}, 
+    {40, "currentpoint", "!Cp"}, 
+    {43, "curveto", "!C"}, 
+    {51, "def", "!D"},
+    {53, "dict", "!d"},
+    {62, "exch", "!E"}, 
+    {63, "exec", "!e"}, 
+    {66, "fill", "!F"}, 
+    {67, "findfont", "!f"}, 
+    {77, "grestore", "!G"}, 
+    {78, "gsave", "!g"}, 
+    {85, "ifelse", "!I"}, 
+    {88, "index", "!i"}, 
+    {98, "length", "!LE"}, 
+    {99, "lineto", "!L"},
+    {100, "load", "!l"},
+    {103, "makefont", "!MF"}, 
+    {104, "matrix", "!m"}, 
+    {107, "moveto", "!M"}, 
+    {111, "newpath", "!N"}, 
+    {113, "null", "!n"},
+    {117, "pop", "!p"},
+    {122, "rcurveto", "!RC"}, 
+    {127, "rectclip", "!R"}, 
+    {128, "rectfill", "!RF"}, 
+    {129, "rectstroke", "!RS"}, 
+    {131, "repeat", "!RP"}, 
+    {132, "restore", "!Rs"}, 
+    {133, "rlineto", "!r"}, 
+    {134, "rmoveto", "!RM"}, 
+    {135, "roll", "!RL"}, 
+    {136, "rotate", "!RO"}, 
+    {137, "round", "!RN"}, 
+    {138, "save", "!SV"}, 
+    {139, "scale", "!SC"}, 
+    {140, "scalefont", "!SF"}, 
+    {142, "selectfont", "!s"}, 
+    {147, "setcmykcolor", "!Sc"}, 
+    {148, "setdash", "!SD"}, 
+    {149, "setfont", "!Sf"}, 
+    {150, "setgray", "!Sg"}, 
+    {152, "sethsbcolor", "!Sh"}, 
+    {153, "setlinecap", "!SL"}, 
+    {154, "setlinejoin", "!SJ"}, 
+    {155, "setlinewidth", "!SW"}, 
+    {156, "setmatrix", "!SM"}, 
+    {157, "setrgbcolor", "!Sr"}, 
+    {158, "setshared", "!SS"}, 
+    {160, "show", "!S"}, 
+    {161, "showpage", "!SP"}, 
+    {167, "stroke", "!ST"}, 
+    {170, "systemdict", "!Sd"}, 
+    {173, "translate", "!T"}, 
+    {182, "userdict", "!u"}, 
+    {186, "where", "!w"}, 
+    {187, "widthshow", "!W"}, 
+    {194, "xshow", "!X"}, 
+    {195, "xyshow", "!x"}, 
+    {196, "yshow", "!Y"}, 
+};
+
+static short abbrevPtr[] = {
+    -1,	/* 0 */
+    0,	/* 1 */
+    -1,	/* 2 */
+    -1,	/* 3 */
+    -1,	/* 4 */
+    -1,	/* 5 */
+    -1,	/* 6 */
+    -1,	/* 7 */
+    -1,	/* 8 */
+    -1,	/* 9 */
+    1,	/* 10 */
+    -1,	/* 11 */
+    2,	/* 12 */
+    3,	/* 13 */
+    4,	/* 14 */
+    -1,	/* 15 */
+    -1,	/* 16 */
+    -1,	/* 17 */
+    -1,	/* 18 */
+    -1,	/* 19 */
+    5,	/* 20 */
+    -1,	/* 21 */
+    6,	/* 22 */
+    7,	/* 23 */
+    -1,	/* 24 */
+    8,	/* 25 */
+    -1,	/* 26 */
+    -1,	/* 27 */
+    -1,	/* 28 */
+    -1,	/* 29 */
+    -1,	/* 30 */
+    -1,	/* 31 */
+    -1,	/* 32 */
+    -1,	/* 33 */
+    -1,	/* 34 */
+    -1,	/* 35 */
+    -1,	/* 36 */
+    -1,	/* 37 */
+    -1,	/* 38 */
+    9,	/* 39 */
+    10,	/* 40 */
+    -1,	/* 41 */
+    -1,	/* 42 */
+    11,	/* 43 */
+    -1,	/* 44 */
+    -1,	/* 45 */
+    -1,	/* 46 */
+    -1,	/* 47 */
+    -1,	/* 48 */
+    -1,	/* 49 */
+    -1,	/* 50 */
+    12,	/* 51 */
+    -1,	/* 52 */
+    13,	/* 53 */
+    -1,	/* 54 */
+    -1,	/* 55 */
+    -1,	/* 56 */
+    -1,	/* 57 */
+    -1,	/* 58 */
+    -1,	/* 59 */
+    -1,	/* 60 */
+    -1,	/* 61 */
+    14,	/* 62 */
+    15,	/* 63 */
+    -1,	/* 64 */
+    -1,	/* 65 */
+    16,	/* 66 */
+    17,	/* 67 */
+    -1,	/* 68 */
+    -1,	/* 69 */
+    -1,	/* 70 */
+    -1,	/* 71 */
+    -1,	/* 72 */
+    -1,	/* 73 */
+    -1,	/* 74 */
+    -1,	/* 75 */
+    -1,	/* 76 */
+    18,	/* 77 */
+    19,	/* 78 */
+    -1,	/* 79 */
+    -1,	/* 80 */
+    -1,	/* 81 */
+    -1,	/* 82 */
+    -1,	/* 83 */
+    -1,	/* 84 */
+    20,	/* 85 */
+    -1,	/* 86 */
+    -1,	/* 87 */
+    21,	/* 88 */
+    -1,	/* 89 */
+    -1,	/* 90 */
+    -1,	/* 91 */
+    -1,	/* 92 */
+    -1,	/* 93 */
+    -1,	/* 94 */
+    -1,	/* 95 */
+    -1,	/* 96 */
+    -1,	/* 97 */
+    22,	/* 98 */
+    23,	/* 99 */
+    24,	/* 100 */
+    -1,	/* 101 */
+    -1,	/* 102 */
+    25,	/* 103 */
+    26,	/* 104 */
+    -1,	/* 105 */
+    -1,	/* 106 */
+    27,	/* 107 */
+    -1,	/* 108 */
+    -1,	/* 109 */
+    -1,	/* 110 */
+    28,	/* 111 */
+    -1,	/* 112 */
+    29,	/* 113 */
+    -1,	/* 114 */
+    -1,	/* 115 */
+    -1,	/* 116 */
+    30,	/* 117 */
+    -1,	/* 118 */
+    -1,	/* 119 */
+    -1,	/* 120 */
+    -1,	/* 121 */
+    31,	/* 122 */
+    -1,	/* 123 */
+    -1,	/* 124 */
+    -1,	/* 125 */
+    -1,	/* 126 */
+    32,	/* 127 */
+    33,	/* 128 */
+    34,	/* 129 */
+    -1,	/* 130 */
+    35,	/* 131 */
+    36,	/* 132 */
+    37,	/* 133 */
+    38,	/* 134 */
+    39,	/* 135 */
+    40,	/* 136 */
+    41,	/* 137 */
+    42,	/* 138 */
+    43,	/* 139 */
+    44,	/* 140 */
+    -1,	/* 141 */
+    45,	/* 142 */
+    -1,	/* 143 */
+    -1,	/* 144 */
+    -1,	/* 145 */
+    -1,	/* 146 */
+    46,	/* 147 */
+    47,	/* 148 */
+    48,	/* 149 */
+    49,	/* 150 */
+    -1,	/* 151 */
+    50,	/* 152 */
+    51,	/* 153 */
+    52,	/* 154 */
+    53,	/* 155 */
+    54,	/* 156 */
+    55,	/* 157 */
+    56,	/* 158 */
+    -1,	/* 159 */
+    57,	/* 160 */
+    58,	/* 161 */
+    -1,	/* 162 */
+    -1,	/* 163 */
+    -1,	/* 164 */
+    -1,	/* 165 */
+    -1,	/* 166 */
+    59,	/* 167 */
+    -1,	/* 168 */
+    -1,	/* 169 */
+    60,	/* 170 */
+    -1,	/* 171 */
+    -1,	/* 172 */
+    61,	/* 173 */
+    -1,	/* 174 */
+    -1,	/* 175 */
+    -1,	/* 176 */
+    -1,	/* 177 */
+    -1,	/* 178 */
+    -1,	/* 179 */
+    -1,	/* 180 */
+    -1,	/* 181 */
+    62,	/* 182 */
+    -1,	/* 183 */
+    -1,	/* 184 */
+    -1,	/* 185 */
+    63,	/* 186 */
+    64,	/* 187 */
+    -1,	/* 188 */
+    -1,	/* 189 */
+    -1,	/* 190 */
+    -1,	/* 191 */
+    -1,	/* 192 */
+    -1,	/* 193 */
+    65,	/* 194 */
+    66,	/* 195 */
+    67,	/* 196 */
+    -1,	/* 197 */
+    -1,	/* 198 */
+    -1,	/* 199 */
+    -1,	/* 200 */
+    -1,	/* 201 */
+    -1,	/* 202 */
+    -1,	/* 203 */
+    -1,	/* 204 */
+    -1,	/* 205 */
+    -1,	/* 206 */
+    -1,	/* 207 */
+    -1,	/* 208 */
+    -1,	/* 209 */
+    -1,	/* 210 */
+    -1,	/* 211 */
+};
+
+void DPSFetchAbbrevList(DPSAbbrevRec **list, int *count)
+{
+    *list = abbrev;
+    *count = sizeof(abbrev) / sizeof(abbrev[0]);
+}
+
+char *DPSGetSysnameAbbrev(int n)
+{
+    if ((unsigned) n > sizeof(abbrevPtr) / sizeof(abbrevPtr[0])) return NULL;
+    if (abbrevPtr[n] == -1) return NULL;
+    return abbrev[abbrevPtr[n]].abbrev;
+}
+
+char *DPSGetOperatorAbbrev(char *op)
+{
+    int min, max, n;
+    int res;
+
+    min = 0;
+    max = sizeof(abbrev) / sizeof(abbrev[0]) - 1;
+
+    while (min <= max) {
+	n = (max + min) / 2;
+	res = strcmp(op, abbrev[n].operatorName);
+	if (res == 0) return abbrev[n].abbrev;
+	if (res < 0) max = n - 1;
+	if (res > 0) min = n + 1;
+    }
+    return NULL;
+}
diff --git a/nx-X11/lib/dps/dpsassert.h b/nx-X11/lib/dps/dpsassert.h
new file mode 100644
index 000000000..00632a111
--- /dev/null
+++ b/nx-X11/lib/dps/dpsassert.h
@@ -0,0 +1,57 @@
+/*
+ * dpsassert.h
+ *
+ * (c) Copyright 1991-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
+ */
+
+#ifndef DPSASSERT_H
+#define DPSASSERT_H
+
+#include "DPS/dpsclient.h"
+
+#define DPSAssertWarn(cndtn, cntxt, mssg)\
+	if (!(cndtn)) DPSWarnProc((DPSContext)(cntxt),(mssg))
+
+extern void DPSWarnProc(DPSContext ctxt, char *msg);
+extern void DPSFatalProc(DPSContext ctxt, char *msg);
+extern void DPSCantHappen(void);
+
+#define DPSAssert(condition) \
+  if (! (condition)) DPSCantHappen();
+/* Tests whether the specified condition is true and aborts the
+   entire application if not.
+ */
+
+#endif /* DPSASSERT_H */
diff --git a/nx-X11/lib/dps/dpsclient.c b/nx-X11/lib/dps/dpsclient.c
new file mode 100644
index 000000000..c75d76ce8
--- /dev/null
+++ b/nx-X11/lib/dps/dpsclient.c
@@ -0,0 +1,2969 @@
+/*
+ * dpsclient.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 <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "dpsXpriv.h"
+#include "DPS/dpsclient.h"
+#include "dpsprivate.h"
+#include "dpsdict.h"
+#include "DPS/dpsexcept.h"
+#include "dpsassert.h"
+
+#ifdef XDPS
+#include "dpsXint.h"
+#endif /* XDPS */
+
+#if defined(SVR4) || defined(SYSV) || defined(SystemV)
+#define os_bcopy(f,t,c) memcpy(t,f,c)
+#else
+#define os_bcopy(f,t,c) bcopy(f,t,c)
+#endif
+
+#if !IEEEFLOAT
+extern void IEEEHighToNative(/* FloatRep *from, real *to */);
+/* Converts from IEEE high-byte-first real to native real. */
+
+extern void NativeToIEEEHigh(/* real *from, FloatRep *to */);
+/* Converts from native real to IEEE high-byte-first real. */
+
+extern void IEEELowToNative(/* FloatRep *from, real *to */);
+/* Converts from IEEE low-byte-first real to native real. */
+
+extern void NativeToIEEELow(/* real *from, FloatRep *to */);
+/* Converts from native real to IEEE low-byte-first real. */
+#endif /* !IEEEFLOAT */
+
+typedef union { /* 32 bit number representations */
+  unsigned int u;
+  int i;
+  float f;
+  unsigned char bytes[4];
+    /* raw bytes, in whatever order they appear in memory */
+  } Swap32Rec;
+
+typedef union { /* 16 bit number representations */
+  unsigned short u;
+  short i;
+  unsigned char bytes[2];
+  } Swap16Rec;
+ 
+#if SWAPBITS
+#define Copy4SrcLo(src, dst)\
+  (((Swap32Rec *) dst)->bytes[0] = ((Swap32Rec *) src)->bytes[0], \
+   ((Swap32Rec *) dst)->bytes[1] = ((Swap32Rec *) src)->bytes[1], \
+   ((Swap32Rec *) dst)->bytes[2] = ((Swap32Rec *) src)->bytes[2], \
+   ((Swap32Rec *) dst)->bytes[3] = ((Swap32Rec *) src)->bytes[3] )
+#define Copy4SrcHi(src, dst)\
+  (((Swap32Rec *) dst)->bytes[0] = ((Swap32Rec *) src)->bytes[3], \
+   ((Swap32Rec *) dst)->bytes[1] = ((Swap32Rec *) src)->bytes[2], \
+   ((Swap32Rec *) dst)->bytes[2] = ((Swap32Rec *) src)->bytes[1], \
+   ((Swap32Rec *) dst)->bytes[3] = ((Swap32Rec *) src)->bytes[0] )
+#define Copy2SrcLo(src, dst)\
+  (((Swap16Rec *) dst)->bytes[0] = ((Swap16Rec *) src)->bytes[0], \
+   ((Swap16Rec *) dst)->bytes[1] = ((Swap16Rec *) src)->bytes[1] )
+#define Copy2SrcHi(src, dst)\
+  (((Swap16Rec *) dst)->bytes[0] = ((Swap16Rec *) src)->bytes[1], \
+   ((Swap16Rec *) dst)->bytes[1] = ((Swap16Rec *) src)->bytes[0] )
+#else /* SWAPBITS */
+#define Copy4SrcHi(src, dst)\
+  (((Swap32Rec *) dst)->bytes[0] = ((Swap32Rec *) src)->bytes[0], \
+   ((Swap32Rec *) dst)->bytes[1] = ((Swap32Rec *) src)->bytes[1], \
+   ((Swap32Rec *) dst)->bytes[2] = ((Swap32Rec *) src)->bytes[2], \
+   ((Swap32Rec *) dst)->bytes[3] = ((Swap32Rec *) src)->bytes[3] )
+#define Copy4SrcLo(src, dst)\
+  (((Swap32Rec *) dst)->bytes[0] = ((Swap32Rec *) src)->bytes[3], \
+   ((Swap32Rec *) dst)->bytes[1] = ((Swap32Rec *) src)->bytes[2], \
+   ((Swap32Rec *) dst)->bytes[2] = ((Swap32Rec *) src)->bytes[1], \
+   ((Swap32Rec *) dst)->bytes[3] = ((Swap32Rec *) src)->bytes[0] )
+#define Copy2SrcHi(src, dst)\
+  (((Swap16Rec *) dst)->bytes[0] = ((Swap16Rec *) src)->bytes[0], \
+   ((Swap16Rec *) dst)->bytes[1] = ((Swap16Rec *) src)->bytes[1] )
+#define Copy2SrcLo(src, dst)\
+  (((Swap16Rec *) dst)->bytes[0] = ((Swap16Rec *) src)->bytes[1], \
+   ((Swap16Rec *) dst)->bytes[1] = ((Swap16Rec *) src)->bytes[0] )
+#endif /* SWAPBITS */
+ 
+
+#define DPS_ERR_TAG 250
+
+#define CONTEXTBUFFERSIZE 256
+#define MAXQUEUEDBUFFERS 5
+
+DPSContext DPSGlobalContext;
+  
+Globals DPSglobals = NULL;
+
+char *DPScalloc(integer e, integer n)
+{
+  char *p;
+  while (!(p = (char *)calloc(e, n))) {
+    DPSOutOfMemory();
+    }
+  return p;
+}
+
+
+
+void DPSSafeSetLastNameIndex(DPSContext ctxt)
+{
+  /* we're about to call the error handler, so roll back the
+     lastNameIndex to the last known valid index */
+  DPSCheckInitClientGlobals();
+  if (ctxt != dummyCtx && ctxt->space != NIL)
+    ((DPSPrivContext)ctxt)->lastNameIndex = ((DPSPrivSpace)(ctxt->space))->lastNameIndex;
+}
+
+void DPSCheckInitClientGlobals(void)
+{
+  if (!DPSglobals) {
+    DPSglobals = (Globals)DPScalloc(sizeof(GlobalsRec), 1);
+    globLastNameIndex = -1;
+    }
+}
+
+/**************************************************************/
+/* Procedures that support the DPSCreateContext context procs */
+/**************************************************************/
+
+/* ARGSUSED */
+static void ReleaseInput(
+  char *unused, char *buffer)
+{
+  ContextBuffer cb = (ContextBuffer)buffer;
+  if (cb == NIL) return;
+  cb->next = contextBuffers;
+  contextBuffers = cb;
+  queuedBuffers--;
+}
+
+/* ARGSUSED */
+static void StuffResultVal(
+  DPSContext ctxt,
+  DPSResults result,
+  integer tag,
+  DPSBinObj obj)
+{
+
+  integer type = obj->attributedType & ~DPS_EXEC;
+  integer nObjs = 1;
+
+  /* check if array */
+  if (type == DPS_ARRAY) {
+    nObjs = obj->length;
+    if (nObjs < 1) return;
+    if (result->count == -1 && nObjs != 1) {
+      DPSSafeSetLastNameIndex(ctxt);
+      if (ctxt->errorProc != NIL)
+	(*ctxt->errorProc)(ctxt, dps_err_resultTypeCheck, (long unsigned)obj, 0);
+      return;
+      }
+    obj = (DPSBinObj) ((char *)obj + obj->val.arrayVal);
+    type = obj->attributedType & ~DPS_EXEC;
+    }
+
+  do {
+    integer bump = 0;
+    if (result->count == 0) return;
+    switch (result->type) {
+      case dps_tBoolean:
+	if (type == DPS_BOOL) {
+	  int *b = (int *) result->value;
+	  *b = (int) obj->val.booleanVal;
+	  bump = sizeof(int);
+	  }
+	break;
+      case dps_tFloat: {
+	float *f = (float *) result->value;
+	if (type == DPS_REAL) {
+	  *f = obj->val.realVal;
+	  bump = sizeof(float);
+	  }
+	else if (type == DPS_INT) {
+	  *f = (float) obj->val.integerVal;
+	  bump = sizeof(float);
+	  }
+	break;
+	}
+      case dps_tDouble: {
+	double *d = (double *) result->value;
+	if (type == DPS_REAL) {
+	  *d = (double) obj->val.realVal;
+	  bump = sizeof(double);
+	  }
+	else if (type == DPS_INT) {
+	  *d = (double) obj->val.integerVal;
+	  bump = sizeof(double);
+	  }
+	break;
+	}
+      case dps_tShort:
+	if (type == DPS_INT) {
+	  short *s = (short *) result->value;
+	  *s = (short) obj->val.integerVal;
+	  bump = sizeof(short);
+	  }
+	break;
+      case dps_tUShort:
+	if (type == DPS_INT) {
+	  unsigned short *us = (unsigned short *) result->value;
+	  *us = (unsigned short) obj->val.integerVal;
+	  bump = sizeof(unsigned short);
+	  }
+	break;
+      case dps_tInt:
+	if (type == DPS_INT) {
+	  int *i = (int *) result->value;
+	  *i = (int) obj->val.integerVal;
+	  bump = sizeof(int);
+	  }
+	break;
+      case dps_tUInt:
+	if (type == DPS_INT) {
+	  unsigned int *ui = (unsigned int *) result->value;
+	  *ui = (unsigned int) obj->val.integerVal;
+	  bump = sizeof(unsigned int);
+	  }
+	break;
+      case dps_tLong:
+	if (type == DPS_INT) {
+	  long int *li = (long int *) result->value;
+	  *li = obj->val.integerVal;
+	  bump = sizeof(long int);
+	  }
+	break;
+      case dps_tULong:
+	if (type == DPS_INT) {
+	  unsigned long *u = (unsigned long *) result->value;
+	  *u = (unsigned long) obj->val.integerVal;
+	  bump = sizeof(unsigned long);
+	  }
+	break;
+      case dps_tChar:
+      case dps_tUChar:
+	if (nObjs != 1) {
+	  DPSSafeSetLastNameIndex(ctxt);
+	  if (ctxt->errorProc != NIL)
+	    (*ctxt->errorProc)(ctxt, dps_err_resultTypeCheck, (long unsigned)obj, 0);
+	  }
+	else if (type == DPS_STRING) {
+	  if (result->count == -1) {
+	    /* char * result, copy first, ignore subsequent, null terminate */
+	    os_bcopy(((integer)(obj->val.stringVal)) + (char *)obj,
+		     result->value, obj->length);
+	    (result->value)[obj->length] = '\0';
+	    result->count = 0;
+	    }
+	  else {
+	    unsigned slen;
+	    if (result->count >= (int) obj->length) {
+	      /* copy entire string into char array */
+	      slen = obj->length;
+	      }
+	    else if (result->count > 0) {
+	      /* copy partial string into char array */
+	      slen = result->count;
+	      }
+	    else return;  /* ignore string result, no room left */
+	    os_bcopy(((integer)(obj->val.stringVal)) + (char *)obj,
+		     result->value, slen);
+	    result->value += slen;
+	    result->count -= slen;
+	    }
+	  return;
+	  }
+	break;
+
+      default:
+	DPSSafeSetLastNameIndex(ctxt);
+	if (ctxt->errorProc != NIL)
+	  (*ctxt->errorProc)(ctxt, dps_err_resultTypeCheck, (long unsigned)obj, 0);
+      } /* switch (result->type) */
+
+    if (bump == 0) {
+      DPSSafeSetLastNameIndex(ctxt);
+      if (ctxt->errorProc != NIL)
+	(*ctxt->errorProc)(ctxt, dps_err_resultTypeCheck, (long unsigned)obj, 0);
+      return;
+      }
+    if (result->count != -1) {
+      result->count--;
+      result->value += bump;
+      }
+    obj += 1;
+    nObjs--;
+    } while (nObjs > 0); /* do */
+
+} /* StuffResultVal */
+
+
+static void NumFormatFromTokenType(
+  unsigned char t,
+  DPSNumFormat *numFormat)
+{
+  switch (t) {
+    case DPS_HI_IEEE:
+      *numFormat = dps_ieee;
+      break;
+    case DPS_LO_IEEE:
+      *numFormat = dps_ieee;
+      break;
+    case DPS_HI_NATIVE:
+      *numFormat = dps_native;
+      break;
+    case DPS_LO_NATIVE:
+      *numFormat = dps_native;
+      break;
+    default: DPSCantHappen();
+    }
+}
+ 
+
+#if !IEEEFLOAT
+/* called to deal with results from the server */
+static void ConvSeqInPlace(nObjs, currObj, base, tokenType)
+  integer nObjs;
+  DPSBinObj currObj;
+  char *base;
+  unsigned char tokenType;
+{
+  DPSNumFormat numFormat;
+  
+  NumFormatFromTokenType(tokenType, &numFormat);
+  
+  while (nObjs--) {
+    unsigned char t = currObj->attributedType & 0x07f;
+    integer i;
+    switch (t) {
+      case DPS_REAL: {
+	float f;
+	if (numFormat == dps_ieee) {
+	  if (DPSDefaultByteOrder == dps_hiFirst)
+	    IEEEHighToNative(&currObj->val.realVal, &f);
+	  else
+	    IEEELowToNative(&currObj->val.realVal, &f);
+	  }
+	else break; /* switch */
+	currObj->val.realVal = f;
+	break;
+	}
+      case DPS_ARRAY:
+	if (currObj->length > 0)
+	  ConvSeqInPlace(currObj->length, (DPSBinObj)(base + currObj->val.arrayVal), base, tokenType);
+	break;
+      case DPS_NAME:
+      case DPS_STRING:
+	break;
+      default:;
+      } /* end switch */
+    ++currObj;
+    } /* end while */
+}
+#endif /* !IEEEFLOAT */
+  
+boolean DPSKnownContext(DPSContext ctxt)
+{
+  DPSPrivContext cc, c = (DPSPrivContext) ctxt;
+  DPSPrivSpace ss;
+  for (ss = spaces; ss != NIL; ss = ss->next)
+    for (cc = ss->firstContext; cc != NIL; cc = cc->next)
+      if (cc == c) return true;
+  return false;
+}
+
+boolean DPSKnownSpace(DPSSpace space)
+{
+  DPSPrivSpace ss, s = (DPSPrivSpace) space;
+  for (ss = spaces; ss != NIL; ss = ss->next)
+    if (ss == s) return true;
+  return false;
+}
+
+void DPSclientPrintProc (
+  DPSContext ctxt,
+  char	     *buf,
+  unsigned    nch)
+{
+  DPSPrivContext cc = (DPSPrivContext) ctxt;
+
+#define DPS_SEQ_MIN 2
+
+  DPSCheckInitClientGlobals();
+  if (cc == NIL) cc = (DPSPrivContext)dummyCtx;
+  if (cc == NIL) return;
+  
+  if (nch == 0) { /* this is an EOF */
+    DPSAssertWarn(buf == NIL, cc, "non-nil output buffer with 0 length");
+    cc->eofReceived = true;
+    if (cc->objBuf) {
+      /* we were buffering; drop buffered chars on the floor */
+      free(cc->objBuf);
+      cc->objBuf = NIL;
+      cc->nObjBufChars = 0;
+      }
+    }
+  while (nch > 0) {
+    char *oldBuf = NIL;
+    unsigned oldNch = 0;
+    unsigned n;
+    if (cc->objBuf) { /* we're buffering */
+      unsigned long int m;
+      char *b = cc->objBuf + cc->nObjBufChars;
+      integer minSize;
+      while (cc->nObjBufChars < DPS_SEQ_MIN) {
+	if (nch == 0) return;
+	*b++ = *buf++;
+	++cc->nObjBufChars;
+	--nch;
+	}
+      b = cc->objBuf;
+      minSize = (*(b+1) == 0) ? DPS_EXT_HEADER_SIZE : DPS_HEADER_SIZE;
+      if (cc->nObjBufChars < minSize) {
+	if (nch + cc->nObjBufChars < (unsigned) minSize) {
+	  os_bcopy(buf, b + cc->nObjBufChars, nch);
+	  cc->nObjBufChars += nch;
+	  return;
+	  }
+	else {
+	  os_bcopy(buf, b + cc->nObjBufChars, minSize - cc->nObjBufChars);
+	  buf += minSize - cc->nObjBufChars;
+	  nch -= minSize - cc->nObjBufChars;
+	  cc->nObjBufChars = minSize;
+	  }
+	}
+      
+      if (minSize == DPS_HEADER_SIZE) {
+	unsigned short *sizeP = (unsigned short *)(cc->objBuf+2);
+	m = *sizeP;
+	}
+      else {
+	unsigned long *extSizeP = (unsigned long *)(cc->objBuf+4);
+	m = *extSizeP;
+	}
+
+      /* here with m = BOS total length in bytes, b = cc->objBuf */
+      cc->objBuf = (char *)realloc(b, m);
+
+      if (nch + cc->nObjBufChars < m) {
+	os_bcopy(buf, cc->objBuf + cc->nObjBufChars, nch);
+	cc->nObjBufChars += nch;
+	return;
+	}
+      else {
+	os_bcopy(buf, cc->objBuf + cc->nObjBufChars, m - cc->nObjBufChars);
+	buf += m - cc->nObjBufChars;
+	nch -= m - cc->nObjBufChars;
+	cc->nObjBufChars = m;
+	}
+      /* we're here only if cc->objBuf contains a complete BOS */
+      oldBuf = buf;
+      oldNch = nch;
+      buf = cc->objBuf;
+      nch = cc->nObjBufChars;
+      cc->objBuf = NIL;
+      cc->nObjBufChars = 0;
+      } /* if we're buffering */
+
+    /* dispose of any plain text.  If no binary conversion, all output
+       is plain text */
+    if (cc->contextFlags & DPS_FLAG_NO_BINARY_CONVERSION) n = nch;
+    else {
+	for (n = 0; n < nch &&
+	  ((unsigned char) buf[n] < 128 || (unsigned char) buf[n] > 159); n++);
+    }
+    if ((n > 0) && (cc->textProc != NIL)) {
+	(*cc->textProc)((DPSContext)cc, buf, n);
+    }
+    buf += n;
+    nch -= n;
+
+    if (nch != 0) {
+      /* here with the next binary object sequence from a server */
+      DPSExtendedBinObjSeq bos;
+      DPSExtendedBinObjSeqRec bosRec;
+      DPSBinObj firstObj;
+      unsigned t;
+      unsigned long int m;
+      unsigned minSize;
+      
+      if (nch < DPS_SEQ_MIN) {
+	/* gotta buffer it */
+	DPSAssertWarn(nch == 1 && !oldBuf, cc, "illegal binary output from context (oldBuf)");
+	cc->objBuf = (char *)DPScalloc(DPS_EXT_HEADER_SIZE, 1);
+	cc->nObjBufChars = nch;
+	*cc->objBuf = *buf;
+	return;
+	}
+      /* check for quadbyte alignment */
+      if ((long int)buf & (MIN_POINTER_ALIGN - 1)) {
+        /* not aligned, we gotta copy the buffer */
+        /* we assert that we can't have an oldBuf if we're not aligned,
+           since we only get an oldBuf if we copied to a new buffer,
+           and we have already tested nch to be at least DPS_SEQ_MIN */
+        DPSAssertWarn(!oldBuf && nch > 1, cc, "return values garbled (oldBuf||nch<DPS_SEQ_MIN");
+        /* copy DPS_SEQ_MIN bytes, so we can use existing buffering code */
+        cc->objBuf = (char *)DPScalloc(DPS_EXT_HEADER_SIZE, 1);
+        cc->nObjBufChars = DPS_SEQ_MIN;
+        os_bcopy(buf, cc->objBuf, cc->nObjBufChars);
+        buf += DPS_SEQ_MIN;
+        nch -= DPS_SEQ_MIN;
+        /* now go to top of loop and go through the buffer update code */
+        continue;
+        }
+      bos = (DPSExtendedBinObjSeq) buf;
+      t = bos->tokenType;
+      minSize = (bos->escape == 0) ? DPS_EXT_HEADER_SIZE : DPS_HEADER_SIZE;
+      if (nch < minSize) {
+	/* gotta buffer it */
+	char *tb;
+	DPSAssertWarn(!oldBuf, cc, "return values garbled (oldBuf)");
+	tb = cc->objBuf = (char *)DPScalloc(minSize, 1);
+	cc->nObjBufChars = nch;
+	while (nch--) *tb++ = *buf++;
+	return;
+	}
+      else if (minSize == DPS_HEADER_SIZE) {
+	/* this is not an extended BOS */
+	DPSBinObjSeq seqHead = (DPSBinObjSeq) buf;
+	bos = &bosRec;
+	bos->tokenType = t;
+	bos->nTopElements = seqHead->nTopElements;
+	bos->length = seqHead->length;
+	firstObj = &(seqHead->objects[0]);
+	}
+      else firstObj = &(bos->objects[0]);
+      m = bos->length;
+      if (nch < m) {
+	/* gotta buffer it */
+	DPSAssertWarn(!oldBuf, cc, "return values garbled (oldBuf&&nch<m");
+	cc->objBuf = (char *)DPScalloc(bos->length, 1);
+	cc->nObjBufChars = nch;
+	os_bcopy(buf, cc->objBuf, nch);
+	return;
+	}
+      DPSAssertWarn(bos->nTopElements == 1, cc, "illegal binary output detected (bos->nTopElements!=1)");
+#if !IEEEFLOAT
+      if (t != DPS_DEF_TOKENTYPE) 
+	ConvSeqInPlace(1, firstObj, firstObj, bos->tokenType);
+#endif /* !IEEEFLOAT */
+      t = firstObj->tag;
+      if (t == DPS_ERR_TAG) {
+	cc->resultTable = NIL;
+	DPSSafeSetLastNameIndex((DPSContext)cc);
+	DURING
+	  if (cc->errorProc != NIL)
+	    (*cc->errorProc)((DPSContext)cc, dps_err_ps, (unsigned long)buf, m);
+	HANDLER
+	  if (oldBuf) free(buf);
+	  RERAISE;
+	END_HANDLER
+	}
+      else { /* dispatch this result */
+	if (!cc->resultTable || t > cc->resultTableLength) {
+	  if (cc->chainParent == NIL && cc->errorProc != NIL) {
+	    DPSSafeSetLastNameIndex((DPSContext)cc);
+	    (*cc->errorProc)((DPSContext)cc, dps_err_resultTagCheck, (unsigned long)buf, m);
+	    }
+	  }
+	else if (t == cc->resultTableLength) {
+	  cc->resultTable = NIL;
+	  }
+	else {
+	  StuffResultVal((DPSContext)cc, &cc->resultTable[t], t, firstObj);
+	  }
+	}
+      if (!oldBuf)
+	buf += m;
+      nch -= m;
+      } /* if (nch != 0) ... the next binary object sequence from a server */
+    if (oldBuf) {
+      DPSAssertWarn(nch == 0, cc, "some return values/data lost (nch)");
+      free(buf);
+      buf = oldBuf;
+      nch = oldNch;
+      }
+    } /* while (nch > 0) */
+
+} /* DPSclientPrintProc */
+
+/**************************************/
+/* Context procs for DPSCreateContext */
+/**************************************/
+
+
+static void procWaitContext(DPSContext ctxt)
+{
+  typedef struct {
+    unsigned char tokenType;
+    unsigned char topLevelCount;
+    unsigned short int nBytes;
+
+    DPSBinObjGeneric obj0;
+    DPSBinObjGeneric obj1;
+    DPSBinObjGeneric obj2;
+    DPSBinObjGeneric obj3;
+    } DPSQ;
+  static DPSQ dpsF = {
+    DPS_DEF_TOKENTYPE, 4, sizeof(DPSQ),
+    {DPS_LITERAL|DPS_INT, 0, 0, -23},	/* arbitrary int */
+    {DPS_LITERAL|DPS_INT, 0, 0, 0},	/* termination tag = 0 */
+    {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 119},	/* printobject */
+    {DPS_EXEC|DPS_NAME, 0, DPSSYSNAME, 70},	/* flush */
+    }; /* DPSQ */
+  DPSResultsRec DPSR;
+
+  if (DPSPrivateCheckWait(ctxt)) return;
+
+  ctxt->resultTable = &DPSR;	    /* must be non-null for handler to work */
+  ctxt->resultTableLength = 0;  /* same value as termination tag */
+  DPSBinObjSeqWrite(ctxt, (char *) &dpsF,sizeof(DPSQ));
+  DPSAwaitReturnValues(ctxt);
+}
+
+static void procUpdateNameMap(DPSContext ctxt)
+{
+  integer i;
+  DPSPrivContext c = (DPSPrivContext) ctxt;
+  DPSPrivSpace s = (DPSPrivSpace) ctxt->space;
+  DPSContext children = ctxt->chainChild;
+
+  /* unlink context from chain temporarily, so DPSPrintf can be called */
+  if (children != NIL) ctxt->chainChild = NIL;
+  DURING
+    for (i = s->lastNameIndex+1; i <= globLastNameIndex; i++)
+      DPSPrintf(ctxt, "%d /%s defineusername\n", i, userNames[i]);
+  HANDLER
+    if (children != NIL) ctxt->chainChild = children;
+    RERAISE;
+  END_HANDLER
+  c->lastNameIndex = globLastNameIndex;
+  if (children != NIL) {
+    /* update any children */
+    ctxt->chainChild = children;
+    DPSUpdateNameMap(ctxt->chainChild);
+  }
+}
+
+static void procWriteData(
+  DPSContext ctxt,
+  char *buf,
+  unsigned int count)
+{
+  /* safe to call with chain */
+  DPSinnerProcWriteData(ctxt, buf, count);
+  if (ctxt->chainChild != NIL) DPSWriteData(ctxt->chainChild, buf, count);
+}
+
+static void procBinObjSeqWrite(
+  DPSContext ctxt,
+  char *buf,
+  unsigned int count)
+{
+  if (((DPSPrivContext)ctxt)->lastNameIndex < globLastNameIndex) DPSUpdateNameMap(ctxt);
+  DPSinnerProcWriteData(ctxt, buf, count);
+  if (ctxt->chainChild != NIL) DPSBinObjSeqWrite(ctxt->chainChild, buf, count);
+}
+
+static void procWriteStringChars(
+  DPSContext ctxt,
+  char *buf,
+  unsigned int count)
+{
+  DPSinnerProcWriteData(ctxt, buf, count);
+  if (ctxt->chainChild != NIL) DPSWriteStringChars(ctxt->chainChild, buf, count);
+}
+
+static void procWritePostScript(
+  DPSContext ctxt,
+  char *buf,
+  unsigned int count)
+{
+  DPSinnerProcWriteData(ctxt, buf, count);
+  if (ctxt->chainChild != NIL) DPSWritePostScript(ctxt->chainChild, buf, count);
+}
+
+static void innerProcWriteNumstring(
+    DPSContext ctxt,
+    DPSDefinedType type,
+    char *data,
+    unsigned int size,
+    int scale,
+    void (*writeProc)(DPSContext, char *, unsigned))
+{
+    unsigned char HNumHeader[4];
+    register int i;
+#define NBUFSIZE 10
+    int ibuf[NBUFSIZE];		/* This needs to be a 32 bit datatype */
+
+    HNumHeader[0] = 149;
+    switch (type) {
+	case dps_tLong:
+	    HNumHeader[1] = (DPS_DEF_TOKENTYPE % 2) * 128 + scale;
+	    break;
+
+	case dps_tInt:
+	    HNumHeader[1] = ((sizeof(int) >= 4) ? 0 : 32)
+                + ((DPS_DEF_TOKENTYPE % 2) * 128) + scale;
+	    break;
+
+	case dps_tShort:
+	    HNumHeader[1] = 32 + ((DPS_DEF_TOKENTYPE % 2) * 128) + scale;
+	    break;
+
+	case dps_tFloat:
+	    HNumHeader[1] = 48 + ((DPS_DEF_TOKENTYPE % 2) * 128)
+                + ((DPS_DEF_TOKENTYPE >= 130) ? 1 : 0);
+	    break;
+
+	default:
+	    break;
+    }
+
+    HNumHeader[(DPS_DEF_TOKENTYPE % 2) ? 2 : 3] = (unsigned char) size;
+    HNumHeader[(DPS_DEF_TOKENTYPE % 2) ? 3 : 2] = (unsigned char) (size >> 8);
+
+    (*writeProc)(ctxt, (char *)HNumHeader, 4);
+
+    switch (type) {
+	case dps_tLong:
+	    if (sizeof(long) == 4) {
+		(*writeProc)(ctxt, (char *) data, size * 4);
+	    } else {
+		while (size > 0) {
+		    for (i = 0; i < NBUFSIZE && (unsigned) i < size; i++) {
+			ibuf[i] = ((long *) data)[i];
+		    }
+		    (*writeProc)(ctxt, (char *) ibuf,
+				 4 * (size < NBUFSIZE ? size : NBUFSIZE));
+		    size -= NBUFSIZE;
+		}
+	    }
+	    break;
+
+	case dps_tInt:
+	    (*writeProc)(ctxt, (char *) data, size * sizeof(int));
+	    break;
+
+	case dps_tShort:
+	    (*writeProc)(ctxt, (char *) data, size * sizeof(short));
+	    break;
+
+	case dps_tFloat:
+	    (*writeProc)(ctxt, (char *) data, size * sizeof(float));
+
+	default:
+	    break;
+    }
+} /* innerProcWriteNumstring */
+
+static void procWriteNumstring(
+    DPSContext ctxt,
+    DPSDefinedType type,
+    char *data,
+    unsigned int size,
+    int scale)
+{
+  innerProcWriteNumstring(ctxt, type, data, size, scale, DPSinnerProcWriteData);
+  if (ctxt->chainChild != NIL) DPSWriteNumString(ctxt->chainChild, type, data, size, scale);
+}
+
+static void writeTypedObjectArray(
+  DPSContext ctxt,
+  DPSDefinedType type,
+  char *array,
+  unsigned int length)
+{
+
+#define DPSMAX_SEQ 10		 
+  unsigned int i;
+  DPSPrivContext c = (DPSPrivContext)(ctxt);
+  static DPSBinObjGeneric bboolObj[DPSMAX_SEQ] = {
+	{DPS_LITERAL | DPS_BOOL, 0,0,0},
+	{DPS_LITERAL | DPS_BOOL, 0,0,0},
+	{DPS_LITERAL | DPS_BOOL, 0,0,0},
+	{DPS_LITERAL | DPS_BOOL, 0,0,0},
+	{DPS_LITERAL | DPS_BOOL, 0,0,0},
+	{DPS_LITERAL | DPS_BOOL, 0,0,0},
+	{DPS_LITERAL | DPS_BOOL, 0,0,0},
+	{DPS_LITERAL | DPS_BOOL, 0,0,0},
+	{DPS_LITERAL | DPS_BOOL, 0,0,0},
+	{DPS_LITERAL | DPS_BOOL, 0,0,0},
+	};
+  static DPSBinObjReal rrealObj[DPSMAX_SEQ] = {
+	{DPS_LITERAL | DPS_REAL, 0,0,0},
+	{DPS_LITERAL | DPS_REAL, 0,0,0},
+	{DPS_LITERAL | DPS_REAL, 0,0,0},
+	{DPS_LITERAL | DPS_REAL, 0,0,0},
+	{DPS_LITERAL | DPS_REAL, 0,0,0},
+	{DPS_LITERAL | DPS_REAL, 0,0,0},
+	{DPS_LITERAL | DPS_REAL, 0,0,0},
+	{DPS_LITERAL | DPS_REAL, 0,0,0},
+	{DPS_LITERAL | DPS_REAL, 0,0,0},
+	{DPS_LITERAL | DPS_REAL, 0,0,0},
+	};
+  static DPSBinObjGeneric iintObj[DPSMAX_SEQ] = {
+	{DPS_LITERAL | DPS_INT, 0,0,0},
+	{DPS_LITERAL | DPS_INT, 0,0,0},
+	{DPS_LITERAL | DPS_INT, 0,0,0},
+	{DPS_LITERAL | DPS_INT, 0,0,0},
+	{DPS_LITERAL | DPS_INT, 0,0,0},
+	{DPS_LITERAL | DPS_INT, 0,0,0},
+	{DPS_LITERAL | DPS_INT, 0,0,0},
+	{DPS_LITERAL | DPS_INT, 0,0,0},
+	{DPS_LITERAL | DPS_INT, 0,0,0},
+	{DPS_LITERAL | DPS_INT, 0,0,0},
+	};
+    
+  if (DPSCheckShared(c)) return;
+
+  switch (type) {
+    case dps_tChar:
+    case dps_tUChar:
+      DPSCantHappen();
+      break;
+
+    case dps_tBoolean: {
+      while (length > 0) {
+	for (i = 0; i < MIN(DPSMAX_SEQ, length); i++) {
+	  bboolObj[i].val = *((int *)array);
+	  array += sizeof(int);
+	  }
+	DPSWritePostScript(ctxt, (char *) bboolObj, sizeof(DPSBinObjGeneric) * i);
+	length -= i;
+	}
+      break;
+      }
+
+    case dps_tFloat: {
+      while (length > 0) {
+	for (i = 0; i < MIN(DPSMAX_SEQ, length); i++) {
+	  rrealObj[i].realVal = *((float *)array);
+	  array += sizeof(float);
+	  }
+	DPSWritePostScript(ctxt, (char *) rrealObj, sizeof(DPSBinObjReal) * i);
+	length -= i;
+	}
+      break;
+      }
+
+    case dps_tDouble: {
+      while (length > 0) {
+	for (i = 0; i < MIN(DPSMAX_SEQ, length); i++) {
+	  rrealObj[i].realVal = *((double *)array);
+	  array += sizeof(double);
+	  }
+	DPSWritePostScript(ctxt, (char *) rrealObj, sizeof(DPSBinObjReal) * i);
+	length -= i;
+	}
+      break;
+      }
+
+    case dps_tShort: {
+      while (length > 0) {
+	for (i = 0; i < MIN(DPSMAX_SEQ, length); i++) {
+	  iintObj[i].val = *((short *)array);
+	  array += sizeof(short);
+	  }
+	DPSWritePostScript(ctxt, (char *) iintObj, sizeof(DPSBinObjGeneric) * i);
+	length -= i;
+	}
+      break;
+      }
+
+    case dps_tUShort: {
+      while (length > 0) {
+	for (i = 0; i < MIN(DPSMAX_SEQ, length); i++) {
+	  iintObj[i].val = *((unsigned short *)array);
+	  array += sizeof(unsigned short);
+	  }
+	DPSWritePostScript(ctxt, (char *) iintObj, sizeof(DPSBinObjGeneric) * i);
+	length -= i;
+	}
+      break;
+      }
+
+    case dps_tInt: {
+      while (length > 0) {
+	for (i = 0; i < MIN(DPSMAX_SEQ, length); i++) {
+	  iintObj[i].val = *((int *)array);
+	  array += sizeof(int);
+	  }
+	DPSWritePostScript(ctxt, (char *) iintObj, sizeof(DPSBinObjGeneric) * i);
+	length -= i;
+	}
+      break;
+      }
+
+    case dps_tUInt: {
+      while (length > 0) {
+	for (i = 0; i < MIN(DPSMAX_SEQ, length); i++) {
+	  iintObj[i].val = *((unsigned int *)array);
+	  array += sizeof(unsigned int);
+	  }
+	DPSWritePostScript(ctxt, (char *) iintObj, sizeof(DPSBinObjGeneric) * i);
+	length -= i;
+	}
+      break;
+      }
+
+    case dps_tLong: {
+      while (length > 0) {
+	for (i = 0; i < MIN(DPSMAX_SEQ, length); i++) {
+	  iintObj[i].val = *((long *)array);
+	  array += sizeof(long);
+	  }
+	DPSWritePostScript(ctxt, (char *) iintObj, sizeof(DPSBinObjGeneric) * i);
+	length -= i;
+	}
+      break;
+      }
+
+    case dps_tULong: {
+      while (length > 0) {
+	for (i = 0; i < MIN(DPSMAX_SEQ, length); i++) {
+	  iintObj[i].val = *((unsigned long *)array);
+	  array += sizeof(unsigned long);
+	  }
+	DPSWritePostScript(ctxt, (char *) iintObj, sizeof(DPSBinObjGeneric) * i);
+	length -= i;
+	}
+      break;
+
+
+      }
+
+    default:;
+    }
+} /* writeTypedObjectArray */
+
+static void procDestroyContext(DPSContext ctxt)
+{
+  DPSPrivContext c = (DPSPrivContext)ctxt, cc, prev;
+  DPSPrivSpace ss = (DPSPrivSpace)(c->space);
+
+  if (c->buf != NIL) {
+    ContextBuffer b = (ContextBuffer)(c->buf);
+    b->next = contextBuffers;
+    contextBuffers = b;
+    c->buf = NIL;
+    }
+  if (c->objBuf != NIL) {
+    free(c->objBuf);
+    c->objBuf = NIL;
+    }
+
+  DPSUnchainContext(ctxt);
+
+  prev = NIL;
+  DPSAssert(ss != NIL);
+  for (cc = ss->firstContext; (cc != NIL) && (cc != c); cc = cc->next)
+    prev = cc;
+  DPSAssert(cc != NIL);
+  DPSAssert(cc != prev);
+  if (prev == NIL) ss->firstContext = cc->next;
+  else {
+    prev->next = cc->next;
+    DPSAssert(prev->next != prev);
+    }
+ 
+  DPSPrivateDestroyContext(ctxt);
+  free(c);
+}
+
+static void procDestroySpace(DPSSpace space)
+{
+  DPSPrivSpace ns, prevS, ss = (DPSPrivSpace)space;
+  integer sid = ss->sid;
+
+  while (ss->firstContext != NIL)
+    DPSDestroyContext((DPSContext)(ss->firstContext));
+  
+  prevS = NIL;
+  for (ns = spaces; (ns != NIL) && (ns->sid != sid); ns = ns->next)
+    prevS = ns;
+  DPSAssert(ns != NIL);
+  DPSAssert(ns == ss);
+  if (prevS == NIL) spaces = ns->next;
+  else {
+    prevS->next = ns->next;
+    DPSAssert(prevS->next != prevS);
+    }
+  
+  DPSPrivateDestroySpace(space);
+  free(ss);
+}
+
+static void procInterrupt(DPSContext ctxt)
+{
+  DPSPrivContext c = (DPSPrivContext)ctxt;
+  DPSSendInterrupt((XDPSPrivContext)c->wh, c->cid, DPSclientPrintProc);
+  if (ctxt->chainChild != NIL) DPSInterruptContext(ctxt->chainChild);
+}
+
+
+/****************************************************************/
+/* Procedures that support the DPSCreateTextContext context procs */
+/****************************************************************/
+
+/* precondition: (c >= 129 && c <= 159), which means that c is the
+   first byte of either a binary token or a binary object sequence */
+
+static boolean IsBinaryToken(unsigned char c)
+{
+  return (c != DPS_HI_IEEE && c != DPS_LO_IEEE
+	  && c != DPS_HI_NATIVE && c != DPS_LO_NATIVE);
+}
+
+/* returns the number of initial bytes of a given goody that are
+   required to figure out how many bytes are needed for the entire goody */
+   
+static unsigned GetHdrNBytes(unsigned char *t)
+{
+  if (!IsBinaryToken(*t)) {
+    if (*(++t) == 0) return DPS_EXT_HEADER_SIZE;
+    else return DPS_HEADER_SIZE;
+    }
+  switch (*t) {
+    case 137: 
+    case 142:
+      return(2);
+    case 143:
+    case 144:
+      return(3);
+    case 149:
+      return(4);
+    default:
+      if (*t > 149 && *t < 160) return(1); /* unassigned */
+      else return(1);
+    }
+}
+
+
+static void WriteHomogeneousArrayAsASCII(
+  DPSContext ctxt,
+  register unsigned char *buf)
+{
+  Swap32Rec n32;
+  Swap16Rec n16;
+  register unsigned char *b;
+
+  unsigned char r = *buf++;
+  float f;
+  boolean hi = (r < 128);
+  
+  if (!hi) r -= 128;
+  DPSPrintf(ctxt, "[ ");
+  b = n16.bytes;
+  if (hi) {Copy2SrcHi(buf, b);} else {Copy2SrcLo(buf, b);}
+  buf += 2;
+  if (r < 32)		/* 32-bit fixed */
+	  while (n16.u--) {
+	      b = n32.bytes;
+	      if (hi) {Copy4SrcHi(buf, b);} else {Copy4SrcLo(buf, b);}
+	      if (r == 0)
+		      DPSPrintf(ctxt, "%d ", n32.i);
+	      else {
+		  f = n32.i;  /* convert to float */
+		  n32.f = f / (1 << r);  /* scale */
+		  DPSPrintf(ctxt, "%g ", n32.f);
+	      }
+	      buf += 4;
+	  }
+  else if (r < 48) {	/* 16-bit fixed */
+      unsigned l = n16.u;
+      r -= 32;
+      while (l--) {
+	  b = n16.bytes;
+	  if (hi) {Copy2SrcHi(buf, b);} else {Copy2SrcLo(buf, b);}
+	  if (r == 0)
+		  DPSPrintf(ctxt, "%d ", n16.i);
+	  else {
+	      f = n16.i; /* convert to float */
+	      n32.f = f / (1 << r);  /* scale */
+	      DPSPrintf(ctxt, "%g ", n32.f);
+	  } 
+	  buf += 2;
+      }
+  }
+  else if (r == 48)	/* 32-bit IEEE */
+	  while (n16.u--) {
+#if IEEEFLOAT
+	      b = n32.bytes;
+	      if (hi) {Copy4SrcHi(buf, b);} else {Copy4SrcLo(buf, b);}
+#else /* IEEEFLOAT */
+	      if (hi) IEEEHighToNative(buf, &n32.f);
+	      else IEEELowToNative(buf, &n32.f);
+#endif /* IEEEFLOAT */
+	      DPSPrintf(ctxt, "%g ", n32.f);
+	      buf += 4;
+	  }
+  else if (r == 49)	  /* 32-bit native */
+	  while (n16.u--) {
+	      b = n32.bytes;
+	      *b++ = *buf++,*b++ = *buf++,*b++ = *buf++,*b = *buf++;
+	      DPSPrintf(ctxt, "%g ", n32.f);
+	  }
+  else DPSCantHappen();
+      DPSPrintf(ctxt, "\n] ");
+} /* WriteHomogeneousArrayAsASCII */
+
+/* returns the number of bytes needed for the entire goody. buf points
+   to enough initial bytes of the goody to figure this out (see above). */
+   
+static integer GetNBytes(register unsigned char *buf)
+{
+  unsigned short int nBytes;
+  register unsigned char *r = (unsigned char *)&nBytes;
+  
+  switch (*buf) {
+      case DPS_HI_IEEE:
+      case DPS_HI_NATIVE:
+	  if (*(buf+1) == 0) {
+	    unsigned int nb;
+	    r = (unsigned char *)&nb;
+	    buf += 4;
+	    Copy4SrcHi(buf, r);
+	    return(nb);
+	    }
+	  else {
+	    buf += 2;
+	    Copy2SrcHi(buf, r);
+	    }
+	  break;
+      case DPS_LO_IEEE:
+      case DPS_LO_NATIVE:
+	  if (*(buf+1) == 0) {
+	    unsigned int nb;
+	    r = (unsigned char *)&nb;
+	    buf += 4;
+	    Copy4SrcLo(buf, r);
+	    return(nb);
+	    }
+	  else {
+	    buf += 2;
+	    Copy2SrcLo(buf, r);
+	    }
+	  break;
+      case 132:
+      case 133:
+      case 138:
+      case 139:
+      case 140:
+	nBytes = 5; break;
+      case 134:
+      case 135:
+	nBytes = 3; break;
+      case 136:
+      case 141:
+      case 145:
+      case 146:
+      case 147:
+      case 148:
+	nBytes = 2; break;
+      case 137: {
+	unsigned int l = *(buf+1);
+	if (l < 32) {nBytes = 6; break;}
+	if (l < 48) {nBytes = 4; break;}
+	if (l-128 < 32) {nBytes = 6; break;}
+	if (l-128 < 48) {nBytes = 4; break;}
+	DPSCantHappen();
+	}
+      case 142:
+	nBytes = *(buf+1);
+	nBytes += 2;
+	break;
+      case 143: 
+	buf++;
+	Copy2SrcHi(buf, r);
+	nBytes += 3;
+	break;
+      case 144: 
+	buf++;
+	Copy2SrcLo(buf, r);
+	nBytes += 3;
+	break;
+      case 149:  {
+	unsigned char scale = *(buf+1);
+	buf += 2;
+	if (scale < 128)
+	  Copy2SrcHi(buf, r);
+	else {
+	  scale -= 128;
+	  Copy2SrcLo(buf, r);
+	  }
+	if (scale < 32)
+	  nBytes *= 4;
+	else if (scale < 48)
+	  nBytes *= 2;
+	else
+	  nBytes *= 4;
+	nBytes += 4;
+	break;
+	}
+      default: nBytes = 1; /* unassigned */
+      }
+  return(nBytes);
+}
+  
+static void WriteSeqAsAscii(
+  DPSContext ctxt,
+  char *base,
+  DPSBinObj currObj,
+  unsigned int nObjs,
+  unsigned char tokenType,
+  int *numstringOffsets)
+{
+  integer nLineObjs = 0;
+  DPSNumFormat numFormat;
+  float f;
+  long int i;
+  unsigned short int length;
+  
+  /* NOTE: It's ok to call DPSPrintf (which calls DPSWritePostScript)
+     from here since we are only sending text, so there's no problem
+     with re-entering DPSWritePostScript.  Caller guarantees
+     that this context has no children. */
+  
+  NumFormatFromTokenType(tokenType, &numFormat);
+   
+  while (nObjs--) {
+    unsigned char type = currObj->attributedType & ~DPS_EXEC;
+    boolean lit = ((currObj->attributedType & DPS_EXEC) == 0);
+
+    switch (type) {
+      case DPS_NULL:
+	break;
+      case DPS_BOOL:
+	i = currObj->val.booleanVal;
+	if (i)
+	  DPSPrintf(ctxt, "true ");
+	else
+	  DPSPrintf(ctxt, "false ");
+	break;
+      case DPS_INT:
+	i = currObj->val.integerVal;
+	DPSPrintf(ctxt, "%d ", i);
+	break;
+      case DPS_REAL:
+#if IEEEFLOAT
+	f = currObj->val.realVal;
+#else /* IEEEFLOAT */
+	if (numFormat != DPSDefaultNumFormat)
+#if SWAPBITS
+	    IEEELowToNative(&currObj->val.realVal, &f);
+#else /* SWAPBITS */
+	    IEEEHighToNative(&currObj->val.realVal, &f);
+#endif /* SWAPBITS */
+	else
+	  f = currObj->val.realVal;
+#endif /* IEEEFLOAT */
+
+	DPSPrintf(ctxt, "%g ", f);
+	break;
+      case DPS_NAME: {
+	char *p = 0;
+	integer index;
+	
+	index = currObj->val.nameVal;
+	length = currObj->length;
+	  
+	if (lit) DPSPrintf(ctxt, "/");
+
+	if (length == DPSSYSNAME) { /* system name index */
+	    if (index <= DPS_LAST_COMMON_SYSNAME) {
+	      if (!lit && (ctxt->contextFlags & DPS_FLAG_USE_ABBREVS)) {
+		  p = DPSGetSysnameAbbrev(index);
+		  if (p == NULL) p = DPSSysNames[index];
+	      } else p = DPSSysNames[index];
+	    } else if (DPS_FIRST_AUX_SYSNAME <= index
+		     && index <= DPS_LAST_AUX_SYSNAME)
+	      p = DPSSysNamesAux[index - DPS_FIRST_AUX_SYSNAME];
+	    else DPSCantHappen();
+	    length = strlen(p);
+	    }
+	else if (length == 0) { /* user name index */
+	    p = DPSNameFromIndex(index);
+	    length = strlen(p);
+	    }
+	else
+	    p = base + index;
+
+	DPSWriteData(ctxt, p, length);
+	DPSPrintf(ctxt, " ");
+	break; 
+	}
+      case DPS_ARRAY:
+	DPSPrintf(ctxt, (lit ? "[ " : "{ "));
+	WriteSeqAsAscii(
+	  ctxt,
+	  base,
+	  (DPSBinObj)(base+currObj->val.arrayVal),
+	  currObj->length,
+	  tokenType, numstringOffsets);
+	DPSPrintf(ctxt, (lit ? " ] " : " } "));
+	break;
+      case DPS_MARK:
+	if (lit)
+	  DPSPrintf(ctxt, "/mark ");
+	else
+	  DPSPrintf(ctxt, "mark ");
+	break;
+      case DPS_STRING: {
+	char *p;
+	int j;
+	i = currObj->val.stringVal;
+	length = currObj->length;
+	p = base + i;
+	if (numstringOffsets != NULL) {
+	    for (j = 2; j < numstringOffsets[1] &&
+		 numstringOffsets[j] != i; j++) ;
+	    if (numstringOffsets[j] == i) {
+		DPSAssert(*(unsigned char *) p++ == 149);
+		WriteHomogeneousArrayAsASCII(ctxt, (unsigned char *) p);
+		break;
+	    }
+	}
+	DPSPrintf(ctxt, "(");
+#ifdef VMS
+	WriteVMSStringBody(ctxt, p, length); /* write this */
+#else /* VMS */
+	/* render string bytes correctly */
+	while (length--) {
+	  char c = *p++;
+	  if (c == '(' || c == ')' || c == '\\')
+	    DPSPrintf(ctxt, "\\%c", c);
+	  else if (c == '\n')
+	    DPSPrintf(ctxt, "\\n");
+	  else if (!(isascii(c) && isprint(c)))
+	    DPSPrintf(ctxt, "\\%03.3o", (unsigned char) c);
+	  else DPSWriteData(ctxt, &c, 1);
+	  }
+#endif /* VMS */
+	DPSPrintf(ctxt, ") ");
+	break;
+	}
+      default: DPSCantHappen();
+      }
+
+    currObj++;
+    if (++nLineObjs == 15) {
+      nLineObjs = 0;
+      DPSPrintf(ctxt, "\n ");
+      }
+    } /* end while */
+
+    DPSPrintf(ctxt, "\n");
+
+} /* WriteSeqAsAscii */
+
+static void ConvertAndWriteSeqAsData(
+  DPSContext ctxt,
+  char *bosBuf,
+  int pass)
+{
+  DPSPrivContext cc = (DPSPrivContext) ctxt;
+  DPSExtendedBinObjSeq bos;
+  DPSExtendedBinObjSeqRec bosRec;
+  DPSNumFormat numFormat;
+  unsigned int offset, firstCharOffset;
+  unsigned int nameOffset;
+  unsigned int len = 0;
+  DPSBinObj currObj;
+  integer headSize;
+  char *seqBase;
+  
+  if (*(bosBuf+1) != 0) {
+    /* not an extended BOS */
+    DPSBinObjSeq seqHead = (DPSBinObjSeq) bosBuf;
+    bos = &bosRec;
+    bos->tokenType = seqHead->tokenType;
+    bos->escape = seqHead->nTopElements;
+    bos->nTopElements = seqHead->nTopElements;
+    bos->length = seqHead->length;
+    currObj = &(seqHead->objects[0]);
+    seqBase = (char *) &(seqHead->objects[0]);
+    headSize = DPS_HEADER_SIZE;
+    }
+  else {
+    bos = (DPSExtendedBinObjSeq) bosBuf;
+    currObj = &(bos->objects[0]);
+    seqBase = (char *) &(bos->objects[0]);
+    headSize = DPS_EXT_HEADER_SIZE;
+    }
+  firstCharOffset = bos->length - headSize;
+  nameOffset = firstCharOffset;
+  
+  /* Caller guarantees that this context has no children,
+     so it is okay to call DPSWriteData */
+  
+  NumFormatFromTokenType(bos->tokenType, &numFormat);
+    
+  /* Pass 0: If we're expanding name indices, find all name objects,
+	     lookup their strings, sum the lengths.
+	     Write the modified sequence header regardless.
+     Pass 1: we're converting indices to strings and/or
+	     converting numbers.  Write each modified object, and
+	     subsidiary strings.
+     Pass 2: Find all name objects, lookup and write the strings. */
+  
+  if (pass == 0 && ctxt->nameEncoding != dps_strings) 
+    /* we're just converting numbers, so skip while loop */
+    offset = firstCharOffset;
+  else
+    offset = 0;
+  
+  while (offset < firstCharOffset) {
+    DPSBinObjRec newObj;
+    unsigned char type = (currObj->attributedType & ~DPS_EXEC);
+    
+    newObj = *currObj;
+    
+#if !IEEEFLOAT
+    if (type == DPS_REAL) {
+	if (numFormat != cc->numFormat) {
+	  if (numFormat == dps_ieee) {
+	    if (DPSDefaultByteOrder == dps_loFirst)
+	      IEEELowToNative(&currObj->val.realVal, &newObj.val.realVal);
+	    else
+	      IEEEHighToNative(&currObj->val.realVal, &newObj.val.realVal);
+	    }  
+	  else { /* numFormat is native */
+	    if (DPSDefaultByteOrder == dps_loFirst)
+	      NativeToIEEELow(&currObj->val.realVal, &newObj.val.realVal);
+	    else
+	      NativeToIEEEHigh(&currObj->val.realVal, &newObj.val.realVal);
+	    }
+	  }
+      }	     
+#endif /* !IEEEFLOAT */
+
+    if (type == DPS_STRING && newObj.length > 0) {
+      /* keep track of where strings start */
+      firstCharOffset = ((unsigned) newObj.val.stringVal < firstCharOffset)
+	? newObj.val.stringVal : firstCharOffset;
+      }
+    if (type == DPS_NAME) {
+      if (newObj.length == DPSSYSNAME) { /* system name index, never expand to string body */
+	  if (pass != 1) goto next_obj;
+	  }
+      else if (newObj.length == 0) { /* user name index */
+	  register char *p = DPSNameFromIndex(newObj.val.nameVal);
+	  switch (pass) {
+	    case 0: len += strlen(p); goto next_obj;
+	    case 1: 
+	      if (ctxt->nameEncoding == dps_strings) {
+		newObj.length = strlen(p);
+		newObj.val.nameVal = nameOffset;
+		nameOffset += newObj.length;
+	      }
+	      break;
+	    case 2: DPSWriteData(ctxt, p, strlen(p)); goto next_obj;
+	    default:;
+	    }
+	  }
+      else { /* name is already a string */
+	  /* keep track of where strings start */
+	  firstCharOffset = ((unsigned) newObj.val.nameVal < firstCharOffset)
+	    ? newObj.val.nameVal : firstCharOffset;
+	}
+      } /* end if type == DPS_NAME */
+    if (pass == 1) {
+      DPSWriteData(ctxt, (char *) &newObj, sizeof(newObj)); 
+      }  
+
+next_obj:	  
+    offset += sizeof(newObj);
+    ++currObj;
+    } /* end while */
+    
+  /* finish pass */
+  switch (pass) {
+    case 0: {
+      unsigned char t;
+      /* write modified seqHead */
+      if (DPSDefaultByteOrder == dps_hiFirst && cc->numFormat == dps_ieee)
+	t = DPS_HI_IEEE;
+      else if (DPSDefaultByteOrder == dps_loFirst && cc->numFormat == dps_ieee) 
+	t = DPS_LO_IEEE;
+      else if (DPSDefaultByteOrder == dps_hiFirst && cc->numFormat == dps_native)
+	t = DPS_HI_NATIVE;
+      else 
+	t = DPS_LO_NATIVE;
+      DPSWriteData(ctxt, (char *) &t, 1);
+      if (headSize == DPS_HEADER_SIZE) {
+	unsigned short int nBytes;
+	unsigned char c = bos->nTopElements;
+	/* write top level count */
+	DPSWriteData(ctxt, (char *) &c, 1);
+	/* write nBytes */
+	nBytes = (ctxt->nameEncoding == dps_strings) ? bos->length + len :
+	   bos->length;
+	DPSWriteData(ctxt, (char *)&nBytes, 2);
+	}
+      else {
+	unsigned int nBytes;
+	/* write escape code & top level count */
+	DPSWriteData(ctxt, (char *)&bos->escape, 3);
+	/* write nBytes */
+	nBytes = (ctxt->nameEncoding == dps_strings) ? bos->length + len :
+	   bos->length;
+	DPSWriteData(ctxt, (char *)&nBytes, 4);
+	}
+      break;
+      }
+    case 1: {
+      char *stringStart = seqBase + firstCharOffset; 
+      DPSWriteData(ctxt, stringStart, (bos->length - headSize - firstCharOffset));
+      break;
+      }
+    default:;
+    }
+    
+} /* ConvertAndWriteSeqAsData */
+
+#define MIN16 -32768
+#define MAX16 32767
+
+/* TestHomogeneous will return a non-negative representation code 'r'
+   if all of the array elements are "integers", or all are "reals".
+   Will return -1 for any other case. */
+   
+static integer TestHomogeneous(
+  DPSBinObj aryObj,
+  unsigned short length,
+  DPSNumFormat numFormat)
+{
+  integer tmp, r = -1;
+  
+  while (length--) {
+    switch (aryObj->attributedType & ~DPS_EXEC) {
+      case DPS_INT:
+#if SWAPBITS
+	tmp = (aryObj->val.integerVal < MIN16
+	       || aryObj->val.integerVal > MAX16) ? 128 : 128+32;
+#else /* SWAPBITS */
+	tmp = (aryObj->val.integerVal < MIN16
+	       || aryObj->val.integerVal > MAX16) ? 0 : 32;
+#endif /* SWAPBITS */
+	if ((r == -1) || ((r & 0x07F) == 32 && (tmp & 0x07F) == 0))
+	  r = tmp; /* first element, or was 16-bit => bump to 32-bit */
+	else if ((r & 0x07F) == 0 && (tmp & 0x07F) == 32)
+	  goto bump_obj;  /* is 32-bit => stay 32-bit */
+	else if (r != tmp)
+	  return(-1);
+	/* else fall thru, r == tmp */
+	break;
+      case DPS_REAL:
+#if SWAPBITS
+	tmp = (numFormat == dps_ieee) ? 128+48 : 128+49;
+#else /* SWAPBITS */
+	tmp = (numFormat == dps_ieee) ? 48 : 49;
+#endif /* SWAPBITS */
+	if (r == -1)
+	  r = tmp;
+	else if (r != tmp) return(-1);
+	break;
+      default: return(-1);
+      }
+bump_obj:
+    ++aryObj;
+    }
+  return(r);
+} /* TestHomogeneous */
+
+static void WriteSeqAsTokens(
+  DPSContext ctxt,
+  char *base,
+  DPSBinObj currObj,
+  unsigned int nObjs,
+  unsigned char tokenType,
+  int *numstringOffsets)
+{
+  int nLineObjs = 0;
+  DPSNumFormat numFormat;
+  unsigned short length;
+  Swap32Rec n32;
+  Swap16Rec n16;
+  unsigned char c;
+
+#define PB(byte) c = (byte),DPSWriteData(ctxt, (char *) &c, 1)
+#if SWAPBITS
+#define WTT(byte) PB((byte)+1)
+#else /* SWAPBITS */
+#define WTT(byte) PB(byte)
+#endif /* SWAPBITS */
+
+  NumFormatFromTokenType(tokenType, &numFormat);
+   
+  while (nObjs--) {
+    unsigned char type = currObj->attributedType & ~DPS_EXEC;
+    boolean lit = ((currObj->attributedType & DPS_EXEC) == 0);
+
+    switch (type) {
+      case DPS_NULL:
+	break;
+      case DPS_BOOL:
+	PB(141);			/* boolean */
+	if (currObj->val.booleanVal)
+	  PB(true);
+	else
+	  PB(false);
+	break;
+      case DPS_INT:
+	n32.i = currObj->val.integerVal;
+	if (n32.i < MIN16 || n32.i > MAX16) {
+	  WTT(132);			/* 32-bit int */
+	  DPSWriteData(ctxt, (char *) n32.bytes, 4);
+	  }
+	else if (n32.i < -128 || n32.i > 127) {
+	  WTT(134);			/* 16-bit int */
+	  n16.i = n32.i;
+	  DPSWriteData(ctxt, (char *) n16.bytes, 2);
+	  }
+	else {
+	  WTT(136);			/* 8-bit int */
+	  PB(n32.i);
+	  }
+	break;
+      case DPS_REAL:
+#if IEEEFLOAT
+	WTT(138);			/* 32-bit IEEE float */
+#else /* IEEEFLOAT */
+	if (numFormat != DPSDefaultNumFormat)
+	  /* then it must be IEEE */
+	  WTT(138);			/* 32-bit IEEE float */
+	else
+	  PB(140);			/* 32-bit native float */
+#endif /* IEEEFLOAT */
+
+	DPSWriteData(ctxt, (char *) &currObj->val.realVal, 4);
+	break;
+      case DPS_NAME: {
+	char *p = 0;
+	integer index = currObj->val.nameVal;
+	
+	length = currObj->length;
+	if (length == DPSSYSNAME) {/* system name index */
+	    if (index >= 0 && index < 256) {
+	      if (lit)
+		PB(145);		/* literal system name */
+	      else
+		PB(146);		/* exec. system name */
+	      PB(index);
+	      goto next_obj;
+	      }
+	    else if (DPS_FIRST_AUX_SYSNAME <= index
+		     && index <= DPS_LAST_AUX_SYSNAME)
+	      p = DPSSysNamesAux[index - DPS_FIRST_AUX_SYSNAME];
+	    else DPSCantHappen();
+	    length = strlen(p);
+	    }
+	else if (length == 0) { /* user name index */
+	    if (ctxt->nameEncoding == dps_indexed && index < 256) {
+	      if (lit)
+		PB(147);		/* literal user name index */
+	      else
+		PB(148);		/* executable user name index */
+	      PB(index);
+	      goto next_obj;
+	      }
+	    else {
+	      p = DPSNameFromIndex(index);
+	      length = strlen(p);
+	      }
+	    }
+	else
+	  p = base + index;
+      if (lit) DPSPrintf(ctxt, "/");
+	DPSWriteData(ctxt, p, length);
+	DPSPrintf(ctxt, " ");
+	break; 
+	}
+      case DPS_ARRAY: {
+	DPSBinObj aryObj = (DPSBinObj)(base+currObj->val.arrayVal);
+	integer r;
+	length = currObj->length;
+	if (lit && (r = TestHomogeneous(aryObj, length, numFormat)) != -1) {
+	  PB(149);			/* homogeneous number array */
+	  PB(r);
+	  DPSWriteData(ctxt, (char *) &length, 2);
+	  if (r > 127) r -= 128;
+	  while (length--) {
+	    switch (r) {
+	      case 0:
+		DPSWriteData(ctxt, (char *) &aryObj->val.integerVal, 4);
+		break;
+	      case 32:
+		n16.i = aryObj->val.integerVal;
+		DPSWriteData(ctxt, (char *) n16.bytes, 2);
+		break;
+	      case 48:
+	      case 49:
+		DPSWriteData(ctxt, (char *) &aryObj->val.realVal, 4);
+		break;
+	      default: DPSCantHappen();
+	      }
+	    ++aryObj;
+	    }
+	  }
+	else { 
+	  DPSPrintf(ctxt, (lit ? "[ " : "{ "));
+	  WriteSeqAsTokens(ctxt, base, aryObj, length, tokenType,
+			   numstringOffsets);
+	  DPSPrintf(ctxt, (lit ? " ] " : " } "));
+	  }
+	break; }
+      case DPS_MARK:
+	if (lit)
+	  DPSPrintf(ctxt, "/mark ");
+	else
+	  DPSPrintf(ctxt, "mark ");
+	break;
+      case DPS_STRING: {
+	char *p = base + currObj->val.stringVal;
+	int i;
+	if (numstringOffsets != NULL) {
+	    for (i = 2; i < numstringOffsets[1] &&
+		 numstringOffsets[i] != currObj->val.stringVal; i++) ;
+	    if (numstringOffsets[i] == currObj->val.stringVal) {
+		DPSAssert(*(unsigned char *) p == 149);
+		DPSWriteData(ctxt, p, length);
+		break;
+	    }
+	}
+	length = currObj->length;
+	if (length < 256) {
+	  PB(142);			/* short string */
+	  PB(length);
+	  }
+	else {
+	  WTT(143);			/* long string */
+	  DPSWriteData(ctxt, (char *) &length, 2);
+	  }
+	DPSWriteData(ctxt, p, length);
+	break;
+	}
+      default: DPSCantHappen();
+      }
+next_obj:
+    ++currObj;
+    if (++nLineObjs == 15) {
+      nLineObjs = 0;
+      DPSPrintf(ctxt, "\n ");
+      }
+    } /* end while */
+
+    DPSPrintf(ctxt, "\n");
+} /* WriteSeqAsTokens */
+
+static void WriteTokenAsAscii(
+  DPSContext ctxt,
+  register unsigned char *buf)
+{
+  Swap32Rec n32;
+  Swap16Rec n16;
+  register unsigned char *b;
+
+  switch (*buf++) {
+    case 132:	 /* 32-bit int, hi */
+      b = n32.bytes;
+      Copy4SrcHi(buf, b);
+      DPSPrintf(ctxt, "%d ", n32.i);
+      break;
+    case 133:	 /* 32-bit int, lo */
+      b = n32.bytes;
+      Copy4SrcLo(buf, b);
+      DPSPrintf(ctxt, "%d ", n32.i);
+      break;
+    case 134:	 /* 16-bit int, hi */
+      b = n16.bytes;
+      Copy2SrcHi(buf, b);
+      DPSPrintf(ctxt, "%d ", n16.i);
+      break;
+    case 135:	 /* 16-bit int, lo */
+      b = n16.bytes;
+      Copy2SrcLo(buf, b);
+      DPSPrintf(ctxt, "%d ", n16.i);
+      break;
+    case 136:	 /* 8-bit int, signed */
+      n32.i = (char) *buf;
+      DPSPrintf(ctxt, "%d ", n32.i);
+      break;
+    case 137: {  /* 16 or 32-bit fixed */
+	unsigned char r = *buf++;
+	float f = 0.0;
+	boolean hi = (r < 128);
+	
+	if (!hi) r -= 128;
+	if (r < 32) {		/* 32-bit */
+	  b = n32.bytes;
+	  if (hi) {Copy4SrcHi(buf, b);} else {Copy4SrcLo(buf, b);}
+	  if (r == 0) {
+	    DPSPrintf(ctxt, "%d ", n32.i);
+	    break;
+	    }
+	  else {
+	    f = n32.i;  /* convert to float */
+	    goto do_scale;
+	    }
+	  }
+	else if (r < 48) {	/* 16-bit */
+	  b = n16.bytes;
+	  if (hi) {Copy2SrcHi(buf, b);} else {Copy2SrcLo(buf, b);};
+	  if (r == 0) {
+	    DPSPrintf(ctxt, "%d ", n16.i);
+	    break;
+	    }
+	  else {
+	    r -= 32;
+	    f = n16.i;  /* convert to float */
+	    goto do_scale;
+	    }
+	  }
+	else DPSCantHappen();
+do_scale:
+	n32.f = f / (1 << r);  /* scale */
+	DPSPrintf(ctxt, "%g ", n32.f);
+	break;
+	}
+    case 138:	 /* 32-bit IEEE float, hi */
+#if IEEEFLOAT
+      b = n32.bytes;
+      Copy4SrcHi(buf, b);
+#else /* IEEEFLOAT */
+      IEEEHighToNative(buf, &n32.f);
+#endif /* IEEEFLOAT */
+      DPSPrintf(ctxt, "%g ", n32.f);
+      break;
+    case 139:	 /* 32-bit IEEE float, lo */
+#if IEEEFLOAT
+      b = n32.bytes;
+      Copy4SrcLo(buf, b);
+#else /* IEEEFLOAT */
+      IEEELowToNative(buf, &n32.f);
+#endif /* IEEEFLOAT */
+      DPSPrintf(ctxt, "%g ", n32.f);
+      break;
+    case 140:	 /* 32-bit native float */
+      b = n32.bytes;
+      *b++ = *buf++,*b++ = *buf++,*b++ = *buf++,*b = *buf;
+      DPSPrintf(ctxt, "%g ", n32.f);
+      break;
+    case 141:	 /* boolean */
+      if (*buf)
+	DPSPrintf(ctxt, "true ");
+      else
+	DPSPrintf(ctxt, "false ");
+      break;
+    case 142:	 /* short string */
+      DPSPrintf(ctxt, "(");
+      n16.u = *buf++;
+      goto share_str_code;
+    case 143:	 /* long string, hi */
+      b = n16.bytes;
+      Copy2SrcHi(buf, b);
+      DPSPrintf(ctxt, "(");
+      buf += 2;
+      goto share_str_code;
+    case 144:	 /* long string, lo */
+      b = n16.bytes;
+      Copy2SrcLo(buf, b);
+      DPSPrintf(ctxt, "(");
+      buf += 2;
+share_str_code:
+#ifdef VMS
+      WriteVMSStringBody(ctxt, buf, n16.u); /* write this */
+#else /* VMS */
+      /* render string bytes correctly */
+      while (n16.u--) {
+	unsigned char c = *buf++;
+	if (c == '(' || c == ')' || c == '\\')
+	  DPSPrintf(ctxt, "\\%c", c);
+	else if (c == '\n')
+	  DPSPrintf(ctxt, "\\n");
+	else if (!(isascii(c) && isprint(c)))
+	  DPSPrintf(ctxt, "\\%03.3o", c);
+	else DPSWriteData(ctxt, (char *) &c, 1);
+	}
+#endif /* VMS */
+      DPSPrintf(ctxt, ") ");
+      break;
+    case 145:	 /* literal system name index */
+      DPSPrintf(ctxt, "/%s ", DPSSysNames[*buf]);
+      break;
+    case 146:	 /* executable system name index */
+      DPSPrintf(ctxt, "%s ", DPSSysNames[*buf]);
+      break;
+    case 147:	/* literal user name index */
+      DPSPrintf(ctxt, "/%s ", DPSNameFromIndex(*buf));
+      break;
+    case 148:	/* executable user name index */
+      DPSPrintf(ctxt, "%s ", DPSNameFromIndex(*buf));
+      break;
+    case 149: {  /* homogeneous number array */
+      WriteHomogeneousArrayAsASCII(ctxt, buf);
+      break;
+      }
+    default:; /* unassigned */
+    }
+} /* WriteTokenAsAscii */
+  
+
+/* WriteEntireGoody converts an entire binary token or binary object
+   sequence as specified by ctxt's encoding parameters. Write the
+   converted bytes via DPSWriteData.  buf points to the complete goody. */
+   
+static void WriteEntireGoody(
+  DPSContext ctxt,
+  unsigned char *buf,
+  int *numstringOffsets)
+{
+
+  DPSExtendedBinObjSeq bos = (DPSExtendedBinObjSeq) buf;
+  DPSExtendedBinObjSeqRec bosRec;
+  DPSBinObj currObj;
+  DPSPrivContext cc = (DPSPrivContext) ctxt;
+  
+  if (IsBinaryToken(*buf)) {
+     /* only supported conversion is binary token to ASCII */
+     WriteTokenAsAscii(ctxt, buf);
+     if (numstringOffsets) numstringOffsets[1] = 2;
+     return;
+     }
+     
+  if (bos->escape != 0) {
+    /* not extended BOS */
+    DPSBinObjSeq seqHead = (DPSBinObjSeq) buf;
+    bos = &bosRec;
+    bos->tokenType = seqHead->tokenType;
+    bos->escape = seqHead->nTopElements;
+    bos->nTopElements = seqHead->nTopElements;
+    bos->length = seqHead->length;
+    currObj = &(seqHead->objects[0]);
+    }
+  else currObj = &(bos->objects[0]);
+
+  switch (ctxt->programEncoding) {
+    case dps_binObjSeq:
+      if (ctxt->nameEncoding == dps_strings) {
+	  /* takes three passes to do conversions */
+	  ConvertAndWriteSeqAsData(ctxt, (char *) buf, 0);
+	  ConvertAndWriteSeqAsData(ctxt, (char *) buf, 1);
+	  ConvertAndWriteSeqAsData(ctxt, (char *) buf, 2);
+	}
+      else if (bos->tokenType != DPS_DEF_TOKENTYPE
+	       || cc->numFormat != DPSDefaultNumFormat) {
+	  /* first pass just writes modified seqHead */
+	  ConvertAndWriteSeqAsData(ctxt, (char *) buf, 0);
+	  /* second pass converts numbers and writes the sequence */
+	  ConvertAndWriteSeqAsData(ctxt, (char *) buf, 1);
+	}
+      else DPSWriteData(ctxt, (char *) buf, bos->length);
+      break;
+    case dps_ascii: 
+    case dps_encodedTokens: {
+      
+      if (ctxt->programEncoding == dps_ascii)
+        {
+	WriteSeqAsAscii(
+	  ctxt, (char *)currObj, currObj, bos->nTopElements,
+	  bos->tokenType, numstringOffsets);
+	}
+      else
+	WriteSeqAsTokens(
+	  ctxt, (char *)currObj, currObj, bos->nTopElements,
+	  bos->tokenType, numstringOffsets);
+      DPSWriteData(ctxt, "\n", 1);
+      break;
+      }
+    default:;
+    }
+  if (numstringOffsets) numstringOffsets[1] = 2;
+} /* WriteEntireGoody */
+
+
+/**************************************/
+/* Context procs for DPSCreateTextContext */
+/**************************************/
+
+static void textWriteData(DPSContext ctxt, char *buf, unsigned int nch)
+{
+  (*ctxt->textProc)(ctxt, buf, nch);
+  if (ctxt->chainChild != NIL) DPSWriteData(ctxt->chainChild, buf, nch);
+}
+
+static void textFlushContext(DPSContext ctxt)
+{
+  if (ctxt->chainChild != NIL) DPSFlushContext(ctxt->chainChild);
+}
+
+static void textInterruptContext(DPSContext ctxt)
+{
+  if (ctxt->chainChild != NIL) DPSInterruptContext(ctxt->chainChild);
+}
+
+static void textDestroyContext(DPSContext ctxt)
+{
+  DPSPrivContext c = (DPSPrivContext)ctxt;
+
+  DPSUnchainContext(ctxt);
+
+  free(c);
+}
+
+static void textInnerWritePostScript(
+  DPSContext ctxt, char *buf, unsigned int nch)
+{
+  DPSPrivContext cc = (DPSPrivContext)ctxt;
+  while (nch > 0) {
+    char *oldBuf = NIL;
+    integer oldNch = 0;
+    unsigned n;
+    if (cc->outBuf) { /* we're buffering */
+      unsigned m;
+      integer bst;
+      if (!IsBinaryToken(cc->outBuf[0]) && cc->nOutBufChars < DPS_SEQ_MIN) {
+	char *tb = cc->outBuf + cc->nOutBufChars;
+	integer nn = DPS_SEQ_MIN - cc->nOutBufChars;
+	DPSAssert(nn == 1);
+	cc->nOutBufChars += nn;
+	nch -= nn;
+	*tb++ = *buf++;
+	}
+      bst = GetHdrNBytes((unsigned char *) cc->outBuf);
+	/* # bytes needed to determine size */
+      if (cc->nOutBufChars < bst) {
+	char *b = cc->outBuf;
+	if (nch + cc->nOutBufChars < (unsigned) bst) {
+	  os_bcopy(buf, cc->outBuf + cc->nOutBufChars, nch);
+	  cc->nOutBufChars += nch;
+	  return;
+	  }
+	os_bcopy(buf, b + cc->nOutBufChars, bst - cc->nOutBufChars);
+	buf += bst - cc->nOutBufChars;
+	nch -= bst - cc->nOutBufChars;
+	cc->nOutBufChars = bst;
+	m = GetNBytes((unsigned char *) cc->outBuf);
+	cc->outBuf = (char *)DPScalloc(m, 1);
+	os_bcopy(b, cc->outBuf, bst);
+	free(b);
+	}
+      else m = GetNBytes((unsigned char *) cc->outBuf);
+
+      /* here with size of entire goody in m and outBuf set up */
+      if (nch + cc->nOutBufChars < m) {
+	os_bcopy(buf, cc->outBuf + cc->nOutBufChars, nch);
+	cc->nOutBufChars += nch;
+	return;
+	}
+      os_bcopy(buf, cc->outBuf + cc->nOutBufChars, m - cc->nOutBufChars);
+      buf += m - cc->nOutBufChars;
+      nch -= m - cc->nOutBufChars;
+      cc->nOutBufChars = m;
+      oldBuf = buf;
+      oldNch = nch;
+      buf = cc->outBuf;
+      nch = cc->nOutBufChars;
+      cc->outBuf = NIL;
+      cc->nOutBufChars = 0;
+      } /* if (cc->outBuf) */
+
+    /* dispose of any plain text.  If no binary conversion, all output
+       is plain text */
+    if (cc->contextFlags & DPS_FLAG_NO_BINARY_CONVERSION) n = nch;
+    else {
+	for (n = 0; n < nch &&
+	  ((unsigned char) buf[n] < 128 || (unsigned char) buf[n] > 159); n++);
+    }
+    if (n > 0) {
+      /* Assumes below that any error proc called uses dpsexcept.h
+	 if it rips control away */
+      DURING
+	DPSWriteData((DPSContext)cc, buf, n);
+      HANDLER
+	if (oldBuf) free(buf);
+	RERAISE;
+      END_HANDLER
+      }
+    buf += n;
+    nch -= n;
+
+    if (nch != 0) {
+      /* here with the next binary object sequence or encoded token */
+      unsigned m = 0;
+      integer bst;
+      if (!IsBinaryToken(buf[0]) && nch < DPS_SEQ_MIN) {
+	/* gotta buffer it */
+	DPSAssertWarn(nch == 1 && !oldBuf, cc, "problem converting binary token/sequence (nch!=1||oldBuf)");
+	cc->outBuf = (char *)DPScalloc(DPS_EXT_HEADER_SIZE, 1);
+	cc->nOutBufChars = nch;
+	cc->outBuf[0] = *buf;
+	return;
+	}
+      bst = GetHdrNBytes((unsigned char *) buf);
+      if (nch < (unsigned)bst || nch < (m = GetNBytes((unsigned char *) buf))) {
+	/* gotta buffer it */
+	DPSAssertWarn(!oldBuf, cc, "problem converting binary token/sequence (oldBuf)");
+	if (nch < (unsigned) bst) {
+	  cc->outBuf = (char *)DPScalloc(bst, 1);
+	  }
+	else {
+	  cc->outBuf = (char *)DPScalloc(m, 1);
+	  }
+	cc->nOutBufChars = nch;
+	os_bcopy(buf, cc->outBuf, nch);
+	return;
+	}
+
+      /* Assumes below that any error proc called uses dpsexcept.h
+	 if it rips control away */
+      DURING
+	WriteEntireGoody(ctxt, (unsigned char *) buf, cc->numstringOffsets);
+      HANDLER
+	if (oldBuf) {
+	  DPSAssertWarn(nch == m, cc, "some converted PostScript language may be lost during error recovery (nch!=m)");
+	  free(buf);
+	  }
+	RERAISE;
+      END_HANDLER
+
+      if (oldBuf) {
+	DPSAssertWarn(nch == m, cc, "some converted PostScript language may be lost (nch!=m)");
+	free(buf);
+	buf = oldBuf;
+	nch = oldNch;
+	oldBuf = NIL;
+	}
+      else {
+	buf += m;
+	nch -= m;
+	}
+      } /* if (nch != 0) */
+    } /* while (nch > 0) */
+} /* textInnerWritePostScript */
+
+static void textWritePostScript(
+  DPSContext ctxt, char *buf, unsigned int nch)
+{
+  DPSContext children = ctxt->chainChild;
+  /* disconnect temporarily so that high level procs can
+     be called safely */
+  if (children != NIL) ctxt->chainChild = NIL;
+  DURING
+  textInnerWritePostScript(ctxt, buf, nch);
+  HANDLER
+    if (children != NIL) ctxt->chainChild = children;
+    RERAISE;
+  END_HANDLER
+  if (children != NIL) {
+    ctxt->chainChild = children;
+    DPSWritePostScript(ctxt->chainChild, buf, nch);
+    }
+}
+
+static void textWriteStringChars(
+  DPSContext ctxt, char *buf, unsigned int nch)
+{
+  DPSContext children = ctxt->chainChild;
+
+  if (DPSCheckShared((DPSPrivContext)ctxt)) return;
+  /* disconnect temporarily so that high level procs can
+     be called safely */
+  if (children != NIL) ctxt->chainChild = NIL;
+  DURING
+  textInnerWritePostScript(ctxt, buf, nch);
+  HANDLER
+    if (children != NIL) ctxt->chainChild = children;
+    RERAISE;
+  END_HANDLER
+  if (children != NIL) {
+    ctxt->chainChild = children;
+    DPSWriteStringChars(ctxt->chainChild, buf, nch);
+    }
+}
+
+static void textBinObjSeqWrite(
+  DPSContext ctxt, char *buf, unsigned int nch)
+{
+  DPSContext children = ctxt->chainChild;
+  DPSPrivContext c = (DPSPrivContext) ctxt;
+
+  if (DPSCheckShared(c)) return;
+  if (c->lastNameIndex < globLastNameIndex)
+    DPSUpdateNameMap(ctxt);
+  /* disconnect temporarily so that high level procs can
+     be called safely */
+  if (children != NIL) ctxt->chainChild = NIL;
+  DURING
+  textInnerWritePostScript(ctxt, buf, nch);
+  HANDLER
+    if (children != NIL) ctxt->chainChild = children;
+    RERAISE;
+  END_HANDLER
+  if (children != NIL) {
+    ctxt->chainChild = children;
+    DPSBinObjSeqWrite(ctxt->chainChild, buf, nch);
+    }
+}
+
+static void textWriteNumstring(
+    DPSContext ctxt,
+    DPSDefinedType type,
+    char *data,
+    unsigned int size,
+    int scale)
+{
+    DPSPrivContext cc = (DPSPrivContext) ctxt;
+#define BUFFER_GROW 10
+
+    if (cc->contextFlags & DPS_FLAG_CONVERT_NUMSTRINGS) {
+	if (cc->numstringOffsets == NULL) {
+	    cc->numstringOffsets = (int *) DPScalloc(sizeof(int),
+						     BUFFER_GROW + 2);
+	    cc->numstringOffsets[0] = BUFFER_GROW + 2;	/* Current size */
+	    cc->numstringOffsets[1] = 2;		/* Next slot */
+	} else if (cc->numstringOffsets[1] >= cc->numstringOffsets[0]) {
+	    cc->numstringOffsets[0] += BUFFER_GROW;
+	    cc->numstringOffsets =
+		    (int *) realloc(cc->numstringOffsets,
+				    sizeof(int)* cc->numstringOffsets[0]);
+	}
+
+	/* Subtract 4 because of binary object sequence header */
+	cc->numstringOffsets[cc->numstringOffsets[1]] = cc->nOutBufChars - 4;
+	cc->numstringOffsets[1] += 1;
+    }
+
+    innerProcWriteNumstring(ctxt, type, data, size, scale, textInnerWritePostScript);
+#undef BUFFER_GROW
+} /* textWriteNumstring */
+
+/*********************/
+/* Public procedures */
+/*********************/
+
+/********************************************/
+/* Public procs for dealing with user names */
+
+char *DPSNameFromIndex(long int index)
+{
+  if (DPSglobals == NIL || index < 0 || index > globLastNameIndex
+      || userNameDict == NIL)
+    return NIL;
+  return (char *) userNames[index];
+}
+
+void DPSMapNames(
+  DPSContext ctxt,
+  unsigned int nNames,
+  char **names,
+  int **indices)
+{
+  unsigned i;
+  char *last = names[0];
+
+  DPSCheckInitClientGlobals();
+
+#define USERNAMEDICTLENGTH 100
+
+  if (userNameDict == NIL) {
+    userNameDict = DPSCreatePSWDict(USERNAMEDICTLENGTH);
+    userNames = (char **)DPScalloc(sizeof(char *), USERNAMEDICTLENGTH);
+    userNamesLength = USERNAMEDICTLENGTH;
+    }
+
+  for (i = 0; i < nNames; i++) {
+    integer j;
+    char *n = names[i];
+    DPSContext c;
+    
+    if (n == NIL)
+      n = last;
+    else
+      last = n;
+    DPSAssert(n != NIL);
+    if (strlen(n) > 128) {
+      DPSSafeSetLastNameIndex(ctxt);
+      (*ctxt->errorProc)(ctxt, dps_err_nameTooLong, (unsigned long) n, strlen(n));
+      return;
+      }
+    j = DPSWDictLookup(userNameDict, n);
+    if (j >= 0) {
+      *(indices[i]) = j;
+      /* handle the case where another context in another space has
+	 defined this name */
+      if (((DPSPrivContext)ctxt)->lastNameIndex < j) 
+	DPSUpdateNameMap(ctxt);
+      }
+    else {
+      /* handle other cases where another context in another
+	 space has defined names */
+      if (((DPSPrivContext)ctxt)->lastNameIndex < globLastNameIndex)
+	DPSUpdateNameMap(ctxt);
+      globLastNameIndex++;
+      if (((globLastNameIndex + 1) > userNamesLength)) {
+	char **t = (char **)DPScalloc(sizeof(char *),
+				      userNamesLength + USERNAMEDICTLENGTH);
+	for (j = 0; j < userNamesLength; j++) {
+	  t[j] = userNames[j];
+	  }
+	free(userNames);
+	userNames = t;
+	userNamesLength += USERNAMEDICTLENGTH;
+	}
+      userNames[globLastNameIndex] = n;
+      DPSWDictEnter(userNameDict, n, globLastNameIndex);
+      *(indices[i]) = globLastNameIndex;
+      DPSPrintf(ctxt, "%d /%s defineusername\n", globLastNameIndex, n);
+      for (c = ctxt; c != NIL; c = c->chainChild)
+	((DPSPrivContext)c)->lastNameIndex = globLastNameIndex;
+      }
+    } /* for */
+}
+     
+/**********************/
+/* Other public procs */
+
+void DPSDefaultErrorProc(
+  DPSContext ctxt,
+  DPSErrorCode errorCode,
+  long unsigned int arg1, long unsigned int arg2)
+{
+
+  DPSTextProc textProc = DPSGetCurrentTextBackstop();
+  
+  char *prefix = "%%[ Error: ";
+  char *suffix = " ]%%\n";
+
+  char *infix = "; OffendingCommand: ";
+  char *nameinfix = "User name too long; Name: ";
+  char *contextinfix = "Invalid context: ";
+  char *taginfix = "Unexpected wrap result tag: ";
+  char *typeinfix = "Unexpected wrap result type; tag: ";
+
+  switch (errorCode) {
+    case dps_err_ps: {
+      char *buf = (char *)arg1;
+      DPSBinObj ary = (DPSBinObj) (buf+DPS_HEADER_SIZE);
+      DPSBinObj elements;
+      char *error, *errorName;
+      integer errorCount, errorNameCount;
+      boolean resyncFlg;
+      
+      if ((ary->attributedType & 0x7f) != DPS_ARRAY 
+        || ary->length != 4) {
+	DPSHandleBogusError(ctxt, prefix, suffix);
+        }
+
+      elements = (DPSBinObj)(((char *) ary) + ary->val.arrayVal);
+
+      errorName = (char *)(((char *) ary) + elements[1].val.nameVal);
+      errorNameCount = elements[1].length;
+
+      error = (char *)(((char *) ary) + elements[2].val.nameVal);
+      errorCount = elements[2].length;
+
+      resyncFlg = elements[3].val.booleanVal;
+
+      if (textProc != NIL) {
+	(*textProc)(ctxt, prefix, strlen(prefix));
+	(*textProc)(ctxt, errorName, errorNameCount);
+	(*textProc)(ctxt, infix, strlen(infix));
+	(*textProc)(ctxt, error, errorCount);
+	(*textProc)(ctxt, suffix, strlen(suffix));
+	}
+      if (resyncFlg && (ctxt != dummyCtx) && (ctxt != NULL)) {
+#if 0	/* Postpone the raise 'til later to avoid RAISEing through Xlib */
+	RAISE(dps_err_ps, (char *) ctxt);
+	DPSCantHappen();
+#else
+	DPSPrivContext cc = (DPSPrivContext) ctxt;
+	cc->resyncing = true;
+#endif
+        }
+      break;
+      }
+    case dps_err_nameTooLong:
+      if (textProc != NIL) {
+	char *buf = (char *)arg1;
+	(*textProc)(ctxt, prefix, strlen(prefix));
+	(*textProc)(ctxt, nameinfix, strlen(nameinfix));
+	(*textProc)(ctxt, buf, arg2);
+	(*textProc)(ctxt, suffix, strlen(suffix));
+	}
+      break;
+    case dps_err_invalidContext:
+      if (textProc != NIL) {
+	char m[100];
+	(void) sprintf(m, "%s%s%ld%s", prefix, contextinfix, arg1, suffix);
+	(*textProc)(ctxt, m, strlen(m));
+	}
+      break;
+    case dps_err_resultTagCheck:
+      if (textProc != NIL) {
+	char m[100];
+	unsigned char tag = *((unsigned char *) arg1+1);
+	(void) sprintf(m, "%s%s%d%s", prefix, taginfix, tag, suffix);
+	(*textProc)(ctxt, m, strlen(m));
+	}
+      break;
+    case dps_err_resultTypeCheck:
+      if (textProc != NIL) {
+	char m[100];
+	unsigned char tag = *((unsigned char *) arg1+1);
+	(void) sprintf(m, "%s%s%d%s", prefix, typeinfix, tag, suffix);
+	(*textProc)(ctxt, m, strlen(m));
+	}
+      break;
+    default:
+	DPSDefaultPrivateHandler(ctxt, errorCode, arg1, arg2, prefix, suffix);
+	break;
+    }
+} /* DPSDefaultErrorProc */
+
+void DPSCheckRaiseError(DPSContext c)
+{
+    DPSPrivContext cc = (DPSPrivContext) c;
+    if (cc != NULL && cc->resyncing) {
+	cc->resyncing = false;
+	RAISE(dps_err_ps, (char *) c);
+	DPSCantHappen();
+    }
+}
+
+/**************************************/
+/* Public procs for creating contexts */
+
+/* dps_err_invalidAccess is now defined for all clients. */
+
+static void textAwaitReturnValues(DPSContext ctxt)
+{
+  (*ctxt->errorProc)(ctxt, dps_err_invalidAccess, 0, 0);
+}
+
+static void Noop(void)
+{
+}
+  
+DPSContext DPSCreateTextContext(
+  DPSTextProc textProc, DPSErrorProc errorProc)
+{
+  DPSPrivContext c;
+
+  if (DPSInitialize () != 0) return((DPSContext) NIL);
+  if (!textCtxProcs) {
+    textCtxProcs = (DPSProcs)DPScalloc(sizeof(DPSProcsRec), 1);
+    DPSInitCommonTextContextProcs(textCtxProcs);
+    DPSInitSysNames();
+    }
+
+  c = (DPSPrivContext)DPScalloc(sizeof(DPSPrivContextRec), 1);
+  c->textProc = textProc;
+  c->procs = textCtxProcs;
+  c->textProc = textProc;
+  c->errorProc = errorProc;
+  c->programEncoding = dps_ascii;
+  c->nameEncoding = dps_strings;  /* don't write user name indices on a file */
+  c->contextFlags = DPS_FLAG_CONVERT_NUMSTRINGS; /* Convert by default */
+  c->numFormat = DPSDefaultNumFormat;
+  c->numstringOffsets = NULL;
+  c->lastNameIndex = -1;
+ 
+  /* Setup a dummy space */
+  if (textSpace == NIL)
+    {
+    textSpace = (DPSPrivSpace) DPScalloc(sizeof (DPSPrivSpaceRec), 1);
+    textSpace->procs = (DPSSpaceProcs) DPScalloc(sizeof (DPSSpaceProcsRec), 1);
+    textSpace->procs->DestroySpace = (DPSSpaceProc) Noop;
+    textSpace->lastNameIndex = -1;
+    DPSInitPrivateSpaceFields(textSpace);
+    }
+  c->space = (DPSSpace) textSpace;
+
+  DPSInitPrivateTextContextFields(c, textSpace);
+  return (DPSContext)c;
+} /* DPSCreateTextContext */
+
+
+static DPSContext CreateDummyContext(void)
+{
+  DPSPrivContext c;
+
+  DPSCheckInitClientGlobals();
+  if (!dummyCtxProcs) {
+    dummyCtxProcs = (DPSProcs)DPScalloc(sizeof(DPSProcsRec), 1);
+    dummyCtxProcs->BinObjSeqWrite = (DPSContextBufProc) Noop;
+    dummyCtxProcs->WriteTypedObjectArray = (DPSContextTypedArrayProc) Noop;
+    dummyCtxProcs->WriteStringChars = (DPSContextBufProc) Noop;
+    dummyCtxProcs->WritePostScript = (DPSContextBufProc) Noop;
+    dummyCtxProcs->WriteData = (DPSContextBufProc) Noop;
+    dummyCtxProcs->FlushContext = (DPSContextProc) Noop;
+    dummyCtxProcs->ResetContext = (DPSContextProc) Noop;
+    dummyCtxProcs->WaitContext = (DPSContextProc) Noop;
+    dummyCtxProcs->UpdateNameMap = (DPSContextProc) Noop;
+    dummyCtxProcs->AwaitReturnValues = (DPSContextProc) Noop;
+    dummyCtxProcs->Interrupt = (DPSContextProc) Noop;
+    dummyCtxProcs->DestroyContext = (DPSContextProc) Noop;
+    dummyCtxProcs->WriteNumString = (DPSWriteNumStringProc) Noop;
+    }
+
+  c = (DPSPrivContext)DPScalloc(sizeof(DPSPrivContextRec), 1);
+  c->procs = dummyCtxProcs;
+  c->programEncoding = DPSDefaultProgramEncoding;
+  c->nameEncoding = DPSDefaultNameEncoding; /* don't care */
+  c->numFormat = DPSDefaultNumFormat;
+  c->lastNameIndex = -1;
+  c->numstringOffsets = NULL;
+
+  return (DPSContext)c;
+} /* CreateDummyContext */
+
+void DPSSetTextBackstop(DPSTextProc textProc)
+{
+  DPSCheckInitClientGlobals();
+  if (!dummyCtx) dummyCtx = CreateDummyContext();
+  dummyCtx->textProc = textProc;
+}
+
+DPSTextProc DPSGetCurrentTextBackstop(void)
+{
+  DPSCheckInitClientGlobals();
+  if (dummyCtx == NIL) return NIL;
+  else return dummyCtx->textProc;
+}
+
+void DPSSetErrorBackstop(DPSErrorProc errorProc)
+{
+  DPSCheckInitClientGlobals();
+  if (!dummyCtx) dummyCtx = CreateDummyContext();
+  dummyCtx->errorProc = errorProc;
+}
+
+DPSErrorProc DPSGetCurrentErrorBackstop(void)
+{
+  DPSCheckInitClientGlobals();
+  if (dummyCtx == NIL) return NIL;
+  else return dummyCtx->errorProc;
+}
+
+static void NoteInitFailure(DPSContext ctxt, char *buf, long unsigned length)
+{
+  initFailed = -1;
+}
+
+int DPSInitialize(void)
+{
+  DPSCheckInitClientGlobals();
+  if (!clientStarted) {
+    clientStarted = true;
+    initFailed = 0;
+    DPSInitClient(NoteInitFailure, ReleaseInput); /* may call DPSCreateContext */
+    /* textProc will not be used unless DPS initialization fails */
+    }
+  return initFailed;
+}
+
+DPSContext DPSCreateContext(
+  char *wh,
+  DPSTextProc textProc,
+  DPSErrorProc errorProc,
+  DPSSpace space)
+{
+  
+  DPSPrivSpace ss;
+  DPSPrivContext c;
+
+  if (DPSInitialize() != 0) return NIL;
+
+  if (!ctxProcs) {
+    ctxProcs = (DPSProcs)DPScalloc(sizeof(DPSProcsRec), 1);
+    ctxProcs->BinObjSeqWrite = procBinObjSeqWrite;
+    ctxProcs->WriteTypedObjectArray = writeTypedObjectArray;
+    ctxProcs->WriteStringChars = procWriteStringChars;
+    ctxProcs->WritePostScript = procWritePostScript;
+    ctxProcs->WriteData = procWriteData;
+    ctxProcs->UpdateNameMap = procUpdateNameMap;
+    ctxProcs->Interrupt = procInterrupt;
+    ctxProcs->WriteNumString = (DPSWriteNumStringProc) procWriteNumstring;
+    }
+  if (!spaceProcs) {
+    spaceProcs = (DPSSpaceProcs)DPScalloc(sizeof(DPSSpaceProcsRec), 1);
+    DPSInitCommonSpaceProcs(spaceProcs);
+    }
+  
+  ss = (DPSPrivSpace)space;
+
+  if (ss == NIL) {
+    ss = (DPSPrivSpace)DPScalloc(sizeof(DPSPrivSpaceRec), 1);
+    ss->procs = spaceProcs;
+    ss->lastNameIndex = -1;
+    ss->next = spaces;
+    DPSAssert(ss->next != ss);
+    spaces = ss;
+    DPSInitPrivateSpaceFields(ss);
+    }
+
+  if (ss->wh == NIL) ss->wh = wh; /* KLUDGE to support DPSSendDestroySpace */
+
+  c = (DPSPrivContext)DPScalloc(sizeof(DPSPrivContextRec), 1);
+  c->procs = ctxProcs;
+  c->wh = wh;
+  c->textProc = textProc;
+  c->errorProc = errorProc;
+  c->programEncoding = DPSDefaultProgramEncoding;
+  c->nameEncoding = DPSDefaultNameEncoding;
+  c->lastNameIndex = -1;
+  c->space = (DPSSpace)ss;
+  c->numstringOffsets = NULL;
+  
+  c->next = ss->firstContext;
+  DPSAssert(c->next != c);
+  ss->firstContext = c;
+
+  DPSInitPrivateContextFields(c, ss);
+
+  c->numFormat = DPSCreatePrivContext(
+	(XDPSPrivContext)wh,
+	(DPSContext)c,
+	(ContextPSID *)&c->cid,
+	(SpaceXID *)&ss->sid,
+	(space == NIL), DPSclientPrintProc);
+  if (c->numFormat ==  (DPSNumFormat) -1)
+    { /* can't create the context */
+    if (space == NIL) {
+      spaces = ss->next;
+      free(ss);
+      }
+    else ss->firstContext = c->next;
+    free(c);
+    return NIL;
+    }
+  else return (DPSContext)c;
+} /* DPSCreateContext */
+
+char *DPSSetWh(
+  DPSContext ctxt,
+  char *newWh)
+{
+  DPSPrivContext cc = (DPSPrivContext) ctxt;
+  char *tmp = cc->wh;
+  cc->wh = newWh;
+  return(tmp);
+}
+
+/*
+   The chainParent field is non-NIL if this context automatically receives
+   a copy of the PostScript code sent to the referenced (parent) context.
+     
+   The chainChild field is non-NIL if this context automatically sends along
+   to the referenced (child) context a copy of any PostScript code received.
+*/
+int DPSChainContext(DPSContext parent, DPSContext child)
+{
+  DPSContext cc = child->chainChild;
+
+  if (child->chainParent != NIL)
+    return -1; /* report an error */
+
+  /* insert new child between parent and existing children */
+  child->chainChild = parent->chainChild;
+  if (parent->chainChild != NIL) {
+    DPSAssertWarn(parent->chainChild->chainParent == parent, (DPSPrivContext)parent, "attempting to chain context on invalid chain");
+    child->chainChild->chainParent = child;
+    }
+  child->chainParent = parent;
+  parent->chainChild = child;
+  /* if child has children, recursively chain them */
+  if (cc != NIL) {
+    cc->chainParent = NIL;
+    (void) DPSChainContext(child, cc);
+    }
+  return 0;
+}
+
+void DPSUnchainContext(DPSContext ctxt)
+{
+  DPSContext p = ctxt->chainParent;
+  DPSContext c = ctxt->chainChild;
+
+  if (p != NIL) { /* remove ctxt from parent's chain */
+    DPSAssertWarn(p->chainChild == ctxt, (DPSPrivContext)p, "attempting to unchain context from wrong chain (parent)");
+    p->chainChild = c;
+    ctxt->chainParent = NIL;
+    }
+  if (c != NIL) { /* remove ctxt's child (if any) from ctxt's chain */
+   DPSAssertWarn(c->chainParent == ctxt, (DPSPrivContext)c, "attempting to unchain context from wrong chain (child)");
+    c->chainParent = p;
+    ctxt->chainChild = NIL;
+    }
+}
+
+/****************/
+/* Veneer procs */
+
+void DPSAwaitReturnValues(DPSContext ctxt)
+{
+  (*(ctxt)->procs->AwaitReturnValues)((ctxt));
+}
+
+void DPSDestroyContext(DPSContext ctxt)
+{
+  (*(ctxt)->procs->DestroyContext)((ctxt));
+}
+
+void DPSDestroySpace(DPSSpace spc)
+{
+  (*(spc)->procs->DestroySpace)((spc));
+}
+
+void DPSFlushContext(DPSContext ctxt)
+{
+  (*(ctxt)->procs->FlushContext)((ctxt));
+}
+
+DPSContext DPSGetCurrentContext(void) { return DPSGlobalContext; }
+
+void DPSInterruptContext(DPSContext ctxt)
+{
+  (*(ctxt)->procs->Interrupt)((ctxt));
+}
+
+DPSContext DPSPrivCurrentContext(void) { return DPSGlobalContext; }
+
+void DPSResetContext(DPSContext ctxt)
+{
+  (*(ctxt)->procs->ResetContext)((ctxt));
+}
+
+void DPSSetResultTable(
+  register DPSContext ctxt,
+  DPSResults tbl,
+  unsigned int len)
+{
+  (ctxt)->resultTable = (tbl);
+  (ctxt)->resultTableLength = (len);
+}
+
+void DPSSetContext(
+  DPSContext ctxt)
+{
+  DPSGlobalContext = ctxt;
+}
+
+void DPSUpdateNameMap(
+  DPSContext ctxt)
+{
+  (*(ctxt)->procs->UpdateNameMap)((ctxt));
+}
+
+void DPSWaitContext(
+  DPSContext ctxt)
+{
+  (*(ctxt)->procs->WaitContext)(ctxt);
+}
+
+void DPSBinObjSeqWrite(
+  DPSContext ctxt,
+  char *buf,
+  unsigned int count)
+{
+  (*(ctxt)->procs->BinObjSeqWrite)((ctxt), (buf), (count));
+}
+
+void DPSWriteData(
+  DPSContext ctxt,
+  char *buf,
+  unsigned int count)
+{
+  (*(ctxt)->procs->WriteData)((ctxt), (buf), (count));
+}
+
+void DPSWritePostScript(
+  DPSContext ctxt,
+  char *buf,
+  unsigned int count)
+{
+  (*(ctxt)->procs->WritePostScript)((ctxt), (buf), (count));
+}
+
+void DPSWriteStringChars(
+  DPSContext ctxt,
+  char *buf,
+  unsigned int count)
+{
+  (*(ctxt)->procs->WriteStringChars)((ctxt), (buf), (count));
+}
+
+void DPSWriteNumString(ctxt, type, data, size, scale)
+    DPSContext ctxt;
+    DPSDefinedType type;
+    char *data;
+    unsigned int size;
+    int scale;
+{
+   (*(ctxt)->procs->WriteNumString)((ctxt), (type), (data), (size), (scale));
+}
+
+void DPSWriteTypedObjectArray(ctxt, type, array, length)
+  DPSContext ctxt;
+  DPSDefinedType type;
+  char *array;
+  unsigned int length; {
+  (*(ctxt)->procs->WriteTypedObjectArray)((ctxt), (type), (array), (length));
+  }
+  
+void DPSInitCommonTextContextProcs(DPSProcs p)
+{
+    p->BinObjSeqWrite = textBinObjSeqWrite;
+    p->WriteTypedObjectArray = writeTypedObjectArray;
+    p->WriteStringChars = textWriteStringChars;
+    p->WritePostScript = textWritePostScript;
+    p->WriteData = textWriteData;
+    p->FlushContext = textFlushContext;
+    p->ResetContext = (DPSContextProc) Noop;
+    p->WaitContext = (DPSContextProc) Noop;
+    p->UpdateNameMap = procUpdateNameMap;
+    p->AwaitReturnValues = textAwaitReturnValues;
+    p->Interrupt = textInterruptContext;
+    p->DestroyContext = textDestroyContext;
+    p->WriteNumString = (DPSWriteNumStringProc) textWriteNumstring;
+}
+
+void DPSInitCommonContextProcs(DPSProcs p)
+{
+    p->BinObjSeqWrite = procBinObjSeqWrite;
+    p->WriteTypedObjectArray = writeTypedObjectArray;
+    p->WriteStringChars = procWriteStringChars;
+    p->WritePostScript = procWritePostScript;
+    p->WaitContext = procWaitContext;
+    p->DestroyContext = procDestroyContext;
+    p->WriteData = procWriteData;
+    p->UpdateNameMap = procUpdateNameMap;
+    p->Interrupt = procInterrupt;
+    p->WriteNumString = (DPSWriteNumStringProc) procWriteNumstring;
+}
+
+void DPSInitCommonSpaceProcs(DPSSpaceProcs p)
+{
+    p->DestroySpace = procDestroySpace;
+}
+    
+void DPSSetNumStringConversion(ctxt, flag)
+    DPSContext ctxt;
+    int flag;
+{
+    if (flag) ctxt->contextFlags |= DPS_FLAG_CONVERT_NUMSTRINGS;
+    else ctxt->contextFlags &= ~DPS_FLAG_CONVERT_NUMSTRINGS;
+}
+
+void DPSSetWrapSynchronization(ctxt, flag)
+    DPSContext ctxt;
+    int flag;
+{
+    if (flag) ctxt->contextFlags |= DPS_FLAG_SYNC;
+    else ctxt->contextFlags &= ~DPS_FLAG_SYNC;
+}
+
+void DPSSuppressBinaryConversion(ctxt, flag)
+    DPSContext ctxt;
+    int flag;
+{
+    if (flag) ctxt->contextFlags |= DPS_FLAG_NO_BINARY_CONVERSION;
+    else ctxt->contextFlags &= ~DPS_FLAG_NO_BINARY_CONVERSION;
+}
+
+void DPSSetAbbrevMode(ctxt, flag)
+    DPSContext ctxt;
+    int flag;
+{
+    if (flag) ctxt->contextFlags |= DPS_FLAG_USE_ABBREVS;
+    else ctxt->contextFlags &= ~DPS_FLAG_USE_ABBREVS;
+}
+
+DPSContextExtensionRec *DPSGetContextExtensionRec(ctxt, extensionId)
+    DPSContext ctxt;
+    int extensionId;
+{
+    DPSContextExtensionRec *r = ctxt->extension;
+
+    while (r != NULL && r->extensionId != extensionId) r = r->next;
+    return r;
+}
+
+void DPSAddContextExtensionRec(ctxt, rec)
+    DPSContext ctxt;
+    DPSContextExtensionRec *rec;
+{
+    rec->next = ctxt->extension;
+    ctxt->extension = rec;
+}
+
+DPSContextExtensionRec *DPSRemoveContextExtensionRec(ctxt, extensionId)
+    DPSContext ctxt;
+    int extensionId;
+{
+    DPSContextExtensionRec *rret, **r = &ctxt->extension;
+
+
+    while (*r != NULL && (*r)->extensionId != extensionId) {
+	r = &(*r)->next;
+    }
+    rret = *r;
+    if (*r != NULL) *r = (*r)->next;
+    return rret;
+}
+
+int DPSGenerateExtensionRecID(void)
+{
+    static int id = 1;
+
+    return id++;
+}
+
+DPSContextType DPSGetContextType(ctxt)
+    DPSContext ctxt;
+{
+    DPSPrivContext c = (DPSPrivContext) ctxt;
+
+    if (c->procs == textCtxProcs) return dps_context_text;
+    else return dps_context_execution;
+}
diff --git a/nx-X11/lib/dps/dpsclrops.psw b/nx-X11/lib/dps/dpsclrops.psw
new file mode 100644
index 000000000..f8ec18269
--- /dev/null
+++ b/nx-X11/lib/dps/dpsclrops.psw
@@ -0,0 +1,81 @@
+/* dpsclrops.psw
+ *
+ * (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
+ */
+
+defineps DPScolorimage(DPSContext ctxt)
+	colorimage 
+endps
+
+defineps DPScurrentblackgeneration(DPSContext ctxt)
+	currentblackgeneration 
+endps
+
+defineps DPScurrentcmykcolor(DPSContext ctxt | float *c, *m, *y, *k)
+	currentcmykcolor k y m c 
+endps
+
+defineps DPScurrentcolorscreen(DPSContext ctxt)
+	currentcolorscreen 
+endps
+
+defineps DPScurrentcolortransfer(DPSContext ctxt)
+	currentcolortransfer 
+endps
+
+defineps DPScurrentundercolorremoval(DPSContext ctxt)
+	currentundercolorremoval 
+endps
+
+defineps DPSsetblackgeneration(DPSContext ctxt)
+	setblackgeneration 
+endps
+
+defineps DPSsetcmykcolor(DPSContext ctxt; float c, m, y, k)
+	c m y k setcmykcolor 
+endps
+
+defineps DPSsetcolorscreen(DPSContext ctxt)
+	setcolorscreen 
+endps
+
+defineps DPSsetcolortransfer(DPSContext ctxt)
+	setcolortransfer 
+endps
+
+defineps DPSsetundercolorremoval(DPSContext ctxt)
+	setundercolorremoval 
+endps
+
diff --git a/nx-X11/lib/dps/dpsctrlops.psw b/nx-X11/lib/dps/dpsctrlops.psw
new file mode 100644
index 000000000..d00707d4c
--- /dev/null
+++ b/nx-X11/lib/dps/dpsctrlops.psw
@@ -0,0 +1,114 @@
+/* 
+ * dpsctrlops.psw
+ *
+ * (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
+ */
+
+defineps DPSeq(DPSContext ctxt)
+	eq 
+endps
+
+defineps DPSexit(DPSContext ctxt)
+	exit 
+endps
+
+defineps DPSfalse(DPSContext ctxt)
+	false 
+endps
+
+defineps DPSfor(DPSContext ctxt)
+	for 
+endps
+
+defineps DPSforall(DPSContext ctxt)
+	forall 
+endps
+
+defineps DPSge(DPSContext ctxt)
+	ge 
+endps
+
+defineps DPSgt(DPSContext ctxt)
+	gt 
+endps
+
+defineps DPSif(DPSContext ctxt)
+	if 
+endps
+
+defineps DPSifelse(DPSContext ctxt)
+	ifelse 
+endps
+
+defineps DPSle(DPSContext ctxt)
+	le 
+endps
+
+defineps DPSloop(DPSContext ctxt)
+	loop 
+endps
+
+defineps DPSlt(DPSContext ctxt)
+	lt 
+endps
+
+defineps DPSne(DPSContext ctxt)
+	ne 
+endps
+
+defineps DPSnot(DPSContext ctxt)
+	not 
+endps
+
+defineps DPSor(DPSContext ctxt)
+	or 
+endps
+
+defineps DPSrepeat(DPSContext ctxt)
+	repeat 
+endps
+
+defineps DPSstop(DPSContext ctxt)
+	stop 
+endps
+
+defineps DPSstopped(DPSContext ctxt)
+	stopped 
+endps
+
+defineps DPStrue(DPSContext ctxt)
+	true 
+endps
+
diff --git a/nx-X11/lib/dps/dpsctxtops.psw b/nx-X11/lib/dps/dpsctxtops.psw
new file mode 100644
index 000000000..00f6f8f18
--- /dev/null
+++ b/nx-X11/lib/dps/dpsctxtops.psw
@@ -0,0 +1,110 @@
+/* 
+ * dpsctxtops.psw
+ *
+ * (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
+ */
+
+defineps DPSUserObjects(DPSContext ctxt)
+	UserObjects
+endps
+
+defineps DPScondition(DPSContext ctxt)
+	condition 
+endps
+
+defineps DPScurrentcontext(DPSContext ctxt | int *cid)
+	currentcontext cid 
+endps
+
+defineps DPScurrentobjectformat(DPSContext ctxt | int *code)
+	currentobjectformat code 
+endps
+
+defineps DPSdefineusername(DPSContext ctxt; int i; char *username)
+	i /username defineusername 
+endps
+
+defineps DPSdefineuserobject(DPSContext ctxt)
+	defineuserobject 
+endps
+
+defineps DPSdetach(DPSContext ctxt)
+	detach 
+endps
+
+defineps DPSexecuserobject(DPSContext ctxt; int userObjIndex)
+	userObjIndex execuserobject 
+endps
+
+defineps DPSfork(DPSContext ctxt)
+	fork 
+endps
+
+defineps DPSjoin(DPSContext ctxt)
+	join 
+endps
+
+defineps DPSlock(DPSContext ctxt)
+	lock 
+endps
+
+defineps DPSmonitor(DPSContext ctxt)
+	monitor 
+endps
+
+defineps DPSnotify(DPSContext ctxt)
+	notify 
+endps
+
+defineps DPSsetobjectformat(DPSContext ctxt; int code)
+	code setobjectformat 
+endps
+
+defineps DPSsetvmthreshold(DPSContext ctxt; int i)
+	i setvmthreshold 
+endps
+
+defineps DPSundefineuserobject(DPSContext ctxt; int userObjIndex)
+	userObjIndex undefineuserobject 
+endps
+
+defineps DPSwait(DPSContext ctxt)
+	wait 
+endps
+
+defineps DPSyield(DPSContext ctxt)
+	yield 
+endps
+
diff --git a/nx-X11/lib/dps/dpsdataops.psw b/nx-X11/lib/dps/dpsdataops.psw
new file mode 100644
index 000000000..c38893678
--- /dev/null
+++ b/nx-X11/lib/dps/dpsdataops.psw
@@ -0,0 +1,258 @@
+/*
+ * dpsdataops.psw
+ *
+ * (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
+ */
+
+defineps DPSaload(DPSContext ctxt)
+	aload 
+endps
+
+defineps DPSanchorsearch(DPSContext ctxt| boolean *truth)
+	anchorsearch truth
+endps
+
+defineps DPSarray(DPSContext ctxt; int len)
+	len array 
+endps
+
+defineps DPSastore(DPSContext ctxt)
+	astore 
+endps
+
+defineps DPSbegin(DPSContext ctxt)
+	begin 
+endps
+
+defineps DPSclear(DPSContext ctxt)
+	clear 
+endps
+
+defineps DPScleartomark(DPSContext ctxt)
+	cleartomark 
+endps
+
+defineps DPScopy(DPSContext ctxt; int n)
+	n copy
+endps
+
+defineps DPScount(DPSContext ctxt | int *n)
+	count n 
+endps
+
+defineps DPScounttomark(DPSContext ctxt | int *n)
+	counttomark n 
+endps
+
+defineps DPScvi(DPSContext ctxt)
+	cvi 
+endps
+
+defineps DPScvlit(DPSContext ctxt)
+	cvlit 
+endps
+
+defineps DPScvn(DPSContext ctxt)
+	cvn 
+endps
+
+defineps DPScvr(DPSContext ctxt)
+	cvr 
+endps
+
+defineps DPScvrs(DPSContext ctxt)
+	cvrs 
+endps
+
+defineps DPScvs(DPSContext ctxt)
+	cvs 
+endps
+
+defineps DPScvx(DPSContext ctxt)
+	cvx 
+endps
+
+defineps DPSdef(DPSContext ctxt)
+	def 
+endps
+
+defineps DPSdict(DPSContext ctxt; int len)
+	len dict 
+endps
+
+defineps DPSdictstack(DPSContext ctxt)
+	dictstack 
+endps
+
+defineps DPSdup(DPSContext ctxt)
+	dup 
+endps
+
+defineps DPSend(DPSContext ctxt)
+	end 
+endps
+
+defineps DPSexch(DPSContext ctxt)
+	exch 
+endps
+
+defineps DPSexecstack(DPSContext ctxt)
+	execstack 
+endps
+
+defineps DPSexecuteonly(DPSContext ctxt)
+	executeonly 
+endps
+
+defineps DPSget(DPSContext ctxt)
+	get 
+endps
+
+defineps DPSgetinterval(DPSContext ctxt)
+	getinterval 
+endps
+
+defineps DPSindex(DPSContext ctxt; int i)
+	i index 
+endps
+
+defineps DPSknown(DPSContext ctxt | boolean *b)
+	known b 
+endps
+
+defineps DPSlength(DPSContext ctxt | int *len)
+	length len 
+endps
+
+defineps DPSload(DPSContext ctxt)
+	load 
+endps
+
+defineps DPSmark(DPSContext ctxt)
+	mark 
+endps
+
+defineps DPSmatrix(DPSContext ctxt)
+	matrix 
+endps
+
+defineps DPSmaxlength(DPSContext ctxt | int *len)
+	maxlength len 
+endps
+
+defineps DPSnoaccess(DPSContext ctxt)
+	noaccess 
+endps
+
+defineps DPSnull(DPSContext ctxt)
+	null 
+endps
+
+defineps DPSpackedarray(DPSContext ctxt)
+	packedarray 
+endps
+
+defineps DPSpop(DPSContext ctxt)
+	pop 
+endps
+
+defineps DPSput(DPSContext ctxt)
+	put 
+endps
+
+defineps DPSputinterval(DPSContext ctxt)
+	putinterval 
+endps
+
+defineps DPSrcheck(DPSContext ctxt | boolean *b)
+	rcheck b 
+endps
+
+defineps DPSreadonly(DPSContext ctxt)
+	readonly 
+endps
+
+defineps DPSroll(DPSContext ctxt; int n, j)
+	n j roll 
+endps
+
+defineps DPSscheck(DPSContext ctxt | boolean *b)
+	scheck b 
+endps
+
+defineps DPSsearch(DPSContext ctxt| boolean *b)
+	search b
+endps
+
+defineps DPSshareddict(DPSContext ctxt)
+	shareddict 
+endps
+
+defineps DPSstatusdict(DPSContext ctxt)
+	statusdict 
+endps
+
+defineps DPSstore(DPSContext ctxt)
+	store 
+endps
+
+defineps DPSstring(DPSContext ctxt; int len)
+	len string 
+endps
+
+defineps DPSstringwidth(DPSContext ctxt; char *s | float *xp, *yp)
+	(s) stringwidth yp xp 
+endps
+
+defineps DPSsystemdict(DPSContext ctxt)
+	systemdict 
+endps
+
+defineps DPSuserdict(DPSContext ctxt)
+	userdict 
+endps
+
+defineps DPSwcheck(DPSContext ctxt | boolean *b)
+	wcheck b 
+endps
+
+defineps DPSwhere(DPSContext ctxt| boolean *b)
+	where b
+endps
+
+defineps DPSxcheck(DPSContext ctxt | boolean *b)
+	xcheck b 
+endps
+
diff --git a/nx-X11/lib/dps/dpsdict.c b/nx-X11/lib/dps/dpsdict.c
new file mode 100644
index 000000000..b2e8a04b2
--- /dev/null
+++ b/nx-X11/lib/dps/dpsdict.c
@@ -0,0 +1,189 @@
+/*
+ * dpsdict.c
+ *
+ * (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$ */
+
+/***********/
+/* Imports */
+/***********/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "dpsint.h"
+
+/********************/
+/* Types */
+/********************/
+
+typedef struct _EntryRec {
+  struct _EntryRec *next;
+  char *name;
+  PSWDictValue value;
+  } EntryRec, *Entry;
+
+ /* The concrete definition for a dictionary */
+ typedef struct _PSWDictRec {
+  integer nEntries;
+  Entry *entries;
+  } PSWDictRec;
+
+static PSWDict atoms;
+
+/**************************/
+/* Procedure Declarations */
+/**************************/
+
+/* Creates and returns a new dictionary. nEntries is a hint. */
+PSWDict DPSCreatePSWDict(integer nEntries)
+{
+  PSWDict d = (PSWDict)DPScalloc(sizeof(PSWDictRec), 1);
+  d->nEntries = nEntries;
+  d->entries = (Entry *)DPScalloc(sizeof(EntryRec), d->nEntries);
+  return d;
+}
+
+/* Destroys a dictionary */
+void DPSDestroyPSWDict(PSWDict dict)
+{
+  integer links = dict->nEntries;
+  Entry   next;
+  Entry   prev;
+  
+  while (links > 0)
+    {
+    next = (dict->entries)[links];
+    while (next != NIL)
+      {
+      prev = next;
+      next = next->next;
+      free (prev);
+      }
+    links--;
+    }
+  free(dict->entries);
+  free(dict);
+}
+
+static integer Hash(char *name, integer nEntries)
+{
+  register integer val = 0;
+  while (*name) val += *name++;
+  if (val < 0) val = -val;
+  return (val % nEntries);
+}
+
+static Entry Probe(PSWDict d, integer x, char *name)
+{
+  register Entry e;
+  for (e = (d->entries)[x]; e != NIL; e = e->next) {
+    if (strcmp(name, e->name) == 0) break;
+    }
+  return e;
+}
+
+static Entry PrevProbe(Entry *prev, PSWDict d, integer x, char *name)
+{
+  register Entry e;
+  *prev = NIL;
+  for (e = (d->entries)[x]; e != NIL; e = e->next) {
+    if (strcmp(name, e->name) == 0) break;
+    *prev = e;
+    }
+  return e;
+}
+
+/* -1 => not found */
+PSWDictValue DPSWDictLookup(PSWDict dict, char *name)
+{
+  Entry e;
+  e = Probe(dict, Hash(name, dict->nEntries), name);
+  if (e == NIL) return -1;
+  return e->value;
+}
+
+/*  0 => normal return (not found)
+   -1 => found. If found, value is replaced. */
+PSWDictValue DPSWDictEnter(PSWDict dict, char *name, PSWDictValue value)
+{
+  Entry e;
+  integer x = Hash(name, dict->nEntries);
+  e = Probe(dict, x, name);
+  if (e != NIL) {
+    e->value = value;
+    return -1;
+    }
+  e = (Entry)DPScalloc(sizeof(EntryRec), 1);
+  e->next = (dict->entries)[x]; (dict->entries)[x] = e;
+  e->value = value;
+  e->name = name; /* MakeAtom(name); */
+  return 0;
+}
+
+/* -1 => not found. If found, value is returned. */
+PSWDictValue DPSWDictRemove(PSWDict dict, char *name)
+{
+  Entry e, prev;
+  PSWDictValue value;
+  integer x = Hash(name, dict->nEntries);
+
+  e = PrevProbe(&prev, dict, x, name);
+  if (e == NIL) return -1;
+  value = e->value;
+  if (prev == NIL) (dict->entries)[x] = e->next; else prev->next = e->next;
+  free(e);
+  return value;
+}
+
+Atom DPSMakeAtom(char *name)
+{
+  Entry e;
+  integer x = Hash(name, 511);
+  char *newname;
+
+  if (atoms == NIL) atoms = DPSCreatePSWDict(511);
+  e = Probe(atoms, x, name);
+  if (e == NIL) {
+    e = (Entry)DPScalloc(sizeof(EntryRec), 1);
+    e->next = (atoms->entries)[x]; (atoms->entries)[x] = e;
+    e->value = 0;
+    newname = (char *)DPScalloc(strlen(name)+1, 1);
+    strcpy(newname, name);
+    e->name = newname;
+    }
+  return (Atom) e->name;
+}
diff --git a/nx-X11/lib/dps/dpsdict.h b/nx-X11/lib/dps/dpsdict.h
new file mode 100644
index 000000000..18b40d42b
--- /dev/null
+++ b/nx-X11/lib/dps/dpsdict.h
@@ -0,0 +1,78 @@
+/*
+ *  dpsdict.h
+ *
+ * (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
+ */
+
+#ifndef	PSWDICT_H
+#define	PSWDICT_H
+
+#include <X11/X.h>
+
+#include "publictypes.h"
+
+typedef struct _PSWDictRec *PSWDict;
+/* Opaque designator for a dictionary */
+
+typedef int PSWDictValue; /* non-negative */
+
+/* PROCEDURES */
+
+/* The name parameters defined below are NULL-terminated C strings.
+   None of the name parameters are handed off, i.e. the caller is
+   responsible for managing their storage. */
+
+extern PSWDict DPSCreatePSWDict(integer /* nEntries */);
+/* nEntries is a hint. Creates and returns a new dictionary */
+
+extern void DPSDestroyPSWDict(PSWDict /* dict */);
+/* Destroys a dictionary */
+
+extern PSWDictValue DPSWDictLookup(PSWDict /* dict */, char * /* name */);
+/* -1 => not found. */
+
+extern PSWDictValue DPSWDictEnter
+  (PSWDict /* dict */, char * /* name */, PSWDictValue /* value */);
+/*  0 => normal return (not found)
+   -1 => found. If found, the old value gets replaced with the new one.
+    caller must ensure continuing validity of name. */
+
+extern PSWDictValue DPSWDictRemove(PSWDict /* dict */, char * /* name */);
+/* -1 => not found. If found, value is returned. */
+
+extern Atom DPSMakeAtom(char * /* name */);
+/* name characters are copied. */
+
+#endif /* PSWDICT_H */
diff --git a/nx-X11/lib/dps/dpsendif.txt b/nx-X11/lib/dps/dpsendif.txt
new file mode 100644
index 000000000..80dd08085
--- /dev/null
+++ b/nx-X11/lib/dps/dpsendif.txt
@@ -0,0 +1,5 @@
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif /* DPSOPS_H */
diff --git a/nx-X11/lib/dps/dpsexcept.c b/nx-X11/lib/dps/dpsexcept.c
new file mode 100644
index 000000000..cd404dd86
--- /dev/null
+++ b/nx-X11/lib/dps/dpsexcept.c
@@ -0,0 +1,73 @@
+/*
+ *  dpsexcept.c
+ *
+ * (c) Copyright 1984-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: $ */
+
+/*
+Original version: Jeffrey Mogul, Stanford, 18 February 1983
+*/
+
+#ifdef VMS
+/* Add publictype.h to get a lowercase definition of "false" */
+#include "publictypes.h"
+#endif /* VMS */
+
+#include "DPS/dpsexcept.h"
+
+_Exc_Buf *_Exc_Header;
+
+
+
+void DPSRaise(code, msg)
+  int code; char *msg; {
+  register _Exc_Buf *EBp = _Exc_Header;
+
+  if (EBp == 0)	{	/* uncaught exception */
+    DPSCantHappen();
+    }
+
+  EBp->Code = code;
+  EBp->Message = msg;
+  _Exc_Header = EBp->Prev;
+  longjmp(EBp->Environ, 1);
+  }
+
+#ifndef XDPS
+void DPSCantHappen() {
+  abort();
+  }
+#endif /* XDPS */
diff --git a/nx-X11/lib/dps/dpsfontops.psw b/nx-X11/lib/dps/dpsfontops.psw
new file mode 100644
index 000000000..9958e776a
--- /dev/null
+++ b/nx-X11/lib/dps/dpsfontops.psw
@@ -0,0 +1,109 @@
+/* dpsfontops.psw
+ *
+ * (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
+ */
+
+defineps DPSFontDirectory(DPSContext ctxt)
+	FontDirectory 
+endps
+
+defineps DPSISOLatin1Encoding(DPSContext ctxt)
+	ISOLatin1Encoding 
+endps
+
+defineps DPSSharedFontDirectory(DPSContext ctxt)
+	SharedFontDirectory 
+endps
+
+defineps DPSStandardEncoding(DPSContext ctxt)
+	StandardEncoding 
+endps
+
+defineps DPScachestatus(DPSContext ctxt)
+	cachestatus 
+endps
+
+defineps DPScurrentcacheparams(DPSContext ctxt)
+	currentcacheparams 
+endps
+
+defineps DPScurrentfont(DPSContext ctxt)
+	currentfont 
+endps
+
+defineps DPSdefinefont(DPSContext ctxt)
+	definefont 
+endps
+
+defineps DPSfindfont(DPSContext ctxt; char *name)
+	/name findfont 
+endps
+
+defineps DPSmakefont(DPSContext ctxt)
+	makefont 
+endps
+
+defineps DPSscalefont(DPSContext ctxt; float size)
+	size scalefont
+endps
+
+defineps DPSselectfont(DPSContext ctxt; char *name; float scale)
+	/name scale selectfont 
+endps
+
+defineps DPSsetcachedevice(DPSContext ctxt; float wx, wy, llx, lly, urx, ury)
+	wx wy llx lly urx ury setcachedevice 
+endps
+
+defineps DPSsetcachelimit(DPSContext ctxt; int n)
+	n setcachelimit 
+endps
+
+defineps DPSsetcacheparams(DPSContext ctxt)
+	setcacheparams 
+endps
+
+defineps DPSsetcharwidth(DPSContext ctxt; float wx, wy)
+	wx wy setcharwidth 
+endps
+
+defineps DPSsetfont(DPSContext ctxt; userobject f)
+	f setfont 
+endps
+
+defineps DPSundefinefont(DPSContext ctxt; char *name)
+	/name undefinefont 
+endps
+
diff --git a/nx-X11/lib/dps/dpsgsttops.psw b/nx-X11/lib/dps/dpsgsttops.psw
new file mode 100644
index 000000000..d9b2728e7
--- /dev/null
+++ b/nx-X11/lib/dps/dpsgsttops.psw
@@ -0,0 +1,213 @@
+/* dpsgsttops.psw
+ *
+ * (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
+ */
+
+defineps DPSconcat(DPSContext ctxt; float m[6])
+	m concat
+endps
+
+defineps DPScurrentdash(DPSContext ctxt)
+	currentdash 
+endps
+
+defineps DPScurrentflat(DPSContext ctxt | float *flatness)
+	currentflat flatness 
+endps
+
+defineps DPScurrentgray(DPSContext ctxt | float *gray)
+	currentgray gray 
+endps
+
+defineps DPScurrentgstate(DPSContext ctxt; userobject gst)
+	gst currentgstate 
+endps
+
+defineps DPScurrenthalftone(DPSContext ctxt)
+	currenthalftone 
+endps
+
+defineps DPScurrenthalftonephase(DPSContext ctxt | float *x, *y)
+	currenthalftonephase y x 
+endps
+
+defineps DPScurrenthsbcolor(DPSContext ctxt | float *h, *s, *b)
+	currenthsbcolor b s h 
+endps
+
+defineps DPScurrentlinecap(DPSContext ctxt | int *linecap)
+	currentlinecap linecap 
+endps
+
+defineps DPScurrentlinejoin(DPSContext ctxt | int *linejoin)
+	currentlinejoin linejoin 
+endps
+
+defineps DPScurrentlinewidth(DPSContext ctxt | float *width)
+	currentlinewidth width 
+endps
+
+defineps DPScurrentmatrix(DPSContext ctxt)
+	currentmatrix 
+endps
+
+defineps DPScurrentmiterlimit(DPSContext ctxt | float *limit)
+	currentmiterlimit limit 
+endps
+
+defineps DPScurrentpoint(DPSContext ctxt | float *x, *y)
+	currentpoint y x 
+endps
+
+defineps DPScurrentrgbcolor(DPSContext ctxt | float *r, *g, *b)
+	currentrgbcolor b g r 
+endps
+
+defineps DPScurrentscreen(DPSContext ctxt)
+	currentscreen 
+endps
+
+defineps DPScurrentstrokeadjust(DPSContext ctxt | boolean *b)
+	currentstrokeadjust b 
+endps
+
+defineps DPScurrenttransfer(DPSContext ctxt)
+	currenttransfer 
+endps
+
+defineps DPSdefaultmatrix(DPSContext ctxt)
+	defaultmatrix 
+endps
+
+defineps DPSgrestore(DPSContext ctxt)
+	grestore 
+endps
+
+defineps DPSgrestoreall(DPSContext ctxt)
+	grestoreall 
+endps
+
+defineps DPSgsave(DPSContext ctxt)
+	gsave 
+endps
+
+defineps DPSgstate(DPSContext ctxt)
+	gstate 
+endps
+
+defineps DPSinitgraphics(DPSContext ctxt)
+	initgraphics 
+endps
+
+defineps DPSinitmatrix(DPSContext ctxt)
+	initmatrix 
+endps
+
+defineps DPSrotate(DPSContext ctxt; float angle)
+	angle rotate 
+endps
+
+defineps DPSscale(DPSContext ctxt; float x, y)
+	x y scale 
+endps
+
+defineps DPSsetdash(DPSContext ctxt; float pat[size]; int size; float offset)
+	pat offset setdash
+endps
+
+defineps DPSsetflat(DPSContext ctxt; float flatness)
+	flatness setflat 
+endps
+
+defineps DPSsetgray(DPSContext ctxt; float gray)
+	gray setgray 
+endps
+
+defineps DPSsetgstate(DPSContext ctxt; userobject gst)
+	gst setgstate 
+endps
+
+defineps DPSsethalftone(DPSContext ctxt)
+	sethalftone 
+endps
+
+defineps DPSsethalftonephase(DPSContext ctxt; float x, y)
+	x y sethalftonephase 
+endps
+
+defineps DPSsethsbcolor(DPSContext ctxt; float h, s, b)
+	h s b sethsbcolor 
+endps
+
+defineps DPSsetlinecap(DPSContext ctxt; int linecap)
+	linecap setlinecap 
+endps
+
+defineps DPSsetlinejoin(DPSContext ctxt; int linejoin)
+	linejoin setlinejoin 
+endps
+
+defineps DPSsetlinewidth(DPSContext ctxt; float width)
+	width setlinewidth 
+endps
+
+defineps DPSsetmatrix(DPSContext ctxt)
+	setmatrix 
+endps
+
+defineps DPSsetmiterlimit(DPSContext ctxt; float limit)
+	limit setmiterlimit 
+endps
+
+defineps DPSsetrgbcolor(DPSContext ctxt; float r, g, b)
+	r g b setrgbcolor 
+endps
+
+defineps DPSsetscreen(DPSContext ctxt)
+	setscreen 
+endps
+
+defineps DPSsetstrokeadjust(DPSContext ctxt; boolean b)
+	b setstrokeadjust 
+endps
+
+defineps DPSsettransfer(DPSContext ctxt)
+	settransfer 
+endps
+
+defineps DPStranslate(DPSContext ctxt; float x, y)
+	x y translate 
+endps
+
diff --git a/nx-X11/lib/dps/dpsifdef.txt b/nx-X11/lib/dps/dpsifdef.txt
new file mode 100644
index 000000000..d44b7c85f
--- /dev/null
+++ b/nx-X11/lib/dps/dpsifdef.txt
@@ -0,0 +1,7 @@
+#ifndef DPSOPS_H
+#define DPSOPS_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
diff --git a/nx-X11/lib/dps/dpsint.h b/nx-X11/lib/dps/dpsint.h
new file mode 100644
index 000000000..8d5ede870
--- /dev/null
+++ b/nx-X11/lib/dps/dpsint.h
@@ -0,0 +1,125 @@
+/*
+ * dpsint.h	-- internal definitions to dpsclient.c
+ *
+ * (c) Copyright 1989-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
+ */
+
+#ifndef DPSINT_H
+#define DPSINT_H
+
+#include <DPS/dpsXclient.h>
+
+#include "publictypes.h"
+#include "dpsassert.h"
+
+#include "dpsprivate.h"
+#include "dpsXint.h"
+#include "dpsdict.h"
+
+typedef struct _t_ContextBufferRec {
+  struct _t_ContextBufferRec *next;
+  } ContextBufferRec, *ContextBuffer;
+
+typedef struct {
+  ContextBuffer gcontextBuffers;
+  integer gqueuedBuffers;
+  DPSProcs gctxProcs, gtextCtxProcs, gdummyCtxProcs;
+  DPSSpaceProcs gspaceProcs;
+  DPSPrivSpace gspaces;
+  char **guserNames;
+  integer guserNamesLength;
+  PSWDict guserNameDict;
+  boolean gclientStarted;
+  DPSContext gdummyCtx;
+  integer ginitFailed, gglobLastNameIndex;
+  DPSPrivSpace gTextSpace;
+} GlobalsRec, *Globals;
+
+extern Globals DPSglobals;
+
+#define contextBuffers DPSglobals->gcontextBuffers
+#define queuedBuffers DPSglobals->gqueuedBuffers
+#define ctxProcs DPSglobals->gctxProcs
+#define textCtxProcs DPSglobals->gtextCtxProcs
+#define dummyCtxProcs DPSglobals->gdummyCtxProcs
+#define spaceProcs DPSglobals->gspaceProcs
+#define spaces DPSglobals->gspaces
+#define userNames DPSglobals->guserNames
+#define userNamesLength DPSglobals->guserNamesLength
+#define userNameDict DPSglobals->guserNameDict
+#define clientStarted DPSglobals->gclientStarted
+#define dummyCtx DPSglobals->gdummyCtx
+#define initFailed DPSglobals->ginitFailed
+#define globLastNameIndex DPSglobals->gglobLastNameIndex
+#define textSpace DPSglobals->gTextSpace
+
+extern boolean DPSCheckShared(DPSPrivContext ctxt);
+extern boolean DPSKnownContext(DPSContext ctxt);
+extern boolean DPSKnownSpace(DPSSpace space);
+extern boolean DPSPrivateCheckWait(DPSContext ctxt);
+extern void DPSCheckInitClientGlobals(void);
+extern void DPSPrivateDestroyContext(DPSContext ctxt);
+extern void DPSPrivateDestroySpace(DPSSpace space);
+extern void DPSSafeSetLastNameIndex(DPSContext ctxt);
+extern void DPSclientPrintProc(DPSContext ctxt, char *buf, unsigned nch);
+extern void DPSinnerProcWriteData(DPSContext ctxt, char *buf, unsigned int count);
+
+extern void DPSDefaultPrivateHandler(
+  DPSContext ctxt,
+  DPSErrorCode errorCode,
+  long unsigned int arg1,
+  long unsigned int arg2,
+  char *prefix,
+  char *suffix);
+
+extern char *DPScalloc(integer e, integer n);
+
+extern DPSContext DPSCreateContext(
+  char *wh,
+  DPSTextProc textProc,
+  DPSErrorProc errorProc,
+  DPSSpace space);
+
+extern void DPSHandleBogusError(DPSContext ctxt, char *prefix, char *suffix);
+extern void DPSInitCommonContextProcs(DPSProcs p);
+extern void DPSInitCommonSpaceProcs(DPSSpaceProcs p);
+extern void DPSInitCommonTextContextProcs(DPSProcs p);
+extern void DPSInitPrivateContextFields(DPSPrivContext c, DPSPrivSpace s);
+extern void DPSInitPrivateContextProcs(DPSProcs p);
+extern void DPSInitPrivateSpaceFields(DPSPrivSpace s);
+extern void DPSInitPrivateTextContextFields(DPSPrivContext c, DPSPrivSpace s);
+extern void DPSServicePostScript(boolean (*returnControl)(void));
+
+#endif /* DPSINT_H */
diff --git a/nx-X11/lib/dps/dpsioops.psw b/nx-X11/lib/dps/dpsioops.psw
new file mode 100644
index 000000000..dec3bb7c3
--- /dev/null
+++ b/nx-X11/lib/dps/dpsioops.psw
@@ -0,0 +1,153 @@
+/* dpsioops.psw
+ *
+ * (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
+ */
+
+defineps DPSequals(DPSContext ctxt)
+	=
+endps
+
+defineps DPSequalsequals(DPSContext ctxt)
+	==
+endps
+
+defineps DPSbytesavailable(DPSContext ctxt | int *n)
+	bytesavailable n 
+endps
+
+defineps DPSclosefile(DPSContext ctxt)
+	closefile 
+endps
+
+defineps DPScurrentfile(DPSContext ctxt)
+	currentfile 
+endps
+
+defineps DPSdeletefile(DPSContext ctxt; char *filename)
+	(filename) deletefile 
+endps
+
+defineps DPSecho(DPSContext ctxt; boolean b)
+	b echo 
+endps
+
+defineps DPSfile(DPSContext ctxt; char *name, *access)
+	(name) (access) file 
+endps
+
+defineps DPSfilenameforall(DPSContext ctxt)
+	filenameforall 
+endps
+
+defineps DPSfileposition(DPSContext ctxt | int *pos)
+	fileposition pos 
+endps
+
+defineps DPSflush(DPSContext ctxt)
+	flush 
+endps
+
+defineps DPSflushfile(DPSContext ctxt)
+	flushfile 
+endps
+
+defineps DPSprint(DPSContext ctxt)
+	print 
+endps
+
+defineps DPSprintobject(DPSContext ctxt; int tag)
+	tag printobject
+endps
+
+defineps DPSpstack(DPSContext ctxt)
+	pstack 
+endps
+
+defineps DPSread(DPSContext ctxt| boolean *b)
+	read b
+endps
+
+defineps DPSreadhexstring(DPSContext ctxt| boolean *b)
+	readhexstring b
+endps
+
+defineps DPSreadline(DPSContext ctxt| boolean *b)
+	readline b
+endps
+
+defineps DPSreadstring(DPSContext ctxt| boolean *b)
+	readstring b
+endps
+
+defineps DPSrenamefile(DPSContext ctxt; char *oldname, *newname)
+	(oldname) (newname) renamefile 
+endps
+
+defineps DPSresetfile(DPSContext ctxt)
+	resetfile 
+endps
+
+defineps DPSsetfileposition(DPSContext ctxt; int pos)
+	pos setfileposition 
+endps
+
+defineps DPSstack(DPSContext ctxt)
+	stack 
+endps
+
+defineps DPSstatus(DPSContext ctxt | boolean *b)
+	status b 
+endps
+
+defineps DPStoken(DPSContext ctxt| boolean *b)
+	token b
+endps
+
+defineps DPSwrite(DPSContext ctxt)
+	write 
+endps
+
+defineps DPSwritehexstring(DPSContext ctxt)
+	writehexstring 
+endps
+
+defineps DPSwriteobject(DPSContext ctxt; int tag)
+	tag writeobject
+endps
+
+defineps DPSwritestring(DPSContext ctxt)
+	writestring 
+endps
+
diff --git a/nx-X11/lib/dps/dpsl2ops.psw b/nx-X11/lib/dps/dpsl2ops.psw
new file mode 100644
index 000000000..67c1aee22
--- /dev/null
+++ b/nx-X11/lib/dps/dpsl2ops.psw
@@ -0,0 +1,208 @@
+/* dpsl2ops.psw
+ * (c) Copyright 1991-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
+ */
+
+defineps DPSleftbracket(DPSContext ctxt)
+	mark					% [ annoys pswrap
+endps
+
+defineps DPSrightbracket(DPSContext ctxt)
+	counttomark array astore exch pop	% ] annoys pswrap
+endps
+
+defineps DPSleftleft(DPSContext ctxt)
+	<<
+endps
+
+defineps DPSrightright(DPSContext ctxt)
+	>>
+endps
+
+defineps DPScshow(DPSContext ctxt; char *s)
+	(s) cshow
+endps
+
+defineps DPScurrentcolor(DPSContext ctxt)
+	currentcolor    
+endps
+
+defineps DPScurrentcolorrendering(DPSContext ctxt)
+	currentcolorrendering
+endps
+
+defineps DPScurrentcolorspace(DPSContext ctxt)
+	currentcolorspace
+endps
+
+defineps DPScurrentdevparams(DPSContext ctxt; char *dev)
+	(dev) currentdevparams
+endps
+
+defineps DPScurrentglobal(DPSContext ctxt | boolean *b)
+	currentglobal b
+endps
+
+defineps DPScurrentoverprint(DPSContext ctxt | boolean *b)
+	currentoverprint b
+endps
+
+defineps DPScurrentpagedevice(DPSContext ctxt)
+	currentpagedevice
+endps
+
+defineps DPScurrentsystemparams(DPSContext ctxt)
+	currentsystemparams
+endps
+
+defineps DPScurrentuserparams(DPSContext ctxt)
+	currentuserparams
+endps
+
+defineps DPSdefineresource(DPSContext ctxt; char *category)
+	/category defineresource
+endps
+
+defineps DPSexecform(DPSContext ctxt)
+	execform
+endps
+
+defineps DPSfilter(DPSContext ctxt)
+	filter
+endps
+
+defineps DPSfindencoding(DPSContext ctxt; char *key)
+	/key findencoding
+endps
+
+defineps DPSfindresource(DPSContext ctxt; char *key, *category)
+	/key /category findresource
+endps
+
+defineps DPSgcheck(DPSContext ctxt | boolean *b)
+	gcheck b
+endps
+
+defineps DPSglobaldict(DPSContext ctxt)
+	globaldict
+endps
+
+defineps DPSGlobalFontDirectory(DPSContext ctxt)
+	GlobalFontDirectory
+endps
+
+defineps DPSglyphshow(DPSContext ctxt; char *name)
+	/name glyphshow
+endps
+
+defineps DPSlanguagelevel(DPSContext ctxt | int *n)
+	languagelevel n
+endps
+
+defineps DPSmakepattern(DPSContext ctxt)
+	makepattern
+endps
+
+defineps DPSproduct(DPSContext ctxt)
+	product
+endps
+
+defineps DPSresourceforall(DPSContext ctxt; char *category)
+	/category resourceforall
+endps
+
+defineps DPSresourcestatus(DPSContext ctxt; char *key, *category; | boolean *b)
+	/key /category resourcestatus b
+endps
+
+defineps DPSrevision(DPSContext ctxt | int *n)
+	revision n
+endps
+
+defineps DPSrootfont(DPSContext ctxt)
+	rootfont
+endps
+
+defineps DPSserialnumber(DPSContext ctxt | int *n)
+	serialnumber n
+endps
+
+defineps DPSsetcolor(DPSContext ctxt)
+	setcolor
+endps
+
+defineps DPSsetcolorrendering(DPSContext ctxt)
+	setcolorrendering
+endps
+
+defineps DPSsetcolorspace(DPSContext ctxt)
+	setcolorspace
+endps
+
+defineps DPSsetdevparams(DPSContext ctxt)
+	setdevparams
+endps
+
+defineps DPSsetglobal(DPSContext ctxt; boolean b)
+	b setglobal
+endps
+
+defineps DPSsetoverprint(DPSContext ctxt; boolean b)
+	b setoverprint
+endps
+
+defineps DPSsetpagedevice(DPSContext ctxt)
+	setpagedevice
+endps
+
+defineps DPSsetpattern(DPSContext ctxt)
+	setpattern
+endps
+
+defineps DPSsetsystemparams(DPSContext ctxt)
+	setsystemparams
+endps
+
+defineps DPSsetuserparams(DPSContext ctxt)
+	setuserparams
+endps
+
+defineps DPSstartjob(DPSContext ctxt; boolean b; char *password)
+	b password startjob
+endps
+
+defineps DPSundefineresource(DPSContext ctxt; char *key, *category)
+	/key /category undefineresource
+endps
+
diff --git a/nx-X11/lib/dps/dpsmathops.psw b/nx-X11/lib/dps/dpsmathops.psw
new file mode 100644
index 000000000..e7ada11af
--- /dev/null
+++ b/nx-X11/lib/dps/dpsmathops.psw
@@ -0,0 +1,125 @@
+/* dpsmathops.psw
+ *
+ * (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
+ */
+
+defineps DPSabs(DPSContext ctxt)
+	abs 
+endps
+
+defineps DPSadd(DPSContext ctxt)
+	add 
+endps
+
+defineps DPSand(DPSContext ctxt)
+	and 
+endps
+
+defineps DPSatan(DPSContext ctxt)
+	atan 
+endps
+
+defineps DPSbitshift(DPSContext ctxt; int shift)
+	shift bitshift
+endps
+
+defineps DPSceiling(DPSContext ctxt)
+	ceiling 
+endps
+
+defineps DPScos(DPSContext ctxt)
+	cos 
+endps
+
+defineps DPSdiv(DPSContext ctxt)
+	div 
+endps
+
+defineps DPSexp(DPSContext ctxt)
+	exp 
+endps
+
+defineps DPSfloor(DPSContext ctxt)
+	floor 
+endps
+
+defineps DPSidiv(DPSContext ctxt)
+	idiv 
+endps
+
+defineps DPSln(DPSContext ctxt)
+	ln 
+endps
+
+defineps DPSlog(DPSContext ctxt)
+	log 
+endps
+
+defineps DPSmod(DPSContext ctxt)
+	mod 
+endps
+
+defineps DPSmul(DPSContext ctxt)
+	mul 
+endps
+
+defineps DPSneg(DPSContext ctxt)
+	neg 
+endps
+
+defineps DPSround(DPSContext ctxt)
+	round 
+endps
+
+defineps DPSsin(DPSContext ctxt)
+	sin 
+endps
+
+defineps DPSsqrt(DPSContext ctxt)
+	sqrt 
+endps
+
+defineps DPSsub(DPSContext ctxt)
+	sub 
+endps
+
+defineps DPStruncate(DPSContext ctxt)
+	truncate 
+endps
+
+defineps DPSxor(DPSContext ctxt)
+	xor 
+endps
+
diff --git a/nx-X11/lib/dps/dpsmiscops.psw b/nx-X11/lib/dps/dpsmiscops.psw
new file mode 100644
index 000000000..6b5bb8078
--- /dev/null
+++ b/nx-X11/lib/dps/dpsmiscops.psw
@@ -0,0 +1,53 @@
+/* dpsmiscops.psw
+ *
+ * (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
+ */
+
+defineps DPSbanddevice(DPSContext ctxt)
+	banddevice 
+endps
+
+defineps DPSframedevice(DPSContext ctxt)
+	framedevice 
+endps
+
+defineps DPSnulldevice(DPSContext ctxt)
+	nulldevice 
+endps
+
+defineps DPSrenderbands(DPSContext ctxt)
+	renderbands 
+endps
+
diff --git a/nx-X11/lib/dps/dpsmtrxops.psw b/nx-X11/lib/dps/dpsmtrxops.psw
new file mode 100644
index 000000000..6b5303ba0
--- /dev/null
+++ b/nx-X11/lib/dps/dpsmtrxops.psw
@@ -0,0 +1,65 @@
+/* dpsmtrxops.psw
+ *
+ * (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
+ */
+
+defineps DPSconcatmatrix(DPSContext ctxt)
+	concatmatrix 
+endps
+
+defineps DPSdtransform(DPSContext ctxt; float x1, y1 | float *x2, *y2)
+	x1 y1 dtransform y2 x2 
+endps
+
+defineps DPSidentmatrix(DPSContext ctxt)
+	identmatrix 
+endps
+
+defineps DPSidtransform(DPSContext ctxt; float x1, y1 | float *x2, *y2)
+	x1 y1 idtransform y2 x2 
+endps
+
+defineps DPSinvertmatrix(DPSContext ctxt)
+	invertmatrix 
+endps
+
+defineps DPSitransform(DPSContext ctxt; float x1, y1 | float *x2, *y2)
+	x1 y1 itransform y2 x2 
+endps
+
+defineps DPStransform(DPSContext ctxt; float x1, y1 | float *x2, *y2)
+	x1 y1 transform y2 x2 
+endps
+
diff --git a/nx-X11/lib/dps/dpsname.txt b/nx-X11/lib/dps/dpsname.txt
new file mode 100644
index 000000000..ab32b7f7d
--- /dev/null
+++ b/nx-X11/lib/dps/dpsname.txt
@@ -0,0 +1,4 @@
+/*
+ * dpsops.h
+ */
+
diff --git a/nx-X11/lib/dps/dpsopstack.psw b/nx-X11/lib/dps/dpsopstack.psw
new file mode 100644
index 000000000..ac10d77c5
--- /dev/null
+++ b/nx-X11/lib/dps/dpsopstack.psw
@@ -0,0 +1,96 @@
+/*
+ * dpsopstack.psw -- wrapped procedures for sending and getting operands
+ *
+ * (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
+ */
+
+defineps DPSgetboolean(DPSContext ctxt | boolean *it)
+	it
+endps
+
+defineps DPSgetchararray(DPSContext ctxt; int size | char s[size])
+	s
+endps
+
+defineps DPSgetfloat(DPSContext ctxt | float *it)
+	it
+endps
+
+defineps DPSgetfloatarray(DPSContext ctxt; int size | float a[size])
+	dup type /arraytype eq { a } { size { a } repeat } ifelse
+endps
+
+defineps DPSgetint(DPSContext ctxt | int *it)
+	it
+endps
+
+defineps DPSgetintarray(DPSContext ctxt; int size | int a[size])
+	dup type /arraytype eq { a } { size { a } repeat } ifelse
+endps
+
+defineps DPSgetstring(DPSContext ctxt | char *s)
+	s
+endps
+
+defineps DPSsendboolean(DPSContext ctxt; boolean it)
+	it
+endps
+
+defineps DPSsendchararray(DPSContext ctxt; char s[size]; int size)
+	(s)
+endps
+
+defineps DPSsendfloat(DPSContext ctxt; float it)
+	it
+endps
+
+defineps DPSsendfloatarray(DPSContext ctxt; float a[size]; int size)
+	a
+endps
+
+defineps DPSsendint(DPSContext ctxt; int it)
+	it
+endps
+
+defineps DPSsendintarray(DPSContext ctxt; int a[size]; int size)
+	a
+endps
+
+defineps DPSsendstring(DPSContext ctxt; char *s)
+	(s)
+endps
+
+
+
diff --git a/nx-X11/lib/dps/dpspathops.psw b/nx-X11/lib/dps/dpspathops.psw
new file mode 100644
index 000000000..7c0ed7600
--- /dev/null
+++ b/nx-X11/lib/dps/dpspathops.psw
@@ -0,0 +1,169 @@
+/* dpspathops.psw
+ *
+ * (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
+ */
+
+defineps DPSarc(DPSContext ctxt; float x, y, r, angle1, angle2)
+	x y r angle1 angle2 arc 
+endps
+
+defineps DPSarcn(DPSContext ctxt; float x, y, r, angle1, angle2)
+	x y r angle1 angle2 arcn 
+endps
+
+defineps DPSarct(DPSContext ctxt; float x1, y1, x2, y2, r)
+	x1 y1 x2 y2 r arct 
+endps
+
+defineps DPSarcto(DPSContext ctxt; float x1, y1, x2, y2, r | float *xt1, *yt1, *xt2, *yt2)
+	x1 y1 x2 y2 r arcto yt2 xt2 yt1 xt1 
+endps
+
+defineps DPScharpath(DPSContext ctxt; char *s; boolean b)
+	(s) b charpath 
+endps
+
+defineps DPSclip(DPSContext ctxt)
+	clip 
+endps
+
+defineps DPSclippath(DPSContext ctxt)
+	clippath 
+endps
+
+defineps DPSclosepath(DPSContext ctxt)
+	closepath 
+endps
+
+defineps DPScurveto(DPSContext ctxt; float x1, y1, x2, y2, x3, y3)
+	x1 y1 x2 y2 x3 y3 curveto 
+endps
+
+defineps DPSeoclip(DPSContext ctxt)
+	eoclip 
+endps
+
+defineps DPSeoviewclip(DPSContext ctxt)
+	eoviewclip 
+endps
+
+defineps DPSflattenpath(DPSContext ctxt)
+	flattenpath 
+endps
+
+defineps DPSinitclip(DPSContext ctxt)
+	initclip 
+endps
+
+defineps DPSinitviewclip(DPSContext ctxt)
+	initviewclip 
+endps
+
+defineps DPSlineto(DPSContext ctxt; float x, y)
+	x y lineto 
+endps
+
+defineps DPSmoveto(DPSContext ctxt; float x, y)
+	x y moveto 
+endps
+
+defineps DPSnewpath(DPSContext ctxt)
+	newpath 
+endps
+
+defineps DPSpathbbox(DPSContext ctxt | float *llx, *lly, *urx, *ury)
+	pathbbox ury urx lly llx 
+endps
+
+defineps DPSpathforall(DPSContext ctxt)
+	pathforall 
+endps
+
+defineps DPSrcurveto(DPSContext ctxt; float x1, y1, x2, y2, x3, y3)
+	x1 y1 x2 y2 x3 y3 rcurveto 
+endps
+
+defineps DPSrectclip(DPSContext ctxt; float x, y, w, h)
+	x y w h rectclip 
+endps
+
+defineps DPSrectviewclip(DPSContext ctxt; float x, y, w, h)
+	x y w h rectviewclip 
+endps
+
+defineps DPSreversepath(DPSContext ctxt)
+	reversepath 
+endps
+
+defineps DPSrlineto(DPSContext ctxt; float x, y)
+	x y rlineto 
+endps
+
+defineps DPSrmoveto(DPSContext ctxt; float x, y)
+	x y rmoveto 
+endps
+
+defineps DPSsetbbox(DPSContext ctxt; float llx, lly, urx, ury)
+	llx lly urx ury setbbox 
+endps
+
+defineps DPSsetucacheparams(DPSContext ctxt)
+	setucacheparams 
+endps
+
+defineps DPSuappend(DPSContext ctxt; char nums[n]; int n; char ops[l]; int l)
+	[(nums) (ops)] uappend
+endps
+
+defineps DPSucache(DPSContext ctxt)
+	ucache 
+endps
+
+defineps DPSucachestatus(DPSContext ctxt)
+	ucachestatus 
+endps
+
+defineps DPSupath(DPSContext ctxt; boolean b)
+	b upath 
+endps
+
+defineps DPSviewclip(DPSContext ctxt)
+	viewclip 
+endps
+
+defineps DPSviewclippath(DPSContext ctxt)
+	viewclippath 
+endps
+
diff --git a/nx-X11/lib/dps/dpspntops.psw b/nx-X11/lib/dps/dpspntops.psw
new file mode 100644
index 000000000..e57de4997
--- /dev/null
+++ b/nx-X11/lib/dps/dpspntops.psw
@@ -0,0 +1,129 @@
+/* dpspntops.psw
+ *
+ * (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
+ */
+
+defineps DPSashow(DPSContext ctxt; float x, y; char *s)
+	x y (s) ashow 
+endps
+
+defineps DPSawidthshow(DPSContext ctxt; float cx, cy; int c; float ax, ay; char *s)
+	cx cy c ax ay (s) awidthshow 
+endps
+
+defineps DPScopypage(DPSContext ctxt)
+	copypage 
+endps
+
+defineps DPSeofill(DPSContext ctxt)
+	eofill 
+endps
+
+defineps DPSerasepage(DPSContext ctxt)
+	erasepage 
+endps
+
+defineps DPSfill(DPSContext ctxt)
+	fill 
+endps
+
+defineps DPSimage(DPSContext ctxt)
+	image 
+endps
+
+defineps DPSimagemask(DPSContext ctxt)
+	imagemask 
+endps
+
+defineps DPSkshow(DPSContext ctxt; char *s)
+	(s) kshow
+endps
+
+defineps DPSrectfill(DPSContext ctxt; float x, y, w, h)
+	x y w h rectfill 
+endps
+
+defineps DPSrectstroke(DPSContext ctxt; float x, y, w, h)
+	x y w h rectstroke 
+endps
+
+defineps DPSshow(DPSContext ctxt; char *s)
+	(s) show 
+endps
+
+defineps DPSshowpage(DPSContext ctxt)
+	showpage 
+endps
+
+defineps DPSstroke(DPSContext ctxt)
+	stroke 
+endps
+
+defineps DPSstrokepath(DPSContext ctxt)
+	strokepath 
+endps
+
+defineps DPSueofill(DPSContext ctxt; char nums[n]; int n; char ops[l]; int l)
+	[(nums) (ops)] ueofill
+endps
+
+defineps DPSufill(DPSContext ctxt; char nums[n]; int n; char ops[l]; int l)
+	[(nums) (ops)] ufill
+endps
+
+defineps DPSustroke(DPSContext ctxt; char nums[n]; int n; char ops[l]; int l)
+	[(nums) (ops)] ustroke
+endps
+
+defineps DPSustrokepath(DPSContext ctxt; char nums[n]; int n; char ops[l]; int l)
+	[(nums) (ops)] ustrokepath
+endps
+
+defineps DPSwidthshow(DPSContext ctxt; float x, y; int c; char *s)
+	x y c (s) widthshow 
+endps
+
+defineps DPSxshow(DPSContext ctxt; char *s; float numarray[size]; int size)
+	(s) numarray xshow
+endps
+
+defineps DPSxyshow(DPSContext ctxt; char *s; float numarray[size]; int size)
+	(s) numarray xyshow
+endps
+
+defineps DPSyshow(DPSContext ctxt; char *s; float numarray[size]; int size)
+	(s) numarray yshow
+endps
+
diff --git a/nx-X11/lib/dps/dpsprintf.c b/nx-X11/lib/dps/dpsprintf.c
new file mode 100644
index 000000000..79d8172b6
--- /dev/null
+++ b/nx-X11/lib/dps/dpsprintf.c
@@ -0,0 +1,68 @@
+/*
+ * dpsprintf.c
+ *
+ * (c) Copyright 1985-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: xc/lib/dps/dpsprintf.c,v 1.3 2000/09/26 15:57:00 tsi Exp $ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "publictypes.h"
+#include "DPS/dpsclient.h"
+
+#ifdef USE_DOPRINT
+extern void DPSdoprint();
+#endif /* USE_DOPRINT */
+
+#include <stdarg.h>
+
+void DPSPrintf(DPSContext ctxt, char *fmt, ...)
+{
+    va_list args;
+
+    va_start(args, fmt);
+
+#ifdef USE_DOPRINT
+    DPSdoprint(ctxt, fmt, &args);
+#else /* USE_DOPRINT */
+    {
+	char buffer[10000];
+	vsprintf(buffer, fmt, args);
+	DPSWritePostScript(ctxt, buffer, strlen(buffer));
+    }
+#endif /* USE_DOPRINT */
+    va_end(args);
+}
diff --git a/nx-X11/lib/dps/dpsprivate.h b/nx-X11/lib/dps/dpsprivate.h
new file mode 100644
index 000000000..0392eedd6
--- /dev/null
+++ b/nx-X11/lib/dps/dpsprivate.h
@@ -0,0 +1,127 @@
+/*
+ * dpsprivate.h -- Private interface for the DPS client library implementation.
+ *
+ * (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
+ */
+
+#ifndef	DPSPRIVATE_H
+#define	DPSPRIVATE_H
+
+#include "DPS/dpsconfig.h"
+#include "DPS/dpsclient.h"
+
+typedef enum {
+  dps_hiFirst, dps_loFirst
+  } DPSByteOrder;
+
+typedef enum {
+  dps_ieee, dps_native
+  } DPSNumFormat;
+
+typedef void (*DPSClientPrintProc)(
+  DPSContext		/* cid */,
+  char *		/* buf */,
+  unsigned int		/* count */);
+  /* Call-back procedure to handle output from the PostScript server for
+     context with id 'cid'. Passed to DPSServicePostScript.
+    'buf' contains 'count' bytes. */
+
+extern void DPSInitClient(
+  DPSTextProc		textProc,
+  void			(* /* releaseProc */) (char *, char *));
+/* Initialize the environment-specific parts of the client library */
+
+#ifndef DPSDefaultProgramEncoding
+#define DPSDefaultProgramEncoding dps_binObjSeq
+#endif /* not DPSDefaultProgramEncoding */
+
+#ifndef DPSDefaultByteOrder
+#if SWAPBITS
+#define DPSDefaultByteOrder dps_loFirst
+#else /* SWAPBITS */
+#define DPSDefaultByteOrder dps_hiFirst
+#endif /* SWAPBITS */
+#endif /* DPSDefaultByteOrder */
+
+#ifndef DPSDefaultNumFormat
+#if IEEEFLOAT
+#define DPSDefaultNumFormat dps_ieee
+#else /* IEEEFLOAT */
+#define DPSDefaultNumFormat dps_native
+#endif /* IEEEFLOAT */
+#endif /* not DPSDefaultNumFormat */
+
+#ifndef DPSDefaultNameEncoding
+#define DPSDefaultNameEncoding dps_indexed
+#endif /* not DPSDefaultNameEncoding */
+
+extern void DPSCheckRaiseError(DPSContext c);
+  /* Checks the resynching flag in a DPSPrivContext and raises an exception
+     if true */
+
+/* system name table boundaries */
+#define DPS_LAST_COMMON_SYSNAME		212
+#define DPS_FIRST_AUX_SYSNAME		256
+#define DPS_LAST_AUX_SYSNAME		427
+
+extern char **DPSSysNames;
+extern char **DPSSysNamesAux;
+
+  /* System name tables.  DPSSysNames[index] is the string for the name.
+     DPSSysNamesAux[index - DPS_FIRST_AUX_SYSNAME] is the string
+     for an uncommon system name. */
+
+extern int DPSInitialize(void);
+extern void DPSInitSysNames(void);
+
+extern char *DPSSetWh(DPSContext /* ctxt */, char * /* newWh */);
+  /* set new window handle, returns old window handle */
+
+extern void DPSOutOfMemory(void);
+  /*
+     This is called by the DPS software when it cannot allocate any more
+     storage from the heap (e.g., when malloc returns NIL).
+
+     MAC ONLY
+     DPSOutOfMemory calls CantHappen (see dpsexcept.h) unless you
+     have used DPSSetOutOfMemoryProc to establish a different procedure
+     to be called, in which case DPSOutOfMemory calls your procedure instead.
+     If your procedure returns, DPSOutOfMemory returns to its caller, which
+     re-attempts the allocation. Note that another allocation failure will
+     cause DPSOutOfMemory to be called again (and again ...).
+     
+     */
+
+#endif /* DPSPRIVATE_H */
diff --git a/nx-X11/lib/dps/dpssimpint.h b/nx-X11/lib/dps/dpssimpint.h
new file mode 100644
index 000000000..8485bc389
--- /dev/null
+++ b/nx-X11/lib/dps/dpssimpint.h
@@ -0,0 +1,88 @@
+/*
+ * dpsXint.h	-- internal definitions to dpsXclient.c
+ *
+ * (c) Copyright 1989-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
+ */
+
+#ifndef DPSXINT_H
+#define DPSXINT_H
+
+/* The first part of this structure is generic; the last part is
+   implementation-specific. */
+
+typedef struct _t_DPSPrivContextRec {
+  char *priv;
+  DPSSpace space;
+  DPSProgramEncoding programEncoding;
+  DPSNameEncoding nameEncoding;
+  DPSProcs procs;
+  void (*textProc)();
+  void (*errorProc)();
+  DPSResults resultTable;
+  unsigned int resultTableLength;
+  struct _t_DPSContextRec *chainParent, *chainChild;
+  unsigned int contextFlags;
+  DPSContextExtensionRec *extension;
+  
+  struct _t_DPSPrivContextRec *next;
+  integer lastNameIndex, cid;
+  boolean eofReceived;
+  char *wh;
+  char *buf, *outBuf, *objBuf;
+  integer nBufChars, nOutBufChars, nObjBufChars;
+  DPSNumFormat numFormat;
+
+/* Nothing is simple-specific */
+
+} DPSPrivContextRec, *DPSPrivContext;
+
+/* The first part of this structure is generic; the last part is
+   implementation-specific. */
+
+typedef struct _t_DPSPrivSpaceRec {
+  DPSSpaceProcs procs;
+  
+  struct _t_DPSPrivSpaceRec *next;
+  long int lastNameIndex, sid;
+  char *wh; /* KLUDGE to support DPSSendDestroySpace */
+  DPSPrivContext firstContext;
+
+/* Nothing is simple-specific */
+
+} DPSPrivSpaceRec, *DPSPrivSpace;
+
+#include "dpsint.h"
+
+#endif /* DPSXINT_H */
diff --git a/nx-X11/lib/dps/dpssysnames.c b/nx-X11/lib/dps/dpssysnames.c
new file mode 100644
index 000000000..54bf07431
--- /dev/null
+++ b/nx-X11/lib/dps/dpssysnames.c
@@ -0,0 +1,444 @@
+/* dpssysnames.c -- system name table
+ *
+ * (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
+ */
+
+#include "publictypes.h"
+#include "DPS/dpsclient.h"
+#include "dpsprivate.h"
+
+char **DPSSysNames;
+char **DPSSysNamesAux;
+
+static char *sysNames[] = {
+    "abs",
+    "add",
+    "aload",
+    "anchorsearch",
+    "and",
+    "arc",
+    "arcn",
+    "arct",
+    "arcto",
+    "array",
+    "ashow",
+    "astore",
+    "awidthshow",
+    "begin",
+    "bind",
+    "bitshift",
+    "ceiling",
+    "charpath",
+    "clear",
+    "cleartomark",
+    "clip",
+    "clippath",
+    "closepath",
+    "concat",
+    "concatmatrix",
+    "copy",
+    "count",
+    "counttomark",
+    "currentcmykcolor",
+    "currentdash",
+    "currentdict",
+    "currentfile",
+    "currentfont",
+    "currentgray",
+    "currentgstate",
+    "currenthsbcolor",
+    "currentlinecap",
+    "currentlinejoin",
+    "currentlinewidth",
+    "currentmatrix",
+    "currentpoint",
+    "currentrgbcolor",
+    "currentshared",
+    "curveto",
+    "cvi",
+    "cvlit",
+    "cvn",
+    "cvr",
+    "cvrs",
+    "cvs",
+    "cvx",
+    "def",
+    "defineusername",
+    "dict",
+    "div",
+    "dtransform",
+    "dup",
+    "end",
+    "eoclip",
+    "eofill",
+    "eoviewclip",
+    "eq",
+    "exch",
+    "exec",
+    "exit",
+    "file",
+    "fill",
+    "findfont",
+    "flattenpath",
+    "floor",
+    "flush",
+    "flushfile",
+    "for",
+    "forall",
+    "ge",
+    "get",
+    "getinterval",
+    "grestore",
+    "gsave",
+    "gstate",
+    "gt",
+    "identmatrix",
+    "idiv",
+    "idtransform",
+    "if",
+    "ifelse",
+    "image",
+    "imagemask",
+    "index",
+    "ineofill",
+    "infill",
+    "initviewclip",
+    "inueofill",
+    "inufill",
+    "invertmatrix",
+    "itransform",
+    "known",
+    "le",
+    "length",
+    "lineto",
+    "load",
+    "loop",
+    "lt",
+    "makefont",
+    "matrix",
+    "maxlength",
+    "mod",
+    "moveto",
+    "mul",
+    "ne",
+    "neg",
+    "newpath",
+    "not",
+    "null",
+    "or",
+    "pathbbox",
+    "pathforall",
+    "pop",
+    "print",
+    "printobject",
+    "put",
+    "putinterval",
+    "rcurveto",
+    "read",
+    "readhexstring",
+    "readline",
+    "readstring",
+    "rectclip",
+    "rectfill",
+    "rectstroke",
+    "rectviewclip",
+    "repeat",
+    "restore",
+    "rlineto",
+    "rmoveto",
+    "roll",
+    "rotate",
+    "round",
+    "save",
+    "scale",
+    "scalefont",
+    "search",
+    "selectfont",
+    "setbbox",
+    "setcachedevice",
+    "setcachedevice2",
+    "setcharwidth",
+    "setcmykcolor",
+    "setdash",
+    "setfont",
+    "setgray",
+    "setgstate",
+    "sethsbcolor",
+    "setlinecap",
+    "setlinejoin",
+    "setlinewidth",
+    "setmatrix",
+    "setrgbcolor",
+    "setshared",
+    "shareddict",
+    "show",
+    "showpage",
+    "stop",
+    "stopped",
+    "store",
+    "string",
+    "stringwidth",
+    "stroke",
+    "strokepath",
+    "sub",
+    "systemdict",
+    "token",
+    "transform",
+    "translate",
+    "truncate",
+    "type",
+    "uappend",
+    "ucache",
+    "ueofill",
+    "ufill",
+    "undef",
+    "upath",
+    "userdict",
+    "ustroke",
+    "viewclip",
+    "viewclippath",
+    "where",
+    "widthshow",
+    "write",
+    "writehexstring",
+    "writeobject",
+    "writestring",
+    "wtranslation",
+    "xor",
+    "xshow",
+    "xyshow",
+    "yshow",
+    "FontDirectory",
+    "SharedFontDirectory",
+    "Courier",
+    "Courier-Bold",
+    "Courier-BoldOblique",
+    "Courier-Oblique",
+    "Helvetica",
+    "Helvetica-Bold",
+    "Helvetica-BoldOblique",
+    "Helvetica-Oblique",
+    "Symbol",
+    "Times-Bold",
+    "Times-BoldItalic",
+    "Times-Italic",
+    "Times-Roman",
+    "execuserobject",			/* 212 */
+    ""
+};
+
+static char *sysNamesAux[] = {
+    "=",				/* 256 */
+    "==",
+    "ISOLatin1Encoding",
+    "StandardEncoding",
+    "[",
+    "]",
+    "atan",
+    "banddevice",
+    "bytesavailable",
+    "cachestatus",
+    "closefile",
+    "colorimage",
+    "condition",
+    "copypage",
+    "cos",
+    "countdictstack",
+    "countexecstack",
+    "cshow",
+    "currentblackgeneration",
+    "currentcacheparams",
+    "currentcolorscreen",
+    "currentcolortransfer",
+    "currentcontext",
+    "currentflat",
+    "currenthalftone",
+    "currenthalftonephase",
+    "currentmiterlimit",
+    "currentobjectformat",
+    "currentpacking",
+    "currentscreen",
+    "currentstrokeadjust",
+    "currenttransfer",
+    "currentundercolorremoval",
+    "defaultmatrix",
+    "definefont",
+    "deletefile",
+    "detach",
+    "deviceinfo",
+    "dictstack",
+    "echo",
+    "erasepage",
+    "errordict",
+    "execstack",
+    "executeonly",
+    "exp",
+    "false",
+    "filenameforall",
+    "fileposition",
+    "fork",
+    "framedevice",
+    "grestoreall",
+    "handleerror",
+    "initclip",
+    "initgraphics",
+    "initmatrix",
+    "instroke",
+    "inustroke",
+    "join",
+    "kshow",
+    "ln",
+    "lock",
+    "log",
+    "mark",
+    "monitor",
+    "noaccess",
+    "notify",
+    "nulldevice",
+    "packedarray",
+    "quit",
+    "rand",
+    "rcheck",
+    "readonly",
+    "realtime",
+    "renamefile",
+    "renderbands",
+    "resetfile",
+    "reversepath",
+    "rootfont",
+    "rrand",
+    "run",
+    "scheck",
+    "setblackgeneration",
+    "setcachelimit",
+    "setcacheparams",
+    "setcolorscreen",
+    "setcolortransfer",
+    "setfileposition",
+    "setflat",
+    "sethalftone",
+    "sethalftonephase",
+    "setmiterlimit",
+    "setobjectformat",
+    "setpacking",
+    "setscreen",
+    "setstrokeadjust",
+    "settransfer",
+    "setucacheparams",
+    "setundercolorremoval",
+    "sin",
+    "sqrt",
+    "srand",
+    "stack",
+    "status",
+    "statusdict",
+    "true",
+    "ucachestatus",
+    "undefinefont",
+    "usertime",
+    "ustrokepath",
+    "version",
+    "vmreclaim",
+    "vmstatus",
+    "wait",
+    "wcheck",
+    "xcheck",
+    "yield",
+    "defineuserobject",
+    "undefineuserobject",
+    "UserObjects",
+    "cleardictstack",
+    "A",				/* 376 */
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",				/* 427 */
+    "setvmthreshold",			/* 428 */
+    "<<",				/* 429 */
+    ">>",				/* 430 */
+    ""
+};
+
+void DPSInitSysNames() {
+  DPSSysNames = (char **)sysNames;
+  DPSSysNamesAux = (char **)sysNamesAux;
+  }
diff --git a/nx-X11/lib/dps/dpssysops.psw b/nx-X11/lib/dps/dpssysops.psw
new file mode 100644
index 000000000..731287930
--- /dev/null
+++ b/nx-X11/lib/dps/dpssysops.psw
@@ -0,0 +1,149 @@
+/* dpssysops.psw
+ *
+ * (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
+ */
+
+defineps DPSbind(DPSContext ctxt)
+	bind 
+endps
+
+defineps DPScleardictstack(DPSContext ctxt)
+	cleardictstack
+endps
+
+defineps DPScountdictstack(DPSContext ctxt | int *n)
+	countdictstack n 
+endps
+
+defineps DPScountexecstack(DPSContext ctxt | int *n)
+	countexecstack n 
+endps
+
+defineps DPScurrentdict(DPSContext ctxt)
+	currentdict 
+endps
+
+defineps DPScurrentpacking(DPSContext ctxt | boolean *b)
+	currentpacking b 
+endps
+
+defineps DPScurrentshared(DPSContext ctxt | boolean *b)
+	currentshared b 
+endps
+
+defineps DPSdeviceinfo(DPSContext ctxt)
+	deviceinfo 
+endps
+
+defineps DPSerrordict(DPSContext ctxt)
+	errordict 
+endps
+
+defineps DPSexec(DPSContext ctxt)
+	exec 
+endps
+
+defineps DPSprompt(DPSContext ctxt)
+	prompt 
+endps
+
+defineps DPSquit(DPSContext ctxt)
+	quit 
+endps
+
+defineps DPSrand(DPSContext ctxt)
+	rand 
+endps
+
+defineps DPSrealtime(DPSContext ctxt | int *i)
+	realtime i 
+endps
+
+defineps DPSrestore(DPSContext ctxt)
+	restore 
+endps
+
+defineps DPSrrand(DPSContext ctxt)
+	rrand 
+endps
+
+defineps DPSrun(DPSContext ctxt; char *filename)
+	(filename) run 
+endps
+
+defineps DPSsave(DPSContext ctxt)
+	save 
+endps
+
+defineps DPSsetpacking(DPSContext ctxt; boolean b)
+	b setpacking 
+endps
+
+defineps DPSsetshared(DPSContext ctxt; boolean b)
+	b setshared 
+endps
+
+defineps DPSsrand(DPSContext ctxt)
+	srand 
+endps
+
+defineps DPSstart(DPSContext ctxt)
+	start 
+endps
+
+defineps DPStype(DPSContext ctxt)
+	type 
+endps
+
+defineps DPSundef(DPSContext ctxt; char *name)
+	/name undef
+endps
+
+defineps DPSusertime(DPSContext ctxt | int *milliseconds)
+	usertime milliseconds 
+endps
+
+defineps DPSversion(DPSContext ctxt; int bufsize | char buf[bufsize])
+	version buf
+endps
+
+defineps DPSvmreclaim(DPSContext ctxt; int code)
+	code vmreclaim 
+endps
+
+defineps DPSvmstatus(DPSContext ctxt | int *level, *used, *maximum)
+	vmstatus maximum used level 
+endps
+
diff --git a/nx-X11/lib/dps/dpswinops.psw b/nx-X11/lib/dps/dpswinops.psw
new file mode 100644
index 000000000..6ccf77b4c
--- /dev/null
+++ b/nx-X11/lib/dps/dpswinops.psw
@@ -0,0 +1,65 @@
+/* dpswinops.psw
+ *
+ * (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
+ */
+
+defineps DPSineofill(DPSContext ctxt; float x, y | boolean *b)
+	x y ineofill b 
+endps
+
+defineps DPSinfill(DPSContext ctxt; float x, y | boolean *b)
+	x y infill b 
+endps
+
+defineps DPSinstroke(DPSContext ctxt; float x, y | boolean *b)
+	x y instroke b 
+endps
+
+defineps DPSinueofill(DPSContext ctxt; float x, y; char nums[n]; int n; char ops[l]; int l | boolean *b)
+	x y [(nums) (ops)] inueofill b
+endps
+
+defineps DPSinufill(DPSContext ctxt; float x, y; char nums[n]; int n; char ops[l]; int l | boolean *b)
+	x y [(nums) (ops)] inufill b
+endps
+
+defineps DPSinustroke(DPSContext ctxt; float x, y; char nums[n]; int n; char ops[l]; int l | boolean *b)
+	x y [(nums) (ops)] inustroke b
+endps
+
+defineps DPSwtranslation(DPSContext ctxt | float *x, *y)
+	wtranslation y x 
+endps
+
diff --git a/nx-X11/lib/dps/else.txt b/nx-X11/lib/dps/else.txt
new file mode 100644
index 000000000..b74df412a
--- /dev/null
+++ b/nx-X11/lib/dps/else.txt
@@ -0,0 +1,6 @@
+#else /* _NO_PROTO */
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
diff --git a/nx-X11/lib/dps/genheader.cmd b/nx-X11/lib/dps/genheader.cmd
new file mode 100644
index 000000000..b1784e232
--- /dev/null
+++ b/nx-X11/lib/dps/genheader.cmd
@@ -0,0 +1,14 @@
+REM 
+/* OS/2 generate header files */
+/* $XFree86: xc/lib/dps/genheader.cmd,v 1.1 2000/04/05 18:13:22 dawes Exp $ */
+cat psclrops.h psctrlops.h psctxtops.h psdataops.h psfontops.h psgsttops.h psioops.h psmathops.h psmtrxops.h psmiscops.h pspntops.h pspathops.h pssysops.h pswinops.h psopstack.h psXops.h psl2ops.h >.ph
+sed -e "/^$$/D" -e "/#/D" -e "/^\//D" -e "/^   gener/D" -e "/^.\//D" .ph | sort >.sort
+awk "/;/ {print;printf(\"\n\");}" .sort >.ttt
+cat psname.txt header.txt psifdef.txt .ttt psendif.txt > psops.h.os2
+rm .ph .sort .ttt
+
+cat dpsclrops.h dpsctrlops.h dpsctxtops.h dpsdataops.h dpsfontops.h dpsgsttops.h dpsioops.h dpsmathops.h dpsmtrxops.h dpsmiscops.h dpspntops.h dpspathops.h dpssysops.h dpswinops.h dpsopstack.h dpsXops.h dpsl2ops.h >.ph
+sed -e "/^$$/D" -e "/#/D" -e "/^\//D" -e "/^   gener/D" -e "/^.\//D" .ph | sort >.sort
+awk "/;/ {print;printf(\"\n\");}" .sort >.ttt
+cat dpsname.txt header.txt dpsifdef.txt .ttt dpsendif.txt > dpsops.h.os2
+rm .ph .sort .ttt
diff --git a/nx-X11/lib/dps/header.txt b/nx-X11/lib/dps/header.txt
new file mode 100644
index 000000000..8b37ebe67
--- /dev/null
+++ b/nx-X11/lib/dps/header.txt
@@ -0,0 +1,35 @@
+/*
+ * (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
+ */
diff --git a/nx-X11/lib/dps/psXops.psw b/nx-X11/lib/dps/psXops.psw
new file mode 100644
index 000000000..5d350418f
--- /dev/null
+++ b/nx-X11/lib/dps/psXops.psw
@@ -0,0 +1,81 @@
+/* psXops.psw
+ *
+ * (c) Copyright 1991-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$ */
+
+defineps PSclientsync()
+	clientsync
+endps
+
+defineps PScurrentXgcdrawable(| int *gc, *draw, *x, *y)
+	currentXgcdrawable y x draw gc
+endps
+
+defineps PScurrentXgcdrawablecolor(| int *gc, *draw, *x, *y, colorInfo[12])
+	currentXgcdrawablecolor colorInfo y x draw gc
+endps
+
+defineps PScurrentXoffset(| int *x, *y)
+	currentXoffset y x
+endps
+
+defineps PSsetXgcdrawable(int gc, draw, x, y)
+	gc draw x y setXgcdrawable
+endps
+
+defineps PSsetXgcdrawablecolor(int gc, draw, x, y, colorInfo[12])
+	gc draw x y colorInfo setXgcdrawablecolor
+endps
+
+defineps PSsetXoffset(int x, y)
+	x y setXoffset
+endps
+
+defineps PSsetXrgbactual(float r, g, b | boolean *success)
+	r g b setXrgbactual success
+endps
+
+defineps PSclientXready(int i0, i1, i2, i3)
+	[ i0 i1 i2 i3 ] clientXready
+endps
+
+defineps PSsetXdrawingfunction(int function)
+	function setXdrawingfunction
+endps
+
+defineps PScurrentXdrawingfunction(| int *function)
+	currentXdrawingfunction function
+endps
diff --git a/nx-X11/lib/dps/psclrops.psw b/nx-X11/lib/dps/psclrops.psw
new file mode 100644
index 000000000..986f85176
--- /dev/null
+++ b/nx-X11/lib/dps/psclrops.psw
@@ -0,0 +1,81 @@
+/* psclrops.psw
+ *
+ * (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
+ */
+
+defineps PScolorimage()
+	colorimage 
+endps
+
+defineps PScurrentblackgeneration()
+	currentblackgeneration 
+endps
+
+defineps PScurrentcmykcolor( | float *c, *m, *y, *k)
+	currentcmykcolor k y m c 
+endps
+
+defineps PScurrentcolorscreen()
+	currentcolorscreen 
+endps
+
+defineps PScurrentcolortransfer()
+	currentcolortransfer 
+endps
+
+defineps PScurrentundercolorremoval()
+	currentundercolorremoval 
+endps
+
+defineps PSsetblackgeneration()
+	setblackgeneration 
+endps
+
+defineps PSsetcmykcolor(float c, m, y, k)
+	c m y k setcmykcolor 
+endps
+
+defineps PSsetcolorscreen()
+	setcolorscreen 
+endps
+
+defineps PSsetcolortransfer()
+	setcolortransfer 
+endps
+
+defineps PSsetundercolorremoval()
+	setundercolorremoval 
+endps
+
diff --git a/nx-X11/lib/dps/psctrlops.psw b/nx-X11/lib/dps/psctrlops.psw
new file mode 100644
index 000000000..882020d63
--- /dev/null
+++ b/nx-X11/lib/dps/psctrlops.psw
@@ -0,0 +1,113 @@
+/* psctrlops.psw
+ *
+ * (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
+ */
+
+defineps PSeq()
+	eq 
+endps
+
+defineps PSexit()
+	exit 
+endps
+
+defineps PSfalse()
+	false 
+endps
+
+defineps PSfor()
+	for 
+endps
+
+defineps PSforall()
+	forall 
+endps
+
+defineps PSge()
+	ge 
+endps
+
+defineps PSgt()
+	gt 
+endps
+
+defineps PSif()
+	if 
+endps
+
+defineps PSifelse()
+	ifelse 
+endps
+
+defineps PSle()
+	le 
+endps
+
+defineps PSloop()
+	loop 
+endps
+
+defineps PSlt()
+	lt 
+endps
+
+defineps PSne()
+	ne 
+endps
+
+defineps PSnot()
+	not 
+endps
+
+defineps PSor()
+	or 
+endps
+
+defineps PSrepeat()
+	repeat 
+endps
+
+defineps PSstop()
+	stop 
+endps
+
+defineps PSstopped()
+	stopped 
+endps
+
+defineps PStrue()
+	true 
+endps
+
diff --git a/nx-X11/lib/dps/psctxtops.psw b/nx-X11/lib/dps/psctxtops.psw
new file mode 100644
index 000000000..43ca803fc
--- /dev/null
+++ b/nx-X11/lib/dps/psctxtops.psw
@@ -0,0 +1,109 @@
+/* psctxtops.psw
+ *
+ * (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
+ */
+
+defineps PSUserObjects()
+	UserObjects
+endps
+
+defineps PScondition()
+	condition 
+endps
+
+defineps PScurrentcontext( | int *cid)
+	currentcontext cid 
+endps
+
+defineps PScurrentobjectformat( | int *code)
+	currentobjectformat code 
+endps
+
+defineps PSdefineusername(int i; char *username)
+	i /username defineusername 
+endps
+
+defineps PSdefineuserobject()
+	defineuserobject 
+endps
+
+defineps PSdetach()
+	detach 
+endps
+
+defineps PSexecuserobject(int userObjIndex)
+	userObjIndex execuserobject 
+endps
+
+defineps PSfork()
+	fork 
+endps
+
+defineps PSjoin()
+	join 
+endps
+
+defineps PSlock()
+	lock 
+endps
+
+defineps PSmonitor()
+	monitor 
+endps
+
+defineps PSnotify()
+	notify 
+endps
+
+defineps PSsetobjectformat(int code)
+	code setobjectformat 
+endps
+
+defineps PSsetvmthreshold(int i)
+	i setvmthreshold 
+endps
+
+defineps PSundefineuserobject(int userObjIndex)
+	userObjIndex undefineuserobject 
+endps
+
+defineps PSwait()
+	wait 
+endps
+
+defineps PSyield()
+	yield 
+endps
+
diff --git a/nx-X11/lib/dps/psdataops.psw b/nx-X11/lib/dps/psdataops.psw
new file mode 100644
index 000000000..ee89313f6
--- /dev/null
+++ b/nx-X11/lib/dps/psdataops.psw
@@ -0,0 +1,257 @@
+/* psdataops.psw
+ *
+ * (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
+ */
+
+defineps PSaload()
+	aload 
+endps
+
+defineps PSanchorsearch(| boolean *truth)
+	anchorsearch truth
+endps
+
+defineps PSarray(int len)
+	len array 
+endps
+
+defineps PSastore()
+	astore 
+endps
+
+defineps PSbegin()
+	begin 
+endps
+
+defineps PSclear()
+	clear 
+endps
+
+defineps PScleartomark()
+	cleartomark 
+endps
+
+defineps PScopy(int n)
+	n copy
+endps
+
+defineps PScount( | int *n)
+	count n 
+endps
+
+defineps PScounttomark( | int *n)
+	counttomark n 
+endps
+
+defineps PScvi()
+	cvi 
+endps
+
+defineps PScvlit()
+	cvlit 
+endps
+
+defineps PScvn()
+	cvn 
+endps
+
+defineps PScvr()
+	cvr 
+endps
+
+defineps PScvrs()
+	cvrs 
+endps
+
+defineps PScvs()
+	cvs 
+endps
+
+defineps PScvx()
+	cvx 
+endps
+
+defineps PSdef()
+	def 
+endps
+
+defineps PSdict(int len)
+	len dict 
+endps
+
+defineps PSdictstack()
+	dictstack 
+endps
+
+defineps PSdup()
+	dup 
+endps
+
+defineps PSend()
+	end 
+endps
+
+defineps PSexch()
+	exch 
+endps
+
+defineps PSexecstack()
+	execstack 
+endps
+
+defineps PSexecuteonly()
+	executeonly 
+endps
+
+defineps PSget()
+	get 
+endps
+
+defineps PSgetinterval()
+	getinterval 
+endps
+
+defineps PSindex(int i)
+	i index 
+endps
+
+defineps PSknown( | boolean *b)
+	known b 
+endps
+
+defineps PSlength( | int *len)
+	length len 
+endps
+
+defineps PSload()
+	load 
+endps
+
+defineps PSmark()
+	mark 
+endps
+
+defineps PSmatrix()
+	matrix 
+endps
+
+defineps PSmaxlength( | int *len)
+	maxlength len 
+endps
+
+defineps PSnoaccess()
+	noaccess 
+endps
+
+defineps PSnull()
+	null 
+endps
+
+defineps PSpackedarray()
+	packedarray 
+endps
+
+defineps PSpop()
+	pop 
+endps
+
+defineps PSput()
+	put 
+endps
+
+defineps PSputinterval()
+	putinterval 
+endps
+
+defineps PSrcheck( | boolean *b)
+	rcheck b 
+endps
+
+defineps PSreadonly()
+	readonly 
+endps
+
+defineps PSroll(int n, j)
+	n j roll 
+endps
+
+defineps PSscheck( | boolean *b)
+	scheck b 
+endps
+
+defineps PSsearch(| boolean *b)
+	search b
+endps
+
+defineps PSshareddict()
+	shareddict 
+endps
+
+defineps PSstatusdict()
+	statusdict 
+endps
+
+defineps PSstore()
+	store 
+endps
+
+defineps PSstring(int len)
+	len string 
+endps
+
+defineps PSstringwidth(char *s | float *xp, *yp)
+	(s) stringwidth yp xp 
+endps
+
+defineps PSsystemdict()
+	systemdict 
+endps
+
+defineps PSuserdict()
+	userdict 
+endps
+
+defineps PSwcheck( | boolean *b)
+	wcheck b 
+endps
+
+defineps PSwhere(| boolean *b)
+	where b
+endps
+
+defineps PSxcheck( | boolean *b)
+	xcheck b 
+endps
+
diff --git a/nx-X11/lib/dps/psendif.txt b/nx-X11/lib/dps/psendif.txt
new file mode 100644
index 000000000..cd3eae5f3
--- /dev/null
+++ b/nx-X11/lib/dps/psendif.txt
@@ -0,0 +1,6 @@
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}
+#endif
+
+#endif /* PSOPS_H */
diff --git a/nx-X11/lib/dps/psfontops.psw b/nx-X11/lib/dps/psfontops.psw
new file mode 100644
index 000000000..9d9b99914
--- /dev/null
+++ b/nx-X11/lib/dps/psfontops.psw
@@ -0,0 +1,109 @@
+/* psfontops.psw
+ *
+ * (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
+ */
+
+defineps PSFontDirectory()
+	FontDirectory 
+endps
+
+defineps PSISOLatin1Encoding()
+	ISOLatin1Encoding 
+endps
+
+defineps PSSharedFontDirectory()
+	SharedFontDirectory 
+endps
+
+defineps PSStandardEncoding()
+	StandardEncoding 
+endps
+
+defineps PScachestatus()
+	cachestatus
+endps
+
+defineps PScurrentcacheparams()
+	currentcacheparams 
+endps
+
+defineps PScurrentfont()
+	currentfont 
+endps
+
+defineps PSdefinefont()
+	definefont 
+endps
+
+defineps PSfindfont(char *name)
+	/name findfont 
+endps
+
+defineps PSmakefont()
+	makefont 
+endps
+
+defineps PSscalefont(float size)
+	size scalefont
+endps
+
+defineps PSselectfont(char *name; float scale)
+	/name scale selectfont 
+endps
+
+defineps PSsetcachedevice(float wx, wy, llx, lly, urx, ury)
+	wx wy llx lly urx ury setcachedevice 
+endps
+
+defineps PSsetcachelimit(int n)
+	n setcachelimit 
+endps
+
+defineps PSsetcacheparams()
+	setcacheparams 
+endps
+
+defineps PSsetcharwidth(float wx, wy)
+	wx wy setcharwidth 
+endps
+
+defineps PSsetfont(userobject f)
+	f setfont 
+endps
+
+defineps PSundefinefont(char *name)
+	/name undefinefont 
+endps
+
diff --git a/nx-X11/lib/dps/psgsttops.psw b/nx-X11/lib/dps/psgsttops.psw
new file mode 100644
index 000000000..a6eb87b62
--- /dev/null
+++ b/nx-X11/lib/dps/psgsttops.psw
@@ -0,0 +1,213 @@
+/* psgsttops.psw
+ *
+ * (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
+ */
+
+defineps PSconcat(float m[6])
+	m concat
+endps
+
+defineps PScurrentdash()
+	currentdash 
+endps
+
+defineps PScurrentflat( | float *flatness)
+	currentflat flatness 
+endps
+
+defineps PScurrentgray( | float *gray)
+	currentgray gray 
+endps
+
+defineps PScurrentgstate(userobject gst)
+	gst currentgstate 
+endps
+
+defineps PScurrenthalftone()
+	currenthalftone 
+endps
+
+defineps PScurrenthalftonephase( | float *x, *y)
+	currenthalftonephase y x 
+endps
+
+defineps PScurrenthsbcolor( | float *h, *s, *b)
+	currenthsbcolor b s h 
+endps
+
+defineps PScurrentlinecap( | int *linecap)
+	currentlinecap linecap 
+endps
+
+defineps PScurrentlinejoin( | int *linejoin)
+	currentlinejoin linejoin 
+endps
+
+defineps PScurrentlinewidth( | float *width)
+	currentlinewidth width 
+endps
+
+defineps PScurrentmatrix()
+	currentmatrix 
+endps
+
+defineps PScurrentmiterlimit( | float *limit)
+	currentmiterlimit limit 
+endps
+
+defineps PScurrentpoint( | float *x, *y)
+	currentpoint y x 
+endps
+
+defineps PScurrentrgbcolor( | float *r, *g, *b)
+	currentrgbcolor b g r 
+endps
+
+defineps PScurrentscreen()
+	currentscreen 
+endps
+
+defineps PScurrentstrokeadjust( | boolean *b)
+	currentstrokeadjust b 
+endps
+
+defineps PScurrenttransfer()
+	currenttransfer 
+endps
+
+defineps PSdefaultmatrix()
+	defaultmatrix 
+endps
+
+defineps PSgrestore()
+	grestore 
+endps
+
+defineps PSgrestoreall()
+	grestoreall 
+endps
+
+defineps PSgsave()
+	gsave 
+endps
+
+defineps PSgstate()
+	gstate 
+endps
+
+defineps PSinitgraphics()
+	initgraphics 
+endps
+
+defineps PSinitmatrix()
+	initmatrix 
+endps
+
+defineps PSrotate(float angle)
+	angle rotate 
+endps
+
+defineps PSscale(float x, y)
+	x y scale 
+endps
+
+defineps PSsetdash(float pat[size]; int size; float offset)
+	pat offset setdash
+endps
+
+defineps PSsetflat(float flatness)
+	flatness setflat 
+endps
+
+defineps PSsetgray(float gray)
+	gray setgray 
+endps
+
+defineps PSsetgstate(userobject gst)
+	gst setgstate 
+endps
+
+defineps PSsethalftone()
+	sethalftone 
+endps
+
+defineps PSsethalftonephase(float x, y)
+	x y sethalftonephase 
+endps
+
+defineps PSsethsbcolor(float h, s, b)
+	h s b sethsbcolor 
+endps
+
+defineps PSsetlinecap(int linecap)
+	linecap setlinecap 
+endps
+
+defineps PSsetlinejoin(int linejoin)
+	linejoin setlinejoin 
+endps
+
+defineps PSsetlinewidth(float width)
+	width setlinewidth 
+endps
+
+defineps PSsetmatrix()
+	setmatrix 
+endps
+
+defineps PSsetmiterlimit(float limit)
+	limit setmiterlimit 
+endps
+
+defineps PSsetrgbcolor(float r, g, b)
+	r g b setrgbcolor 
+endps
+
+defineps PSsetscreen()
+	setscreen 
+endps
+
+defineps PSsetstrokeadjust(boolean b)
+	b setstrokeadjust 
+endps
+
+defineps PSsettransfer()
+	settransfer 
+endps
+
+defineps PStranslate(float x, y)
+	x y translate 
+endps
+
diff --git a/nx-X11/lib/dps/psifdef.txt b/nx-X11/lib/dps/psifdef.txt
new file mode 100644
index 000000000..0de071a23
--- /dev/null
+++ b/nx-X11/lib/dps/psifdef.txt
@@ -0,0 +1,7 @@
+#ifndef PSOPS_H
+#define PSOPS_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
diff --git a/nx-X11/lib/dps/psioops.psw b/nx-X11/lib/dps/psioops.psw
new file mode 100644
index 000000000..c4d4b4bb9
--- /dev/null
+++ b/nx-X11/lib/dps/psioops.psw
@@ -0,0 +1,153 @@
+/* psioops.psw
+ *
+ * (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
+ */
+
+defineps PSequals()
+	=
+endps
+
+defineps PSequalsequals()
+	==
+endps
+
+defineps PSbytesavailable( | int *n)
+	bytesavailable n 
+endps
+
+defineps PSclosefile()
+	closefile 
+endps
+
+defineps PScurrentfile()
+	currentfile 
+endps
+
+defineps PSdeletefile(char *filename)
+	(filename) deletefile 
+endps
+
+defineps PSecho(boolean b)
+	b echo 
+endps
+
+defineps PSfile(char *name, *access)
+	(name) (access) file 
+endps
+
+defineps PSfilenameforall()
+	filenameforall 
+endps
+
+defineps PSfileposition( | int *pos)
+	fileposition pos 
+endps
+
+defineps PSflush()
+	flush 
+endps
+
+defineps PSflushfile()
+	flushfile 
+endps
+
+defineps PSprint()
+	print 
+endps
+
+defineps PSprintobject(int tag)
+	tag printobject
+endps
+
+defineps PSpstack()
+	pstack 
+endps
+
+defineps PSread(| boolean *b)
+	read b
+endps
+
+defineps PSreadhexstring(| boolean *b)
+	readhexstring b
+endps
+
+defineps PSreadline(| boolean *b)
+	readline b
+endps
+
+defineps PSreadstring(| boolean *b)
+	readstring b
+endps
+
+defineps PSrenamefile(char *oldname, *newname)
+	(oldname) (newname) renamefile 
+endps
+
+defineps PSresetfile()
+	resetfile 
+endps
+
+defineps PSsetfileposition(int pos)
+	pos setfileposition 
+endps
+
+defineps PSstack()
+	stack 
+endps
+
+defineps PSstatus( | boolean *b)
+	status b 
+endps
+
+defineps PStoken(| boolean *b)
+	token b
+endps
+
+defineps PSwrite()
+	write 
+endps
+
+defineps PSwritehexstring()
+	writehexstring 
+endps
+
+defineps PSwriteobject(int tag)
+	tag writeobject
+endps
+
+defineps PSwritestring()
+	writestring 
+endps
+
diff --git a/nx-X11/lib/dps/psl2ops.psw b/nx-X11/lib/dps/psl2ops.psw
new file mode 100644
index 000000000..684b5b2e0
--- /dev/null
+++ b/nx-X11/lib/dps/psl2ops.psw
@@ -0,0 +1,208 @@
+/* psl2ops.psw
+ * (c) Copyright 1991-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
+ */
+
+defineps PSleftbracket()
+	mark					% [ annoys pswrap
+endps
+
+defineps PSrightbracket()
+	counttomark array astore exch pop	% ] annoys pswrap
+endps
+
+defineps PSleftleft()
+	<<
+endps
+
+defineps PSrightright()
+	>>
+endps
+
+defineps PScshow(char *s)
+	(s) cshow
+endps
+
+defineps PScurrentcolor()
+	currentcolor    
+endps
+
+defineps PScurrentcolorrendering()
+	currentcolorrendering
+endps
+
+defineps PScurrentcolorspace()
+	currentcolorspace
+endps
+
+defineps PScurrentdevparams(char *dev)
+	(dev) currentdevparams
+endps
+
+defineps PScurrentglobal(| boolean *b)
+	currentglobal b
+endps
+
+defineps PScurrentoverprint(| boolean *b)
+	currentoverprint b
+endps
+
+defineps PScurrentpagedevice()
+	currentpagedevice
+endps
+
+defineps PScurrentsystemparams()
+	currentsystemparams
+endps
+
+defineps PScurrentuserparams()
+	currentuserparams
+endps
+
+defineps PSdefineresource(char *category)
+	/category defineresource
+endps
+
+defineps PSexecform()
+	execform
+endps
+
+defineps PSfilter()
+	filter
+endps
+
+defineps PSfindencoding(char *key)
+	/key findencoding
+endps
+
+defineps PSfindresource(char *key, *category)
+	/key /category findresource
+endps
+
+defineps PSgcheck(| boolean *b)
+	gcheck b
+endps
+
+defineps PSglobaldict()
+	globaldict
+endps
+
+defineps PSGlobalFontDirectory()
+	GlobalFontDirectory
+endps
+
+defineps PSglyphshow(char *name)
+	/name glyphshow
+endps
+
+defineps PSlanguagelevel(| int *n)
+	languagelevel n
+endps
+
+defineps PSmakepattern()
+	makepattern
+endps
+
+defineps PSproduct()
+	product
+endps
+
+defineps PSresourceforall(char *category)
+	/category resourceforall
+endps
+
+defineps PSresourcestatus(char *key, *category; | boolean *b)
+	/key /category resourcestatus b
+endps
+
+defineps PSrevision(| int *n)
+	revision n
+endps
+
+defineps PSrootfont()
+	rootfont
+endps
+
+defineps PSserialnumber(| int *n)
+	serialnumber n
+endps
+
+defineps PSsetcolor()
+	setcolor
+endps
+
+defineps PSsetcolorrendering()
+	setcolorrendering
+endps
+
+defineps PSsetcolorspace()
+	setcolorspace
+endps
+
+defineps PSsetdevparams()
+	setdevparams
+endps
+
+defineps PSsetglobal(boolean b)
+	b setglobal
+endps
+
+defineps PSsetoverprint(boolean b)
+	b setoverprint
+endps
+
+defineps PSsetpagedevice()
+	setpagedevice
+endps
+
+defineps PSsetpattern()
+	setpattern
+endps
+
+defineps PSsetsystemparams()
+	setsystemparams
+endps
+
+defineps PSsetuserparams()
+	setuserparams
+endps
+
+defineps PSstartjob(boolean b; char *password)
+	b password startjob
+endps
+
+defineps PSundefineresource(char *key, *category)
+	/key /category undefineresource
+endps
+
diff --git a/nx-X11/lib/dps/psmathops.psw b/nx-X11/lib/dps/psmathops.psw
new file mode 100644
index 000000000..268535348
--- /dev/null
+++ b/nx-X11/lib/dps/psmathops.psw
@@ -0,0 +1,125 @@
+/* psmathops.psw
+ *
+ * (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
+ */
+
+defineps PSabs()
+	abs 
+endps
+
+defineps PSadd()
+	add 
+endps
+
+defineps PSand()
+	and 
+endps
+
+defineps PSatan()
+	atan 
+endps
+
+defineps PSbitshift(int shift)
+	shift bitshift
+endps
+
+defineps PSceiling()
+	ceiling 
+endps
+
+defineps PScos()
+	cos 
+endps
+
+defineps PSdiv()
+	div 
+endps
+
+defineps PSexp()
+	exp 
+endps
+
+defineps PSfloor()
+	floor 
+endps
+
+defineps PSidiv()
+	idiv 
+endps
+
+defineps PSln()
+	ln 
+endps
+
+defineps PSlog()
+	log 
+endps
+
+defineps PSmod()
+	mod 
+endps
+
+defineps PSmul()
+	mul 
+endps
+
+defineps PSneg()
+	neg 
+endps
+
+defineps PSround()
+	round 
+endps
+
+defineps PSsin()
+	sin 
+endps
+
+defineps PSsqrt()
+	sqrt 
+endps
+
+defineps PSsub()
+	sub 
+endps
+
+defineps PStruncate()
+	truncate 
+endps
+
+defineps PSxor()
+	xor 
+endps
+
diff --git a/nx-X11/lib/dps/psmiscops.psw b/nx-X11/lib/dps/psmiscops.psw
new file mode 100644
index 000000000..35bc092d0
--- /dev/null
+++ b/nx-X11/lib/dps/psmiscops.psw
@@ -0,0 +1,53 @@
+/* psmiscops.psw
+ *
+ * (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
+ */
+
+defineps PSbanddevice()
+	banddevice 
+endps
+
+defineps PSframedevice()
+	framedevice 
+endps
+
+defineps PSnulldevice()
+	nulldevice 
+endps
+
+defineps PSrenderbands()
+	renderbands 
+endps
+
diff --git a/nx-X11/lib/dps/psmtrxops.psw b/nx-X11/lib/dps/psmtrxops.psw
new file mode 100644
index 000000000..cd9ae1b79
--- /dev/null
+++ b/nx-X11/lib/dps/psmtrxops.psw
@@ -0,0 +1,65 @@
+/* psmtrxops.psw
+ *
+ * (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
+ */
+
+defineps PSconcatmatrix()
+	concatmatrix 
+endps
+
+defineps PSdtransform(float x1, y1 | float *x2, *y2)
+	x1 y1 dtransform y2 x2 
+endps
+
+defineps PSidentmatrix()
+	identmatrix 
+endps
+
+defineps PSidtransform(float x1, y1 | float *x2, *y2)
+	x1 y1 idtransform y2 x2 
+endps
+
+defineps PSinvertmatrix()
+	invertmatrix 
+endps
+
+defineps PSitransform(float x1, y1 | float *x2, *y2)
+	x1 y1 itransform y2 x2 
+endps
+
+defineps PStransform(float x1, y1 | float *x2, *y2)
+	x1 y1 transform y2 x2 
+endps
+
diff --git a/nx-X11/lib/dps/psname.txt b/nx-X11/lib/dps/psname.txt
new file mode 100644
index 000000000..508b7a86d
--- /dev/null
+++ b/nx-X11/lib/dps/psname.txt
@@ -0,0 +1,3 @@
+/*
+ * psops.h
+ */
diff --git a/nx-X11/lib/dps/psopstack.psw b/nx-X11/lib/dps/psopstack.psw
new file mode 100644
index 000000000..d78ad6b7c
--- /dev/null
+++ b/nx-X11/lib/dps/psopstack.psw
@@ -0,0 +1,96 @@
+/*
+ *  psopstack.psw -- wrapped procedures for sending and getting operands
+ *
+ * (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
+ */
+
+defineps PSgetboolean(| boolean *it)
+	it
+endps
+
+defineps PSgetchararray(int size | char s[size])
+	s
+endps
+
+defineps PSgetfloat(| float *it)
+	it
+endps
+
+defineps PSgetfloatarray(int size | float a[size])
+        dup type /arraytype eq { a } { size { a } repeat } ifelse
+endps
+
+defineps PSgetint(| int *it)
+	it
+endps
+
+defineps PSgetintarray(int size | int a[size])
+	dup type /arraytype eq { a } { size { a } repeat } ifelse
+endps
+
+defineps PSgetstring(| char *s)
+	s
+endps
+
+defineps PSsendboolean(boolean it)
+	it
+endps
+
+defineps PSsendchararray(char s[size]; int size)
+	(s)
+endps
+
+defineps PSsendfloat(float it)
+	it
+endps
+
+defineps PSsendfloatarray(float a[size]; int size)
+	a
+endps
+
+defineps PSsendint(int it)
+	it
+endps
+
+defineps PSsendintarray(int a[size]; int size)
+	a
+endps
+
+defineps PSsendstring(char *s)
+	(s)
+endps
+
+
+
diff --git a/nx-X11/lib/dps/pspathops.psw b/nx-X11/lib/dps/pspathops.psw
new file mode 100644
index 000000000..e4c378282
--- /dev/null
+++ b/nx-X11/lib/dps/pspathops.psw
@@ -0,0 +1,169 @@
+/* pspathops.psw
+ *
+ * (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
+ */
+
+defineps PSarc(float x, y, r, angle1, angle2)
+	x y r angle1 angle2 arc 
+endps
+
+defineps PSarcn(float x, y, r, angle1, angle2)
+	x y r angle1 angle2 arcn 
+endps
+
+defineps PSarct(float x1, y1, x2, y2, r)
+	x1 y1 x2 y2 r arct 
+endps
+
+defineps PSarcto(float x1, y1, x2, y2, r | float *xt1, *yt1, *xt2, *yt2)
+	x1 y1 x2 y2 r arcto yt2 xt2 yt1 xt1 
+endps
+
+defineps PScharpath(char *s; boolean b)
+	(s) b charpath 
+endps
+
+defineps PSclip()
+	clip 
+endps
+
+defineps PSclippath()
+	clippath 
+endps
+
+defineps PSclosepath()
+	closepath 
+endps
+
+defineps PScurveto(float x1, y1, x2, y2, x3, y3)
+	x1 y1 x2 y2 x3 y3 curveto 
+endps
+
+defineps PSeoclip()
+	eoclip 
+endps
+
+defineps PSeoviewclip()
+	eoviewclip 
+endps
+
+defineps PSflattenpath()
+	flattenpath 
+endps
+
+defineps PSinitclip()
+	initclip 
+endps
+
+defineps PSinitviewclip()
+	initviewclip 
+endps
+
+defineps PSlineto(float x, y)
+	x y lineto 
+endps
+
+defineps PSmoveto(float x, y)
+	x y moveto 
+endps
+
+defineps PSnewpath()
+	newpath 
+endps
+
+defineps PSpathbbox( | float *llx, *lly, *urx, *ury)
+	pathbbox ury urx lly llx 
+endps
+
+defineps PSpathforall()
+	pathforall 
+endps
+
+defineps PSrcurveto(float x1, y1, x2, y2, x3, y3)
+	x1 y1 x2 y2 x3 y3 rcurveto 
+endps
+
+defineps PSrectclip(float x, y, w, h)
+	x y w h rectclip 
+endps
+
+defineps PSrectviewclip(float x, y, w, h)
+	x y w h rectviewclip 
+endps
+
+defineps PSreversepath()
+	reversepath 
+endps
+
+defineps PSrlineto(float x, y)
+	x y rlineto 
+endps
+
+defineps PSrmoveto(float x, y)
+	x y rmoveto 
+endps
+
+defineps PSsetbbox(float llx, lly, urx, ury)
+	llx lly urx ury setbbox 
+endps
+
+defineps PSsetucacheparams()
+	setucacheparams 
+endps
+
+defineps PSuappend(char nums[n]; int n; char ops[l]; int l)
+	[(nums) (ops)] uappend
+endps
+
+defineps PSucache()
+	ucache 
+endps
+
+defineps PSucachestatus()
+	ucachestatus 
+endps
+
+defineps PSupath(boolean b)
+	b upath 
+endps
+
+defineps PSviewclip()
+	viewclip 
+endps
+
+defineps PSviewclippath()
+	viewclippath 
+endps
+
diff --git a/nx-X11/lib/dps/pspntops.psw b/nx-X11/lib/dps/pspntops.psw
new file mode 100644
index 000000000..2f7beef00
--- /dev/null
+++ b/nx-X11/lib/dps/pspntops.psw
@@ -0,0 +1,129 @@
+/* pspntops.psw
+ *
+ * (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
+ */
+
+defineps PSashow(float x, y; char *s)
+	x y (s) ashow 
+endps
+
+defineps PSawidthshow(float cx, cy; int c; float ax, ay; char *s)
+	cx cy c ax ay (s) awidthshow 
+endps
+
+defineps PScopypage()
+	copypage 
+endps
+
+defineps PSeofill()
+	eofill 
+endps
+
+defineps PSerasepage()
+	erasepage 
+endps
+
+defineps PSfill()
+	fill 
+endps
+
+defineps PSimage()
+	image 
+endps
+
+defineps PSimagemask()
+	imagemask 
+endps
+
+defineps PSkshow(char *s)
+	(s) kshow
+endps
+
+defineps PSrectfill(float x, y, w, h)
+	x y w h rectfill 
+endps
+
+defineps PSrectstroke(float x, y, w, h)
+	x y w h rectstroke 
+endps
+
+defineps PSshow(char *s)
+	(s) show 
+endps
+
+defineps PSshowpage()
+	showpage 
+endps
+
+defineps PSstroke()
+	stroke 
+endps
+
+defineps PSstrokepath()
+	strokepath 
+endps
+
+defineps PSueofill(char nums[n]; int n; char ops[l]; int l)
+	[(nums) (ops)] ueofill
+endps
+
+defineps PSufill(char nums[n]; int n; char ops[l]; int l)
+	[(nums) (ops)] ufill
+endps
+
+defineps PSustroke(char nums[n]; int n; char ops[l]; int l)
+	[(nums) (ops)] ustroke
+endps
+
+defineps PSustrokepath(char nums[n]; int n; char ops[l]; int l)
+	[(nums) (ops)] ustrokepath
+endps
+
+defineps PSwidthshow(float x, y; int c; char *s)
+	x y c (s) widthshow 
+endps
+
+defineps PSxshow(char *s; float numarray[size]; int size)
+	(s) numarray xshow
+endps
+
+defineps PSxyshow(char *s; float numarray[size]; int size)
+	(s) numarray xyshow
+endps
+
+defineps PSyshow(char *s; float numarray[size]; int size)
+	(s) numarray yshow
+endps
+
diff --git a/nx-X11/lib/dps/pssysops.psw b/nx-X11/lib/dps/pssysops.psw
new file mode 100644
index 000000000..024d4fd52
--- /dev/null
+++ b/nx-X11/lib/dps/pssysops.psw
@@ -0,0 +1,150 @@
+/*
+ * pssysops.psw
+ *
+ * (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
+ */
+
+defineps PSbind()
+	bind 
+endps
+
+defineps PScleardictstack()
+	cleardictstack
+endps
+
+defineps PScountdictstack( | int *n)
+	countdictstack n 
+endps
+
+defineps PScountexecstack( | int *n)
+	countexecstack n 
+endps
+
+defineps PScurrentdict()
+	currentdict 
+endps
+
+defineps PScurrentpacking( | boolean *b)
+	currentpacking b 
+endps
+
+defineps PScurrentshared( | boolean *b)
+	currentshared b 
+endps
+
+defineps PSdeviceinfo()
+	deviceinfo 
+endps
+
+defineps PSerrordict()
+	errordict 
+endps
+
+defineps PSexec()
+	exec 
+endps
+
+defineps PSprompt()
+	prompt 
+endps
+
+defineps PSquit()
+	quit 
+endps
+
+defineps PSrand()
+	rand 
+endps
+
+defineps PSrealtime( | int *i)
+	realtime i 
+endps
+
+defineps PSrestore()
+	restore 
+endps
+
+defineps PSrrand()
+	rrand 
+endps
+
+defineps PSrun(char *filename)
+	(filename) run 
+endps
+
+defineps PSsave()
+	save 
+endps
+
+defineps PSsetpacking(boolean b)
+	b setpacking 
+endps
+
+defineps PSsetshared(boolean b)
+	b setshared 
+endps
+
+defineps PSsrand()
+	srand 
+endps
+
+defineps PSstart()
+	start 
+endps
+
+defineps PStype()
+	type 
+endps
+
+defineps PSundef(char *name)
+	/name undef
+endps
+
+defineps PSusertime( | int *milliseconds)
+	usertime milliseconds 
+endps
+
+defineps PSversion(int bufsize | char buf[bufsize])
+	version buf
+endps
+
+defineps PSvmreclaim(int code)
+	code vmreclaim 
+endps
+
+defineps PSvmstatus( | int *level, *used, *maximum)
+	vmstatus maximum used level 
+endps
+
diff --git a/nx-X11/lib/dps/pswinops.psw b/nx-X11/lib/dps/pswinops.psw
new file mode 100644
index 000000000..4a6a2db5a
--- /dev/null
+++ b/nx-X11/lib/dps/pswinops.psw
@@ -0,0 +1,66 @@
+/*
+ * pswinops.psw
+ *
+ * (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
+ */
+
+defineps PSineofill(float x, y | boolean *b)
+	x y ineofill b 
+endps
+
+defineps PSinfill(float x, y | boolean *b)
+	x y infill b 
+endps
+
+defineps PSinstroke(float x, y | boolean *b)
+	x y instroke b 
+endps
+
+defineps PSinueofill(float x, y; char nums[n]; int n; char ops[l]; int l | boolean *b)
+	x y [(nums) (ops)] inueofill b
+endps
+
+defineps PSinufill(float x, y; char nums[n]; int n; char ops[l]; int l | boolean *b)
+	x y [(nums) (ops)] inufill b
+endps
+
+defineps PSinustroke(float x, y; char nums[n]; int n; char ops[l]; int l | boolean *b)
+	x y [(nums) (ops)] inustroke b
+endps
+
+defineps PSwtranslation( | float *x, *y)
+	wtranslation y x 
+endps
+
diff --git a/nx-X11/lib/dps/publictypes.h b/nx-X11/lib/dps/publictypes.h
new file mode 100644
index 000000000..871766e69
--- /dev/null
+++ b/nx-X11/lib/dps/publictypes.h
@@ -0,0 +1,71 @@
+/*
+ * publictypes.h
+ *
+ * (c) Copyright 1984-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: xc/lib/dps/publictypes.h,v 1.2 2000/06/07 22:02:58 tsi Exp $ */
+
+#ifndef	PUBLICTYPES_H
+#define	PUBLICTYPES_H
+
+/*
+ * Note: for the moment we depend absolutely on an int being the same
+ * as a long int and being at least 32 bits.
+ */
+
+/* Inline Functions */
+
+#undef MIN
+#define MIN(a,b) ((a)<(b)?(a):(b))
+#undef MAX
+#define MAX(a,b) ((a)>(b)?(a):(b))
+
+/* Declarative Sugar */
+
+/* Type boolean based derived from unsigned int */
+
+typedef unsigned int boolean;
+typedef long int integer;
+
+#define true 1
+#define false 0
+
+/* Generic Pointers */
+
+#include <stddef.h>
+
+#define	NIL	NULL
+
+#endif /* PUBLICTYPES_H */