Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /branches/pure-cfg/src/lib/common/input.c
ViewVC logotype

Annotation of /branches/pure-cfg/src/lib/common/input.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1253 - (view) (download) (as text)

1 : jhr 1231 /*! \file input.c
2 :     *
3 : glk 1252 * \author John Reppy, Gordon Kindlmann
4 : jhr 1231 */
5 :    
6 :     /*
7 :     * COPYRIGHT (c) 2011 The Diderot Project (http://diderot-language.cs.uchicago.edu)
8 :     * All rights reserved.
9 :     */
10 :     #include "Diderot/diderot.h"
11 :     #include <teem/hest.h>
12 :    
13 :     /* FIXME: eventally we should change the naming conventions in the header files to be generic */
14 :     #if defined(DIDEROT_SINGLE_PRECISION)
15 : glk 1252 #define vec2(a,b) vec2f(a,b)
16 :     #define vec3(a,b,c) vec3f(a,b,c)
17 :     #define vec4(a,b,c,d) vec4f(a,b,c,d)
18 : jhr 1231 #else
19 : glk 1252 #define vec2(a,b) vec2d(a,b)
20 :     #define vec3(a,b,c) vec3d(a,b,c)
21 :     #define vec4(a,b,c,d) vec4d(a,b,c,d)
22 : jhr 1231 #endif
23 :    
24 :     Status_t Diderot_InputString (const char *name, const char **v, bool hasDflt)
25 :     {
26 :     return DIDEROT_FAIL;
27 :     }
28 :    
29 :     Status_t Diderot_InputReal (const char *name, Diderot_real_t *v, bool hasDflt)
30 :     {
31 : glk 1252 char buf[256];
32 :     double f;
33 :    
34 : jhr 1231 while (true) {
35 : glk 1252 if (hasDflt)
36 :     printf("Enter value for %s (default %lf): ", name, (double)*v);
37 :     else
38 :     printf("Enter value for %s: ", name);
39 :     fflush (stdout);
40 :    
41 :     char *p = fgets(buf, sizeof(buf), stdin);
42 :     if (p == NULL)
43 :     return DIDEROT_FAIL; // EOF
44 :     int n = sscanf(buf, "%lf\n", &f);
45 :     if (n == 1) {
46 :     *v = (Diderot_real_t)f;
47 :     return DIDEROT_OK;;
48 :     }
49 :     else if (hasDflt)
50 :     return DIDEROT_OK;;
51 : jhr 1231 }
52 : glk 1252
53 : jhr 1231 }
54 :    
55 :     Status_t Diderot_InputVec2 (const char *name, Diderot_vec2_t *v, bool hasDflt)
56 :     {
57 : glk 1252 char buf[256];
58 :     double f1, f2;
59 :    
60 : jhr 1231 while (true) {
61 : glk 1252 if (hasDflt) {
62 :     Diderot_union2_t u;
63 :     u.v = *v;
64 :     printf("Enter value for %s (default %f %f): ",
65 :     name, (double)(u.r[0]), (double)(u.r[1]));
66 :     }
67 :     else
68 :     printf("Enter value for %s: ", name);
69 :     fflush (stdout);
70 :    
71 :     char *p = fgets(buf, sizeof(buf), stdin);
72 :     if (p == NULL)
73 :     return DIDEROT_FAIL; // EOF
74 :     int n = sscanf(buf, "%lf %lf\n", &f1, &f2);
75 :     if (n == 2) {
76 :     *v = vec2((Diderot_real_t)f1, (Diderot_real_t)f2);
77 :     return DIDEROT_OK;;
78 :     }
79 :     else if (hasDflt)
80 :     return DIDEROT_OK;;
81 : jhr 1231 }
82 : glk 1252
83 : jhr 1231 }
84 :    
85 :     Status_t Diderot_InputVec3 (const char *name, Diderot_vec3_t *v, bool hasDflt)
86 :     {
87 : glk 1252 char buf[256];
88 :     double f1, f2, f3;
89 :    
90 : jhr 1231 while (true) {
91 : glk 1252 if (hasDflt) {
92 :     Diderot_union3_t u;
93 :     u.v = *v;
94 :     printf("Enter value for %s (default %f %f %f): ",
95 :     name, (double)(u.r[0]), (double)(u.r[1]), (double)(u.r[2]));
96 :     }
97 :     else
98 :     printf("Enter value for %s: ", name);
99 :     fflush (stdout);
100 :    
101 :     char *p = fgets(buf, sizeof(buf), stdin);
102 :     if (p == NULL)
103 :     return DIDEROT_FAIL; // EOF
104 :     int n = sscanf(buf, "%lf %lf %lf\n", &f1, &f2, &f3);
105 :     if (n == 3) {
106 :     *v = vec3((Diderot_real_t)f1, (Diderot_real_t)f2, (Diderot_real_t)f3);
107 :     return DIDEROT_OK;;
108 :     }
109 :     else if (hasDflt)
110 :     return DIDEROT_OK;;
111 : jhr 1231 }
112 : glk 1252
113 : jhr 1231 }
114 : jhr 1236
115 : jhr 1243 //! Option type tags
116 : jhr 1236 typedef enum {
117 : glk 1253 optTypeUnknown, // 0
118 :     optTypeFlag, // 1
119 :     optTypeBool, // 2
120 :     optTypeInt, // 3
121 :     optTypeReal, // 4
122 :     optTypeReal2, // 5
123 :     optTypeReal3, // 6
124 :     optTypeReal4, // 7
125 :     optTypeString // 8
126 : glk 1252 } optType_t;
127 : jhr 1236
128 : glk 1252 typedef struct {
129 :     char *name; // option name
130 :     char *desc; // option description (a phrase or sentence)
131 :     optType_t ty; // option type
132 :     union { // storage that is passed into hest
133 :     int b; // storage for boolean-valued options
134 :     double r[4]; // storage for real-valued options
135 :     int64_t i[4]; // storage for integer-valued options
136 :     char *s; // storage for string-valued options
137 :     } hval;
138 :     void *valp; // pointer to Diderot global variable being set
139 :     } optDef_t;
140 : jhr 1236
141 : glk 1252 struct Diderot_Options_s {
142 :     char *progInfo; // documentation string for describing whole program,
143 :     // intended to be one or more sentences
144 :     hestOpt *hopt; // dynamically managed hest options
145 :     hestParm *hparm; // hest parameters
146 : glk 1253 optDef_t **odef; // dynamically reallocated via odefArr
147 : glk 1252 unsigned int odefNum; // length of meaningful values in odef[]
148 :     airArray *odefArr; // manages odef and odefNum;
149 :     airArray *mop; // manages hopt, hparm, and odefArr
150 :     };
151 : jhr 1236
152 : glk 1253 static void *optDefNew () {
153 :     optDef_t *odef = AIR_CALLOC(1, optDef_t);
154 : glk 1252 odef->name = odef->desc = NULL;
155 :     odef->ty = optTypeUnknown;
156 : glk 1253 /* not trying to initialize hval */
157 : glk 1252 odef->valp = NULL;
158 : glk 1253 return (void*)odef;
159 : jhr 1236 }
160 :    
161 : glk 1253 static void *optDefNix (void *_odef) {
162 : glk 1252 optDef_t *odef = (optDef_t *)_odef;
163 :     airFree(odef->name);
164 :     airFree(odef->desc);
165 :     if (optTypeString == odef->ty) {
166 :     airFree(odef->hval.s);
167 : jhr 1236 }
168 : glk 1253 airFree(odef);
169 :     return NULL;
170 : glk 1252 }
171 : jhr 1236
172 : glk 1252 struct Diderot_Options_s *Diderot_Options_New (void) {
173 :     static const char me[]="Diderot_Options_New";
174 :     struct Diderot_Options_s *dopts = AIR_CALLOC(1, struct Diderot_Options_s);
175 :     if (!dopts) {
176 :     fprintf (stderr, "%s: unable to allocate output\n", me);
177 :     exit (1);
178 : jhr 1236 }
179 : glk 1252 dopts->progInfo = NULL;
180 :     dopts->mop = airMopNew();
181 :     dopts->hopt = NULL;
182 :     dopts->hparm = hestParmNew();
183 :     dopts->hparm->noArgsIsNoProblem = AIR_TRUE;
184 :     airMopAdd(dopts->mop, dopts->hparm, (airMopper)hestParmFree, airMopAlways);
185 :     dopts->odef = NULL;
186 :     dopts->odefNum = 0;
187 :     dopts->odefArr = airArrayNew((void**)(&dopts->odef), &dopts->odefNum,
188 : glk 1253 sizeof(optDef_t*), 8 /* allocation increment */);
189 : glk 1252 if (!(dopts->odefArr)) {
190 :     fprintf (stderr, "%s: unable to allocate option array\n", me);
191 :     exit (1);
192 :     }
193 :     airMopAdd(dopts->mop, dopts->odefArr, (airMopper)airArrayNuke, airMopAlways);
194 :    
195 :     return dopts;
196 : jhr 1236 }
197 :    
198 : glk 1252 void Diderot_Options_Nix (struct Diderot_Options_s *dopts) {
199 :     if (dopts) {
200 :     airFree(dopts->progInfo);
201 :     airMopOkay(dopts->mop);
202 :     free(dopts);
203 :     }
204 :     return;
205 : jhr 1236 }
206 :    
207 : glk 1252 void Diderot_OptProgramInfoSet (struct Diderot_Options_s *dopts,
208 :     const char *progInfo) {
209 :     static const char me[]="Diderot_OptProgramInfoSet";
210 : jhr 1236
211 : glk 1252 if (progInfo) {
212 :     if (!( dopts->progInfo = airStrdup(progInfo) )) {
213 :     fprintf (stderr, "%s: unable to copy program info", me);
214 :     exit (1);
215 :     }
216 : jhr 1236 }
217 :     }
218 :    
219 : glk 1252 static optDef_t *optAdd (struct Diderot_Options_s *dopts,
220 :     const char *name, const char *desc,
221 :     void *valp, optType_t ty) {
222 :     static const char me[]="optAdd";
223 :     unsigned int nidx;
224 :    
225 :     if (!( name && desc )) {
226 :     fprintf (stderr, "%s: need both name (%p) and desc (%p) non-NULL\n",
227 :     me, name, desc);
228 :     exit (1);
229 : jhr 1236 }
230 : glk 1252 nidx = airArrayLenIncr(dopts->odefArr, 1);
231 :     if (!dopts->odef) {
232 :     fprintf (stderr, "%s: unable to reallocate option array\n", me);
233 :     exit (1);
234 :     }
235 : glk 1253 optDef_t *odef = dopts->odef[nidx];
236 : glk 1252 odef->name = airStrdup(name);
237 :     odef->desc = airStrdup(desc);
238 :     if (!(odef->name && odef->desc)) {
239 :     fprintf (stderr, "%s: unable to allocate strings (%p,%p)\n",
240 :     me, odef->name, odef->desc);
241 :     exit (1);
242 :     }
243 :     odef->valp = valp;
244 :     odef->ty = ty;
245 :    
246 :     return odef;
247 :     }
248 : jhr 1236
249 : glk 1252 void Diderot_OptAddFlag (struct Diderot_Options_s *dopts,
250 :     const char *name, const char *desc,
251 :     bool *flg) {
252 :     optDef_t *odef = optAdd (dopts, name, desc, (void*)flg, optTypeFlag);
253 :     hestOptAdd (&dopts->hopt, name, NULL, airTypeInt, 0, 0, &odef->hval.b,
254 :     NULL, desc);
255 : jhr 1236 }
256 :    
257 : glk 1252 void Diderot_OptAddBool (struct Diderot_Options_s *dopts,
258 :     const char *name, const char *desc,
259 :     bool *v, bool hasDflt) {
260 :     optDef_t *odef = optAdd (dopts, name, desc, (void*)v, optTypeBool);
261 :     hestOptAdd (&dopts->hopt, name, "bool", airTypeBool, 1, 1, &odef->hval.b,
262 :     hasDflt ? (*v ? "true" : "false") : NULL, desc);
263 :     }
264 : jhr 1236
265 : glk 1252 void Diderot_OptAddInt (struct Diderot_Options_s *dopts,
266 :     const char *name, const char *desc,
267 :     Diderot_int_t *v, bool hasDflt) {
268 :     char buf[AIR_STRLEN_HUGE] = "";
269 : jhr 1236 if (hasDflt) {
270 : glk 1252 sprintf (buf, "%ld", (long)*v);
271 : jhr 1236 }
272 : glk 1252 optDef_t *odef = optAdd (dopts, name, desc, (void*)v, optTypeInt);
273 :     hestOptAdd (&dopts->hopt, name, "int", airTypeLongInt, 1, 1, odef->hval.i,
274 :     hasDflt ? buf : NULL, desc);
275 : jhr 1236 }
276 :    
277 : glk 1252 void Diderot_OptAddReal (struct Diderot_Options_s *dopts,
278 :     const char *name, const char *desc,
279 :     Diderot_real_t *v, bool hasDflt) {
280 :     char buf[AIR_STRLEN_HUGE] = "";
281 : jhr 1236 if (hasDflt) {
282 : glk 1252 sprintf (buf, "%lf", (double)*v);
283 : jhr 1236 }
284 : glk 1252 optDef_t *odef = optAdd (dopts, name, desc, (void*)v, optTypeReal);
285 :     hestOptAdd (&dopts->hopt, name, "val", airTypeDouble, 1, 1, odef->hval.r,
286 :     hasDflt ? buf : NULL, desc);
287 : jhr 1236 }
288 :    
289 : glk 1252 void Diderot_OptAddReal2 (struct Diderot_Options_s *dopts,
290 :     const char *name, const char *desc,
291 :     Diderot_vec2_t *v, bool hasDflt) {
292 :     char buf[AIR_STRLEN_HUGE] = "";
293 : jhr 1236
294 :     if (hasDflt) {
295 : glk 1252 Diderot_union2_t u;
296 :     u.v = *v;
297 :     sprintf (buf, "%lf %lf", (double)(u.r[0]), (double)(u.r[1]));
298 : jhr 1236 }
299 : glk 1252 optDef_t *odef = optAdd (dopts, name, desc, (void*)v, optTypeReal2);
300 :     hestOptAdd (&dopts->hopt, name, "x y", airTypeDouble, 2, 2, odef->hval.r,
301 :     hasDflt ? buf : NULL, desc);
302 : jhr 1236 }
303 :    
304 : glk 1252 void Diderot_OptAddReal3 (struct Diderot_Options_s *dopts,
305 :     const char *name, const char *desc,
306 :     Diderot_vec3_t *v, bool hasDflt) {
307 :     char buf[AIR_STRLEN_HUGE] = "";
308 : jhr 1236
309 :     if (hasDflt) {
310 : glk 1252 Diderot_union3_t u;
311 :     u.v = *v;
312 :     sprintf (buf, "%lf %lf %lf",
313 :     (double)(u.r[0]), (double)(u.r[1]), (double)(u.r[2]));
314 : jhr 1236 }
315 : glk 1252 optDef_t *odef = optAdd (dopts, name, desc, (void*)v, optTypeReal3);
316 :     hestOptAdd (&dopts->hopt, name, "x y z", airTypeDouble, 3, 3, odef->hval.r,
317 :     hasDflt ? buf : NULL, desc);
318 : jhr 1236 }
319 :    
320 : glk 1252 void Diderot_OptAddReal4 (struct Diderot_Options_s *dopts,
321 :     const char *name, const char *desc,
322 :     Diderot_vec4_t *v, bool hasDflt) {
323 :     char buf[AIR_STRLEN_HUGE] = "";
324 : jhr 1236
325 :     if (hasDflt) {
326 : glk 1252 Diderot_union4_t u;
327 :     u.v = *v;
328 :     sprintf (buf, "%lf %lf %lf %lf",
329 :     (double)(u.r[0]), (double)(u.r[1]),
330 :     (double)(u.r[2]), (double)(u.r[3]));
331 : jhr 1236 }
332 : glk 1252 optDef_t *odef = optAdd (dopts, name, desc, (void*)v, optTypeReal4);
333 :     hestOptAdd (&dopts->hopt, name, "x y z w", airTypeDouble, 4, 4, odef->hval.r,
334 :     hasDflt ? buf : NULL, desc);
335 :     }
336 : jhr 1236
337 : glk 1252 void Diderot_OptAddString (struct Diderot_Options_s *dopts,
338 :     const char *name, const char *desc,
339 :     char **v, bool hasDflt) {
340 :     optDef_t *odef = optAdd (dopts, name, desc, (void*)v, optTypeString);
341 :     hestOptAdd (&dopts->hopt, name, "str", airTypeString, 1, 1, &odef->hval.s,
342 :     hasDflt ? *v : NULL, desc);
343 : jhr 1236 }
344 :    
345 : glk 1252 void Diderot_ProcessOptions (struct Diderot_Options_s *dopts,
346 :     int argc, const char **argv) {
347 :     static const char me[]="Diderot_ProcessOptions";
348 : jhr 1236
349 : glk 1252 hestParseOrDie (dopts->hopt, argc-1, argv+1, dopts->hparm, argv[0],
350 :     dopts->progInfo ? dopts->progInfo : "(no program info set)",
351 :     AIR_TRUE, AIR_TRUE, AIR_TRUE);
352 :     airMopAdd (dopts->mop, dopts->hopt, (airMopper)hestOptFree, airMopAlways);
353 :     airMopAdd (dopts->mop, dopts->hopt, (airMopper)hestParseFree, airMopAlways);
354 : jhr 1236
355 : glk 1252 // convert values learned by hest to their Diderot representations
356 :     for (int i = 0; i < dopts->odefNum; i++) {
357 : glk 1253 optDef_t *odef = dopts->odef[i];
358 : glk 1252 switch (odef->ty) {
359 :     case optTypeFlag:
360 :     case optTypeBool:
361 :     *(bool*)(odef->valp) = odef->hval.b ? true : false;
362 :     break;
363 :     case optTypeInt:
364 :     *(Diderot_int_t *)(odef->valp) = (Diderot_int_t)(odef->hval.i[0]);
365 :     break;
366 :     case optTypeReal:
367 :     *(Diderot_real_t *)(odef->valp) = (Diderot_real_t)(odef->hval.r[0]);
368 :     break;
369 :     case optTypeReal2:
370 :     *(Diderot_vec2_t *)(odef->valp) = vec2((Diderot_real_t)(odef->hval.r[0]),
371 :     (Diderot_real_t)(odef->hval.r[1]));
372 :     break;
373 :     case optTypeReal3:
374 :     *(Diderot_vec3_t *)(odef->valp) = vec3((Diderot_real_t)(odef->hval.r[0]),
375 :     (Diderot_real_t)(odef->hval.r[1]),
376 :     (Diderot_real_t)(odef->hval.r[2]));
377 :     break;
378 :     case optTypeReal4:
379 :     *(Diderot_vec4_t *)(odef->valp) = vec4((Diderot_real_t)(odef->hval.r[0]),
380 :     (Diderot_real_t)(odef->hval.r[1]),
381 :     (Diderot_real_t)(odef->hval.r[2]),
382 :     (Diderot_real_t)(odef->hval.r[3]));
383 :     break;
384 :     case optTypeString:
385 :     if (!( *(char **)(odef->valp) = airStrdup(odef->hval.s) )) {
386 :     fprintf(stderr, "%s: unable to allocate string copy\n", me);
387 :     exit (1);
388 :     }
389 :     break;
390 :     default:
391 :     fprintf (stderr, "%s: unknown option type %d\n", me, odef->ty);
392 :     exit (1);
393 :     }
394 : jhr 1243 }
395 : jhr 1236 }

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0