diff options
Diffstat (limited to 'misc.c')
| -rw-r--r-- | misc.c | 605 |
1 files changed, 605 insertions, 0 deletions
@@ -0,0 +1,605 @@ +/* $Xorg: misc.c,v 1.3 2000/08/17 19:54:33 cpqbld Exp $ */ +/************************************************************ + Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc. + + Permission to use, copy, modify, and distribute this + software and its documentation for any purpose and without + fee is hereby granted, provided that the above copyright + notice appear in all copies and that both that copyright + notice and this permission notice appear in supporting + documentation, and that the name of Silicon Graphics not be + used in advertising or publicity pertaining to distribution + of the software without specific prior written permission. + Silicon Graphics makes no representation about the suitability + of this software for any purpose. It is provided "as is" + without any express or implied warranty. + + SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS + SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON + GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL + DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE + OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH + THE USE OR PERFORMANCE OF THIS SOFTWARE. + + ********************************************************/ + +#include "xkbcomp.h" +#include "xkbpath.h" +#include "tokens.h" +#include "keycodes.h" +#include "misc.h" +#include <X11/keysym.h> +#include "parseutils.h" + +#include <X11/extensions/XKBgeom.h> + +/***====================================================================***/ + +Bool +#if NeedFunctionPrototypes +ProcessIncludeFile( IncludeStmt * stmt, + unsigned file_type, + XkbFile ** file_rtrn, + unsigned * merge_rtrn) +#else +ProcessIncludeFile(stmt,file_type,file_rtrn,merge_rtrn) + IncludeStmt * stmt; + unsigned file_type; + XkbFile ** file_rtrn; + unsigned * merge_rtrn; +#endif +{ +FILE *file; +XkbFile *rtrn,*mapToUse; +char oldFile[1024]; +int oldLine = lineNum; + + rtrn= XkbFindFileInCache(stmt->file,file_type,&stmt->path); + if (rtrn==NULL) { + file= XkbFindFileInPath(stmt->file,file_type,&stmt->path); + if (file==NULL) { + ERROR2("Can't find file \"%s\" for %s include\n",stmt->file, + XkbDirectoryForInclude(file_type)); + ACTION("Exiting\n"); + return False; + } + strcpy(oldFile,scanFile); + oldLine= lineNum; + setScanState(stmt->file,1); + if (debugFlags&2) + INFO1("About to parse include file %s\n",stmt->file); + if ((XKBParseFile(file,&rtrn)==0)||(rtrn==NULL)) { + setScanState(oldFile,oldLine); + ERROR1("Error interpreting include file \"%s\"\n",stmt->file); + ACTION("Exiting\n"); + fclose(file); + return False; + } + fclose(file); + XkbAddFileToCache(stmt->file,file_type,stmt->path,rtrn); + } + mapToUse= rtrn; + if (stmt->map!=NULL) { + while ((mapToUse)&&((!uStringEqual(mapToUse->name,stmt->map))|| + (mapToUse->type!=file_type))) { + mapToUse= (XkbFile *)mapToUse->common.next; + } + if (!mapToUse) { + ERROR3("No %s named \"%s\" in the include file \"%s\"\n", + XkbConfigText(file_type,XkbMessage), + stmt->map,stmt->file); + ACTION("Exiting\n"); + return False; + } + } + else if ((rtrn->common.next!=NULL)&&(warningLevel>5)) { + WARN1("No map in include statement, but \"%s\" contains several\n", + stmt->file); + ACTION1("Using first defined map, \"%s\"\n",rtrn->name); + } + setScanState(oldFile,oldLine); + if (mapToUse->type!=file_type) { + ERROR2("Include file wrong type (expected %s, got %s)\n", + XkbConfigText(file_type,XkbMessage), + XkbConfigText(mapToUse->type,XkbMessage)); + ACTION1("Include file \"%s\" ignored\n",stmt->file); + return False; + } + if (mapToUse->compiled) { + ERROR2("Map \"%s(%s)\" included more than once\n",stmt->file, + rtrn->name); + ACTION("Later inclusion ignored\n"); + return False; + } + mapToUse->compiled= True; + *file_rtrn= mapToUse; + *merge_rtrn= stmt->merge; + return True; +} + +/***====================================================================***/ + +int +#if NeedFunctionPrototypes +ReportNotArray(char *type,char *field,char *name) +#else +ReportNotArray(type,field,name) + char * type; + char * field; + char * name; +#endif +{ + ERROR2("The %s %s field is not an array\n",type,field); + ACTION1("Ignoring illegal assignment in %s\n",name); + return False; +} + +int +#if NeedFunctionPrototypes +ReportShouldBeArray(char *type,char *field,char *name) +#else +ReportShouldBeArray(type,field,name) + char * type; + char * field; + char * name; +#endif +{ + ERROR2("Missing subscript for %s %s\n",type,field); + ACTION1("Ignoring illegal assignment in %s\n",name); + return False; +} + +int +#if NeedFunctionPrototypes +ReportBadType(char *type,char *field,char *name,char *wanted) +#else +ReportBadType(type,field,name,wanted) + char *type; + char *field; + char *name; + char *wanted; +#endif +{ + ERROR3("The %s %s field must be a %s\n",type,field,wanted); + ACTION1("Ignoring illegal assignment in %s\n",name); + return False; +} + +int +#if NeedFunctionPrototypes +ReportBadIndexType(char *type,char *field,char *name,char *wanted) +#else +ReportBadIndexType(type,field,name,wanted) + char *type; + char *field; + char *name; + char *wanted; +#endif +{ + ERROR3("Index for the %s %s field must be a %s\n",type,field,wanted); + ACTION1("Ignoring assignment to illegal field in %s\n",name); + return False; +} + +int +#if NeedFunctionPrototypes +ReportBadField(char *type,char *field,char *name) +#else +ReportBadField(type,field,name) + char *type; + char *field; + char *name; +#endif +{ + ERROR3("Unknown %s field %s in %s\n",type,field,name); + ACTION1("Ignoring assignment to unknown field in %s\n",name); + return False; +} + +int +#if NeedFunctionPrototypes +ReportMultipleDefs(char *type,char *field,char *name) +#else +ReportMultipleDefs(type,field,name) + char *type; + char *field; + char *name; +#endif +{ + WARN3("Multiple definitions of %s in %s \"%s\"\n",field,type,name); + ACTION("Using last definition\n"); + return False; +} + +/***====================================================================***/ + +Bool +#if NeedFunctionPrototypes +UseNewField( unsigned field, + CommonInfo * oldDefs, + CommonInfo * newDefs, + unsigned * pCollide) +#else +UseNewField(field,oldDefs,newDefs,pCollide) + unsigned field; + CommonInfo * oldDefs; + CommonInfo * newDefs; + unsigned * pCollide; +#endif +{ +Bool useNew; + + useNew= False; + if (oldDefs->defined&field) { + if (newDefs->defined&field) { + if (((oldDefs->fileID==newDefs->fileID)&&(warningLevel>0))|| + (warningLevel>9)) { + *pCollide|= field; + } + if (newDefs->merge!=MergeAugment) + useNew= True; + } + } + else if (newDefs->defined&field) + useNew= True; + return useNew; +} + +Bool +#if NeedFunctionPrototypes +MergeNewField( unsigned field, + CommonInfo * oldDefs, + CommonInfo * newDefs, + unsigned * pCollide) +#else +MergeNewField(field,oldDefs,newDefs,pCollide) + unsigned field; + CommonInfo * oldDefs; + CommonInfo * newDefs; + unsigned * pCollide; +#endif +{ + if ((oldDefs->defined&field)&&(newDefs->defined&field)) { + if (((oldDefs->fileID==newDefs->fileID)&&(warningLevel>0))|| + (warningLevel>9)) { + *pCollide|= field; + } + if (newDefs->merge==MergeAugment) + return True; + } + return False; +} + +XPointer +#if NeedFunctionPrototypes +ClearCommonInfo(CommonInfo *cmn) +#else +ClearCommonInfo(cmn) + CommonInfo * cmn; +#endif +{ + if (cmn!=NULL) { + CommonInfo *this,*next; + for (this=cmn;this!=NULL;this=next) { + next= this->next; + uFree(this); + } + } + return NULL; +} + +XPointer +#if NeedFunctionPrototypes +AddCommonInfo(CommonInfo *old,CommonInfo *new) +#else +AddCommonInfo(old,new) + CommonInfo * old; + CommonInfo * new; +#endif +{ +CommonInfo * first; + + first= old; + while ( old && old->next ) { + old= old->next; + } + new->next= NULL; + if (old) { + old->next= new; + return (XPointer)first; + } + return (XPointer)new; +} + +/***====================================================================***/ + +typedef struct _KeyNameDesc { + KeySym level1; + KeySym level2; + char name[5]; + Bool used; +} KeyNameDesc; + +KeyNameDesc dfltKeys[] = { + { XK_Escape, NoSymbol, "ESC\0" }, + { XK_quoteleft, XK_asciitilde, "TLDE" }, + { XK_1, XK_exclam, "AE01" }, + { XK_2, XK_at, "AE02" }, + { XK_3, XK_numbersign, "AE03" }, + { XK_4, XK_dollar, "AE04" }, + { XK_5, XK_percent, "AE05" }, + { XK_6, XK_asciicircum, "AE06" }, + { XK_7, XK_ampersand, "AE07" }, + { XK_8, XK_asterisk, "AE08" }, + { XK_9, XK_parenleft, "AE09" }, + { XK_0, XK_parenright, "AE10" }, + { XK_minus, XK_underscore, "AE11" }, + { XK_equal, XK_plus, "AE12" }, + { XK_BackSpace, NoSymbol, "BKSP" }, + { XK_Tab, NoSymbol, "TAB\0" }, + { XK_q, XK_Q, "AD01" }, + { XK_w, XK_W, "AD02" }, + { XK_e, XK_E, "AD03" }, + { XK_r, XK_R, "AD04" }, + { XK_t, XK_T, "AD05" }, + { XK_y, XK_Y, "AD06" }, + { XK_u, XK_U, "AD07" }, + { XK_i, XK_I, "AD08" }, + { XK_o, XK_O, "AD09" }, + { XK_p, XK_P, "AD10" }, + { XK_bracketleft, XK_braceleft, "AD11" }, + { XK_bracketright,XK_braceright, "AD12" }, + { XK_Return, NoSymbol, "RTRN" }, + { XK_Caps_Lock, NoSymbol, "CAPS" }, + { XK_a, XK_A, "AC01" }, + { XK_s, XK_S, "AC02" }, + { XK_d, XK_D, "AC03" }, + { XK_f, XK_F, "AC04" }, + { XK_g, XK_G, "AC05" }, + { XK_h, XK_H, "AC06" }, + { XK_j, XK_J, "AC07" }, + { XK_k, XK_K, "AC08" }, + { XK_l, XK_L, "AC09" }, + { XK_semicolon, XK_colon, "AC10" }, + { XK_quoteright, XK_quotedbl, "AC11" }, + { XK_Shift_L, NoSymbol, "LFSH" }, + { XK_z, XK_Z, "AB01" }, + { XK_x, XK_X, "AB02" }, + { XK_c, XK_C, "AB03" }, + { XK_v, XK_V, "AB04" }, + { XK_b, XK_B, "AB05" }, + { XK_n, XK_N, "AB06" }, + { XK_m, XK_M, "AB07" }, + { XK_comma, XK_less, "AB08" }, + { XK_period, XK_greater, "AB09" }, + { XK_slash, XK_question, "AB10" }, + { XK_backslash, XK_bar, "BKSL" }, + { XK_Control_L, NoSymbol, "LCTL" }, + { XK_space, NoSymbol, "SPCE" }, + { XK_Shift_R, NoSymbol, "RTSH" }, + { XK_Alt_L, NoSymbol, "LALT" }, + { XK_space, NoSymbol, "SPCE" }, + { XK_Control_R, NoSymbol, "RCTL" }, + { XK_Alt_R, NoSymbol, "RALT" }, + { XK_F1, NoSymbol, "FK01" }, + { XK_F2, NoSymbol, "FK02" }, + { XK_F3, NoSymbol, "FK03" }, + { XK_F4, NoSymbol, "FK04" }, + { XK_F5, NoSymbol, "FK05" }, + { XK_F6, NoSymbol, "FK06" }, + { XK_F7, NoSymbol, "FK07" }, + { XK_F8, NoSymbol, "FK08" }, + { XK_F9, NoSymbol, "FK09" }, + { XK_F10, NoSymbol, "FK10" }, + { XK_F11, NoSymbol, "FK11" }, + { XK_F12, NoSymbol, "FK12" }, + { XK_Print, NoSymbol, "PRSC" }, + { XK_Scroll_Lock, NoSymbol, "SCLK" }, + { XK_Pause, NoSymbol, "PAUS" }, + { XK_Insert, NoSymbol, "INS\0" }, + { XK_Home, NoSymbol, "HOME" }, + { XK_Prior, NoSymbol, "PGUP" }, + { XK_Delete, NoSymbol, "DELE" }, + { XK_End, NoSymbol, "END" }, + { XK_Next, NoSymbol, "PGDN" }, + { XK_Up, NoSymbol, "UP\0\0" }, + { XK_Left, NoSymbol, "LEFT" }, + { XK_Down, NoSymbol, "DOWN" }, + { XK_Right, NoSymbol, "RGHT" }, + { XK_Num_Lock, NoSymbol, "NMLK" }, + { XK_KP_Divide, NoSymbol, "KPDV" }, + { XK_KP_Multiply, NoSymbol, "KPMU" }, + { XK_KP_Subtract, NoSymbol, "KPSU" }, + { NoSymbol, XK_KP_7, "KP7\0" }, + { NoSymbol, XK_KP_8, "KP8\0" }, + { NoSymbol, XK_KP_9, "KP9\0" }, + { XK_KP_Add, NoSymbol, "KPAD" }, + { NoSymbol, XK_KP_4, "KP4\0" }, + { NoSymbol, XK_KP_5, "KP5\0" }, + { NoSymbol, XK_KP_6, "KP6\0" }, + { NoSymbol, XK_KP_1, "KP1\0" }, + { NoSymbol, XK_KP_2, "KP2\0" }, + { NoSymbol, XK_KP_3, "KP3\0" }, + { XK_KP_Enter, NoSymbol, "KPEN" }, + { NoSymbol, XK_KP_0, "KP0\0" }, + { XK_KP_Delete, NoSymbol, "KPDL" }, + { XK_less, XK_greater, "LSGT" }, + { XK_KP_Separator,NoSymbol, "KPCO" }, + { XK_Find, NoSymbol, "FIND" }, + { NoSymbol, NoSymbol, "\0\0\0\0" } +}; + +Status +#if NeedFunctionPrototypes +ComputeKbdDefaults(XkbDescPtr xkb) +#else +ComputeKbdDefaults(xkb) + XkbDescPtr xkb; +#endif +{ +Status rtrn; +register int i,tmp,nUnknown; +KeyNameDesc * name; +KeySym * syms; + + if ((xkb->names==NULL)||(xkb->names->keys==NULL)) { + if ((rtrn=XkbAllocNames(xkb,XkbKeyNamesMask,0,0))!=Success) + return rtrn; + } + for (name=dfltKeys;(name->name[0]!='\0');name++) { + name->used= False; + } + nUnknown= 0; + for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) { + tmp= XkbKeyNumSyms(xkb,i); + if ((xkb->names->keys[i].name[0]=='\0')&&(tmp>0)) { + tmp= XkbKeyGroupsWidth(xkb,i); + syms= XkbKeySymsPtr(xkb,i); + for (name=dfltKeys;(name->name[0]!='\0');name++) { + Bool match= True; + if (((name->level1!=syms[0])&&(name->level1!=NoSymbol))|| + ((name->level2!=NoSymbol)&&(tmp<2))|| + ((name->level2!=syms[1])&&(name->level2!=NoSymbol))) { + match= False; + } + if (match) { + if (!name->used) { + memcpy(xkb->names->keys[i].name,name->name, + XkbKeyNameLength); + name->used= True; + } + else { + if (warningLevel>2) { + WARN1("Several keys match pattern for %s\n", + XkbKeyNameText(name->name,XkbMessage)); + ACTION2("Using <U%03d> for key %d\n",nUnknown,i); + } + sprintf(xkb->names->keys[i].name,"U%03d",nUnknown++); + } + break; + } + } + if (xkb->names->keys[i].name[0]=='\0') { + if (warningLevel>2) { + WARN1("Key %d does not match any defaults\n",i); + ACTION1("Using name <U%03d>\n",nUnknown); + sprintf(xkb->names->keys[i].name,"U%03d",nUnknown++); + } + } + } + } + return Success; +} + +Bool +#if NeedFunctionPrototypes +FindNamedKey( XkbDescPtr xkb, + unsigned long name, + unsigned int * kc_rtrn, + Bool use_aliases, + Bool create, + int start_from) +#else +FindNamedKey(xkb,name,kc_rtrn,use_aliases,create,start_from) + XkbDescPtr xkb; + unsigned long name; + unsigned int * kc_rtrn; + Bool use_aliases; + Bool create; + int start_from; +#endif +{ +register unsigned n; + + if (start_from<xkb->min_key_code) { + start_from= xkb->min_key_code; + } + else if (start_from>xkb->max_key_code) { + return False; + } + + *kc_rtrn= 0; /* some callers rely on this */ + if (xkb&&xkb->names&&xkb->names->keys) { + for (n=start_from;n<=xkb->max_key_code;n++) { + unsigned long tmp; + tmp= KeyNameToLong(xkb->names->keys[n].name); + if (tmp==name) { + *kc_rtrn= n; + return True; + } + } + if (use_aliases) { + unsigned long new_name; + if (FindKeyNameForAlias(xkb,name,&new_name)) + return FindNamedKey(xkb,new_name,kc_rtrn,False,create,0); + } + } + if (create) { + if ((!xkb->names)||(!xkb->names->keys)) { + if (xkb->min_key_code<XkbMinLegalKeyCode) { + xkb->min_key_code= XkbMinLegalKeyCode; + xkb->max_key_code= XkbMaxLegalKeyCode; + } + if (XkbAllocNames(xkb,XkbKeyNamesMask,0,0)!=Success) { + if (warningLevel>0) { + WARN("Couldn't allocate key names in FindNamedKey\n"); + ACTION1("Key \"%s\" not automatically created\n", + longText(name,XkbMessage)); + } + return False; + } + } + for (n=xkb->min_key_code;n<=xkb->max_key_code;n++) { + if (xkb->names->keys[n].name[0]=='\0') { + char buf[XkbKeyNameLength+1]; + LongToKeyName(name,buf); + memcpy(xkb->names->keys[n].name,buf,XkbKeyNameLength); + *kc_rtrn= n; + return True; + } + } + } + return False; +} + +Bool +#if NeedFunctionPrototypes +FindKeyNameForAlias(XkbDescPtr xkb,unsigned long lname,unsigned long *real_name) +#else +FindKeyNameForAlias(xkb,lname,real_name) + XkbDescPtr xkb; + unsigned long lname; + unsigned long * real_name; +#endif +{ +register int i; +char name[XkbKeyNameLength+1]; + + if (xkb&&xkb->geom&&xkb->geom->key_aliases) { + XkbKeyAliasPtr a; + a= xkb->geom->key_aliases; + LongToKeyName(lname,name); + name[XkbKeyNameLength]= '\0'; + for (i=0;i<xkb->geom->num_key_aliases;i++,a++) { + if (strncmp(name,a->alias,XkbKeyNameLength)==0) { + *real_name= KeyNameToLong(a->real); + return True; + } + } + } + if (xkb&&xkb->names&&xkb->names->key_aliases) { + XkbKeyAliasPtr a; + a= xkb->names->key_aliases; + LongToKeyName(lname,name); + name[XkbKeyNameLength]= '\0'; + for (i=0;i<xkb->names->num_key_aliases;i++,a++) { + if (strncmp(name,a->alias,XkbKeyNameLength)==0) { + *real_name= KeyNameToLong(a->real); + return True; + } + } + } + return False; +} |