File: | src/printObject.c |
Warning: | line 857, column 5 Value stored to 'slen' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* |
2 | * CAPS: Computational Aircraft Prototype Syntheses |
3 | * |
4 | * Object Output Utility |
5 | * |
6 | * * Copyright 2014-2023, Massachusetts Institute of Technology |
7 | * Licensed under The GNU Lesser General Public License, version 2.1 |
8 | * See http://www.opensource.org/licenses/lgpl-2.1.php |
9 | * |
10 | */ |
11 | |
12 | #include "caps.h" |
13 | #include <string.h> |
14 | |
15 | #ifdef WIN32 |
16 | #define PATH_MAX4096 _MAX_PATH |
17 | #else |
18 | #include <limits.h> |
19 | #endif |
20 | |
21 | #define DEBUG |
22 | |
23 | typedef struct { |
24 | char *name; |
25 | enum capsvType vtype; |
26 | int nrow; |
27 | int ncol; |
28 | bool_Bool nulldata; |
29 | int *iValue; |
30 | double *dValue; |
31 | char *sValue; |
32 | capsTuple *tValue; |
33 | int ndot; |
34 | char **derivNames; |
35 | double **derivs; |
36 | int *lens; |
37 | int *len_wrts; |
38 | } ValueData; |
39 | |
40 | typedef struct { |
41 | char *id; |
42 | ValueData *analysisIn; |
43 | ValueData *analysisOut; |
44 | ValueData *analysisDynO; |
45 | int inCount; |
46 | int outCount; |
47 | int dynOCount; |
48 | bool_Bool dirty; |
49 | } AIMData; |
50 | |
51 | typedef struct { |
52 | char *sourceAim; |
53 | char *targetAim; |
54 | char *sourceVar; |
55 | char *targetVar; |
56 | } ValLinkData; |
57 | |
58 | typedef struct { |
59 | char *sourceAim; |
60 | char *targetAim; |
61 | char *sourceVar; |
62 | char *targetVar; |
63 | char *bound; |
64 | } GeomLinkData; |
65 | |
66 | |
67 | |
68 | static int |
69 | printValues(capsObj pobject, capsObj object, int indent) |
70 | { |
71 | int i, j, status, len, nerr, dim, nrow, ncol, range, rank, pmtr; |
72 | int nLines, *ints; |
73 | char *str, *phase, *pname, *pID, *uID, **dotnames, **lines; |
74 | const char *units; |
75 | const int *partial; |
76 | double *reals; |
77 | const void *data; |
78 | short datetime[6]; |
79 | CAPSLONGunsigned long sNum; |
80 | enum capsoType otype; |
81 | enum capssType stype; |
82 | enum capsvType vtype; |
83 | enum capsFixed lfixed, sfixed; |
84 | enum capsNull nval; |
85 | capsTuple *tuple; |
86 | capsObj link, parent; |
87 | capsErrs *errors; |
88 | capsOwn own; |
89 | |
90 | status = caps_info(object, &pname, &otype, &stype, &link, &parent, &own); |
91 | if (status < CAPS_SUCCESS0) return status; |
92 | status = caps_ownerInfo(pobject, own, &phase, &pname, &pID, &uID, &nLines, |
93 | &lines, datetime, &sNum); |
94 | if (status != CAPS_SUCCESS0) return status; |
95 | if ((sNum == 0) && (stype != USER)) { |
96 | for (i = 0; i < indent; i++) printf(" "); |
97 | printf(" value = UNITITIALIZED\n"); |
98 | return CAPS_SUCCESS0; |
99 | } |
100 | status = caps_getValue(object, &vtype, &nrow, &ncol, &data, &partial, &units, |
101 | &nerr, &errors); |
102 | if (errors != NULL((void*)0)) caps_freeError(errors); |
103 | if (status != CAPS_SUCCESS0) return status; |
104 | status = caps_getValueProps(object, &dim, &pmtr, &lfixed, &sfixed, &nval); |
105 | if (status != CAPS_SUCCESS0) return status; |
106 | len = nrow*ncol; |
107 | range = 0; |
108 | for (i = 0; i < indent; i++) printf(" "); |
109 | if (len == 1) { |
110 | printf(" value ="); |
111 | } else { |
112 | printf(" value (%dx%d) =", nrow, ncol); |
113 | } |
114 | if (data == NULL((void*)0)) { |
115 | printf(" NULL with len = %d", len); |
116 | if (vtype == Tuple) printf("\n"); |
117 | } else { |
118 | if ((vtype == Boolean) || (vtype == Integer)) { |
119 | ints = (int *) data; |
120 | for (i = 0; i < len; i++) printf(" %d", ints[i]); |
121 | if (vtype == Integer) { |
122 | data = NULL((void*)0); |
123 | status = caps_getLimits(object, &vtype, &data, &units); |
124 | if ((data != NULL((void*)0)) && (status == CAPS_SUCCESS0)) range = 1; |
125 | } |
126 | } else if ((vtype == Double) || (vtype == DoubleDeriv)) { |
127 | reals = (double *) data; |
128 | for (i = 0; i < len; i++) printf(" %lf", reals[i]); |
129 | data = NULL((void*)0); |
130 | status = caps_getLimits(object, &vtype, &data, &units); |
131 | if ((data != NULL((void*)0)) && (status == CAPS_SUCCESS0)) range = 2; |
132 | } else if (vtype == String) { |
133 | str = (char *) data; |
134 | printf(" %s", str); |
135 | } else if (vtype == Tuple) { |
136 | printf("\n"); |
137 | tuple = (capsTuple *) data; |
138 | for (j = 0; j < len; j++) { |
139 | for (i = 0; i < indent+2; i++) printf(" "); |
140 | printf("%d: %s -> %s\n", j+1, tuple[j].name, tuple[j].value); |
141 | } |
142 | } else if ((vtype == Pointer) || (vtype == PointerMesh)) { |
143 | #if defined(WIN32) && defined(_OCC64) |
144 | printf(" %llx", (long long) data); |
145 | #else |
146 | printf(" %lx", (long) data); |
147 | #endif |
148 | } else { |
149 | return CAPS_BADTYPE-306; |
150 | } |
151 | } |
152 | if (vtype == Tuple) return CAPS_SUCCESS0; |
153 | |
154 | printf(" %s", units); |
155 | if (range == 1) { |
156 | ints = (int *) data; |
157 | if (ints != NULL((void*)0)) printf(" lims=[%d-%d]", ints[0], ints[1]); |
158 | } else if (range == 2) { |
159 | reals = (double *) data; |
160 | if (reals != NULL((void*)0)) printf(" lims=[%lf-%lf]", reals[0], reals[1]); |
161 | } |
162 | printf("\n"); |
163 | if (vtype != DoubleDeriv) return CAPS_SUCCESS0; |
164 | |
165 | status = caps_hasDeriv(object, &dim, &dotnames, |
166 | &nerr, &errors); |
167 | if (errors != NULL((void*)0)) caps_freeError(errors); |
168 | if (status != CAPS_SUCCESS0) return status; |
169 | |
170 | for (i = 0; i < dim; i++) { |
171 | status = caps_getDeriv(object, dotnames[i], &len, &rank, &reals, |
172 | &nerr, &errors); |
173 | if (errors != NULL((void*)0)) caps_freeError(errors); |
174 | if (status != CAPS_SUCCESS0) continue; |
175 | for (j = 0; j < indent; j++) printf(" "); |
176 | printf(" dot %2d: %s rank = %d\n ", i+1, dotnames[i], rank); |
177 | if (reals != NULL((void*)0)) { |
178 | for (j = 0; j < indent+2; j++) printf(" "); |
179 | for (j = 0; j < len*rank; j++) printf(" %lf", reals[j]); |
180 | } |
181 | printf("\n"); |
182 | } |
183 | EG_free(dotnames); |
184 | |
185 | return CAPS_SUCCESS0; |
186 | } |
187 | |
188 | |
189 | void |
190 | caps_printObjects(capsObj pobject, capsObj object, int indent) |
191 | { |
192 | int i, j, k, status, nBody, nTess, nParam, nGeomIn, nGeomOut, stat; |
193 | int nAnalysis, nBound, nAnalIn, nAnalOut, nConnect, nUnConnect; |
194 | int nAttr, nHist, nDataSet, npts, rank, nErr, nLines, nAnalDynO; |
195 | char *name, *units, *phase, *pname, *pID, *userID, *oname, **lines; |
196 | double *data; |
197 | short datetime[6]; |
198 | ego *eobjs; |
199 | CAPSLONGunsigned long sn, lsn; |
200 | capsObj link, parent, obj, attr; |
201 | capsOwn own, *hist; |
202 | capsErrs *errors; |
203 | enum capsoType type, otype; |
204 | enum capssType subtype, osubtype; |
205 | static char *oType[9] = { "BODIES", "ATTRIBUTES", "UNUSED", "PROBLEM", |
206 | "VALUE", "ANALYSIS", "BOUND", "VERTEXSET", |
207 | "DATASET" }; |
208 | static char *sType[12] = { "NONE", "STATIC", "PARAMETRIC", "GEOMETRYIN", |
209 | "GEOMETRYOUT", "PARAMETER", "USER", |
210 | "ANALYSISIN", "ANALYSISOUT", "CONNECTED", |
211 | "UNCONNECTED", "ANALYSISDYNO" }; |
212 | |
213 | #ifdef TESTHIERACHY |
214 | { |
215 | extern int caps_findProblem(const capsObject *object, int funID, |
216 | capsObject **pobject); |
217 | extern int caps_hierarchy(capsObject *obj, char **full); |
218 | extern int caps_string2obj(capsProblem *problm, /*@null@*/ const char *full, |
219 | capsObject **object); |
220 | |
221 | char *full; |
222 | capsProblem *problem; |
223 | capsObject *pobject, *tmp; |
224 | |
225 | status = caps_findProblem(object, 9999, &pobject); |
226 | if (status != CAPS_SUCCESS0) { |
227 | printf(" caps_findProblem = %d\n", status); |
228 | exit(1); |
229 | } |
230 | problem = pobject->blind; |
231 | status = caps_hierarchy(object, &full); |
232 | if (status != CAPS_SUCCESS0) { |
233 | printf(" caps_hierarchy = %d\n", status); |
234 | exit(1); |
235 | } |
236 | if (full != NULL((void*)0)) { |
237 | status = caps_string2obj(problem, full, &tmp); |
238 | EG_free(full); |
239 | if (status != CAPS_SUCCESS0) { |
240 | printf(" caps_string2obj = %d\n", status); |
241 | exit(1); |
242 | } |
243 | if (tmp != object) { |
244 | printf(" tmp = %lx, object = %lx\n", (long) tmp, (long) object); |
245 | exit(1); |
246 | } |
247 | } |
248 | } |
249 | #endif |
250 | |
251 | stat = caps_info(object, &name, &type, &subtype, &link, &parent, &own); |
252 | if (stat < CAPS_SUCCESS0) { |
253 | #if defined(WIN32) && defined(_OCC64) |
254 | printf(" CAPS Error: Object %llx returns %d from caps_info!\n", |
255 | (long long) object, stat); |
256 | #else |
257 | printf(" CAPS Error: Object %lx returns %d from caps_info!\n", |
258 | (long) object, stat); |
259 | #endif |
260 | return; |
261 | } |
262 | status = caps_size(object, ATTRIBUTES, NONE, &nAttr, &nErr, &errors); |
263 | if (errors != NULL((void*)0)) caps_freeError(errors); |
264 | if (status != CAPS_SUCCESS0) { |
265 | printf(" CAPS Error: Object %s returns %d from caps_size(Attribute)!\n", |
266 | name, status); |
267 | return; |
268 | } |
269 | for (i = 0; i < indent; i++) printf(" "); |
270 | printf(" %s has type %s, subtype %s with %d attributes", |
271 | name, oType[type+2], sType[subtype], nAttr); |
272 | if (stat > CAPS_SUCCESS0) printf(" marked for deletion"); |
273 | printf("\n"); |
274 | /* output owner */ |
275 | status = caps_ownerInfo(pobject, own, &phase, &pname, &pID, &userID, &nLines, |
276 | &lines, datetime, &sn); |
277 | if (status != CAPS_SUCCESS0) { |
278 | printf(" CAPS Error: Object %s returns %d from caps_ownerInfo!\n", |
279 | name, status); |
280 | } else { |
281 | if (datetime[0] != 0) { |
282 | for (i = 0; i < indent; i++) printf(" "); |
283 | #ifdef WIN32 |
284 | printf(" last: %s %s %s %d/%02d/%02d %02d:%02d:%02d %lld\n", pname, |
285 | pID, userID, datetime[0], datetime[1], datetime[2], datetime[3], |
286 | datetime[4], datetime[5], sn); |
287 | #else |
288 | printf(" last: %s %s %s %d/%02d/%02d %02d:%02d:%02d %ld\n", pname, |
289 | pID, userID, datetime[0], datetime[1], datetime[2], datetime[3], |
290 | datetime[4], datetime[5], sn); |
291 | #endif |
292 | } |
293 | } |
294 | |
295 | /* output attributes */ |
296 | for (j = 1; j <= nAttr; j++) { |
297 | status = caps_attrByIndex(object, j, &attr); |
298 | if (status != CAPS_SUCCESS0) { |
299 | for (i = 0; i < indent+2; i++) printf(" "); |
300 | printf(" CAPS Error: Object %s Attr %d ret=%d from caps_attrByIndex!\n", |
301 | name, j, status); |
302 | continue; |
303 | } |
304 | caps_printObjects(pobject, attr, indent+2); |
305 | } |
306 | |
307 | /* output history */ |
308 | status = caps_getHistory(object, &nHist, &hist); |
309 | if (status == CAPS_SUCCESS0) |
310 | for (j = 0; j < nHist; j++) { |
311 | status = caps_ownerInfo(pobject, hist[j], &phase, &pname, &pID, &userID, |
312 | &nLines, &lines, datetime, &sn); |
313 | if (status == CAPS_SUCCESS0) { |
314 | for (i = 0; i < indent; i++) printf(" "); |
315 | printf(" hist: %s", phase); |
316 | if (nLines > 0) printf(" -> %s", lines[0]); |
317 | printf("\n"); |
318 | for (i = 0; i < indent; i++) printf(" "); |
319 | #ifdef WIN32 |
320 | printf(" %s %s %s %d/%02d/%02d %02d:%02d:%02d %lld\n", pname, |
321 | pID, userID, datetime[0], datetime[1], datetime[2], datetime[3], |
322 | datetime[4], datetime[5], sn); |
323 | #else |
324 | printf(" %s %s %s %d/%02d/%02d %02d:%02d:%02d %ld\n", pname, |
325 | pID, userID, datetime[0], datetime[1], datetime[2], datetime[3], |
326 | datetime[4], datetime[5], sn); |
327 | #endif |
328 | for (k = 1; k < nLines; k++) { |
329 | for (i = 0; i < indent; i++) printf(" "); |
330 | printf(" %s\n", lines[k]); |
331 | for (i = 0; i < indent; i++) printf(" "); |
332 | #ifdef WIN32 |
333 | printf(" %s %s %s %d/%02d/%02d %02d:%02d:%02d %lld\n", pname, |
334 | pID, userID, datetime[0], datetime[1], datetime[2], datetime[3], |
335 | datetime[4], datetime[5], sn); |
336 | #else |
337 | printf(" %s %s %s %d/%02d/%02d %02d:%02d:%02d %ld\n", pname, |
338 | pID, userID, datetime[0], datetime[1], datetime[2], datetime[3], |
339 | datetime[4], datetime[5], sn); |
340 | #endif |
341 | } |
342 | } |
343 | } |
344 | |
345 | if (type == PROBLEM) { |
346 | status = caps_size(object, BODIES, NONE, &nBody, &nErr, &errors); |
347 | if (errors != NULL((void*)0)) caps_freeError(errors); |
348 | if (status != CAPS_SUCCESS0) { |
349 | printf(" CAPS Error: Object %s returns %d from caps_size(Body)!\n", |
350 | name, status); |
351 | return; |
352 | } |
353 | status = caps_size(object, VALUE, PARAMETER, &nParam, &nErr, &errors); |
354 | if (errors != NULL((void*)0)) caps_freeError(errors); |
355 | if (status != CAPS_SUCCESS0) { |
356 | printf(" CAPS Error: Object %s returns %d from caps_size(Parameter)!\n", |
357 | name, status); |
358 | return; |
359 | } |
360 | status = caps_size(object, VALUE, GEOMETRYIN, &nGeomIn, &nErr, &errors); |
361 | if (errors != NULL((void*)0)) caps_freeError(errors); |
362 | if (status != CAPS_SUCCESS0) { |
363 | printf(" CAPS Error: Object %s returns %d from caps_size(GeomIn)!\n", |
364 | name, status); |
365 | return; |
366 | } |
367 | status = caps_size(object, VALUE, GEOMETRYOUT, &nGeomOut, &nErr, &errors); |
368 | if (errors != NULL((void*)0)) caps_freeError(errors); |
369 | if (status != CAPS_SUCCESS0) { |
370 | printf(" CAPS Error: Object %s returns %d from caps_size(GeomOut)!\n", |
371 | name, status); |
372 | return; |
373 | } |
374 | status = caps_size(object, ANALYSIS, NONE, &nAnalysis, &nErr, &errors); |
375 | if (errors != NULL((void*)0)) caps_freeError(errors); |
376 | if (status != CAPS_SUCCESS0) { |
377 | printf(" CAPS Error: Object %s returns %d from caps_size(Analysis)!\n", |
378 | name, status); |
379 | return; |
380 | } |
381 | status = caps_size(object, BOUND, NONE, &nBound, &nErr, &errors); |
382 | if (errors != NULL((void*)0)) caps_freeError(errors); |
383 | if (status != CAPS_SUCCESS0) { |
384 | printf(" CAPS Error: Object %s returns %d from caps_size(Bound)!\n", |
385 | name, status); |
386 | return; |
387 | } |
388 | for (i = 0; i < indent; i++) printf(" "); |
389 | printf(" %d Bodies, %d Parameters, %d GeomIns, %d GeomOuts,", |
390 | nBody, nParam, nGeomIn, nGeomOut); |
391 | printf(" %d Analyses, %d Bounds\n", nAnalysis, nBound); |
392 | |
393 | if (nParam > 0) { |
394 | printf("\n"); |
395 | for (i = 0; i < nParam; i++) { |
396 | status = caps_childByIndex(object, VALUE, PARAMETER, i+1, &obj); |
397 | if (status != CAPS_SUCCESS0) { |
398 | printf(" CAPS Error: Object %s ret=%d from caps_child(Param,%d)!\n", |
399 | name, status, i+1); |
400 | return; |
401 | } |
402 | caps_printObjects(pobject, obj, indent+2); |
403 | } |
404 | } |
405 | |
406 | if (nGeomIn > 0) { |
407 | printf("\n"); |
408 | for (i = 0; i < nGeomIn; i++) { |
409 | status = caps_childByIndex(object, VALUE, GEOMETRYIN, i+1, &obj); |
410 | if (status != CAPS_SUCCESS0) { |
411 | printf(" CAPS Error: Object %s ret=%d from caps_child(GeomIn,%d)!\n", |
412 | name, status, i+1); |
413 | return; |
414 | } |
415 | caps_printObjects(pobject, obj, indent+2); |
416 | } |
417 | } |
418 | if (nGeomOut > 0) { |
419 | printf("\n"); |
420 | for (i = 0; i < nGeomOut; i++) { |
421 | status = caps_childByIndex(object, VALUE, GEOMETRYOUT, i+1, &obj); |
422 | if (status != CAPS_SUCCESS0) { |
423 | printf(" CAPS Error: Object %s ret=%d from caps_child(GeomOut,%d)!\n", |
424 | name, status, i+1); |
425 | return; |
426 | } |
427 | caps_printObjects(pobject, obj, indent+2); |
428 | } |
429 | } |
430 | |
431 | if (nAnalysis > 0) { |
432 | printf("\n"); |
433 | for (i = 0; i < nAnalysis; i++) { |
434 | status = caps_childByIndex(object, ANALYSIS, NONE, i+1, &obj); |
435 | if (status != CAPS_SUCCESS0) { |
436 | printf(" CAPS Error: Object %s ret=%d from caps_child(Analysis,%d)!\n", |
437 | name, status, i+1); |
438 | return; |
439 | } |
440 | caps_printObjects(pobject, obj, indent+2); |
441 | } |
442 | } |
443 | |
444 | if (nBound > 0) { |
445 | printf("\n"); |
446 | for (i = 0; i < nBound; i++) { |
447 | status = caps_childByIndex(object, BOUND, NONE, i+1, &obj); |
448 | if (status != CAPS_SUCCESS0) { |
449 | printf(" CAPS Error: Object %s ret=%d from caps_child(Bound,%d)!\n", |
450 | name, status, i+1); |
451 | return; |
452 | } |
453 | caps_printObjects(pobject, obj, indent+2); |
454 | } |
455 | } |
456 | |
457 | } else if (type == VALUE) { |
458 | if (link != NULL((void*)0)) { |
459 | for (i = 0; i < indent+2; i++) printf(" "); |
460 | printf(" linked to %s\n", link->name); |
461 | } else { |
462 | status = printValues(pobject, object, indent+2); |
463 | if (status != CAPS_SUCCESS0) { |
464 | for (i = 0; i < indent; i++) printf(" "); |
465 | printf(" CAPS Error: printVal returns %d!\n", status); |
466 | } |
467 | } |
468 | |
469 | } else if (type == ANALYSIS) { |
470 | status = caps_size(object, VALUE, ANALYSISIN, &nAnalIn, &nErr, &errors); |
471 | if (errors != NULL((void*)0)) caps_freeError(errors); |
472 | if (status != CAPS_SUCCESS0) { |
473 | printf(" CAPS Error: Object %s returns %d from caps_size(AnalysisIn)!\n", |
474 | name, status); |
475 | return; |
476 | } |
477 | status = caps_size(object, VALUE, ANALYSISOUT, &nAnalOut, &nErr, &errors); |
478 | if (errors != NULL((void*)0)) caps_freeError(errors); |
479 | if (status != CAPS_SUCCESS0) { |
480 | printf(" CAPS Error: Object %s returns %d from caps_size(AnalysisIn)!\n", |
481 | name, status); |
482 | return; |
483 | } |
484 | status = caps_size(object, VALUE, ANALYSISDYNO, &nAnalDynO, &nErr, &errors); |
485 | if (errors != NULL((void*)0)) caps_freeError(errors); |
486 | if (status != CAPS_SUCCESS0) { |
487 | printf(" CAPS Error: Object %s returns %d from caps_size(AnalysisIn)!\n", |
488 | name, status); |
489 | return; |
490 | } |
491 | for (i = 0; i < indent; i++) printf(" "); |
492 | printf(" %d AnalysisIns, %d AnalysisOuts, %d AnalysisDynOs\n", |
493 | nAnalIn, nAnalOut, nAnalDynO); |
494 | |
495 | status = caps_getBodies(object, &nBody, &eobjs, &nErr, &errors); |
496 | if (errors != NULL((void*)0)) caps_freeError(errors); |
497 | if (status != CAPS_SUCCESS0) { |
498 | printf(" CAPS Error: Object %s returns %d from caps_getBodies!\n", |
499 | name, status); |
500 | return; |
501 | } |
502 | status = caps_getTessels(object, &nTess, &eobjs, &nErr, &errors); |
503 | if (errors != NULL((void*)0)) caps_freeError(errors); |
504 | if (status != CAPS_SUCCESS0) { |
505 | printf(" CAPS Error: Object %s returns %d from caps_getTessels!\n", |
506 | name, status); |
507 | return; |
508 | } |
509 | for (i = 0; i < indent; i++) printf(" "); |
510 | printf(" %d Bodies, %d Tessellations\n", nBody, nTess); |
511 | |
512 | if (nAnalIn > 0) { |
513 | printf("\n"); |
514 | for (i = 0; i < nAnalIn; i++) { |
515 | status = caps_childByIndex(object, VALUE, ANALYSISIN, i+1, &obj); |
516 | if (status != CAPS_SUCCESS0) { |
517 | printf(" CAPS Error: Object %s ret=%d from caps_child(AnalIn,%d)!\n", |
518 | name, status, i+1); |
519 | return; |
520 | } |
521 | caps_printObjects(pobject, obj, indent+2); |
522 | } |
523 | } |
524 | |
525 | if (nAnalOut > 0) { |
526 | printf("\n"); |
527 | for (i = 0; i < nAnalOut; i++) { |
528 | status = caps_childByIndex(object, VALUE, ANALYSISOUT, i+1, &obj); |
529 | if (status != CAPS_SUCCESS0) { |
530 | printf(" CAPS Error: Object %s ret=%d from caps_child(AnalOut,%d)!\n", |
531 | name, status, i+1); |
532 | return; |
533 | } |
534 | sn = 0; |
535 | status = caps_info(obj, &oname, &otype, &osubtype, &link, &parent, &own); |
536 | if (status >= CAPS_SUCCESS0) |
537 | caps_ownerInfo(pobject, own, &phase, &pname, &pID, &userID, &nLines, |
538 | &lines, datetime, &sn); |
539 | if (sn == 0) continue; |
540 | |
541 | caps_printObjects(pobject, obj, indent+2); |
542 | |
543 | status = caps_info(obj, &oname, &otype, &osubtype, &link, &parent, &own); |
544 | if (status >= CAPS_SUCCESS0) { |
545 | status = caps_ownerInfo(pobject, own, &phase, &pname, &pID, &userID, |
546 | &nLines, &lines, datetime, &lsn); |
547 | if (status == CAPS_SUCCESS0) |
548 | if (lsn != sn) { |
549 | for (j = 0; j < indent+2; j++) printf(" "); |
550 | #ifdef WIN32 |
551 | printf(" lazy: %s %s %s %d/%02d/%02d %02d:%02d:%02d %lld\n", |
552 | pname, pID, userID, datetime[0], datetime[1], datetime[2], |
553 | datetime[3], datetime[4], datetime[5], lsn); |
554 | #else |
555 | printf(" lazy: %s %s %s %d/%02d/%02d %02d:%02d:%02d %ld\n", |
556 | pname, pID, userID, datetime[0], datetime[1], datetime[2], |
557 | datetime[3], datetime[4], datetime[5], lsn); |
558 | #endif |
559 | for (k = 0; k < nLines; k++) { |
560 | for (j = 0; j < indent; j++) printf(" "); |
561 | printf(" %s\n", lines[k]); |
562 | } |
563 | } |
564 | } |
565 | } |
566 | } |
567 | |
568 | if (nAnalDynO > 0) { |
569 | printf("\n"); |
570 | for (i = 0; i < nAnalDynO; i++) { |
571 | status = caps_childByIndex(object, VALUE, ANALYSISDYNO, i+1, &obj); |
572 | if (status != CAPS_SUCCESS0) { |
573 | printf(" CAPS Error: Object %s ret=%d from caps_child(AnalDynO,%d)!\n", |
574 | name, status, i+1); |
575 | return; |
576 | } |
577 | caps_printObjects(pobject, obj, indent+2); |
578 | } |
579 | } |
580 | |
581 | } else if (type == BOUND) { |
582 | status = caps_size(object, VERTEXSET, CONNECTED, &nConnect, &nErr, &errors); |
583 | if (errors != NULL((void*)0)) caps_freeError(errors); |
584 | if (status != CAPS_SUCCESS0) { |
585 | printf(" CAPS Error: Object %s returns %d from caps_size(VSconnected)!\n", |
586 | name, status); |
587 | return; |
588 | } |
589 | status = caps_size(object, VERTEXSET, UNCONNECTED, &nUnConnect, |
590 | &nErr, &errors); |
591 | if (errors != NULL((void*)0)) caps_freeError(errors); |
592 | if (status != CAPS_SUCCESS0) { |
593 | printf(" CAPS Error: Object %s returns %d from caps_size(VSconnected)!\n", |
594 | name, status); |
595 | return; |
596 | } |
597 | for (i = 0; i < indent; i++) printf(" "); |
598 | printf(" %d Connecteds, %d UnConnecteds\n", nConnect, nUnConnect); |
599 | |
600 | if (nConnect > 0) { |
601 | printf("\n"); |
602 | for (i = 0; i < nConnect; i++) { |
603 | status = caps_childByIndex(object, VERTEXSET, CONNECTED, i+1, &obj); |
604 | if (status != CAPS_SUCCESS0) { |
605 | printf(" CAPS Error: Object %s ret=%d from caps_child(Connect,%d)!\n", |
606 | name, status, i+1); |
607 | return; |
608 | } |
609 | caps_printObjects(pobject, obj, indent+2); |
610 | } |
611 | } |
612 | |
613 | if (nUnConnect > 0) { |
614 | printf("\n"); |
615 | for (i = 0; i < nUnConnect; i++) { |
616 | status = caps_childByIndex(object, VERTEXSET, UNCONNECTED, i+1, &obj); |
617 | if (status != CAPS_SUCCESS0) { |
618 | printf(" CAPS Error: Object %s ret=%d from caps_child(UnConnect,%d)!\n", |
619 | name, status, i+1); |
620 | return; |
621 | } |
622 | caps_printObjects(pobject, obj, indent+2); |
623 | } |
624 | } |
625 | |
626 | } else if (type == VERTEXSET) { |
627 | status = caps_size(object, DATASET, NONE, &nDataSet, &nErr, &errors); |
628 | if (errors != NULL((void*)0)) caps_freeError(errors); |
629 | if (status != CAPS_SUCCESS0) { |
630 | printf(" CAPS Error: Object %s returns %d from caps_size(DataSet)!\n", |
631 | name, status); |
632 | return; |
633 | } |
634 | for (i = 0; i < indent; i++) printf(" "); |
635 | printf(" %d DataSets\n", nDataSet); |
636 | |
637 | if (nDataSet > 0) { |
638 | printf("\n"); |
639 | for (i = 0; i < nDataSet; i++) { |
640 | status = caps_childByIndex(object, DATASET, NONE, i+1, &obj); |
641 | if (status != CAPS_SUCCESS0) { |
642 | printf(" CAPS Error: Object %s ret=%d from caps_child(DataSet,%d)!\n", |
643 | name, status, i+1); |
644 | return; |
645 | } |
646 | caps_printObjects(pobject, obj, indent+2); |
647 | } |
648 | } |
649 | |
650 | } else if (type == DATASET) { |
651 | status = caps_getData(object, &npts, &rank, &data, &units, &nErr, &errors); |
652 | if (errors != NULL((void*)0)) caps_freeError(errors); |
653 | if (status != CAPS_SUCCESS0) { |
654 | printf(" CAPS Error: Object %s return=%d from caps_getData!\n", |
655 | name, status); |
656 | return; |
657 | } |
658 | for (i = 0; i < indent; i++) printf(" "); |
659 | printf(" %d points, rank=%d, units=%s\n", npts, rank, units); |
660 | |
661 | } |
662 | |
663 | } |
664 | |
665 | |
666 | static int printValueString(char *valueStr, int slen, ValueData *valObj) |
667 | { |
668 | int i, j; |
669 | int strIndex = 0; |
670 | capsTuple *currentTuple; |
671 | |
672 | if (valObj->vtype == String || valObj->vtype == Pointer || |
673 | valObj->vtype == PointerMesh) { |
674 | |
675 | strIndex += snprintf(valueStr, slen, "\"%s\"", valObj->sValue); |
676 | if (valueStr == NULL((void*)0)) slen = strIndex; |
677 | } else { |
678 | if (valObj->nrow > 1) { |
679 | strIndex += snprintf(valueStr ? &valueStr[strIndex] : NULL((void*)0), slen-strIndex, "["); |
680 | if (valueStr == NULL((void*)0)) slen = strIndex; |
681 | } |
682 | for (i = 0; i < valObj->nrow; i++) { |
683 | if (i > 0) { |
684 | strIndex += snprintf(valueStr ? &valueStr[strIndex] : NULL((void*)0), slen-strIndex, ",\n"); |
685 | if (valueStr == NULL((void*)0)) slen = strIndex; |
686 | } |
687 | if (valObj->ncol > 1) { |
688 | strIndex += snprintf(valueStr ? &valueStr[strIndex] : NULL((void*)0), slen-strIndex, "["); |
689 | if (valueStr == NULL((void*)0)) slen = strIndex; |
690 | } |
691 | for (j = 0; j < valObj->ncol; j++) { |
692 | if (j > 0) { |
693 | strIndex += snprintf(valueStr ? &valueStr[strIndex] : NULL((void*)0), slen-strIndex, ", "); |
694 | if (valueStr == NULL((void*)0)) slen = strIndex; |
695 | } |
696 | if ((valObj->vtype == Boolean) || (valObj->vtype == Integer)) { |
697 | strIndex += snprintf(valueStr ? &valueStr[strIndex] : NULL((void*)0), slen-strIndex, "%d", |
698 | valObj->iValue[i * valObj->ncol + j]); |
699 | if (valueStr == NULL((void*)0)) slen = strIndex; |
700 | } else if ((valObj->vtype == Double) || |
701 | (valObj->vtype == DoubleDeriv)) { |
702 | strIndex += snprintf(valueStr ? &valueStr[strIndex] : NULL((void*)0), slen-strIndex, "%f", |
703 | valObj->dValue[i * valObj->ncol + j]); |
704 | if (valueStr == NULL((void*)0)) slen = strIndex; |
705 | } else { |
706 | #ifndef __clang_analyzer__1 |
707 | currentTuple = &valObj->tValue[i*valObj->ncol+j]; |
708 | if ((currentTuple->value[0] != '{' && |
709 | currentTuple->value[0] != '[') && |
710 | currentTuple->value[0] != '"') { |
711 | strIndex += snprintf(valueStr ? &valueStr[strIndex] : NULL((void*)0), slen-strIndex, "{\"%s\": \"%s\"}", |
712 | currentTuple->name, |
713 | currentTuple->value); |
714 | if (valueStr == NULL((void*)0)) slen = strIndex; |
715 | } else { |
716 | strIndex += snprintf(valueStr ? &valueStr[strIndex] : NULL((void*)0), slen-strIndex, "{\"%s\": %s}", |
717 | currentTuple->name, |
718 | currentTuple->value); |
719 | if (valueStr == NULL((void*)0)) slen = strIndex; |
720 | } |
721 | #endif |
722 | } |
723 | } |
724 | if (valObj->ncol > 1) { |
725 | strIndex += snprintf(valueStr ? &valueStr[strIndex] : NULL((void*)0), slen-strIndex, "]"); |
726 | if (valueStr == NULL((void*)0)) slen = strIndex; |
727 | } |
728 | } |
729 | if (valObj->nrow > 1) { |
730 | strIndex += snprintf(valueStr ? &valueStr[strIndex] : NULL((void*)0), slen-strIndex, "]"); |
731 | if (valueStr == NULL((void*)0)) slen = strIndex; |
732 | } |
733 | } |
734 | |
735 | return strIndex; |
736 | } |
737 | |
738 | static int printDerivString(char *derivStr, int slen, ValueData *valObj) |
739 | { |
740 | int i, j, k; |
741 | int strIndex = 0; |
742 | |
743 | strIndex += snprintf(derivStr, slen, " \"deriv\": {"); |
744 | if (derivStr == NULL((void*)0)) slen = strIndex; |
745 | for (i = 0; i < valObj->ndot; i++) { |
746 | if (i > 0) { |
747 | strIndex += snprintf(derivStr ? &derivStr[strIndex] : NULL((void*)0), slen-strIndex, ","); |
748 | if (derivStr == NULL((void*)0)) slen = strIndex; |
749 | } |
750 | strIndex += snprintf(derivStr ? &derivStr[strIndex] : NULL((void*)0), slen-strIndex, "\n \"%s\": ", |
751 | valObj->derivNames[i]); |
752 | if (derivStr == NULL((void*)0)) slen = strIndex; |
753 | if (valObj->lens[i] > 1) { |
754 | strIndex += snprintf(derivStr ? &derivStr[strIndex] : NULL((void*)0), slen-strIndex, "["); |
755 | if (derivStr == NULL((void*)0)) slen = strIndex; |
756 | } |
757 | |
758 | for (j=0; j<valObj->lens[i]; j++) { |
759 | if (j > 0) { |
760 | strIndex += snprintf(derivStr ? &derivStr[strIndex] : NULL((void*)0), slen-strIndex, ",\n"); |
761 | if (derivStr == NULL((void*)0)) slen = strIndex; |
762 | } |
763 | if (valObj->len_wrts[i] > 1) { |
764 | strIndex += snprintf(derivStr ? &derivStr[strIndex] : NULL((void*)0), slen-strIndex, "["); |
765 | if (derivStr == NULL((void*)0)) slen = strIndex; |
766 | } |
767 | for (k=0; k<valObj->len_wrts[i]; k++) { |
768 | if (k > 0) { |
769 | strIndex += snprintf(derivStr ? &derivStr[strIndex] : NULL((void*)0), slen-strIndex, ", "); |
770 | if (derivStr == NULL((void*)0)) slen = strIndex; |
771 | } |
772 | strIndex += snprintf(derivStr ? &derivStr[strIndex] : NULL((void*)0), slen-strIndex, "%f", |
773 | valObj->derivs[i][j*valObj->lens[i]+k]); |
774 | if (derivStr == NULL((void*)0)) slen = strIndex; |
775 | } |
776 | if (valObj->len_wrts[i] > 1) { |
777 | strIndex += snprintf(derivStr ? &derivStr[strIndex] : NULL((void*)0), slen-strIndex, "]"); |
778 | if (derivStr == NULL((void*)0)) slen = strIndex; |
779 | } |
780 | } |
781 | if (valObj->lens[i] > 1) { |
782 | strIndex += snprintf(derivStr ? &derivStr[strIndex] : NULL((void*)0), slen-strIndex, "]"); |
783 | if (derivStr == NULL((void*)0)) slen = strIndex; |
784 | } |
785 | } |
786 | strIndex += snprintf(derivStr ? &derivStr[strIndex] : NULL((void*)0), slen-strIndex, "}"); |
787 | if (derivStr == NULL((void*)0)) slen = strIndex; |
788 | |
789 | return strIndex; |
790 | } |
791 | |
792 | |
793 | static /*@null@*/ char *valueString(ValueData *valObj) |
794 | { |
795 | char *varStr, *valueStr, *derivStr, *tmpStr; |
796 | size_t slen; |
797 | |
798 | slen = 70 + strlen(valObj->name); |
799 | varStr = (char *) malloc(slen* sizeof(char)); |
800 | if (varStr == NULL((void*)0)) return NULL((void*)0); |
801 | |
802 | snprintf(varStr, slen, "{ \"name\": \"%s\",\n", valObj->name); |
803 | strcat(varStr, "\t\"value\": "); |
804 | if (!valObj->nulldata) { |
805 | |
806 | // first get the size of the string |
807 | slen = printValueString(NULL((void*)0), 0, valObj); |
808 | |
809 | // allocate the string |
810 | valueStr = (char *) malloc(slen*sizeof(char)); |
811 | if (valueStr == NULL((void*)0)) { |
812 | free(varStr); |
813 | return NULL((void*)0); |
814 | } |
815 | |
816 | // fill the string |
817 | slen = printValueString(valueStr, slen, valObj); |
818 | |
819 | if (valObj->vtype == String || valObj->vtype == Pointer || |
820 | valObj->vtype == PointerMesh) { |
821 | free(valObj->sValue); |
822 | } else if ((valObj->vtype == Boolean) || (valObj->vtype == Integer)) { |
823 | free(valObj->iValue); |
824 | } else if ((valObj->vtype == Double) || (valObj->vtype == DoubleDeriv)) { |
825 | free(valObj->dValue); |
826 | } else { |
827 | free(valObj->tValue); |
828 | } |
829 | |
830 | tmpStr = (char *) realloc(varStr, |
831 | (strlen(valueStr)+strlen(varStr)+30)*sizeof(char)); |
832 | if (tmpStr == NULL((void*)0)) { |
833 | free(valueStr); |
834 | free(varStr); |
835 | return NULL((void*)0); |
836 | } |
837 | varStr = tmpStr; |
838 | strcat(varStr, valueStr); |
839 | strcat(varStr, ","); |
840 | free(valueStr); |
841 | } else { |
842 | strcat(varStr, "null,\n"); |
843 | } |
844 | |
845 | if ((!valObj->nulldata) && (valObj->vtype == DoubleDeriv)) { |
846 | |
847 | // first get the size of the string |
848 | slen = printDerivString(NULL((void*)0), 0, valObj); |
849 | |
850 | derivStr = (char *) malloc(slen * sizeof(char)); |
851 | if (derivStr == NULL((void*)0)) { |
852 | free(varStr); |
853 | return NULL((void*)0); |
854 | } |
855 | |
856 | // fill the string |
857 | slen = printDerivString(derivStr, slen, valObj); |
Value stored to 'slen' is never read | |
858 | |
859 | tmpStr = (char *) realloc(varStr, |
860 | (strlen(varStr)+strlen(derivStr)+10)*sizeof(char)); |
861 | if (tmpStr == NULL((void*)0)) { |
862 | free(derivStr); |
863 | free(varStr); |
864 | return NULL((void*)0); |
865 | } |
866 | varStr = tmpStr; |
867 | strcat(varStr, derivStr); |
868 | free(derivStr); |
869 | if (valObj->derivNames != NULL((void*)0)) free(valObj->derivNames); |
870 | if (valObj->derivs != NULL((void*)0)) free(valObj->derivs); |
871 | if (valObj->lens != NULL((void*)0)) free(valObj->lens); |
872 | if (valObj->len_wrts != NULL((void*)0)) free(valObj->len_wrts); |
873 | } else { |
874 | strcat(varStr, " \"deriv\": null"); |
875 | } |
876 | |
877 | strcat(varStr, "}"); |
878 | return varStr; |
879 | } |
880 | |
881 | |
882 | static int getValueData(capsObj *valueObj, ValueData *valObj) |
883 | { |
884 | int status, ncol, nrow, dim, pmtr, valLen, *ints; |
885 | int i, nErr, ndot, len, len_wrt; |
886 | double *reals, *deriv; |
887 | const char *units; |
888 | char *str, **names; |
889 | const int *partial; |
890 | const void *data; |
891 | capsErrs *errors; |
892 | capsTuple *tuple; |
893 | enum capsvType vtype; |
894 | enum capsFixed lfixed, sfixed; |
895 | enum capsNull nval; |
896 | |
897 | status = caps_getValue(*valueObj, &vtype, &nrow, &ncol, &data, &partial, |
898 | &units, &nErr, &errors); |
899 | if (errors != NULL((void*)0)) caps_freeError(errors); |
900 | if (status != CAPS_SUCCESS0) { |
901 | printf(" CAPS Error: Object %s ret=%d from caps_getValue(Value)!\n", |
902 | valObj->name, status); |
903 | valObj->nulldata = true1; |
904 | return status; |
905 | } |
906 | status = caps_getValueProps(*valueObj, &dim, &pmtr, &lfixed, &sfixed, &nval); |
907 | if (status != CAPS_SUCCESS0) { |
908 | printf(" CAPS Error: Object %s ret=%d from caps_getValueProps(Value)!\n", |
909 | valObj->name, status); |
910 | return status; |
911 | } |
912 | |
913 | valObj->nrow = nrow; |
914 | valObj->ncol = ncol; |
915 | valObj->vtype = vtype; |
916 | valObj->nulldata = (data == NULL((void*)0)); |
917 | |
918 | valLen = nrow * ncol; |
919 | if (data != NULL((void*)0)) { |
920 | if ((vtype == Boolean) || (vtype == Integer)) { |
921 | ints = (int *) data; |
922 | valObj->iValue = (int *) malloc(valLen * sizeof(int)); |
923 | if (valObj->iValue == NULL((void*)0)) return EGADS_MALLOC-4; |
924 | for (i = 0; i < valLen; i++) { |
925 | valObj->iValue[i] = ints[i]; |
926 | } |
927 | } else if ((vtype == Double) || (vtype == DoubleDeriv)) { |
928 | reals = (double *) data; |
929 | valObj->dValue = (double *) malloc(valLen * sizeof(double)); |
930 | if (valObj->dValue == NULL((void*)0)) return EGADS_MALLOC-4; |
931 | for (i = 0; i < valLen; i++) { |
932 | valObj->dValue[i] = reals[i]; |
933 | } |
934 | // if DoubleDeriv, get derivative values |
935 | if (vtype == DoubleDeriv) { |
936 | valObj->ndot = 0; |
937 | status = caps_hasDeriv(*valueObj, &ndot, &names, &nErr, &errors); |
938 | if (status != CAPS_SUCCESS0) { |
939 | printf(" CAPS Error: Object %s ret=%d from caps_hasDeriv(Value)!\n", |
940 | valObj->name, status); |
941 | } |
942 | valObj->ndot = ndot; |
943 | valObj->derivNames = NULL((void*)0); |
944 | valObj->derivs = NULL((void*)0); |
945 | valObj->lens = NULL((void*)0); |
946 | valObj->len_wrts = NULL((void*)0); |
947 | if (ndot > 0) { |
948 | valObj->derivNames = (char **) malloc(ndot * sizeof(char *)); |
949 | valObj->derivs = (double **) malloc(ndot * sizeof(double *)); |
950 | valObj->lens = (int *) malloc(ndot * sizeof(int)); |
951 | valObj->len_wrts = (int *) malloc(ndot * sizeof(int)); |
952 | |
953 | if ((valObj->derivNames == NULL((void*)0)) || (valObj->derivs == NULL((void*)0)) || |
954 | (valObj->lens == NULL((void*)0)) || (valObj->len_wrts == NULL((void*)0))) { |
955 | if (valObj->derivNames != NULL((void*)0)) free(valObj->derivNames); |
956 | if (valObj->derivs != NULL((void*)0)) free(valObj->derivs); |
957 | if (valObj->lens != NULL((void*)0)) free(valObj->lens); |
958 | if (valObj->len_wrts != NULL((void*)0)) free(valObj->len_wrts); |
959 | return EGADS_MALLOC-4; |
960 | } |
961 | for (i = 0; i < ndot; i++) { |
962 | status = caps_getDeriv(*valueObj, names[i], &len, |
963 | &len_wrt, &deriv, |
964 | &nErr, &errors); |
965 | if (status != CAPS_SUCCESS0) { |
966 | printf(" CAPS Error: Object %s ret=%d from caps_getDeriv(Value_%d)!\n", |
967 | valObj->name, status, i); |
968 | continue; |
969 | } |
970 | printf(" %s: %dx%d\n", names[i], len, len_wrt); |
971 | valObj->derivNames[i] = names[i]; |
972 | valObj->derivs[i] = deriv; |
973 | valObj->lens[i] = len; |
974 | valObj->len_wrts[i] = len_wrt; |
975 | } |
976 | } |
977 | |
978 | } |
979 | } else if (vtype == String) { |
980 | str = (char *) data; |
981 | valObj->sValue = (char *) malloc((strlen(str)+1) * sizeof(char)); |
982 | if (valObj->sValue == NULL((void*)0)) return EGADS_MALLOC-4; |
983 | strcpy(valObj->sValue, str); |
984 | } else if (vtype == Tuple) { |
985 | tuple = (capsTuple *) data; |
986 | valObj->tValue = (capsTuple *) malloc(valLen * sizeof(capsTuple)); |
987 | if (valObj->tValue == NULL((void*)0)) return EGADS_MALLOC-4; |
988 | for (i = 0; i < valLen; i++) { |
989 | valObj->tValue[i] = tuple[i]; |
990 | } |
991 | } else if (vtype == Pointer || vtype == PointerMesh) { |
992 | valObj->sValue = (char *) malloc(10 * sizeof(char)); |
993 | if (valObj->sValue == NULL((void*)0)) return EGADS_MALLOC-4; |
994 | strcpy(valObj->sValue, "pointer"); |
995 | } else { |
996 | /* if not of above types, set to null */ |
997 | valObj->nulldata = true1; |
998 | } |
999 | } |
1000 | |
1001 | return CAPS_SUCCESS0; |
1002 | } |
1003 | |
1004 | |
1005 | int caps_outputObjects(capsObj problemObj, /*@null@*/ char **stream) |
1006 | { |
1007 | int status, nErr, i, j, k, nGpts, nDpts, nConnect, nDataSet; |
1008 | int nAnalysis, nBound, nAnalIn, nAnalOut, nDynAnalOut, dbg = 0; |
1009 | int major, minor, nFields, *ranks, *fInOut, dirty, exec; |
1010 | char *aName, *vName, *bName, *dName, *name, *env = NULL((void*)0); |
1011 | char *analysisPath = NULL((void*)0), *unitSystem, *intents, **fnames; |
1012 | char *varStr, *tmpStr, filename[PATH_MAX4096], *jsonText = NULL((void*)0); |
1013 | capsObj link, parent, dataLink; |
1014 | capsObj analysisObj, valueObj, vertexObj, dataSetObj, boundObject; |
1015 | capsObj bObj, aObj; |
1016 | capsOwn own; |
1017 | capsErrs *errors; |
1018 | enum capsoType type; |
1019 | enum capssType subtype; |
1020 | enum capsfType ftype; |
1021 | enum capsdMethod dmethod; |
1022 | AIMData *aims = NULL((void*)0); |
1023 | ValLinkData *valLinks = NULL((void*)0), *tmpValLink; |
1024 | GeomLinkData *geomLinks = NULL((void*)0), *tmpGeomLink; |
1025 | int valLinksIndex = 0; |
1026 | int geomLinksIndex = 0; |
1027 | FILE *fptr; |
1028 | |
1029 | #ifdef DEBUG |
1030 | printf("\n In caps_outputObjects:\n"); |
1031 | #endif |
1032 | |
1033 | if (stream == NULL((void*)0)) { |
1034 | /* for now key off CAPS_FLOW (no spaces in path!) */ |
1035 | env = getenv("CAPS_FLOW"); |
1036 | if (env == NULL((void*)0)) { |
1037 | printf(" CAPS_Error: CAPS_FLOW not in the environment\n"); |
1038 | return CAPS_NOTIMPLEMENT-334; |
1039 | } |
1040 | /* build up our filename from CAPS_FLOW */ |
1041 | k = strlen(env); |
1042 | for (j = k-1; j >= 0; j--) |
1043 | if (env[j] == ' ') break; |
1044 | if (j < 0) { |
1045 | printf(" CAPS_Error: Bad Environment: %s\n", env); |
1046 | return CAPS_BADNAME-317; |
1047 | } |
1048 | snprintf(filename, PATH_MAX4096, "%s", &env[j+1]); |
1049 | k = strlen(filename); |
1050 | for (i = k-1; i >= 0; i--) |
1051 | if (filename[i] == '.') break; |
1052 | if (i < 0) { |
1053 | printf(" CAPS_Error: Bad environment: %s\n", filename); |
1054 | return CAPS_BADNAME-317; |
1055 | } |
1056 | filename[i ] = '_'; |
1057 | filename[i+1] = 'd'; |
1058 | filename[i+2] = 'a'; |
1059 | filename[i+3] = 't'; |
1060 | filename[i+4] = 'a'; |
1061 | filename[i+5] = '.'; |
1062 | filename[i+6] = 'j'; |
1063 | filename[i+7] = 's'; |
1064 | filename[i+8] = 0; |
1065 | #ifdef DEBUG |
1066 | printf(" JavaScript filename: %s\n", filename); |
1067 | #endif |
1068 | } else { |
1069 | *stream = NULL((void*)0); |
1070 | } |
1071 | |
1072 | /* make CAPS static */ |
1073 | status = caps_debug(problemObj); |
1074 | if (status < CAPS_SUCCESS0) { |
1075 | printf(" CAPS_Error: caps_debug returns %d!\n", status); |
1076 | return status; |
1077 | } else if (status != 1) { |
1078 | /* was in debug mode -- put it back! */ |
1079 | dbg = 1; |
1080 | status = caps_debug(problemObj); |
1081 | if (status < CAPS_SUCCESS0) return status; |
1082 | } |
1083 | |
1084 | /* Get number of AIMS */ |
1085 | status = caps_size(problemObj, ANALYSIS, NONE, &nAnalysis, &nErr, &errors); |
1086 | if (errors != NULL((void*)0)) caps_freeError(errors); |
1087 | if (status != CAPS_SUCCESS0) { |
1088 | printf(" CAPS Error: Problem Obj returns %d from caps_size(Analysis)!\n", |
1089 | status); |
1090 | goto cleanup; |
1091 | } |
1092 | #ifdef DEBUG |
1093 | printf(" %d Analyses found\n", nAnalysis); |
1094 | #endif |
1095 | if (nAnalysis == 0) { |
1096 | status = CAPS_STATEERR-329; |
1097 | goto cleanup; |
1098 | } |
1099 | |
1100 | status = caps_size(problemObj, BOUND, NONE, &nBound, &nErr, &errors); |
1101 | if (errors != NULL((void*)0)) caps_freeError(errors); |
1102 | if (status != CAPS_SUCCESS0) { |
1103 | printf(" CAPS Error: Problem Obj returns %d from caps_size(Bound)!\n", |
1104 | status); |
1105 | goto cleanup; |
1106 | } |
1107 | #ifdef DEBUG |
1108 | printf(" %d Bounds found\n", nBound); |
1109 | #endif |
1110 | |
1111 | aims = (AIMData *) malloc(nAnalysis * sizeof(AIMData)); |
1112 | if (aims == NULL((void*)0)) { |
1113 | printf(" CAPS Error: Cannot allocate %d AIM storage!\n", nAnalysis); |
1114 | status = EGADS_MALLOC-4; |
1115 | goto cleanup; |
1116 | } |
1117 | for (i = 0; i < nAnalysis; i++) { |
1118 | aims[i].id = NULL((void*)0); |
1119 | aims[i].inCount = 0; |
1120 | aims[i].outCount = 0; |
1121 | aims[i].dynOCount = 0; |
1122 | aims[i].analysisIn = NULL((void*)0); |
1123 | aims[i].analysisOut = NULL((void*)0); |
1124 | aims[i].analysisDynO = NULL((void*)0); |
1125 | } |
1126 | |
1127 | /* loop through each analysis (AIM) */ |
1128 | for (i = 0; i < nAnalysis; i++) { |
1129 | status = caps_childByIndex(problemObj, ANALYSIS, NONE, i+1, |
1130 | &analysisObj); |
1131 | if (status != CAPS_SUCCESS0) { |
1132 | printf(" CAPS Error: Problem Obj ret=%d from caps_cBI(Analy,%d)!\n", |
1133 | status, i+1); |
1134 | goto cleanup; |
1135 | } |
1136 | status = caps_info(analysisObj, &aName, &type, &subtype, &link, |
1137 | &parent, &own); |
1138 | if (status < CAPS_SUCCESS0) { |
1139 | printf(" CAPS Error: Analy Obj %d ret=%d from caps_info!\n", |
1140 | i+1, status); |
1141 | goto cleanup; |
1142 | } |
1143 | /* analysisInfo -> dirty: color Box differently, don't populate output */ |
1144 | status = caps_analysisInfo(analysisObj, &analysisPath, &unitSystem, |
1145 | &major, &minor, &intents, &nFields, &fnames, |
1146 | &ranks, &fInOut, &exec, &dirty); |
1147 | if (status != CAPS_SUCCESS0) { |
1148 | printf(" CAPS Error: Analy Obj %d ret=%d from caps_analysisInfo!\n", |
1149 | i+1, status); |
1150 | goto cleanup; |
1151 | } |
1152 | if (dirty != 0) { |
1153 | aims[i].dirty = true1; |
1154 | } else { |
1155 | aims[i].dirty = false0; |
1156 | } |
1157 | /* get # inputs */ |
1158 | status = caps_size(analysisObj, VALUE, ANALYSISIN, &nAnalIn, |
1159 | &nErr, &errors); |
1160 | if (errors != NULL((void*)0)) caps_freeError(errors); |
1161 | if (status != CAPS_SUCCESS0) { |
1162 | printf(" CAPS Error: Obj %s ret=%d from caps_size(AnalysisIn)!\n", |
1163 | aName, status); |
1164 | goto cleanup; |
1165 | } |
1166 | /* get # outputs */ |
1167 | status = caps_size(analysisObj, VALUE, ANALYSISOUT, &nAnalOut, |
1168 | &nErr, &errors); |
1169 | if (errors != NULL((void*)0)) caps_freeError(errors); |
1170 | if (status != CAPS_SUCCESS0) { |
1171 | printf(" CAPS Error: Obj %s ret=%d from caps_size(AnalysisOut)!\n", |
1172 | aName, status); |
1173 | goto cleanup; |
1174 | } |
1175 | /* get # dynamic outputs */ |
1176 | if (dirty == 0) { |
1177 | status = caps_size(analysisObj, VALUE, ANALYSISDYNO, &nDynAnalOut, |
1178 | &nErr, &errors); |
1179 | if (errors != NULL((void*)0)) caps_freeError(errors); |
1180 | if (status != CAPS_SUCCESS0) { |
1181 | printf(" CAPS Error: Obj %s ret=%d from caps_size(AnalysisDynO)!\n", |
1182 | aName, status); |
1183 | goto cleanup; |
1184 | } |
1185 | } else { |
1186 | nDynAnalOut = 0; |
1187 | } |
1188 | aims[i].id = aName; |
1189 | aims[i].inCount = nAnalIn; |
1190 | aims[i].outCount = nAnalOut; |
1191 | aims[i].dynOCount = nDynAnalOut; |
1192 | |
1193 | if (nAnalIn > 0) { |
1194 | aims[i].analysisIn = (ValueData *) malloc(nAnalIn*sizeof(ValueData)); |
1195 | if (aims[i].analysisIn == NULL((void*)0)) { |
1196 | printf(" CAPS Error: Name Malloc for %s -- %d AnalysisIn!\n", |
1197 | aName, nAnalIn); |
1198 | status = EGADS_MALLOC-4; |
1199 | goto cleanup; |
1200 | } |
1201 | for (j = 0; j < nAnalIn; j++) { |
1202 | /* get value object */ |
1203 | status = caps_childByIndex(analysisObj, VALUE, ANALYSISIN, j+1, |
1204 | &valueObj); |
1205 | if (status != CAPS_SUCCESS0) { |
1206 | printf(" CAPS Error: Object %s ret=%d from caps_child(AnalIn,%d)!\n", |
1207 | aName, status, j+1); |
1208 | goto cleanup; |
1209 | } |
1210 | status = caps_info(valueObj, &vName, &type, &subtype, &dataLink, |
1211 | &parent, &own); |
1212 | if (status < CAPS_SUCCESS0) { |
1213 | printf(" CAPS Error: Object %s ret=%d from caps_info(AnalIn,%d)!\n", |
1214 | vName, status, j+1); |
1215 | goto cleanup; |
1216 | } |
1217 | aims[i].analysisIn[j].name = vName; |
1218 | status = getValueData(&valueObj, &aims[i].analysisIn[j]); |
1219 | if (status != CAPS_SUCCESS0) goto cleanup; |
1220 | /* if linked to another aim */ |
1221 | if (dataLink != NULL((void*)0)) { |
1222 | status = caps_info(dataLink, &name, &type, &subtype, &link, |
1223 | &parent, &own); |
1224 | if (status < CAPS_SUCCESS0) { |
1225 | printf(" CAPS Error: Object %s ret=%d from caps_info(link)!\n", |
1226 | vName, status); |
1227 | goto cleanup; |
1228 | } |
1229 | tmpValLink = (ValLinkData *) realloc(valLinks, |
1230 | (valLinksIndex+1) * sizeof(ValLinkData)); |
1231 | if (tmpValLink == NULL((void*)0)) { |
1232 | printf(" CAPS Error: Link Malloc for %s -- %d Links!\n", |
1233 | aName, valLinksIndex+1); |
1234 | status = EGADS_MALLOC-4; |
1235 | goto cleanup; |
1236 | } |
1237 | valLinks = tmpValLink; |
1238 | valLinks[valLinksIndex].sourceAim = parent->name; |
1239 | /*@-kepttrans@*/ |
1240 | valLinks[valLinksIndex].targetAim = aName; |
1241 | valLinks[valLinksIndex].sourceVar = name; |
1242 | valLinks[valLinksIndex].targetVar = vName; |
1243 | /*@+kepttrans@*/ |
1244 | valLinksIndex++; |
1245 | } |
1246 | } |
1247 | } |
1248 | if (nAnalOut > 0) { |
1249 | aims[i].analysisOut = (ValueData *) malloc(nAnalOut*sizeof(ValueData)); |
1250 | if (aims[i].analysisOut == NULL((void*)0)) { |
1251 | printf(" CAPS Error: Name Malloc for %s -- %d AnalysisOut!\n", |
1252 | aName, nAnalOut); |
1253 | status = EGADS_MALLOC-4; |
1254 | goto cleanup; |
1255 | } |
1256 | for (j = 0; j < nAnalOut; j++) { |
1257 | status = caps_childByIndex(analysisObj, VALUE, ANALYSISOUT, j+1, |
1258 | &valueObj); |
1259 | if (status != CAPS_SUCCESS0) { |
1260 | printf(" CAPS Error: Obj %s ret=%d from caps_child(AnalOut,%d)!\n", |
1261 | aName, status, j+1); |
1262 | goto cleanup; |
1263 | } |
1264 | status = caps_info(valueObj, &vName, &type, &subtype, &dataLink, |
1265 | &parent, &own); |
1266 | if (status < CAPS_SUCCESS0) { |
1267 | printf(" CAPS Error: Obj %s ret=%d from caps_info(AnalOut,%d)!\n", |
1268 | vName, status, j+1); |
1269 | goto cleanup; |
1270 | } |
1271 | /*@-kepttrans@*/ |
1272 | aims[i].analysisOut[j].name = vName; |
1273 | /*@+kepttrans@*/ |
1274 | if (aims[i].dirty) { |
1275 | aims[i].analysisOut[j].nulldata = true1; |
1276 | } else { |
1277 | status = getValueData(&valueObj, &aims[i].analysisOut[j]); |
1278 | if (status != CAPS_SUCCESS0) goto cleanup; |
1279 | } |
1280 | } |
1281 | } |
1282 | if (nDynAnalOut > 0) { |
1283 | aims[i].analysisDynO = (ValueData *) malloc(nDynAnalOut*sizeof(ValueData)); |
1284 | if (aims[i].analysisDynO == NULL((void*)0)) { |
1285 | printf(" CAPS Error: Name Malloc for %s -- %d AnalysisDynOut!\n", |
1286 | aName, nDynAnalOut); |
1287 | status = EGADS_MALLOC-4; |
1288 | goto cleanup; |
1289 | } |
1290 | for (j = 0; j < nDynAnalOut; j++) { |
1291 | status = caps_childByIndex(analysisObj, VALUE, ANALYSISDYNO, j+1, |
1292 | &valueObj); |
1293 | if (status != CAPS_SUCCESS0) { |
1294 | printf(" CAPS Error: Obj %s ret=%d from caps_child(AnalDynOut,%d)!\n", |
1295 | aName, status, j+1); |
1296 | goto cleanup; |
1297 | } |
1298 | status = caps_info(valueObj, &vName, &type, &subtype, &dataLink, |
1299 | &parent, &own); |
1300 | if (status < CAPS_SUCCESS0) { |
1301 | printf(" CAPS Error: Obj %s ret=%d from caps_info(AnalDynOut,%d)!\n", |
1302 | vName, status, j+1); |
1303 | goto cleanup; |
1304 | } |
1305 | /*@-kepttrans@*/ |
1306 | aims[i].analysisDynO[j].name = vName; |
1307 | /*@+kepttrans@*/ |
1308 | status = getValueData(&valueObj, &aims[i].analysisDynO[j]); |
1309 | if (status != CAPS_SUCCESS0) goto cleanup; |
1310 | } |
1311 | } |
1312 | } |
1313 | |
1314 | /* loop through bounds */ |
1315 | if (nBound > 0) { |
1316 | for (i = 0; i < nBound; i++) { |
1317 | status = caps_childByIndex(problemObj, BOUND, NONE, i+1, &boundObject); |
1318 | if (status != CAPS_SUCCESS0) { |
1319 | printf(" CAPS Error: Problem Object ret=%d from caps_child(Bound,%d)!\n", |
1320 | status, i+1); |
1321 | goto cleanup; |
1322 | } |
1323 | status = caps_info(boundObject, &bName, &type, &subtype, &link, |
1324 | &parent, &own); |
1325 | if (status < CAPS_SUCCESS0) { |
1326 | printf(" CAPS Error: Bound Object ret=%d from caps_info,%d)!\n", |
1327 | status, i+1); |
1328 | goto cleanup; |
1329 | } |
1330 | status = caps_size(boundObject, VERTEXSET, CONNECTED, &nConnect, |
1331 | &nErr, &errors); |
1332 | if (errors != NULL((void*)0)) caps_freeError(errors); |
1333 | if (status != CAPS_SUCCESS0) { |
1334 | printf(" CAPS Error: Bound %s ret=%d from caps_size(VSconnected)!\n", |
1335 | bName, status); |
1336 | goto cleanup; |
1337 | } |
1338 | |
1339 | if (nConnect == 0) continue; |
1340 | for (j = 0; j < nConnect; j++) { |
1341 | status = caps_childByIndex(boundObject, VERTEXSET, CONNECTED, |
1342 | j+1, &vertexObj); |
1343 | if (status != CAPS_SUCCESS0) { |
1344 | printf(" CAPS Error: Obj %s ret=%d from caps_child(VSConnected,%d)!\n", |
1345 | bName, status, j+1); |
1346 | goto cleanup; |
1347 | } |
1348 | |
1349 | status = caps_vertexSetInfo(vertexObj, &nGpts, &nDpts, &bObj, |
1350 | &aObj); |
1351 | if (status != CAPS_SUCCESS0) { |
1352 | printf(" CAPS Error: Obj %d ret=%d from caps_vertesSetInfo!\n", |
1353 | j+1, status); |
1354 | goto cleanup; |
1355 | } |
1356 | status = caps_size(vertexObj, DATASET, NONE, &nDataSet, &nErr, |
1357 | &errors); |
1358 | if (status != CAPS_SUCCESS0) { |
1359 | printf(" CAPS Error: VSObj %d ret=%d from caps_size(DataSet)!\n", |
1360 | j+1, status); |
1361 | goto cleanup; |
1362 | } |
1363 | if (nDataSet == 0) continue; |
1364 | for (k = 0; k < nDataSet; k++) { |
1365 | status = caps_childByIndex(vertexObj, DATASET, NONE, k+1, |
1366 | &dataSetObj); |
1367 | if (status != CAPS_SUCCESS0) { |
1368 | printf(" CAPS Error: DSObj %d ret=%d from CBI(DataSet)!\n", |
1369 | k+1, status); |
1370 | goto cleanup; |
1371 | } |
1372 | status = caps_dataSetInfo(dataSetObj, &ftype, &dataLink, |
1373 | &dmethod); |
1374 | if (status != CAPS_SUCCESS0) { |
1375 | printf(" CAPS Error: DSObj %d ret=%d from dataSetInfo!\n", |
1376 | k+1, status); |
1377 | goto cleanup; |
1378 | } |
1379 | if (ftype == FieldIn) { |
1380 | status = caps_info(dataSetObj, &dName, &type, &subtype, |
1381 | &link, &parent, &own); |
1382 | if (status < CAPS_SUCCESS0) { |
1383 | printf(" CAPS Error: DSObj %d ret=%d from caps_info!\n", |
1384 | k+1, status); |
1385 | goto cleanup; |
1386 | } |
1387 | status = caps_info(dataLink, &name, &type, &subtype, |
1388 | &link, &parent, &own); |
1389 | if (status < CAPS_SUCCESS0) { |
1390 | printf(" CAPS Error: DSLnk %d ret=%d from caps_info!\n", |
1391 | k+1, status); |
1392 | goto cleanup; |
1393 | } |
1394 | tmpGeomLink = (GeomLinkData *) realloc(geomLinks, |
1395 | (geomLinksIndex+1) * sizeof(GeomLinkData)); |
1396 | if (tmpGeomLink == NULL((void*)0)) { |
1397 | printf(" CAPS Error: Link Malloc for %s -- %d Xfers!\n", |
1398 | bName, geomLinksIndex+1); |
1399 | status = EGADS_MALLOC-4; |
1400 | goto cleanup; |
1401 | } |
1402 | geomLinks = tmpGeomLink; |
1403 | geomLinks[geomLinksIndex].sourceAim = parent->name; |
1404 | geomLinks[geomLinksIndex].targetAim = aObj->name; |
1405 | /*@-kepttrans@*/ |
1406 | geomLinks[geomLinksIndex].sourceVar = name; |
1407 | geomLinks[geomLinksIndex].targetVar = dName; |
1408 | geomLinks[geomLinksIndex].bound = bName; |
1409 | /*@+kepttrans@*/ |
1410 | geomLinksIndex++; |
1411 | } |
1412 | } |
1413 | } |
1414 | } |
1415 | } |
1416 | |
1417 | /* make the stream */ |
1418 | status = EGADS_MALLOC-4; |
1419 | jsonText = (char *) EG_alloc(30 * sizeof(char)); |
1420 | if (jsonText == NULL((void*)0)) goto cleanup; |
1421 | snprintf(jsonText, 30, "dataJSON = {\n\"aims\": [\n"); |
1422 | |
1423 | for (i = 0; i < nAnalysis; i++) { |
1424 | size_t slen; |
1425 | char *idStr, *inStr, *outStr, *dynOStr, *aimStr; |
1426 | char dirtyStr[20]; |
1427 | |
1428 | slen = 20 + strlen(aims[i].id); |
1429 | idStr = (char *) malloc( slen * sizeof(char)); |
1430 | inStr = (char *) malloc( 20 * sizeof(char)); |
1431 | outStr = (char *) malloc( 20 * sizeof(char)); |
1432 | dynOStr = (char *) malloc( 20 * sizeof(char)); |
1433 | if ((idStr == NULL((void*)0)) || (inStr == NULL((void*)0)) || (outStr == NULL((void*)0)) || |
1434 | (dynOStr == NULL((void*)0))) { |
1435 | if (idStr != NULL((void*)0)) free(idStr); |
1436 | if (inStr != NULL((void*)0)) free(inStr); |
1437 | if (outStr != NULL((void*)0)) free(outStr); |
1438 | if (dynOStr != NULL((void*)0)) free(dynOStr); |
1439 | goto cleanup; |
1440 | } |
1441 | |
1442 | snprintf(idStr , slen, "\"id\": \"%s\"", aims[i].id); |
1443 | snprintf(dirtyStr, 20 , "\"dirty\": %s", aims[i].dirty ? "true" : "false"); |
1444 | snprintf(inStr , 20 , "\"inVars\" : ["); |
1445 | |
1446 | for (j = 0; j < aims[i].inCount; j++) { |
1447 | if (j > 0) strcat(inStr, ",\n"); |
1448 | varStr = valueString(&aims[i].analysisIn[j]); |
1449 | if (varStr == NULL((void*)0)) { |
1450 | free(idStr); |
1451 | free(inStr); |
1452 | free(outStr); |
1453 | free(dynOStr); |
1454 | goto cleanup; |
1455 | } |
1456 | tmpStr = (char *) realloc(inStr, (strlen(inStr)+strlen(varStr)+10)* |
1457 | sizeof(char)); |
1458 | if (tmpStr == NULL((void*)0)) { |
1459 | free(varStr); |
1460 | free(idStr); |
1461 | free(inStr); |
1462 | free(outStr); |
1463 | free(dynOStr); |
1464 | goto cleanup; |
1465 | } |
1466 | inStr = tmpStr; |
1467 | strcat(inStr, varStr); |
1468 | free(varStr); |
1469 | } |
1470 | strcat(inStr, "]"); |
1471 | |
1472 | snprintf(outStr, 20, "\"outVars\" : ["); |
1473 | for (j = 0; j < aims[i].outCount; j++) { |
1474 | if (j > 0) strcat(outStr, ",\n"); |
1475 | varStr = valueString(&aims[i].analysisOut[j]); |
1476 | if (varStr == NULL((void*)0)) { |
1477 | free(idStr); |
1478 | free(inStr); |
1479 | free(outStr); |
1480 | free(dynOStr); |
1481 | goto cleanup; |
1482 | } |
1483 | |
1484 | tmpStr = (char *) realloc(outStr, (strlen(outStr)+strlen(varStr)+10)* |
1485 | sizeof(char)); |
1486 | if (tmpStr == NULL((void*)0)) { |
1487 | free(varStr); |
1488 | free(idStr); |
1489 | free(inStr); |
1490 | free(outStr); |
1491 | free(dynOStr); |
1492 | goto cleanup; |
1493 | } |
1494 | outStr = tmpStr; |
1495 | strcat(outStr, varStr); |
1496 | free(varStr); |
1497 | } |
1498 | strcat(outStr, "]"); |
1499 | |
1500 | snprintf(dynOStr, 20, "\"dynOutVars\" : ["); |
1501 | for (j = 0; j < aims[i].dynOCount; j++) { |
1502 | if (j > 0) strcat(dynOStr, ",\n"); |
1503 | varStr = valueString(&aims[i].analysisDynO[j]); |
1504 | if (varStr == NULL((void*)0)) { |
1505 | free(idStr); |
1506 | free(inStr); |
1507 | free(outStr); |
1508 | free(dynOStr); |
1509 | goto cleanup; |
1510 | } |
1511 | tmpStr = (char *) realloc(dynOStr, (strlen(dynOStr)+strlen(varStr)+10)* |
1512 | sizeof(char)); |
1513 | if (tmpStr == NULL((void*)0)) { |
1514 | free(varStr); |
1515 | free(idStr); |
1516 | free(inStr); |
1517 | free(outStr); |
1518 | free(dynOStr); |
1519 | goto cleanup; |
1520 | } |
1521 | dynOStr = tmpStr; |
1522 | strcat(dynOStr, varStr); |
1523 | free(varStr); |
1524 | } |
1525 | strcat(dynOStr, "]"); |
1526 | |
1527 | slen = strlen(idStr) +strlen(dirtyStr)+strlen(inStr) + |
1528 | strlen(outStr)+strlen(dynOStr)+20; |
1529 | aimStr = (char *) malloc(slen*sizeof(char)); |
1530 | if (aimStr == NULL((void*)0)) { |
1531 | free(idStr); |
1532 | free(inStr); |
1533 | free(outStr); |
1534 | free(dynOStr); |
1535 | goto cleanup; |
1536 | } |
1537 | snprintf(aimStr, slen, "{ %s,\n %s,\n %s,\n %s,\n %s}", |
1538 | idStr, dirtyStr, inStr, outStr, dynOStr); |
1539 | |
1540 | tmpStr = (char *) EG_reall(jsonText, (strlen(jsonText)+strlen(aimStr) + |
1541 | 30) * sizeof(char)); |
1542 | if (tmpStr == NULL((void*)0)) { |
1543 | free(aimStr); |
1544 | free(idStr); |
1545 | free(inStr); |
1546 | free(outStr); |
1547 | free(dynOStr); |
1548 | goto cleanup; |
1549 | } |
1550 | jsonText = tmpStr; |
1551 | if (i > 0) strcat(jsonText, ",\n"); |
1552 | strcat(jsonText, aimStr); |
1553 | free(aimStr); |
1554 | free(idStr); |
1555 | free(inStr); |
1556 | free(outStr); |
1557 | free(dynOStr); |
1558 | } |
1559 | |
1560 | /*@-nullderef@*/ |
1561 | strcat(jsonText, "],\n \"valLinks\": [\n"); |
1562 | for (i = 0; i < valLinksIndex; i++) { |
1563 | size_t slen; |
1564 | char *sourceStr, *targetStr, *dataStr, *linkStr; |
1565 | |
1566 | sourceStr = (char *) malloc((strlen(valLinks[i].sourceAim) + 20) * |
1567 | sizeof(char)); |
1568 | targetStr = (char *) malloc((strlen(valLinks[i].targetAim) + 20) * |
1569 | sizeof(char)); |
1570 | dataStr = (char *) malloc((strlen(valLinks[i].sourceVar) + |
1571 | strlen(valLinks[i].targetVar) + 60) * |
1572 | sizeof(char)); |
1573 | if ((sourceStr == NULL((void*)0)) || (targetStr == NULL((void*)0)) || (dataStr == NULL((void*)0))) { |
1574 | if (sourceStr != NULL((void*)0)) free(sourceStr); |
1575 | if (targetStr != NULL((void*)0)) free(targetStr); |
1576 | if (dataStr != NULL((void*)0)) free(dataStr); |
1577 | goto cleanup; |
1578 | } |
1579 | snprintf(sourceStr, strlen(valLinks[i].sourceAim)+20, "\"source\": \"%s\"", valLinks[i].sourceAim); |
1580 | snprintf(targetStr, strlen(valLinks[i].targetAim)+20, "\"target\": \"%s\"", valLinks[i].targetAim); |
1581 | snprintf(dataStr , strlen(valLinks[i].sourceVar) + |
1582 | strlen(valLinks[i].targetVar) + 60, "\"data\": [{\"sourceVar\": \"%s\", \"targetVar\": \"%s\"}]", |
1583 | valLinks[i].sourceVar, valLinks[i].targetVar); |
1584 | |
1585 | slen = strlen(sourceStr) + strlen(targetStr) + strlen(dataStr) + 20; |
1586 | linkStr = (char *) malloc(slen * sizeof(char)); |
1587 | if (linkStr == NULL((void*)0)) { |
1588 | free(sourceStr); |
1589 | free(targetStr); |
1590 | free(dataStr); |
1591 | goto cleanup; |
1592 | } |
1593 | snprintf(linkStr, slen, "{ %s,\n %s,\n %s }", sourceStr, targetStr, dataStr); |
1594 | |
1595 | tmpStr = (char *) EG_reall(jsonText, (strlen(jsonText)+strlen(linkStr)+ |
1596 | 30) * sizeof(char)); |
1597 | if (tmpStr == NULL((void*)0)) { |
1598 | free(linkStr); |
1599 | free(sourceStr); |
1600 | free(targetStr); |
1601 | free(dataStr); |
1602 | goto cleanup; |
1603 | } |
1604 | jsonText = tmpStr; |
1605 | if (i > 0) strcat(jsonText, ",\n"); |
1606 | strcat(jsonText, linkStr); |
1607 | free(linkStr); |
1608 | free(sourceStr); |
1609 | free(targetStr); |
1610 | free(dataStr); |
1611 | } |
1612 | tmpStr = (char *) EG_reall(jsonText, strlen(jsonText)+30*sizeof(char)); |
1613 | if (tmpStr == NULL((void*)0)) goto cleanup; |
1614 | jsonText = tmpStr; |
1615 | |
1616 | strcat(jsonText, "],\n \"geomLinks\": [\n"); |
1617 | for (i = 0; i < geomLinksIndex; i++) { |
1618 | size_t slen; |
1619 | char *sourceStr, *targetStr, *dataStr, *linkStr; |
1620 | |
1621 | sourceStr = (char *) malloc((strlen(geomLinks[i].sourceAim) + 20) * |
1622 | sizeof(char)); |
1623 | targetStr = (char *) malloc((strlen(geomLinks[i].targetAim) + 20) * |
1624 | sizeof(char)); |
1625 | dataStr = (char *) malloc((strlen(geomLinks[i].sourceVar) + |
1626 | strlen(geomLinks[i].targetVar) + 80) * |
1627 | sizeof(char)); |
1628 | if ((sourceStr == NULL((void*)0)) || (targetStr == NULL((void*)0)) || (dataStr == NULL((void*)0))) { |
1629 | if (sourceStr != NULL((void*)0)) free(sourceStr); |
1630 | if (targetStr != NULL((void*)0)) free(targetStr); |
1631 | if (dataStr != NULL((void*)0)) free(dataStr); |
1632 | goto cleanup; |
1633 | } |
1634 | snprintf(sourceStr, strlen(geomLinks[i].sourceAim)+20, "\"source\": \"%s\"", geomLinks[i].sourceAim); |
1635 | snprintf(targetStr, strlen(geomLinks[i].targetAim)+20, "\"target\": \"%s\"", geomLinks[i].targetAim); |
1636 | snprintf(dataStr , strlen(geomLinks[i].sourceVar) + |
1637 | strlen(geomLinks[i].targetVar) + 80, "\"data\": [{\"bound\": \"%s\", \"sourceVar\": \"%s\", \"targetVar\": \"%s\"}]", |
1638 | geomLinks[i].bound, geomLinks[i].sourceVar, geomLinks[i].targetVar); |
1639 | |
1640 | slen = strlen(sourceStr) + strlen(targetStr) + strlen(dataStr) + 20; |
1641 | linkStr = (char *) malloc(slen * sizeof(char)); |
1642 | if (linkStr == NULL((void*)0)) { |
1643 | free(sourceStr); |
1644 | free(targetStr); |
1645 | free(dataStr); |
1646 | goto cleanup; |
1647 | } |
1648 | snprintf(linkStr, slen, "{ %s,\n %s,\n %s }", sourceStr, targetStr, dataStr); |
1649 | |
1650 | tmpStr = (char *) EG_reall(jsonText, (strlen(jsonText)+strlen(linkStr)+ |
1651 | 30) * sizeof(char)); |
1652 | if (tmpStr == NULL((void*)0)) { |
1653 | free(linkStr); |
1654 | free(sourceStr); |
1655 | free(targetStr); |
1656 | free(dataStr); |
1657 | goto cleanup; |
1658 | } |
1659 | jsonText = tmpStr; |
1660 | if (i > 0) strcat(jsonText, ",\n"); |
1661 | strcat(jsonText, linkStr); |
1662 | free(sourceStr); |
1663 | free(targetStr); |
1664 | free(dataStr); |
1665 | free(linkStr); |
1666 | } |
1667 | /*@+nullderef@*/ |
1668 | strcat(jsonText, "] \n }"); |
1669 | |
1670 | if (stream == NULL((void*)0)) { |
1671 | fptr = fopen(filename, "w"); |
1672 | if (fptr == NULL((void*)0)) { |
1673 | printf(" CAPS Error: error opening file %s\n", filename); |
1674 | status = CAPS_IOERR-332; |
1675 | goto cleanup; |
1676 | } |
1677 | fprintf(fptr, "%s", jsonText); |
1678 | fclose(fptr); |
1679 | |
1680 | // start browser and wait until done |
1681 | system(env); |
1682 | } |
1683 | #ifdef DEBUG |
1684 | printf("\n"); |
1685 | #endif |
1686 | status = CAPS_SUCCESS0; |
1687 | |
1688 | cleanup: |
1689 | if ((stream != NULL((void*)0)) && (status == CAPS_SUCCESS0)) { |
1690 | *stream = jsonText; |
1691 | } else { |
1692 | EG_free(jsonText); |
1693 | } |
1694 | if (geomLinks != NULL((void*)0)) free(geomLinks); |
1695 | if (valLinks != NULL((void*)0)) free(valLinks); |
1696 | if (aims != NULL((void*)0)) { |
1697 | for (i = 0; i < nAnalysis; i++) { |
1698 | if (aims[i].analysisDynO != NULL((void*)0)) free(aims[i].analysisDynO); |
1699 | if (aims[i].analysisOut != NULL((void*)0)) free(aims[i].analysisOut); |
1700 | if (aims[i].analysisIn != NULL((void*)0)) free(aims[i].analysisIn); |
1701 | } |
1702 | free(aims); |
1703 | } |
1704 | |
1705 | if (dbg == 0) { |
1706 | /* return of caps_debug(problemObj) should be 0 */ |
1707 | i = caps_debug(problemObj); |
1708 | if (i != 0) { |
1709 | printf(" CAPS_Error: CAPS debug sync problem!\n"); |
1710 | if ((stream != NULL((void*)0)) && (status == CAPS_SUCCESS0)) { |
1711 | EG_free(*stream); |
1712 | *stream = NULL((void*)0); |
1713 | } |
1714 | return CAPS_STATEERR-329; |
1715 | } |
1716 | } |
1717 | |
1718 | return status; |
1719 | } |