form/fty_int.c

   1 /****************************************************************************
   2  * Copyright 2020 Thomas E. Dickey                                          *
   3  * Copyright 1998-2010,2012 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_int.c,v 1.31 2020/12/12 01:15:37 tom Exp $")
  39
  40 #if USE_WIDEC_SUPPORT
  41 #define isDigit(c) (iswdigit((wint_t)(c)) || isdigit(UChar(c)))
  42 #else
  43 #define isDigit(c) isdigit(UChar(c))
  44 #endif
  45
  46 #define thisARG integerARG
  47
  48 typedef struct
  49   {
  50     int precision;
  51     long low;
  52     long high;
  53   }
  54 thisARG;
  55
  56 typedef struct
  57   {
  58     int precision;
  59     long low;
  60     long high;
  61   }
  62 integerPARM;
  63
  64 /*---------------------------------------------------------------------------
  65 |   Facility      :  libnform
  66 |   Function      :  static void *Generic_This_Type( void * arg )
  67 |
  68 |   Description   :  Allocate structure for integer type argument.
  69 |
  70 |   Return Values :  Pointer to argument structure or NULL on error
  71 +--------------------------------------------------------------------------*/
  72 static void *
  73 Generic_This_Type(void *arg)
  74 {
  75   thisARG *argp = (thisARG *)0;
  76   thisARG *param = (thisARG *)arg;
  77
  78   if (param)
  79     {
  80       argp = typeMalloc(thisARG, 1);
  81
  82       if (argp)
  83         {
  84           T((T_CREATE("thisARG %p"), (void *)argp));
  85           *argp = *param;
  86         }
  87     }
  88   return (void *)argp;
  89 }
  90
  91 /*---------------------------------------------------------------------------
  92 |   Facility      :  libnform
  93 |   Function      :  static void *Make_This_Type( va_list * ap )
  94 |
  95 |   Description   :  Allocate structure for integer type argument.
  96 |
  97 |   Return Values :  Pointer to argument structure or NULL on error
  98 +--------------------------------------------------------------------------*/
  99 static void *
 100 Make_This_Type(va_list *ap)
 101 {
 102   thisARG arg;
 103
 104   arg.precision = va_arg(*ap, int);
 105   arg.low = va_arg(*ap, long);
 106   arg.high = va_arg(*ap, long);
 107
 108   return Generic_This_Type((void *)&arg);
 109 }
 110
 111 /*---------------------------------------------------------------------------
 112 |   Facility      :  libnform
 113 |   Function      :  static void *Copy_This_Type(const void * argp)
 114 |
 115 |   Description   :  Copy structure for integer type argument.
 116 |
 117 |   Return Values :  Pointer to argument structure or NULL on error.
 118 +--------------------------------------------------------------------------*/
 119 static void *
 120 Copy_This_Type(const void *argp)
 121 {
 122   const thisARG *ap = (const thisARG *)argp;
 123   thisARG *result = (thisARG *)0;
 124
 125   if (argp)
 126     {
 127       result = typeMalloc(thisARG, 1);
 128
 129       if (result)
 130         {
 131           T((T_CREATE("thisARG %p"), (void *)result));
 132           *result = *ap;
 133         }
 134     }
 135   return (void *)result;
 136 }
 137
 138 /*---------------------------------------------------------------------------
 139 |   Facility      :  libnform
 140 |   Function      :  static void Free_This_Type(void * argp)
 141 |
 142 |   Description   :  Free structure for integer type argument.
 143 |
 144 |   Return Values :  -
 145 +--------------------------------------------------------------------------*/
 146 static void
 147 Free_This_Type(void *argp)
 148 {
 149   if (argp)
 150     free(argp);
 151 }
 152
 153 /*---------------------------------------------------------------------------
 154 |   Facility      :  libnform
 155 |   Function      :  static bool Check_This_Field(
 156 |                                                 FIELD * field,
 157 |                                                 const void * argp)
 158 |
 159 |   Description   :  Validate buffer content to be a valid integer value
 160 |
 161 |   Return Values :  TRUE  - field is valid
 162 |                    FALSE - field is invalid
 163 +--------------------------------------------------------------------------*/
 164 static bool
 165 Check_This_Field(FIELD *field, const void *argp)
 166 {
 167   const thisARG *argi = (const thisARG *)argp;
 168   long low = argi->low;
 169   long high = argi->high;
 170   int prec = argi->precision;
 171   unsigned char *bp = (unsigned char *)field_buffer(field, 0);
 172   char *s = (char *)bp;
 173   long val;
 174   char buf[100];
 175   bool result = FALSE;
 176
 177   while (*bp && *bp == ' ')
 178     bp++;
 179   if (*bp)
 180     {
 181       if (*bp == '-')
 182         bp++;
 183 #if USE_WIDEC_SUPPORT
 184       if (*bp)
 185         {
 186           bool blank = FALSE;
 187           int len;
 188           int n;
 189           wchar_t *list = _nc_Widen_String((char *)bp, &len);
 190
 191           if (list != 0)
 192             {
 193               result = TRUE;
 194               for (n = 0; n < len; ++n)
 195                 {
 196                   if (blank)
 197                     {
 198                       if (list[n] != ' ')
 199                         {
 200                           result = FALSE;
 201                           break;
 202                         }
 203                     }
 204                   else if (list[n] == ' ')
 205                     {
 206                       blank = TRUE;
 207                     }
 208                   else if (!isDigit(list[n]))
 209                     {
 210                       result = FALSE;
 211                       break;
 212                     }
 213                 }
 214               free(list);
 215             }
 216         }
 217 #else
 218       while (*bp)
 219         {
 220           if (!isdigit(UChar(*bp)))
 221             break;
 222           bp++;
 223         }
 224       while (*bp && *bp == ' ')
 225         bp++;
 226       result = (*bp == '\0');
 227 #endif
 228       if (result)
 229         {
 230           val = atol(s);
 231           if (low < high)
 232             {
 233               if (val < low || val > high)
 234                 result = FALSE;
 235             }
 236           if (result)
 237             {
 238               _nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf))
 239                           "%.*ld", (prec > 0 ? prec : 0), val);
 240               set_field_buffer(field, 0, buf);
 241             }
 242         }
 243     }
 244   return (result);
 245 }
 246
 247 /*---------------------------------------------------------------------------
 248 |   Facility      :  libnform
 249 |   Function      :  static bool Check_This_Character(
 250 |                                      int c,
 251 |                                      const void * argp)
 252 |
 253 |   Description   :  Check a character for the integer type.
 254 |
 255 |   Return Values :  TRUE  - character is valid
 256 |                    FALSE - character is invalid
 257 +--------------------------------------------------------------------------*/
 258 static bool
 259 Check_This_Character(int c, const void *argp GCC_UNUSED)
 260 {
 261   return ((isDigit(UChar(c)) || (c == '-')) ? TRUE : FALSE);
 262 }
 263
 264 static FIELDTYPE typeTHIS =
 265 {
 266   _HAS_ARGS | _RESIDENT,
 267   1,                            /* this is mutable, so we can't be const */
 268   (FIELDTYPE *)0,
 269   (FIELDTYPE *)0,
 270   Make_This_Type,
 271   Copy_This_Type,
 272   Free_This_Type,
 273   INIT_FT_FUNC(Check_This_Field),
 274   INIT_FT_FUNC(Check_This_Character),
 275   INIT_FT_FUNC(NULL),
 276   INIT_FT_FUNC(NULL),
 277 #if NCURSES_INTEROP_FUNCS
 278   Generic_This_Type
 279 #endif
 280 };
 281
 282 FORM_EXPORT_VAR(FIELDTYPE *) TYPE_INTEGER = &typeTHIS;
 283
 284 #if NCURSES_INTEROP_FUNCS
 285 /* The next routines are to simplify the use of ncurses from
 286    programming languages with restrictions on interop with C level
 287    constructs (e.g. variable access or va_list + ellipsis constructs)
 288 */
 289 FORM_EXPORT(FIELDTYPE *)
 290 _nc_TYPE_INTEGER(void)
 291 {
 292   return TYPE_INTEGER;
 293 }
 294 #endif
 295
 296 /* fty_int.c ends here */