home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / lib / Xt / TMparse.c.orig < prev    next >
Encoding:
Text File  |  1993-07-21  |  54.5 KB  |  2,048 lines
  1. /* $XConsortium: TMparse.c,v 1.128 92/03/05 18:48:55 converse Exp $ */
  2.  
  3. /***********************************************************
  4. Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
  5. and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
  6.  
  7.                         All Rights Reserved
  8.  
  9. Permission to use, copy, modify, and distribute this software and its 
  10. documentation for any purpose and without fee is hereby granted, 
  11. provided that the above copyright notice appear in all copies and that
  12. both that copyright notice and this permission notice appear in 
  13. supporting documentation, and that the names of Digital or MIT not be
  14. used in advertising or publicity pertaining to distribution of the
  15. software without specific, written prior permission.  
  16.  
  17. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  18. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  19. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  20. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  21. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  22. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  23. SOFTWARE.
  24.  
  25. ******************************************************************/
  26.  
  27. #include "IntrinsicI.h"
  28. #include "StringDefs.h"
  29. #include <ctype.h>
  30. #ifndef NOTASCII
  31. #define XK_LATIN1
  32. #endif
  33. #define XK_MISCELLANY
  34. #include <X11/keysymdef.h>
  35.  
  36. #ifdef CACHE_TRANSLATIONS
  37. # ifdef REFCNT_TRANSLATIONS
  38. #  define CACHED XtCacheAll | XtCacheRefCount
  39. # else
  40. #  define CACHED XtCacheAll
  41. # endif
  42. #else
  43. # define CACHED XtCacheNone
  44. #endif
  45.  
  46. static String XtNtranslationParseError = "translationParseError";
  47.  
  48. typedef int        EventType;
  49.  
  50. typedef String (*ParseProc)(); /* str, closure, event ,error */
  51.     /* String str; */
  52.     /* Opaque closure; */
  53.     /* EventPtr event; */
  54.     /* Boolean* error */
  55.  
  56. typedef void (*ModifierProc)(); 
  57. typedef TMShortCard    Value;
  58.  
  59. typedef struct _ModifierRec {
  60.     char*      name;
  61.     XrmQuark   signature;
  62.     ModifierProc modifierParseProc;
  63.     Value      value;
  64. } ModifierRec, *ModifierKeys;
  65.  
  66. typedef struct _EventKey {
  67.     char        *event;
  68.     XrmQuark    signature;
  69.     EventType    eventType;
  70.     ParseProc    parseDetail;
  71.     Opaque    closure;
  72. }EventKey, *EventKeys;
  73.  
  74. typedef struct {
  75.     char    *name;
  76.     XrmQuark    signature;
  77.     Value    value;
  78. } NameValueRec, *NameValueTable;
  79.  
  80. static void ParseModImmed();
  81. static void ParseModSym();
  82. static String PanicModeRecovery();
  83. static String CheckForPoundSign();
  84. static KeySym StringToKeySym();
  85. static ModifierRec modifiers[] = {
  86.     {"None",    0,      ParseModImmed,None},
  87.     {"Shift",    0,    ParseModImmed,ShiftMask},
  88.     {"Lock",    0,    ParseModImmed,LockMask},
  89.     {"Ctrl",    0,    ParseModImmed,ControlMask},
  90.     {"Mod1",    0,    ParseModImmed,Mod1Mask},
  91.     {"Mod2",    0,    ParseModImmed,Mod2Mask},
  92.     {"Mod3",    0,    ParseModImmed,Mod3Mask},
  93.     {"Mod4",    0,    ParseModImmed,Mod4Mask},
  94.     {"Mod5",    0,    ParseModImmed,Mod5Mask},
  95.     {"Meta",    0,    ParseModSym,  XK_Meta_L},
  96.     {"m",       0,      ParseModSym,  XK_Meta_L},
  97.     {"h",       0,      ParseModSym,  XK_Hyper_L},
  98.     {"su",      0,      ParseModSym,  XK_Super_L},
  99.     {"a",       0,      ParseModSym,  XK_Alt_L},
  100.     {"Hyper",   0,      ParseModSym,  XK_Hyper_L},
  101.     {"Super",   0,      ParseModSym,  XK_Super_L},
  102.     {"Alt",     0,      ParseModSym,  XK_Alt_L},
  103.     {"Button1",    0,    ParseModImmed,Button1Mask},
  104.     {"Button2",    0,    ParseModImmed,Button2Mask},
  105.     {"Button3",    0,    ParseModImmed,Button3Mask},
  106.     {"Button4",    0,    ParseModImmed,Button4Mask},
  107.     {"Button5",    0,    ParseModImmed,Button5Mask},
  108.  
  109.     {"Any",    0,    ParseModImmed,AnyModifier},
  110.  
  111.     {"c",    0,    ParseModImmed,ControlMask},
  112.     {"s",    0,    ParseModImmed,ShiftMask},
  113.     {"l",    0,    ParseModImmed,LockMask},
  114. };
  115.  
  116. static NameValueRec buttonNames[] = {
  117.     {"Button1",    0,    Button1},
  118.     {"Button2", 0,    Button2},
  119.     {"Button3", 0,    Button3},
  120.     {"Button4", 0,    Button4},
  121.     {"Button5", 0,    Button5},
  122.     {NULL, NULLQUARK, 0},
  123. };
  124.  
  125. static NameValueRec motionDetails[] = {
  126.     {"Normal",        0,    NotifyNormal},
  127.     {"Hint",        0,    NotifyHint},
  128.     {NULL, NULLQUARK, 0},
  129. };
  130.  
  131. static NameValueRec notifyModes[] = {
  132.     {"Normal",        0,    NotifyNormal},
  133.     {"Grab",        0,    NotifyGrab},
  134.     {"Ungrab",        0,    NotifyUngrab},
  135.     {"WhileGrabbed",    0,    NotifyWhileGrabbed},
  136.     {NULL, NULLQUARK, 0},
  137. };
  138.  
  139. #if 0
  140. static NameValueRec notifyDetail[] = {
  141.     {"Ancestor",        0,    NotifyAncestor},
  142.     {"Virtual",            0,    NotifyVirtual},
  143.     {"Inferior",        0,    NotifyInferior},
  144.     {"Nonlinear",        0,    NotifyNonlinear},
  145.     {"NonlinearVirtual",    0,    NotifyNonlinearVirtual},
  146.     {"Pointer",            0,    NotifyPointer},
  147.     {"PointerRoot",        0,    NotifyPointerRoot},
  148.     {"DetailNone",        0,    NotifyDetailNone},
  149.     {NULL, NULLQUARK, 0},
  150. };
  151.  
  152. static NameValueRec visibilityNotify[] = {
  153.     {"Unobscured",        0,    VisibilityUnobscured},
  154.     {"PartiallyObscured",   0,    VisibilityPartiallyObscured},
  155.     {"FullyObscured",       0,    VisibilityFullyObscured},
  156.     {NULL, NULLQUARK, 0},
  157. };
  158.  
  159. static NameValueRec circulation[] = {
  160.     {"OnTop",       0,    PlaceOnTop},
  161.     {"OnBottom",    0,    PlaceOnBottom},
  162.     {NULL, NULLQUARK, 0},
  163. };
  164.  
  165. static NameValueRec propertyChanged[] = {
  166.     {"NewValue",    0,    PropertyNewValue},
  167.     {"Delete",      0,    PropertyDelete},
  168.     {NULL, NULLQUARK, 0},
  169. };
  170. #endif /*0*/
  171.  
  172. static NameValueRec mappingNotify[] = {
  173.     {"Modifier",    0,    MappingModifier},
  174.     {"Keyboard",    0,    MappingKeyboard},
  175.     {"Pointer",    0,    MappingPointer},
  176.     {NULL, NULLQUARK, 0},
  177. };
  178.  
  179. static String ParseKeySym();
  180. static String ParseKeyAndModifiers();
  181. static String ParseTable();
  182. static String ParseImmed();
  183. static String ParseAddModifier();
  184. static String ParseNone();
  185. static String ParseAtom();
  186.  
  187. static EventKey events[] = {
  188.  
  189. /* Event Name,      Quark, Event Type,    Detail Parser, Closure */
  190.  
  191. {"KeyPress",        NULLQUARK, KeyPress,    ParseKeySym,    NULL},
  192. {"Key",         NULLQUARK, KeyPress,    ParseKeySym,    NULL},
  193. {"KeyDown",        NULLQUARK, KeyPress,    ParseKeySym,    NULL},
  194. {"Ctrl",            NULLQUARK, KeyPress, ParseKeyAndModifiers,(Opaque)ControlMask},
  195. {"Shift",           NULLQUARK, KeyPress, ParseKeyAndModifiers,(Opaque)ShiftMask},
  196. {"Meta",            NULLQUARK, KeyPress,   ParseKeyAndModifiers,(Opaque)NULL},
  197. {"KeyUp",        NULLQUARK, KeyRelease,    ParseKeySym,    NULL},
  198. {"KeyRelease",        NULLQUARK, KeyRelease,    ParseKeySym,    NULL},
  199.  
  200. {"ButtonPress",     NULLQUARK, ButtonPress,  ParseTable,(Opaque)buttonNames},
  201. {"BtnDown",        NULLQUARK, ButtonPress,  ParseTable,(Opaque)buttonNames},
  202. {"Btn1Down",        NULLQUARK, ButtonPress,    ParseImmed,(Opaque)Button1},
  203. {"Btn2Down",         NULLQUARK, ButtonPress,    ParseImmed,(Opaque)Button2},
  204. {"Btn3Down",         NULLQUARK, ButtonPress,    ParseImmed,(Opaque)Button3},
  205. {"Btn4Down",         NULLQUARK, ButtonPress,    ParseImmed,(Opaque)Button4},
  206. {"Btn5Down",         NULLQUARK, ButtonPress,    ParseImmed,(Opaque)Button5},
  207.  
  208. /* Event Name,      Quark, Event Type,    Detail Parser, Closure */
  209.  
  210. {"ButtonRelease",   NULLQUARK, ButtonRelease,  ParseTable,(Opaque)buttonNames},
  211. {"BtnUp",         NULLQUARK, ButtonRelease,  ParseTable,(Opaque)buttonNames},
  212. {"Btn1Up",         NULLQUARK, ButtonRelease,    ParseImmed,(Opaque)Button1},
  213. {"Btn2Up",         NULLQUARK, ButtonRelease,    ParseImmed,(Opaque)Button2},
  214. {"Btn3Up",         NULLQUARK, ButtonRelease,    ParseImmed,(Opaque)Button3},
  215. {"Btn4Up",         NULLQUARK, ButtonRelease,    ParseImmed,(Opaque)Button4},
  216. {"Btn5Up",         NULLQUARK, ButtonRelease,    ParseImmed,(Opaque)Button5},
  217.  
  218. {"MotionNotify",    NULLQUARK, MotionNotify, ParseTable, (Opaque)motionDetails},
  219. {"PtrMoved",         NULLQUARK, MotionNotify, ParseTable, (Opaque)motionDetails},
  220. {"Motion",         NULLQUARK, MotionNotify, ParseTable, (Opaque)motionDetails},
  221. {"MouseMoved",         NULLQUARK, MotionNotify, ParseTable, (Opaque)motionDetails},
  222. {"BtnMotion",  NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)AnyButtonMask},
  223. {"Btn1Motion", NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)Button1Mask},
  224. {"Btn2Motion", NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)Button2Mask},
  225. {"Btn3Motion", NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)Button3Mask},
  226. {"Btn4Motion", NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)Button4Mask},
  227. {"Btn5Motion", NULLQUARK, MotionNotify, ParseAddModifier, (Opaque)Button5Mask},
  228.  
  229. {"EnterNotify",     NULLQUARK, EnterNotify,    ParseTable,(Opaque)notifyModes},
  230. {"Enter",        NULLQUARK, EnterNotify,    ParseTable,(Opaque)notifyModes},
  231. {"EnterWindow",     NULLQUARK, EnterNotify,    ParseTable,(Opaque)notifyModes},
  232.  
  233. {"LeaveNotify",     NULLQUARK, LeaveNotify,    ParseTable,(Opaque)notifyModes},
  234. {"LeaveWindow",     NULLQUARK, LeaveNotify,    ParseTable,(Opaque)notifyModes},
  235. {"Leave",        NULLQUARK, LeaveNotify,    ParseTable,(Opaque)notifyModes},
  236.  
  237. /* Event Name,      Quark, Event Type,    Detail Parser, Closure */
  238.  
  239. {"FocusIn",        NULLQUARK, FocusIn,      ParseTable,(Opaque)notifyModes},
  240.  
  241. {"FocusOut",        NULLQUARK, FocusOut,       ParseTable,(Opaque)notifyModes},
  242.  
  243. {"KeymapNotify",    NULLQUARK, KeymapNotify,    ParseNone,    NULL},
  244. {"Keymap",        NULLQUARK, KeymapNotify,    ParseNone,    NULL},
  245.  
  246. {"Expose",         NULLQUARK, Expose,        ParseNone,    NULL},
  247.  
  248. {"GraphicsExpose",  NULLQUARK, GraphicsExpose,    ParseNone,    NULL},
  249. {"GrExp",        NULLQUARK, GraphicsExpose,    ParseNone,    NULL},
  250.  
  251. {"NoExpose",        NULLQUARK, NoExpose,    ParseNone,    NULL},
  252. {"NoExp",        NULLQUARK, NoExpose,    ParseNone,    NULL},
  253.  
  254. {"VisibilityNotify",NULLQUARK, VisibilityNotify,ParseNone,    NULL},
  255. {"Visible",        NULLQUARK, VisibilityNotify,ParseNone,    NULL},
  256.  
  257. {"CreateNotify",    NULLQUARK, CreateNotify,    ParseNone,    NULL},
  258. {"Create",        NULLQUARK, CreateNotify,    ParseNone,    NULL},
  259.  
  260. /* Event Name,      Quark, Event Type,    Detail Parser, Closure */
  261.  
  262. {"DestroyNotify",   NULLQUARK, DestroyNotify,    ParseNone,    NULL},
  263. {"Destroy",        NULLQUARK, DestroyNotify,    ParseNone,    NULL},
  264.  
  265. {"UnmapNotify",     NULLQUARK, UnmapNotify,    ParseNone,    NULL},
  266. {"Unmap",        NULLQUARK, UnmapNotify,    ParseNone,    NULL},
  267.  
  268. {"MapNotify",        NULLQUARK, MapNotify,    ParseNone,    NULL},
  269. {"Map",            NULLQUARK, MapNotify,    ParseNone,    NULL},
  270.  
  271. {"MapRequest",        NULLQUARK, MapRequest,    ParseNone,    NULL},
  272. {"MapReq",        NULLQUARK, MapRequest,    ParseNone,    NULL},
  273.  
  274. {"ReparentNotify",  NULLQUARK, ReparentNotify,    ParseNone,    NULL},
  275. {"Reparent",        NULLQUARK, ReparentNotify,    ParseNone,    NULL},
  276.  
  277. {"ConfigureNotify", NULLQUARK, ConfigureNotify,    ParseNone,    NULL},
  278. {"Configure",        NULLQUARK, ConfigureNotify,    ParseNone,    NULL},
  279.  
  280. {"ConfigureRequest",NULLQUARK, ConfigureRequest,ParseNone,    NULL},
  281. {"ConfigureReq",    NULLQUARK, ConfigureRequest,ParseNone,    NULL},
  282.  
  283. /* Event Name,      Quark, Event Type,    Detail Parser, Closure */
  284.  
  285. {"GravityNotify",   NULLQUARK, GravityNotify,    ParseNone,    NULL},
  286. {"Grav",        NULLQUARK, GravityNotify,    ParseNone,    NULL},
  287.  
  288. {"ResizeRequest",   NULLQUARK, ResizeRequest,    ParseNone,    NULL},
  289. {"ResReq",        NULLQUARK, ResizeRequest,    ParseNone,    NULL},
  290.  
  291. {"CirculateNotify", NULLQUARK, CirculateNotify,    ParseNone,    NULL},
  292. {"Circ",        NULLQUARK, CirculateNotify,    ParseNone,    NULL},
  293.  
  294. {"CirculateRequest",NULLQUARK, CirculateRequest,ParseNone,    NULL},
  295. {"CircReq",        NULLQUARK, CirculateRequest,ParseNone,    NULL},
  296.  
  297. {"PropertyNotify",  NULLQUARK, PropertyNotify,    ParseAtom,    NULL},
  298. {"Prop",        NULLQUARK, PropertyNotify,    ParseAtom,    NULL},
  299.  
  300. {"SelectionClear",  NULLQUARK, SelectionClear,    ParseAtom,    NULL},
  301. {"SelClr",        NULLQUARK, SelectionClear,    ParseAtom,    NULL},
  302.  
  303. {"SelectionRequest",NULLQUARK, SelectionRequest,ParseAtom,    NULL},
  304. {"SelReq",        NULLQUARK, SelectionRequest,ParseAtom,    NULL},
  305.  
  306. /* Event Name,      Quark, Event Type,    Detail Parser, Closure */
  307.  
  308. {"SelectionNotify", NULLQUARK, SelectionNotify,    ParseAtom,    NULL},
  309. {"Select",        NULLQUARK, SelectionNotify,    ParseAtom,    NULL},
  310.  
  311. {"ColormapNotify",  NULLQUARK, ColormapNotify,    ParseNone,    NULL},
  312. {"Clrmap",        NULLQUARK, ColormapNotify,    ParseNone,    NULL},
  313.  
  314. {"ClientMessage",   NULLQUARK, ClientMessage,    ParseAtom,    NULL},
  315. {"Message",        NULLQUARK, ClientMessage,    ParseAtom,    NULL},
  316.  
  317. {"MappingNotify",   NULLQUARK, MappingNotify, ParseTable, (Opaque)mappingNotify},
  318. {"Mapping",        NULLQUARK, MappingNotify, ParseTable, (Opaque)mappingNotify},
  319.  
  320. #ifdef DEBUG
  321. # ifdef notdef
  322. {"Timer",        NULLQUARK, _XtTimerEventType,ParseNone,    NULL},
  323. # endif /* notdef */
  324. {"EventTimer",        NULLQUARK, _XtEventTimerEventType,ParseNone,NULL},
  325. #endif /* DEBUG */
  326.  
  327. /* Event Name,      Quark, Event Type,    Detail Parser, Closure */
  328.  
  329. };
  330.  
  331.  
  332. #define ScanFor(str, ch) \
  333.     while ((*(str) != (ch)) && (*(str) != '\0') && (*(str) != '\n')) (str)++
  334.  
  335. #define ScanNumeric(str)  while ('0' <= *(str) && *(str) <= '9') (str)++
  336.  
  337. #define ScanAlphanumeric(str) \
  338.     while (('A' <= *(str) && *(str) <= 'Z') || \
  339.            ('a' <= *(str) && *(str) <= 'z') || \
  340.            ('0' <= *(str) && *(str) <= '9')) (str)++
  341.  
  342. #define ScanWhitespace(str) \
  343.     while (*(str) == ' ' || *(str) == '\t') (str)++
  344.  
  345.  
  346. static Boolean initialized = FALSE;
  347.  
  348. static void FreeEventSeq(eventSeq)
  349.     EventSeqPtr eventSeq;
  350. {
  351.     register EventSeqPtr evs = eventSeq;
  352.  
  353.     while (evs != NULL) {
  354.     evs->state = (StatePtr) evs;
  355.     if (evs->next != NULL
  356.         && evs->next->state == (StatePtr) evs->next)
  357.         evs->next = NULL;
  358.     evs = evs->next;
  359.     }
  360.  
  361.     evs = eventSeq;
  362.     while (evs != NULL) {
  363.     register EventPtr event = evs;
  364.     evs = evs->next;
  365.     if (evs == event) evs = NULL;
  366.     XtFree((char *)event);
  367.     }
  368. }
  369.  
  370. static void CompileNameValueTable(table)
  371.     NameValueTable table;
  372. {
  373.     register int i;
  374.  
  375.     for (i=0; table[i].name; i++)
  376.         table[i].signature = XrmPermStringToQuark(table[i].name);
  377. }
  378.  
  379. static int OrderEvents(a, b)
  380.     EventKey    *a, *b;
  381. {
  382.     return ((a->signature < b->signature) ? -1 : 1);
  383. }
  384.  
  385. static void Compile_XtEventTable(table, count)
  386.     EventKeys    table;
  387.     Cardinal    count;
  388. {
  389.     register int i;
  390.     register EventKeys entry = table;
  391.  
  392.     for (i=count; --i >= 0; entry++)
  393.     entry->signature = XrmPermStringToQuark(entry->event);
  394.     qsort(table, count, sizeof(EventKey), OrderEvents);
  395. }
  396.  
  397. static int OrderModifiers(a, b)
  398.     ModifierRec *a, *b;
  399. {
  400.     return ((a->signature < b->signature) ? -1 : 1);
  401. }
  402.  
  403. static void Compile_XtModifierTable(table, count)
  404.     ModifierKeys table;
  405.     Cardinal count;
  406. {
  407.     register int i;
  408.     register ModifierKeys entry = table;
  409.  
  410.     for (i=count; --i >= 0; entry++)
  411.     entry->signature = XrmPermStringToQuark(entry->name);
  412.     qsort(table, count, sizeof(ModifierRec), OrderModifiers);
  413. }
  414.  
  415. static String PanicModeRecovery(str)
  416.     String str;
  417. {
  418.      ScanFor(str,'\n');
  419.      if (*str == '\n') str++;
  420.      return str;
  421.  
  422. }
  423.  
  424.  
  425. static Syntax(str,str1)
  426.     String str,str1;
  427. {
  428.     Cardinal numChars;
  429.     Cardinal num_params = 1;
  430.     String params[1];
  431.     char message[1000];
  432.  
  433.     (void)strcpy(message,str);
  434.     numChars = strlen(message);
  435.     (void) strcpy(&message[numChars], str1);
  436.     numChars += strlen(str1);
  437.     message[numChars] = '\0';
  438.     params[0] = message;
  439.     XtWarningMsg(XtNtranslationParseError,"parseError",XtCXtToolkitError,
  440.          "translation table syntax error: %s",params,&num_params);
  441. }
  442.  
  443.  
  444.  
  445. static Cardinal LookupTMEventType(eventStr,error)
  446.   String eventStr;
  447.   Boolean *error;
  448. {
  449.     register int   i, left, right;
  450.     register XrmQuark    signature;
  451.     static int     previous = 0;
  452.  
  453.     if ((signature = StringToQuark(eventStr)) == events[previous].signature)
  454.     return (Cardinal) previous;
  455.  
  456.     left = 0;
  457.     right = XtNumber(events) - 1;
  458.     while (left <= right) {
  459.     i = (left + right) >> 1;
  460.     if (signature < events[i].signature)
  461.         right = i - 1;
  462.     else if (signature > events[i].signature)
  463.         left = i + 1;
  464.     else {
  465.         previous = i;
  466.         return (Cardinal) i;
  467.     }
  468.     }
  469.  
  470.     Syntax("Unknown event type :  ",eventStr);
  471.     *error = TRUE;
  472.     return (Cardinal) i;
  473. }
  474.  
  475. /***********************************************************************
  476.  * _XtLookupTableSym
  477.  * Given a table and string, it fills in the value if found and returns
  478.  * status
  479.  ***********************************************************************/
  480.  
  481. static Boolean _XtLookupTableSym(table, name, valueP)
  482.     NameValueTable    table;
  483.     String name;
  484.     Value *valueP;
  485. {
  486. /* ||| should implement via hash or something else faster than linear search */
  487.  
  488.     register int i;
  489.     register XrmQuark signature = StringToQuark(name);
  490.  
  491.     for (i=0; table[i].name != NULL; i++)
  492.     if (table[i].signature == signature) {
  493.         *valueP = table[i].value;
  494.         return TRUE;
  495.     }
  496.  
  497.     return FALSE;
  498. }
  499.  
  500.  
  501.  
  502.  
  503. static void StoreLateBindings(keysymL,notL,keysymR,notR,lateBindings)
  504.  
  505.     KeySym  keysymL;
  506.     Boolean notL;
  507.     KeySym keysymR;
  508.     Boolean notR;
  509.     LateBindingsPtr* lateBindings;
  510. {
  511.     LateBindingsPtr temp;
  512.     Boolean pair = FALSE;
  513.     unsigned long count,number;
  514.     if (lateBindings != NULL){
  515.         temp = *lateBindings;
  516.         if (temp != NULL) {
  517.             for (count = 0; temp[count].keysym; count++){/*EMPTY*/}
  518.         }
  519.         else count = 0;
  520.         if (! keysymR){
  521.              number = 1;pair = FALSE;
  522.         } else{
  523.              number = 2;pair = TRUE;
  524.         }
  525.           
  526.         temp = (LateBindingsPtr)XtRealloc((char *)temp,
  527.             (unsigned)((count+number+1) * sizeof(LateBindings)) );
  528.         *lateBindings = temp;
  529.         temp[count].knot = notL;
  530.         temp[count].pair = pair;
  531.     if (count == 0)
  532.         temp[count].ref_count = 1;
  533.         temp[count++].keysym = keysymL;
  534.         if (keysymR){
  535.             temp[count].knot = notR;
  536.             temp[count].pair = FALSE;
  537.             temp[count++].keysym = keysymR;
  538.         }
  539.         temp[count].knot = FALSE;
  540.         temp[count].keysym = 0;
  541.     }
  542. } 
  543.  
  544. static _XtParseKeysymMod(name,lateBindings,notFlag,valueP,error)
  545.     String name;
  546.     LateBindingsPtr* lateBindings;
  547.     Boolean notFlag;
  548.     Value *valueP;
  549.     Boolean *error;
  550. {
  551.     KeySym keySym;
  552.     keySym = StringToKeySym(name, error);
  553.     *valueP = 0;
  554.     if (keySym != NoSymbol) {
  555.         StoreLateBindings(keySym,notFlag,(KeySym) NULL,FALSE,lateBindings);
  556.     }
  557. }
  558.  
  559. static Boolean _XtLookupModifier(name,lateBindings,notFlag,valueP,constMask)
  560.     String name;
  561.     LateBindingsPtr* lateBindings;
  562.     Boolean notFlag;
  563.     Value *valueP;
  564.     Bool constMask;
  565. {
  566.    register int i, left, right;
  567.    register XrmQuark signature = StringToQuark(name);
  568.    static int previous = 0;
  569.    
  570.    if (signature == modifiers[previous].signature) {
  571.        if (constMask)  *valueP = modifiers[previous].value;
  572.        else /* if (modifiers[previous].modifierParseProc) always true */
  573.        (*modifiers[previous].modifierParseProc)
  574.           (name, modifiers[previous].value, lateBindings, notFlag, valueP);
  575.        return TRUE;
  576.    }
  577.  
  578.    left = 0;
  579.    right = XtNumber(modifiers) - 1;
  580.    while (left <= right) {
  581.        i = (left + right) >> 1;
  582.        if (signature < modifiers[i].signature)
  583.        right = i - 1;
  584.        else if (signature > modifiers[i].signature)
  585.        left = i + 1;
  586.        else {
  587.        previous = i;
  588.        if (constMask)  *valueP = modifiers[i].value;
  589.        else /* if (modifiers[i].modifierParseProc) always true */
  590.            (*modifiers[i].modifierParseProc)
  591.            (name, modifiers[i].value, lateBindings, notFlag, valueP);
  592.        return TRUE;
  593.        }
  594.    }
  595.    return FALSE;
  596. }
  597.  
  598.  
  599. static String ScanIdent(str)
  600.     register String str;
  601. {
  602.     ScanAlphanumeric(str);
  603.     while (
  604.        ('A' <= *str && *str <= 'Z')
  605.     || ('a' <= *str && *str <= 'z')
  606.     || ('0' <= *str && *str <= '9')
  607.     || (*str == '-')
  608.     || (*str == '_')
  609.     || (*str == '$')
  610.     ) str++;
  611.     return str;
  612. }
  613.  
  614. static String FetchModifierToken(str,modStr)
  615.     String str,modStr;
  616. {
  617.     String start = str;
  618.     String metaString = "Meta";
  619.     String ctrlString = "Ctrl";
  620.     if (*str == '$') {
  621.         strcpy(modStr,metaString);
  622.         str++;
  623.         return str;
  624.     }
  625.     if (*str == '^') {
  626.         strcpy(modStr,ctrlString);
  627.         str++;
  628.         return str;
  629.     }
  630.     str = ScanIdent(str);
  631.     if (start != str) {
  632.      bcopy(start, modStr, str-start);
  633.           modStr[str-start] = '\0';
  634.           return str;
  635.     }
  636.     return str;
  637. }        
  638.     
  639. static String ParseModifiers(str, event,error)
  640.     register String str;
  641.     EventPtr event;
  642.     Boolean* error;
  643. {
  644.     register String start;
  645.     Boolean notFlag, exclusive, keysymAsMod;
  646.     Value maskBit;
  647.     char modStr[100];
  648.  
  649.     ScanWhitespace(str);
  650.     start = str;
  651.     str = FetchModifierToken(str,modStr);
  652.     exclusive = FALSE;
  653.     if (start != str) {
  654.           if (_XtLookupModifier(modStr,(LateBindingsPtr *) NULL,
  655.           FALSE,&maskBit,TRUE)) {
  656.           if (maskBit== None) {
  657.           event->event.modifierMask = ~0;
  658.           event->event.modifiers = 0;
  659.           ScanWhitespace(str);
  660.           return str;
  661.           }
  662.           if (maskBit == AnyModifier) {/*backward compatability*/
  663.           event->event.modifierMask = 0;
  664.           event->event.modifiers = 0;
  665.           ScanWhitespace(str);
  666.           return str;
  667.           }
  668.       }
  669.       str = start; /*if plain modifier, reset to beginning */
  670.     }
  671.     else while (*str == '!' || *str == ':') {
  672.         if (*str == '!') {
  673.              exclusive = TRUE;
  674.              str++;
  675.              ScanWhitespace(str);
  676.         }
  677.         if (*str == ':') {
  678.              event->event.standard = TRUE;
  679.              str++;
  680.              ScanWhitespace(str);
  681.         }
  682.     }
  683.    
  684.     while (*str != '<') {
  685.         if (*str == '~') {
  686.              notFlag = TRUE;
  687.              str++;
  688.           } else 
  689.               notFlag = FALSE;
  690.         if (*str == '@') {
  691.             keysymAsMod = TRUE;
  692.             str++;
  693.         }
  694.         else keysymAsMod = FALSE;
  695.     start = str;
  696.         str = FetchModifierToken(str,modStr);
  697.         if (start == str) {
  698.             Syntax("Modifier or '<' expected","");
  699.             *error = TRUE;
  700.             return PanicModeRecovery(str);
  701.         }
  702.          if (keysymAsMod) {
  703.              _XtParseKeysymMod(modStr,&event->event.lateModifiers,
  704.                    notFlag,&maskBit, error);
  705.          if (*error)
  706.                  return PanicModeRecovery(str);
  707.  
  708.          } else
  709.            if (!_XtLookupModifier( modStr,
  710.        &event->event.lateModifiers, notFlag, &maskBit,FALSE)) {
  711.              Syntax("Unknown modifier name:  ",modStr);
  712.                  *error = TRUE;
  713.                  return PanicModeRecovery(str);
  714.              }
  715.         event->event.modifierMask |= maskBit;
  716.     if (notFlag) event->event.modifiers &= ~maskBit;
  717.     else event->event.modifiers |= maskBit;
  718.         ScanWhitespace(str);
  719.     }
  720.     if (exclusive) event->event.modifierMask = ~0;
  721.     return str;
  722. }
  723.  
  724. static String ParseXtEventType(str, event, tmEventP,error)
  725.     register String str;
  726.     EventPtr event;
  727.     Cardinal *tmEventP;
  728.     Boolean* error;
  729. {
  730.     String start = str;
  731.     char eventTypeStr[100];
  732.  
  733.     ScanAlphanumeric(str);
  734.     bcopy(start, eventTypeStr, str-start);
  735.     eventTypeStr[str-start] = '\0';
  736.     *tmEventP = LookupTMEventType(eventTypeStr,error);
  737.     if (*error) 
  738.         return PanicModeRecovery(str);
  739.     event->event.eventType = events[*tmEventP].eventType;
  740.     return str;
  741. }
  742.  
  743. static unsigned long StrToHex(str)
  744.     String str;
  745. {
  746.     register char   c;
  747.     register unsigned long    val = 0;
  748.  
  749.     while (c = *str) {
  750.     if ('0' <= c && c <= '9') val = val*16+c-'0';
  751.     else if ('a' <= c && c <= 'z') val = val*16+c-'a'+10;
  752.     else if ('A' <= c && c <= 'Z') val = val*16+c-'A'+10;
  753.     else return 0;
  754.     str++;
  755.     }
  756.  
  757.     return val;
  758. }
  759.  
  760. static unsigned long StrToOct(str)
  761.     String str;
  762. {
  763.     register char c;
  764.     register unsigned long  val = 0;
  765.  
  766.     while (c = *str) {
  767.         if ('0' <= c && c <= '7') val = val*8+c-'0'; else return 0;
  768.     str++;
  769.     }
  770.  
  771.     return val;
  772. }
  773.  
  774. static unsigned long StrToNum(str)
  775.     String str;
  776. {
  777.     register char c;
  778.     register unsigned long val = 0;
  779.  
  780.     if (*str == '0') {
  781.     str++;
  782.     if (*str == 'x' || *str == 'X') return StrToHex(++str);
  783.     else return StrToOct(str);
  784.     }
  785.  
  786.     while (c = *str) {
  787.     if ('0' <= c && c <= '9') val = val*10+c-'0';
  788.     else return 0;
  789.     str++;
  790.     }
  791.  
  792.     return val;
  793. }
  794.  
  795. static KeySym StringToKeySym(str, error)
  796.     String str;
  797.     Boolean *error;
  798. {
  799.     KeySym k;
  800.  
  801.     if (str == NULL || *str == '\0') return (KeySym) 0;
  802.  
  803. #ifndef NOTASCII
  804.     /* special case single character ASCII, for speed */
  805.     if (*(str+1) == '\0') {
  806.     if (' ' <= *str && *str <= '~') return XK_space + (*str - ' ');
  807.     }
  808. #endif
  809.  
  810.     if ('0' <= *str && *str <= '9') return (KeySym) StrToNum(str);
  811.     k = XStringToKeysym(str);
  812.     if (k != NoSymbol) return k;
  813.  
  814. #ifdef NOTASCII
  815.     /* fall-back case to preserve backwards compatibility; no-one
  816.      * should be relying upon this!
  817.      */
  818.     if (*(str+1) == '\0') return (KeySym) *str;
  819. #endif
  820.  
  821.     Syntax("Unknown keysym name: ", str);
  822.     *error = True;
  823.     return NoSymbol;
  824. }
  825. /* ARGSUSED */
  826. static void ParseModImmed(name,value,lateBindings,notFlag,valueP)
  827.     String name;
  828.     Value value;
  829.     LateBindingsPtr* lateBindings;
  830.     Boolean notFlag;
  831.     Value* valueP;
  832. {
  833.     *valueP = value;
  834. }
  835. /* ARGSUSED */
  836. static void ParseModSym (name,value,lateBindings,notFlag,valueP)
  837.  /* is only valid with keysyms that have an _L and _R in their name;
  838.   * and ignores keysym lookup errors (i.e. assumes only valid keysyms)
  839.   */
  840.     String name;
  841.     Value value;
  842.     LateBindingsPtr* lateBindings;
  843.     Boolean notFlag;
  844.     Value* valueP;
  845. {
  846.     register KeySym keysymL = (KeySym)value;
  847.     register KeySym keysymR = keysymL + 1; /* valid for supported keysyms */
  848.     StoreLateBindings(keysymL,notFlag,keysymR,notFlag,lateBindings);
  849.     *valueP = 0;
  850. }
  851.  
  852. #ifdef sparc
  853. /*
  854.  * The stupid optimizer in SunOS 4.0.3 and below generates bogus code that
  855.  * causes the value of the most recently used variable to be returned instead
  856.  * of the value passed in.
  857.  */
  858. static String stupid_optimizer_kludge;
  859. #define BROKEN_OPTIMIZER_HACK(val) stupid_optimizer_kludge = (val)
  860. #else
  861. #define BROKEN_OPTIMIZER_HACK(val) val
  862. #endif
  863.  
  864. /* ARGSUSED */
  865. static String ParseImmed(str, closure, event,error)
  866.     register String str;
  867.     register Opaque closure;
  868.     register EventPtr event;
  869.     Boolean* error;
  870. {
  871.     event->event.eventCode = (unsigned long)closure;
  872.     event->event.eventCodeMask = (unsigned long)~0L;
  873.  
  874.     return BROKEN_OPTIMIZER_HACK(str);
  875. }
  876.  
  877. /* ARGSUSED */
  878. static String ParseAddModifier(str, closure, event, error)
  879.     register String str;
  880.     register Opaque closure;
  881.     register EventPtr event;
  882.     Boolean* error;
  883. {
  884.     register unsigned long modval = (unsigned long)closure;
  885.     event->event.modifiers |= modval;
  886.     if (modval != AnyButtonMask) /* AnyButtonMask is don't-care mask */
  887.     event->event.modifierMask |= modval;
  888.  
  889.     return BROKEN_OPTIMIZER_HACK(str);
  890. }
  891.  
  892.  
  893. static String ParseKeyAndModifiers(str, closure, event,error)
  894.     String str;
  895.     Opaque closure;
  896.     EventPtr event;
  897.     Boolean* error;
  898. {
  899.     str = ParseKeySym(str, closure, event,error);
  900.  
  901.     event->event.modifiers |= (unsigned long)closure;
  902.     event->event.modifierMask |= (unsigned long)closure;
  903.  
  904.     return str;
  905. }
  906.  
  907. /*ARGSUSED*/
  908. static String ParseKeySym(str, closure, event,error)
  909.     register String str;
  910.     Opaque closure;
  911.     EventPtr event;
  912.     Boolean* error;
  913. {
  914.     char *start;
  915.     char keySymName[100];
  916.  
  917.     ScanWhitespace(str);
  918.  
  919.     if (*str == '\\') {
  920.     str++;
  921.     keySymName[0] = *str;
  922.     if (*str != '\0' && *str != '\n') str++;
  923.     keySymName[1] = '\0';
  924.     event->event.eventCode = StringToKeySym(keySymName, error);
  925.     event->event.eventCodeMask = ~0L;
  926.     } else if (*str == ',' || *str == ':' ||
  927.              /* allow leftparen to be single char symbol,
  928.               * for backwards compatibility
  929.               */
  930.              (*str == '(' && *(str+1) >= '0' && *(str+1) <= '9')) {
  931.     /* no detail */
  932.     event->event.eventCode = 0L;
  933.         event->event.eventCodeMask = 0L;
  934.     } else {
  935.     start = str;
  936.     while (
  937.         *str != ','
  938.         && *str != ':'
  939.         && *str != ' '
  940.         && *str != '\t'
  941.                 && *str != '\n'
  942.                 && (*str != '(' || *(str+1) <= '0' || *(str+1) >= '9')
  943.         && *str != '\0') str++;
  944.     bcopy(start, keySymName, str-start);
  945.     keySymName[str-start] = '\0';
  946.     event->event.eventCode = StringToKeySym(keySymName, error);
  947.     event->event.eventCodeMask = ~0L;
  948.     }
  949.     if (*error) {
  950.     if (keySymName[0] == '<') {
  951.         /* special case for common error */
  952.         XtWarningMsg(XtNtranslationParseError, "missingComma",
  953.              XtCXtToolkitError,
  954.              "... possibly due to missing ',' in event sequence.",
  955.              (String*)NULL, (Cardinal*)NULL);
  956.     }
  957.     return PanicModeRecovery(str);
  958.     }
  959.     if (event->event.standard)
  960.     event->event.matchEvent = _XtMatchUsingStandardMods;
  961.     else 
  962.     event->event.matchEvent = _XtMatchUsingDontCareMods;
  963.  
  964.     return str;
  965. }
  966.  
  967. static String ParseTable(str, closure, event,error)
  968.     register String str;
  969.     Opaque closure;
  970.     EventPtr event;
  971.     Boolean* error;
  972. {
  973.     register String start = str;
  974.     char tableSymName[100];
  975.  
  976.     event->event.eventCode = 0L;
  977.     ScanAlphanumeric(str);
  978.     if (str == start) {event->event.eventCodeMask = 0L; return str; }
  979.     if (str-start >= 99) {
  980.     Syntax("Invalid Detail Type (string is too long).", "");
  981.     *error = TRUE;
  982.     return str;
  983.     }
  984.     bcopy(start, tableSymName, str-start);
  985.     tableSymName[str-start] = '\0';
  986.     if (! _XtLookupTableSym((NameValueTable)closure, tableSymName, 
  987.             (Value *)&event->event.eventCode)) {
  988.     Syntax("Unknown Detail Type:  ",tableSymName);
  989.         *error = TRUE;
  990.         return PanicModeRecovery(str);
  991.     }
  992.     event->event.eventCodeMask = ~0L;
  993.  
  994.     return str;
  995. }
  996.  
  997. /*ARGSUSED*/
  998. static String ParseNone(str, closure, event,error)
  999.     String str;
  1000.     Opaque closure;
  1001.     EventPtr event;
  1002.     Boolean* error;
  1003. {
  1004.     event->event.eventCode = 0;
  1005.     event->event.eventCodeMask = 0;
  1006.  
  1007.     return BROKEN_OPTIMIZER_HACK(str);
  1008. }
  1009.  
  1010. /*ARGSUSED*/
  1011. static String ParseAtom(str, closure, event,error)
  1012.     String str;
  1013.     Opaque closure;
  1014.     EventPtr event;
  1015.     Boolean* error;
  1016. {
  1017.     ScanWhitespace(str);
  1018.  
  1019.     if (*str == ',' || *str == ':') {
  1020.     /* no detail */
  1021.     event->event.eventCode = 0L;
  1022.         event->event.eventCodeMask = 0L;
  1023.     } else {
  1024.     char *start, atomName[1000];
  1025.     start = str;
  1026.     while (
  1027.         *str != ','
  1028.         && *str != ':'
  1029.         && *str != ' '
  1030.         && *str != '\t'
  1031.                 && *str != '\n'
  1032.         && *str != '\0') str++;
  1033.     if (str-start >= 999) {
  1034.         Syntax( "Atom name must be less than 1000 characters long.", "" );
  1035.         *error = TRUE;
  1036.         return str;
  1037.     }
  1038.     bcopy(start, atomName, str-start);
  1039.     atomName[str-start] = '\0';
  1040.     event->event.eventCode = XrmStringToQuark(atomName);
  1041.     event->event.matchEvent = _XtMatchAtom;
  1042.     }
  1043.     return str;
  1044. }
  1045.  
  1046. static ModifierMask buttonModifierMasks[] = {
  1047.     0, Button1Mask, Button2Mask, Button3Mask, Button4Mask, Button5Mask
  1048. };
  1049. static String ParseRepeat();
  1050.  
  1051. static String ParseEvent(str, event, reps, plus, error)
  1052.     register String str;
  1053.     EventPtr    event;
  1054.     int*    reps;
  1055.     Boolean*    plus;
  1056.     Boolean* error;
  1057. {
  1058.     Cardinal    tmEvent;
  1059.  
  1060.     str = ParseModifiers(str, event,error);
  1061.     if (*error) return str;
  1062.     if (*str != '<') {
  1063.          Syntax("Missing '<' while parsing event type.",""); 
  1064.          *error = TRUE;
  1065.          return PanicModeRecovery(str);
  1066.     }
  1067.     else str++;
  1068.     str = ParseXtEventType(str, event, &tmEvent,error);
  1069.     if (*error) return str;
  1070.     if (*str != '>'){
  1071.          Syntax("Missing '>' while parsing event type","");
  1072.          *error = TRUE;
  1073.          return PanicModeRecovery(str);
  1074.     }
  1075.     else str++;
  1076.     if (*str == '(') {
  1077.     str = ParseRepeat(str, reps, plus, error);
  1078.     if (*error) return str;
  1079.     }
  1080.     str = (*(events[tmEvent].parseDetail))(
  1081.         str, events[tmEvent].closure, event,error);
  1082.     if (*error) return str;
  1083.  
  1084. /* gross hack! ||| this kludge is related to the X11 protocol deficiency w.r.t.
  1085.  * modifiers in grabs.
  1086.  */
  1087.     if ((event->event.eventType == ButtonRelease)
  1088.     && (event->event.modifiers | event->event.modifierMask) /* any */
  1089.         && (event->event.modifiers != AnyModifier))
  1090.     {
  1091.     event->event.modifiers
  1092.         |= buttonModifierMasks[event->event.eventCode];
  1093.     /* the button that is going up will always be in the modifiers... */
  1094.     }
  1095.  
  1096.     return str;
  1097. }
  1098.  
  1099. static String ParseQuotedStringEvent(str, event,error)
  1100.     register String str;
  1101.     register EventPtr event;
  1102.     Boolean *error;
  1103. {
  1104.     register int j;
  1105.  
  1106.     Value ctrlMask;
  1107.     Value metaMask;
  1108.     Value shiftMask;
  1109.     register char    c;
  1110.     char    s[2];
  1111.     (void) _XtLookupModifier("Ctrl",(LateBindingsPtr*)NULL,
  1112.                  FALSE,(Value *) &ctrlMask,TRUE);
  1113.     (void) _XtLookupModifier("Meta", &event->event.lateModifiers,
  1114.                  FALSE,(Value *) &metaMask,FALSE);
  1115.     (void) _XtLookupModifier("Shift",(LateBindingsPtr*)NULL,
  1116.                  FALSE,(Value *) &shiftMask,TRUE);
  1117.     for (j=0; j < 2; j++)
  1118.     if (*str=='^' && !(event->event.modifiers | ctrlMask)) {
  1119.         str++;
  1120.         event->event.modifiers |= ctrlMask;
  1121.     } else if (*str == '$' && !(event->event.modifiers | metaMask)) {
  1122.         str++;
  1123.         event->event.modifiers |= metaMask;
  1124.     } else if (*str == '\\') {
  1125.         str++;
  1126.         c = *str;
  1127.         if (*str != '\0' && *str != '\n') str++;
  1128.         break;
  1129.     } else {
  1130.         c = *str;
  1131.         if (*str != '\0' && *str != '\n') str++;
  1132.         break;
  1133.     }
  1134.     event->event.eventType = KeyPress;
  1135.     s[0] = c;
  1136.     s[1] = '\0';
  1137.     event->event.eventCode = StringToKeySym(s, error);
  1138.     if (*error) return PanicModeRecovery(str);
  1139.     event->event.eventCodeMask = ~0L;
  1140.     event->event.matchEvent = _XtMatchUsingStandardMods;
  1141.     event->event.standard = True;
  1142.  
  1143.     return str;
  1144. }
  1145.  
  1146.  
  1147. static EventSeqRec timerEventRec = {
  1148.     {0, 0, NULL, _XtEventTimerEventType, 0L, 0L, NULL},
  1149.     /* (StatePtr) -1 */ NULL,
  1150.     NULL,
  1151.     NULL
  1152. };
  1153.  
  1154. static void RepeatDown(eventP, reps, actionsP)
  1155.     EventPtr *eventP;
  1156.     int reps;
  1157.     ActionPtr **actionsP;
  1158. {
  1159.     EventRec upEventRec;
  1160.     register EventPtr event, downEvent;
  1161.     EventPtr upEvent = &upEventRec;
  1162.     register int i;
  1163.  
  1164.     downEvent = event = *eventP;
  1165.     *upEvent = *downEvent;
  1166.     upEvent->event.eventType = ((event->event.eventType == ButtonPress) ?
  1167.     ButtonRelease : KeyRelease);
  1168.     if ((upEvent->event.eventType == ButtonRelease)
  1169.     && (upEvent->event.modifiers != AnyModifier)
  1170.         && (upEvent->event.modifiers | upEvent->event.modifierMask))
  1171.     upEvent->event.modifiers
  1172.         |= buttonModifierMasks[event->event.eventCode];
  1173.  
  1174.     if (event->event.lateModifiers)
  1175.     event->event.lateModifiers->ref_count += (reps - 1) * 2;
  1176.  
  1177.     for (i=1; i<reps; i++) {
  1178.  
  1179.     /* up */
  1180.     event->next = XtNew(EventSeqRec);
  1181.     event = event->next;
  1182.     *event = *upEvent;
  1183.  
  1184.     /* timer */
  1185.     event->next = XtNew(EventSeqRec);
  1186.     event = event->next;
  1187.     *event = timerEventRec;
  1188.  
  1189.     /* down */
  1190.     event->next = XtNew(EventSeqRec);
  1191.     event = event->next;
  1192.     *event = *downEvent;
  1193.  
  1194.     }
  1195.  
  1196.     event->next = NULL;
  1197.     *eventP = event;
  1198.     *actionsP = &event->actions;
  1199. }
  1200.  
  1201. static void RepeatDownPlus(eventP, reps, actionsP)
  1202.     EventPtr *eventP;
  1203.     int reps;
  1204.     ActionPtr **actionsP;
  1205. {
  1206.     EventRec upEventRec;
  1207.     register EventPtr event, downEvent, lastDownEvent;
  1208.     EventPtr upEvent = &upEventRec;
  1209.     register int i;
  1210.  
  1211.     downEvent = event = *eventP;
  1212.     *upEvent = *downEvent;
  1213.     upEvent->event.eventType = ((event->event.eventType == ButtonPress) ?
  1214.     ButtonRelease : KeyRelease);
  1215.     if ((upEvent->event.eventType == ButtonRelease)
  1216.     && (upEvent->event.modifiers != AnyModifier)
  1217.         && (upEvent->event.modifiers | upEvent->event.modifierMask))
  1218.     upEvent->event.modifiers
  1219.         |= buttonModifierMasks[event->event.eventCode];
  1220.  
  1221.     if (event->event.lateModifiers)
  1222.     event->event.lateModifiers->ref_count += reps * 2 - 1;
  1223.  
  1224.     for (i=0; i<reps; i++) {
  1225.  
  1226.     if (i > 0) {
  1227.     /* down */
  1228.     event->next = XtNew(EventSeqRec);
  1229.     event = event->next;
  1230.     *event = *downEvent;
  1231.     }
  1232.     lastDownEvent = event;
  1233.  
  1234.     /* up */
  1235.     event->next = XtNew(EventSeqRec);
  1236.     event = event->next;
  1237.     *event = *upEvent;
  1238.  
  1239.     /* timer */
  1240.     event->next = XtNew(EventSeqRec);
  1241.     event = event->next;
  1242.     *event = timerEventRec;
  1243.  
  1244.     }
  1245.  
  1246.     event->next = lastDownEvent;
  1247.     *eventP = event;
  1248.     *actionsP = &lastDownEvent->actions;
  1249. }
  1250.  
  1251. static void RepeatUp(eventP, reps, actionsP)
  1252.     EventPtr *eventP;
  1253.     int reps;
  1254.     ActionPtr **actionsP;
  1255. {
  1256.     EventRec upEventRec;
  1257.     register EventPtr event, downEvent;
  1258.     EventPtr upEvent = &upEventRec;
  1259.     register int i;
  1260.  
  1261.     /* the event currently sitting in *eventP is an "up" event */
  1262.     /* we want to make it a "down" event followed by an "up" event, */
  1263.     /* so that sequence matching on the "state" side works correctly. */
  1264.  
  1265.     downEvent = event = *eventP;
  1266.     *upEvent = *downEvent;
  1267.     downEvent->event.eventType = ((event->event.eventType == ButtonRelease) ?
  1268.     ButtonPress : KeyPress);
  1269.     if ((downEvent->event.eventType == ButtonPress)
  1270.     && (downEvent->event.modifiers != AnyModifier)
  1271.         && (downEvent->event.modifiers | downEvent->event.modifierMask))
  1272.     downEvent->event.modifiers
  1273.         &= ~buttonModifierMasks[event->event.eventCode];
  1274.  
  1275.     if (event->event.lateModifiers)
  1276.     event->event.lateModifiers->ref_count += reps * 2 - 1;
  1277.  
  1278.     /* up */
  1279.     event->next = XtNew(EventSeqRec);
  1280.     event = event->next;
  1281.     *event = *upEvent;
  1282.  
  1283.     for (i=1; i<reps; i++) {
  1284.  
  1285.     /* timer */
  1286.     event->next = XtNew(EventSeqRec);
  1287.     event = event->next;
  1288.     *event = timerEventRec;
  1289.  
  1290.     /* down */
  1291.     event->next = XtNew(EventSeqRec);
  1292.     event = event->next;
  1293.     *event = *downEvent;
  1294.  
  1295.     /* up */
  1296.     event->next = XtNew(EventSeqRec);
  1297.     event = event->next;
  1298.     *event = *upEvent;
  1299.  
  1300.     }
  1301.  
  1302.     event->next = NULL;
  1303.     *eventP = event;
  1304.     *actionsP = &event->actions;
  1305. }
  1306.  
  1307. static void RepeatUpPlus(eventP, reps, actionsP)
  1308.     EventPtr *eventP;
  1309.     int reps;
  1310.     ActionPtr **actionsP;
  1311. {
  1312.     EventRec upEventRec;
  1313.     register EventPtr event, downEvent, lastUpEvent;
  1314.     EventPtr upEvent = &upEventRec;
  1315.     register int i;
  1316.  
  1317.     /* the event currently sitting in *eventP is an "up" event */
  1318.     /* we want to make it a "down" event followed by an "up" event, */
  1319.     /* so that sequence matching on the "state" side works correctly. */
  1320.  
  1321.     downEvent = event = *eventP;
  1322.     *upEvent = *downEvent;
  1323.     downEvent->event.eventType = ((event->event.eventType == ButtonRelease) ?
  1324.     ButtonPress : KeyPress);
  1325.     if ((downEvent->event.eventType == ButtonPress)
  1326.     && (downEvent->event.modifiers != AnyModifier)
  1327.         && (downEvent->event.modifiers | downEvent->event.modifierMask))
  1328.     downEvent->event.modifiers
  1329.         &= ~buttonModifierMasks[event->event.eventCode];
  1330.  
  1331.     if (event->event.lateModifiers)
  1332.     event->event.lateModifiers->ref_count += reps * 2;
  1333.  
  1334.     for (i=0; i<reps; i++) {
  1335.  
  1336.     /* up */
  1337.     event->next = XtNew(EventSeqRec);
  1338.     lastUpEvent = event = event->next;
  1339.     *event = *upEvent;
  1340.  
  1341.     /* timer */
  1342.     event->next = XtNew(EventSeqRec);
  1343.     event = event->next;
  1344.     *event = timerEventRec;
  1345.  
  1346.     /* down */
  1347.     event->next = XtNew(EventSeqRec);
  1348.         event = event->next;
  1349.     *event = *downEvent;
  1350.  
  1351.     }
  1352.  
  1353.     event->next = lastUpEvent;
  1354.     *eventP = event;
  1355.     *actionsP = &lastUpEvent->actions;
  1356. }
  1357.  
  1358. static void RepeatOther(eventP, reps, actionsP)
  1359.     EventPtr *eventP;
  1360.     int reps;
  1361.     ActionPtr **actionsP;
  1362. {
  1363.     register EventPtr event, tempEvent;
  1364.     register int i;
  1365.  
  1366.     tempEvent = event = *eventP;
  1367.  
  1368.     if (event->event.lateModifiers)
  1369.     event->event.lateModifiers->ref_count += reps - 1;
  1370.  
  1371.     for (i=1; i<reps; i++) {
  1372.     event->next = XtNew(EventSeqRec);
  1373.     event = event->next;
  1374.     *event = *tempEvent;
  1375.     }
  1376.  
  1377.     *eventP = event;
  1378.     *actionsP = &event->actions;
  1379. }
  1380.  
  1381. static void RepeatOtherPlus(eventP, reps, actionsP)
  1382.     EventPtr *eventP;
  1383.     int reps;
  1384.     ActionPtr **actionsP;
  1385. {
  1386.     register EventPtr event, tempEvent;
  1387.     register int i;
  1388.  
  1389.     tempEvent = event = *eventP;
  1390.  
  1391.     if (event->event.lateModifiers)
  1392.     event->event.lateModifiers->ref_count += reps - 1;
  1393.  
  1394.     for (i=1; i<reps; i++) {
  1395.     event->next = XtNew(EventSeqRec);
  1396.     event = event->next;
  1397.     *event = *tempEvent;
  1398.     }
  1399.  
  1400.     event->next = event;
  1401.     *eventP = event;
  1402.     *actionsP = &event->actions;
  1403. }
  1404.  
  1405. static void RepeatEvent(eventP, reps, plus, actionsP)
  1406.     EventPtr *eventP;
  1407.     int reps;
  1408.     Boolean plus;
  1409.     ActionPtr **actionsP;
  1410. {
  1411.     switch ((*eventP)->event.eventType) {
  1412.  
  1413.     case ButtonPress:
  1414.     case KeyPress:
  1415.         if (plus) RepeatDownPlus(eventP, reps, actionsP);
  1416.         else RepeatDown(eventP, reps, actionsP);
  1417.         break;
  1418.  
  1419.     case ButtonRelease:
  1420.     case KeyRelease:
  1421.         if (plus) RepeatUpPlus(eventP, reps, actionsP);
  1422.         else RepeatUp(eventP, reps, actionsP);
  1423.         break;
  1424.  
  1425.     default:
  1426.         if (plus) RepeatOtherPlus(eventP, reps, actionsP);
  1427.         else RepeatOther(eventP, reps, actionsP);
  1428.     }
  1429. }
  1430.  
  1431. static String ParseRepeat(str, reps, plus, error)
  1432.     register String str;
  1433.     int    *reps;
  1434.     Boolean *plus, *error;
  1435. {
  1436.  
  1437.     /*** Parse the repetitions, for double click etc... ***/
  1438.     if (*str != '(' || !(isdigit(str[1]) || str[1] == '+' || str[1] == ')'))
  1439.     return str;
  1440.     str++;
  1441.     if (isdigit(*str)) {
  1442.     String start = str;
  1443.     char repStr[7];
  1444.     int len;
  1445.  
  1446.     ScanNumeric(str);
  1447.     len = (str - start);
  1448.     if (len < sizeof repStr) {
  1449.         bcopy(start, repStr, len);
  1450.         repStr[len] = '\0';
  1451.         *reps = StrToNum(repStr);
  1452.     } else {
  1453.         Syntax("Repeat count too large.", "");
  1454.         *error = True;
  1455.         return str;
  1456.     }
  1457.     }
  1458.     if (*reps == 0) {
  1459.     Syntax("Missing repeat count.","");
  1460.     *error = True;
  1461.     return str;
  1462.     }
  1463.  
  1464.     if (*str == '+') {
  1465.     *plus = TRUE;
  1466.     str++;
  1467.     }
  1468.     if (*str == ')')
  1469.     str++;
  1470.     else {
  1471.     Syntax("Missing ')'.","");
  1472.     *error = True;
  1473.     }
  1474.  
  1475.     return str;
  1476. }
  1477.  
  1478. /***********************************************************************
  1479.  * ParseEventSeq
  1480.  * Parses the left hand side of a translation table production
  1481.  * up to, and consuming the ":".
  1482.  * Takes a pointer to a char* (where to start parsing) and returns an
  1483.  * event seq (in a passed in variable), having updated the String 
  1484.  **********************************************************************/
  1485.  
  1486. static String ParseEventSeq(str, eventSeqP, actionsP,error)
  1487.     register String str;
  1488.     EventSeqPtr *eventSeqP;
  1489.     ActionPtr    **actionsP;
  1490.     Boolean *error;
  1491. {
  1492.     EventSeqPtr *nextEvent = eventSeqP;
  1493.  
  1494.     *eventSeqP = NULL;
  1495.  
  1496.     while ( *str != '\0' && *str != '\n') {
  1497.     static Event    nullEvent =
  1498.              {0, 0,0L, 0, 0L, 0L,_XtRegularMatch,FALSE};
  1499.     EventPtr    event;
  1500.  
  1501.     ScanWhitespace(str);
  1502.  
  1503.     if (*str == '"') {
  1504.         str++;
  1505.         while (*str != '"' && *str != '\0' && *str != '\n') {
  1506.                 event = XtNew(EventRec);
  1507.                 event->event = nullEvent;
  1508.                 event->state = /* (StatePtr) -1 */ NULL;
  1509.                 event->next = NULL;
  1510.                 event->actions = NULL;
  1511.         str = ParseQuotedStringEvent(str, event,error);
  1512.         if (*error) {
  1513.             XtWarningMsg(XtNtranslationParseError, "nonLatin1",
  1514.             XtCXtToolkitError,
  1515.             "... probably due to non-Latin1 character in quoted string",
  1516.             (String*)NULL, (Cardinal*)NULL);
  1517.             return PanicModeRecovery(str);
  1518.         }
  1519.         *nextEvent = event;
  1520.         *actionsP = &event->actions;
  1521.         nextEvent = &event->next;
  1522.         }
  1523.         if (*str != '"') {
  1524.                 Syntax("Missing '\"'.","");
  1525.                 *error = TRUE;
  1526.                 return PanicModeRecovery(str);
  1527.              }
  1528.              else str++;
  1529.     } else {
  1530.         int reps = 0;
  1531.         Boolean plus = False;
  1532.  
  1533.             event = XtNew(EventRec);
  1534.             event->event = nullEvent;
  1535.             event->state = /* (StatePtr) -1 */ NULL;
  1536.             event->next = NULL;
  1537.             event->actions = NULL;
  1538.  
  1539.         str = ParseEvent(str, event, &reps, &plus, error);
  1540.             if (*error) return str;
  1541.         *nextEvent = event;
  1542.         *actionsP = &event->actions;
  1543.         if (reps > 1 || plus)
  1544.         RepeatEvent(&event, reps, plus, actionsP);
  1545.         nextEvent = &event->next;
  1546.     }
  1547.     ScanWhitespace(str);
  1548.         if (*str == ':') break;
  1549.         else {
  1550.             if (*str != ',') {
  1551.                 Syntax("',' or ':' expected while parsing event sequence.","");
  1552.                 *error = TRUE;
  1553.                 return PanicModeRecovery(str);
  1554.         } else str++;
  1555.         }
  1556.     }
  1557.  
  1558.     if (*str != ':') {
  1559.         Syntax("Missing ':'after event sequence.",""); 
  1560.         *error = TRUE;
  1561.         return PanicModeRecovery(str);
  1562.     } else str++;
  1563.  
  1564.     return str;
  1565. }
  1566.  
  1567.  
  1568. static String ParseActionProc(str, actionProcNameP, error)
  1569.     register String str;
  1570.     XrmQuark *actionProcNameP;
  1571.     Boolean *error;
  1572. {
  1573.     register String start = str;
  1574.     char procName[200];
  1575.  
  1576.     str = ScanIdent(str);
  1577.     if (str-start >= 199) {
  1578.     Syntax("Action procedure name is longer than 199 chars","");
  1579.     *error = TRUE;
  1580.     return str;
  1581.     }
  1582.     bcopy(start, procName, str-start);
  1583.     procName[str-start] = '\0';
  1584.     *actionProcNameP = XrmStringToQuark( procName );
  1585.     return str;
  1586. }
  1587.  
  1588.  
  1589. static String ParseString(str, strP)
  1590.     register String str;
  1591.     String *strP;
  1592. {
  1593.     register String start;
  1594.  
  1595.     if (*str == '"') {
  1596.     register unsigned prev_len, len;
  1597.     str++;
  1598.     start = str;
  1599.     *strP = NULL;
  1600.     prev_len = 0;
  1601.  
  1602.     while (*str != '"' && *str != '\0') {
  1603.         /* \"  produces double quote embedded in a quoted parameter
  1604.          * \\" produces backslash as last character of a quoted parameter
  1605.          */
  1606.         if (*str == '\\' && 
  1607.         (*(str+1) == '"' || (*(str+1) == '\\' && *(str+2) == '"'))) {
  1608.         len = prev_len + (str-start+2);
  1609.         *strP = XtRealloc(*strP, len);
  1610.         bcopy(start, *strP + prev_len, str-start);
  1611.         prev_len = len-1;
  1612.         str++;
  1613.         (*strP)[prev_len-1] = *str;
  1614.         (*strP)[prev_len] = '\0';
  1615.         start = str+1;
  1616.         } 
  1617.         str++;
  1618.     }
  1619.     len = prev_len + (str-start+1);
  1620.     *strP = XtRealloc(*strP, len);
  1621.     bcopy(start, *strP + prev_len, str-start);
  1622.     (*strP)[len-1] = '\0';
  1623.     if (*str == '"') str++; else
  1624.             XtWarningMsg(XtNtranslationParseError,"parseString",
  1625.                       XtCXtToolkitError,"Missing '\"'.",
  1626.               (String *)NULL, (Cardinal *)NULL);
  1627.     } else {
  1628.     /* scan non-quoted string, stop on whitespace, ',' or ')' */
  1629.     start = str;
  1630.     while (*str != ' '
  1631.         && *str != '\t'
  1632.         && *str != ','
  1633.         && *str != ')'
  1634.                 && *str != '\n'
  1635.         && *str != '\0') str++;
  1636.     *strP = XtMalloc((unsigned)(str-start+1));
  1637.     bcopy(start, *strP, str-start);
  1638.     (*strP)[str-start] = '\0';
  1639.     }
  1640.     return str;
  1641. }
  1642.  
  1643.  
  1644. static String ParseParamSeq(str, paramSeqP, paramNumP)
  1645.     register String str;
  1646.     String **paramSeqP;
  1647.     Cardinal *paramNumP;
  1648. {
  1649.     typedef struct _ParamRec *ParamPtr;
  1650.     typedef struct _ParamRec {
  1651.     ParamPtr next;
  1652.     String    param;
  1653.     } ParamRec;
  1654.  
  1655.     ParamPtr params = NULL;
  1656.     register Cardinal num_params = 0;
  1657.     register Cardinal i;
  1658.  
  1659.     ScanWhitespace(str);
  1660.     while (*str != ')' && *str != '\0' && *str != '\n') {
  1661.     String newStr;
  1662.     str = ParseString(str, &newStr);
  1663.     if (newStr != NULL) {
  1664.         ParamPtr temp = (ParamRec*)
  1665.         ALLOCATE_LOCAL( (unsigned)sizeof(ParamRec) );
  1666.  
  1667.         num_params++;
  1668.         temp->next = params;
  1669.         params = temp;
  1670.         temp->param = newStr;
  1671.         ScanWhitespace(str);
  1672.         if (*str == ',') {
  1673.         str++;
  1674.         ScanWhitespace(str);
  1675.         }
  1676.     }
  1677.     }
  1678.  
  1679.     if (num_params != 0) {
  1680.     String *paramP = (String *)
  1681.         XtMalloc( (unsigned)(num_params+1) * sizeof(String) );
  1682.     *paramSeqP = paramP;
  1683.     *paramNumP = num_params;
  1684.     paramP += num_params; /* list is LIFO right now */
  1685.     *paramP-- = NULL;
  1686.     for (i=0; i < num_params; i++) {
  1687.         ParamPtr next = params->next;
  1688.         *paramP-- = params->param;
  1689.         DEALLOCATE_LOCAL( (char *)params );
  1690.         params = next;
  1691.     }
  1692.     } else {
  1693.     *paramSeqP = NULL;
  1694.     *paramNumP = 0;
  1695.     }
  1696.  
  1697.     return str;
  1698. }
  1699.  
  1700. static String ParseAction(str, actionP, quarkP, error)
  1701.     String str;
  1702.     ActionPtr actionP;
  1703.     XrmQuark* quarkP;
  1704.     Boolean* error;
  1705. {
  1706.     str = ParseActionProc(str, quarkP, error);
  1707.     if (*error) return str;
  1708.  
  1709.     if (*str == '(') {
  1710.     str++;
  1711.     str = ParseParamSeq(str, &actionP->params, &actionP->num_params);
  1712.     } else {
  1713.         Syntax("Missing '(' while parsing action sequence",""); 
  1714.         *error = TRUE;
  1715.         return str;
  1716.     }
  1717.     if (*str == ')') str++;
  1718.     else{
  1719.         Syntax("Missing ')' while parsing action sequence","");
  1720.         *error = TRUE;
  1721.         return str;
  1722.     }
  1723.     return str;
  1724. }
  1725.  
  1726.  
  1727. static String ParseActionSeq(parseTree, str, actionsP, error)
  1728.     TMParseStateTree       parseTree;
  1729.     String         str;
  1730.     ActionPtr         *actionsP;
  1731.     Boolean        *error;
  1732. {
  1733.     ActionPtr *nextActionP = actionsP;
  1734.  
  1735.     *actionsP = NULL;
  1736.     while (*str != '\0' && *str != '\n') {
  1737.     register ActionPtr    action;
  1738.     XrmQuark quark;
  1739.  
  1740.     action = XtNew(ActionRec);
  1741.         action->params = NULL;
  1742.         action->num_params = 0;
  1743.         action->next = NULL;
  1744.  
  1745.     str = ParseAction(str, action, &quark, error);
  1746.     if (*error) return PanicModeRecovery(str);
  1747.  
  1748.     action->idx = _XtGetQuarkIndex(parseTree, quark);
  1749.     ScanWhitespace(str);
  1750.     *nextActionP = action;
  1751.     nextActionP = &action->next;
  1752.     }
  1753.     if (*str == '\n') str++;
  1754.     ScanWhitespace(str);
  1755.     return str;
  1756. }
  1757.  
  1758.  
  1759. static void ShowProduction(currentProduction)
  1760.   String currentProduction;
  1761. {
  1762.     Cardinal num_params = 1;
  1763.     String params[1];
  1764.     int len = 499;
  1765.     char *eol, production[500];
  1766.  
  1767.     eol = strchr(currentProduction, '\n');
  1768.     if (eol) len = MIN(499, eol - currentProduction);
  1769.     bcopy(currentProduction, production, len);
  1770.     production[len] = '\0';
  1771.  
  1772.     params[0] = production;
  1773.     XtWarningMsg(XtNtranslationParseError, "showLine", XtCXtToolkitError,
  1774.          "... found while parsing '%s'", params, &num_params);
  1775. }
  1776.  
  1777. /***********************************************************************
  1778.  * ParseTranslationTableProduction
  1779.  * Parses one line of event bindings.
  1780.  ***********************************************************************/
  1781.  
  1782. static String ParseTranslationTableProduction(parseTree, str)
  1783.     TMParseStateTree     parseTree;
  1784.     register String str;
  1785. {
  1786.     EventSeqPtr    eventSeq = NULL;
  1787.     ActionPtr    *actionsP;
  1788.     Boolean error = FALSE;
  1789.     String    production = str;
  1790.  
  1791.     str = ParseEventSeq(str, &eventSeq, &actionsP,&error);
  1792.     if (error == TRUE) {
  1793.     ShowProduction(production);
  1794.         FreeEventSeq(eventSeq);
  1795.         return (str);
  1796.     }
  1797.     ScanWhitespace(str);
  1798.     str = ParseActionSeq(parseTree, str, actionsP, &error);
  1799.     if (error) {
  1800.     ShowProduction(production);
  1801.         FreeEventSeq(eventSeq);
  1802.         return (str);
  1803.     }
  1804.  
  1805.     _XtAddEventSeqToStateTree(eventSeq, parseTree);
  1806.     FreeEventSeq(eventSeq);
  1807.     return (str);
  1808. }
  1809.  
  1810.  
  1811. /*ARGSUSED*/
  1812. Boolean XtCvtStringToAcceleratorTable(dpy, args, num_args, from, to, closure)
  1813.     Display*    dpy;
  1814.     XrmValuePtr args;
  1815.     Cardinal    *num_args;
  1816.     XrmValuePtr from,to;
  1817.     XtPointer    *closure;
  1818. {
  1819.     String str;
  1820.  
  1821.     if (*num_args != 0)
  1822.         XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
  1823.       "wrongParameters","cvtStringToAcceleratorTable",XtCXtToolkitError,
  1824.           "String to AcceleratorTable conversion needs no extra arguments",
  1825.       (String *)NULL, (Cardinal *)NULL);
  1826.      str = (String)(from->addr);
  1827.      if (str == NULL)
  1828.          return False;
  1829.  
  1830.     if (to->addr != NULL) {
  1831.     if (to->size < sizeof(XtAccelerators)) {
  1832.         to->size = sizeof(XtAccelerators);
  1833.         return False;
  1834.     }
  1835.     *(XtAccelerators*)to->addr = XtParseAcceleratorTable(str);
  1836.     }
  1837.     else {
  1838.     static XtAccelerators staticStateTable;
  1839.     staticStateTable = XtParseAcceleratorTable(str);
  1840.     to->addr = (XPointer) &staticStateTable;
  1841.     to->size = sizeof(XtAccelerators);
  1842.     }
  1843.     return True;
  1844. }
  1845.  
  1846.  
  1847. /*ARGSUSED*/
  1848. Boolean
  1849. XtCvtStringToTranslationTable(dpy, args, num_args, from, to, closure_ret)
  1850.     Display    *dpy;
  1851.     XrmValuePtr args;
  1852.     Cardinal    *num_args;
  1853.     XrmValuePtr from,to;
  1854.     XtPointer    *closure_ret;
  1855. {
  1856.     String str;
  1857.     
  1858.     if (*num_args != 0)
  1859.       XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
  1860.         "wrongParameters","cvtStringToTranslationTable",XtCXtToolkitError,
  1861.         "String to TranslationTable conversion needs no extra arguments",
  1862.         (String *)NULL, (Cardinal *)NULL);
  1863.     str = (String)(from->addr);
  1864.     if (str == NULL)
  1865.       return False;
  1866.  
  1867.     if (to->addr != NULL) {
  1868.     if (to->size < sizeof(XtTranslations)) {
  1869.         to->size = sizeof(XtTranslations);
  1870.         return False;
  1871.     }
  1872.     *(XtTranslations*)to->addr = XtParseTranslationTable(str);
  1873.     }
  1874.     else {
  1875.     static XtTranslations staticStateTable;
  1876.     staticStateTable = XtParseTranslationTable(str);
  1877.     to->addr = (XPointer) &staticStateTable;
  1878.     to->size = sizeof(XtTranslations);
  1879.     }
  1880.     return True;
  1881. }
  1882.  
  1883. static String CheckForPoundSign(str, defaultOp, actualOpRtn)
  1884.     String str;
  1885.     _XtTranslateOp defaultOp;
  1886.     _XtTranslateOp *actualOpRtn;
  1887. {
  1888.     String start;
  1889.     char operation[20];
  1890.     _XtTranslateOp opType;
  1891.     
  1892.     opType = defaultOp;
  1893.     ScanWhitespace(str);
  1894.     if (*str == '#') {
  1895.     int len;
  1896.     str++;
  1897.     start = str;
  1898.     str = ScanIdent(str);
  1899.     len = MIN(19, str-start);
  1900.     bcopy(start, operation, len);
  1901.     operation[len] = '\0';
  1902.     if (!strcmp(operation,"replace"))
  1903.       opType = XtTableReplace;
  1904.     else if (!strcmp(operation,"augment"))
  1905.       opType = XtTableAugment;
  1906.     else if (!strcmp(operation,"override"))
  1907.       opType = XtTableOverride;
  1908.     ScanWhitespace(str);
  1909.     if (*str == '\n') {
  1910.         str++;
  1911.         ScanWhitespace(str);
  1912.     }
  1913.     }
  1914.     *actualOpRtn = opType;
  1915.     return str;
  1916. }
  1917.  
  1918. static XtTranslations ParseTranslationTable(source, isAccelerator, defaultOp)
  1919.     String     source;
  1920.     Boolean    isAccelerator;
  1921.     _XtTranslateOp defaultOp;
  1922. {
  1923.     XtTranslations        xlations;
  1924.     TMStateTree            stateTrees[8];
  1925.     TMParseStateTreeRec        parseTreeRec, *parseTree = &parseTreeRec;
  1926.     XrmQuark            stackQuarks[200];
  1927.     TMBranchHeadRec        stackBranchHeads[200];
  1928.     StatePtr            stackComplexBranchHeads[200];
  1929.     _XtTranslateOp        actualOp;
  1930.  
  1931.     if (source == NULL)
  1932.       return (XtTranslations)NULL;
  1933.  
  1934.     source = CheckForPoundSign(source, defaultOp, &actualOp);
  1935.  
  1936.     parseTree->isSimple = True;
  1937.     parseTree->mappingNotifyInterest = False;
  1938.     parseTree->isAccelerator = isAccelerator;
  1939.     parseTree->isStackBranchHeads =
  1940.       parseTree->isStackQuarks =
  1941.     parseTree->isStackComplexBranchHeads = True;
  1942.  
  1943.     parseTree->numQuarks =
  1944.       parseTree->numBranchHeads =
  1945.     parseTree->numComplexBranchHeads = 0;
  1946.  
  1947.     parseTree->quarkTblSize =
  1948.       parseTree->branchHeadTblSize =
  1949.     parseTree->complexBranchHeadTblSize = 200;
  1950.  
  1951.     parseTree->quarkTbl = stackQuarks;
  1952.     parseTree->branchHeadTbl = stackBranchHeads;
  1953.     parseTree->complexBranchHeadTbl = stackComplexBranchHeads;
  1954.  
  1955.     while (source != NULL && *source != '\0') {
  1956.     source =  ParseTranslationTableProduction(parseTree, source);
  1957.     }
  1958.     stateTrees[0] = _XtParseTreeToStateTree(parseTree);
  1959.  
  1960.     if (!parseTree->isStackQuarks)
  1961.       XtFree((char *)parseTree->quarkTbl);
  1962.     if (!parseTree->isStackBranchHeads)
  1963.       XtFree((char *)parseTree->branchHeadTbl);
  1964.     if (!parseTree->isStackComplexBranchHeads)
  1965.       XtFree((char *)parseTree->complexBranchHeadTbl);
  1966.  
  1967.     xlations = _XtCreateXlations(stateTrees, 1, NULL, NULL);
  1968.     xlations->operation = actualOp;
  1969.  
  1970. #ifdef notdef
  1971.     XtFree(stateTrees);
  1972. #endif /* notdef */
  1973.     return xlations;
  1974. }
  1975.  
  1976. /*** public procedures ***/
  1977.  
  1978. /*
  1979.  * Parses a user's or applications translation table
  1980.  */
  1981. #if NeedFunctionPrototypes
  1982. XtAccelerators XtParseAcceleratorTable(
  1983.     _Xconst char* source
  1984.     )
  1985. #else
  1986. XtAccelerators XtParseAcceleratorTable(source)
  1987.     String source;
  1988. #endif
  1989. {
  1990.     return ((XtAccelerators)ParseTranslationTable(source, True, XtTableAugment));
  1991. }
  1992.  
  1993. #if NeedFunctionPrototypes
  1994. XtTranslations XtParseTranslationTable(
  1995.     _Xconst char* source
  1996.     )
  1997. #else
  1998. XtTranslations XtParseTranslationTable(source)
  1999.     String source;
  2000. #endif
  2001. {
  2002.     return (ParseTranslationTable(source, False, XtTableReplace));
  2003. }
  2004.  
  2005. void _XtTranslateInitialize()
  2006. {
  2007.     if (initialized) {
  2008.     XtWarningMsg("translationError","xtTranslateInitialize",
  2009.                   XtCXtToolkitError,"Initializing Translation manager twice.",
  2010.                     (String *)NULL, (Cardinal *)NULL);
  2011.     return;
  2012.     }
  2013.  
  2014.     initialized = TRUE;
  2015.  
  2016.     Compile_XtEventTable( events, XtNumber(events) );
  2017.     Compile_XtModifierTable( modifiers, XtNumber(modifiers) );
  2018.     CompileNameValueTable( buttonNames );
  2019.     CompileNameValueTable( notifyModes );
  2020.     CompileNameValueTable( motionDetails );
  2021. #if 0
  2022.     CompileNameValueTable( notifyDetail );
  2023.     CompileNameValueTable( visibilityNotify );
  2024.     CompileNameValueTable( circulation );
  2025.     CompileNameValueTable( propertyChanged );
  2026. #endif
  2027.     CompileNameValueTable( mappingNotify );
  2028. }
  2029.  
  2030. _XtAddTMConverters(table)
  2031.     ConverterTable table;
  2032. {
  2033.      _XtTableAddConverter(table,
  2034.          _XtQString,
  2035.          XrmPermStringToQuark(XtRTranslationTable), 
  2036.           XtCvtStringToTranslationTable, (XtConvertArgList) NULL,
  2037.          (Cardinal)0, True, CACHED, _XtFreeTranslations);
  2038.      _XtTableAddConverter(table, _XtQString,
  2039.          XrmPermStringToQuark(XtRAcceleratorTable),
  2040.           XtCvtStringToAcceleratorTable, (XtConvertArgList) NULL,
  2041.          (Cardinal)0, True, CACHED, _XtFreeTranslations);
  2042.      _XtTableAddConverter(table,
  2043.          XrmPermStringToQuark( _XtRStateTablePair ),
  2044.          XrmPermStringToQuark(XtRTranslationTable), 
  2045.           _XtCvtMergeTranslations, (XtConvertArgList) NULL,
  2046.          (Cardinal)0, True, CACHED, _XtFreeTranslations);
  2047. }
  2048.