sun-src/libdps/dpsXpriv.c

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