aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/dps
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/lib/dps')
-rw-r--r--nx-X11/lib/dps/DPSCAP.h77
-rw-r--r--nx-X11/lib/dps/DPSCAPClient.h139
-rw-r--r--nx-X11/lib/dps/DPSCAPproto.h180
-rw-r--r--nx-X11/lib/dps/Imakefile265
-rw-r--r--nx-X11/lib/dps/XDPS.c2235
-rw-r--r--nx-X11/lib/dps/Xlibnet.h284
-rw-r--r--nx-X11/lib/dps/Xstreams.h218
-rw-r--r--nx-X11/lib/dps/csconndi.c839
-rw-r--r--nx-X11/lib/dps/csfindNX.c657
-rw-r--r--nx-X11/lib/dps/csfindNX.h93
-rw-r--r--nx-X11/lib/dps/cslibext.c762
-rw-r--r--nx-X11/lib/dps/cslibint.c1910
-rw-r--r--nx-X11/lib/dps/cslibint.h302
-rw-r--r--nx-X11/lib/dps/csopendi.c567
-rw-r--r--nx-X11/lib/dps/csstartNX.c237
-rw-r--r--nx-X11/lib/dps/csstartNX.h67
-rw-r--r--nx-X11/lib/dps/dps-def.cpp991
-rw-r--r--nx-X11/lib/dps/dpsNXprops.h90
-rw-r--r--nx-X11/lib/dps/dpsXclient.c1134
-rw-r--r--nx-X11/lib/dps/dpsXcmu.c1602
-rw-r--r--nx-X11/lib/dps/dpsXint.h104
-rw-r--r--nx-X11/lib/dps/dpsXops.psw80
-rw-r--r--nx-X11/lib/dps/dpsXpriv.c534
-rw-r--r--nx-X11/lib/dps/dpsXpriv.h187
-rw-r--r--nx-X11/lib/dps/dpsXtdisp.c109
-rw-r--r--nx-X11/lib/dps/dpsabbrev.c360
-rw-r--r--nx-X11/lib/dps/dpsassert.h57
-rw-r--r--nx-X11/lib/dps/dpsclient.c2969
-rw-r--r--nx-X11/lib/dps/dpsclrops.psw81
-rw-r--r--nx-X11/lib/dps/dpsctrlops.psw114
-rw-r--r--nx-X11/lib/dps/dpsctxtops.psw110
-rw-r--r--nx-X11/lib/dps/dpsdataops.psw258
-rw-r--r--nx-X11/lib/dps/dpsdict.c189
-rw-r--r--nx-X11/lib/dps/dpsdict.h78
-rw-r--r--nx-X11/lib/dps/dpsendif.txt5
-rw-r--r--nx-X11/lib/dps/dpsexcept.c73
-rw-r--r--nx-X11/lib/dps/dpsfontops.psw109
-rw-r--r--nx-X11/lib/dps/dpsgsttops.psw213
-rw-r--r--nx-X11/lib/dps/dpsifdef.txt7
-rw-r--r--nx-X11/lib/dps/dpsint.h125
-rw-r--r--nx-X11/lib/dps/dpsioops.psw153
-rw-r--r--nx-X11/lib/dps/dpsl2ops.psw208
-rw-r--r--nx-X11/lib/dps/dpsmathops.psw125
-rw-r--r--nx-X11/lib/dps/dpsmiscops.psw53
-rw-r--r--nx-X11/lib/dps/dpsmtrxops.psw65
-rw-r--r--nx-X11/lib/dps/dpsname.txt4
-rw-r--r--nx-X11/lib/dps/dpsopstack.psw96
-rw-r--r--nx-X11/lib/dps/dpspathops.psw169
-rw-r--r--nx-X11/lib/dps/dpspntops.psw129
-rw-r--r--nx-X11/lib/dps/dpsprintf.c68
-rw-r--r--nx-X11/lib/dps/dpsprivate.h127
-rw-r--r--nx-X11/lib/dps/dpssimpint.h88
-rw-r--r--nx-X11/lib/dps/dpssysnames.c444
-rw-r--r--nx-X11/lib/dps/dpssysops.psw149
-rw-r--r--nx-X11/lib/dps/dpswinops.psw65
-rw-r--r--nx-X11/lib/dps/else.txt6
-rw-r--r--nx-X11/lib/dps/genheader.cmd14
-rw-r--r--nx-X11/lib/dps/header.txt35
-rw-r--r--nx-X11/lib/dps/psXops.psw81
-rw-r--r--nx-X11/lib/dps/psclrops.psw81
-rw-r--r--nx-X11/lib/dps/psctrlops.psw113
-rw-r--r--nx-X11/lib/dps/psctxtops.psw109
-rw-r--r--nx-X11/lib/dps/psdataops.psw257
-rw-r--r--nx-X11/lib/dps/psendif.txt6
-rw-r--r--nx-X11/lib/dps/psfontops.psw109
-rw-r--r--nx-X11/lib/dps/psgsttops.psw213
-rw-r--r--nx-X11/lib/dps/psifdef.txt7
-rw-r--r--nx-X11/lib/dps/psioops.psw153
-rw-r--r--nx-X11/lib/dps/psl2ops.psw208
-rw-r--r--nx-X11/lib/dps/psmathops.psw125
-rw-r--r--nx-X11/lib/dps/psmiscops.psw53
-rw-r--r--nx-X11/lib/dps/psmtrxops.psw65
-rw-r--r--nx-X11/lib/dps/psname.txt3
-rw-r--r--nx-X11/lib/dps/psopstack.psw96
-rw-r--r--nx-X11/lib/dps/pspathops.psw169
-rw-r--r--nx-X11/lib/dps/pspntops.psw129
-rw-r--r--nx-X11/lib/dps/pssysops.psw150
-rw-r--r--nx-X11/lib/dps/pswinops.psw66
-rw-r--r--nx-X11/lib/dps/publictypes.h71
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 */