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