form/fty_enum.c

   1 /****************************************************************************
   2  * Copyright 2020 Thomas E. Dickey                                          *
   3  * Copyright 1998-2009,2010 Free Software Foundation, Inc.                  *
   4  *                                                                          *
   5  * Permission is hereby granted, free of charge, to any person obtaining a  *
   6  * copy of this software and associated documentation files (the            *
   7  * "Software"), to deal in the Software without restriction, including      *
   8  * without limitation the rights to use, copy, modify, merge, publish,      *
   9  * distribute, distribute with modifications, sublicense, and/or sell       *
  10  * copies of the Software, and to permit persons to whom the Software is    *
  11  * furnished to do so, subject to the following conditions:                 *
  12  *                                                                          *
  13  * The above copyright notice and this permission notice shall be included  *
  14  * in all copies or substantial portions of the Software.                   *
  15  *                                                                          *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  23  *                                                                          *
  24  * Except as contained in this notice, the name(s) of the above copyright   *
  25  * holders shall not be used in advertising or otherwise to promote the     *
  26  * sale, use or other dealings in this Software without prior written       *
  27  * authorization.                                                           *
  28  ****************************************************************************/
  29
  30 /***************************************************************************
  31 *                                                                          *
  32 *  Author : Juergen Pfeifer                                                *
  33 *                                                                          *
  34 ***************************************************************************/
  35
  36 #include "form.priv.h"
  37
  38 MODULE_ID("$Id: fty_enum.c,v 1.27 2020/02/02 23:34:34 tom Exp $")
  39
  40 typedef struct
  41   {
  42     char **kwds;
  43     int count;
  44     bool checkcase;
  45     bool checkunique;
  46   }
  47 enumARG;
  48
  49 typedef struct
  50   {
  51     char **kwds;
  52     int ccase;
  53     int cunique;
  54   }
  55 enumParams;
  56
  57 /*---------------------------------------------------------------------------
  58 |   Facility      :  libnform
  59 |   Function      :  static void *Generic_Enum_Type(void * arg)
  60 |
  61 |   Description   :  Allocate structure for enumeration type argument.
  62 |
  63 |   Return Values :  Pointer to argument structure or NULL on error
  64 +--------------------------------------------------------------------------*/
  65 static void *
  66 Generic_Enum_Type(void *arg)
  67 {
  68   enumARG *argp = (enumARG *)0;
  69   enumParams *params = (enumParams *) arg;
  70
  71   if (params)
  72     {
  73       argp = typeMalloc(enumARG, 1);
  74
  75       if (argp)
  76         {
  77           int cnt = 0;
  78           char **kp = (char **)0;
  79           char **kwds = (char **)0;
  80           char **kptarget;
  81           int ccase, cunique;
  82
  83           T((T_CREATE("enumARG %p"), (void *)argp));
  84           kwds = params->kwds;
  85           ccase = params->ccase;
  86           cunique = params->cunique;
  87
  88           argp->checkcase = ccase ? TRUE : FALSE;
  89           argp->checkunique = cunique ? TRUE : FALSE;
  90           argp->kwds = (char **)0;
  91
  92           kp = kwds;
  93           while (kp && (*kp++))
  94             cnt++;
  95           argp->count = cnt;
  96
  97           if (cnt > 0)
  98             {
  99               /* We copy the keywords, because we can't rely on the fact
 100                  that the caller doesn't relocate or free the memory used
 101                  for the keywords (maybe he has GC)
 102                */
 103               argp->kwds = typeMalloc(char *, cnt + 1);
 104
 105               kp = kwds;
 106               if ((kptarget = argp->kwds) != 0)
 107                 {
 108                   while (kp && (*kp))
 109                     {
 110                       (*kptarget++) = strdup(*kp++);
 111                     }
 112                   *kptarget = (char *)0;
 113                 }
 114             }
 115         }
 116     }
 117   return (void *)argp;
 118 }
 119
 120 /*---------------------------------------------------------------------------
 121 |   Facility      :  libnform
 122 |   Function      :  static void *Make_Enum_Type( va_list * ap )
 123 |
 124 |   Description   :  Allocate structure for enumeration type argument.
 125 |
 126 |   Return Values :  Pointer to argument structure or NULL on error
 127 +--------------------------------------------------------------------------*/
 128 static void *
 129 Make_Enum_Type(va_list *ap)
 130 {
 131   enumParams params;
 132
 133   params.kwds = va_arg(*ap, char **);
 134   params.ccase = va_arg(*ap, int);
 135   params.cunique = va_arg(*ap, int);
 136
 137   return Generic_Enum_Type((void *)&params);
 138 }
 139
 140 /*---------------------------------------------------------------------------
 141 |   Facility      :  libnform
 142 |   Function      :  static void *Copy_Enum_Type( const void * argp )
 143 |
 144 |   Description   :  Copy structure for enumeration type argument.
 145 |
 146 |   Return Values :  Pointer to argument structure or NULL on error.
 147 +--------------------------------------------------------------------------*/
 148 static void *
 149 Copy_Enum_Type(const void *argp)
 150 {
 151   enumARG *result = (enumARG *)0;
 152
 153   if (argp)
 154     {
 155       const enumARG *ap = (const enumARG *)argp;
 156
 157       result = typeMalloc(enumARG, 1);
 158
 159       if (result)
 160         {
 161           T((T_CREATE("enumARG %p"), (void *)result));
 162           *result = *ap;
 163
 164           if (ap->count > 0)
 165             {
 166               char **kptarget;
 167               char **kp = ap->kwds;
 168               result->kwds = typeMalloc(char *, 1 + ap->count);
 169
 170               if ((kptarget = result->kwds) != 0)
 171                 {
 172                   while (kp && (*kp))
 173                     {
 174                       (*kptarget++) = strdup(*kp++);
 175                     }
 176                   *kptarget = (char *)0;
 177                 }
 178             }
 179         }
 180     }
 181   return (void *)result;
 182 }
 183
 184 /*---------------------------------------------------------------------------
 185 |   Facility      :  libnform
 186 |   Function      :  static void Free_Enum_Type( void * argp )
 187 |
 188 |   Description   :  Free structure for enumeration type argument.
 189 |
 190 |   Return Values :  -
 191 +--------------------------------------------------------------------------*/
 192 static void
 193 Free_Enum_Type(void *argp)
 194 {
 195   if (argp)
 196     {
 197       const enumARG *ap = (const enumARG *)argp;
 198
 199       if (ap->kwds && ap->count > 0)
 200         {
 201           char **kp = ap->kwds;
 202           int cnt = 0;
 203
 204           while (kp && (*kp))
 205             {
 206               free(*kp++);
 207               cnt++;
 208             }
 209           assert(cnt == ap->count);
 210           free(ap->kwds);
 211         }
 212       free(argp);
 213     }
 214 }
 215
 216 #define SKIP_SPACE(x) while(((*(x))!='\0') && (is_blank(*(x)))) (x)++
 217 #define NOMATCH 0
 218 #define PARTIAL 1
 219 #define EXACT   2
 220
 221 /*---------------------------------------------------------------------------
 222 |   Facility      :  libnform
 223 |   Function      :  static int Compare(const unsigned char * s,
 224 |                                       const unsigned char * buf,
 225 |                                       bool  ccase )
 226 |
 227 |   Description   :  Check whether or not the text in 'buf' matches the
 228 |                    text in 's', at least partial.
 229 |
 230 |   Return Values :  NOMATCH   - buffer doesn't match
 231 |                    PARTIAL   - buffer matches partially
 232 |                    EXACT     - buffer matches exactly
 233 +--------------------------------------------------------------------------*/
 234 static int
 235 Compare(const unsigned char *s, const unsigned char *buf,
 236         bool ccase)
 237 {
 238   SKIP_SPACE(buf);              /* Skip leading spaces in both texts */
 239   SKIP_SPACE(s);
 240
 241   if (*buf == '\0')
 242     {
 243       return (((*s) != '\0') ? NOMATCH : EXACT);
 244     }
 245   else
 246     {
 247       if (ccase)
 248         {
 249           while (*s++ == *buf)
 250             {
 251               if (*buf++ == '\0')
 252                 return EXACT;
 253             }
 254         }
 255       else
 256         {
 257           while (toupper(*s++) == toupper(*buf))
 258             {
 259               if (*buf++ == '\0')
 260                 return EXACT;
 261             }
 262         }
 263     }
 264   /* At this location buf points to the first character where it no longer
 265      matches with s. So if only blanks are following, we have a partial
 266      match otherwise there is no match */
 267   SKIP_SPACE(buf);
 268   if (*buf)
 269     return NOMATCH;
 270
 271   /* If it happens that the reference buffer is at its end, the partial
 272      match is actually an exact match. */
 273   return ((s[-1] != '\0') ? PARTIAL : EXACT);
 274 }
 275
 276 /*---------------------------------------------------------------------------
 277 |   Facility      :  libnform
 278 |   Function      :  static bool Check_Enum_Field(
 279 |                                      FIELD * field,
 280 |                                      const void  * argp)
 281 |
 282 |   Description   :  Validate buffer content to be a valid enumeration value
 283 |
 284 |   Return Values :  TRUE  - field is valid
 285 |                    FALSE - field is invalid
 286 +--------------------------------------------------------------------------*/
 287 static bool
 288 Check_Enum_Field(FIELD *field, const void *argp)
 289 {
 290   char **kwds = ((const enumARG *)argp)->kwds;
 291   bool ccase = ((const enumARG *)argp)->checkcase;
 292   bool unique = ((const enumARG *)argp)->checkunique;
 293   unsigned char *bp = (unsigned char *)field_buffer(field, 0);
 294   char *s, *t, *p;
 295   int res;
 296
 297   while (kwds && (s = (*kwds++)))
 298     {
 299       if ((res = Compare((unsigned char *)s, bp, ccase)) != NOMATCH)
 300         {
 301           p = t = s;            /* t is at least a partial match */
 302           if ((unique && res != EXACT))
 303             {
 304               while (kwds && (p = *kwds++))
 305                 {
 306                   if ((res = Compare((unsigned char *)p, bp, ccase)) != NOMATCH)
 307                     {
 308                       if (res == EXACT)
 309                         {
 310                           t = p;
 311                           break;
 312                         }
 313                       else
 314                         t = (char *)0;
 315                     }
 316                 }
 317             }
 318           if (t)
 319             {
 320               set_field_buffer(field, 0, t);
 321               return TRUE;
 322             }
 323           if (!p)
 324             break;
 325         }
 326     }
 327   return FALSE;
 328 }
 329
 330 static const char *dummy[] =
 331 {(char *)0};
 332
 333 /*---------------------------------------------------------------------------
 334 |   Facility      :  libnform
 335 |   Function      :  static bool Next_Enum(FIELD * field,
 336 |                                          const void * argp)
 337 |
 338 |   Description   :  Check for the next enumeration value
 339 |
 340 |   Return Values :  TRUE  - next value found and loaded
 341 |                    FALSE - no next value loaded
 342 +--------------------------------------------------------------------------*/
 343 static bool
 344 Next_Enum(FIELD *field, const void *argp)
 345 {
 346   const enumARG *args = (const enumARG *)argp;
 347   char **kwds = args->kwds;
 348   bool ccase = args->checkcase;
 349   int cnt = args->count;
 350   unsigned char *bp = (unsigned char *)field_buffer(field, 0);
 351
 352   if (kwds)
 353     {
 354       while (cnt--)
 355         {
 356           if (Compare((unsigned char *)(*kwds++), bp, ccase) == EXACT)
 357             break;
 358         }
 359       if (cnt <= 0)
 360         kwds = args->kwds;
 361       if ((cnt >= 0) || (Compare((const unsigned char *)dummy, bp, ccase) == EXACT))
 362         {
 363           set_field_buffer(field, 0, *kwds);
 364           return TRUE;
 365         }
 366     }
 367   return FALSE;
 368 }
 369
 370 /*---------------------------------------------------------------------------
 371 |   Facility      :  libnform
 372 |   Function      :  static bool Previous_Enum(
 373 |                                          FIELD * field,
 374 |                                          const void * argp)
 375 |
 376 |   Description   :  Check for the previous enumeration value
 377 |
 378 |   Return Values :  TRUE  - previous value found and loaded
 379 |                    FALSE - no previous value loaded
 380 +--------------------------------------------------------------------------*/
 381 static bool
 382 Previous_Enum(FIELD *field, const void *argp)
 383 {
 384   const enumARG *args = (const enumARG *)argp;
 385   int cnt = args->count;
 386   char **kwds = &args->kwds[cnt - 1];
 387   bool ccase = args->checkcase;
 388   unsigned char *bp = (unsigned char *)field_buffer(field, 0);
 389
 390   if (kwds)
 391     {
 392       while (cnt--)
 393         {
 394           if (Compare((unsigned char *)(*kwds--), bp, ccase) == EXACT)
 395             break;
 396         }
 397
 398       if (cnt <= 0)
 399         kwds = &args->kwds[args->count - 1];
 400
 401       if ((cnt >= 0) || (Compare((const unsigned char *)dummy, bp, ccase) == EXACT))
 402         {
 403           set_field_buffer(field, 0, *kwds);
 404           return TRUE;
 405         }
 406     }
 407   return FALSE;
 408 }
 409
 410 static FIELDTYPE typeENUM =
 411 {
 412   _HAS_ARGS | _HAS_CHOICE | _RESIDENT,
 413   1,                            /* this is mutable, so we can't be const */
 414   (FIELDTYPE *)0,
 415   (FIELDTYPE *)0,
 416   Make_Enum_Type,
 417   Copy_Enum_Type,
 418   Free_Enum_Type,
 419   INIT_FT_FUNC(Check_Enum_Field),
 420   INIT_FT_FUNC(NULL),
 421   INIT_FT_FUNC(Next_Enum),
 422   INIT_FT_FUNC(Previous_Enum),
 423 #if NCURSES_INTEROP_FUNCS
 424   Generic_Enum_Type
 425 #endif
 426 };
 427
 428 NCURSES_EXPORT_VAR(FIELDTYPE *)
 429 TYPE_ENUM = &typeENUM;
 430
 431 #if NCURSES_INTEROP_FUNCS
 432 /* The next routines are to simplify the use of ncurses from
 433    programming languages with restictions on interop with C level
 434    constructs (e.g. variable access or va_list + ellipsis constructs)
 435 */
 436 NCURSES_EXPORT(FIELDTYPE *)
 437 _nc_TYPE_ENUM(void)
 438 {
 439   return TYPE_ENUM;
 440 }
 441 #endif
 442
 443 /* fty_enum.c ends here */