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