workbench/libs/commodities/parseix.c

   1 /*
   2     Copyright © 1995-2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 #ifndef  DEBUG
  10 #define  DEBUG 0
  11 #endif
  12
  13 #include "cxintern.h"
  14
  15 #include <aros/debug.h>
  16
  17 #include <libraries/commodities.h>
  18 #include <proto/commodities.h>
  19 #include <proto/utility.h>
  20 #define __NOLIBBASE__ 1
  21 #include <proto/keymap.h>
  22 #undef __NOLIBBASE__
  23 #include <devices/inputevent.h>
  24 #include <devices/keymap.h>
  25 #include <string.h>
  26
  27 #include "parse.h"
  28
  29 #define DEBUG_PARSEIX(x)        ;
  30 #define DEBUG_PMATCH(x)         ;
  31
  32 BOOL pMatch(pix_S[], CONST_STRPTR, LONG *, BOOL *, struct Library *CxBase);
  33 VOID GetNext(CONST_STRPTR *);
  34 BOOL IsSeparator(char);
  35
  36 /*****************************************************************************
  37
  38     NAME */
  39
  40     AROS_LH2(LONG, ParseIX,
  41
  42 /*  SYNOPSIS */
  43
  44         AROS_LHA(CONST_STRPTR, desc, A0),
  45         AROS_LHA(IX *  , ix  , A1),
  46
  47 /*  LOCATION */
  48
  49         struct Library *, CxBase, 22, Commodities)
  50
  51 /*  FUNCTION
  52
  53     Fill in an InputXpression 'ix' according to the specifications given
  54     in the string pointed to by 'desc'.
  55
  56     The string should be formatted according to:
  57
  58     [class] {[-] (qualifier|synonym)} [[-] upstroke] [HighMap|ANSICode]
  59
  60     For more information on this, consult "xxx/CxParse.doc".
  61
  62     INPUTS
  63
  64     desc  --  pointer to the string specifying the conditions and codes of
  65               the InputXpression.
  66     ix    --  pointer to an (uninitizlized) InputXpression structure that
  67               will be filled according to 'desc'.
  68
  69     RESULT
  70
  71     0   --  Everything went OK.
  72     -1  --  Tokens after end
  73     -2  --  'desc' was NULL
  74
  75     NOTES
  76
  77     EXAMPLE
  78
  79     BUGS
  80
  81     SEE ALSO
  82
  83     MatchIX(), <libraries/commodities.h>
  84
  85     INTERNALS
  86
  87     HISTORY
  88
  89     10.05.97   SDuvan  implemented
  90
  91 ******************************************************************************/
  92
  93 {
  94     AROS_LIBFUNC_INIT
  95
  96     LONG val;
  97     BOOL dash, upstrdash = TRUE;
  98     BOOL upstroke = FALSE;
  99
 100     struct InputEvent event;
 101
 102     /* Set as standard if no class is specified in the description */
 103 #if 0
 104     /* Caller is expected to set this! */
 105     ix->ix_Version = IX_VERSION;
 106 #endif
 107     ix->ix_Class = IECLASS_RAWKEY;
 108     ix->ix_Code = 0;
 109     ix->ix_CodeMask = 0xFFFF;
 110     ix->ix_Qualifier = 0;
 111     ix->ix_QualMask = IX_NORMALQUALS & ~(IEQUALIFIER_INTERRUPT | IEQUALIFIER_MULTIBROADCAST);
 112     ix->ix_QualSame = 0;
 113
 114     if (desc == NULL)
 115     {
 116         ix->ix_Code = 0xFFFF;
 117
 118         return -2;
 119     }
 120
 121     DEBUG_PARSEIX(dprintf("ParseIX: ix = 0x%lx, desc = \"%s\"\n", ix, desc));
 122
 123     while (IsSeparator(*desc))
 124     {
 125         desc++;
 126     }
 127
 128     dash = FALSE;
 129
 130     if (pMatch(pix_Class, desc, &val, &dash, CxBase))
 131     {
 132         ix->ix_Class = val;
 133         GetNext(&desc);
 134     }
 135
 136     while (TRUE)
 137     {
 138         dash = TRUE;
 139
 140         if (pMatch(pix_IEvent, desc, &val, &dash, CxBase))
 141         {
 142             if (dash)
 143             {
 144                 ix->ix_QualMask &= ~val;
 145             }
 146             else
 147             {
 148                 ix->ix_Qualifier |= val;
 149             }
 150
 151             GetNext(&desc);
 152         }
 153         else
 154         {
 155             dash = TRUE;
 156
 157             if (pMatch(pix_Synonyms, desc, &val, &dash, CxBase))
 158             {
 159                 ix->ix_QualSame |= val;
 160
 161                 if (dash)
 162                 {
 163                     switch (val)
 164                     {
 165                     case IXSYM_SHIFT:
 166                         ix->ix_QualMask &= ~IXSYM_SHIFTMASK;
 167                         break;
 168
 169                     case IXSYM_ALT:
 170                         ix->ix_QualMask &= ~IXSYM_ALTMASK;
 171                         break;
 172
 173                     case IXSYM_CAPS:
 174                         ix->ix_QualMask &= ~IXSYM_CAPSMASK;
 175                         break;
 176                     }
 177                 }
 178                 else
 179                 {
 180                     switch (val)
 181                     {
 182                     case IXSYM_SHIFT:
 183                         ix->ix_Qualifier |= IXSYM_SHIFTMASK;
 184                         break;
 185
 186                     case IXSYM_ALT:
 187                         ix->ix_Qualifier |= IXSYM_ALTMASK;
 188                         break;
 189
 190                     case IXSYM_CAPS:
 191                         ix->ix_Qualifier |= IXSYM_CAPSMASK;
 192                         break;
 193                     }
 194                 }
 195
 196                 GetNext(&desc);
 197             }
 198             else
 199             {
 200                 break;
 201             }
 202         }
 203     }
 204
 205     if (pMatch(pix_Upstroke, desc, &val, &upstrdash, CxBase))
 206     {
 207         upstroke = TRUE;
 208         GetNext(&desc);
 209     }
 210
 211     dash = FALSE;
 212
 213     if (pMatch(pix_Highmap, desc, &val, &dash, CxBase))
 214     {
 215         ix->ix_Code = val;
 216     }
 217     else
 218     {
 219         if (*desc != '\0')
 220         {
 221             if (InvertKeyMap(*desc, &event, NULL))
 222             {
 223                 ix->ix_Code = event.ie_Code;
 224             }
 225         }
 226     }
 227
 228     if (upstroke)
 229     {
 230         if (upstrdash)
 231         {
 232             ix->ix_CodeMask &= ~IECODE_UP_PREFIX;
 233         }
 234         else
 235         {
 236             ix->ix_Code |= IECODE_UP_PREFIX;
 237         }
 238     }
 239
 240     while (!(IsSeparator(*desc)))
 241     {
 242         desc++;
 243     }
 244
 245     DEBUG_PARSEIX(dprintf("ParseIX: Class 0x%lx Code 0x%lx CodeMask 0x%lx\n"
 246                           "ParseIX: Qualifier 0x%lx QualMask 0x%lx QualSame 0x%lx\n",
 247                           ix->ix_Class,
 248                           ix->ix_Code,
 249                           ix->ix_CodeMask,
 250                           ix->ix_Qualifier,
 251                           ix->ix_QualMask,
 252                           ix->ix_QualSame));
 253
 254     if (*desc == '\0')
 255     {
 256         return 0;
 257     }
 258     else
 259     {
 260         DEBUG_PARSEIX(dprintf("ParseIX: fail, desc 0x%lx *desc 0x%lx\n", desc, *desc));
 261         return -1;
 262     }
 263
 264     AROS_LIBFUNC_EXIT
 265 } /* ParseIX */
 266
 267
 268 BOOL pMatch(pix_S words[], CONST_STRPTR string, LONG *v, BOOL *dash,
 269             struct Library *CxBase)
 270 {
 271     CONST_STRPTR nstr = string;
 272     int    i;
 273
 274     DEBUG_PMATCH(dprintf("pMatch: words[0] = \"%s\" string \"%s\" dash %d\n",
 275                          words[0].name, string, *dash));
 276
 277     if (*dash)
 278     {
 279         if (*nstr == '-')
 280         {
 281             nstr++;
 282             *dash = TRUE;
 283         }
 284         else
 285         {
 286             *dash = FALSE;
 287         }
 288     }
 289
 290     for (i = 0; words[i].name != NULL; i++)
 291     {
 292         if (Strnicmp(nstr, words[i].name, strlen(words[i].name)) == 0)
 293         {
 294             *v = words[i].value;
 295             DEBUG_PMATCH(dprintf("pMatch: value 0x%lx\n", *v));
 296             return TRUE;
 297         }
 298     }
 299
 300     DEBUG_PMATCH(dprintf("pMatch: not found\n"));
 301     return FALSE;
 302 }
 303
 304
 305 VOID GetNext(CONST_STRPTR *str)
 306 {
 307     while (!(IsSeparator(**str)))
 308     {
 309         (*str)++;
 310     }
 311
 312     while (IsSeparator(**str) && !(**str=='\0'))
 313     {
 314         (*str)++;
 315     }
 316 }
 317
 318
 319 BOOL IsSeparator(char a)
 320 {
 321     if (a == ' ' || a == '\n' || a == '\t' || a == ',' || a == '\0')
 322     {
 323         return TRUE;
 324     }
 325     else
 326     {
 327         return FALSE;
 328     }
 329 }