ncurses 6.0 - patch 20171216
[ncurses.git] / form / fty_generic.c
1 /****************************************************************************
2  * Copyright (c) 2008-2012,2016 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_generic.c,v 1.7 2016/01/23 21:32:00 tom Exp $")
38
39 /*
40  * This is not a full implementation of a field type, but adds some
41  * support for higher level languages with some restrictions to interop
42  * with C language. Especially the collection of arguments for the
43  * various fieldtypes is not based on the vararg C mechanism, but on a
44  * iterator based callback mechanism that allowes the high level language
45  * to provide the arguments as a structure. Most languages have mechanisms
46  * to layout structures so that they can be passed to C.
47  * The languages can register a new generic fieldtype dynamically and store
48  * a handle (key) to the calling object as an argument. Together with that
49  * it can register a freearg callback, so that the high level language
50  * remains in control of the memory management of the arguments they pass.
51  * The design idea is, that the high-level language - typically a OO
52  * language like C# or Java, uses it's own dispatching mechanisms
53  * (polymorphism) to call the proper check routines responsible for the
54  * argument type. So these language implement typically only one generic
55  * fieldtype they register with the forms library using this call.
56  *
57  * For that purpose we have extended the fieldtype struc by a new element
58  * that gets the arguments from a single struct passed by the caller. 
59  * 
60  */
61 #if NCURSES_INTEROP_FUNCS
62
63 /*---------------------------------------------------------------------------
64 |   Facility      :  libnform  
65 |   Function      :  static void *Generic_This_Type( void * arg )
66 |   
67 |   Description   :  We interpret the passed arg just as a handle the
68 |                    calling language uses to keep track of its allocated
69 |                    argument structures. We can simply copy it back.
70 |
71 |   Return Values :  Pointer to argument structure
72 +--------------------------------------------------------------------------*/
73 static void *
74 Generic_This_Type(void *arg)
75 {
76   return (arg);
77 }
78
79 /*---------------------------------------------------------------------------
80 |   Facility      :  libnform
81 |   Function      :  FIELDTYPE *_nc_generic_fieldtype(
82 |                       bool (* const field_check)(FIELD *,const void *),
83 |                       bool (* const char_check) (int, const void *),
84 |                       bool (*const next)(FORM*,FIELD*,const void*),
85 |                       bool (*const prev)(FORM*,FIELD*,const void*),
86 |                       void (*freecallback)(void*))
87 |
88 |   Description   :  Create a new fieldtype. The application programmer must
89 |                    write a field_check and a char_check function and give
90 |                    them as input to this call. A callback to allow the
91 |                    release of the allocated memory must also be provided.
92 |                    For generic field types, we provide some more 
93 |                    information about the field as parameters.
94 |
95 |                    If an error occurs, errno is set to
96 |                       E_BAD_ARGUMENT  - invalid arguments
97 |                       E_SYSTEM_ERROR  - system error (no memory)
98 |
99 |   Return Values :  Fieldtype pointer or NULL if error occurred
100 +--------------------------------------------------------------------------*/
101 NCURSES_EXPORT(FIELDTYPE *)
102 _nc_generic_fieldtype(bool (*const field_check) (FORM *, FIELD *, const void *),
103                       bool (*const char_check) (int, FORM *, FIELD *, const
104                                                 void *),
105                       bool (*const next) (FORM *, FIELD *, const void *),
106                       bool (*const prev) (FORM *, FIELD *, const void *),
107                       void (*freecallback) (void *))
108 {
109   int code = E_SYSTEM_ERROR;
110   FIELDTYPE *res = (FIELDTYPE *)0;
111
112   T((T_CALLED("_nc_generic_fieldtype(%p,%p,%p,%p,%p)"),
113      TR_FUNC(field_check),
114      TR_FUNC(char_check),
115      TR_FUNC(next),
116      TR_FUNC(prev),
117      TR_FUNC(freecallback)));
118
119   if (field_check || char_check)
120     {
121       res = typeMalloc(FIELDTYPE, 1);
122
123       if (res)
124         {
125           *res = *_nc_Default_FieldType;
126           SetStatus(res, (_HAS_ARGS | _GENERIC));
127           res->fieldcheck.gfcheck = field_check;
128           res->charcheck.gccheck = char_check;
129           res->genericarg = Generic_This_Type;
130           res->freearg = freecallback;
131           res->enum_next.gnext = next;
132           res->enum_prev.gprev = prev;
133           code = E_OK;
134         }
135     }
136   else
137     code = E_BAD_ARGUMENT;
138
139   if (E_OK != code)
140     SET_ERROR(code);
141
142   returnFieldType(res);
143 }
144
145 /*---------------------------------------------------------------------------
146 |   Facility      :  libnform  
147 |   Function      :  static TypeArgument *GenericArgument(
148 |                      const FIELDTYPE* typ,
149 |                      int (*argiterator)(void**),
150 |                      int* err)
151 |   
152 |   Description   :  The iterator callback must browse through all fieldtype
153 |                    parameters that have an argument associated with the
154 |                    type. The iterator returns 1 if the operation to get
155 |                    the next element was successfull, 0 otherwise. If the
156 |                    iterator could move to the next argument, it fills
157 |                    the void* pointer representing the argument into the
158 |                    location provided as argument to the iterator.
159 |                    The err reference is used to keep track of errors.
160 |
161 |   Return Values :  Pointer to argument structure
162 +--------------------------------------------------------------------------*/
163 static TypeArgument *
164 GenericArgument(const FIELDTYPE *typ,
165                 int (*argiterator) (void **), int *err)
166 {
167   TypeArgument *res = (TypeArgument *)0;
168
169   if (typ != 0 && (typ->status & _HAS_ARGS) != 0 && err != 0 && argiterator != 0)
170     {
171       if (typ->status & _LINKED_TYPE)
172         {
173           /* Composite fieldtypes keep track internally of their own memory */
174           TypeArgument *p = typeMalloc(TypeArgument, 1);
175
176           if (p)
177             {
178               p->left = GenericArgument(typ->left, argiterator, err);
179               p->right = GenericArgument(typ->right, argiterator, err);
180               return p;
181             }
182           else
183             *err += 1;
184         }
185       else
186         {
187           assert(typ->genericarg != (void *)0);
188           if (typ->genericarg == 0)
189             *err += 1;
190           else
191             {
192               void *argp;
193               int valid = argiterator(&argp);
194
195               if (valid == 0 || argp == 0 ||
196                   !(res = (TypeArgument *)typ->genericarg(argp)))
197                 {
198                   *err += 1;
199                 }
200             }
201         }
202     }
203   return res;
204 }
205
206 /*---------------------------------------------------------------------------
207 |   Facility      :  libnform  
208 |   Function      :  int _nc_set_generic_fieldtype(
209 |                      FIELD* field,
210 |                      FIELDTYPE* ftyp,
211 |                      int (*argiterator)(void**))
212 |   
213 |   Description   :  Assign the fieldtype to the field and use the iterator
214 |                    mechanism to get the arguments when a check is 
215 |                    performed.
216 |
217 |   Return Values :  E_OK if all went well
218 |                    E_SYSTEM_ERROR if an error occurred
219 +--------------------------------------------------------------------------*/
220 NCURSES_EXPORT(int)
221 _nc_set_generic_fieldtype(FIELD *field,
222                           FIELDTYPE *ftyp,
223                           int (*argiterator) (void **))
224 {
225   int code = E_SYSTEM_ERROR;
226   int err = 0;
227
228   if (field)
229     {
230       if (field && field->type)
231         _nc_Free_Type(field);
232
233       field->type = ftyp;
234       if (ftyp)
235         {
236           if (argiterator)
237             {
238               /* The precondition is that the iterator is reset */
239               field->arg = (void *)GenericArgument(field->type, argiterator, &err);
240
241               if (err)
242                 {
243                   _nc_Free_Argument(field->type, (TypeArgument *)(field->arg));
244                   field->type = (FIELDTYPE *)0;
245                   field->arg = (void *)0;
246                 }
247               else
248                 {
249                   code = E_OK;
250                   if (field->type)
251                     field->type->ref++;
252                 }
253             }
254         }
255       else
256         {
257           field->arg = (void *)0;
258           code = E_OK;
259         }
260     }
261   return code;
262 }
263
264 /*---------------------------------------------------------------------------
265 |   Facility      :  libnform  
266 |   Function      :  WINDOW* _nc_form_cursor(
267 |                      FORM* form,
268 |                      int *pRow, int *pCol)
269 |   
270 |   Description   :  Get the current position of the form cursor position
271 |                    We also return the field window
272 |
273 |   Return Values :  The fields Window or NULL on error
274 +--------------------------------------------------------------------------*/
275 NCURSES_EXPORT(WINDOW *)
276 _nc_form_cursor(const FORM *form, int *pRow, int *pCol)
277 {
278   int code = E_SYSTEM_ERROR;
279   WINDOW *res = (WINDOW *)0;
280
281   if (!(form == 0 || pRow == 0 || pCol == 0))
282     {
283       *pRow = form->currow;
284       *pCol = form->curcol;
285       res = form->w;
286       code = E_OK;
287     }
288   if (code != E_OK)
289     SET_ERROR(code);
290   return res;
291 }
292
293 #else
294 extern void _nc_fty_generic(void);
295 void
296 _nc_fty_generic(void)
297 {
298 }
299 #endif
300
301 /* fty_generic.c ends here */