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 1236 - (view) (download) (as text)

1 : jhr 1231 /*! \file input.c
2 :     *
3 :     * \author John Reppy
4 :     */
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 :     #define vec2(a,b) vec2f(a,b)
16 :     #define vec3(a,b,c) vec3f(a,b,c)
17 : jhr 1236 #define vec4(a,b,c,d) vec4f(a,b,c,d)
18 : jhr 1231 #else
19 :     #define vec2(a,b) vec2d(a,b)
20 :     #define vec3(a,b,c) vec3d(a,b,c)
21 : jhr 1236 #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 :     char buf[256];
32 :     double f;
33 :    
34 :     while (true) {
35 :     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 :     }
52 :    
53 :     }
54 :    
55 :     Status_t Diderot_InputVec2 (const char *name, Diderot_vec2_t *v, bool hasDflt)
56 :     {
57 :     char buf[256];
58 :     double f1, f2;
59 :    
60 :     while (true) {
61 :     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 :     }
82 :    
83 :     }
84 :    
85 :     Status_t Diderot_InputVec3 (const char *name, Diderot_vec3_t *v, bool hasDflt)
86 :     {
87 :     char buf[256];
88 :     double f1, f2, f3;
89 :    
90 :     while (true) {
91 :     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 :     }
112 :    
113 :     }
114 : jhr 1236
115 :     typedef enum {
116 :     OPT_FLAG,
117 :     OPT_BOOL,
118 :     OPT_INT,
119 :     OPT_INT2,
120 :     OPT_INT3,
121 :     OPT_INT4,
122 :     OPT_REAL,
123 :     OPT_REAL2,
124 :     OPT_REAL3,
125 :     OPT_REAL4,
126 :     OPT_STRING
127 :     } OptionTy_t;
128 :    
129 :     typedef union {
130 :     char *name; // option name
131 :     OptionTy_t ty; // option type
132 :     struct { // 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 :     } hestVal;
138 :     void *val; // pointer to global that is being initialized.
139 :     } OptionDesc_t;
140 :    
141 :     static hestOpt *Options = 0;
142 :     static OptionDesc_t *OptDescs;
143 :     static int MaxNumOptions;
144 :     static int NumOptions;
145 :    
146 :     void Diderot_InitOptions ()
147 :     {
148 :     MaxNumOptions = 8; // initial size of OptDescs array
149 :     NumOptions = 0;
150 :     OptDescs = (OptionDesc_t *)malloc(MaxNumOptions * sizeof(OptionDesc_t));
151 :     if (OptDescs == 0) {
152 :     fprintf (stderr, "Diderot_InitOptions: unable to allocate memory\n");
153 :     exit (1);
154 :     }
155 :     }
156 :    
157 :     static OptionDesc_t *OptAdd (const char *name, OptionTy_t ty)
158 :     {
159 :     if (NumOptions == MaxNumOptions) {
160 :     // grow the OptDescs array
161 :     int newN = 2 * MaxNumOptions;
162 :     OptionDesc_t *newDescs = (OptionDesc_t *)malloc(newN * sizeof(OptionDesc_t));
163 :     if (newDescs == 0) {
164 :     fprintf (stderr, "AddOpt: unable to allocate memory\n");
165 :     exit (1);
166 :     }
167 :     memcpy (newDescs, OptDescs, MaxNumOptions * sizeof(OptionDesc_t));
168 :     free (OptDescs);
169 :     MaxNumOptions = newN;
170 :     }
171 :    
172 :     OptionDesc_t *desc = &(OptDescs[NumOptions++]);
173 :     desc->name = (char *)malloc(strlen(name)+1);
174 :     if (desc->name == 0) {
175 :     fprintf (stderr, "AddOpt: unable to allocate memory\n");
176 :     exit (1);
177 :     }
178 :     strcpy (desc->name, name);
179 :     desc->ty = ty;
180 :    
181 :     return desc;
182 :     }
183 :    
184 :     void Diderot_OptAddFlag (char *name, bool *flg)
185 :     {
186 :     OptionDesc_t *desc = OptAdd (name, OPT_FLAG);
187 :     desc->val = flg;
188 :     hestOptAdd (&Options, name, 0, airTypeBool, 0, 0, &(desc->hestVal.b), 0, 0);
189 :     }
190 :    
191 :     void Diderot_OptAddBool (char *name, bool *v, bool hasDflt)
192 :     {
193 :     char buf[32];
194 :     char *dflt = 0;
195 :    
196 :     if (hasDflt) {
197 :     sprintf (buf, "%s", *v ? "true" : "false");
198 :     }
199 :     OptionDesc_t *desc = OptAdd (name, OPT_BOOL);
200 :     desc->val = v;
201 :     hestOptAdd (&Options, name, 0, airTypeBool, 1, 1, &(desc->hestVal.b), dflt, 0);
202 :    
203 :     }
204 :    
205 :     void Diderot_OptAddInt (char *name, Diderot_int_t *v, bool hasDflt)
206 :     {
207 :     char buf[32];
208 :     char *dflt = 0;
209 :    
210 :     if (hasDflt) {
211 :     sprintf (buf, "%ld", (long)*v);
212 :     }
213 :     OptionDesc_t *desc = OptAdd (name, OPT_INT);
214 :     desc->val = v;
215 :     hestOptAdd (&Options, name, 0, airTypeLongInt, 1, 1, desc->hestVal.i, dflt, 0);
216 :    
217 :     }
218 :    
219 :     void Diderot_OptAddReal (char *name, Diderot_real_t *v, bool hasDflt)
220 :     {
221 :     char buf[32];
222 :     char *dflt = 0;
223 :    
224 :     if (hasDflt) {
225 :     sprintf (buf, "%lf", (double)*v);
226 :     }
227 :     OptionDesc_t *desc = OptAdd (name, OPT_REAL);
228 :     desc->val = v;
229 :     hestOptAdd (&Options, name, 0, airTypeDouble, 1, 1, desc->hestVal.r, dflt, 0);
230 :    
231 :     }
232 :    
233 :     void Diderot_OptAddReal2 (char *name, Diderot_vec2_t *v, bool hasDflt)
234 :     {
235 :     char buf[32];
236 :     char *dflt = 0;
237 :    
238 :     if (hasDflt) {
239 :     Diderot_union2_t u;
240 :     u.v = *v;
241 :     sprintf (buf, "%lf %lf", (double)(u.r[0]), (double)(u.r[1]));
242 :     }
243 :     OptionDesc_t *desc = OptAdd (name, OPT_REAL2);
244 :     desc->val = v;
245 :     hestOptAdd (&Options, name, 0, airTypeDouble, 2, 2, desc->hestVal.r, dflt, 0);
246 :    
247 :     }
248 :    
249 :     void Diderot_OptAddReal3 (char *name, Diderot_vec3_t *v, bool hasDflt)
250 :     {
251 :     char buf[64];
252 :     char *dflt = 0;
253 :    
254 :     if (hasDflt) {
255 :     Diderot_union3_t u;
256 :     u.v = *v;
257 :     sprintf (buf, "%lf %lf %lf",
258 :     (double)(u.r[0]), (double)(u.r[1]), (double)(u.r[2]));
259 :     }
260 :     OptionDesc_t *desc = OptAdd (name, OPT_REAL3);
261 :     desc->val = v;
262 :     hestOptAdd (&Options, name, 0, airTypeDouble, 3, 3, desc->hestVal.r, dflt, 0);
263 :    
264 :     }
265 :    
266 :     void Diderot_OptAddReal4 (char *name, Diderot_vec4_t *v, bool hasDflt)
267 :     {
268 :     char buf[128];
269 :     char *dflt = 0;
270 :    
271 :     if (hasDflt) {
272 :     Diderot_union3_t u;
273 :     u.v = *v;
274 :     sprintf (buf, "%lf %lf %lf %lf",
275 :     (double)(u.r[0]), (double)(u.r[1]),
276 :     (double)(u.r[2]), (double)(u.r[3]));
277 :     }
278 :     OptionDesc_t *desc = OptAdd (name, OPT_REAL4);
279 :     desc->val = v;
280 :     hestOptAdd (&Options, name, 0, airTypeDouble, 4, 4, desc->hestVal.i, dflt, 0);
281 :    
282 :     }
283 :    
284 :     void Diderot_OptAddString (char *name, char **v, bool hasDflt)
285 :     {
286 :     char *dflt = 0;
287 :    
288 :     if (hasDflt) {
289 :     dflt = *v;
290 :     }
291 :     OptionDesc_t *desc = OptAdd (name, OPT_STRING);
292 :     desc->val = v;
293 :     hestOptAdd (&Options, name, 0, airTypeString, 1, 1, desc->hestVal.s, dflt, 0);
294 :    
295 :     }
296 :    
297 :     void Diderot_ProcessOptions (int argc, const char **argv)
298 :     {
299 :     airArray *mop = airMopNew();
300 :     hestParm *hparm = hestParmNew();
301 :     hparm->noArgsIsNoProblem = AIR_TRUE;
302 :     hestParseOrDie (
303 :     Options, argc-1, argv+1, hparm,
304 :     argv[0], 0, AIR_TRUE, AIR_TRUE, AIR_TRUE);
305 :     airMopAdd (mop, hparm, (airMopper)hestParmFree, airMopAlways);
306 :     airMopAdd (mop, Options, (airMopper)hestOptFree, airMopAlways);
307 :     airMopAdd (mop, Options, (airMopper)hestParseFree, airMopAlways);
308 :    
309 :     // convert options to Diderot representation
310 :     for (int i = 0; i < NumOptions; i++) {
311 :     OptionDesc_t *desc = &(OptDescs[i]);
312 :     switch (desc->ty) {
313 :     case OPT_FLAG:
314 :     break;
315 :     case OPT_BOOL:
316 :     *(bool*)(desc->val) = desc->hestVal.b ? true : false;
317 :     break;
318 :     case OPT_INT:
319 :     *(Diderot_int_t *)(desc->val) = (Diderot_int_t)(desc->hestVal.i[0]);
320 :     break;
321 :     // case OPT_INT2:
322 :     // case OPT_INT3:
323 :     // case OPT_INT4:
324 :     case OPT_REAL:
325 :     *(Diderot_real_t *)(desc->val) = (Diderot_real_t)(desc->hestVal.r[0]);
326 :     break;
327 :     case OPT_REAL2:
328 :     *(Diderot_vec2_t *)(desc->val) = vec2(
329 :     (Diderot_real_t)(desc->hestVal.r[0]),
330 :     (Diderot_real_t)(desc->hestVal.r[1]));
331 :     case OPT_REAL3:
332 :     *(Diderot_vec3_t *)(desc->val) = vec3(
333 :     (Diderot_real_t)(desc->hestVal.r[0]),
334 :     (Diderot_real_t)(desc->hestVal.r[1]),
335 :     (Diderot_real_t)(desc->hestVal.r[2]));
336 :     case OPT_REAL4:
337 :     *(Diderot_vec4_t *)(desc->val) = vec4(
338 :     (Diderot_real_t)(desc->hestVal.r[0]),
339 :     (Diderot_real_t)(desc->hestVal.r[1]),
340 :     (Diderot_real_t)(desc->hestVal.r[2]),
341 :     (Diderot_real_t)(desc->hestVal.r[3]));
342 :     break;
343 :     case OPT_STRING: {
344 :     char *s = (char *)malloc(strlen(desc->hestVal.s) + 1);
345 :     if (s == 0) {
346 :     fprintf (stderr, "Diderot_ProcessOptions: unable to allocate memory\n");
347 :     exit (1);
348 :     }
349 :     strcpy (s, desc->hestVal.s);
350 :     *(char **)(desc->val) = s;
351 :     }
352 :     break;
353 :     default:
354 :     fprintf (stderr, "Diderot_ProcessOptions: bogus option type\n");
355 :     exit (1);
356 :     }
357 :     }
358 :    
359 :     airMopOkay(mop);
360 :    
361 :     }

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