/*
 * 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;
}
