vjg@WUCS1.WUSTL.EDU (Victor J. Griswold) (09/23/89)
Mr. Stallman:
In the process of building the MIT X11R3 release on our sun4 system,
we found a set of five files which cause gcc-cc1 to get a fatal signal 6.
Our system configuration is as such: sun4 OS 4.03, gcc 1.35, tm.h ->
config/tm-sparc.h, md -> config/sparc.md. The same X11R3 files compile
correctly with gcc 1.35, sun3, OS 4.03.
The first set of files below are 'gcc -E' outputs of two of the files which
resulted in the signal 6. I apologize about their length; this is X11...
If you desire 'gcc -E' output of the other three, I will be happy to send them,
but, since you appear to be very close to releasing 1.36 which may have fixed
this problem, I felt you might not like a 400K mail message about a problem
which may no longer exist.
The compile commands which were used to generate the errors are also
included. The common option which resulted in the signal 6 is
'-fstrength-reduce'. All the files compile fine when that one option is
removed. Yes, I did test and "signal 6" gcc on the 'gcc -E' output
itself (no -D or -I options on the command line).
Thank you for developing a very useful compiler. I hope this bug
report helps.
Victor Griswold
Washington University Computer Science Dept.
Computer & Communications Research Center
vjg@wucs1.wustl.edu
-----------------------------------------------------------------------------
commands to reproduce problem:
in lib/X:
gcc -fcombine-regs -fstrength-reduce -finline-functions -fpcc-struct-return -Dinline=INLINE -DNOSTDHDRS -c -O -I. -I../../. -I../.././X11 -DTCPCONN -DUNIXCONN XStrKeysym.c
gcc: Program cc1 got fatal signal 6.
*** Error code 1
in lib/Xt:
gcc -fcombine-regs -fstrength-reduce -finline-functions -fpcc-struct-return -Dinline=INLINE -DNOSTDHDRS -c -O -I. -I../.././lib/X -I../../. -I../.././X11 Converters.c
gcc: Program cc1 got fatal signal 6.
*** Error code 1
in lib/Xmu:
gcc -fcombine-regs -fstrength-reduce -finline-functions -fpcc-struct-return -Dinline=INLINE -DNOSTDHDRS -c -O -I. -I../../. -I../.././X11 StrToCurs.c
gcc: Program cc1 got fatal signal 6.
*** Error code 1
in clients/bitmap:
gcc -fcombine-regs -fstrength-reduce -finline-functions -fpcc-struct-return -Dinline=INLINE -DNOSTDHDRS -O -I../../. -sun4 -c bitmap.c
bitmap.c:155: warning: useless keyword or type name in declaration
gcc: Program cc1 got fatal signal 6.
*** Error code 1
in clients/xwininfo:
gcc -fcombine-regs -fstrength-reduce -finline-functions -fpcc-struct-return -Dinline=INLINE -DNOSTDHDRS -O -I../../. -sun4 -c xwininfo.c
gcc: Program cc1 got fatal signal 6.
*** Error code 1
------------------------------------------------------------------------------
gcc -E of XStrKeysim.c:
==============================================================================
# 1 "XStrKeysym.c"
# 1 "Xlibint.h"
# 1 "../.././X11/copyright.h"
# 1 "Xlibint.h"
# 1 "/usr/include/sys/types.h"
# 1 "/usr/include/sys/sysmacros.h"
# 16 "/usr/include/sys/types.h"
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef struct _physadr { int r[1]; } *physadr;
typedef struct label_t {
int val[2];
} label_t;
typedef struct _quad { long val[2]; } quad;
typedef long daddr_t;
typedef char * caddr_t;
typedef u_long ino_t;
typedef long swblk_t;
typedef int size_t;
typedef long time_t;
typedef short dev_t;
typedef long off_t;
typedef u_short uid_t;
typedef u_short gid_t;
typedef long key_t;
typedef long fd_mask;
typedef struct fd_set {
fd_mask fds_bits[(((256 )+(( (sizeof(fd_mask) * 8 ) )-1))/( (sizeof(fd_mask) * 8 ) )) ];
} fd_set;
typedef char * addr_t;
# 107 "/usr/include/sys/types.h"
# 23 "Xlibint.h"
# 1 "Xlib.h"
# 1 "/usr/include/sys/types.h"
# 109 "/usr/include/sys/types.h"
# 34 "Xlib.h"
# 1 "../.././X11/X.h"
typedef unsigned long XID;
typedef XID Window;
typedef XID Drawable;
typedef XID Font;
typedef XID Pixmap;
typedef XID Cursor;
typedef XID Colormap;
typedef XID GContext;
typedef XID KeySym;
typedef unsigned long Mask;
typedef unsigned long Atom;
typedef unsigned long VisualID;
typedef unsigned long Time;
typedef unsigned char KeyCode;
# 311 "../.././X11/X.h"
# 37 "Xlib.h"
typedef struct _XExtData {
int number;
struct _XExtData *next;
int (*free_private)();
char *private_data;
} XExtData;
typedef struct {
int extension;
int major_opcode;
int first_event;
int first_error;
} XExtCodes;
typedef struct _XExten {
struct _XExten *next;
XExtCodes codes;
int (*create_GC)();
int (*copy_GC)();
int (*flush_GC)();
int (*free_GC)();
int (*create_Font)();
int (*free_Font)();
int (*close_display)();
int (*error)();
int (*error_string)();
} _XExtension;
typedef struct {
int function;
unsigned long plane_mask;
unsigned long foreground;
unsigned long background;
int line_width;
int line_style;
int cap_style;
int join_style;
int fill_style;
int fill_rule;
int arc_mode;
Pixmap tile;
Pixmap stipple;
int ts_x_origin;
int ts_y_origin;
Font font;
int subwindow_mode;
int graphics_exposures;
int clip_x_origin;
int clip_y_origin;
Pixmap clip_mask;
int dash_offset;
char dashes;
} XGCValues;
typedef struct _XGC {
XExtData *ext_data;
GContext gid;
int rects;
int dashes;
unsigned long dirty;
XGCValues values;
} *GC;
typedef struct {
XExtData *ext_data;
VisualID visualid;
int class;
unsigned long red_mask, green_mask, blue_mask;
int bits_per_rgb;
int map_entries;
} Visual;
typedef struct {
int depth;
int nvisuals;
Visual *visuals;
} Depth;
typedef struct {
XExtData *ext_data;
struct _XDisplay *display;
Window root;
int width, height;
int mwidth, mheight;
int ndepths;
Depth *depths;
int root_depth;
Visual *root_visual;
GC default_gc;
Colormap cmap;
unsigned long white_pixel;
unsigned long black_pixel;
int max_maps, min_maps;
int backing_store;
int save_unders;
long root_input_mask;
} Screen;
typedef struct {
XExtData *ext_data;
int depth;
int bits_per_pixel;
int scanline_pad;
} ScreenFormat;
typedef struct {
Pixmap background_pixmap;
unsigned long background_pixel;
Pixmap border_pixmap;
unsigned long border_pixel;
int bit_gravity;
int win_gravity;
int backing_store;
unsigned long backing_planes;
unsigned long backing_pixel;
int save_under;
long event_mask;
long do_not_propagate_mask;
int override_redirect;
Colormap colormap;
Cursor cursor;
} XSetWindowAttributes;
typedef struct {
int x, y;
int width, height;
int border_width;
int depth;
Visual *visual;
Window root;
int class;
int bit_gravity;
int win_gravity;
int backing_store;
unsigned long backing_planes;
unsigned long backing_pixel;
int save_under;
Colormap colormap;
int map_installed;
int map_state;
long all_event_masks;
long your_event_mask;
long do_not_propagate_mask;
int override_redirect;
Screen *screen;
} XWindowAttributes;
typedef struct {
int family;
int length;
char *address;
} XHostAddress;
typedef struct _XImage {
int width, height;
int xoffset;
int format;
char *data;
int byte_order;
int bitmap_unit;
int bitmap_bit_order;
int bitmap_pad;
int depth;
int bytes_per_line;
int bits_per_pixel;
unsigned long red_mask;
unsigned long green_mask;
unsigned long blue_mask;
char *obdata;
struct funcs {
struct _XImage *(*create_image)();
int (*destroy_image)();
unsigned long (*get_pixel)();
int (*put_pixel)();
struct _XImage *(*sub_image)();
int (*add_pixel)();
} f;
} XImage;
typedef struct {
int x, y;
int width, height;
int border_width;
Window sibling;
int stack_mode;
} XWindowChanges;
typedef struct {
unsigned long pixel;
unsigned short red, green, blue;
char flags;
char pad;
} XColor;
typedef struct {
short x1, y1, x2, y2;
} XSegment;
typedef struct {
short x, y;
} XPoint;
typedef struct {
short x, y;
unsigned short width, height;
} XRectangle;
typedef struct {
short x, y;
unsigned short width, height;
short angle1, angle2;
} XArc;
typedef struct {
int key_click_percent;
int bell_percent;
int bell_pitch;
int bell_duration;
int led;
int led_mode;
int key;
int auto_repeat_mode;
} XKeyboardControl;
typedef struct {
int key_click_percent;
int bell_percent;
unsigned int bell_pitch, bell_duration;
unsigned long led_mask;
int global_auto_repeat;
char auto_repeats[32];
} XKeyboardState;
typedef struct {
Time time;
short x, y;
} XTimeCoord;
typedef struct {
int max_keypermod;
KeyCode *modifiermap;
} XModifierKeymap;
XModifierKeymap *XNewModifiermap(),
*XGetModifierMapping(),
*XDeleteModifiermapEntry(),
*XInsertModifiermapEntry();
typedef struct _XDisplay {
XExtData *ext_data;
struct _XDisplay *next;
int fd;
int lock;
int proto_major_version;
int proto_minor_version;
char *vendor;
long resource_base;
long resource_mask;
long resource_id;
int resource_shift;
XID (*resource_alloc)();
int byte_order;
int bitmap_unit;
int bitmap_pad;
int bitmap_bit_order;
int nformats;
ScreenFormat *pixmap_format;
int vnumber;
int release;
struct _XSQEvent *head, *tail;
int qlen;
unsigned long last_request_read;
unsigned long request;
char *last_req;
char *buffer;
char *bufptr;
char *bufmax;
unsigned max_request_size;
struct _XrmHashBucketRec *db;
int (*synchandler)();
char *display_name;
int default_screen;
int nscreens;
Screen *screens;
unsigned long motion_buffer;
Window current;
int min_keycode;
int max_keycode;
KeySym *keysyms;
XModifierKeymap *modifiermap;
int keysyms_per_keycode;
char *xdefaults;
char *scratch_buffer;
unsigned long scratch_length;
int ext_number;
_XExtension *ext_procs;
int (*event_vec[128])();
int (*wire_vec[128])();
KeySym lock_meaning;
struct XKeytrans *key_bindings;
Font cursor_font;
} Display;
# 925 "Xlib.h"
typedef struct {
short lbearing;
short rbearing;
short width;
short ascent;
short descent;
unsigned short attributes;
} XCharStruct;
typedef struct {
Atom name;
unsigned long card32;
} XFontProp;
typedef struct {
XExtData *ext_data;
Font fid;
unsigned direction;
unsigned min_char_or_byte2;
unsigned max_char_or_byte2;
unsigned min_byte1;
unsigned max_byte1;
int all_chars_exist;
unsigned default_char;
int n_properties;
XFontProp *properties;
XCharStruct min_bounds;
XCharStruct max_bounds;
XCharStruct *per_char;
int ascent;
int descent;
} XFontStruct;
typedef struct {
char *chars;
int nchars;
int delta;
Font font;
} XTextItem;
typedef struct {
unsigned char byte1;
unsigned char byte2;
} XChar2b;
typedef struct {
XChar2b *chars;
int nchars;
int delta;
Font font;
} XTextItem16;
XFontStruct *XLoadQueryFont(), *XQueryFont();
XTimeCoord *XGetMotionEvents();
typedef union { Display *display;
GC gc;
Visual *visual;
Screen *screen;
ScreenFormat *pixmap_format;
XFontStruct *font; } XEDataObject;
Display *XOpenDisplay();
char *XFetchBytes();
char *XFetchBuffer();
char *XGetAtomName();
char *XGetDefault();
char *XDisplayName();
char *XKeysymToString();
int (*XSynchronize())();
int (*XSetAfterFunction())();
Atom XInternAtom();
Colormap XCopyColormapAndFree(), XCreateColormap();
Cursor XCreatePixmapCursor(), XCreateGlyphCursor(), XCreateFontCursor();
Font XLoadFont();
GC XCreateGC();
GContext XGContextFromGC();
Pixmap XCreatePixmap();
Pixmap XCreateBitmapFromData(), XCreatePixmapFromBitmapData();
Window XCreateSimpleWindow(), XGetSelectionOwner();
Window XCreateWindow();
Colormap *XListInstalledColormaps();
char **XListFonts(), **XListFontsWithInfo(), **XGetFontPath();
char **XListExtensions();
Atom *XListProperties();
XImage *XCreateImage(), *XGetImage(), *XGetSubImage();
XHostAddress *XListHosts();
KeySym XKeycodeToKeysym(), XLookupKeysym(), *XGetKeyboardMapping();
KeySym XStringToKeysym();
long XMaxRequestSize();
char *XResourceManagerString();
unsigned long XDisplayMotionBufferSize();
VisualID XVisualIDFromVisual();
XExtCodes *XInitExtension();
int (*XESetCreateGC())(), (*XESetCopyGC())(), (*XESetFlushGC())(),
(*XESetFreeGC())(), (*XESetCreateFont())(), (*XESetFreeFont())(),
(*XESetCloseDisplay())(),
(*XESetError())(), (*XESetErrorString())();
int (*XESetWireToEvent())();
int (*XESetEventToWire())();
XExtCodes *XAddExtension();
XExtData *XFindOnExtensionList();
XExtData **XEHeadOfExtensionList();
Window XRootWindow(), XDefaultRootWindow(), XRootWindowOfScreen();
Visual *XDefaultVisual(), *XDefaultVisualOfScreen();
GC XDefaultGC(), XDefaultGCOfScreen();
unsigned long XBlackPixel(), XWhitePixel(), XAllPlanes();
unsigned long XBlackPixelOfScreen(), XWhitePixelOfScreen();
unsigned long XNextRequest(), XLastKnownRequestProcessed();
char *XServerVendor(), *XDisplayString();
Colormap XDefaultColormap(), XDefaultColormapOfScreen();
Display *XDisplayOfScreen();
Screen *XScreenOfDisplay(), *XDefaultScreenOfDisplay();
long XEventMaskOfScreen();
# 33 "Xlibint.h"
# 1 "../.././X11/Xproto.h"
# 1 "../.././X11/Xmd.h"
typedef long INT32;
typedef short INT16;
typedef char INT8;
typedef unsigned long CARD32;
typedef unsigned short CARD16;
typedef unsigned char CARD8;
typedef unsigned long BITS32;
typedef unsigned short BITS16;
typedef unsigned char BYTE;
typedef unsigned char BOOL;
# 53 "../.././X11/Xproto.h"
# 1 "../.././X11/Xprotostr.h"
# 1 "../.././X11/Xmd.h"
# 139 "../.././X11/Xmd.h"
# 28 "../.././X11/Xprotostr.h"
typedef struct _xSegment {
INT16 x1 , y1 , x2 , y2 ;
} xSegment;
typedef struct _xPoint {
INT16 x , y ;
} xPoint;
typedef struct _xRectangle {
INT16 x , y ;
CARD16 width , height ;
} xRectangle;
typedef struct _xArc {
INT16 x , y ;
CARD16 width , height ;
INT16 angle1 , angle2 ;
} xArc;
# 54 "../.././X11/Xproto.h"
typedef CARD16 KeyButMask;
typedef struct {
CARD8 byteOrder;
BYTE pad;
CARD16 majorVersion , minorVersion ;
CARD16 nbytesAuthProto ;
CARD16 nbytesAuthString ;
CARD16 pad2;
} xConnClientPrefix;
typedef struct {
BOOL success;
BYTE lengthReason;
CARD16 majorVersion ,
minorVersion ;
CARD16 length ;
} xConnSetupPrefix;
typedef struct {
CARD32 release ;
CARD32 ridBase ,
ridMask ;
CARD32 motionBufferSize ;
CARD16 nbytesVendor ;
CARD16 maxRequestSize ;
CARD8 numRoots;
CARD8 numFormats;
CARD8 imageByteOrder;
CARD8 bitmapBitOrder;
CARD8 bitmapScanlineUnit,
bitmapScanlinePad;
CARD8 minKeyCode, maxKeyCode;
CARD32 pad2 ;
} xConnSetup;
typedef struct {
CARD8 depth;
CARD8 bitsPerPixel;
CARD8 scanLinePad;
CARD8 pad1;
CARD32 pad2 ;
} xPixmapFormat;
typedef struct {
CARD8 depth;
CARD8 pad1;
CARD16 nVisuals ;
CARD32 pad2 ;
} xDepth;
typedef struct {
CARD32 visualID ;
CARD8 class;
CARD8 bitsPerRGB;
CARD16 colormapEntries ;
CARD32 redMask , greenMask , blueMask ;
CARD32 pad ;
} xVisualType;
typedef struct {
CARD32 windowId ;
CARD32 defaultColormap ;
CARD32 whitePixel , blackPixel ;
CARD32 currentInputMask ;
CARD16 pixWidth , pixHeight ;
CARD16 mmWidth , mmHeight ;
CARD16 minInstalledMaps , maxInstalledMaps ;
CARD32 rootVisualID ;
CARD8 backingStore;
BOOL saveUnders;
CARD8 rootDepth;
CARD8 nDepths;
} xWindowRoot;
typedef struct {
CARD32 time ;
INT16 x , y ;
} xTimecoord;
typedef struct {
CARD8 family;
BYTE pad;
CARD16 length ;
} xHostEntry;
typedef struct {
INT16 leftSideBearing ,
rightSideBearing ,
characterWidth ,
ascent ,
descent ;
CARD16 attributes ;
} xCharInfo;
typedef struct {
CARD32 name ;
CARD32 value ;
} xFontProp;
typedef struct {
CARD8 len;
INT8 delta;
} xTextElt;
typedef struct {
CARD32 pixel ;
CARD16 red , green , blue ;
CARD8 flags;
CARD8 pad;
} xColorItem;
typedef struct {
CARD16 red , green , blue , pad ;
} xrgb;
typedef CARD8 KEYCODE;
# 937 "../.././X11/Xproto.h"
typedef struct {
BYTE type;
BYTE errorCode;
CARD16 sequenceNumber ;
CARD32 resourceID ;
CARD16 minorCode ;
CARD8 majorCode;
BYTE pad1;
CARD32 pad3 ;
CARD32 pad4 ;
CARD32 pad5 ;
CARD32 pad6 ;
CARD32 pad7 ;
} xError;
# 1196 "../.././X11/Xproto.h"
# 1250 "../.././X11/Xproto.h"
typedef struct {
CARD8 reqType;
CARD8 data;
CARD16 length ;
} xReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 id ;
} xResourceReq;
typedef struct {
CARD8 reqType;
CARD8 depth;
CARD16 length ;
CARD32 wid , parent ;
INT16 x , y ;
CARD16 width , height , borderWidth ;
CARD16 class ;
CARD32 visual ;
CARD32 mask ;
} xCreateWindowReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window ;
CARD32 valueMask ;
} xChangeWindowAttributesReq;
typedef struct {
CARD8 reqType;
BYTE mode;
CARD16 length ;
CARD32 window ;
} xChangeSaveSetReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window , parent ;
INT16 x , y ;
} xReparentWindowReq;
typedef struct {
CARD8 reqType;
CARD8 pad;
CARD16 length ;
CARD32 window ;
CARD16 mask ;
CARD16 pad2 ;
} xConfigureWindowReq;
typedef struct {
CARD8 reqType;
CARD8 direction;
CARD16 length ;
CARD32 window ;
} xCirculateWindowReq;
typedef struct {
CARD8 reqType;
BOOL onlyIfExists;
CARD16 length ;
CARD16 nbytes ;
CARD16 pad ;
} xInternAtomReq;
typedef struct {
CARD8 reqType;
CARD8 mode;
CARD16 length ;
CARD32 window ;
CARD32 property , type ;
CARD8 format;
BYTE pad[3];
CARD32 nUnits ;
} xChangePropertyReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window ;
CARD32 property ;
} xDeletePropertyReq;
typedef struct {
CARD8 reqType;
BOOL delete;
CARD16 length ;
CARD32 window ;
CARD32 property , type ;
CARD32 longOffset ;
CARD32 longLength ;
} xGetPropertyReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window ;
CARD32 selection ;
CARD32 time ;
} xSetSelectionOwnerReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 requestor ;
CARD32 selection , target , property ;
CARD32 time ;
} xConvertSelectionReq;
# 1404 "../.././X11/Xproto.h"
typedef struct {
CARD8 reqType;
BOOL ownerEvents;
CARD16 length ;
CARD32 grabWindow ;
CARD16 eventMask ;
BYTE pointerMode, keyboardMode;
CARD32 confineTo ;
CARD32 cursor ;
CARD32 time ;
} xGrabPointerReq;
typedef struct {
CARD8 reqType;
BOOL ownerEvents;
CARD16 length ;
CARD32 grabWindow ;
CARD16 eventMask ;
BYTE pointerMode, keyboardMode;
CARD32 confineTo ;
CARD32 cursor ;
CARD8 button;
BYTE pad;
CARD16 modifiers ;
} xGrabButtonReq;
typedef struct {
CARD8 reqType;
CARD8 button;
CARD16 length ;
CARD32 grabWindow ;
CARD16 modifiers ;
CARD16 pad ;
} xUngrabButtonReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cursor ;
CARD32 time ;
CARD16 eventMask ;
CARD16 pad2 ;
} xChangeActivePointerGrabReq;
typedef struct {
CARD8 reqType;
BOOL ownerEvents;
CARD16 length ;
CARD32 grabWindow ;
CARD32 time ;
BYTE pointerMode, keyboardMode;
CARD16 pad ;
} xGrabKeyboardReq;
typedef struct {
CARD8 reqType;
BOOL ownerEvents;
CARD16 length ;
CARD32 grabWindow ;
CARD16 modifiers ;
CARD8 key;
BYTE pointerMode, keyboardMode;
BYTE pad1, pad2, pad3;
} xGrabKeyReq;
typedef struct {
CARD8 reqType;
CARD8 key;
CARD16 length ;
CARD32 grabWindow ;
CARD16 modifiers ;
CARD16 pad ;
} xUngrabKeyReq;
typedef struct {
CARD8 reqType;
CARD8 mode;
CARD16 length ;
CARD32 time ;
} xAllowEventsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window ;
CARD32 start , stop ;
} xGetMotionEventsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 srcWid , dstWid ;
INT16 srcX , srcY ;
} xTranslateCoordsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 srcWid , dstWid ;
INT16 srcX , srcY ;
CARD16 srcWidth , srcHeight ;
INT16 dstX , dstY ;
} xWarpPointerReq;
typedef struct {
CARD8 reqType;
CARD8 revertTo;
CARD16 length ;
CARD32 focus ;
CARD32 time ;
} xSetInputFocusReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 fid ;
CARD16 nbytes ;
BYTE pad1, pad2;
} xOpenFontReq;
typedef struct {
CARD8 reqType;
BOOL oddLength;
CARD16 length ;
CARD32 fid ;
} xQueryTextExtentsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD16 maxNames ;
CARD16 nbytes ;
} xListFontsReq;
typedef xListFontsReq xListFontsWithInfoReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD16 nFonts ;
BYTE pad1, pad2;
} xSetFontPathReq;
typedef struct {
CARD8 reqType;
CARD8 depth;
CARD16 length ;
CARD32 pid ;
CARD32 drawable ;
CARD16 width , height ;
} xCreatePixmapReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 gc ;
CARD32 drawable ;
CARD32 mask ;
} xCreateGCReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 gc ;
CARD32 mask ;
} xChangeGCReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 srcGC , dstGC ;
CARD32 mask ;
} xCopyGCReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 gc ;
CARD16 dashOffset ;
CARD16 nDashes ;
} xSetDashesReq;
typedef struct {
CARD8 reqType;
BYTE ordering;
CARD16 length ;
CARD32 gc ;
INT16 xOrigin , yOrigin ;
} xSetClipRectanglesReq;
typedef struct {
CARD8 reqType;
BOOL exposures;
CARD16 length ;
CARD32 window ;
INT16 x , y ;
CARD16 width , height ;
} xClearAreaReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 srcDrawable , dstDrawable ;
CARD32 gc ;
INT16 srcX , srcY , dstX , dstY ;
CARD16 width , height ;
} xCopyAreaReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 srcDrawable , dstDrawable ;
CARD32 gc ;
INT16 srcX , srcY , dstX , dstY ;
CARD16 width , height ;
CARD32 bitPlane ;
} xCopyPlaneReq;
typedef struct {
CARD8 reqType;
BYTE coordMode;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
} xPolyPointReq;
typedef xPolyPointReq xPolyLineReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
} xPolySegmentReq;
typedef xPolySegmentReq xPolyArcReq;
typedef xPolySegmentReq xPolyRectangleReq;
typedef xPolySegmentReq xPolyFillRectangleReq;
typedef xPolySegmentReq xPolyFillArcReq;
typedef struct _FillPolyReq {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
BYTE shape;
BYTE coordMode;
CARD16 pad1 ;
} xFillPolyReq;
typedef struct _PutImageReq {
CARD8 reqType;
CARD8 format;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
CARD16 width , height ;
INT16 dstX , dstY ;
CARD8 leftPad;
CARD8 depth;
CARD16 pad ;
} xPutImageReq;
typedef struct {
CARD8 reqType;
CARD8 format;
CARD16 length ;
CARD32 drawable ;
INT16 x , y ;
CARD16 width , height ;
CARD32 planeMask ;
} xGetImageReq;
typedef struct {
CARD8 reqType;
CARD8 pad;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
INT16 x , y ;
} xPolyTextReq;
typedef xPolyTextReq xPolyText8Req;
typedef xPolyTextReq xPolyText16Req;
typedef struct {
CARD8 reqType;
BYTE nChars;
CARD16 length ;
CARD32 drawable ;
CARD32 gc ;
INT16 x , y ;
} xImageTextReq;
typedef xImageTextReq xImageText8Req;
typedef xImageTextReq xImageText16Req;
typedef struct {
CARD8 reqType;
BYTE alloc;
CARD16 length ;
CARD32 mid ;
CARD32 window ;
CARD32 visual ;
} xCreateColormapReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 mid ;
CARD32 srcCmap ;
} xCopyColormapAndFreeReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
CARD16 red , green , blue ;
CARD16 pad2 ;
} xAllocColorReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
CARD16 nbytes ;
BYTE pad1, pad2;
} xAllocNamedColorReq;
typedef struct {
CARD8 reqType;
BOOL contiguous;
CARD16 length ;
CARD32 cmap ;
CARD16 colors , planes ;
} xAllocColorCellsReq;
typedef struct {
CARD8 reqType;
BOOL contiguous;
CARD16 length ;
CARD32 cmap ;
CARD16 colors , red , green , blue ;
} xAllocColorPlanesReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
CARD32 planeMask ;
} xFreeColorsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
} xStoreColorsReq;
typedef struct {
CARD8 reqType;
CARD8 flags;
CARD16 length ;
CARD32 cmap ;
CARD32 pixel ;
CARD16 nbytes ;
BYTE pad1, pad2;
} xStoreNamedColorReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
} xQueryColorsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cmap ;
CARD16 nbytes ;
BYTE pad1, pad2;
} xLookupColorReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cid ;
CARD32 source , mask ;
CARD16 foreRed , foreGreen , foreBlue ;
CARD16 backRed , backGreen , backBlue ;
CARD16 x , y ;
} xCreateCursorReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cid ;
CARD32 source , mask ;
CARD16 sourceChar , maskChar ;
CARD16 foreRed , foreGreen , foreBlue ;
CARD16 backRed , backGreen , backBlue ;
} xCreateGlyphCursorReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 cursor ;
CARD16 foreRed , foreGreen , foreBlue ;
CARD16 backRed , backGreen , backBlue ;
} xRecolorCursorReq;
typedef struct {
CARD8 reqType;
CARD8 class;
CARD16 length ;
CARD32 drawable ;
CARD16 width , height ;
} xQueryBestSizeReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD16 nbytes ;
BYTE pad1, pad2;
} xQueryExtensionReq;
typedef struct {
CARD8 reqType;
CARD8 numKeyPerModifier;
CARD16 length ;
} xSetModifierMappingReq;
typedef struct {
CARD8 reqType;
CARD8 nElts;
CARD16 length ;
} xSetPointerMappingReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD8 firstKeyCode;
CARD8 count;
CARD16 pad1 ;
} xGetKeyboardMappingReq;
typedef struct {
CARD8 reqType;
CARD8 keyCodes;
CARD16 length ;
CARD8 firstKeyCode;
CARD8 keySymsPerKeyCode;
CARD16 pad1 ;
} xChangeKeyboardMappingReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 mask ;
} xChangeKeyboardControlReq;
typedef struct {
CARD8 reqType;
INT8 percent;
CARD16 length ;
} xBellReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
INT16 accelNum , accelDenum ;
INT16 threshold ;
BOOL doAccel, doThresh;
} xChangePointerControlReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
INT16 timeout , interval ;
BYTE preferBlank, allowExpose;
CARD16 pad2 ;
} xSetScreenSaverReq;
typedef struct {
CARD8 reqType;
BYTE mode;
CARD16 length ;
CARD8 hostFamily;
BYTE pad;
CARD16 hostLength ;
} xChangeHostsReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
} xListHostsReq;
typedef struct {
CARD8 reqType;
BYTE mode;
CARD16 length ;
} xChangeModeReq;
typedef xChangeModeReq xSetAccessControlReq;
typedef xChangeModeReq xSetCloseDownModeReq;
typedef xChangeModeReq xForceScreenSaverReq;
typedef struct {
CARD8 reqType;
BYTE pad;
CARD16 length ;
CARD32 window ;
CARD16 nAtoms ;
INT16 nPositions ;
} xRotatePropertiesReq;
# 34 "Xlibint.h"
# 1 "Xlibos.h"
# 1 "/usr/include/netinet/in.h"
struct in_addr {
union {
struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
struct { u_short s_w1,s_w2; } S_un_w;
u_long S_addr;
} S_un;
};
struct sockaddr_in {
short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};
# 5 "Xlibos.h"
# 1 "/usr/include/sys/ioctl.h"
# 1 "/usrc/acs/conman/lib/gcc-include/sys/ttychars.h"
struct ttychars {
char tc_erase;
char tc_kill;
char tc_intrc;
char tc_quitc;
char tc_startc;
char tc_stopc;
char tc_eofc;
char tc_brkc;
char tc_suspc;
char tc_dsuspc;
char tc_rprntc;
char tc_flushc;
char tc_werasc;
char tc_lnextc;
};
# 15 "/usr/include/sys/ioctl.h"
# 1 "/usr/include/sys/ttydev.h"
# 46 "/usr/include/sys/ttydev.h"
# 16 "/usr/include/sys/ioctl.h"
# 1 "/usrc/acs/conman/lib/gcc-include/sys/ttold.h"
struct tchars {
char t_intrc;
char t_quitc;
char t_startc;
char t_stopc;
char t_eofc;
char t_brkc;
};
struct ltchars {
char t_suspc;
char t_dsuspc;
char t_rprntc;
char t_flushc;
char t_werasc;
char t_lnextc;
};
struct sgttyb {
char sg_ispeed;
char sg_ospeed;
char sg_erase;
char sg_kill;
short sg_flags;
};
# 1 "/usrc/acs/conman/lib/gcc-include/sys/ioccom.h"
# 39 "/usrc/acs/conman/lib/gcc-include/sys/ttold.h"
# 1 "/usrc/acs/conman/lib/gcc-include/sys/ttycom.h"
struct winsize {
unsigned short ws_row;
unsigned short ws_col;
unsigned short ws_xpixel;
unsigned short ws_ypixel;
};
struct ttysize {
int ts_lines;
int ts_cols;
};
# 167 "/usrc/acs/conman/lib/gcc-include/sys/ttold.h"
# 17 "/usr/include/sys/ioctl.h"
# 1 "/usrc/acs/conman/lib/gcc-include/sys/filio.h"
# 1 "/usrc/acs/conman/lib/gcc-include/sys/ioccom.h"
# 32 "/usrc/acs/conman/lib/gcc-include/sys/ioccom.h"
# 15 "/usrc/acs/conman/lib/gcc-include/sys/filio.h"
# 67 "/usr/include/sys/ioctl.h"
# 1 "/usrc/acs/conman/lib/gcc-include/sys/sockio.h"
# 1 "/usrc/acs/conman/lib/gcc-include/sys/ioccom.h"
# 32 "/usrc/acs/conman/lib/gcc-include/sys/ioccom.h"
# 15 "/usrc/acs/conman/lib/gcc-include/sys/sockio.h"
# 69 "/usr/include/sys/ioctl.h"
# 6 "Xlibos.h"
# 1 "/usr/include/netdb.h"
struct hostent {
char *h_name;
char **h_aliases;
int h_addrtype;
int h_length;
char **h_addr_list;
};
struct netent {
char *n_name;
char **n_aliases;
int n_addrtype;
unsigned long n_net;
};
struct servent {
char *s_name;
char **s_aliases;
int s_port;
char *s_proto;
};
struct protoent {
char *p_name;
char **p_aliases;
int p_proto;
};
struct rpcent {
char *r_name;
char **r_aliases;
int r_number;
};
struct hostent *gethostbyname(), *gethostbyaddr(), *gethostent();
struct netent *getnetbyname(), *getnetbyaddr(), *getnetent();
struct servent *getservbyname(), *getservbyport(), *getservent();
struct protoent *getprotobyname(), *getprotobynumber(), *getprotoent();
struct rpcent *getrpcbyname(), *getrpcbynumber(), *getrpcent();
extern int h_errno;
# 7 "Xlibos.h"
# 1 "/usr/include/sys/uio.h"
struct iovec {
caddr_t iov_base;
int iov_len;
};
struct uio {
struct iovec *uio_iov;
int uio_iovcnt;
off_t uio_offset;
short uio_segflg;
short uio_fmode;
int uio_resid;
};
enum uio_rw { UIO_READ, UIO_WRITE };
# 9 "Xlibos.h"
# 1 "/usr/include/sys/param.h"
# 1 "/usr/include/machine/param.h"
# 101 "/usr/include/machine/param.h"
# 9 "/usr/include/sys/param.h"
# 56 "/usr/include/sys/param.h"
# 1 "/usr/include/sys/signal.h"
# 1 "/usr/include/vm/faultcode.h"
typedef int faultcode_t;
# 15 "/usr/include/sys/signal.h"
# 46 "/usr/include/sys/signal.h"
# 77 "/usr/include/sys/signal.h"
# 93 "/usr/include/sys/signal.h"
void (*signal())();
void (*sigset())();
int sighold();
int sigrelse();
int sigignore();
struct sigvec {
void (*sv_handler)();
int sv_mask;
int sv_flags;
};
struct sigstack {
char *ss_sp;
int ss_onstack;
};
struct sigcontext {
int sc_onstack;
int sc_mask;
int sc_sp;
int sc_pc;
int sc_npc;
int sc_psr;
int sc_g1;
int sc_o0;
int sc_wbcnt;
char *sc_spbuf[31 ];
int sc_wbuf[31 ][16];
};
# 61 "/usr/include/sys/param.h"
# 1 "/usr/include/sys/types.h"
# 109 "/usr/include/sys/types.h"
# 83 "/usr/include/sys/param.h"
# 11 "Xlibos.h"
# 67 "Xlibos.h"
# 82 "Xlibos.h"
char *malloc(), *realloc(), *calloc(), *alloca();
char *strncpy(), *strncat();
void exit();
void bcopy();
void perror();
void free();
extern char *index();
# 35 "Xlibint.h"
# 1 "/usr/include/errno.h"
# 1 "/usr/include/sys/errno.h"
# 7 "/usr/include/errno.h"
extern int errno;
# 36 "Xlibint.h"
extern int errno;
extern void bcopy();
extern (*_XIOErrorFunction)();
extern (*_XErrorFunction)();
extern char *_XAllocScratch();
extern Visual *_XVIDtoVisual();
# 82 "Xlibint.h"
# 106 "Xlibint.h"
# 117 "Xlibint.h"
# 132 "Xlibint.h"
# 142 "Xlibint.h"
# 162 "Xlibint.h"
# 173 "Xlibint.h"
# 189 "Xlibint.h"
# 199 "Xlibint.h"
# 287 "Xlibint.h"
# 4 "XStrKeysym.c"
static struct ks_info {
char *ks_name;
KeySym ks_val;
} keySymInfo[] = {
# 1 "ks_names.h"
{ "BackSpace", 0xFF08 },
{ "Tab", 0xFF09 },
{ "Linefeed", 0xFF0A },
{ "Clear", 0xFF0B },
{ "Return", 0xFF0D },
{ "Pause", 0xFF13 },
{ "Escape", 0xFF1B },
{ "Delete", 0xFFFF },
{ "Multi_key", 0xFF20 },
{ "Kanji", 0xFF21 },
{ "Home", 0xFF50 },
{ "Left", 0xFF51 },
{ "Up", 0xFF52 },
{ "Right", 0xFF53 },
{ "Down", 0xFF54 },
{ "Prior", 0xFF55 },
{ "Next", 0xFF56 },
{ "End", 0xFF57 },
{ "Begin", 0xFF58 },
{ "Select", 0xFF60 },
{ "Print", 0xFF61 },
{ "Execute", 0xFF62 },
{ "Insert", 0xFF63 },
{ "Undo", 0xFF65 },
{ "Redo", 0xFF66 },
{ "Menu", 0xFF67 },
{ "Find", 0xFF68 },
{ "Cancel", 0xFF69 },
{ "Help", 0xFF6A },
{ "Break", 0xFF6B },
{ "Mode_switch", 0xFF7E },
{ "script_switch", 0xFF7E },
{ "Num_Lock", 0xFF7F },
{ "KP_Space", 0xFF80 },
{ "KP_Tab", 0xFF89 },
{ "KP_Enter", 0xFF8D },
{ "KP_F1", 0xFF91 },
{ "KP_F2", 0xFF92 },
{ "KP_F3", 0xFF93 },
{ "KP_F4", 0xFF94 },
{ "KP_Equal", 0xFFBD },
{ "KP_Multiply", 0xFFAA },
{ "KP_Add", 0xFFAB },
{ "KP_Separator", 0xFFAC },
{ "KP_Subtract", 0xFFAD },
{ "KP_Decimal", 0xFFAE },
{ "KP_Divide", 0xFFAF },
{ "KP_0", 0xFFB0 },
{ "KP_1", 0xFFB1 },
{ "KP_2", 0xFFB2 },
{ "KP_3", 0xFFB3 },
{ "KP_4", 0xFFB4 },
{ "KP_5", 0xFFB5 },
{ "KP_6", 0xFFB6 },
{ "KP_7", 0xFFB7 },
{ "KP_8", 0xFFB8 },
{ "KP_9", 0xFFB9 },
{ "F1", 0xFFBE },
{ "F2", 0xFFBF },
{ "F3", 0xFFC0 },
{ "F4", 0xFFC1 },
{ "F5", 0xFFC2 },
{ "F6", 0xFFC3 },
{ "F7", 0xFFC4 },
{ "F8", 0xFFC5 },
{ "F9", 0xFFC6 },
{ "F10", 0xFFC7 },
{ "F11", 0xFFC8 },
{ "L1", 0xFFC8 },
{ "F12", 0xFFC9 },
{ "L2", 0xFFC9 },
{ "F13", 0xFFCA },
{ "L3", 0xFFCA },
{ "F14", 0xFFCB },
{ "L4", 0xFFCB },
{ "F15", 0xFFCC },
{ "L5", 0xFFCC },
{ "F16", 0xFFCD },
{ "L6", 0xFFCD },
{ "F17", 0xFFCE },
{ "L7", 0xFFCE },
{ "F18", 0xFFCF },
{ "L8", 0xFFCF },
{ "F19", 0xFFD0 },
{ "L9", 0xFFD0 },
{ "F20", 0xFFD1 },
{ "L10", 0xFFD1 },
{ "F21", 0xFFD2 },
{ "R1", 0xFFD2 },
{ "F22", 0xFFD3 },
{ "R2", 0xFFD3 },
{ "F23", 0xFFD4 },
{ "R3", 0xFFD4 },
{ "F24", 0xFFD5 },
{ "R4", 0xFFD5 },
{ "F25", 0xFFD6 },
{ "R5", 0xFFD6 },
{ "F26", 0xFFD7 },
{ "R6", 0xFFD7 },
{ "F27", 0xFFD8 },
{ "R7", 0xFFD8 },
{ "F28", 0xFFD9 },
{ "R8", 0xFFD9 },
{ "F29", 0xFFDA },
{ "R9", 0xFFDA },
{ "F30", 0xFFDB },
{ "R10", 0xFFDB },
{ "F31", 0xFFDC },
{ "R11", 0xFFDC },
{ "F32", 0xFFDD },
{ "R12", 0xFFDD },
{ "R13", 0xFFDE },
{ "F33", 0xFFDE },
{ "F34", 0xFFDF },
{ "R14", 0xFFDF },
{ "F35", 0xFFE0 },
{ "R15", 0xFFE0 },
{ "Shift_L", 0xFFE1 },
{ "Shift_R", 0xFFE2 },
{ "Control_L", 0xFFE3 },
{ "Control_R", 0xFFE4 },
{ "Caps_Lock", 0xFFE5 },
{ "Shift_Lock", 0xFFE6 },
{ "Meta_L", 0xFFE7 },
{ "Meta_R", 0xFFE8 },
{ "Alt_L", 0xFFE9 },
{ "Alt_R", 0xFFEA },
{ "Super_L", 0xFFEB },
{ "Super_R", 0xFFEC },
{ "Hyper_L", 0xFFED },
{ "Hyper_R", 0xFFEE },
{ "space", 0x020 },
{ "exclam", 0x021 },
{ "quotedbl", 0x022 },
{ "numbersign", 0x023 },
{ "dollar", 0x024 },
{ "percent", 0x025 },
{ "ampersand", 0x026 },
{ "quoteright", 0x027 },
{ "parenleft", 0x028 },
{ "parenright", 0x029 },
{ "asterisk", 0x02a },
{ "plus", 0x02b },
{ "comma", 0x02c },
{ "minus", 0x02d },
{ "period", 0x02e },
{ "slash", 0x02f },
{ "0", 0x030 },
{ "1", 0x031 },
{ "2", 0x032 },
{ "3", 0x033 },
{ "4", 0x034 },
{ "5", 0x035 },
{ "6", 0x036 },
{ "7", 0x037 },
{ "8", 0x038 },
{ "9", 0x039 },
{ "colon", 0x03a },
{ "semicolon", 0x03b },
{ "less", 0x03c },
{ "equal", 0x03d },
{ "greater", 0x03e },
{ "question", 0x03f },
{ "at", 0x040 },
{ "A", 0x041 },
{ "B", 0x042 },
{ "C", 0x043 },
{ "D", 0x044 },
{ "E", 0x045 },
{ "F", 0x046 },
{ "G", 0x047 },
{ "H", 0x048 },
{ "I", 0x049 },
{ "J", 0x04a },
{ "K", 0x04b },
{ "L", 0x04c },
{ "M", 0x04d },
{ "N", 0x04e },
{ "O", 0x04f },
{ "P", 0x050 },
{ "Q", 0x051 },
{ "R", 0x052 },
{ "S", 0x053 },
{ "T", 0x054 },
{ "U", 0x055 },
{ "V", 0x056 },
{ "W", 0x057 },
{ "X", 0x058 },
{ "Y", 0x059 },
{ "Z", 0x05a },
{ "bracketleft", 0x05b },
{ "backslash", 0x05c },
{ "bracketright", 0x05d },
{ "asciicircum", 0x05e },
{ "underscore", 0x05f },
{ "quoteleft", 0x060 },
{ "a", 0x061 },
{ "b", 0x062 },
{ "c", 0x063 },
{ "d", 0x064 },
{ "e", 0x065 },
{ "f", 0x066 },
{ "g", 0x067 },
{ "h", 0x068 },
{ "i", 0x069 },
{ "j", 0x06a },
{ "k", 0x06b },
{ "l", 0x06c },
{ "m", 0x06d },
{ "n", 0x06e },
{ "o", 0x06f },
{ "p", 0x070 },
{ "q", 0x071 },
{ "r", 0x072 },
{ "s", 0x073 },
{ "t", 0x074 },
{ "u", 0x075 },
{ "v", 0x076 },
{ "w", 0x077 },
{ "x", 0x078 },
{ "y", 0x079 },
{ "z", 0x07a },
{ "braceleft", 0x07b },
{ "bar", 0x07c },
{ "braceright", 0x07d },
{ "asciitilde", 0x07e },
{ "nobreakspace", 0x0a0 },
{ "exclamdown", 0x0a1 },
{ "cent", 0x0a2 },
{ "sterling", 0x0a3 },
{ "currency", 0x0a4 },
{ "yen", 0x0a5 },
{ "brokenbar", 0x0a6 },
{ "section", 0x0a7 },
{ "diaeresis", 0x0a8 },
{ "copyright", 0x0a9 },
{ "ordfeminine", 0x0aa },
{ "guillemotleft", 0x0ab },
{ "notsign", 0x0ac },
{ "hyphen", 0x0ad },
{ "registered", 0x0ae },
{ "macron", 0x0af },
{ "degree", 0x0b0 },
{ "plusminus", 0x0b1 },
{ "twosuperior", 0x0b2 },
{ "threesuperior", 0x0b3 },
{ "acute", 0x0b4 },
{ "mu", 0x0b5 },
{ "paragraph", 0x0b6 },
{ "periodcentered", 0x0b7 },
{ "cedilla", 0x0b8 },
{ "onesuperior", 0x0b9 },
{ "masculine", 0x0ba },
{ "guillemotright", 0x0bb },
{ "onequarter", 0x0bc },
{ "onehalf", 0x0bd },
{ "threequarters", 0x0be },
{ "questiondown", 0x0bf },
{ "Agrave", 0x0c0 },
{ "Aacute", 0x0c1 },
{ "Acircumflex", 0x0c2 },
{ "Atilde", 0x0c3 },
{ "Adiaeresis", 0x0c4 },
{ "Aring", 0x0c5 },
{ "AE", 0x0c6 },
{ "Ccedilla", 0x0c7 },
{ "Egrave", 0x0c8 },
{ "Eacute", 0x0c9 },
{ "Ecircumflex", 0x0ca },
{ "Ediaeresis", 0x0cb },
{ "Igrave", 0x0cc },
{ "Iacute", 0x0cd },
{ "Icircumflex", 0x0ce },
{ "Idiaeresis", 0x0cf },
{ "Eth", 0x0d0 },
{ "Ntilde", 0x0d1 },
{ "Ograve", 0x0d2 },
{ "Oacute", 0x0d3 },
{ "Ocircumflex", 0x0d4 },
{ "Otilde", 0x0d5 },
{ "Odiaeresis", 0x0d6 },
{ "multiply", 0x0d7 },
{ "Ooblique", 0x0d8 },
{ "Ugrave", 0x0d9 },
{ "Uacute", 0x0da },
{ "Ucircumflex", 0x0db },
{ "Udiaeresis", 0x0dc },
{ "Yacute", 0x0dd },
{ "Thorn", 0x0de },
{ "ssharp", 0x0df },
{ "agrave", 0x0e0 },
{ "aacute", 0x0e1 },
{ "acircumflex", 0x0e2 },
{ "atilde", 0x0e3 },
{ "adiaeresis", 0x0e4 },
{ "aring", 0x0e5 },
{ "ae", 0x0e6 },
{ "ccedilla", 0x0e7 },
{ "egrave", 0x0e8 },
{ "eacute", 0x0e9 },
{ "ecircumflex", 0x0ea },
{ "ediaeresis", 0x0eb },
{ "igrave", 0x0ec },
{ "iacute", 0x0ed },
{ "icircumflex", 0x0ee },
{ "idiaeresis", 0x0ef },
{ "eth", 0x0f0 },
{ "ntilde", 0x0f1 },
{ "ograve", 0x0f2 },
{ "oacute", 0x0f3 },
{ "ocircumflex", 0x0f4 },
{ "otilde", 0x0f5 },
{ "odiaeresis", 0x0f6 },
{ "division", 0x0f7 },
{ "oslash", 0x0f8 },
{ "ugrave", 0x0f9 },
{ "uacute", 0x0fa },
{ "ucircumflex", 0x0fb },
{ "udiaeresis", 0x0fc },
{ "yacute", 0x0fd },
{ "thorn", 0x0fe },
{ "ydiaeresis", 0x0ff },
{ "Aogonek", 0x1a1 },
{ "breve", 0x1a2 },
{ "Lstroke", 0x1a3 },
{ "Lcaron", 0x1a5 },
{ "Sacute", 0x1a6 },
{ "Scaron", 0x1a9 },
{ "Scedilla", 0x1aa },
{ "Tcaron", 0x1ab },
{ "Zacute", 0x1ac },
{ "Zcaron", 0x1ae },
{ "Zabovedot", 0x1af },
{ "aogonek", 0x1b1 },
{ "ogonek", 0x1b2 },
{ "lstroke", 0x1b3 },
{ "lcaron", 0x1b5 },
{ "sacute", 0x1b6 },
{ "caron", 0x1b7 },
{ "scaron", 0x1b9 },
{ "scedilla", 0x1ba },
{ "tcaron", 0x1bb },
{ "zacute", 0x1bc },
{ "doubleacute", 0x1bd },
{ "zcaron", 0x1be },
{ "zabovedot", 0x1bf },
{ "Racute", 0x1c0 },
{ "Abreve", 0x1c3 },
{ "Cacute", 0x1c6 },
{ "Ccaron", 0x1c8 },
{ "Eogonek", 0x1ca },
{ "Ecaron", 0x1cc },
{ "Dcaron", 0x1cf },
{ "Nacute", 0x1d1 },
{ "Ncaron", 0x1d2 },
{ "Odoubleacute", 0x1d5 },
{ "Rcaron", 0x1d8 },
{ "Uring", 0x1d9 },
{ "Udoubleacute", 0x1db },
{ "Tcedilla", 0x1de },
{ "racute", 0x1e0 },
{ "abreve", 0x1e3 },
{ "cacute", 0x1e6 },
{ "ccaron", 0x1e8 },
{ "eogonek", 0x1ea },
{ "ecaron", 0x1ec },
{ "dcaron", 0x1ef },
{ "nacute", 0x1f1 },
{ "ncaron", 0x1f2 },
{ "odoubleacute", 0x1f5 },
{ "udoubleacute", 0x1fb },
{ "rcaron", 0x1f8 },
{ "uring", 0x1f9 },
{ "tcedilla", 0x1fe },
{ "abovedot", 0x1ff },
{ "Hstroke", 0x2a1 },
{ "Hcircumflex", 0x2a6 },
{ "Iabovedot", 0x2a9 },
{ "Gbreve", 0x2ab },
{ "Jcircumflex", 0x2ac },
{ "hstroke", 0x2b1 },
{ "hcircumflex", 0x2b6 },
{ "idotless", 0x2b9 },
{ "gbreve", 0x2bb },
{ "jcircumflex", 0x2bc },
{ "Cabovedot", 0x2c5 },
{ "Ccircumflex", 0x2c6 },
{ "Gabovedot", 0x2d5 },
{ "Gcircumflex", 0x2d8 },
{ "Ubreve", 0x2dd },
{ "Scircumflex", 0x2de },
{ "cabovedot", 0x2e5 },
{ "ccircumflex", 0x2e6 },
{ "gabovedot", 0x2f5 },
{ "gcircumflex", 0x2f8 },
{ "ubreve", 0x2fd },
{ "scircumflex", 0x2fe },
{ "kappa", 0x3a2 },
{ "Rcedilla", 0x3a3 },
{ "Itilde", 0x3a5 },
{ "Lcedilla", 0x3a6 },
{ "Emacron", 0x3aa },
{ "Gcedilla", 0x3ab },
{ "Tslash", 0x3ac },
{ "rcedilla", 0x3b3 },
{ "itilde", 0x3b5 },
{ "lcedilla", 0x3b6 },
{ "emacron", 0x3ba },
{ "gacute", 0x3bb },
{ "tslash", 0x3bc },
{ "ENG", 0x3bd },
{ "eng", 0x3bf },
{ "Amacron", 0x3c0 },
{ "Iogonek", 0x3c7 },
{ "Eabovedot", 0x3cc },
{ "Imacron", 0x3cf },
{ "Ncedilla", 0x3d1 },
{ "Omacron", 0x3d2 },
{ "Kcedilla", 0x3d3 },
{ "Uogonek", 0x3d9 },
{ "Utilde", 0x3dd },
{ "Umacron", 0x3de },
{ "amacron", 0x3e0 },
{ "iogonek", 0x3e7 },
{ "eabovedot", 0x3ec },
{ "imacron", 0x3ef },
{ "ncedilla", 0x3f1 },
{ "omacron", 0x3f2 },
{ "kcedilla", 0x3f3 },
{ "uogonek", 0x3f9 },
{ "utilde", 0x3fd },
{ "umacron", 0x3fe },
{ "overline", 0x47e },
{ "kana_fullstop", 0x4a1 },
{ "kana_openingbracket", 0x4a2 },
{ "kana_closingbracket", 0x4a3 },
{ "kana_comma", 0x4a4 },
{ "kana_middledot", 0x4a5 },
{ "kana_WO", 0x4a6 },
{ "kana_a", 0x4a7 },
{ "kana_i", 0x4a8 },
{ "kana_u", 0x4a9 },
{ "kana_e", 0x4aa },
{ "kana_o", 0x4ab },
{ "kana_ya", 0x4ac },
{ "kana_yu", 0x4ad },
{ "kana_yo", 0x4ae },
{ "kana_tu", 0x4af },
{ "prolongedsound", 0x4b0 },
{ "kana_A", 0x4b1 },
{ "kana_I", 0x4b2 },
{ "kana_U", 0x4b3 },
{ "kana_E", 0x4b4 },
{ "kana_O", 0x4b5 },
{ "kana_KA", 0x4b6 },
{ "kana_KI", 0x4b7 },
{ "kana_KU", 0x4b8 },
{ "kana_KE", 0x4b9 },
{ "kana_KO", 0x4ba },
{ "kana_SA", 0x4bb },
{ "kana_SHI", 0x4bc },
{ "kana_SU", 0x4bd },
{ "kana_SE", 0x4be },
{ "kana_SO", 0x4bf },
{ "kana_TA", 0x4c0 },
{ "kana_TI", 0x4c1 },
{ "kana_TU", 0x4c2 },
{ "kana_TE", 0x4c3 },
{ "kana_TO", 0x4c4 },
{ "kana_NA", 0x4c5 },
{ "kana_NI", 0x4c6 },
{ "kana_NU", 0x4c7 },
{ "kana_NE", 0x4c8 },
{ "kana_NO", 0x4c9 },
{ "kana_HA", 0x4ca },
{ "kana_HI", 0x4cb },
{ "kana_HU", 0x4cc },
{ "kana_HE", 0x4cd },
{ "kana_HO", 0x4ce },
{ "kana_MA", 0x4cf },
{ "kana_MI", 0x4d0 },
{ "kana_MU", 0x4d1 },
{ "kana_ME", 0x4d2 },
{ "kana_MO", 0x4d3 },
{ "kana_YA", 0x4d4 },
{ "kana_YU", 0x4d5 },
{ "kana_YO", 0x4d6 },
{ "kana_RA", 0x4d7 },
{ "kana_RI", 0x4d8 },
{ "kana_RU", 0x4d9 },
{ "kana_RE", 0x4da },
{ "kana_RO", 0x4db },
{ "kana_WA", 0x4dc },
{ "kana_N", 0x4dd },
{ "voicedsound", 0x4de },
{ "semivoicedsound", 0x4df },
{ "kana_switch", 0xFF7E },
{ "Arabic_comma", 0x5ac },
{ "Arabic_semicolon", 0x5bb },
{ "Arabic_question_mark", 0x5bf },
{ "Arabic_hamza", 0x5c1 },
{ "Arabic_maddaonalef", 0x5c2 },
{ "Arabic_hamzaonalef", 0x5c3 },
{ "Arabic_hamzaonwaw", 0x5c4 },
{ "Arabic_hamzaunderalef", 0x5c5 },
{ "Arabic_hamzaonyeh", 0x5c6 },
{ "Arabic_alef", 0x5c7 },
{ "Arabic_beh", 0x5c8 },
{ "Arabic_tehmarbuta", 0x5c9 },
{ "Arabic_teh", 0x5ca },
{ "Arabic_theh", 0x5cb },
{ "Arabic_jeem", 0x5cc },
{ "Arabic_hah", 0x5cd },
{ "Arabic_khah", 0x5ce },
{ "Arabic_dal", 0x5cf },
{ "Arabic_thal", 0x5d0 },
{ "Arabic_ra", 0x5d1 },
{ "Arabic_zain", 0x5d2 },
{ "Arabic_seen", 0x5d3 },
{ "Arabic_sheen", 0x5d4 },
{ "Arabic_sad", 0x5d5 },
{ "Arabic_dad", 0x5d6 },
{ "Arabic_tah", 0x5d7 },
{ "Arabic_zah", 0x5d8 },
{ "Arabic_ain", 0x5d9 },
{ "Arabic_ghain", 0x5da },
{ "Arabic_tatweel", 0x5e0 },
{ "Arabic_feh", 0x5e1 },
{ "Arabic_qaf", 0x5e2 },
{ "Arabic_kaf", 0x5e3 },
{ "Arabic_lam", 0x5e4 },
{ "Arabic_meem", 0x5e5 },
{ "Arabic_noon", 0x5e6 },
{ "Arabic_heh", 0x5e7 },
{ "Arabic_waw", 0x5e8 },
{ "Arabic_alefmaksura", 0x5e9 },
{ "Arabic_yeh", 0x5ea },
{ "Arabic_fathatan", 0x5eb },
{ "Arabic_dammatan", 0x5ec },
{ "Arabic_kasratan", 0x5ed },
{ "Arabic_fatha", 0x5ee },
{ "Arabic_damma", 0x5ef },
{ "Arabic_kasra", 0x5f0 },
{ "Arabic_shadda", 0x5f1 },
{ "Arabic_sukun", 0x5f2 },
{ "Arabic_switch", 0xFF7E },
{ "Serbian_dje", 0x6a1 },
{ "Macedonia_gje", 0x6a2 },
{ "Cyrillic_io", 0x6a3 },
{ "Ukranian_je", 0x6a4 },
{ "Macedonia_dse", 0x6a5 },
{ "Ukranian_i", 0x6a6 },
{ "Ukranian_yi", 0x6a7 },
{ "Serbian_je", 0x6a8 },
{ "Serbian_lje", 0x6a9 },
{ "Serbian_nje", 0x6aa },
{ "Serbian_tshe", 0x6ab },
{ "Macedonia_kje", 0x6ac },
{ "Byelorussian_shortu", 0x6ae },
{ "Serbian_dze", 0x6af },
{ "numerosign", 0x6b0 },
{ "Serbian_DJE", 0x6b1 },
{ "Macedonia_GJE", 0x6b2 },
{ "Cyrillic_IO", 0x6b3 },
{ "Ukranian_JE", 0x6b4 },
{ "Macedonia_DSE", 0x6b5 },
{ "Ukranian_I", 0x6b6 },
{ "Ukranian_YI", 0x6b7 },
{ "Serbian_JE", 0x6b8 },
{ "Serbian_LJE", 0x6b9 },
{ "Serbian_NJE", 0x6ba },
{ "Serbian_TSHE", 0x6bb },
{ "Macedonia_KJE", 0x6bc },
{ "Byelorussian_SHORTU", 0x6be },
{ "Serbian_DZE", 0x6bf },
{ "Cyrillic_yu", 0x6c0 },
{ "Cyrillic_a", 0x6c1 },
{ "Cyrillic_be", 0x6c2 },
{ "Cyrillic_tse", 0x6c3 },
{ "Cyrillic_de", 0x6c4 },
{ "Cyrillic_ie", 0x6c5 },
{ "Cyrillic_ef", 0x6c6 },
{ "Cyrillic_ghe", 0x6c7 },
{ "Cyrillic_ha", 0x6c8 },
{ "Cyrillic_i", 0x6c9 },
{ "Cyrillic_shorti", 0x6ca },
{ "Cyrillic_ka", 0x6cb },
{ "Cyrillic_el", 0x6cc },
{ "Cyrillic_em", 0x6cd },
{ "Cyrillic_en", 0x6ce },
{ "Cyrillic_o", 0x6cf },
{ "Cyrillic_pe", 0x6d0 },
{ "Cyrillic_ya", 0x6d1 },
{ "Cyrillic_er", 0x6d2 },
{ "Cyrillic_es", 0x6d3 },
{ "Cyrillic_te", 0x6d4 },
{ "Cyrillic_u", 0x6d5 },
{ "Cyrillic_zhe", 0x6d6 },
{ "Cyrillic_ve", 0x6d7 },
{ "Cyrillic_softsign", 0x6d8 },
{ "Cyrillic_yeru", 0x6d9 },
{ "Cyrillic_ze", 0x6da },
{ "Cyrillic_sha", 0x6db },
{ "Cyrillic_e", 0x6dc },
{ "Cyrillic_shcha", 0x6dd },
{ "Cyrillic_che", 0x6de },
{ "Cyrillic_hardsign", 0x6df },
{ "Cyrillic_YU", 0x6e0 },
{ "Cyrillic_A", 0x6e1 },
{ "Cyrillic_BE", 0x6e2 },
{ "Cyrillic_TSE", 0x6e3 },
{ "Cyrillic_DE", 0x6e4 },
{ "Cyrillic_IE", 0x6e5 },
{ "Cyrillic_EF", 0x6e6 },
{ "Cyrillic_GHE", 0x6e7 },
{ "Cyrillic_HA", 0x6e8 },
{ "Cyrillic_I", 0x6e9 },
{ "Cyrillic_SHORTI", 0x6ea },
{ "Cyrillic_KA", 0x6eb },
{ "Cyrillic_EL", 0x6ec },
{ "Cyrillic_EM", 0x6ed },
{ "Cyrillic_EN", 0x6ee },
{ "Cyrillic_O", 0x6ef },
{ "Cyrillic_PE", 0x6f0 },
{ "Cyrillic_YA", 0x6f1 },
{ "Cyrillic_ER", 0x6f2 },
{ "Cyrillic_ES", 0x6f3 },
{ "Cyrillic_TE", 0x6f4 },
{ "Cyrillic_U", 0x6f5 },
{ "Cyrillic_ZHE", 0x6f6 },
{ "Cyrillic_VE", 0x6f7 },
{ "Cyrillic_SOFTSIGN", 0x6f8 },
{ "Cyrillic_YERU", 0x6f9 },
{ "Cyrillic_ZE", 0x6fa },
{ "Cyrillic_SHA", 0x6fb },
{ "Cyrillic_E", 0x6fc },
{ "Cyrillic_SHCHA", 0x6fd },
{ "Cyrillic_CHE", 0x6fe },
{ "Cyrillic_HARDSIGN", 0x6ff },
{ "Greek_ALPHAaccent", 0x7a1 },
{ "Greek_EPSILONaccent", 0x7a2 },
{ "Greek_ETAaccent", 0x7a3 },
{ "Greek_IOTAaccent", 0x7a4 },
{ "Greek_IOTAdiaeresis", 0x7a5 },
{ "Greek_IOTAaccentdiaeresis", 0x7a6 },
{ "Greek_OMICRONaccent", 0x7a7 },
{ "Greek_UPSILONaccent", 0x7a8 },
{ "Greek_UPSILONdieresis", 0x7a9 },
{ "Greek_UPSILONaccentdieresis", 0x7aa },
{ "Greek_OMEGAaccent", 0x7ab },
{ "Greek_alphaaccent", 0x7b1 },
{ "Greek_epsilonaccent", 0x7b2 },
{ "Greek_etaaccent", 0x7b3 },
{ "Greek_iotaaccent", 0x7b4 },
{ "Greek_iotadieresis", 0x7b5 },
{ "Greek_iotaaccentdieresis", 0x7b6 },
{ "Greek_omicronaccent", 0x7b7 },
{ "Greek_upsilonaccent", 0x7b8 },
{ "Greek_upsilondieresis", 0x7b9 },
{ "Greek_upsilonaccentdieresis", 0x7ba },
{ "Greek_omegaaccent", 0x7bb },
{ "Greek_ALPHA", 0x7c1 },
{ "Greek_BETA", 0x7c2 },
{ "Greek_GAMMA", 0x7c3 },
{ "Greek_DELTA", 0x7c4 },
{ "Greek_EPSILON", 0x7c5 },
{ "Greek_ZETA", 0x7c6 },
{ "Greek_ETA", 0x7c7 },
{ "Greek_THETA", 0x7c8 },
{ "Greek_IOTA", 0x7c9 },
{ "Greek_KAPPA", 0x7ca },
{ "Greek_LAMBDA", 0x7cb },
{ "Greek_MU", 0x7cc },
{ "Greek_NU", 0x7cd },
{ "Greek_XI", 0x7ce },
{ "Greek_OMICRON", 0x7cf },
{ "Greek_PI", 0x7d0 },
{ "Greek_RHO", 0x7d1 },
{ "Greek_SIGMA", 0x7d2 },
{ "Greek_TAU", 0x7d4 },
{ "Greek_UPSILON", 0x7d5 },
{ "Greek_PHI", 0x7d6 },
{ "Greek_CHI", 0x7d7 },
{ "Greek_PSI", 0x7d8 },
{ "Greek_OMEGA", 0x7d9 },
{ "Greek_alpha", 0x7e1 },
{ "Greek_beta", 0x7e2 },
{ "Greek_gamma", 0x7e3 },
{ "Greek_delta", 0x7e4 },
{ "Greek_epsilon", 0x7e5 },
{ "Greek_zeta", 0x7e6 },
{ "Greek_eta", 0x7e7 },
{ "Greek_theta", 0x7e8 },
{ "Greek_iota", 0x7e9 },
{ "Greek_kappa", 0x7ea },
{ "Greek_lambda", 0x7eb },
{ "Greek_mu", 0x7ec },
{ "Greek_nu", 0x7ed },
{ "Greek_xi", 0x7ee },
{ "Greek_omicron", 0x7ef },
{ "Greek_pi", 0x7f0 },
{ "Greek_rho", 0x7f1 },
{ "Greek_sigma", 0x7f2 },
{ "Greek_finalsmallsigma", 0x7f3 },
{ "Greek_tau", 0x7f4 },
{ "Greek_upsilon", 0x7f5 },
{ "Greek_phi", 0x7f6 },
{ "Greek_chi", 0x7f7 },
{ "Greek_psi", 0x7f8 },
{ "Greek_omega", 0x7f9 },
{ "Greek_switch", 0xFF7E },
{ "leftradical", 0x8a1 },
{ "topleftradical", 0x8a2 },
{ "horizconnector", 0x8a3 },
{ "topintegral", 0x8a4 },
{ "botintegral", 0x8a5 },
{ "vertconnector", 0x8a6 },
{ "topleftsqbracket", 0x8a7 },
{ "botleftsqbracket", 0x8a8 },
{ "toprightsqbracket", 0x8a9 },
{ "botrightsqbracket", 0x8aa },
{ "topleftparens", 0x8ab },
{ "botleftparens", 0x8ac },
{ "toprightparens", 0x8ad },
{ "botrightparens", 0x8ae },
{ "leftmiddlecurlybrace", 0x8af },
{ "rightmiddlecurlybrace", 0x8b0 },
{ "topleftsummation", 0x8b1 },
{ "botleftsummation", 0x8b2 },
{ "topvertsummationconnector", 0x8b3 },
{ "botvertsummationconnector", 0x8b4 },
{ "toprightsummation", 0x8b5 },
{ "botrightsummation", 0x8b6 },
{ "rightmiddlesummation", 0x8b7 },
{ "lessthanequal", 0x8bc },
{ "notequal", 0x8bd },
{ "greaterthanequal", 0x8be },
{ "integral", 0x8bf },
{ "therefore", 0x8c0 },
{ "variation", 0x8c1 },
{ "infinity", 0x8c2 },
{ "nabla", 0x8c5 },
{ "approximate", 0x8c8 },
{ "similarequal", 0x8c9 },
{ "ifonlyif", 0x8cd },
{ "implies", 0x8ce },
{ "identical", 0x8cf },
{ "radical", 0x8d6 },
{ "includedin", 0x8da },
{ "includes", 0x8db },
{ "intersection", 0x8dc },
{ "union", 0x8dd },
{ "logicaland", 0x8de },
{ "logicalor", 0x8df },
{ "partialderivative", 0x8ef },
{ "function", 0x8f6 },
{ "leftarrow", 0x8fb },
{ "uparrow", 0x8fc },
{ "rightarrow", 0x8fd },
{ "downarrow", 0x8fe },
{ "blank", 0x9df },
{ "soliddiamond", 0x9e0 },
{ "checkerboard", 0x9e1 },
{ "ht", 0x9e2 },
{ "ff", 0x9e3 },
{ "cr", 0x9e4 },
{ "lf", 0x9e5 },
{ "nl", 0x9e8 },
{ "vt", 0x9e9 },
{ "lowrightcorner", 0x9ea },
{ "uprightcorner", 0x9eb },
{ "upleftcorner", 0x9ec },
{ "lowleftcorner", 0x9ed },
{ "crossinglines", 0x9ee },
{ "horizlinescan1", 0x9ef },
{ "horizlinescan3", 0x9f0 },
{ "horizlinescan5", 0x9f1 },
{ "horizlinescan7", 0x9f2 },
{ "horizlinescan9", 0x9f3 },
{ "leftt", 0x9f4 },
{ "rightt", 0x9f5 },
{ "bott", 0x9f6 },
{ "topt", 0x9f7 },
{ "vertbar", 0x9f8 },
{ "emspace", 0xaa1 },
{ "enspace", 0xaa2 },
{ "em3space", 0xaa3 },
{ "em4space", 0xaa4 },
{ "digitspace", 0xaa5 },
{ "punctspace", 0xaa6 },
{ "thinspace", 0xaa7 },
{ "hairspace", 0xaa8 },
{ "emdash", 0xaa9 },
{ "endash", 0xaaa },
{ "signifblank", 0xaac },
{ "ellipsis", 0xaae },
{ "doubbaselinedot", 0xaaf },
{ "onethird", 0xab0 },
{ "twothirds", 0xab1 },
{ "onefifth", 0xab2 },
{ "twofifths", 0xab3 },
{ "threefifths", 0xab4 },
{ "fourfifths", 0xab5 },
{ "onesixth", 0xab6 },
{ "fivesixths", 0xab7 },
{ "careof", 0xab8 },
{ "figdash", 0xabb },
{ "leftanglebracket", 0xabc },
{ "decimalpoint", 0xabd },
{ "rightanglebracket", 0xabe },
{ "marker", 0xabf },
{ "oneeighth", 0xac3 },
{ "threeeighths", 0xac4 },
{ "fiveeighths", 0xac5 },
{ "seveneighths", 0xac6 },
{ "trademark", 0xac9 },
{ "signaturemark", 0xaca },
{ "trademarkincircle", 0xacb },
{ "leftopentriangle", 0xacc },
{ "rightopentriangle", 0xacd },
{ "emopencircle", 0xace },
{ "emopenrectangle", 0xacf },
{ "leftsinglequotemark", 0xad0 },
{ "rightsinglequotemark", 0xad1 },
{ "leftdoublequotemark", 0xad2 },
{ "rightdoublequotemark", 0xad3 },
{ "prescription", 0xad4 },
{ "minutes", 0xad6 },
{ "seconds", 0xad7 },
{ "latincross", 0xad9 },
{ "hexagram", 0xada },
{ "filledrectbullet", 0xadb },
{ "filledlefttribullet", 0xadc },
{ "filledrighttribullet", 0xadd },
{ "emfilledcircle", 0xade },
{ "emfilledrect", 0xadf },
{ "enopencircbullet", 0xae0 },
{ "enopensquarebullet", 0xae1 },
{ "openrectbullet", 0xae2 },
{ "opentribulletup", 0xae3 },
{ "opentribulletdown", 0xae4 },
{ "openstar", 0xae5 },
{ "enfilledcircbullet", 0xae6 },
{ "enfilledsqbullet", 0xae7 },
{ "filledtribulletup", 0xae8 },
{ "filledtribulletdown", 0xae9 },
{ "leftpointer", 0xaea },
{ "rightpointer", 0xaeb },
{ "club", 0xaec },
{ "diamond", 0xaed },
{ "heart", 0xaee },
{ "maltesecross", 0xaf0 },
{ "dagger", 0xaf1 },
{ "doubledagger", 0xaf2 },
{ "checkmark", 0xaf3 },
{ "ballotcross", 0xaf4 },
{ "musicalsharp", 0xaf5 },
{ "musicalflat", 0xaf6 },
{ "malesymbol", 0xaf7 },
{ "femalesymbol", 0xaf8 },
{ "telephone", 0xaf9 },
{ "telephonerecorder", 0xafa },
{ "phonographcopyright", 0xafb },
{ "caret", 0xafc },
{ "singlelowquotemark", 0xafd },
{ "doublelowquotemark", 0xafe },
{ "cursor", 0xaff },
{ "leftcaret", 0xba3 },
{ "rightcaret", 0xba6 },
{ "downcaret", 0xba8 },
{ "upcaret", 0xba9 },
{ "overbar", 0xbc0 },
{ "downtack", 0xbc2 },
{ "upshoe", 0xbc3 },
{ "downstile", 0xbc4 },
{ "underbar", 0xbc6 },
{ "jot", 0xbca },
{ "quad", 0xbcc },
{ "uptack", 0xbce },
{ "circle", 0xbcf },
{ "upstile", 0xbd3 },
{ "downshoe", 0xbd6 },
{ "rightshoe", 0xbd8 },
{ "leftshoe", 0xbda },
{ "lefttack", 0xbdc },
{ "righttack", 0xbfc },
{ "hebrew_aleph", 0xce0 },
{ "hebrew_beth", 0xce1 },
{ "hebrew_gimmel", 0xce2 },
{ "hebrew_daleth", 0xce3 },
{ "hebrew_he", 0xce4 },
{ "hebrew_waw", 0xce5 },
{ "hebrew_zayin", 0xce6 },
{ "hebrew_het", 0xce7 },
{ "hebrew_teth", 0xce8 },
{ "hebrew_yod", 0xce9 },
{ "hebrew_finalkaph", 0xcea },
{ "hebrew_kaph", 0xceb },
{ "hebrew_lamed", 0xcec },
{ "hebrew_finalmem", 0xced },
{ "hebrew_mem", 0xcee },
{ "hebrew_finalnun", 0xcef },
{ "hebrew_nun", 0xcf0 },
{ "hebrew_samekh", 0xcf1 },
{ "hebrew_ayin", 0xcf2 },
{ "hebrew_finalpe", 0xcf3 },
{ "hebrew_pe", 0xcf4 },
{ "hebrew_finalzadi", 0xcf5 },
{ "hebrew_zadi", 0xcf6 },
{ "hebrew_kuf", 0xcf7 },
{ "hebrew_resh", 0xcf8 },
{ "hebrew_shin", 0xcf9 },
{ "hebrew_taf", 0xcfa },
{ "Hebrew_switch", 0xFF7E },
# 9 "XStrKeysym.c"
};
KeySym XStringToKeysym(s)
char *s;
{
int i;
for (i = 0; i < ((sizeof keySymInfo)/(sizeof keySymInfo[0])); i++) {
if (strcmp(s, keySymInfo[i].ks_name) == 0)
return (keySymInfo[i].ks_val);
}
return ( 0L );
}
char *XKeysymToString(ks)
KeySym ks;
{
int i;
for (i = 0; i < ((sizeof keySymInfo)/(sizeof keySymInfo[0])); i++) {
if (ks == keySymInfo[i].ks_val)
return (keySymInfo[i].ks_name);
}
return ((char *) 0 );
}
------------------------------------------------------------------------------
gcc -E of Converters.i:
==============================================================================
# 1 "Converters.c"
static char Xrcsid[] = "$XConsortium: Converters.c,v 1.36 88/10/18 11:22:55 swick Exp $";
# 1 "StringDefs.h"
# 33 "Converters.c"
# 1 "/usr/include/stdio.h"
extern struct _iobuf {
int _cnt;
unsigned char *_ptr;
unsigned char *_base;
int _bufsiz;
short _flag;
char _file;
} _iob[];
extern struct _iobuf *fopen();
extern struct _iobuf *fdopen();
extern struct _iobuf *freopen();
extern struct _iobuf *popen();
extern struct _iobuf *tmpfile();
extern long ftell();
extern char *fgets();
extern char *gets();
extern char *ctermid();
extern char *cuserid();
extern char *tempnam();
extern char *tmpnam();
# 34 "Converters.c"
# 1 "../.././X11/cursorfont.h"
# 35 "Converters.c"
# 1 "IntrinsicI.h"
# 1 "IntrinsicP.h"
# 1 "Intrinsic.h"
# 1 "../.././X11/Xlib.h"
# 1 "/usr/include/sys/types.h"
# 1 "/usr/include/sys/sysmacros.h"
# 16 "/usr/include/sys/types.h"
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef struct _physadr { int r[1]; } *physadr;
typedef struct label_t {
int val[2];
} label_t;
typedef struct _quad { long val[2]; } quad;
typedef long daddr_t;
typedef char * caddr_t;
typedef u_long ino_t;
typedef long swblk_t;
typedef int size_t;
typedef long time_t;
typedef short dev_t;
typedef long off_t;
typedef u_short uid_t;
typedef u_short gid_t;
typedef long key_t;
typedef long fd_mask;
typedef struct fd_set {
fd_mask fds_bits[(((256 )+(( (sizeof(fd_mask) * 8 ) )-1))/( (sizeof(fd_mask) * 8 ) )) ];
} fd_set;
typedef char * addr_t;
# 107 "/usr/include/sys/types.h"
# 34 "../.././X11/Xlib.h"
# 1 "../.././X11/X.h"
typedef unsigned long XID;
typedef XID Window;
typedef XID Drawable;
typedef XID Font;
typedef XID Pixmap;
typedef XID Cursor;
typedef XID Colormap;
typedef XID GContext;
typedef XID KeySym;
typedef unsigned long Mask;
typedef unsigned long Atom;
typedef unsigned long VisualID;
typedef unsigned long Time;
typedef unsigned char KeyCode;
# 311 "../.././X11/X.h"
# 37 "../.././X11/Xlib.h"
typedef struct _XExtData {
int number;
struct _XExtData *next;
int (*free_private)();
char *private_data;
} XExtData;
typedef struct {
int extension;
int major_opcode;
int first_event;
int first_error;
} XExtCodes;
typedef struct _XExten {
struct _XExten *next;
XExtCodes codes;
int (*create_GC)();
int (*copy_GC)();
int (*flush_GC)();
int (*free_GC)();
int (*create_Font)();
int (*free_Font)();
int (*close_display)();
int (*error)();
int (*error_string)();
} _XExtension;
typedef struct {
int function;
unsigned long plane_mask;
unsigned long foreground;
unsigned long background;
int line_width;
int line_style;
int cap_style;
int join_style;
int fill_style;
int fill_rule;
int arc_mode;
Pixmap tile;
Pixmap stipple;
int ts_x_origin;
int ts_y_origin;
Font font;
int subwindow_mode;
int graphics_exposures;
int clip_x_origin;
int clip_y_origin;
Pixmap clip_mask;
int dash_offset;
char dashes;
} XGCValues;
typedef struct _XGC {
XExtData *ext_data;
GContext gid;
int rects;
int dashes;
unsigned long dirty;
XGCValues values;
} *GC;
typedef struct {
XExtData *ext_data;
VisualID visualid;
int class;
unsigned long red_mask, green_mask, blue_mask;
int bits_per_rgb;
int map_entries;
} Visual;
typedef struct {
int depth;
int nvisuals;
Visual *visuals;
} Depth;
typedef struct {
XExtData *ext_data;
struct _XDisplay *display;
Window root;
int width, height;
int mwidth, mheight;
int ndepths;
Depth *depths;
int root_depth;
Visual *root_visual;
GC default_gc;
Colormap cmap;
unsigned long white_pixel;
unsigned long black_pixel;
int max_maps, min_maps;
int backing_store;
int save_unders;
long root_input_mask;
} Screen;
typedef struct {
XExtData *ext_data;
int depth;
int bits_per_pixel;
int scanline_pad;
} ScreenFormat;
typedef struct {
Pixmap background_pixmap;
unsigned long background_pixel;
Pixmap border_pixmap;
unsigned long border_pixel;
int bit_gravity;
int win_gravity;
int backing_store;
unsigned long backing_planes;
unsigned long backing_pixel;
int save_under;
long event_mask;
long do_not_propagate_mask;
int override_redirect;
Colormap colormap;
Cursor cursor;
} XSetWindowAttributes;
typedef struct {
int x, y;
int width, height;
int border_width;
int depth;
Visual *visual;
Window root;
int class;
int bit_gravity;
int win_gravity;
int backing_store;
unsigned long backing_planes;
unsigned long backing_pixel;
int save_under;
Colormap colormap;
int map_installed;
int map_state;
long all_event_masks;
long your_event_mask;
long do_not_propagate_mask;
int override_redirect;
Screen *screen;
} XWindowAttributes;
typedef struct {
int family;
int length;
char *address;
} XHostAddress;
typedef struct _XImage {
int width, height;
int xoffset;
int format;
char *data;
int byte_order;
int bitmap_unit;
int bitmap_bit_order;
int bitmap_pad;
int depth;
int bytes_per_line;
int bits_per_pixel;
unsigned long red_mask;
unsigned long green_mask;
unsigned long blue_mask;
char *obdata;
struct funcs {
struct _XImage *(*create_image)();
int (*destroy_image)();
unsigned long (*get_pixel)();
int (*put_pixel)();
struct _XImage *(*sub_image)();
int (*add_pixel)();
} f;
} XImage;
typedef struct {
int x, y;
int width, height;
int border_width;
Window sibling;
int stack_mode;
} XWindowChanges;
typedef struct {
unsigned long pixel;
unsigned short red, green, blue;
char flags;
char pad;
} XColor;
typedef struct {
short x1, y1, x2, y2;
} XSegment;
typedef struct {
short x, y;
} XPoint;
typedef struct {
short x, y;
unsigned short width, height;
} XRectangle;
typedef struct {
short x, y;
unsigned short width, height;
short angle1, angle2;
} XArc;
typedef struct {
int key_click_percent;
int bell_percent;
int bell_pitch;
int bell_duration;
int led;
int led_mode;
int key;
int auto_repeat_mode;
} XKeyboardControl;
typedef struct {
int key_click_percent;
int bell_percent;
unsigned int bell_pitch, bell_duration;
unsigned long led_mask;
int global_auto_repeat;
char auto_repeats[32];
} XKeyboardState;
typedef struct {
Time time;
short x, y;
} XTimeCoord;
typedef struct {
int max_keypermod;
KeyCode *modifiermap;
} XModifierKeymap;
XModifierKeymap *XNewModifiermap(),
*XGetModifierMapping(),
*XDeleteModifiermapEntry(),
*XInsertModifiermapEntry();
typedef struct _XDisplay {
XExtData *ext_data;
struct _XDisplay *next;
int fd;
int lock;
int proto_major_version;
int proto_minor_version;
char *vendor;
long resource_base;
long resource_mask;
long resource_id;
int resource_shift;
XID (*resource_alloc)();
int byte_order;
int bitmap_unit;
int bitmap_pad;
int bitmap_bit_order;
int nformats;
ScreenFormat *pixmap_format;
int vnumber;
int release;
struct _XSQEvent *head, *tail;
int qlen;
unsigned long last_request_read;
unsigned long request;
char *last_req;
char *buffer;
char *bufptr;
char *bufmax;
unsigned max_request_size;
struct _XrmHashBucketRec *db;
int (*synchandler)();
char *display_name;
int default_screen;
int nscreens;
Screen *screens;
unsigned long motion_buffer;
Window current;
int min_keycode;
int max_keycode;
KeySym *keysyms;
XModifierKeymap *modifiermap;
int keysyms_per_keycode;
char *xdefaults;
char *scratch_buffer;
unsigned long scratch_length;
int ext_number;
_XExtension *ext_procs;
int (*event_vec[128])();
int (*wire_vec[128])();
KeySym lock_meaning;
struct XKeytrans *key_bindings;
Font cursor_font;
} Display;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
Window root;
Window subwindow;
Time time;
int x, y;
int x_root, y_root;
unsigned int state;
unsigned int keycode;
int same_screen;
} XKeyEvent;
typedef XKeyEvent XKeyPressedEvent;
typedef XKeyEvent XKeyReleasedEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
Window root;
Window subwindow;
Time time;
int x, y;
int x_root, y_root;
unsigned int state;
unsigned int button;
int same_screen;
} XButtonEvent;
typedef XButtonEvent XButtonPressedEvent;
typedef XButtonEvent XButtonReleasedEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
Window root;
Window subwindow;
Time time;
int x, y;
int x_root, y_root;
unsigned int state;
char is_hint;
int same_screen;
} XMotionEvent;
typedef XMotionEvent XPointerMovedEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
Window root;
Window subwindow;
Time time;
int x, y;
int x_root, y_root;
int mode;
int detail;
int same_screen;
int focus;
unsigned int state;
} XCrossingEvent;
typedef XCrossingEvent XEnterWindowEvent;
typedef XCrossingEvent XLeaveWindowEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
int mode;
int detail;
} XFocusChangeEvent;
typedef XFocusChangeEvent XFocusInEvent;
typedef XFocusChangeEvent XFocusOutEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
char key_vector[32];
} XKeymapEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
int x, y;
int width, height;
int count;
} XExposeEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Drawable drawable;
int x, y;
int width, height;
int count;
int major_code;
int minor_code;
} XGraphicsExposeEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Drawable drawable;
int major_code;
int minor_code;
} XNoExposeEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
int state;
} XVisibilityEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window parent;
Window window;
int x, y;
int width, height;
int border_width;
int override_redirect;
} XCreateWindowEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window event;
Window window;
} XDestroyWindowEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window event;
Window window;
int from_configure;
} XUnmapEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window event;
Window window;
int override_redirect;
} XMapEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window parent;
Window window;
} XMapRequestEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window event;
Window window;
Window parent;
int x, y;
int override_redirect;
} XReparentEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window event;
Window window;
int x, y;
int width, height;
int border_width;
Window above;
int override_redirect;
} XConfigureEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window event;
Window window;
int x, y;
} XGravityEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
int width, height;
} XResizeRequestEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window parent;
Window window;
int x, y;
int width, height;
int border_width;
Window above;
int detail;
unsigned long value_mask;
} XConfigureRequestEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window event;
Window window;
int place;
} XCirculateEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window parent;
Window window;
int place;
} XCirculateRequestEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
Atom atom;
Time time;
int state;
} XPropertyEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
Atom selection;
Time time;
} XSelectionClearEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window owner;
Window requestor;
Atom selection;
Atom target;
Atom property;
Time time;
} XSelectionRequestEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window requestor;
Atom selection;
Atom target;
Atom property;
Time time;
} XSelectionEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
Colormap colormap;
int new;
int state;
} XColormapEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
Atom message_type;
int format;
union {
char b[20];
short s[10];
long l[5];
} data;
} XClientMessageEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
int request;
int first_keycode;
int count;
} XMappingEvent;
typedef struct {
int type;
Display *display;
XID resourceid;
unsigned long serial;
unsigned char error_code;
unsigned char request_code;
unsigned char minor_code;
} XErrorEvent;
typedef struct {
int type;
unsigned long serial;
int send_event;
Display *display;
Window window;
} XAnyEvent;
typedef union _XEvent {
int type;
XAnyEvent xany;
XKeyEvent xkey;
XButtonEvent xbutton;
XMotionEvent xmotion;
XCrossingEvent xcrossing;
XFocusChangeEvent xfocus;
XExposeEvent xexpose;
XGraphicsExposeEvent xgraphicsexpose;
XNoExposeEvent xnoexpose;
XVisibilityEvent xvisibility;
XCreateWindowEvent xcreatewindow;
XDestroyWindowEvent xdestroywindow;
XUnmapEvent xunmap;
XMapEvent xmap;
XMapRequestEvent xmaprequest;
XReparentEvent xreparent;
XConfigureEvent xconfigure;
XGravityEvent xgravity;
XResizeRequestEvent xresizerequest;
XConfigureRequestEvent xconfigurerequest;
XCirculateEvent xcirculate;
XCirculateRequestEvent xcirculaterequest;
XPropertyEvent xproperty;
XSelectionClearEvent xselectionclear;
XSelectionRequestEvent xselectionrequest;
XSelectionEvent xselection;
XColormapEvent xcolormap;
XClientMessageEvent xclient;
XMappingEvent xmapping;
XErrorEvent xerror;
XKeymapEvent xkeymap;
long pad[24];
} XEvent;
typedef struct _XSQEvent {
struct _XSQEvent *next;
XEvent event;
} _XQEvent;
typedef struct {
short lbearing;
short rbearing;
short width;
short ascent;
short descent;
unsigned short attributes;
} XCharStruct;
typedef struct {
Atom name;
unsigned long card32;
} XFontProp;
typedef struct {
XExtData *ext_data;
Font fid;
unsigned direction;
unsigned min_char_or_byte2;
unsigned max_char_or_byte2;
unsigned min_byte1;
unsigned max_byte1;
int all_chars_exist;
unsigned default_char;
int n_properties;
XFontProp *properties;
XCharStruct min_bounds;
XCharStruct max_bounds;
XCharStruct *per_char;
int ascent;
int descent;
} XFontStruct;
typedef struct {
char *chars;
int nchars;
int delta;
Font font;
} XTextItem;
typedef struct {
unsigned char byte1;
unsigned char byte2;
} XChar2b;
typedef struct {
XChar2b *chars;
int nchars;
int delta;
Font font;
} XTextItem16;
XFontStruct *XLoadQueryFont(), *XQueryFont();
XTimeCoord *XGetMotionEvents();
typedef union { Display *display;
GC gc;
Visual *visual;
Screen *screen;
ScreenFormat *pixmap_format;
XFontStruct *font; } XEDataObject;
Display *XOpenDisplay();
char *XFetchBytes();
char *XFetchBuffer();
char *XGetAtomName();
char *XGetDefault();
char *XDisplayName();
char *XKeysymToString();
int (*XSynchronize())();
int (*XSetAfterFunction())();
Atom XInternAtom();
Colormap XCopyColormapAndFree(), XCreateColormap();
Cursor XCreatePixmapCursor(), XCreateGlyphCursor(), XCreateFontCursor();
Font XLoadFont();
GC XCreateGC();
GContext XGContextFromGC();
Pixmap XCreatePixmap();
Pixmap XCreateBitmapFromData(), XCreatePixmapFromBitmapData();
Window XCreateSimpleWindow(), XGetSelectionOwner();
Window XCreateWindow();
Colormap *XListInstalledColormaps();
char **XListFonts(), **XListFontsWithInfo(), **XGetFontPath();
char **XListExtensions();
Atom *XListProperties();
XImage *XCreateImage(), *XGetImage(), *XGetSubImage();
XHostAddress *XListHosts();
KeySym XKeycodeToKeysym(), XLookupKeysym(), *XGetKeyboardMapping();
KeySym XStringToKeysym();
long XMaxRequestSize();
char *XResourceManagerString();
unsigned long XDisplayMotionBufferSize();
VisualID XVisualIDFromVisual();
XExtCodes *XInitExtension();
int (*XESetCreateGC())(), (*XESetCopyGC())(), (*XESetFlushGC())(),
(*XESetFreeGC())(), (*XESetCreateFont())(), (*XESetFreeFont())(),
(*XESetCloseDisplay())(),
(*XESetError())(), (*XESetErrorString())();
int (*XESetWireToEvent())();
int (*XESetEventToWire())();
XExtCodes *XAddExtension();
XExtData *XFindOnExtensionList();
XExtData **XEHeadOfExtensionList();
Window XRootWindow(), XDefaultRootWindow(), XRootWindowOfScreen();
Visual *XDefaultVisual(), *XDefaultVisualOfScreen();
GC XDefaultGC(), XDefaultGCOfScreen();
unsigned long XBlackPixel(), XWhitePixel(), XAllPlanes();
unsigned long XBlackPixelOfScreen(), XWhitePixelOfScreen();
unsigned long XNextRequest(), XLastKnownRequestProcessed();
char *XServerVendor(), *XDisplayString();
Colormap XDefaultColormap(), XDefaultColormapOfScreen();
Display *XDisplayOfScreen();
Screen *XScreenOfDisplay(), *XDefaultScreenOfDisplay();
long XEventMaskOfScreen();
# 32 "Intrinsic.h"
# 1 "../.././X11/Xutil.h"
typedef struct {
long flags;
int x, y;
int width, height;
int min_width, min_height;
int max_width, max_height;
int width_inc, height_inc;
struct {
int x;
int y;
} min_aspect, max_aspect;
} XSizeHints;
typedef struct {
long flags;
int input;
int initial_state;
Pixmap icon_pixmap;
Window icon_window;
int icon_x, icon_y;
Pixmap icon_mask;
XID window_group;
} XWMHints;
typedef struct {
int min_width, min_height;
int max_width, max_height;
int width_inc, height_inc;
} XIconSize;
typedef struct {
char *res_name;
char *res_class;
} XClassHint;
typedef struct _XComposeStatus {
char *compose_ptr;
int chars_matched;
} XComposeStatus;
typedef struct _XRegion *Region;
typedef struct {
Visual *visual;
VisualID visualid;
int screen;
int depth;
int class;
unsigned long red_mask;
unsigned long green_mask;
unsigned long blue_mask;
int colormap_size;
int bits_per_rgb;
} XVisualInfo;
typedef struct {
Colormap colormap;
unsigned long red_max;
unsigned long red_mult;
unsigned long green_max;
unsigned long green_mult;
unsigned long blue_max;
unsigned long blue_mult;
unsigned long base_pixel;
} XStandardColormap;
typedef int XContext;
extern int XSaveContext();
extern int XFindContext();
extern int XDeleteContext();
XWMHints *XGetWMHints();
Region XCreateRegion(), XPolygonRegion();
XImage *XCreateImage();
XVisualInfo *XGetVisualInfo();
# 33 "Intrinsic.h"
# 1 "../.././X11/Xresource.h"
# 1 "/usr/include/sys/types.h"
# 109 "/usr/include/sys/types.h"
# 54 "../.././X11/Xresource.h"
extern char *Xpermalloc();
typedef int XrmQuark, *XrmQuarkList;
typedef char *XrmString;
extern XrmQuark XrmStringToQuark();
extern XrmString XrmQuarkToString();
extern XrmQuark XrmUniqueQuark();
extern void XrmStringToQuarkList();
extern void XrmStringToBindingQuarkList();
typedef XrmQuark XrmName;
typedef XrmQuarkList XrmNameList;
typedef XrmQuark XrmClass;
typedef XrmQuarkList XrmClassList;
typedef XrmQuark XrmRepresentation;
typedef struct {
unsigned int size;
caddr_t addr;
} XrmValue, *XrmValuePtr;
typedef enum {XrmBindTightly, XrmBindLoosely} XrmBinding, *XrmBindingList;
typedef struct _XrmHashBucketRec *XrmHashBucket;
typedef XrmHashBucket *XrmHashTable;
typedef XrmHashTable XrmSearchList[];
typedef struct _XrmHashBucketRec *XrmDatabase;
extern void XrmInitialize();
extern void XrmQPutResource();
extern void XrmPutResource();
extern void XrmQPutStringResource();
extern void XrmPutStringResource();
extern void XrmPutLineResource();
extern XrmQGetResource();
extern int XrmGetResource();
extern int XrmQGetSearchList();
extern int XrmQGetSearchResource();
extern XrmDatabase XrmGetFileDatabase();
extern XrmDatabase XrmGetStringDatabase();
extern void XrmPutFileDatabase();
extern void XrmMergeDatabases();
typedef enum {
XrmoptionNoArg,
XrmoptionIsArg,
XrmoptionStickyArg,
XrmoptionSepArg,
XrmoptionResArg,
XrmoptionSkipArg,
XrmoptionSkipLine
} XrmOptionKind;
typedef struct {
char *option;
char *specifier;
XrmOptionKind argKind;
caddr_t value;
} XrmOptionDescRec, *XrmOptionDescList;
extern void XrmParseCommand();
# 34 "Intrinsic.h"
# 1 "../.././X11/Xos.h"
# 1 "/usr/include/sys/types.h"
# 109 "/usr/include/sys/types.h"
# 37 "../.././X11/Xos.h"
# 1 "/usr/include/strings.h"
char *strcat();
char *strncat();
int strcmp();
int strncmp();
char *strcpy();
char *strncpy();
int strlen();
char *index();
char *rindex();
# 68 "../.././X11/Xos.h"
# 1 "/usr/include/sys/file.h"
# 37 "/usr/include/sys/file.h"
# 1 "/usr/include/sys/fcntlcom.h"
struct flock {
short l_type;
short l_whence;
long l_start;
long l_len;
short l_pid;
short l_xxx;
};
# 39 "/usr/include/sys/file.h"
# 93 "/usr/include/sys/file.h"
# 79 "../.././X11/Xos.h"
# 1 "/usr/include/sys/time.h"
struct timeval {
long tv_sec;
long tv_usec;
};
struct timezone {
int tz_minuteswest;
int tz_dsttime;
};
struct itimerval {
struct timeval it_interval;
struct timeval it_value;
};
# 1 "/usr/include/time.h"
struct tm {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
char *tm_zone;
long tm_gmtoff;
};
extern struct tm *gmtime(), *localtime();
extern char *asctime(), *ctime();
extern void tzset(), tzsetwall();
# 62 "/usr/include/sys/time.h"
# 96 "../.././X11/Xos.h"
# 35 "Intrinsic.h"
typedef char *String;
typedef struct _WidgetRec *Widget;
typedef Widget *WidgetList;
typedef struct _WidgetClassRec *WidgetClass;
typedef struct _CompositeRec *CompositeWidget;
typedef struct _XtActionsRec *XtActionList;
typedef struct _XtEventRec *XtEventTable;
typedef struct _XtBoundAccActionRec *XtBoundAccActions;
typedef unsigned int Cardinal;
typedef unsigned short ShortCard;
typedef char Boolean;
typedef unsigned long *Opaque;
typedef struct _XtAppStruct *XtAppContext;
typedef unsigned long XtValueMask;
typedef unsigned long XtIntervalId;
typedef unsigned long XtInputId;
typedef unsigned long XtWorkProcId;
typedef unsigned int XtGeometryMask;
typedef unsigned long XtGCMask;
typedef unsigned long Pixel;
typedef short Position;
typedef ShortCard Dimension;
typedef long XtArgVal;
# 1 "Core.h"
extern WidgetClass widgetClass;
# 95 "Intrinsic.h"
# 1 "Composite.h"
typedef struct _CompositeClassRec *CompositeWidgetClass;
extern void XtManageChildren ();
extern void XtManageChild ();
extern void XtUnmanageChildren ();
extern void XtUnmanageChild ();
extern WidgetClass compositeWidgetClass;
# 96 "Intrinsic.h"
# 1 "Constraint.h"
typedef struct _ConstraintClassRec *ConstraintWidgetClass;
extern WidgetClass constraintWidgetClass;
# 97 "Intrinsic.h"
extern void _XtConvertInitialize();
extern void XtStringConversionWarning();
typedef void (*XtConverter)();
typedef enum {
XtAddress,
XtBaseOffset,
XtImmediate,
XtResourceString,
XtResourceQuark
} XtAddressMode;
typedef struct {
XtAddressMode address_mode;
caddr_t address_id;
Cardinal size;
} XtConvertArgRec, *XtConvertArgList;
extern XtConvertArgRec colorConvertArgs[];
extern XtConvertArgRec screenConvertArg[];
extern void XtAppAddConverter();
extern void XtAddConverter();
extern void XtConvert();
extern void XtDirectConvert();
typedef struct _TranslationData *XtTranslations;
typedef struct _TranslationData *XtAccelerators;
typedef unsigned int Modifiers;
typedef void (*XtActionProc)();
typedef XtActionProc* XtBoundActions;
typedef struct _XtActionsRec{
char *string;
XtActionProc proc;
} XtActionsRec;
extern XtTranslations XtParseTranslationTable();
extern XtAccelerators XtParseAcceleratorTable();
extern void XtOverrideTranslations();
extern void XtAugmentTranslations();
extern void XtInstallAccelerators();
extern void XtInstallAllAccelerators();
extern void XtUninstallTranslations();
extern void XtAppAddActions();
extern void XtAddActions();
typedef void (*XtKeyProc)();
extern void XtTranslateKeycode();
extern void XtTranslateKey();
extern void XtSetKeyTranslator();
typedef void (*XtCaseProc)();
extern void XtRegisterCaseConverter();
extern void XtConvertCase();
typedef void (*XtEventHandler)();
typedef void (*XtAsyncHandler)();
typedef unsigned long EventMask;
extern void XtAddEventHandler();
extern void XtRemoveEventHandler();
extern void XtAddRawEventHandler();
extern void XtRemoveRawEventHandler();
extern EventMask XtBuildEventMask();
extern void XtAddGrab();
extern void XtRemoveGrab();
extern void XtDispatchEvent();
extern void XtProcessEvent();
extern void XtAppProcessEvent();
extern void XtMainLoop();
extern void XtAppMainLoop();
extern void XtAddExposureToRegion();
extern void XtSetAsyncEventHandler();
extern void XtMakeToolkitAsync();
extern void XtSetKeyboardFocus();
typedef unsigned long XtInputMask;
typedef void (*XtTimerCallbackProc)();
extern XtIntervalId XtAddTimeOut();
extern XtIntervalId XtAppAddTimeOut();
extern void XtRemoveTimeOut();
typedef void (* XtInputCallbackProc)();
extern XtInputId XtAddInput();
extern XtInputId XtAppAddInput();
extern void XtRemoveInput();
extern void XtNextEvent();
extern void XtAppNextEvent();
extern Boolean XtPeekEvent();
extern Boolean XtAppPeekEvent();
extern XtInputMask XtPending ();
extern XtInputMask XtAppPending();
extern Boolean XtIsSubclass ();
extern void XtRealizeWidget ();
void XtUnrealizeWidget ();
extern void XtDestroyWidget ();
extern void XtSetSensitive ();
extern void XtSetMappedWhenManaged ();
extern Widget XtNameToWidget();
extern Widget XtWindowToWidget();
typedef struct {
String name;
XtArgVal value;
} Arg, *ArgList;
extern ArgList XtMergeArgLists();
extern Display *XtDisplay();
extern Screen *XtScreen();
extern Window XtWindow();
extern WidgetClass XtSuperclass();
extern WidgetClass XtClass();
extern Boolean XtIsManaged();
extern Boolean XtIsRealized ();
extern Boolean XtIsSensitive();
extern Widget XtParent();
typedef struct _XtCallbackRec* XtCallbackList;
typedef void (*XtCallbackProc)();
typedef struct _XtCallbackRec {
XtCallbackProc callback;
caddr_t closure;
} XtCallbackRec;
extern void XtAddCallback ();
extern void XtRemoveCallback ();
extern void XtAddCallbacks ();
extern void XtRemoveCallbacks ();
extern void XtRemoveAllCallbacks ();
extern void XtCallCallbacks ();
typedef enum {
XtCallbackNoList,
XtCallbackHasNone,
XtCallbackHasSome
} XtCallbackStatus;
extern XtCallbackStatus XtHasCallbacks();
typedef struct {
XtGeometryMask request_mode;
Position x, y;
Dimension width, height, border_width;
Widget sibling;
int stack_mode;
} XtWidgetGeometry;
typedef enum {
XtGeometryYes,
XtGeometryNo,
XtGeometryAlmost,
XtGeometryDone
} XtGeometryResult;
extern XtGeometryResult XtMakeGeometryRequest();
extern XtGeometryResult XtMakeResizeRequest ();
extern void XtTransformCoords();
extern XtGeometryResult XtQueryGeometry();
extern Widget XtCreatePopupShell();
typedef enum {XtGrabNone, XtGrabNonexclusive, XtGrabExclusive} XtGrabKind;
extern void XtPopup();
extern void XtCallbackNone();
extern void XtCallbackNonexclusive();
extern void XtCallbackExclusive();
extern void XtPopdown();
typedef struct {
Widget shell_widget;
Widget enable_widget;
} XtPopdownIDRec, *XtPopdownID;
extern void XtCallbackPopdown();
extern Widget XtCreateWidget ();
extern Widget XtCreateManagedWidget ();
extern Widget XtCreateApplicationShell ();
extern Widget XtAppCreateShell ();
extern void XtToolkitInitialize();
extern void XtDisplayInitialize();
extern Widget XtInitialize();
extern Display *XtOpenDisplay();
extern XtAppContext XtCreateApplicationContext();
extern void XtDestroyApplicationContext();
extern XtAppContext XtWidgetToApplicationContext();
extern XrmDatabase XtDatabase();
extern void XtCloseDisplay();
typedef struct {
XrmQuark xrm_name;
XrmQuark xrm_class;
XrmQuark xrm_type;
Cardinal xrm_size;
long int xrm_offset;
XrmQuark xrm_default_type;
caddr_t xrm_default_addr;
} XrmResource, *XrmResourceList;
extern void XtCopyFromParent();
extern void XtCopyDefaultDepth();
extern void XtCopyDefaultColormap();
extern void XtCopyAncestorSensitive();
extern void XtCopyScreen();
typedef struct _XtResource *XtResourceList;
extern void XrmCompileResourceList();
extern void XtGetSubresources();
extern void XtSetValues();
extern void XtGetValues();
extern void XtSetSubvalues();
extern void XtGetSubvalues();
extern void XtGetResourceList();
typedef struct _XtResource {
String resource_name;
String resource_class;
String resource_type;
Cardinal resource_size;
Cardinal resource_offset;
String default_type;
caddr_t default_addr;
} XtResource;
typedef void (*XtErrorMsgHandler)();
extern void XtAppSetErrorMsgHandler();
extern void XtSetErrorMsgHandler();
extern void XtAppSetWarningMsgHandler();
extern void XtSetWarningMsgHandler();
extern void XtAppErrorMsg();
extern void XtErrorMsg();
extern void XtAppWarningMsg();
extern void XtWarningMsg();
typedef void (*XtErrorHandler)();
extern void XtAppSetErrorHandler();
extern void XtSetErrorHandler();
extern void XtAppSetWarningHandler();
extern void XtSetWarningHandler();
extern void XtAppError();
extern void XtError();
extern void XtAppWarning();
extern void XtWarning();
extern XrmDatabase *XtAppGetErrorDatabase();
extern XrmDatabase *XtGetErrorDatabase();
extern void XtAppGetErrorDatabaseText();
extern void XtGetErrorDatabaseText();
extern char *XtMalloc();
extern char *XtCalloc();
extern char *XtRealloc();
extern void XtFree();
typedef Boolean (*XtWorkProc)();
extern XtWorkProcId XtAddWorkProc();
extern XtWorkProcId XtAppAddWorkProc();
extern void XtRemoveWorkProc();
extern GC XtGetGC();
extern void XtDestroyGC ();
# 33 "IntrinsicP.h"
typedef unsigned long XtVersionType;
extern void _XtInherit();
typedef void (*XtProc)();
typedef void (*XtWidgetClassProc)();
typedef void (*XtWidgetProc)();
typedef Boolean (*XtAcceptFocusProc)();
typedef void (*XtArgsProc)();
typedef void (*XtInitProc)();
typedef Boolean (*XtSetValuesFunc)();
typedef Boolean (*XtArgsFunc)();
typedef void (*XtAlmostProc)();
typedef void (*XtExposeProc)();
typedef void (*XtRealizeProc) ();
typedef void (*XtCreatePopupChildProc)();
typedef XtGeometryResult (*XtGeometryHandler)();
typedef void (*XtStringProc)();
typedef struct _StateRec *StatePtr;
typedef struct _XtTMRec {
XtTranslations translations;
XtBoundActions proc_table;
StatePtr current_state;
unsigned long lastEventTime;
} XtTMRec, *XtTM;
# 1 "CoreP.h"
extern int _XtInheritTranslations;
typedef struct _CorePart {
Widget self;
WidgetClass widget_class;
Widget parent;
XrmName xrm_name;
Boolean being_destroyed;
XtCallbackList destroy_callbacks;
caddr_t constraints;
Position x, y;
Dimension width, height;
Dimension border_width;
Boolean managed;
Boolean sensitive;
Boolean ancestor_sensitive;
XtEventTable event_table;
XtTMRec tm;
XtTranslations accelerators;
Pixel border_pixel;
Pixmap border_pixmap;
WidgetList popup_list;
Cardinal num_popups;
String name;
Screen *screen;
Colormap colormap;
Window window;
Cardinal depth;
Pixel background_pixel;
Pixmap background_pixmap;
Boolean visible;
Boolean mapped_when_managed;
} CorePart;
typedef struct _WidgetRec {
CorePart core;
} WidgetRec;
typedef struct _CoreClassPart {
WidgetClass superclass;
String class_name;
Cardinal widget_size;
XtProc class_initialize;
XtWidgetClassProc class_part_initialize;
Boolean class_inited;
XtInitProc initialize;
XtArgsProc initialize_hook;
XtRealizeProc realize;
XtActionList actions;
Cardinal num_actions;
XtResourceList resources;
Cardinal num_resources;
XrmClass xrm_class;
Boolean compress_motion;
Boolean compress_exposure;
Boolean compress_enterleave;
Boolean visible_interest;
XtWidgetProc destroy;
XtWidgetProc resize;
XtExposeProc expose;
XtSetValuesFunc set_values;
XtArgsFunc set_values_hook;
XtAlmostProc set_values_almost;
XtArgsProc get_values_hook;
XtAcceptFocusProc accept_focus;
XtVersionType version;
struct _XtOffsetRec *callback_private;
String tm_table;
XtGeometryHandler query_geometry;
XtStringProc display_accelerator;
caddr_t extension;
} CoreClassPart;
typedef struct _WidgetClassRec {
CoreClassPart core_class;
} WidgetClassRec;
extern WidgetClassRec widgetClassRec;
# 113 "IntrinsicP.h"
# 1 "CompositeP.h"
typedef Cardinal (*XtOrderProc)();
typedef struct _CompositePart {
WidgetList children;
Cardinal num_children;
Cardinal num_slots;
XtOrderProc insert_position;
} CompositePart,*CompositePtr;
typedef struct _CompositeRec {
CorePart core;
CompositePart composite;
} CompositeRec;
typedef struct _CompositeClassPart {
XtGeometryHandler geometry_manager;
XtWidgetProc change_managed;
XtWidgetProc insert_child;
XtWidgetProc delete_child;
caddr_t extension;
} CompositeClassPart,*CompositePartPtr;
typedef struct _CompositeClassRec {
CoreClassPart core_class;
CompositeClassPart composite_class;
} CompositeClassRec;
extern CompositeClassRec compositeClassRec;
# 114 "IntrinsicP.h"
# 1 "ConstrainP.h"
typedef struct _ConstraintPart {
caddr_t mumble;
} ConstraintPart;
typedef struct _ConstraintRec {
CorePart core;
CompositePart composite;
ConstraintPart constraint;
} ConstraintRec, *ConstraintWidget;
typedef struct _ConstraintClassPart {
XtResourceList resources;
Cardinal num_resources;
Cardinal constraint_size;
XtInitProc initialize;
XtWidgetProc destroy;
XtSetValuesFunc set_values;
caddr_t extension;
} ConstraintClassPart;
typedef struct _ConstraintClassRec {
CoreClassPart core_class;
CompositeClassPart composite_class;
ConstraintClassPart constraint_class;
} ConstraintClassRec;
extern ConstraintClassRec constraintClassRec;
# 115 "IntrinsicP.h"
# 141 "IntrinsicP.h"
extern void XtCreateWindow ();
extern void XtResizeWidget();
extern void XtMoveWidget();
extern void XtConfigureWidget();
# 33 "IntrinsicI.h"
# 1 "Object.h"
typedef struct _ObjectRec *Object;
typedef struct _ObjectClassRec *ObjectClass;
extern ObjectClass objectClass;
# 35 "IntrinsicI.h"
# 1 "RectObj.h"
typedef struct _RectObjRec *RectObj;
typedef struct _RectObjClassRec *RectObjClass;
extern RectObjClass rectObjClass;
# 36 "IntrinsicI.h"
# 1 "WindowObj.h"
typedef struct _WindowObjRec *WindowObj;
typedef struct _WindowObjClassRec *WindowObjClass;
extern WindowObjClass windowObjClass;
# 37 "IntrinsicI.h"
# 1 "CompObj.h"
typedef struct _CompositeObjectClassRec *CompositeObjectClass;
typedef struct _CompositeObjRec *CompositeObject;
extern WidgetClass compositeObjectClass;
# 38 "IntrinsicI.h"
# 1 "ObjectP.h"
typedef struct _ObjectPart {
Widget self;
WidgetClass widget_class;
Widget parent;
XrmName xrm_name;
Boolean being_destroyed;
XtCallbackList destroy_callbacks;
caddr_t constraints;
} ObjectPart;
typedef struct _ObjectRec {
ObjectPart object;
} ObjectRec;
typedef struct _ObjectClassPart {
WidgetClass superclass;
String class_name;
Cardinal widget_size;
XtProc class_initialize;
XtWidgetClassProc class_part_initialize;
Boolean class_inited;
XtInitProc initialize;
XtArgsProc initialize_hook;
XtProc obj1;
XtProc obj2;
Cardinal obj3;
XtResourceList resources;
Cardinal num_resources;
XrmClass xrm_class;
Boolean obj4;
Boolean obj5;
Boolean obj6;
Boolean obj7;
XtWidgetProc destroy;
XtProc obj8;
XtProc obj9;
XtSetValuesFunc set_values;
XtArgsFunc set_values_hook;
XtProc obj10;
XtArgsProc get_values_hook;
XtProc obj11;
XtVersionType version;
struct _XtOffsetRec *callback_private;
String obj12;
XtProc obj13;
XtProc obj14;
caddr_t extension;
}ObjectClassPart;
typedef struct _ObjectClassRec {
ObjectClassPart object_class;
} ObjectClassRec;
extern ObjectClassRec objectClassRec;
# 39 "IntrinsicI.h"
# 1 "RectObjP.h"
# 1 "ObjectP.h"
# 102 "ObjectP.h"
# 30 "RectObjP.h"
typedef struct _RectObjPart {
Position x, y;
Dimension width, height;
Dimension border_width;
Boolean managed;
Boolean sensitive;
Boolean ancestor_sensitive;
}RectObjPart;
typedef struct _RectObjRec {
ObjectPart object;
RectObjPart rectangle;
} RectObjRec;
typedef struct _RectObjClassPart {
WidgetClass superclass;
String class_name;
Cardinal widget_size;
XtProc class_initialize;
XtWidgetClassProc class_part_initialize;
Boolean class_inited;
XtInitProc initialize;
XtArgsProc initialize_hook;
XtProc rect1;
XtProc rect2;
Cardinal rect3;
XtResourceList resources;
Cardinal num_resources;
XrmClass xrm_class;
Boolean rect4;
Boolean rect5;
Boolean rect6;
Boolean rect7;
XtWidgetProc destroy;
XtWidgetProc resize;
XtExposeProc expose;
XtSetValuesFunc set_values;
XtArgsFunc set_values_hook;
XtAlmostProc set_values_almost;
XtArgsProc get_values_hook;
XtProc rect9;
XtVersionType version;
struct _XtOffsetRec *callback_private;
String rect10;
XtGeometryHandler query_geometry;
XtProc rect11;
caddr_t extension;
}RectObjClassPart;
typedef struct _RectObjClassRec {
RectObjClassPart rect_class;
} RectObjClassRec;
extern RectObjClassRec rectObjClassRec;
# 40 "IntrinsicI.h"
# 1 "WindowObjP.h"
# 1 "RectObjP.h"
# 105 "RectObjP.h"
# 30 "WindowObjP.h"
extern int _XtInheritTranslations;
typedef struct _WindowObjPart {
XtEventTable event_table;
XtTMRec tm;
XtTranslations accelerators;
Pixel border_pixel;
Pixmap border_pixmap;
WidgetList popup_list;
Cardinal num_popups;
String name;
Screen *screen;
Colormap colormap;
Window window;
Cardinal depth;
Pixel background_pixel;
Pixmap background_pixmap;
Boolean visible;
Boolean mapped_when_managed;
} WindowObjPart;
typedef struct _WindowObjRec {
ObjectPart object;
RectObjPart rect;
WindowObjPart win_obj;
}WindowObjRec;
typedef struct _WindowObjClassPart {
WidgetClass superclass;
String class_name;
Cardinal widget_size;
XtProc class_initialize;
XtWidgetClassProc class_part_initialize;
Boolean class_inited;
XtInitProc initialize;
XtArgsProc initialize_hook;
XtRealizeProc realize;
XtActionList actions;
Cardinal num_actions;
XtResourceList resources;
Cardinal num_resources;
XrmClass xrm_class;
Boolean compress_motion;
Boolean compress_exposure;
Boolean compress_enterleave;
Boolean visible_interest;
XtWidgetProc destroy;
XtWidgetProc resize;
XtExposeProc expose;
XtSetValuesFunc set_values;
XtArgsFunc set_values_hook;
XtAlmostProc set_values_almost;
XtArgsProc get_values_hook;
XtAcceptFocusProc accept_focus;
XtVersionType version;
struct _XtOffsetRec *callback_private;
String tm_table;
XtGeometryHandler query_geometry;
XtStringProc display_accelerator;
caddr_t extension;
}WindowObjClassPart;
typedef struct _WindowObjClassRec {
WindowObjClassPart window_class;
} WindowObjClassRec;
extern WindowObjClassRec windowObjClassRec;
# 41 "IntrinsicI.h"
# 1 "CompObjP.h"
typedef struct _CompositeObjRec {
ObjectPart object;
RectObjPart rectangle;
CompositePart composite;
} CompositeObjRec;
typedef struct _CompositeObjectClassRec {
ObjectClassPart object_class;
CompositeClassPart composite_class;
}CompositeObjectClassRec;
extern CompositeObjectClassRec compositeObjectClassRec;
# 42 "IntrinsicI.h"
# 1 "TranslateI.h"
typedef Boolean (*MatchProc)();
typedef struct _ModToKeysymTable {
Modifiers mask;
int count;
int index;
} ModToKeysymTable;
typedef struct _LateBindings {
Boolean knot;
Boolean pair;
KeySym keysym;
} LateBindings, *LateBindingsPtr;
typedef short ModifierMask;
typedef struct _EventObjRec *EventObjPtr;
typedef struct _EventRec {
unsigned long modifiers;
unsigned long modifierMask;
LateBindingsPtr lateModifiers;
unsigned long eventType;
unsigned long eventCode;
unsigned long eventCodeMask;
MatchProc matchEvent;
Boolean standard;
} Event;
typedef enum _TMkind {override,augment} TMkind;
typedef struct _TMConvertRec {
XtTranslations old;
XtTranslations new;
TMkind operation;
} TMConvertRec;
typedef struct _EventObjRec {
Event event;
StatePtr state;
} EventObjRec;
typedef struct _ActionsRec *ActionPtr;
typedef struct _ActionsRec {
char * token;
int index;
String *params;
unsigned long num_params;
ActionPtr next;
} ActionRec;
typedef struct _StateRec {
int index;
ActionPtr actions;
StatePtr nextLevel;
StatePtr next;
StatePtr forw;
Boolean cycle;
} StateRec;
typedef enum {XtTableReplace,XtTableAugment,XtTableOverride} _XtTranslateOp;
typedef struct _TranslationData {
_XtTranslateOp operation;
unsigned int numEvents;
unsigned int eventTblSize;
EventObjPtr eventObjTbl;
unsigned long clickTime;
unsigned long lastEventTime;
unsigned int numQuarks;
unsigned int quarkTblSize;
XrmQuark* quarkTable;
unsigned int accNumQuarks;
unsigned int accQuarkTblSize;
XrmQuark* accQuarkTable;
struct _XtBoundAccActionRec* accProcTbl;
StatePtr head;
} TranslationData;
typedef struct _EventSeqRec *EventSeqPtr;
typedef struct _EventSeqRec {
Event event;
StatePtr state;
EventSeqPtr next;
ActionPtr actions;
} EventSeqRec;
typedef EventSeqRec EventRec;
typedef EventSeqPtr EventPtr;
typedef struct _TMEventRec {
Display *dpy;
Event event;
}TMEventRec,*TMEventPtr;
typedef struct _XtBoundAccActionRec {
Widget widget;
XtActionProc proc;
} XtBoundAccActionRec;
extern void _XtAddEventSeqToStateTable();
extern void _XtInitializeStateTable();
typedef XrmQuark XtAction;
typedef unsigned int Value;
typedef struct {
char *name;
XrmQuark signature;
Value value;
} NameValueRec, *NameValueTable;
extern Boolean _XtLookupModifier();
extern Boolean _XtMatchUsingStandardMods();
extern Boolean _XtMatchUsingDontCareMods();
extern Boolean _XtRegularMatch();
extern void _XtConvertCase();
extern ModToKeysymTable* _XtBuildModsToKeysymTable();
extern void _XtBuildKeysymTable();
extern XModifierKeymap *_XtBuildModifierTable();
extern Boolean _XtLookupTableSym();
extern void _XtPopupInitialize();
extern void _XtInstallTranslations();
extern void _XtUninstallTranslations();
extern void _XtBindActions();
extern void _XtTranslateInitialize();
extern XtTranslations _XtParseTranslationTable();
extern void _XtRegisterGrabs();
extern void _XtPopup();
extern Boolean RegularMatch();
# 48 "IntrinsicI.h"
# 1 "CallbackI.h"
typedef struct _XtOffsetRec {
struct _XtOffsetRec *next;
XrmQuark name;
int offset;
} XtOffsetRec, *_XtOffsetList;
extern void _XtRemoveAllCallbacks ();
extern void _XtCallCallbacks ();
extern void _XtAddCallback();
typedef struct _CallbackRec *CallbackList;
typedef struct _CallbackStruct CallbackStruct;
extern CallbackList *_XtDestroyList;
# 49 "IntrinsicI.h"
# 1 "CompositeI.h"
extern void CompositeClassPartInitialize();
extern void CompositeInitialize();
extern void CompositeInsertChild();
extern void CompositeDeleteChild();
extern void CompositeDestroy();
# 50 "IntrinsicI.h"
# 1 "ConvertI.h"
typedef struct _ConverterRec **ConverterTable;
extern void _XtTableAddConverter();
extern void _XtConvert();
extern void LowerCase();
# 51 "IntrinsicI.h"
# 1 "InitialI.h"
# 1 "/usr/include/sys/param.h"
# 1 "/usr/include/machine/param.h"
# 101 "/usr/include/machine/param.h"
# 9 "/usr/include/sys/param.h"
# 56 "/usr/include/sys/param.h"
# 1 "/usr/include/sys/signal.h"
# 1 "/usr/include/vm/faultcode.h"
typedef int faultcode_t;
# 15 "/usr/include/sys/signal.h"
# 46 "/usr/include/sys/signal.h"
# 77 "/usr/include/sys/signal.h"
# 93 "/usr/include/sys/signal.h"
void (*signal())();
void (*sigset())();
int sighold();
int sigrelse();
int sigignore();
struct sigvec {
void (*sv_handler)();
int sv_mask;
int sv_flags;
};
struct sigstack {
char *ss_sp;
int ss_onstack;
};
struct sigcontext {
int sc_onstack;
int sc_mask;
int sc_sp;
int sc_pc;
int sc_npc;
int sc_psr;
int sc_g1;
int sc_o0;
int sc_wbcnt;
char *sc_spbuf[31 ];
int sc_wbuf[31 ][16];
};
# 61 "/usr/include/sys/param.h"
# 1 "/usr/include/sys/types.h"
# 109 "/usr/include/sys/types.h"
# 83 "/usr/include/sys/param.h"
# 33 "InitialI.h"
# 1 "fd.h"
typedef struct Fd_set {
fd_mask fds_bits[(((256 )+(( (sizeof(fd_mask) * 8 ) )-1))/( (sizeof(fd_mask) * 8 ) )) ];
} Fd_set;
# 44 "InitialI.h"
typedef struct _TimerEventRec {
struct timeval te_timer_value;
struct _TimerEventRec *te_next;
Display *te_dpy;
XtTimerCallbackProc te_proc;
XtAppContext app;
caddr_t te_closure;
} TimerEventRec;
typedef struct _InputEvent {
XtInputCallbackProc ie_proc;
caddr_t ie_closure;
struct _InputEvent *ie_next;
struct _InputEvent *ie_oq;
XtAppContext app;
int ie_source;
} InputEvent;
typedef struct _WorkProcRec {
XtWorkProc proc;
caddr_t closure;
struct _WorkProcRec *next;
XtAppContext app;
} WorkProcRec;
typedef struct
{
Fd_set rmask;
Fd_set wmask;
Fd_set emask;
int nfds;
int count;
} FdStruct;
typedef struct _ProcessContextRec {
XtAppContext defaultAppContext;
XtAppContext appContextList;
ConverterTable globalConverterTable;
} ProcessContextRec, *ProcessContext;
typedef struct _XtAppStruct {
XtAppContext next;
ProcessContext process;
Display **list;
TimerEventRec *timerQueue;
WorkProcRec *workQueue;
InputEvent *selectRqueue[64 ], *selectWqueue[64 ],
*selectEqueue[64 ];
InputEvent *outstandingQueue;
XrmDatabase errorDB;
XtErrorMsgHandler errorMsgHandler, warningMsgHandler;
XtErrorHandler errorHandler, warningHandler;
struct _ActionListRec *action_table;
ConverterTable converterTable;
unsigned long selectionTimeout;
FdStruct fds;
short count, max, last;
Boolean sync, rv, being_destroyed, error_inited;
} XtAppStruct;
extern void _XtSetDefaultErrorHandlers();
extern void _XtSetDefaultSelectionTimeout();
extern void _XtSetDefaultConverterTable();
extern void _XtFreeConverterTable();
extern XtAppContext _XtDefaultAppContext();
extern ProcessContext _XtGetProcessContext();
extern void _XtDestroyAppContexts();
extern void _XtCloseDisplays();
extern int _XtAppDestroyCount;
extern int _XtDpyDestroyCount;
extern int _XtwaitForSomething();
typedef struct _XtPerDisplayStruct {
Region region;
XtCaseProc defaultCaseConverter;
XtKeyProc defaultKeycodeTranslator;
XtAppContext appContext;
KeySym *keysyms;
int keysyms_per_keycode;
KeySym *modKeysyms;
ModToKeysymTable *modsToKeysyms;
Boolean being_destroyed;
XrmName name;
XrmClass class;
} XtPerDisplayStruct, *XtPerDisplay;
extern void _XtPerDisplayInitialize();
extern XtPerDisplay _XtGetPerDisplay();
extern XtAppContext _XtDisplayToApplicationContext();
extern void _XtDisplayInitialize();
;
# 52 "IntrinsicI.h"
# 1 "ResourceI.h"
extern void XtGetResources();
extern void _XtResourceDependencies();
extern void _XtConstraintResDependencies();
# 53 "IntrinsicI.h"
# 1 "EventI.h"
typedef struct _GrabRec *GrabList;
extern void _XtEventInitialize();
extern void _XtRegisterWindow();
extern void _XtUnregisterWindow();
typedef struct _XtEventRec {
XtEventTable next;
EventMask mask;
Boolean non_filter;
Boolean select;
Boolean raw;
Boolean async;
XtEventHandler proc;
caddr_t closure;
} XtEventRec;
typedef struct _GrabRec {
GrabList next;
Widget widget;
Widget keyboard_focus;
Boolean exclusive;
Boolean spring_loaded;
}GrabRec;
extern void _XtFreeEventTable();
extern void _XtAsyncMainLoop();
extern void _XtRegisterAsyncHandlers();
# 54 "IntrinsicI.h"
extern void bcopy();
extern void bzero();
extern int bcmp();
extern int XtUnspecifiedPixmap;
# 96 "IntrinsicI.h"
extern int _XtClassIsSubclass();
# 36 "Converters.c"
# 1 "Quarks.h"
extern XrmQuark XtQBool;
extern XrmQuark XtQBoolean;
extern XrmQuark XtQColor;
extern XrmQuark XtQCursor;
extern XrmQuark XtQDimension;
extern XrmQuark XtQDisplay;
extern XrmQuark XtQFile;
extern XrmQuark XtQFont;
extern XrmQuark XtQFontStruct;
extern XrmQuark XtQInt;
extern XrmQuark XtQPixel;
extern XrmQuark XtQPixmap;
extern XrmQuark XtQPointer;
extern XrmQuark XtQPosition;
extern XrmQuark XtQShort;
extern XrmQuark XtQString;
extern XrmQuark XtQUnsignedChar;
extern XrmQuark XtQWindow;
extern XrmQuark XtQEoff;
extern XrmQuark XtQEfalse;
extern XrmQuark XtQEno;
extern XrmQuark XtQEon;
extern XrmQuark XtQEtrue;
extern XrmQuark XtQEyes;
extern XrmQuark XtQExtdefaultbackground;
extern XrmQuark XtQExtdefaultforeground;
extern XrmQuark XtQExtdefaultfont;
# 37 "Converters.c"
void XtStringConversionWarning(from, toType)
String from, toType;
{
# 75 "Converters.c"
String params[2];
Cardinal num_params = 2;
params[0] = from;
params[1] = toType;
XtWarningMsg("conversionError","string","XtToolkitError",
"Cannot convert string \"%s\" to type %s",
params,&num_params);
}
static void CvtXColorToPixel();
static void CvtIntToBoolean();
static void CvtIntToBool();
static void CvtIntToPixmap();
static void CvtIntToFont();
static void CvtIntOrPixelToXColor();
static void CvtIntToPixel();
static void CvtStringToBoolean();
static void CvtStringToBool();
static void CvtStringToCursor();
static void CvtStringToDisplay();
static void CvtStringToFile();
static void CvtStringToFont();
static void CvtStringToFontStruct();
static void CvtStringToGeometry();
static void CvtStringToInt();
static void CvtStringToShort();
static void CvtStringToUnsignedChar();
static void CvtStringToPixel();
static void CvtIntToBoolean(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static Boolean b;
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtIntToBoolean","XtToolkitError",
"Integer to Boolean conversion needs no extra arguments",
(String *)0 , (Cardinal *)0 );
b = (*(int *)fromVal->addr != 0);
{ (*toVal).size = sizeof( Boolean); (*toVal).addr = (caddr_t) &b; } ;
};
static void CvtIntToShort(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static short s;
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtIntToShort","XtToolkitError",
"Integer to Short conversion needs no extra arguments",
(String *)0 , (Cardinal *)0 );
s = (*(int *)fromVal->addr);
{ (*toVal).size = sizeof( short); (*toVal).addr = (caddr_t) &s; } ;
};
static void CvtStringToBoolean(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static Boolean b;
XrmQuark q;
char lowerName[1000];
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtStringToBoolean","XtToolkitError",
"String to Boolean conversion needs no extra arguments",
(String *)0 , (Cardinal *)0 );
LowerCase((char *) fromVal->addr, lowerName);
q = XrmStringToQuark(lowerName);
if (q == XtQEtrue || q == XtQEon || q == XtQEyes) {
b = 1 ;
{ (*toVal).size = sizeof( Boolean); (*toVal).addr = (caddr_t) &b; } ;
return;
}
if (q == XtQEfalse || q ==XtQEoff || q == XtQEno) {
b = 0 ;
{ (*toVal).size = sizeof( Boolean); (*toVal).addr = (caddr_t) &b; } ;
return;
}
XtStringConversionWarning((char *) fromVal->addr, "Boolean");
};
static void CvtIntToBool(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static int b;
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtIntToBool","XtToolkitError",
"Integer to Bool conversion needs no extra arguments",
(String *)0 , (Cardinal *)0 );
b = (*(int *)fromVal->addr != 0);
{ (*toVal).size = sizeof( int ); (*toVal).addr = (caddr_t) &b; } ;
};
static void CvtStringToBool(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static int b;
XrmQuark q;
char lowerName[1000];
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtStringToBool",
"XtToolkitError",
"String to Bool conversion needs no extra arguments",
(String *)0 , (Cardinal *)0 );
LowerCase((char *) fromVal->addr, lowerName);
q = XrmStringToQuark(lowerName);
if (q == XtQEtrue || q == XtQEon || q == XtQEyes) {
b = 1 ;
{ (*toVal).size = sizeof( int ); (*toVal).addr = (caddr_t) &b; } ;
return;
}
if (q == XtQEfalse || q ==XtQEoff || q == XtQEno) {
b = 0 ;
{ (*toVal).size = sizeof( int ); (*toVal).addr = (caddr_t) &b; } ;
return;
}
XtStringConversionWarning((char *) fromVal->addr, "Bool");
};
XtConvertArgRec colorConvertArgs[] = {
{XtBaseOffset, (caddr_t) ((unsigned int) (((char *) (&(((Widget)0 )-> core.screen))) - ((char *) 0 ))) , sizeof(Screen *)},
{XtBaseOffset, (caddr_t) ((unsigned int) (((char *) (&(((Widget)0 )-> core.colormap))) - ((char *) 0 ))) ,sizeof(Colormap)}
};
static void CvtIntOrPixelToXColor(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static XColor c;
Screen *screen;
Colormap colormap;
if (*num_args != 2)
XtErrorMsg("wrongParameters","cvtIntOrPixelToXColor","XtToolkitError",
"Pixel to color conversion needs screen and colormap arguments",
(String *)0 , (Cardinal *)0 );
screen = *((Screen **) args[0].addr);
colormap = *((Colormap *) args[1].addr);
c.pixel = *(int *)fromVal->addr;
XQueryColor(((screen)->display) , colormap, &c);
{ (*toVal).size = sizeof( XColor); (*toVal).addr = (caddr_t) &c; } ;
};
static void CvtStringToPixel(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static XColor screenColor;
XColor exactColor;
Screen *screen;
XtPerDisplay perDpy;
XtAppContext app;
Colormap colormap;
int status;
char message[1000];
XrmQuark q;
String params[1];
Cardinal num_params=1;
if (*num_args != 2)
XtErrorMsg("wrongParameters","cvtStringToPixel","XtToolkitError",
"String to pixel conversion needs screen and colormap arguments",
(String *)0 , (Cardinal *)0 );
screen = *((Screen **) args[0].addr);
perDpy = _XtGetPerDisplay(((screen)->display) );
app = perDpy->appContext;
colormap = *((Colormap *) args[1].addr);
LowerCase((char *) fromVal->addr, message);
q = XrmStringToQuark(message);
if (q == XtQExtdefaultbackground) {
if (app->rv) { { (*toVal).size = sizeof( Pixel); (*toVal).addr = (caddr_t) &screen->black_pixel; } ; return; }
else { { (*toVal).size = sizeof( Pixel); (*toVal).addr = (caddr_t) &screen->white_pixel; } ; return; }
}
if (q == XtQExtdefaultforeground) {
if (app->rv) { { (*toVal).size = sizeof( Pixel); (*toVal).addr = (caddr_t) &screen->white_pixel; } ; return; }
else { { (*toVal).size = sizeof( Pixel); (*toVal).addr = (caddr_t) &screen->black_pixel; } ; return; }
}
if ((char) fromVal->addr[0] == '#') {
status = XParseColor(((screen)->display) , colormap,
(String) fromVal->addr, &screenColor);
if (status != 0)
status = XAllocColor(((screen)->display) , colormap,
&screenColor);
} else
status = XAllocNamedColor(((screen)->display) , colormap,
(String) fromVal->addr, &screenColor,
&exactColor);
if (status == 0) {
params[0]=(String)fromVal->addr;
XtWarningMsg("noColormap","cvtStringToPixel","XtToolkitError",
"Cannot allocate colormap entry for \"%s\"",
params,&num_params);
} else {
{ (*toVal).size = sizeof( Pixel); (*toVal).addr = (caddr_t) &(screenColor.pixel); }
}
};
XtConvertArgRec screenConvertArg[] = {
{XtBaseOffset, (caddr_t) ((unsigned int) (((char *) (&(((Widget)0 )-> core.screen))) - ((char *) 0 ))) , sizeof(Screen *)}
};
static void CvtStringToCursor(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static struct _CursorName {
char *name;
unsigned int shape;
Cursor cursor;
} cursor_names[] = {
{"X_cursor", 0 , 0 },
{"arrow", 2 , 0 },
{"based_arrow_down", 4 , 0 },
{"based_arrow_up", 6 , 0 },
{"boat", 8 , 0 },
{"bogosity", 10 , 0 },
{"bottom_left_corner", 12 , 0 },
{"bottom_right_corner", 14 , 0 },
{"bottom_side", 16 , 0 },
{"bottom_tee", 18 , 0 },
{"box_spiral", 20 , 0 },
{"center_ptr", 22 , 0 },
{"circle", 24 , 0 },
{"clock", 26 , 0 },
{"coffee_mug", 28 , 0 },
{"cross", 30 , 0 },
{"cross_reverse", 32 , 0 },
{"crosshair", 34 , 0 },
{"diamond_cross", 36 , 0 },
{"dot", 38 , 0 },
{"dotbox", 40 , 0 },
{"double_arrow", 42 , 0 },
{"draft_large", 44 , 0 },
{"draft_small", 46 , 0 },
{"draped_box", 48 , 0 },
{"exchange", 50 , 0 },
{"fleur", 52 , 0 },
{"gobbler", 54 , 0 },
{"gumby", 56 , 0 },
{"hand1", 58 , 0 },
{"hand2", 60 , 0 },
{"heart", 62 , 0 },
{"icon", 64 , 0 },
{"iron_cross", 66 , 0 },
{"left_ptr", 68 , 0 },
{"left_side", 70 , 0 },
{"left_tee", 72 , 0 },
{"leftbutton", 74 , 0 },
{"ll_angle", 76 , 0 },
{"lr_angle", 78 , 0 },
{"man", 80 , 0 },
{"middlebutton", 82 , 0 },
{"mouse", 84 , 0 },
{"pencil", 86 , 0 },
{"pirate", 88 , 0 },
{"plus", 90 , 0 },
{"question_arrow", 92 , 0 },
{"right_ptr", 94 , 0 },
{"right_side", 96 , 0 },
{"right_tee", 98 , 0 },
{"rightbutton", 100 , 0 },
{"rtl_logo", 102 , 0 },
{"sailboat", 104 , 0 },
{"sb_down_arrow", 106 , 0 },
{"sb_h_double_arrow", 108 , 0 },
{"sb_left_arrow", 110 , 0 },
{"sb_right_arrow", 112 , 0 },
{"sb_up_arrow", 114 , 0 },
{"sb_v_double_arrow", 116 , 0 },
{"shuttle", 118 , 0 },
{"sizing", 120 , 0 },
{"spider", 122 , 0 },
{"spraycan", 124 , 0 },
{"star", 126 , 0 },
{"target", 128 , 0 },
{"tcross", 130 , 0 },
{"top_left_arrow", 132 , 0 },
{"top_left_corner", 134 , 0 },
{"top_right_corner", 136 , 0 },
{"top_side", 138 , 0 },
{"top_tee", 140 , 0 },
{"trek", 142 , 0 },
{"ul_angle", 144 , 0 },
{"umbrella", 146 , 0 },
{"ur_angle", 148 , 0 },
{"watch", 150 , 0 },
{"xterm", 152 , 0 },
};
struct _CursorName *cache;
char *name = (char *)fromVal->addr;
register int i;
Screen *screen;
if (*num_args != 1)
XtErrorMsg("wrongParameters","cvtStringToCursor","XtToolkitError",
"String to cursor conversion needs screen argument",
(String *)0 , (Cardinal *)0 );
screen = *((Screen **) args[0].addr);
for (i=0, cache=cursor_names; i < ((Cardinal) (sizeof(cursor_names) / sizeof(cursor_names[0]))) ; i++, cache++ ) {
if (strcmp(name, cache->name) == 0) {
if (!cache->cursor)
cache->cursor =
XCreateFontCursor(((screen)->display) , cache->shape );
{ (*toVal).size = sizeof( Cursor); (*toVal).addr = (caddr_t) &(cache->cursor); } ;
return;
}
}
XtStringConversionWarning(name, "Cursor");
};
static void CvtStringToDisplay(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static Display *d;
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtStringToDisplay","XtToolkitError",
"String to Display conversion needs no extra arguments",
(String *)0 , (Cardinal *)0 );
d = XOpenDisplay((char *)fromVal->addr);
if (d != 0 ) {
{ (*toVal).size = sizeof( Display); (*toVal).addr = (caddr_t) &d; } ;
} else {
XtStringConversionWarning((char *) fromVal->addr, "Display");
}
};
static void CvtStringToFile(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static struct _iobuf *f;
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtStringToFile","XtToolkitError",
"String to File conversion needs no extra arguments",
(String *) 0 , (Cardinal *)0 );
f = fopen((char *)fromVal->addr, "r");
if (f != 0 ) {
{ (*toVal).size = sizeof( struct _iobuf ); (*toVal).addr = (caddr_t) &f; } ;
} else {
XtStringConversionWarning((char *) fromVal->addr, "File");
}
};
static void CvtStringToFont(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static Font f;
Screen *screen;
Display *display;
char lcfont[1000];
XrmQuark q;
if (*num_args != 1)
XtErrorMsg("wrongParameters","cvtStringToFont","XtToolkitError",
"String to font conversion needs screen argument",
(String *) 0 , (Cardinal *)0 );
screen = *((Screen **) args[0].addr);
LowerCase((char *) fromVal->addr, lcfont);
q = XrmStringToQuark(lcfont);
if (q != XtQExtdefaultfont) {
f = XLoadFont(((screen)->display) , (char *)fromVal->addr);
if (f != 0) {
{ (*toVal).size = sizeof( Font); (*toVal).addr = (caddr_t) &f; } ;
return;
}
XtStringConversionWarning((char *) fromVal->addr, "Font");
}
display = ((screen)->display) ;
f = XLoadFont(display,"fixed");
if (f != 0) { (*toVal).size = sizeof( Font); (*toVal).addr = (caddr_t) &f; } ;
}
static void CvtIntToFont(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtIntToFont","XtToolkitError",
"Integer to Font conversion needs no extra arguments",
(String *) 0 , (Cardinal *)0 );
{ (*toVal).size = sizeof( int); (*toVal).addr = (caddr_t) fromVal->addr; } ;
};
static void CvtStringToFontStruct(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static XFontStruct *f;
Screen *screen;
char lcfont[1000];
XrmQuark q;
if (*num_args != 1)
XtErrorMsg("wrongParameters","cvtStringToFontStruct","XtToolkitError",
"String to cursor conversion needs screen argument",
(String *) 0 , (Cardinal *)0 );
screen = *((Screen **) args[0].addr);
LowerCase((char *) fromVal->addr, lcfont);
q = XrmStringToQuark(lcfont);
if (q != XtQExtdefaultfont) {
f = XLoadQueryFont(((screen)->display) , (char *)fromVal->addr);
if (f != 0 ) {
{ (*toVal).size = sizeof( XFontStruct *); (*toVal).addr = (caddr_t) &f; } ;
return;
}
XtStringConversionWarning((char *) fromVal->addr, "XFontStruct");
}
f = XLoadQueryFont(((screen)->display) , "fixed");
if (f != 0) { (*toVal).size = sizeof( XFontStruct *); (*toVal).addr = (caddr_t) &f; } ;
}
static void CvtStringToInt(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static int i;
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtStringToInt","XtToolkitError",
"String to Integer conversion needs no extra arguments",
(String *) 0 , (Cardinal *)0 );
if (sscanf((char *)fromVal->addr, "%d", &i) == 1) {
{ (*toVal).size = sizeof( int); (*toVal).addr = (caddr_t) &i; } ;
} else {
XtStringConversionWarning((char *) fromVal->addr, "Integer");
}
}
static void CvtStringToShort(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static short i;
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtStringToShort","XtToolkitError",
"String to Integer conversion needs no extra arguments",
(String *) 0 , (Cardinal *)0 );
if (sscanf((char *)fromVal->addr, "%hd", &i) == 1) {
{ (*toVal).size = sizeof( short); (*toVal).addr = (caddr_t) &i; } ;
} else {
XtStringConversionWarning((char *) fromVal->addr, "Short");
}
}
static void CvtStringToUnsignedChar(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
static int i;
static unsigned char uc;
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtStringToUnsignedChar","XtToolkitError",
"String to Integer conversion needs no extra arguments",
(String *) 0 , (Cardinal *)0 );
if (sscanf((char *)fromVal->addr, "%d", &i) == 1) {
if ( i < 0 || i > 255 )
XtStringConversionWarning((char *) fromVal->addr, "Unsigned Char");
uc = (unsigned char)i;
{ (*toVal).size = sizeof( unsigned char); (*toVal).addr = (caddr_t) &uc; } ;
} else {
XtStringConversionWarning((char *) fromVal->addr, "Unsigned Char");
}
}
static void CvtXColorToPixel(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtXColorToPixel","XtToolkitError",
"Color to Pixel conversion needs no extra arguments",
(String *) 0 , (Cardinal *)0 );
{ (*toVal).size = sizeof( int); (*toVal).addr = (caddr_t) &((XColor *)fromVal->addr)->pixel; } ;
};
static void CvtIntToPixel(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtIntToPixel","XtToolkitError",
"Integer to Pixel conversion needs no extra arguments",
(String *) 0 , (Cardinal *)0 );
{ (*toVal).size = sizeof( int); (*toVal).addr = (caddr_t) fromVal->addr; } ;
};
static void CvtIntToPixmap(args, num_args, fromVal, toVal)
XrmValuePtr args;
Cardinal *num_args;
XrmValuePtr fromVal;
XrmValuePtr toVal;
{
if (*num_args != 0)
XtWarningMsg("wrongParameters","cvtIntToPixmap","XtToolkitError",
"Integer to Pixmap conversion needs no extra arguments",
(String *) 0 , (Cardinal *)0 );
{ (*toVal).size = sizeof( int); (*toVal).addr = (caddr_t) fromVal->addr; } ;
};
void LowerCase(source, dest)
register char *source, *dest;
{
register char ch;
for (; (ch = *source) != 0; source++, dest++) {
if ('A' <= ch && ch <= 'Z')
*dest = ch - 'A' + 'a';
else
*dest = ch;
}
*dest = 0;
}
XrmQuark XtQBoolean;
XrmQuark XtQBool;
XrmQuark XtQColor;
XrmQuark XtQCursor;
XrmQuark XtQDisplay;
XrmQuark XtQDimension;
XrmQuark XtQFile;
XrmQuark XtQFont;
XrmQuark XtQFontStruct;
XrmQuark XtQInt;
XrmQuark XtQPixel;
XrmQuark XtQPixmap;
XrmQuark XtQPointer;
XrmQuark XtQPosition;
XrmQuark XtQShort;
XrmQuark XtQString;
XrmQuark XtQUnsignedChar;
XrmQuark XtQWindow;
XrmQuark XtQEoff;
XrmQuark XtQEfalse;
XrmQuark XtQEno;
XrmQuark XtQEon;
XrmQuark XtQEtrue;
XrmQuark XtQEyes;
XrmQuark XtQEnotUseful;
XrmQuark XtQEwhenMapped;
XrmQuark XtQEalways;
XrmQuark XtQEdefault;
XrmQuark XtQExtdefaultbackground;
XrmQuark XtQExtdefaultforeground;
XrmQuark XtQExtdefaultfont;
static Boolean initialized = 0 ;
void _XtConvertInitialize()
{
if (initialized) return;
initialized = 1 ;
XtQBoolean = XrmStringToQuark( "Boolean" );
XtQColor = XrmStringToQuark( "Color" );
XtQCursor = XrmStringToQuark( "Cursor" );
XtQDimension = XrmStringToQuark( "Dimension" );
XtQDisplay = XrmStringToQuark( "Display" );
XtQFile = XrmStringToQuark( "File" );
XtQFont = XrmStringToQuark( "Font" );
XtQFontStruct = XrmStringToQuark( "FontStruct" );
XtQInt = XrmStringToQuark( "Int" );
XtQBool = XrmStringToQuark( "Bool" );
XtQPixel = XrmStringToQuark( "Pixel" );
XtQPixmap = XrmStringToQuark( "Pixmap" );
XtQPointer = XrmStringToQuark( "Pointer" );
XtQPosition = XrmStringToQuark( "Position" );
XtQShort = XrmStringToQuark( "Short" );
XtQString = XrmStringToQuark( "String" );
XtQUnsignedChar = XrmStringToQuark( "UnsignedChar" );
XtQWindow = XrmStringToQuark( "Window" );
XtQEfalse = XrmStringToQuark( "false" );
XtQEno = XrmStringToQuark( "no" );
XtQEoff = XrmStringToQuark( "off" );
XtQEon = XrmStringToQuark( "on" );
XtQEtrue = XrmStringToQuark( "true" );
XtQEyes = XrmStringToQuark( "yes" );
XtQExtdefaultbackground = XrmStringToQuark( "xtdefaultbackground" );
XtQExtdefaultforeground = XrmStringToQuark( "xtdefaultforeground" );
XtQExtdefaultfont = XrmStringToQuark("xtdefaultfont" );
}
_XtAddDefaultConverters(table)
ConverterTable table;
{
_XtTableAddConverter(table, XtQColor, XtQPixel, (XtConverter) CvtXColorToPixel, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQInt, XtQBoolean, (XtConverter) CvtIntToBoolean, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQInt, XtQBool, (XtConverter) CvtIntToBool, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQInt, XtQDimension, (XtConverter) CvtIntToShort, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQInt, XtQPixel, (XtConverter) CvtIntToPixel, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQInt, XtQPosition, (XtConverter) CvtIntToShort, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQInt, XtQPixmap, (XtConverter) CvtIntToPixmap, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQInt, XtQFont, (XtConverter) CvtIntToFont, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQInt, XtQColor, (XtConverter) CvtIntOrPixelToXColor, (XtConvertArgList)
colorConvertArgs, ((Cardinal) (sizeof(colorConvertArgs) / sizeof(colorConvertArgs[0]))) ) ;
_XtTableAddConverter(table, XtQString, XtQBoolean, (XtConverter) CvtStringToBoolean, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQString, XtQBool, (XtConverter) CvtStringToBool, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQString, XtQCursor, (XtConverter) CvtStringToCursor, (XtConvertArgList)
screenConvertArg, ((Cardinal) (sizeof(screenConvertArg) / sizeof(screenConvertArg[0]))) ) ;
_XtTableAddConverter(table, XtQString, XtQDimension, (XtConverter) CvtStringToShort, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQString, XtQDisplay, (XtConverter) CvtStringToDisplay, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQString, XtQFile, (XtConverter) CvtStringToFile, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQString, XtQFont, (XtConverter) CvtStringToFont, (XtConvertArgList)
screenConvertArg, ((Cardinal) (sizeof(screenConvertArg) / sizeof(screenConvertArg[0]))) ) ;
_XtTableAddConverter(table, XtQString, XtQFontStruct, (XtConverter) CvtStringToFontStruct, (XtConvertArgList)
screenConvertArg, ((Cardinal) (sizeof(screenConvertArg) / sizeof(screenConvertArg[0]))) ) ;
_XtTableAddConverter(table, XtQString, XtQInt, (XtConverter) CvtStringToInt, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQString, XtQPosition, (XtConverter) CvtStringToShort, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQString, XtQPixel, (XtConverter) CvtStringToPixel, (XtConvertArgList)
colorConvertArgs, ((Cardinal) (sizeof(colorConvertArgs) / sizeof(colorConvertArgs[0]))) ) ;
_XtTableAddConverter(table, XtQString, XtQShort, (XtConverter) CvtStringToShort, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQString, XtQUnsignedChar, (XtConverter) CvtStringToUnsignedChar, (XtConvertArgList) 0 , 0) ;
_XtTableAddConverter(table, XtQPixel, XtQColor, (XtConverter) CvtIntOrPixelToXColor, (XtConvertArgList)
colorConvertArgs, ((Cardinal) (sizeof(colorConvertArgs) / sizeof(colorConvertArgs[0]))) ) ;
_XtAddTMConverters(table);
}
------------------------------------------------------------------------------