NetNews Usenet Archive 1992 #19/NN_1992_19.iso/spool/vmsnet/sources/354

Internet Message Format | 1992-09-04 | 47.9 KB

Path: sparky!uunet!usc!news.service.uci.edu!unogate!mvb.saic.com!vmsnet-sources
From: [e-mail] (Patrick L. Mahan - TGV Window Washer)
Newsgroups: vmsnet.sources
Subject: XSCOPE/VMS 1.0, part 07/08
Message-ID: <[e-mail]>
Date: Fri, 04 Sep 1992 05:34:37 GMT
Reply-To: [e-mail]
Organization: TGV Incorporated (Tech Support) in Santa Cruz, CA
Lines: 1455
Approved: [e-mail]

Submitted-by: [e-mail] (Patrick L. Mahan - TGV Window Washer)
Posting-number: Volume 3, Issue 159
Archive-name: xscope/part07


-+-+-+-+-+-+-+-+ START OF PART 7 -+-+-+-+-+-+-+-+
X  sec = tp.tv_sec - ZeroTime1;
X  hsec = tp.tv_usec / 10000 - ZeroTime2;
X  if (hsec < 0)
X    `7B
X      hsec += 100;
X      sec -= 1;
X    `7D
X  fprintf(stdout, "%2d.%02ld: ", sec, hsec);
X`7D
X
X/* ************************************************************ */
X/*`09`09`09`09`09`09`09`09*/
X/*`09`09`09`09`09`09`09`09*/
X/* ************************************************************ */
X
X/* we will need to be able to interpret the values stored in the
X   requests as various built-in types.  The following routines
X   support the types built into X11 */
X
Xlong    pad (n)
X     long    n;
X`7B
X  /* round up to next multiple of 4 */
X  return((n + 3) & `7E0x3);
X`7D
X
Xextern int  littleEndian;
X
Xunsigned long    ILong (buf)
X     unsigned char   buf`5B`5D;
X`7B
X  if (littleEndian)
X    return((((((buf`5B3`5D << 8) `7C buf`5B2`5D) << 8) `7C buf`5B1`5D) << 8)
V `7C buf`5B0`5D);
X  return((((((buf`5B0`5D << 8) `7C buf`5B1`5D) << 8) `7C buf`5B2`5D) << 8) `
V7C buf`5B3`5D);
X`7D
X
Xunsigned short   IShort (buf)
Xunsigned char   buf`5B`5D;
X`7B
X  if (littleEndian)
X    return (buf`5B1`5D << 8) `7C buf`5B0`5D;
X  return((buf`5B0`5D << 8) `7C buf`5B1`5D);
X`7D
X
Xunsigned short   IByte (buf)
Xunsigned char   buf`5B`5D;
X`7B
X  return(buf`5B0`5D);
X`7D
X
XBoolean IBool(buf)
X     unsigned char   buf`5B`5D;
X`7B
X  if (buf`5B0`5D != 0)
X    return(true);
X  else
X    return(false);
X`7D
X
X
X/* ************************************************************ */
X/*`09`09`09`09`09`09`09`09*/
X/*`09`09`09`09`09`09`09`09*/
X/* ************************************************************ */
X
X/* we will need to save bytes until we get a complete request to
X   interpret.  The following procedures provide this ability */
X
XSaveBytes(fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  /* check if there is enough space to hold the bytes we want */
X  if (CS`5Bfd`5D.NumberofSavedBytes + n > CS`5Bfd`5D.SizeofSavedBytes)
X    `7B
X      /* not enough room so far; malloc more space and copy */
X      long    SizeofNewBytes = (CS`5Bfd`5D.NumberofSavedBytes + n + 1);
X#ifdef vax11c
X      unsigned char   *NewBytes = (unsigned char *)MyMalloc (SizeofNewBytes)
V;
X#else
X      unsigned char   *NewBytes = (unsigned char *)Malloc (SizeofNewBytes);
X#endif /* vax11c */
X      bcopy(/* from  */(char *)CS`5Bfd`5D.SavedBytes,
X`09    /* to    */(char *)NewBytes,
X`09    /* count */(int)CS`5Bfd`5D.SizeofSavedBytes);
X#ifdef vax11c
X      MyFree((char *)CS`5Bfd`5D.SavedBytes);
X#else
X      Free((char *)CS`5Bfd`5D.SavedBytes);
X#endif /* vax11c */
X      CS`5Bfd`5D.SavedBytes = NewBytes;
X      CS`5Bfd`5D.SizeofSavedBytes = SizeofNewBytes;
X    `7D
X
X  /* now copy the new bytes onto the end of the old bytes */
X  bcopy(/* from  */(char *)buf,
X`09/* to    */(char *)(CS`5Bfd`5D.SavedBytes + CS`5Bfd`5D.NumberofSavedBytes
V),
X`09/* count */(int)n);
X  CS`5Bfd`5D.NumberofSavedBytes += n;
X`7D
X
XRemoveSavedBytes(fd, n)
X     FD fd;
X     long    n;
X`7B
X  /* check if all bytes are being removed -- easiest case */
X  if (CS`5Bfd`5D.NumberofSavedBytes <= n)
X    CS`5Bfd`5D.NumberofSavedBytes = 0;
X  else if (n == 0)
X    return;
X  else
X    `7B
X      /* not all bytes are being removed -- shift the remaining ones down  *
V/
X      register unsigned char  *p = CS`5Bfd`5D.SavedBytes;
X      register unsigned char  *q = CS`5Bfd`5D.SavedBytes + n;
X      register long   i = CS`5Bfd`5D.NumberofSavedBytes - n;
X      while (i-- > 0)
X`09*p++ = *q++;
X      CS`5Bfd`5D.NumberofSavedBytes -= n;
X    `7D
X`7D
X
X
X/* ************************************************************ */
X/*`09`09`09`09`09`09`09`09*/
X/*`09`09`09`09`09`09`09`09*/
X/* ************************************************************ */
X
X
X/* following are the possible values for ByteProcessing */
X/* forward declarations */
Xlong    StartSetUpMessage ();
Xlong    FinishSetUpMessage ();
Xlong    StartRequest ();
Xlong    FinishRequest ();
X
Xlong    StartSetUpReply ();
Xlong    FinishSetUpReply ();
Xlong    ServerPacket ();
Xlong    FinishReply ();
X
X
X/* ************************************************************ */
X/*`09`09`09`09`09`09`09`09*/
X/*`09`09`09`09`09`09`09`09*/
X/* ************************************************************ */
X
Xint littleEndian;
X
XProcessBuffer(fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  unsigned char   *BytesToProcess;
X  long    NumberofUsedBytes;
X
X  /* as long as we have enough bytes to do anything -- do it */
X
X  littleEndian = CS`5Bfd`5D.littleEndian;
X  while (CS`5Bfd`5D.NumberofSavedBytes + n >= CS`5Bfd`5D.NumberofBytesNeeded
V)
X    `7B
X      /*
X`09we have enough bytes to do something.  We want the bytes to be
X`09grouped together into one contiguous block of bytes. We have three
X`09cases:
X
X`09(1) NumberofSavedBytes = 0; so all needed bytes are in the
X`09read buffer, buf.
X
X`09(2) NumberofSavedBytes >= NumberofBytesNeeded;`09in this case we
X`09will not need to copy any extra bytes into the save buffer.
X
X`09(3) 0 < NumberofSavedBytes < NumberofBytesNeeded; so
X`09some bytes are in the save buffer and others are in the read
X`09buffer.  In this case we need to copy some of the bytes from the
X`09read buffer to the save buffer to get as many bytes as we need,
X`09then use these bytes.
X      */
X
X      if (CS`5Bfd`5D.NumberofSavedBytes == 0)
X`09`7B
X`09  /* no saved bytes, so just process the first bytes in the
X`09     read buffer */
X`09  BytesToProcess = buf /* address of request bytes */;
X`09`7D
X      else
X`09`7B
X`09  if (CS`5Bfd`5D.NumberofSavedBytes < CS`5Bfd`5D.NumberofBytesNeeded)
X`09    `7B
X`09      /* first determine the number of bytes we need to
X`09`09 transfer; then transfer them and remove them from
X`09`09 the read buffer. (there may be additional requests
X`09`09 in the read buffer) */
X`09      long    m;
X`09      m = CS`5Bfd`5D.NumberofBytesNeeded - CS`5Bfd`5D.NumberofSavedBytes;
X`09      SaveBytes(fd, buf, m);
X`09      buf += m;
X`09      n -= m;
X`09    `7D
X`09  BytesToProcess = CS`5Bfd`5D.SavedBytes /* address of request bytes */;
X`09`7D
X
X      /*
X`09BytesToProcess points to a contiguous block of NumberofBytesNeeded
X`09bytes that we should process.  The type of processing depends upon
X`09the state we are in. The processing routine should return the
X`09number of bytes that it actually used.
X      */
X      NumberofUsedBytes = (*CS`5Bfd`5D.ByteProcessing)
X                             (fd, BytesToProcess, CS`5Bfd`5D.NumberofBytesNe
Veded);
X
X      /* the number of bytes that were actually used is normally (but not
X`09 always) the number of bytes needed.  Discard the bytes that were
X`09 actually used, not the bytes that were needed. The number of used
X`09 bytes must be less than or equal to the number of needed bytes. */
X
X      if (NumberofUsedBytes > 0)
X`09`7B
X`09  if (CS`5Bfd`5D.NumberofSavedBytes > 0)
X`09    RemoveSavedBytes(fd, NumberofUsedBytes);
X`09  else
X`09    `7B
X`09      /* there are no saved bytes, so the bytes that were
X`09`09 used must have been in the read buffer */
X`09      buf += NumberofUsedBytes;
X`09      n -= NumberofUsedBytes;
X`09    `7D
X`09`7D
X    `7D /* end of while (NumberofSavedBytes + n >= NumberofBytesNeeded) */
X
X  /* not enough bytes -- just save the new bytes for more later */
X  if (n > 0)
X    SaveBytes(fd, buf, n);
X  return;
X`7D
X
X
X
X/* ************************************************************ */
X/*`09`09`09`09`09`09`09`09*/
X/*`09`09`09`09`09`09`09`09*/
X/* ************************************************************ */
X/*
X  Byte Processing Routines.  Each routine MUST set NumberofBytesNeeded
X  and ByteProcessing.  It probably needs to do some computation first.
X*/
X
X
XStartClientConnection(fd)
X     FD fd;
X`7B
X  enterprocedure("StartClientConnection");
X  /* when a new connection is started, we have no saved bytes */
X  CS`5Bfd`5D.SavedBytes = NULL;
X  CS`5Bfd`5D.SizeofSavedBytes = 0;
X  CS`5Bfd`5D.NumberofSavedBytes = 0;
X
X  /* when a new connection is started, we have no reply Queue */
X  FlushReplyQ(fd);
X
X  /* each new connection gets a request sequence number */
X  CS`5Bfd`5D.SequenceNumber = 0;
X
X  /* we need 12 bytes to start a SetUp message */
X  CS`5Bfd`5D.ByteProcessing = StartSetUpMessage;
X  CS`5Bfd`5D.NumberofBytesNeeded = 12;
X`7D
X
XStopClientConnection(fd)
X     FD fd;
X`7B
X  enterprocedure("StopClientConnection");
X  /* when a new connection is stopped, discard the old buffer */
X
X  if (CS`5Bfd`5D.SizeofSavedBytes > 0)
X#ifdef vax11c
X    MyFree((char*)CS`5Bfd`5D.SavedBytes);
X#else
X    Free((char*)CS`5Bfd`5D.SavedBytes);
X#endif /* vax11c */
X`7D
X
Xlong    StartSetUpMessage (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  short   namelength;
X  short   datalength;
X
X  enterprocedure("StartSetUpMessage");
X  /*
X    we need the first 12 bytes to be able to determine if, and how many,
X    additional bytes we need for name and data authorization.  However, we
X    can't process the first 12 bytes until we get all of them, so
X    return zero bytes used, and increase the number of bytes needed
X  */
X
X  namelength = IShort(&buf`5B6`5D);
X  datalength = IShort(&buf`5B8`5D);
X  CS`5Bfd`5D.ByteProcessing = FinishSetUpMessage;
X  CS`5Bfd`5D.NumberofBytesNeeded = n
X                               + pad((long)namelength) + pad((long)datalengt
Vh);
X  debug(8,(stderr, "need %d bytes to finish startup\n",
X`09   CS`5Bfd`5D.NumberofBytesNeeded - n));
X  return(0);
X`7D
X
Xlong    FinishSetUpMessage (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  enterprocedure("FinishSetUpMessage");
X  CS`5Bfd`5D.littleEndian = (buf`5B0`5D == 'l');
X  CS`5BServerHalf(fd)`5D.littleEndian = CS`5Bfd`5D.littleEndian;
X  littleEndian = CS`5Bfd`5D.littleEndian;
X  PrintSetUpMessage(buf);
X
X  /* after a set-up message, we expect a string of requests */
X  CS`5Bfd`5D.ByteProcessing = StartRequest;
X  CS`5Bfd`5D.NumberofBytesNeeded = 4;
X  return(n);
X`7D
X
X
Xlong    StartRequest (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  short   requestlength;
X  enterprocedure("StartRequest");
X
X  /* bytes 0,1 are ignored now; bytes 2,3 tell us the request length */
X  requestlength = IShort(&buf`5B2`5D);
X  CS`5Bfd`5D.ByteProcessing = FinishRequest;
X  CS`5Bfd`5D.NumberofBytesNeeded = 4 * requestlength;
X  debug(8,(stderr, "need %d more bytes to finish request\n",
X`09   CS`5Bfd`5D.NumberofBytesNeeded - n));
X  return(0);
X`7D
X
X
Xlong    FinishRequest (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  enterprocedure("FinishRequest");
X  DecodeRequest(fd, buf, n);
X  CS`5Bfd`5D.ByteProcessing = StartRequest;
X  CS`5Bfd`5D.NumberofBytesNeeded = 4;
X  return(n);
X`7D
X
X/* ************************************************************ */
X/*`09`09`09`09`09`09`09`09*/
X/*`09`09`09`09`09`09`09`09*/
X/* ************************************************************ */
X
XStartServerConnection(fd)
X     FD fd;
X`7B
X  enterprocedure("StartServerConnection");
X  /* when a new connection is started, we have no saved bytes */
X  CS`5Bfd`5D.SavedBytes = NULL;
X  CS`5Bfd`5D.SizeofSavedBytes = 0;
X  CS`5Bfd`5D.NumberofSavedBytes = 0;
X
X  /* when a new connection is started, we have no reply Queue */
X  FlushReplyQ(fd);
X
X  /* we need 8 bytes to start a SetUp reply */
X  CS`5Bfd`5D.ByteProcessing = StartSetUpReply;
X  CS`5Bfd`5D.NumberofBytesNeeded = 8;
X`7D
X
XStopServerConnection(fd)
X     FD fd;
X`7B
X  enterprocedure("StopServerConnection");
X  /* when a new connection is stopped, discard the old buffer */
X
X  if (CS`5Bfd`5D.SizeofSavedBytes > 0)
X#ifdef vax11c
X    MyFree((char *)CS`5Bfd`5D.SavedBytes);
X#else
X    Free((char *)CS`5Bfd`5D.SavedBytes);
X#endif /* vax11c */
X`7D
X
Xlong    StartSetUpReply (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  short   replylength;
X
X  enterprocedure("StartSetUpReply");
X  replylength = IShort(&buf`5B6`5D);
X  CS`5Bfd`5D.ByteProcessing = FinishSetUpReply;
X  CS`5Bfd`5D.NumberofBytesNeeded = n + 4 * replylength;
X  debug(8,(stderr, "need %d bytes to finish startup reply\n",
X`09   CS`5Bfd`5D.NumberofBytesNeeded - n));
X  return(0);
X`7D
X
Xlong    FinishSetUpReply (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  enterprocedure("FinishSetUpReply");
X  PrintSetUpReply(buf);
X  CS`5Bfd`5D.ByteProcessing = ServerPacket;
X  CS`5Bfd`5D.NumberofBytesNeeded = 32;
X  return(n);
X`7D
X
X/* ************************************************************ */
X
Xlong    ErrorPacket (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  fprintf(stdout, "Error: ");
X  DecodeError(fd, buf, n);
X  CS`5Bfd`5D.ByteProcessing = ServerPacket;
X  CS`5Bfd`5D.NumberofBytesNeeded = 32;
X  return(n);
X`7D
X
X
Xlong    EventPacket (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  DecodeEvent(fd, buf, n);
X  CS`5Bfd`5D.ByteProcessing = ServerPacket;
X  CS`5Bfd`5D.NumberofBytesNeeded = 32;
X  return(n);
X`7D
X
X
Xlong    ReplyPacket (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  short   replylength;
X
X  replylength = ILong(&buf`5B4`5D);
X
X  /*
X    Replies may need more bytes, so we compute how many more
X    bytes are needed and ask for them, not using any of the bytes
X    we were given (return(0) to say that no bytes were used).
X    If the replylength is zero (we don't need any more bytes), the
X    number of bytes needed will be the same as what we have, and
X    so the top-level loop will call the next routine immediately
X    with the same buffer of bytes that we were given.
X  */
X
X  CS`5Bfd`5D.ByteProcessing = FinishReply;
X  CS`5Bfd`5D.NumberofBytesNeeded = n + 4 * replylength;
X  debug(8,(stderr, "need %d bytes to finish reply\n", (4 * replylength)));
X  return(0);
X`7D
X
Xlong    ServerPacket (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  short   PacketType;
X  enterprocedure("ServerPacket");
X
X  PacketType = IByte(&buf`5B0`5D);
X  if (PacketType == 0)
X    return(ErrorPacket(fd, buf, n));
X  if (PacketType == 1)
X    return(ReplyPacket(fd, buf, n));
X  return(EventPacket(fd, buf, n));
X`7D
X
Xlong    FinishReply (fd, buf, n)
X     FD fd;
X     unsigned char *buf;
X     long    n;
X`7B
X  enterprocedure("FinishReply");
X  DecodeReply(fd, buf, n);
X  CS`5Bfd`5D.ByteProcessing = ServerPacket;
X  CS`5Bfd`5D.NumberofBytesNeeded = 32;
X  return(n);
X`7D
$ CALL UNPACK SERVER.C;10 355330808
$ create 'f'
X/* ************************************************** *
X *`09`09`09`09`09`09      *
X *  Table initialization for X11 protocol`09      *
X *`09`09`09`09`09`09      *
X *`09James Peterson, 1988`09`09`09      *
X *`09(c) Copyright MCC, 1988 `09`09      *
X *`09`09`09`09`09`09      *
X * ************************************************** */
X#if defined(vax11c) && !defined(MULTINET)
X#include "emulationlib.h"
X#endif
X
X#include "scope.h"
X#include "x11.h"
X
X/*
X  To initialize for the X11 protocol, we need to create data structures
X  describing the data types used by X11.
X*/
X
X/*
X  There are about 100-128 data types for X11.  This start with the simple
X  INT8, INT16, INT32 (byte, short, long), and the CARD8, CARD16, CARD32
X  (unsigned) and extend to records like RGB (a resource id, 3 color
X  values and a bitmask to select a subset of the 3 color values).  Each
X  data type has an assigned type index.  The type index identifies the
X  type (with a #define in x11.h) and is used to access an entry in an
X  array of type descriptors (TD).  Each type descriptor has the type name,
X  the kind of type, and a procedure to print an object of that type.
X  The print procedure for a type <foo> is named Print<foo>.  The kind of
X  type is
X
X  BUILTIN:      one of the primitive types.
X  ENUMERATED:   value should be one of a small set of values.  This type
X                needs a list of allowed values (and their print names).
X  SET:          value is a bitmask of a small set of values.  Each value
X                is a one-bit mask (and its print name).
X  RECORD:       value is a record of fields of other types.
X
X  The Type Descriptor array allows us to print a value if we know its type
X  (index) and the bytes in memory that are its value.
X*/
X
X
XInitializeX11()
X`7B
X  InitReplyQ();
X
X  InitBuiltInTypes();
X  InitEnumeratedTypes();
X  InitSetTypes();
X  InitValuesTypes();
X  InitRecordTypes();
X`7D
X
X/* ************************************************************ */
X/*`09`09`09`09`09`09`09`09*/
X/*`09`09`09`09`09`09`09`09*/
X/* ************************************************************ */
X
X/* define the various types */
X
XTYPE DefineType(typeid, class, name, printproc)
X     short   typeid;
X     short   class;
X     char   *name;
X     int     (*printproc)();
X`7B
X  TD`5Btypeid`5D.Name = name;
X  TD`5Btypeid`5D.Type = class;
X  TD`5Btypeid`5D.ValueList = NULL;
X  TD`5Btypeid`5D.PrintProc = printproc;
X  return(&TD`5Btypeid`5D);
X`7D
X
X/* ************************************************************ */
X/* define an Enumerated Value (or a Set Value) */
X
XDefineEValue(type, value, name)
X     TYPE type;
X     long    value;
X     char   *name;
X`7B
X  struct ValueListEntry  *p;
X
X  /* define the new value */
X  p = (struct ValueListEntry *)
X#ifdef vax11c
X                          MyMalloc ((long)(sizeof (struct ValueListEntry)));
X#else
X                          Malloc ((long)(sizeof (struct ValueListEntry)));
X#endif /* vax11c */
X  p->Name = name;
X  p->Value = value;
X
X  /* add an new value to the list. */
X  if (type->ValueList == NULL `7C`7C type->ValueList->Value > p->Value)
X    `7B
X      p->Next = type->ValueList;
X      type->ValueList = p;
X    `7D
X  else
X    `7B
X      /* keep the list sorted, smallest to largest */
X      struct ValueListEntry  *q = type->ValueList;
X      while (q->Next != NULL && q->Next->Value < p->Value)
X`09q = q->Next;
X      p->Next = q->Next;
X      q->Next = p;
X    `7D
X`7D
X
X/* ************************************************************ */
X/* a Values list is like an enumerated Value, but has a type and length
X   in addition to a value and name.  It is used to print a Values List */
X
X/* A Values List is a bitmask (like a set), but if the bit is set on, then
X   we have an associated value.  We need to know the length and type of the
X   associated value for each bit */
X
XDefineValues(type, value, length, ctype, name)
X     TYPE type;
X     long    value;
X     char   *name;
X`7B
X  struct ValueListEntry  *p;
X
X  p = (struct ValueListEntry *)
X#ifdef vax11c
X                            MyMalloc ((long)(sizeof (struct ValueListEntry))
V);
X#else
X                            Malloc ((long)(sizeof (struct ValueListEntry)));
X#endif /* vax11c */
X  p->Name = name;
X  p->Type = ctype;
X  p->Length = length;
X  p->Value = value;
X
X  /* add an new value to the list. */
X  if (type->ValueList == NULL `7C`7C type->ValueList->Value > p->Value)
X    `7B
X      p->Next = type->ValueList;
X      type->ValueList = p;
X    `7D
X  else
X    `7B
X      /* keep the list sorted, smallest to largest  */
X      struct ValueListEntry  *q = type->ValueList;
X      while (q->Next != NULL && q->Next->Value < p->Value)
X`09q = q->Next;
X      p->Next = q->Next;
X      q->Next = p;
X    `7D
X`7D
X
X
X
X/* ************************************************************ */
X
XInitBuiltInTypes()
X`7B
X  (void) DefineType(INT8, BUILTIN, "INT8", PrintINT8);
X  (void) DefineType(INT16, BUILTIN, "INT16", PrintINT16);
X  (void) DefineType(INT32, BUILTIN, "INT32", PrintINT32);
X  (void) DefineType(CARD8, BUILTIN, "CARD8", PrintCARD8);
X  (void) DefineType(CARD16, BUILTIN, "CARD16", PrintCARD16);
X  (void) DefineType(CARD32, BUILTIN, "CARD32", PrintCARD32);
X  (void) DefineType(BYTE, BUILTIN, "BYTE", PrintBYTE);
X  (void) DefineType(CHAR8, BUILTIN, "CHAR8", PrintCHAR8);
X  (void) DefineType(STRING16, BUILTIN, "STRING16", PrintSTRING16);
X  (void) DefineType(STR, BUILTIN, "STR", PrintSTR);
X  (void) DefineType(WINDOW, BUILTIN, "WINDOW", PrintWINDOW);
X  (void) DefineType(WINDOWD, BUILTIN, "WINDOWD", PrintWINDOWD);
X  (void) DefineType(WINDOWNR, BUILTIN, "WINDOWNR", PrintWINDOWNR);
X  (void) DefineType(PIXMAP, BUILTIN, "PIXMAP", PrintPIXMAP);
X  (void) DefineType(PIXMAPNPR, BUILTIN, "PIXMAPNPR", PrintPIXMAPNPR);
X  (void) DefineType(PIXMAPC, BUILTIN, "PIXMAPC", PrintPIXMAPC);
X  (void) DefineType(CURSOR, BUILTIN, "CURSOR", PrintCURSOR);
X  (void) DefineType(FONT, BUILTIN, "FONT", PrintFONT);
X  (void) DefineType(GCONTEXT, BUILTIN, "GCONTEXT", PrintGCONTEXT);
X  (void) DefineType(COLORMAP, BUILTIN, "COLORMAP", PrintCOLORMAP);
X  (void) DefineType(COLORMAPC, BUILTIN, "COLORMAPC", PrintCOLORMAPC);
X  (void) DefineType(DRAWABLE, BUILTIN, "DRAWABLE", PrintDRAWABLE);
X  (void) DefineType(FONTABLE, BUILTIN, "FONTABLE", PrintFONTABLE);
X  (void) DefineType(ATOM, BUILTIN, "ATOM", PrintATOM);
X  (void) DefineType(ATOMT, BUILTIN, "ATOMT", PrintATOMT);
X  (void) DefineType(VISUALID, BUILTIN, "VISUALID", PrintVISUALID);
X  (void) DefineType(VISUALIDC, BUILTIN, "VISUALIDC", PrintVISUALIDC);
X  (void) DefineType(TIMESTAMP, BUILTIN, "TIMESTAMP", PrintTIMESTAMP);
X  (void) DefineType(RESOURCEID, BUILTIN, "RESOURCEID", PrintRESOURCEID);
X  (void) DefineType(KEYSYM, BUILTIN, "KEYSYM", PrintKEYSYM);
X  (void) DefineType(KEYCODE, BUILTIN, "KEYCODE", PrintKEYCODE);
X  (void) DefineType(KEYCODEA, BUILTIN, "KEYCODEA", PrintKEYCODEA);
X  (void) DefineType(BUTTON, BUILTIN, "BUTTON", PrintBUTTON);
X  (void) DefineType(BUTTONA, BUILTIN, "BUTTONA", PrintBUTTONA);
X  (void) DefineType(EVENTFORM, BUILTIN, "EVENTFORM", PrintEVENTFORM);
X`7D
X
X/* ************************************************************ */
X/*`09`09`09`09`09`09`09`09*/
X/*`09`09`09`09`09`09`09`09*/
X/* ************************************************************ */
X
XInitEnumeratedTypes()
X`7B
X  TYPE p;
X
X  p = DefineType(REQUEST, ENUMERATED, "REQUEST", PrintENUMERATED);
X  DefineEValue(p, 1L, "CreateWindow");
X  DefineEValue(p, 2L, "ChangeWindowAttributes");
X  DefineEValue(p, 3L, "GetWindowAttributes");
X  DefineEValue(p, 4L, "DestroyWindow");
X  DefineEValue(p, 5L, "DestroySubwindows");
X  DefineEValue(p, 6L, "ChangeSaveSet");
X  DefineEValue(p, 7L, "ReparentWindow");
X  DefineEValue(p, 8L, "MapWindow");
X  DefineEValue(p, 9L, "MapSubwindows");
X  DefineEValue(p, 10L, "UnmapWindow");
X  DefineEValue(p, 11L, "UnmapSubwindows");
X  DefineEValue(p, 12L, "ConfigureWindow");
X  DefineEValue(p, 13L, "CirculateWindow");
X  DefineEValue(p, 14L, "GetGeometry");
X  DefineEValue(p, 15L, "QueryTree");
X  DefineEValue(p, 16L, "InternAtom");
X  DefineEValue(p, 17L, "GetAtomName");
X  DefineEValue(p, 18L, "ChangeProperty");
X  DefineEValue(p, 19L, "DeleteProperty");
X  DefineEValue(p, 20L, "GetProperty");
X  DefineEValue(p, 21L, "ListProperties");
X  DefineEValue(p, 22L, "SetSelectionOwner");
X  DefineEValue(p, 23L, "GetSelectionOwner");
X  DefineEValue(p, 24L, "ConvertSelection");
X  DefineEValue(p, 25L, "SendEvent");
X  DefineEValue(p, 26L, "GrabPointer");
X  DefineEValue(p, 27L, "UngrabPointer");
X  DefineEValue(p, 28L, "GrabButton");
X  DefineEValue(p, 29L, "UngrabButton");
X  DefineEValue(p, 30L, "ChangeActivePointerGrab");
X  DefineEValue(p, 31L, "GrabKeyboard");
X  DefineEValue(p, 32L, "UngrabKeyboard");
X  DefineEValue(p, 33L, "GrabKey");
X  DefineEValue(p, 34L, "UngrabKey");
X  DefineEValue(p, 35L, "AllowEvents");
X  DefineEValue(p, 36L, "GrabServer");
X  DefineEValue(p, 37L, "UngrabServer");
X  DefineEValue(p, 38L, "QueryPointer");
X  DefineEValue(p, 39L, "GetMotionEvents");
X  DefineEValue(p, 40L, "TranslateCoordinates");
X  DefineEValue(p, 41L, "WarpPointer");
X  DefineEValue(p, 42L, "SetInputFocus");
X  DefineEValue(p, 43L, "GetInputFocus");
X  DefineEValue(p, 44L, "QueryKeymap");
X  DefineEValue(p, 45L, "OpenFont");
X  DefineEValue(p, 46L, "CloseFont");
X  DefineEValue(p, 47L, "QueryFont");
X  DefineEValue(p, 48L, "QueryTextExtents");
X  DefineEValue(p, 49L, "ListFonts");
X  DefineEValue(p, 50L, "ListFontsWithInfo");
X  DefineEValue(p, 51L, "SetFontPath");
X  DefineEValue(p, 52L, "GetFontPath");
X  DefineEValue(p, 53L, "CreatePixmap");
X  DefineEValue(p, 54L, "FreePixmap");
X  DefineEValue(p, 55L, "CreateGC");
X  DefineEValue(p, 56L, "ChangeGC");
X  DefineEValue(p, 57L, "CopyGC");
X  DefineEValue(p, 58L, "SetDashes");
X  DefineEValue(p, 59L, "SetClipRectangles");
X  DefineEValue(p, 60L, "FreeGC");
X  DefineEValue(p, 61L, "ClearArea");
X  DefineEValue(p, 62L, "CopyArea");
X  DefineEValue(p, 63L, "CopyPlane");
X  DefineEValue(p, 64L, "PolyPoint");
X  DefineEValue(p, 65L, "PolyLine");
X  DefineEValue(p, 66L, "PolySegment");
X  DefineEValue(p, 67L, "PolyRectangle");
X  DefineEValue(p, 68L, "PolyArc");
X  DefineEValue(p, 69L, "FillPoly");
X  DefineEValue(p, 70L, "PolyFillRectangle");
X  DefineEValue(p, 71L, "PolyFillArc");
X  DefineEValue(p, 72L, "PutImage");
X  DefineEValue(p, 73L, "GetImage");
X  DefineEValue(p, 74L, "PolyText8");
X  DefineEValue(p, 75L, "PolyText16");
X  DefineEValue(p, 76L, "ImageText8");
X  DefineEValue(p, 77L, "ImageText16");
X  DefineEValue(p, 78L, "CreateColormap");
X  DefineEValue(p, 79L, "FreeColormap");
X  DefineEValue(p, 80L, "CopyColormapAndFree");
X  DefineEValue(p, 81L, "InstallColormap");
X  DefineEValue(p, 82L, "UninstallColormap");
X  DefineEValue(p, 83L, "ListInstalledColormaps");
X  DefineEValue(p, 84L, "AllocColor");
X  DefineEValue(p, 85L, "AllocNamedColor");
X  DefineEValue(p, 86L, "AllocColorCells");
X  DefineEValue(p, 87L, "AllocColorPlanes");
X  DefineEValue(p, 88L, "FreeColors");
X  DefineEValue(p, 89L, "StoreColors");
X  DefineEValue(p, 90L, "StoreNamedColor");
X  DefineEValue(p, 91L, "QueryColors");
X  DefineEValue(p, 92L, "LookupColor");
X  DefineEValue(p, 93L, "CreateCursor");
X  DefineEValue(p, 94L, "CreateGlyphCursor");
X  DefineEValue(p, 95L, "FreeCursor");
X  DefineEValue(p, 96L, "RecolorCursor");
X  DefineEValue(p, 97L, "QueryBestSize");
X  DefineEValue(p, 98L, "QueryExtension");
X  DefineEValue(p, 99L, "ListExtensions");
X  DefineEValue(p, 100L, "ChangeKeyboardMapping");
X  DefineEValue(p, 101L, "GetKeyboardMapping");
X  DefineEValue(p, 102L, "ChangeKeyboardControl");
X  DefineEValue(p, 103L, "GetKeyboardControl");
X  DefineEValue(p, 104L, "Bell");
X  DefineEValue(p, 105L, "ChangePointerControl");
X  DefineEValue(p, 106L, "GetPointerControl");
X  DefineEValue(p, 107L, "SetScreenSaver");
X  DefineEValue(p, 108L, "GetScreenSaver");
X  DefineEValue(p, 109L, "ChangeHosts");
X  DefineEValue(p, 110L, "ListHosts");
X  DefineEValue(p, 111L, "SetAccessControl");
X  DefineEValue(p, 112L, "SetCloseDownMode");
X  DefineEValue(p, 113L, "KillClient");
X  DefineEValue(p, 114L, "RotateProperties");
X  DefineEValue(p, 115L, "ForceScreenSaver");
X  DefineEValue(p, 116L, "SetPointerMapping");
X  DefineEValue(p, 117L, "GetPointerMapping");
X  DefineEValue(p, 118L, "SetModifierMapping");
X  DefineEValue(p, 119L, "GetModifierMapping");
X  DefineEValue(p, 127L, "NoOperation");
X
X  p = DefineType(REPLY, ENUMERATED, "REPLY", PrintENUMERATED);
X  DefineEValue(p, 3L, "GetWindowAttributes");
X  DefineEValue(p, 14L, "GetGeometry");
X  DefineEValue(p, 15L, "QueryTree");
X  DefineEValue(p, 16L, "InternAtom");
X  DefineEValue(p, 17L, "GetAtomName");
X  DefineEValue(p, 20L, "GetProperty");
X  DefineEValue(p, 21L, "ListProperties");
X  DefineEValue(p, 23L, "GetSelectionOwner");
X  DefineEValue(p, 26L, "GrabPointer");
X  DefineEValue(p, 31L, "GrabKeyboard");
X  DefineEValue(p, 38L, "QueryPointer");
X  DefineEValue(p, 39L, "GetMotionEvents");
X  DefineEValue(p, 40L, "TranslateCoordinates");
X  DefineEValue(p, 43L, "GetInputFocus");
X  DefineEValue(p, 44L, "QueryKeymap");
X  DefineEValue(p, 47L, "QueryFont");
X  DefineEValue(p, 48L, "QueryTextExtents");
X  DefineEValue(p, 49L, "ListFonts");
X  DefineEValue(p, 50L, "ListFontsWithInfo");
X  DefineEValue(p, 52L, "GetFontPath");
X  DefineEValue(p, 73L, "GetImage");
X  DefineEValue(p, 83L, "ListInstalledColormaps");
X  DefineEValue(p, 84L, "AllocColor");
X  DefineEValue(p, 85L, "AllocNamedColor");
X  DefineEValue(p, 86L, "AllocColorCells");
X  DefineEValue(p, 87L, "AllocColorPlanes");
X  DefineEValue(p, 91L, "QueryColors");
X  DefineEValue(p, 92L, "LookupColor");
X  DefineEValue(p, 97L, "QueryBestSize");
X  DefineEValue(p, 98L, "QueryExtension");
X  DefineEValue(p, 99L, "ListExtensions");
X  DefineEValue(p, 101L, "GetKeyboardMapping");
X  DefineEValue(p, 103L, "GetKeyboardControl");
X  DefineEValue(p, 106L, "GetPointerControl");
X  DefineEValue(p, 108L, "GetScreenSaver");
X  DefineEValue(p, 110L, "ListHosts");
X  DefineEValue(p, 116L, "SetPointerMapping");
X  DefineEValue(p, 117L, "GetPointerMapping");
X  DefineEValue(p, 118L, "SetModifierMapping");
X  DefineEValue(p, 119L, "GetModifierMapping");
X
X  p = DefineType(ERROR, ENUMERATED, "ERROR", PrintENUMERATED);
X  DefineEValue(p, 1L, "Request");
X  DefineEValue(p, 2L, "Value");
X  DefineEValue(p, 3L, "Window");
X  DefineEValue(p, 4L, "Pixmap");
X  DefineEValue(p, 5L, "Atom");
X  DefineEValue(p, 6L, "Cursor");
X  DefineEValue(p, 7L, "Font");
X  DefineEValue(p, 8L, "Match");
X  DefineEValue(p, 9L, "Drawable");
X  DefineEValue(p, 10L, "Access");
X  DefineEValue(p, 11L, "Alloc");
X  DefineEValue(p, 12L, "Colormap");
X  DefineEValue(p, 13L, "GContext");
X  DefineEValue(p, 14L, "IDChoice");
X  DefineEValue(p, 15L, "Name");
X  DefineEValue(p, 16L, "Length");
X  DefineEValue(p, 17L, "Implementation");
X
X  p = DefineType(EVENT, ENUMERATED, "EVENT", PrintENUMERATED);
X  DefineEValue(p, 2L, "KeyPress");
X  DefineEValue(p, 3L, "KeyRelease");
X  DefineEValue(p, 4L, "ButtonPress");
X  DefineEValue(p, 5L, "ButtonRelease");
X  DefineEValue(p, 6L, "MotionNotify");
X  DefineEValue(p, 7L, "EnterNotify");
X  DefineEValue(p, 8L, "LeaveNotify");
X  DefineEValue(p, 9L, "FocusIn");
X  DefineEValue(p, 10L, "FocusOut");
X  DefineEValue(p, 11L, "KeymapNotify");
X  DefineEValue(p, 12L, "Expose");
X  DefineEValue(p, 13L, "GraphicsExposure");
X  DefineEValue(p, 14L, "NoExposure");
X  DefineEValue(p, 15L, "VisibilityNotify");
X  DefineEValue(p, 16L, "CreateNotify");
X  DefineEValue(p, 17L, "DestroyNotify");
X  DefineEValue(p, 18L, "UnmapNotify");
X  DefineEValue(p, 19L, "MapNotify");
X  DefineEValue(p, 20L, "MapRequest");
X  DefineEValue(p, 21L, "ReparentNotify");
X  DefineEValue(p, 22L, "ConfigureNotify");
X  DefineEValue(p, 23L, "ConfigureRequest");
X  DefineEValue(p, 24L, "GravityNotify");
X  DefineEValue(p, 25L, "ResizeRequest");
X  DefineEValue(p, 26L, "CirculateNotify");
X  DefineEValue(p, 27L, "CirculateRequest");
X  DefineEValue(p, 28L, "PropertyNotify");
X  DefineEValue(p, 29L, "SelectionClear");
X  DefineEValue(p, 30L, "SelectionRequest");
X  DefineEValue(p, 31L, "SelectionNotify");
X  DefineEValue(p, 32L, "ColormapNotify");
X  DefineEValue(p, 33L, "ClientMessage");
X  DefineEValue(p, 34L, "MappingNotify");
X
X
X  p = DefineType(BITGRAVITY, ENUMERATED, "BITGRAVITY", PrintENUMERATED);
X  DefineEValue(p, 0L, "Forget");
X  DefineEValue(p, 1L, "NorthWest");
X  DefineEValue(p, 2L, "North");
X  DefineEValue(p, 3L, "NorthEast");
X  DefineEValue(p, 4L, "West");
X  DefineEValue(p, 5L, "Center");
X  DefineEValue(p, 6L, "East");
X  DefineEValue(p, 7L, "SouthWest");
X  DefineEValue(p, 8L, "South");
X  DefineEValue(p, 9L, "SouthEast");
X  DefineEValue(p, 10L, "Static");
X
X  p = DefineType(WINGRAVITY, ENUMERATED, "WINGRAVITY", PrintENUMERATED);
X  DefineEValue(p, 0L, "Unmap");
X  DefineEValue(p, 1L, "NorthWest");
X  DefineEValue(p, 2L, "North");
X  DefineEValue(p, 3L, "NorthEast");
X  DefineEValue(p, 4L, "West");
X  DefineEValue(p, 5L, "Center");
X  DefineEValue(p, 6L, "East");
X  DefineEValue(p, 7L, "SouthWest");
X  DefineEValue(p, 8L, "South");
X  DefineEValue(p, 9L, "SouthEast");
X  DefineEValue(p, 10L, "Static");
X
X  p = DefineType(BOOL, ENUMERATED, "BOOL", PrintENUMERATED);
X  DefineEValue(p, 0L, "False");
X  DefineEValue(p, 1L, "True");
X
X  p = DefineType(HOSTFAMILY, ENUMERATED, "HOSTFAMILY", PrintENUMERATED);
X  DefineEValue(p, 0L, "Internet");
X  DefineEValue(p, 1L, "DECnet");
X  DefineEValue(p, 2L, "Chaos");
X
X  p = DefineType(PK_MODE, ENUMERATED, "PK_MODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Synchronous");
X  DefineEValue(p, 1L, "Asynchronous");
X
X  p = DefineType(NO_YES, ENUMERATED, "NO_YES", PrintENUMERATED);
X  DefineEValue(p, 0L, "No");
X  DefineEValue(p, 1L, "Yes");
X  DefineEValue(p, 2L, "Default");
X
X  p = DefineType(WINDOWCLASS, ENUMERATED, "WINDOWCLASS", PrintENUMERATED);
X  DefineEValue(p, 0L, "CopyFromParent");
X  DefineEValue(p, 1L, "InputOutput");
X  DefineEValue(p, 2L, "InputOnly");
X
X  p = DefineType(BACKSTORE, ENUMERATED, "BACKSTORE", PrintENUMERATED);
X  DefineEValue(p, 0L, "NotUseful");
X  DefineEValue(p, 1L, "WhenMapped");
X  DefineEValue(p, 2L, "Always");
X
X  p = DefineType(MAPSTATE, ENUMERATED, "MAPSTATE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Unmapped");
X  DefineEValue(p, 1L, "Unviewable");
X  DefineEValue(p, 2L, "Viewable");
X
X  p = DefineType(STACKMODE, ENUMERATED, "STACKMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Above");
X  DefineEValue(p, 1L, "Below");
X  DefineEValue(p, 2L, "TopIf");
X  DefineEValue(p, 3L, "BottomIf");
X  DefineEValue(p, 4L, "Opposite");
X
X  p = DefineType(CIRMODE, ENUMERATED, "CIRMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "RaiseLowest");
X  DefineEValue(p, 1L, "LowerHighest");
X
X  p = DefineType(CHANGEMODE, ENUMERATED, "CHANGEMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Replace");
X  DefineEValue(p, 1L, "Prepend");
X  DefineEValue(p, 2L, "Append");
X
X  p = DefineType(GRABSTAT, ENUMERATED, "GRABSTAT", PrintENUMERATED);
X  DefineEValue(p, 0L, "Success");
X  DefineEValue(p, 1L, "AlreadyGrabbed");
X  DefineEValue(p, 2L, "InvalidTime");
X  DefineEValue(p, 3L, "NotViewable");
X  DefineEValue(p, 4L, "Frozen");
X
X  p = DefineType(EVENTMODE, ENUMERATED, "EVENTMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "AsyncPointer");
X  DefineEValue(p, 1L, "SyncPointer");
X  DefineEValue(p, 2L, "ReplayPointer");
X  DefineEValue(p, 3L, "AsyncKeyboard");
X  DefineEValue(p, 4L, "SyncKeyboard");
X  DefineEValue(p, 5L, "ReplayKeyboard");
X  DefineEValue(p, 6L, "AsyncBoth");
X  DefineEValue(p, 7L, "SyncBoth");
X
X  p = DefineType(FOCUSAGENT, ENUMERATED, "FOCUSAGENT", PrintENUMERATED);
X  DefineEValue(p, 0L, "None");
X  DefineEValue(p, 1L, "PointerRoot");
X  DefineEValue(p, 2L, "Parent");
X
X  p = DefineType(DIRECT, ENUMERATED, "DIRECT", PrintENUMERATED);
X  DefineEValue(p, 0L, "LeftToRight");
X  DefineEValue(p, 1L, "RightToLeft");
X
X  p = DefineType(GCFUNC, ENUMERATED, "GCFUNC", PrintENUMERATED);
X  DefineEValue(p, 0L, "Clear");
X  DefineEValue(p, 1L, "And");
X  DefineEValue(p, 2L, "AndReverse");
X  DefineEValue(p, 3L, "Copy");
X  DefineEValue(p, 4L, "AndInverted");
X  DefineEValue(p, 5L, "Noop");
X  DefineEValue(p, 6L, "Xor");
X  DefineEValue(p, 7L, "Or");
X  DefineEValue(p, 8L, "Nor");
X  DefineEValue(p, 9L, "Equiv");
X  DefineEValue(p, 10L, "Invert");
X  DefineEValue(p, 11L, "OrReverse");
X  DefineEValue(p, 12L, "CopyInverted");
X  DefineEValue(p, 13L, "OrInverted");
X  DefineEValue(p, 14L, "Nand");
X  DefineEValue(p, 15L, "Set");
X
X  p = DefineType(LINESTYLE, ENUMERATED, "LINESTYLE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Solid");
X  DefineEValue(p, 1L, "OnOffDash");
X  DefineEValue(p, 2L, "DoubleDash");
X
X  p = DefineType(CAPSTYLE, ENUMERATED, "CAPSTYLE", PrintENUMERATED);
X  DefineEValue(p, 0L, "NotLast");
X  DefineEValue(p, 1L, "Butt");
X  DefineEValue(p, 2L, "Round");
X  DefineEValue(p, 3L, "Projecting");
X
X  p = DefineType(JOINSTYLE, ENUMERATED, "JOINSTYLE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Miter");
X  DefineEValue(p, 1L, "Round");
X  DefineEValue(p, 2L, "Bevel");
X
X  p = DefineType(FILLSTYLE, ENUMERATED, "FILLSTYLE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Solid");
X  DefineEValue(p, 1L, "Tiled");
X  DefineEValue(p, 2L, "Stippled");
X  DefineEValue(p, 3L, "OpaqueStippled");
X
X  p = DefineType(FILLRULE, ENUMERATED, "FILLRULE", PrintENUMERATED);
X  DefineEValue(p, 0L, "EvenOdd");
X  DefineEValue(p, 1L, "Winding");
X
X  p = DefineType(SUBWINMODE, ENUMERATED, "SUBWINMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "ClipByChildren");
X  DefineEValue(p, 1L, "IncludeInferiors");
X
X  p = DefineType(ARCMODE, ENUMERATED, "ARCMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Chord");
X  DefineEValue(p, 1L, "PieSlice");
X
X  p = DefineType(RECTORDER, ENUMERATED, "RECTORDER", PrintENUMERATED);
X  DefineEValue(p, 0L, "UnSorted");
X  DefineEValue(p, 1L, "YSorted");
X  DefineEValue(p, 2L, "YXSorted");
X  DefineEValue(p, 3L, "YXBanded");
X
X  p = DefineType(COORMODE, ENUMERATED, "COORMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Origin");
X  DefineEValue(p, 1L, "Previous");
X
X  p = DefineType(POLYSHAPE, ENUMERATED, "POLYSHAPE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Complex");
X  DefineEValue(p, 1L, "Nonconvex");
X  DefineEValue(p, 2L, "Convex");
X
X  p = DefineType(IMAGEMODE, ENUMERATED, "IMAGEMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Bitmap");
X  DefineEValue(p, 1L, "XYPixmap");
X  DefineEValue(p, 2L, "ZPixmap");
X
X  p = DefineType(ALLORNONE, ENUMERATED, "ALLORNONE", PrintENUMERATED);
X  DefineEValue(p, 0L, "None");
X  DefineEValue(p, 1L, "All");
X
X  p = DefineType(OBJECTCLASS, ENUMERATED, "OBJECTCLASS", PrintENUMERATED);
X  DefineEValue(p, 0L, "Cursor");
X  DefineEValue(p, 1L, "Tile");
X  DefineEValue(p, 2L, "Stipple");
X
X  p = DefineType(OFF_ON, ENUMERATED, "OFF_ON", PrintENUMERATED);
X  DefineEValue(p, 0L, "Off");
X  DefineEValue(p, 1L, "On");
X  DefineEValue(p, 2L, "Default");
X
X  p = DefineType(INS_DEL, ENUMERATED, "INS_DEL", PrintENUMERATED);
X  DefineEValue(p, 0L, "Insert");
X  DefineEValue(p, 1L, "Delete");
X
X  p = DefineType(DIS_EN, ENUMERATED, "DIS_EN", PrintENUMERATED);
X  DefineEValue(p, 0L, "Disabled");
X  DefineEValue(p, 1L, "Enabled");
X
X  p = DefineType(CLOSEMODE, ENUMERATED, "CLOSEMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Destroy");
X  DefineEValue(p, 1L, "RetainPermanent");
X  DefineEValue(p, 2L, "RetainTemporary");
X
X  p = DefineType(SAVEMODE, ENUMERATED, "SAVEMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Reset");
X  DefineEValue(p, 1L, "Activate");
X
X  p = DefineType(RSTATUS, ENUMERATED, "RSTATUS", PrintENUMERATED);
X  DefineEValue(p, 0L, "Success");
X  DefineEValue(p, 1L, "Busy");
X  DefineEValue(p, 2L, "Failed");
X
X  p = DefineType(MOTIONDETAIL, ENUMERATED, "MOTIONDETAIL", PrintENUMERATED);
X  DefineEValue(p, 0L, "Normal");
X  DefineEValue(p, 1L, "Hint");
X
X  p = DefineType(ENTERDETAIL, ENUMERATED, "ENTERDETAIL", PrintENUMERATED);
X  DefineEValue(p, 0L, "Ancestor");
X  DefineEValue(p, 1L, "Virtual");
X  DefineEValue(p, 2L, "Inferior");
X  DefineEValue(p, 3L, "Nonlinear");
X  DefineEValue(p, 4L, "NonlinearVirtual");
X  DefineEValue(p, 5L, "Pointer");
X  DefineEValue(p, 6L, "PointerRoot");
X  DefineEValue(p, 7L, "None");
X
X  p = DefineType(BUTTONMODE, ENUMERATED, "BUTTONMODE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Normal");
X  DefineEValue(p, 1L, "Grab");
X  DefineEValue(p, 2L, "Ungrab");
X  DefineEValue(p, 3L, "WhileGrabbed");
X
X  p = DefineType(VISIBLE, ENUMERATED, "VISIBLE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Unobscured");
X  DefineEValue(p, 1L, "PartiallyObscured");
X  DefineEValue(p, 2L, "FullyObscured");
X
X  p = DefineType(CIRSTAT, ENUMERATED, "CIRSTAT", PrintENUMERATED);
X  DefineEValue(p, 0L, "Top");
X  DefineEValue(p, 1L, "Bottom");
X
X  p = DefineType(PROPCHANGE, ENUMERATED, "PROPCHANGE", PrintENUMERATED);
X  DefineEValue(p, 0L, "NewValue");
X  DefineEValue(p, 1L, "Deleted");
X
X  p = DefineType(CMAPCHANGE, ENUMERATED, "CMAPCHANGE", PrintENUMERATED);
X  DefineEValue(p, 0L, "Uninstalled");
X  DefineEValue(p, 1L, "Installed");
X
X  p = DefineType(MAPOBJECT, ENUMERATED, "MAPOBJECT", PrintENUMERATED);
X  DefineEValue(p, 0L, "Modifier");
X  DefineEValue(p, 1L, "Keyboard");
X  DefineEValue(p, 2L, "Pointer");
X
X  p = DefineType(BYTEMODE, ENUMERATED, "BYTEMODE", PrintENUMERATED);
X  DefineEValue(p, 0x42L, "MSB first");
X  DefineEValue(p, 0x6CL, "LSB first");
X
X  p = DefineType(BYTEORDER, ENUMERATED, "BYTEORDER", PrintENUMERATED);
X  DefineEValue(p, 0L, "LSB first");
X  DefineEValue(p, 1L, "MSB first");
X
X  p = DefineType(COLORCLASS, ENUMERATED, "COLORCLASS", PrintENUMERATED);
X  DefineEValue(p, 0L, "StaticGray");
X  DefineEValue(p, 1L, "GrayScale");
X  DefineEValue(p, 2L, "StaticColor");
X  DefineEValue(p, 3L, "PseudoColor");
X  DefineEValue(p, 4L, "TrueColor");
X  DefineEValue(p, 5L, "DirectColor");
X`7D
X
X/* ************************************************************ */
X/*`09`09`09`09`09`09`09`09*/
X/*`09`09`09`09`09`09`09`09*/
X/* ************************************************************ */
X
XInitSetTypes()
X`7B
X  TYPE p;
X
X  p = DefineType(SETofEVENT, SET, "SETofEVENT", PrintSET);
X  DefineEValue(p, 0x00000001L, "KeyPress");
X  DefineEValue(p, 0x00000002L, "KeyRelease");
X  DefineEValue(p, 0x00000004L, "ButtonPress");
X  DefineEValue(p, 0x00000008L, "ButtonRelease");
X  DefineEValue(p, 0x00000010L, "EnterWindow");
X  DefineEValue(p, 0x00000020L, "LeaveWindow");
X  DefineEValue(p, 0x00000040L, "PointerMotion");
X  DefineEValue(p, 0x00000080L, "PointerMotionHint");
X  DefineEValue(p, 0x00000100L, "Button1Motion");
X  DefineEValue(p, 0x00000200L, "Button2Motion");
X  DefineEValue(p, 0x00000400L, "Button3Motion");
X  DefineEValue(p, 0x00000800L, "Button4Motion");
X  DefineEValue(p, 0x00001000L, "Button5Motion");
X  DefineEValue(p, 0x00002000L, "ButtonMotion");
X  DefineEValue(p, 0x00004000L, "KeymapState");
X  DefineEValue(p, 0x00008000L, "Exposure");
X  DefineEValue(p, 0x00010000L, "VisibilityChange");
X  DefineEValue(p, 0x00020000L, "StructureNotify");
X  DefineEValue(p, 0x00040000L, "ResizeRedirect");
X  DefineEValue(p, 0x00080000L, "SubstructureNotify");
X  DefineEValue(p, 0x00100000L, "SubstructureRedirect");
X  DefineEValue(p, 0x00200000L, "FocusChange");
X  DefineEValue(p, 0x00400000L, "PropertyChange");
X  DefineEValue(p, 0x00800000L, "ColormapChange");
X  DefineEValue(p, 0x01000000L, "OwnerGrabButton");
X
X  p = DefineType(SETofPOINTEREVENT, SET, "SETofPOINTEREVENT", PrintSET);
X  DefineEValue(p, 0x00000004L, "ButtonPress");
X  DefineEValue(p, 0x00000008L, "ButtonRelease");
X  DefineEValue(p, 0x00000010L, "EnterWindow");
X  DefineEValue(p, 0x00000020L, "LeaveWindow");
X  DefineEValue(p, 0x00000040L, "PointerMotion");
X  DefineEValue(p, 0x00000080L, "PointerMotionHint");
X  DefineEValue(p, 0x00000100L, "Button1Motion");
X  DefineEValue(p, 0x00000200L, "Button2Motion");
X  DefineEValue(p, 0x00000400L, "Button3Motion");
X  DefineEValue(p, 0x00000800L, "Button4Motion");
X  DefineEValue(p, 0x00001000L, "Button5Motion");
X  DefineEValue(p, 0x00002000L, "ButtonMotion");
X  DefineEValue(p, 0x00004000L, "KeymapState");
X
X  p = DefineType(SETofDEVICEEVENT, SET, "SETofDEVICEEVENT", PrintSET);
X  DefineEValue(p, 0x00000001L, "KeyPress");
X  DefineEValue(p, 0x00000002L, "KeyRelease");
X  DefineEValue(p, 0x00000004L, "ButtonPress");
X  DefineEValue(p, 0x00000008L, "ButtonRelease");
X  DefineEValue(p, 0x00000040L, "PointerMotion");
X  DefineEValue(p, 0x00000100L, "Button1Motion");
X  DefineEValue(p, 0x00000200L, "Button2Motion");
X  DefineEValue(p, 0x00000400L, "Button3Motion");
X  DefineEValue(p, 0x00000800L, "Button4Motion");
X  DefineEValue(p, 0x00001000L, "Button5Motion");
X  DefineEValue(p, 0x00002000L, "ButtonMotion");
X
X  p = DefineType(SETofKEYBUTMASK, SET, "SETofKEYBUTMASK", PrintSET);
X  DefineEValue(p, 0x0001L, "Shift");
X  DefineEValue(p, 0x0002L, "Lock");
X  DefineEValue(p, 0x0004L, "Control");
X  DefineEValue(p, 0x0008L, "Mod1");
X  DefineEValue(p, 0x0010L, "Mod2");
X  DefineEValue(p, 0x0020L, "Mod3");
X  DefineEValue(p, 0x0040L, "Mod4");
X  DefineEValue(p, 0x0080L, "Mod5");
X  DefineEValue(p, 0x0100L, "Button1");
X  DefineEValue(p, 0x0200L, "Button2");
X  DefineEValue(p, 0x0400L, "Button3");
X  DefineEValue(p, 0x0800L, "Button4");
X  DefineEValue(p, 0x1000L, "Button5");
X
X  p = DefineType(SETofKEYMASK, SET, "SETofKEYMASK", PrintSET);
X  DefineEValue(p, 0x0001L, "Shift");
X  DefineEValue(p, 0x0002L, "Lock");
X  DefineEValue(p, 0x0004L, "Control");
X  DefineEValue(p, 0x0008L, "Mod1");
X  DefineEValue(p, 0x0010L, "Mod2");
X  DefineEValue(p, 0x0020L, "Mod3");
X  DefineEValue(p, 0x0040L, "Mod4");
X  DefineEValue(p, 0x0080L, "Mod5");
X  DefineEValue(p, 0x8000L, "AnyModifier");
X
X  p = DefineType(COLORMASK, SET, "COLORMASK", PrintSET);
X  DefineEValue(p, 0x01L, "do-red");
X  DefineEValue(p, 0x02L, "do-green");
X  DefineEValue(p, 0x04L, "do-blue");
X
X  p = DefineType(SCREENFOCUS, SET, "SCREENFOCUS", PrintSET);
X  DefineEValue(p, 0x01L, "focus");
X  DefineEValue(p, 0x02L, "same-screen");
X`7D
X
X
X/* ************************************************************ */
X/*`09`09`09`09`09`09`09`09*/
X/*`09`09`09`09`09`09`09`09*/
X/* ************************************************************ */
X
X/* Print Routines for builtin record types */
X
XPrintCHAR2B(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 1, CARD8, "byte1");
X  PrintField(buf, 1, 1, CARD8, "byte2");
X`7D
X
XPrintPOINT(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 2, INT16, "x");
X  PrintField(buf, 2, 2, INT16, "y");
X  return(4);
X`7D
X
XPrintRECTANGLE(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 2, INT16, "x");
X  PrintField(buf, 2, 2, INT16, "y");
X  PrintField(buf, 4, 2, CARD16, "width");
X  PrintField(buf, 6, 2, CARD16, "height");
X  return(8);
X`7D
X
XPrintARC(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 2, INT16, "x");
X  PrintField(buf, 2, 2, INT16, "y");
X  PrintField(buf, 4, 2, CARD16, "width");
X  PrintField(buf, 6, 2, CARD16, "height");
X  PrintField(buf, 8, 2, INT16, "angle1");
X  PrintField(buf, 10, 2, INT16, "angle2");
X  return(12);
X`7D
X
XPrintHOST(buf)
X     unsigned char *buf;
X`7B
X  short   n;
X  PrintField(buf, 0, 1, HOSTFAMILY, "family");
X  PrintField(buf, 2, 2, DVALUE2(n), "length of address");
X  n = IShort(&buf`5B2`5D);
X  PrintList(&buf`5B4`5D, (long)n, BYTE, "address");
X  return(pad((long)(4 + n)));
X`7D
X
XPrintTIMECOORD(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 4, TIMESTAMP, "time");
X  PrintField(buf, 4, 2, CARD16, "x");
X  PrintField(buf, 6, 2, CARD16, "y");
X  return(8);
X`7D
X
XPrintFONTPROP(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 4, ATOM, "name");
X  PrintField(buf, 4, 4, INT32, "value");
X  return(8);
X`7D
X
XPrintCHARINFO(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 2, INT16, "left-side-bearing");
X  PrintField(buf, 2, 2, INT16, "right-side-bearing");
X  PrintField(buf, 4, 2, INT16, "character-width");
X  PrintField(buf, 6, 2, INT16, "ascent");
X  PrintField(buf, 8, 2, INT16, "descent");
X  PrintField(buf, 10, 2, CARD16, "attributes");
X  return(12);
X`7D
X
XPrintSEGMENT(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 2, INT16, "x1");
X  PrintField(buf, 2, 2, INT16, "y1");
X  PrintField(buf, 4, 2, INT16, "x2");
X  PrintField(buf, 6, 2, INT16, "y2");
X  return(8);
X`7D
X
XPrintCOLORITEM(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 4, CARD32, "pixel");
X  PrintField(buf, 4, 2, CARD16, "red");
X  PrintField(buf, 6, 2, CARD16, "green");
X  PrintField(buf, 8, 2, CARD16, "blue");
X  PrintField(buf, 10, 1, COLORMASK, "component selector");
X  return(12);
X`7D
X
XPrintRGB(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 2, CARD16, "red");
X  PrintField(buf, 2, 2, CARD16, "green");
X  PrintField(buf, 4, 2, CARD16, "blue");
X  return(8);
X`7D
X
XPrintFORMAT(buf)
X     unsigned char *buf;
X`7B
X  PrintField(buf, 0, 1, CARD8, "depth");
X  PrintField(buf, 1, 1, CARD8, "bits-per-pixel");
X  PrintField(buf, 2, 1, CARD8, "scanline-pad");
X  return(8);
X`7D
X
XPrintSCREEN(buf)
X     unsigned char *buf;
X`7B
X  short   n /* number of elements in List of DEPTH */ ;
X  long    m /* length (in bytes) of List of DEPTH */ ;
X
X  PrintField(buf, 0, 4, WINDOW, "root");
X  PrintField(buf, 4, 4, COLORMAP, "default-colormap");
X  PrintField(buf, 8, 4, CARD32, "white-pixel");
+-+-+-+-+-+-+-+-  END  OF PART 7 +-+-+-+-+-+-+-+-
--
Patrick L. Mahan

--- TGV Window Washer ------------------------------- [e-mail] ---------

Waking a person unnecessarily should not be considered  - Lazarus Long
a capital crime.  For a first offense, that is            From the Notebooks of
                              Lazarus Long