in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

int

XChangeGC (dpy, gc, valuemask, values)

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

int

XChangeProperty (

register Display *dpy,

Window w,

int mode, /* PropModeReplace, PropModePrepend, PropModeAppend */

_Xconst unsigned char *data,

int nelements)

{

register xChangePropertyReq *req;

register long len;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

#define AllMaskBits (CWBackPixmap|CWBackPixel|CWBorderPixmap|\

CWBorderPixel|CWBitGravity|CWWinGravity|\

CWBackingStore|CWBackingPlanes|CWBackingPixel|\

in this Software without prior written authorization from The Open Group.

*/

#define NEED_EVENTS

#include "Xlibint.h"

Bool XCheckIfEvent (dpy, event, predicate, arg)

register Display *dpy;

Bool (*predicate)(

Display* /* display */,

XEvent* /* event */,

char* /* arg */

); /* function to call */

register XEvent *event; /* XEvent to be filled in. */

char *arg;

from The Open Group.

*/

#include "Xlibint.h"

/*

* XCloseDisplay - XSync the connection to the X Server, close the connection,

*/

int

{

register _XExtension *ext;

register int i;

in this Software without prior written authorization from The Open Group.

*/

/*

* This file contains operating system dependencies.

#include <sys/utsname.h>

#endif

{

char *dst = Xmalloc (len + 1);

*

* [protocol/] [hostname] : [:] displaynumber [.screennumber]

*

* as the most efficient local connection to a server on the same machine.

* This is usually:

*

*

*/

XtransConnInfo

{

int family;

int saddrlen;

/*

* Step 1, find the hostname. This is delimited by either one colon,

* or two colons in the case of DECnet (DECnet Phase V allows a single

*/

lastp = p;

if (!lastc) return NULL; /* must have a colon */

/* DECnet display specified */

#ifndef DNETCONN

*

*/

{

XtransConnInfo trans_conn;

AUTH *a;

XDR xdr;

a = (AUTH *)authdes_create(servername, window, NULL, NULL);

if (a == (AUTH *)NULL) {

perror("auth_create");

return 0;

#endif /* K5AUTH */

static void

{

#ifdef SECURE_RPC

char rpc_cred[MAX_AUTH_BYTES];

from The Open Group.

*/

/* This module implements a simple sparse array.

Possible errors are Out-of-memory.

*/

int XSaveContext(

Display *display,

register XID rid,

register XContext context,

_Xconst char* data)

{

DB *pdb;

register DB db;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlib.h"

* xoffset=0

* no extra bytes per line

*/

Pixmap XCreateBitmapFromData(

Display *display,

Drawable d,

_Xconst char *data,

unsigned int width,

unsigned int height)

{

XImage ximage;

GC gc;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

#include "Xcmsint.h"

Colormap XCreateColormap(dpy, w, visual, alloc)

register Display *dpy;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

static XGCValues const initial_GC = {

GXcopy, /* function */

4 /* dashes (list [4,4]) */

};

GC XCreateGC (dpy, d, valuemask, values)

register Display *dpy;

*/

static void

{

unsigned long values[32];

register unsigned long *value = values;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

#else

#include <dlfcn.h>

#endif

#if defined(hpux)

typedef shl_dt XModuleType;

_XUnlockMutex (_Xglobal_lock); \

}

_XTryShapeCursor (Display *dpy,

Font source_font,

Font mask_font,

from The Open Group.

*/

/* XDisplayName.c */

/*

/* Written at Waterloo - JMSellens */

#include <stdio.h>

char *

{

char *d;

if ( display != (char *)NULL && *display != '\0' )

if ( (d = getenv( "DISPLAY" )) != (char *)NULL )

return( d );

return( "" );

SOFTWARE.

******************************************************************/

#include "Xlibint.h"

#include <X11/Xos.h>

}

int

/*ARGSUSED*/

XGetErrorDatabaseText(

Display *dpy,

_Xconst char *defaultp,

char *buffer,

int nbytes)

{

static XrmDatabase db = NULL;

if (db)

{

tlen = strlen (name) + strlen (type) + 2;

}

else

result.addr = (XPointer)NULL;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

/*

* XErrorHandler - This procedure sets the X non-fatal error handler

* (_XErrorFunction) to be the specified routine. If NULL is passed in

* the original error handler is restored.

*/

{

_XLockMutex(_Xglobal_lock);

oldhandler = _XErrorFunction;

* the original error handler is restored.

*/

{

_XLockMutex(_Xglobal_lock);

oldhandler = _XIOErrorFunction;

*/

#include "Xlibint.h"

#include "Xlcint.h"

#define XMAXLIST 256

char **

{

char *plist[XMAXLIST];

char **list;

*num = 0;

if (!str || !*str) {

}

strcpy(ptr, str);

/* somebody who specifies more than XMAXLIST basefontnames will lose */

while (*num < (sizeof plist / sizeof plist[0])) {

char *back;

break;

}

if (!(list = (char **) Xmalloc((unsigned)sizeof(char *) * (*num + 1)))) {

return (char **)NULL;

}

memcpy((char *)list, (char *)plist, sizeof(char *) * (*num));

}

static char **

{

char **string_list_ret, **list_src, **list_dst, *dst;

int length, count;

return string_list_ret;

}

XFontSet

XCreateFontSet (

Display *dpy,

char ***missing_charset_list,

int *missing_charset_count,

char **def_string)

{

XOM om;

XOC oc;

authorization from the X Consortium and the XFree86 Project.

*/

#define NEED_REPLIES

#include "Xlibint.h"

static XFontStruct *_XQueryFont(

Display* /* dpy */,

Font /* fid */,

unsigned long /* seq */

);

#ifdef USE_XF86BIGFONT

#define CAP_VerifiedLocal 256

static XF86BigfontCodes *_XF86BigfontCodes(

Display* /* dpy */

);

static XFontStruct *_XF86BigfontQueryFont(

Display* /* dpy */,

XF86BigfontCodes* /* extcodes */,

Font /* fid */,

unsigned long /* seq */

);

void _XF86BigfontFreeFontMetrics(

XFontStruct* /* fs */

);

#endif /* USE_XF86BIGFONT */

XFontStruct *XLoadQueryFont(

register Display *dpy,

_Xconst char *name)

{

XFontStruct *font_result;

register long nbytes;

static int XF86BigfontNumber = 1040697125;

static int

{

/* Don't Xfree(extension->private_data) because it is on the same malloc

chunk as extension. */

}

static XF86BigfontCodes *

{

XEDataObject dpy_union;

XExtData *pData;

}

static int

{

return 0;

}

#endif /* USE_XF86BIGFONT */

int _XF86LoadQueryLocaleFont(

Display *dpy,

_Xconst char *name,

XFontStruct **xfp,

Font *fidp)

{

int l;

char *charset, *p;

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

#endif

#ifdef USE_XF86BIGFONT

extern void _XF86BigfontFreeFontMetrics(

XFontStruct* /* fs */

);

#endif

char **XListFontsWithInfo(

register Display *dpy,

_Xconst char *pattern, /* null-terminated */

int maxNames,

int *actualCount, /* RETURN */

XFontStruct **info) /* RETURN */

{

register long nbytes;

register int i;

*/

#define NEED_REPLIES

#include "Xlibint.h"

register Display *dpy,

_Xconst char *pattern, /* null-terminated */

int maxNames,

int *actualCount) /* RETURN */

{

register long nbytes;

register unsigned i;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

int

{

register xResourceReq *req;

from The Open Group.

*/

#include "Xlibint.h"

#include "Xutil.h"

* returns 0 if there was some problem, else the position bitmask.

*/

Display *dpy, /* user's display connection */

int screen, /* screen on which to do computation */

_Xconst char *pos, /* user provided geometry spec */

register int *y, /* always set on successful RETURN */

register int *width, /* always set on successful RETURN */

register int *height) /* always set on successful RETURN */

{

int px, py; /* returned values from parse */

unsigned int pwidth, pheight; /* returned values from parse */

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include <stdio.h>

#include "Xlibint.h"

#include "Xcmsint.h"

register Display *dpy,

Colormap cmap,

_Xconst char *colorname, /* STRING8 */

XColor *hard_def, /* RETURN */

XColor *exact_def) /* RETURN */

{

long nbytes;

SOFTWARE.

******************************************************************/

#include "Xlibint.h"

#include <X11/Xos.h>

/*ARGSUSED*/

{

#ifdef WIN32

register char *ptr1;

}

{

XrmDatabase userdb;

XrmDatabase xdb;

#endif

}

Display *dpy, /* display for defaults.... */

char _Xconst *prog, /* name of program for option */

register _Xconst char *name) /* name of option program wants */

{ /* to get, for example, "font" */

XrmName names[3];

XrmClass classes[3];

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

#include <X11/Xutil.h> /* for XDestroyImage */

#define ROUNDUP(nbytes, pad) (((((nbytes) - 1) + (pad)) / (pad)) * (pad))

{

register unsigned long y;

*/

#define NEED_REPLIES

#include "Xlibint.h"

return ((int) rep.nElts);

}

#if NeedWidePrototypes

unsigned int first_keycode,

#else

#endif

int count,

int *keysyms_per_keycode)

{

long nbytes;

unsigned long nkeysyms;

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

} _XWAttrsState;

static Bool

{

register _XWAttrsState *state;

xGetWindowAttributesReply replbuf;

in this Software without prior written authorization from The Open Group.

*/

#define NEED_EVENTS

#include "Xlibint.h"

XIfEvent (dpy, event, predicate, arg)

register Display *dpy;

Bool (*predicate)(

Display* /* display */,

XEvent* /* event */,

char* /* arg */

); /* function to call */

register XEvent *event;

char *arg;

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

int

XDrawImageString(

register Display *dpy,

Drawable d,

int y,

_Xconst char *string,

int length)

{

register xImageText8Req *req;

char *CharacterOffset = (char *)string;

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

int

XDrawImageString16(

register Display *dpy,

Drawable d,

int y,

_Xconst XChar2b *string,

int length)

{

register xImageText16Req *req;

XChar2b *CharacterOffset = (XChar2b *)string;

in this Software without prior written authorization from The Open Group.

*/

#include <X11/Xlibint.h>

#include <X11/Xutil.h>

#include <stdio.h>

static int _XDestroyImage(XImage *);

static unsigned long _XGetPixel(XImage *, int, int);

static unsigned long _XGetPixel1(XImage *, int, int);

static int _XPutPixel32(XImage *, int, int, unsigned long);

static XImage *_XSubImage(XImage *, int, int, unsigned int, unsigned int);

static int _XAddPixel(XImage *, long);

static unsigned char const _lomask[0x09] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };

static unsigned char const _himask[0x09] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00 };

display. */

int

{

register ScreenFormat *fmt = dpy->pixmap_format;

register int i;

}

int

{

register ScreenFormat *fmt = dpy->pixmap_format;

register int i;

* For XY formats, bitmap_unit is 8, 16, or 32 bits.

* For Z format, bits_per_pixel is 1, 4, 8, 16, 24, or 32 bits.

*/

{

register unsigned char c;

_XReverse_Bytes (bp, img->bitmap_unit >> 3);

}

{

register unsigned char c;

switch (img->bits_per_pixel) {

}

}

{

register unsigned char chlo, chhi;

int hibits;

* routines always have to check to make sure the optimization is still

* valid, and reinit the functions if not.

*/

{

image->f.create_image = XCreateImage;

image->f.destroy_image = _XDestroyImage;

*

*/

{

register unsigned long pixel;

register int row, col;

from The Open Group.

*/

#include <X11/Xlibint.h>

#include <X11/Xos.h>

* at appropriate times.

*/

XExtCodes *XInitExtension (

Display *dpy,

_Xconst char *name)

{

XExtCodes codes; /* temp. place for extension information. */

register _XExtension *ext;/* need a place to build it all */

}

typedef Bool (*WireToEventType) (

Display* /* display */,

XEvent* /* re */,

xEvent* /* event */

);

WireToEventType XESetWireToEvent(dpy, event_number, proc)

}

typedef Status (*EventToWireType) (

Display* /* display */,

XEvent* /* re */,

xEvent* /* event */

);

EventToWireType XESetEventToWire(dpy, event_number, proc)

}

typedef Bool (*WireToErrorType) (

Display* /* display */,

XErrorEvent* /* he */,

xError* /* we */

);

WireToErrorType XESetWireToError(dpy, error_number, proc)

from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

}

}

Display *dpy,

const char *name,

Bool onlyIfExists)

{

Atom atom;

unsigned long sig;

in this Software without prior written authorization from The Open Group.

*/

/* Beware, here be monsters (still under construction... - JG */

#define XK_LATIN2

#define XK_LATIN3

#define XK_LATIN4

#define XK_CYRILLIC

#define XK_GREEK

#define XK_ARMENIAN

#define XK_XKB_KEYS

#include <X11/keysymdef.h>

#include <stdio.h>

#ifdef USE_OWN_COMPOSE

#include "imComp.h"

#endif

#ifdef XKB

#define XKeycodeToKeysym _XKeycodeToKeysym

#define XKeysymToKeycode _XKeysymToKeycode

#define AllMods (ShiftMask|LockMask|ControlMask| \

Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask)

struct _XKeytrans {

struct _XKeytrans *next;/* next on list */

};

static KeySym

KeyCodetoKeySym(register Display *dpy, KeyCode keycode, int col)

{

register int per = dpy->keysyms_per_keycode;

register KeySym *syms;

return syms[col];

}

KeySym

XKeycodeToKeysym(Display *dpy,

#if NeedWidePrototypes

KeyCode kc,

#endif

int col)

{

if ((! dpy->keysyms) && (! _XKeyInitialize(dpy)))

return NoSymbol;

}

static void

{

register XModifierKeymap *map;

register int i, j, n;

}

static int

{

register XModifierKeymap *map;

}

int

{

int per, n;

KeySym *keysyms;

return 1;

}

void

XConvertCase(sym, lower, upper)

register KeySym sym;

KeySym *lower;

KeySym *upper;

{

*lower = sym;

*upper = sym;

switch(sym >> 8) {

case 0: /* Latin 1 */

if ((sym >= XK_A) && (sym <= XK_Z))

*lower += (XK_oslash - XK_Ooblique);

else if ((sym >= XK_oslash) && (sym <= XK_thorn))

*upper -= (XK_oslash - XK_Ooblique);

break;

case 1: /* Latin 2 */

/* Assume the KeySym is a legal value (ignore discontinuities) */

sym != XK_Greek_finalsmallsigma)

*upper -= (XK_Greek_alpha - XK_Greek_ALPHA);

break;

case 0x14: /* Armenian */

if (sym >= XK_Armenian_AYB && sym <= XK_Armenian_fe) {

*lower = sym | 1;

*upper = sym & ~1;

}

break;

}

}

int

_XTranslateKey( register Display *dpy,

KeyCode keycode,

register unsigned int modifiers,

unsigned int *modifiers_return,

KeySym *keysym_return)

{

int per;

register KeySym *syms;

}

static void

{

register struct _XKeytrans *p, *np;

}

int

XRebindKeysym (

Display *dpy,

KeySym keysym,

int nm, /* number of modifiers in mlist */

_Xconst unsigned char *str,

int nbytes)

{

register struct _XKeytrans *tmp, *p;

int nb;

}

unsigned

{

CARD8 code,mods;

register KeySym *kmax;

* can't map some keysym to a modifier.

*/

static void

{

register int i;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

#include <X11/Xresource.h>

#define NEEDVTABLE

#include "ks_tables.h"

typedef struct _GRNData {

XrmValuePtr value;

} GRNData;

/*ARGSUSED*/

XrmDatabase* db,

XrmBindingList bindings,

XrmQuarkList quarks,

XrmValuePtr value,

XPointer data

)

{

GRNData *gd = (GRNData *)data;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

register Display *dpy,

_Xconst char *name)

{

register long nbytes;

Font fid;

in this Software without prior written authorization from The Open Group.

*/

/*

* Author: Stephen Gildea, MIT X Consortium

#include "locking.h"

#endif

register Display* dpy)

{

#ifdef XTHREADS

LockDisplay(dpy);

#endif

}

register Display* dpy)

{

#ifdef XTHREADS

LockDisplay(dpy);

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include <stdio.h>

#include "Xlibint.h"

#include "Xcmsint.h"

register Display *dpy,

Colormap cmap,

_Xconst char *spec,

XColor *def,

XColor *scr)

{

register int n;

xLookupColorReply reply;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

/*

* This file makes full definitions of routines for each macro.

* We do not expect C programs to use these, but other languages may

*/

#undef XDestroyImage

int

{

return((*((ximage)->f.destroy_image))((ximage)));

}

#undef XGetPixel

{

return ((*((ximage)->f.get_pixel))((ximage), (x), (y)));

}

#undef XPutPixel

{

return((*((ximage)->f.put_pixel))((ximage), (x), (y), (pixel)));

}

#undef XSubImage

{

return((*((ximage)->f.sub_image))((ximage), (x),

(y), (width), (height)));

}

#undef XAddPixel

{

return((*((ximage)->f.add_pixel))((ximage), (value)));

}

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

return 1;

}

XModifierKeymap *

XInsertModifiermapEntry(XModifierKeymap *map,

#if NeedWidePrototypes

KeyCode keycode,

#endif

int modifier)

{

XModifierKeymap *newmap;

int i,

return(newmap);

}

XModifierKeymap *

XDeleteModifiermapEntry(XModifierKeymap *map,

#if NeedWidePrototypes

KeyCode keycode,

#endif

int modifier)

{

int i,

row = modifier * map->max_keypermod;

* Author: Katsuhisa Yano TOSHIBA Corp.

* mopi@osa.ilab.toshiba.co.jp

*/

#include "Xlibint.h"

#include "Xlcint.h"

XOM

XOpenOM(Display *dpy, XrmDatabase rdb, _Xconst char *res_name,

_Xconst char *res_class)

{

XLCd lcd = _XOpenLC((char *) NULL);

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#define NEED_EVENTS

#include "Xlibint.h"

#include <X11/Xtrans.h>

#include <X11/Xatom.h>

#include "bigreqstr.h"

#include <stdio.h>

#include "Xintconn.h"

* Connects to a server, creates a Display object and returns a pointer to

* the newly created Display back to the caller.

*/

register _Xconst char *display)

{

register Display *dpy; /* New Display object being created. */

register int i;

xVisualType *vp;

} u; /* proto data returned from server */

long setuplength; /* number of bytes in setup message */

char *conn_auth_name, *conn_auth_data;

int conn_auth_namelen, conn_auth_datalen;

unsigned long mask;

bzero((char *) &client, sizeof(client));

bzero((char *) &prefix, sizeof(prefix));

}

/* Set up the output buffers. */

/* Set up the input event queue and input event queue parameters. */

dpy->head = dpy->tail = NULL;

return(NULL);

}

_XRead (dpy, (char *)u.setup, setuplength);

/*

* If the connection was not accepted by the server due to problems,

* give error message to the user....

fprintf (stderr,

"Xlib: connection to \"%s\" refused by server\r\nXlib: ",

fullname);

(Size_t)prefix.lengthReason, stderr);

OutOfMemory(dpy, setup);

return (NULL);

}

/*

* We succeeded at authorization, so let us move the data into

* the display structure.

*/

OutOfMemory(dpy, setup);

return (NULL);

}

dpy->vendor = (char *) Xmalloc((unsigned) (u.setup->nbytesVendor + 1));

if (dpy->vendor == NULL) {

OutOfMemory(dpy, setup);

return (NULL);

}

vendorlen = u.setup->nbytesVendor;

/*

* validate setup length

*/

OutOfMemory(dpy, setup);

return (NULL);

}

memmove (setup, u.vendor + vendorlen,

(int) setuplength - sz_xConnSetup - vendorlen);

u.vendor = setup;

/*

* First decode the Z axis Screen format information.

*/

for (i = 0; i < dpy->nformats; i++) {

register ScreenFormat *fmt = &dpy->pixmap_format[i];

fmt->depth = u.sf->depth;

OutOfMemory (dpy, setup);

return(NULL);

}

/*

* Now go deal with each screen structure.

*/

for (i = 0; i < dpy->nscreens; i++) {

register Screen *sp = &dpy->screens[i];

sp->display = dpy;

sp->root = u.rp->windowId;

sp->cmap = u.rp->defaultColormap;

*/

for (j = 0; j < sp->ndepths; j++) {

Depth *dp = &sp->depths[j];

dp->depth = u.dp->depth;

dp->nvisuals = u.dp->nVisuals;

u.dp = (xDepth *) (((char *) u.dp) + sz_xDepth);

}

for (k = 0; k < dp->nvisuals; k++) {

register Visual *vp = &dp->visuals[k];

vp->visualid = u.vp->visualID;

vp->class = u.vp->class;

vp->bits_per_rgb= u.vp->bitsPerRGB;

}

sp->root_visual = _XVIDtoVisual(dpy, root_visualID);

}

/*

* Now start talking to the server to setup all other information...

if (dpy->xkb_info)

(*dpy->free_funcs->xkb)(dpy);

if (dpy->screens) {

register int i;

SOFTWARE.

******************************************************************/

/* XrmParseCommand()

exit(1);

}

XrmDatabase *pdb, /* data base */

register XrmOptionDescList options, /* pointer to table of valid options */

int num_options, /* number of options */

_Xconst char *prefix, /* name to prefix resources with */

int *argc, /* address of argument count */

char **argv) /* argument list (command line) */

{

int foundOption;

char **argsave;

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include <stdio.h>

#include "Xlibint.h"

#include "Xcmsint.h"

register Display *dpy,

Colormap cmap,

_Xconst char *spec,

XColor *def)

{

register int n, i;

int r, g, b;

from The Open Group.

*/

#include "Xlibint.h"

#include "Xutil.h"

return (-Result);

}

_Xconst char *string,

int *x,

int *y,

unsigned int *width, /* RETURN */

unsigned int *height) /* RETURN */

{

int mask = NoValue;

register char *strind;

in this Software without prior written authorization from The Open Group.

*/

#define NEED_EVENTS

#include "Xlibint.h"

register Display *dpy;

register XEvent *event;

Bool (*predicate)(

Display* /* display */,

XEvent* /* event */,

char* /* arg */

);

char *arg;

{

SOFTWARE.

************************************************************************/

#define LARGE_COORDINATE 1000000

#define SMALL_COORDINATE -LARGE_COORDINATE

*

*/

static void

{

register EdgeTableEntry *start, *prev;

register ScanLineList *pSLL, *pPrevSLL;

*/

static void

{

register XPoint *top, *bottom;

register XPoint *PrevPt, *CurrPt;

*/

static void

{

register EdgeTableEntry *pPrevAET;

register EdgeTableEntry *tmp;

*

*/

static void

{

register EdgeTableEntry *pWETE;

register int inside = 1;

*/

static int

{

register EdgeTableEntry *pETEchase;

register EdgeTableEntry *pETEinsert;

* Clean up our act.

*/

static void

{

register ScanLineListBlock *tmpSLLBlock;

* stack by the calling procedure.

*

*/

{

register BOX *rects;

register XPoint *pts;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

#include "Xutil.h"

#include <stdio.h>

#if defined(__STDC__) && ((defined(sun) && defined(SVR4)) || defined(WIN32))

#define RConst /**/

};

int

{

do {

*bpt = _reverse_byte[*bpt];

/*ARGSUSED*/

static void

{

long h = height;

}

static void

{

long length = ROUNDUP(srclen, 2);

register long h, n;

}

static void

{

long length = ((srclen + 2) / 3) * 3;

register long h, n;

}

static void

{

long length = ROUNDUP(srclen, 4);

register long h, n;

}

static void

{

long length = ROUNDUP(srclen, 4);

register long h, n;

}

static void

{

register long h, n;

register const unsigned char *rev = _reverse_nibs;

}

static void

{

register long h, n;

register unsigned char c1, c2;

/*ARGSUSED*/

static void

{

register long h, n;

register const unsigned char *rev = _reverse_byte;

}

static void

{

long length = ROUNDUP(srclen, 2);

register long h, n;

}

static void

{

long length = ROUNDUP(srclen, 4);

register long h, n;

}

static void

{

long length = ROUNDUP(srclen, 4);

register long h, n;

*/

#define n NoSwap,

#define s SwapTwoBytes,

#define l SwapFourBytes,

#endif

static void

{

register int j;

long total_xoffset, bytes_per_src, bytes_per_dest, length;

long bytes_per_line, bytes_per_src_plane, bytes_per_dest_plane;

char *src, *dest, *buf;

char *extra = (char *)NULL;

int half_order;

total_xoffset = image->xoffset + req_xoffset;

}

static void

{

long bytes_per_src, bytes_per_dest, length;

unsigned char *src, *dest;

}

static void

{

register xPutImageReq *req;

}

static void

{

int left_pad, BytesPerRow, Available;

}

}

int

XPutImage (dpy, d, gc, image, req_xoffset, req_yoffset, x, y, req_width,

req_height)

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

register Display *dpy,

_Xconst char *name,

int *major_opcode, /* RETURN */

int *first_event, /* RETURN */

int *first_error) /* RETURN */

{

xQueryExtensionReply rep;

register xQueryExtensionReq *req;

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

int

XQueryTextExtents16 (

register Display *dpy,

Font fid,

int *font_ascent,

int *font_descent,

register XCharStruct *overall)

{

register long i;

register unsigned char *ptr;

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

int

XQueryTextExtents (

register Display *dpy,

Font fid,

int *font_ascent,

int *font_descent,

register XCharStruct *overall)

{

register int i;

register char *ptr;

from The Open Group.

*/

#include "Xlibint.h"

#include <X11/Xresource.h>

/* Not cost effective, at least for vanilla MIT clients */

/* #define PERMQ */

#ifdef PERMQ

typedef unsigned char Bits;

#endif

static XrmQuark nextQuark = 1; /* next available quark number */

static unsigned long quarkMask = 0;

return True;

}

register _Xconst char *name, register int len, register Signature sig,

Bool permstring)

{

register XrmQuark q;

register Entry entry;

return NULLQUARK;

}

_Xconst char *name)

{

register char c, *tname;

register Signature sig = 0;

return _XrmInternalStringToQuark(name, tname-(char *)name-1, sig, False);

}

_Xconst char *name)

{

register char c, *tname;

register Signature sig = 0;

from The Open Group.

*/

/*

* Code to read bitmaps from disk files. Interprets

* Table index for the hex values. Initialized once, first time.

* Used for translation value or delimiter significance lookup.

*/

{

/*

* We build the table at run time for several reasons:

* read next hex value in the input stream, return -1 if EOF

*/

static int

{

int ch;

int value = 0;

return value;

}

_Xconst char *filename,

unsigned int *width, /* RETURNED */

unsigned int *height, /* RETURNED */

unsigned char **data, /* RETURNED */

int *x_hot, /* RETURNED */

int *y_hot) /* RETURNED */

{

FILE *fstream; /* handle on file */

unsigned char *bits = NULL; /* working variable */

return (BitmapSuccess);

}

Display *display,

Drawable d,

_Xconst char *filename,

Pixmap *pixmap, /* RETURNED */

int *x_hot, /* RETURNED */

int *y_hot) /* RETURNED */

{

unsigned char *data;

int res;

SOFTWARE.

************************************************************************/

/*

* The functions in this file implement the Region abstraction, similar to one

* used in the X11 sample server. A Region is simply an area, as the name

#define assert(expr)

#endif

/* Create a new empty region */

Region

{

Region temp;

}

int

{

rect->x = r->extents.x1;

rect->y = r->extents.y1;

}

int

{

REGION region;

*-----------------------------------------------------------------------

*/

static void

{

register BoxPtr pBox,

pBoxEnd,

assert(pExtents->x1 < pExtents->x2);

}

int

{

register int i;

register XRectangle *xr, *pr;

}

int

{

Xfree( (char *) r->rects );

Xfree( (char *) r );

*/

int

{

register int nbox;

register BOX *pbox;

#define ZCopyRegion(a,b) XUnionRegion(a,a,b)

static void

{

register unsigned shift = 1;

#undef ZCopyRegion

int

{

Region s, t;

int grow;

***********************************************************/

static BOX

{

while ((numRects--) && (rects->y2 <= y))

rects++;

*/

/* static void*/

static int

{

register short x1;

register short x2;

}

int

{

/* check for trivial reject */

if ( (!(reg1->numRects)) || (!(reg2->numRects)) ||

newReg->numRects = 0;

else

miRegionOp (newReg, reg1, reg2,

/*

* Can't alter newReg's extents before we call miRegionOp because

}

static void

{

if (dstrgn != rgn) /* don't want to copy to itself */

*/

static void

{

register Region tempReg;

register BOX *rects;

*/

static int

{

/* if unioning with itself or no rects to union with */

*/

static int

{

register BOX *tempRects;

*/

/* static int*/

static int

{

register BoxPtr pPrevBox; /* Current box in previous band */

register BoxPtr pCurBox; /* Current box in current band */

*/

/* static void*/

static void

* lapping bands */

* overlapping bands in region

* 1 */

* overlapping bands in region

* 2 */

{

top = max(r1->y1,ybot);

bot = min(r1->y2,r2->y1);

{

(* nonOverlap1Func) (newReg, r1, r1BandEnd, top, bot);

}

top = max(r2->y1,ybot);

bot = min(r2->y2,r1->y1);

{

(* nonOverlap2Func) (newReg, r2, r2BandEnd, top, bot);

}

curBand = newReg->numRects;

if (r1 != r1End)

{

{

do

{

} while (r1 != r1End);

}

}

{

do

{

*/

/* static void*/

static int

{

register BoxPtr pNextRect;

/* static void*/

static int

{

register BoxPtr pNextRect;

}

int

{

/* checks all the simple cases */

return 1;

}

newReg->extents.x1 = min(reg1->extents.x1, reg2->extents.x1);

newReg->extents.y1 = min(reg1->extents.y1, reg2->extents.y1);

*/

/* static void*/

static int

{

register BoxPtr pNextRect;

*/

/* static void*/

static int

{

register BoxPtr pNextRect;

register int x1;

*/

int

{

/* check for trivial reject */

if ( (!(regM->numRects)) || (!(regS->numRects)) ||

return 1;

}

/*

* Can't alter newReg's extents before we call miRegionOp because

}

int

{

Region tra, trb;

* as a parameter

*/

int

{

if( r->numRects == 0 ) return TRUE;

else return FALSE;

* Check to see if two regions are equal

*/

int

{

int i;

}

int

{

int i;

}

int

{

register BoxPtr pbox;

register BoxPtr pboxEnd;

from The Open Group.

*/

#include "Xlibint.h"

#include "Xlcint.h"

static void

{

register XFilterEventList fl;

* Register a filter with the filter machinery by event mask.

*/

void

Bool (*filter)(

Display*, Window, XEvent*, XPointer

{

XFilterEventRec *rec;

* Register a filter with the filter machinery by type code.

*/

void

Bool (*filter)(

Display*, Window, XEvent*, XPointer

{

XFilterEventRec *rec;

}

void

Bool (*filter)(

Display*, Window, XEvent*, XPointer

{

register XFilterEventList *prev, fl;

in this Software without prior written authorization from The Open Group.

*/

#define NEED_EVENTS

#include "Xlibint.h"

{

register xSendEventReq *req;

xEvent ev;

Status status;

LockDisplay (dpy);

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

/* can only call when display is locked. */

{

register xSetClipRectanglesReq *req;

register long len;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

int

XSetDashes (

register Display *dpy,

GC gc,

int dash_offset,

_Xconst char *list,

int n)

{

register xSetDashesReq *req;

SOFTWARE.

******************************************************************/

#include <X11/Xlibint.h>

#include <X11/Xutil.h>

*/

int

XSetStandardProperties (

Display *dpy,

Window w, /* window to decorate */

char **argv, /* command to be used to restart application */

int argc, /* count of arguments */

XSizeHints *hints) /* size hints for window in its normal state */

{

XWMHints phints;

phints.flags = 0;

from The Open Group.

*/

#include "Xlibint.h"

#include "Xlcint.h"

#include <X11/Xlocale.h>

#include <X11/Xos.h>

#define MAXLOCALE 64 /* buffer size of locale name */

/* alternative setlocale() for when the OS does not provide one */

char *

_Xsetlocale(

int category,

_Xconst char *name

)

{

static char *xsl_name;

char *old_name;

name = getenv("LANG");

if (name && strlen(name) >= MAXLOCALE)

name = NULL;

name = "C";

old_name = xsl_name;

xsl_name = (char *)name;

*/

char *

{

#if defined(hpux) || defined(CSRG_BASED) || defined(sun) || defined(SVR4) || defined(sgi) || defined(__osf__) || defined(AIXV3) || defined(ultrix) || defined(WIN32) || defined(__UNIXOS2__) || defined(linux)

# ifdef hpux

in this Software without prior written authorization from The Open Group.

*/

#define NEED_REPLIES

#include "Xlibint.h"

/* returns either DeviceMappingSuccess or DeviceMappingBusy */

register Display *dpy,

_Xconst unsigned char *map,

int nmaps)

{

register xSetPointerMappingReq *req;

xSetPointerMappingReply rep;

in this Software without prior written authorization from The Open Group.

*/

#include <X11/Xlibint.h>

#include <X11/Xatom.h>

}

int

XStoreBuffer (

register Display *dpy,

_Xconst char *bytes,

int nbytes,

register int buffer)

{

if ((buffer < 0) || (buffer > 7)) return 0;

return XChangeProperty(dpy, RootWindow(dpy, 0), n_to_atom[buffer],

}

int

XStoreBytes (

register Display *dpy,

_Xconst char *bytes,

int nbytes)

{

return XStoreBuffer (dpy, bytes, nbytes, 0);

}

in this Software without prior written authorization from The Open Group.

*/

#include <stdio.h>

#include "Xlibint.h"

#include "Xcmsint.h"

int

XStoreNamedColor(

register Display *dpy,

Colormap cmap,

_Xconst char *name, /* STRING8 */

unsigned long pixel, /* CARD32 */

int flags) /* DoRed, DoGreen, DoBlue */

{

unsigned int nbytes;

register xStoreNamedColorReq *req;

in this Software without prior written authorization from The Open Group.

*/

#include <X11/Xlibint.h>

#include <X11/Xatom.h>

int

XStoreName (

register Display *dpy,

Window w,

_Xconst char *name)

{

return XChangeProperty(dpy, w, XA_WM_NAME, XA_STRING,

8, PropModeReplace, (unsigned char *)name,

}

int

XSetIconName (

register Display *dpy,

Window w,

_Xconst char *icon_name)

{

return XChangeProperty(dpy, w, XA_WM_ICON_NAME, XA_STRING,

8, PropModeReplace, (unsigned char *)icon_name,

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

#include <X11/Xresource.h>

#include <X11/keysymdef.h>

#define NEEDKTABLE

#include "ks_tables.h"

#ifndef KEYSYMDB

#define KEYSYMDB "/usr/lib/X11/XKeysymDB"

static XrmQuark Qkeysym[2];

XrmDatabase

{

if (!initialized)

{

return keysymdb;

}

{

register int i, n;

int h;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

{

XSync(dpy,0);

return 0;

}

{

if (onoff)

func = _XSyncFunction;

return (temp);

}

int (*XSetAfterFunction(

Display *dpy,

int (*func)(

Display*

)

{

LockDisplay(dpy);

if (dpy->flags & XlibDisplayPrivSync) {

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

int

XDrawString(

register Display *dpy,

Drawable d,

int y,

_Xconst char *string,

int length)

{

int Datalength = 0;

register xPolyText8Req *req;

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

int

XDrawString16(

register Display *dpy,

Drawable d,

int y,

_Xconst XChar2b *string,

int length)

{

int Datalength = 0;

register xPolyText16Req *req;

from The Open Group.

*/

/*

* Copyright 1995 by FUJITSU LIMITED

* This is source code modified by FUJITSU LIMITED under the Joint

* what is done in XTextExtents16.

*/

int

XTextExtents (

XFontStruct *fs,

_Xconst char *string,

int *font_ascent, /* RETURN font information */

int *font_descent, /* RETURN font information */

register XCharStruct *overall) /* RETURN character information */

{

int i; /* iterator */

Bool singlerow = (fs->max_byte1 == 0); /* optimization */

* XTextWidth - compute the width of a string of eightbit bytes. This is a

* subset of XTextExtents.

*/

XFontStruct *fs,

_Xconst char *string,

int count)

{

int i; /* iterator */

Bool singlerow = (fs->max_byte1 == 0); /* optimization */

/*

* _XTextHeight - compute the height of a string of eightbit bytes.

*/

XFontStruct *fs,

_Xconst char *string,

int count)

{

int i; /* iterator */

Bool singlerow = (fs->max_byte1 == 0); /* optimization */

from The Open Group.

*/

/*

* Copyright 1995 by FUJITSU LIMITED

* This is source code modified by FUJITSU LIMITED under the Joint

* XChar2bs.

*/

int

XTextExtents16 (

XFontStruct *fs,

_Xconst XChar2b *string,

int *font_ascent, /* RETURN font information */

int *font_descent, /* RETURN font information */

register XCharStruct *overall) /* RETURN character information */

{

int i; /* iterator */

Bool singlerow = (fs->max_byte1 == 0); /* optimization */

* XTextWidth16 - compute the width of sequence of XChar2bs. This is a

* subset of XTextExtents16.

*/

XFontStruct *fs,

_Xconst XChar2b *string,

int count)

{

int i; /* iterator */

Bool singlerow = (fs->max_byte1 == 0); /* optimization */

/*

* _XTextHeight16 - compute the height of sequence of XChar2bs.

*/

XFontStruct *fs,

_Xconst XChar2b *string,

int count)

{

int i; /* iterator */

Bool singlerow = (fs->max_byte1 == 0); /* optimization */

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

#include "Xutil.h"

/*

* This routine given a user supplied positional argument and a default

* be considered "negative".

*/

Display *dpy, /* user's display connection */

int screen, /* screen on which to do computation */

_Xconst char *user_geom, /* user provided geometry spec */

int *width_return, /* size of window */

int *height_return, /* size of window */

int *gravity_return) /* gravity of window */

{

int ux, uy; /* returned values from parse */

unsigned int uwidth, uheight; /* returned values from parse */

}

{

switch (mask & (XNegative|YNegative)) {

case 0:

in this Software without prior written authorization from The Open Group.

*/

#include "Xlibint.h"

{

unsigned long values[32];

register unsigned long *value = values;

from The Open Group.

*/

#include "Xlibint.h"

#include <X11/Xos.h>

#define ERR_RETURN 0

{

register int x, c, b;

register char *ptr;

#define BYTES_PER_OUTPUT_LINE 12

Display *display,

_Xconst char *filename,

Pixmap bitmap,

unsigned int height,

int x_hot,

int y_hot)

{

char *data, *ptr;

int size, byte;

#ifndef _XINTCONN_H_

#define _XINTCONN_H_ 1

/* ConnDis.c */

extern int _XDisconnectDisplay(XtransConnInfo trans_conn);

extern Bool _XSendClientPrefix(Display *dpy, xConnClientPrefix *client,

char *auth_proto, char *auth_string,

from The Open Group.

*/

/*

* XlibInt.c - Internal support routines for the C subroutine

/* these pointers get initialized by XInitThreads */

LockInfoPtr _Xglobal_lock = NULL;

#define XThread_Self() ((*_Xthread_self_fn)())

char buf[BUFSIZE];

} _XAlignedBuffer;

#define SEQLIMIT (65535 - (BUFSIZE / SIZEOF(xReq)) - 10)

/*

* until the connection is writable.

*/

static void