clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name capsProblem.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D REVISION=7.6 -I ../include -I /home/jenkins/workspace/ESP_Stanalizer/LINUX64/CAPS/scan-build/ESP/LINUX64/include -I . -I /usr/include/udunits2 -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-dangling-else -Wno-parentheses -Wno-unused-result -Wno-format-truncation -fdebug-compilation-dir /home/jenkins/workspace/ESP_Stanalizer/LINUX64/CAPS/scan-build/CAPS/src -ferror-limit 19 -fmessage-length 0 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/jenkins/workspace/ESP_Stanalizer/LINUX64/CAPS/scan-build/scanCAPS/2022-01-20-175430-12637-1 -x c capsProblem.c
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | #include <stdio.h> |
13 | #include <stdlib.h> |
14 | #include <string.h> |
15 | #include <signal.h> |
16 | #ifndef WIN32 |
17 | #include <strings.h> |
18 | #include <unistd.h> |
19 | #include <limits.h> |
20 | #else |
21 | #define strcasecmp stricmp |
22 | #define snprintf _snprintf |
23 | #define getcwd _getcwd |
24 | #define PATH_MAX _MAX_PATH |
25 | #endif |
26 | |
27 | #include "udunits.h" |
28 | |
29 | #include "capsBase.h" |
30 | #include "capsAIM.h" |
31 | |
32 | |
33 | #include "common.h" |
34 | #include "OpenCSM.h" |
35 | #include "udp.h" |
36 | |
37 | typedef void (*blCB)(capsObj problem, capsObj obj, int src, |
38 | enum capstMethod tmethod, char *name, |
39 | enum capssType stype); |
40 | |
41 | static int CAPSnLock = 0; |
42 | static char **CAPSlocks = NULL; |
43 | static int CAPSextSgnl = 1; |
44 | static blCB CAPScallBack = NULL; |
45 | |
46 | extern |
47 | void *caps_initUnits(); |
48 | extern void caps_initFunIDs(); |
49 | extern int caps_freeError( capsErrs *errs); |
50 | extern int caps_Aprx1DFree( capsAprx1D *approx); |
51 | extern int caps_Aprx2DFree( capsAprx2D *approx); |
52 | extern int caps_checkDiscr(capsDiscr *discr, int l, char *line); |
53 | extern int caps_filter(capsProblem *problem, capsAnalysis *analysis); |
54 | extern int caps_statFile(const char *path); |
55 | extern int caps_rmFile(const char *path); |
56 | extern int caps_rmDir(const char *path); |
57 | extern void caps_rmWild(const char *path); |
58 | extern int caps_mkDir(const char *path); |
59 | extern int caps_cpDir(const char *src, const char *dst); |
60 | extern int caps_rename(const char *src, const char *dst); |
61 | |
62 | |
63 | void |
64 | caps_rmLock(void) |
65 | { |
66 | int i; |
67 | |
68 | for (i = 0; i < CAPSnLock; i++) |
69 | if (CAPSlocks[i] != NULL) |
70 | caps_rmFile(CAPSlocks[i]); |
71 | |
72 | for (i = 0; i < CAPSnLock; i++) |
73 | if (CAPSlocks[i] != NULL) |
74 | EG_free(CAPSlocks[i]); |
75 | |
76 | EG_free(CAPSlocks); |
77 | CAPSnLock = 0; |
78 | CAPSlocks = NULL; |
79 | |
80 | |
81 | ocsmFree(NULL); |
82 | } |
83 | |
84 | |
85 | void |
86 | caps_rmLockOnClose(const char* root) |
87 | { |
88 | int i, j; |
89 | |
90 | for (i = 0; i < CAPSnLock; i++) { |
91 | if ((CAPSlocks[i] != NULL) && |
92 | (strncmp(CAPSlocks[i], root, strlen(root)) == 0)) { |
93 | caps_rmFile(CAPSlocks[i]); |
94 | EG_free(CAPSlocks[i]); |
95 | for (j = i; j < CAPSnLock-1; j++) |
96 | CAPSlocks[j] = CAPSlocks[j+1]; |
97 | CAPSnLock--; |
98 | break; |
99 | } |
100 | } |
101 | } |
102 | |
103 | |
104 | void |
105 | caps_externSignal() |
106 | { |
107 | if (CAPSextSgnl == 1) { |
108 | atexit(caps_rmLock); |
109 | caps_initFunIDs(); |
110 | } |
111 | |
112 | CAPSextSgnl = 0; |
113 | } |
114 | |
115 | |
116 | static void |
117 | caps_intHandler(int sig) |
118 | { |
119 | caps_rmLock(); |
120 | (void) signal(sig, SIG_DFL); |
121 | raise(sig); |
122 | } |
123 | |
124 | |
125 | static void |
126 | caps_initSignals() |
127 | { |
128 | if (CAPSextSgnl <= 0) return; |
129 | atexit(caps_rmLock); |
130 | (void) signal(SIGSEGV, caps_intHandler); |
131 | (void) signal(SIGINT, caps_intHandler); |
132 | #ifdef WIN32 |
133 | (void) signal(SIGABRT, caps_intHandler); |
134 | #else |
135 | |
136 | (void) signal(SIGHUP, caps_intHandler); |
137 | (void) signal(SIGBUS, caps_intHandler); |
138 | |
139 | #endif |
140 | caps_initFunIDs(); |
141 | |
142 | CAPSextSgnl = -1; |
143 | } |
144 | |
145 | |
146 | static void |
147 | caps_brokenLinkCB( capsObj problem, capsObj obj, int src, |
148 | enum capstMethod tmethod, char *name, |
149 | enum capssType stype) |
150 | { |
151 | if (src == 0) { |
152 | |
153 | printf(" BrokenLink: %s to lost %s (GeometryIn)!\n", obj->name, name); |
154 | } else { |
155 | |
156 | printf(" BrokenLink: lost %s (GeometryOut) to %s!\n", name, obj->name); |
157 | } |
158 | } |
159 | |
160 | |
161 | int |
162 | caps_isNameOK(const char *name) |
163 | { |
164 | int i, n; |
165 | |
166 | if (name == NULL) return CAPS_NULLNAME; |
167 | |
168 | n = strlen(name); |
169 | for (i = 0; i < n; i++) |
170 | if ((name[i] == '/') || (name[i] == '\\') || (name[i] == ':') || |
171 | (name[i] == ' ') || (name[i] == '@') || (name[i] == '!') || |
172 | (name[i] == '(') || (name[i] == ')')) return CAPS_BADNAME; |
173 | |
174 | return CAPS_SUCCESS; |
175 | } |
176 | |
177 | |
178 | static void |
179 | caps_prunePath(char *path) |
180 | { |
181 | int i, j, k, len, hit; |
182 | |
183 | |
184 | do { |
185 | hit = 0; |
186 | len = strlen(path); |
187 | for (i = 1; i < len-2; i++) |
188 | if ( (path[i-1] != '.') && (path[i] == '.') && |
189 | ((path[i+1] == '/') || (path[i+1] == '\\'))) break; |
190 | if (i == len-2) continue; |
191 | hit++; |
192 | for (j = i; j < len-1; j++) path[j] = path[j+2]; |
193 | } while (hit != 0); |
194 | |
195 | |
196 | do { |
197 | hit = 0; |
198 | len = strlen(path); |
199 | for (i = 0; i < len-3; i++) |
200 | if ((path[i] == '.') && (path[i+1] == '.') && |
201 | ((path[i+2] == '/') || (path[i+2] == '\\'))) break; |
202 | if (i == len-3) return; |
203 | hit++; |
204 | while (i+3*hit < len-3) |
205 | if ((path[i+3*hit] == '.') && (path[i+1+3*hit] == '.') && |
206 | ((path[i+2+3*hit] == '/') || (path[i+2+3*hit] == '\\'))) { |
207 | hit++; |
208 | } else { |
209 | break; |
210 | } |
211 | k = i + 3*hit; |
212 | hit++; |
213 | |
214 | |
215 | for (j = i; j >= 0; j--) |
216 | if ((path[j] == '/') || (path[j] == '\\')) { |
217 | hit--; |
218 | if (hit == 0) break; |
219 | } |
220 | if (j < 0) { |
221 | printf(" CAPS Warning: Invalid path = %s\n", path); |
222 | return; |
223 | } |
224 | for (i = k-1; i <= len; j++, i++) path[j] = path[i]; |
225 | hit++; |
226 | |
227 | } while (hit != 0); |
228 | |
229 | } |
230 | |
231 | |
232 | void |
233 | caps_freeValue(capsValue *value) |
234 | { |
235 | int i; |
236 | |
237 | if (value == NULL) return; |
238 | |
239 | if (value->units != NULL) EG_free(value->units); |
240 | if (value->meshWriter != NULL) EG_free(value->meshWriter); |
241 | if ((value->type == Boolean) || (value->type == Integer)) { |
242 | if (value->length > 1) EG_free(value->vals.integers); |
243 | } else if ((value->type == Double) || (value->type == DoubleDeriv)) { |
244 | if (value->length > 1) EG_free(value->vals.reals); |
245 | } else if (value->type == String) { |
246 | EG_free(value->vals.string); |
247 | } else if (value->type == Tuple) { |
248 | caps_freeTuple(value->length, value->vals.tuple); |
249 | } |
250 | if (value->partial != NULL) EG_free(value->partial); |
251 | if (value->derivs == NULL) return; |
252 | for (i = 0; i < value->nderiv; i++) { |
253 | if (value->derivs[i].name != NULL) EG_free(value->derivs[i].name); |
254 | if (value->derivs[i].deriv != NULL) EG_free(value->derivs[i].deriv); |
255 | } |
256 | EG_free(value->derivs); |
257 | } |
258 | |
259 | |
260 | void |
261 | caps_freeFList(capsObject *obj) |
262 | { |
263 | int i; |
264 | capsFList *flist, *next; |
265 | |
266 | if (obj->flist == NULL) return; |
267 | |
268 | flist = obj->flist; |
269 | do { |
270 | if (flist->type == jTuple) { |
271 | caps_freeTuple(flist->num, flist->member.tuple); |
272 | } else if (flist->type == jPointer) { |
273 | EG_free(flist->member.pointer); |
274 | } else if (flist->type == jOwn) { |
275 | caps_freeOwner(&flist->member.own); |
276 | } else if (flist->type == jOwns) { |
277 | for (i = 0; i < flist->num; i++) caps_freeOwner(&flist->member.owns[i]); |
278 | EG_free(flist->member.owns); |
279 | } else if (flist->type == jStrings) { |
280 | for (i = 0; i < flist->num; i++) EG_free(flist->member.strings[i]); |
281 | EG_free(flist->member.strings); |
282 | } else if (flist->type == jEgos) { |
283 | EG_deleteObject(flist->member.model); |
284 | } else { |
285 | printf(" CAPS Internal: caps_freeFList type = %d\n", flist->type); |
286 | } |
287 | next = flist->next; |
288 | EG_free(flist); |
289 | flist = next; |
290 | } while (flist != NULL); |
291 | |
292 | obj->flist = NULL; |
293 | } |
294 | |
295 | |
296 | int |
297 | caps_hierarchy(capsObject *obj, char **full) |
298 | { |
299 | int i, n, pos, index, len = 0; |
300 | char *path, number[5]; |
301 | capsObject *object; |
302 | capsBound *bound; |
303 | capsValue *value; |
304 | static char type[7] = {'U', 'P', 'V', 'A', 'B', 'S', 'D'}; |
305 | static char sub[12] = {'N', 'S', 'P', 'I', 'O', 'P', 'U', 'I', 'O', 'C', |
306 | 'N', 'D'}; |
307 | |
308 | *full = NULL; |
309 | if (obj == NULL) return CAPS_SUCCESS; |
310 | if (obj->type == PROBLEM) { |
311 | path = (char *) EG_alloc(2*sizeof(char)); |
312 | if (path == NULL) return EGADS_MALLOC; |
313 | path[0] = '.'; |
314 | path[1] = 0; |
315 | *full = path; |
316 | return CAPS_SUCCESS; |
317 | } |
318 | |
319 | object = obj; |
320 | do { |
321 | if ((object->type == VALUE) || (object->type == BOUND)) { |
322 | len += 8; |
323 | } else { |
324 | len += strlen(object->name) + 4; |
325 | } |
326 | object = object->parent; |
327 | } while (object->type != PROBLEM); |
328 | |
329 | path = (char *) EG_alloc(len*sizeof(char)); |
330 | if (path == NULL) return EGADS_MALLOC; |
331 | |
332 | pos = len; |
333 | object = obj; |
334 | do { |
335 | if ((object->type == VALUE) || (object->type == BOUND)) { |
336 | n = 4; |
337 | } else { |
338 | n = strlen(object->name); |
339 | } |
340 | pos -= n+4; |
341 | path[pos ] = type[object->type]; |
342 | path[pos+1] = sub[object->subtype]; |
343 | path[pos+2] = '-'; |
344 | if ((object->type == VALUE) || (object->type == BOUND)) { |
345 | if (object->type == VALUE) { |
346 | value = (capsValue *) object->blind; |
347 | index = value->index; |
348 | } else { |
349 | bound = (capsBound *) object->blind; |
350 | index = bound->index; |
351 | } |
352 | snprintf(number, 5, "%4.4d", index); |
353 | for (i = 0; i < 4; i++) path[pos+i+3] = number[i]; |
354 | } else { |
355 | for (i = 0; i < n; i++) path[pos+i+3] = object->name[i]; |
356 | } |
357 | path[pos+n+3] = '/'; |
358 | object = object->parent; |
359 | } while (object->type != PROBLEM); |
360 | path[len-1] = 0; |
361 | |
362 | *full = path; |
363 | return CAPS_SUCCESS; |
364 | } |
365 | |
366 | |
367 | static int |
368 | caps_string2obj(capsProblem *problem, const char *full, |
369 | capsObject **object) |
370 | { |
371 | int i, j, in, it, is, pos, len, index; |
372 | char name[PATH_MAX]; |
373 | capsObject *obj; |
374 | capsAnalysis *analysis; |
375 | capsBound *bound; |
376 | capsVertexSet *vs; |
377 | static char type[7] = {'U', 'P', 'V', 'A', 'B', 'S', 'D'}; |
378 | static char sub[12] = {'N', 'S', 'P', 'I', 'O', 'P', 'U', 'I', 'O', 'C', |
379 | 'N', 'D'}; |
380 | |
381 | *object = NULL; |
382 | if (full == NULL) return CAPS_SUCCESS; |
383 | len = strlen(full); |
384 | if ((len == 1) && (full[0] == '.')) { |
385 | *object = problem->mySelf; |
386 | return CAPS_SUCCESS; |
387 | } |
388 | |
389 | obj = NULL; |
390 | pos = 0; |
391 | do { |
392 | for (it = 0; it < 7; it++) |
393 | if (full[pos] == type[it]) break; |
394 | if (it == 7) { |
395 | printf(" CAPS Error: type %c not found (caps_string2obj)\n", full[pos]); |
396 | return CAPS_BADOBJECT; |
397 | } |
398 | pos++; |
399 | for (is = 0; is < 12; is++) |
400 | if (full[pos] == sub[is]) break; |
401 | if (is == 13) { |
402 | printf(" CAPS Error: subtype %c not found (caps_string2obj)\n", full[pos]); |
403 | return CAPS_BADOBJECT; |
404 | } |
405 | pos++; |
406 | if (full[pos] != '-') { |
407 | printf(" CAPS Error: %c not a seperator (caps_string2obj)\n", full[pos]); |
408 | return CAPS_BADOBJECT; |
409 | } |
410 | pos++; |
411 | in = pos; |
412 | for (; pos < len; pos++) |
413 | if ((full[pos] == '/') || (full[pos] == '\\')) break; |
414 | |
415 | if ((it == 2) || (it == 4)) { |
416 | |
417 | |
418 | index = atoi(&full[in]); |
419 | if (obj == NULL) { |
420 | |
421 | if (it == 2) { |
422 | if (is == 2) { |
423 | if (index > problem->nParam) { |
424 | printf(" CAPS Error: Bad index %d for pValue (caps_string2obj)\n", |
425 | index); |
426 | return CAPS_BADINDEX; |
427 | } |
428 | obj = problem->params[index-1]; |
429 | } else if (is == 3) { |
430 | if (index > problem->nGeomIn) { |
431 | printf(" CAPS Error: Bad index %d for giValue (caps_string2obj)\n", |
432 | index); |
433 | return CAPS_BADINDEX; |
434 | } |
435 | obj = problem->geomIn[index-1]; |
436 | } else if (is == 4) { |
437 | if (index > problem->nGeomOut) { |
438 | printf(" CAPS Error: Bad index %d for goValue (caps_string2obj)\n", |
439 | index); |
440 | return CAPS_BADINDEX; |
441 | } |
442 | obj = problem->geomOut[index-1]; |
443 | } else { |
444 | printf(" CAPS Error: incorrect sub %d for Value (caps_string2obj)\n", |
445 | is); |
446 | return CAPS_BADOBJECT; |
447 | } |
448 | } else { |
449 | for (i = 0; i < problem->nBound; i++) { |
450 | if (problem->bounds[i] == NULL) continue; |
451 | bound = (capsBound *) problem->bounds[i]->blind; |
452 | if (bound == NULL) continue; |
453 | if (bound->index == index) { |
454 | obj = problem->bounds[i]; |
455 | break; |
456 | } |
457 | } |
458 | if (i == problem->nBound) { |
459 | printf(" CAPS Error: Bad index %d for Bound (caps_string2obj)\n", |
460 | index); |
461 | return CAPS_BADINDEX; |
462 | } |
463 | } |
464 | } else { |
465 | |
466 | if (it == 4) { |
467 | printf(" CAPS Error: Bad Bound child %s (caps_string2obj)\n", full); |
468 | return CAPS_BADOBJECT; |
469 | } |
470 | if (obj->type != ANALYSIS) { |
471 | printf(" CAPS Error: Bad Value child %s (caps_string2obj)\n", full); |
472 | return CAPS_BADOBJECT; |
473 | } |
474 | analysis = (capsAnalysis *) obj->blind; |
475 | if (analysis == NULL) { |
476 | printf(" CAPS Error: NULL Analysis %s (caps_string2obj)\n", full); |
477 | return CAPS_BADOBJECT; |
478 | } |
479 | if (is == 3) { |
480 | if (index > analysis->nAnalysisIn) { |
481 | printf(" CAPS Error: Bad index %d for aiValue (caps_string2obj)\n", |
482 | index); |
483 | return CAPS_BADINDEX; |
484 | } |
485 | obj = analysis->analysisIn[index-1]; |
486 | } else if (is == 4) { |
487 | if (index > analysis->nAnalysisOut) { |
488 | printf(" CAPS Error: Bad index %d for aoValue (caps_string2obj)\n", |
489 | index); |
490 | return CAPS_BADINDEX; |
491 | } |
492 | obj = analysis->analysisOut[index-1]; |
493 | } else if (is == 11) { |
494 | if (index > analysis->nAnalysisDynO) { |
495 | printf(" CAPS Error: Bad index %d for adValue (caps_string2obj)\n", |
496 | index); |
497 | return CAPS_BADINDEX; |
498 | } |
499 | obj = analysis->analysisDynO[index-1]; |
500 | } else { |
501 | printf(" CAPS Error: Incorrect sub %d for Value (caps_string2obj)\n", |
502 | is); |
503 | return CAPS_BADOBJECT; |
504 | } |
505 | } |
506 | |
507 | } else { |
508 | |
509 | |
510 | j = 0; |
511 | for (i = in; i < pos; i++, j++) name[j] = full[i]; |
512 | name[j] = 0; |
513 | if (obj == NULL) { |
514 | |
515 | if (it != 3) { |
516 | printf(" CAPS Error: Incorrect type %d for Problem (caps_string2obj)\n", |
517 | it); |
518 | return CAPS_BADOBJECT; |
519 | } |
520 | for (i = 0; i < problem->nAnalysis; i++) |
521 | if (strcmp(name, problem->analysis[i]->name) == 0) { |
522 | obj = problem->analysis[i]; |
523 | break; |
524 | } |
525 | if (i == problem->nAnalysis) { |
526 | printf(" CAPS Error: Analysis %s Not Found (caps_string2obj)\n", name); |
527 | return CAPS_NOTFOUND; |
528 | } |
529 | } else { |
530 | |
531 | if (obj->type == BOUND) { |
532 | if (it != 5) { |
533 | printf(" CAPS Error: Bad Bound child %s (caps_string2obj)\n", full); |
534 | return CAPS_BADOBJECT; |
535 | } |
536 | bound = (capsBound *) obj->blind; |
537 | if (bound == NULL) { |
538 | printf(" CAPS Error: NULL Bound %s (caps_string2obj)\n", full); |
539 | return CAPS_BADOBJECT; |
540 | } |
541 | for (i = 0; i < bound->nVertexSet; i++) |
542 | if (strcmp(name, bound->vertexSet[i]->name) == 0) { |
543 | obj = bound->vertexSet[i]; |
544 | break; |
545 | } |
546 | if (i == bound->nVertexSet) { |
547 | printf(" CAPS Error: VertexSet %s Not Found (caps_string2obj)\n", |
548 | name); |
549 | return CAPS_NOTFOUND; |
550 | } |
551 | } else if (obj->type == VERTEXSET) { |
552 | if (it != 6) { |
553 | printf(" CAPS Error: Bad VertexSet child %s (caps_string2obj)\n", |
554 | full); |
555 | return CAPS_BADOBJECT; |
556 | } |
557 | vs = (capsVertexSet *) obj->blind; |
558 | if (vs == NULL) { |
559 | printf(" CAPS Error: NULL VertexSet %s (caps_string2obj)\n", full); |
560 | return CAPS_BADOBJECT; |
561 | } |
562 | for (i = 0; i < vs->nDataSets; i++) |
563 | if (strcmp(name, vs->dataSets[i]->name) == 0) { |
564 | obj = vs->dataSets[i]; |
565 | break; |
566 | } |
567 | if (i == vs->nDataSets) { |
568 | printf(" CAPS Error: DataSet %s Not Found (caps_string2obj)\n", |
569 | name); |
570 | return CAPS_NOTFOUND; |
571 | } |
572 | } else { |
573 | printf(" CAPS Error: Incorrect type %d for child (caps_string2obj)\n", |
574 | it); |
575 | return CAPS_BADOBJECT; |
576 | } |
577 | } |
578 | } |
579 | |
580 | pos++; |
581 | } while (pos < len); |
582 | |
583 | *object = obj; |
584 | |
585 | return CAPS_SUCCESS; |
586 | } |
587 | |
588 | |
589 | static int |
590 | caps_writeDoubles(FILE *fp, int len, const double *reals) |
591 | { |
592 | size_t n; |
593 | |
594 | if (len < 0) return CAPS_BADINDEX; |
595 | if ((reals == NULL) && (len != 0)) return CAPS_NULLVALUE; |
596 | n = fwrite(&len, sizeof(int), 1, fp); |
597 | if (n != 1) return CAPS_IOERR; |
598 | |
599 | if (reals == NULL) return CAPS_SUCCESS; |
600 | n = fwrite(reals, sizeof(double), len, fp); |
601 | if (n != len) return CAPS_IOERR; |
602 | |
603 | return CAPS_SUCCESS; |
604 | } |
605 | |
606 | |
607 | static int |
608 | caps_writeString(FILE *fp, const char *string) |
609 | { |
610 | int len = 0; |
611 | size_t n; |
612 | |
613 | if (string != NULL) len = strlen(string) + 1; |
614 | n = fwrite(&len, sizeof(int), 1, fp); |
615 | if (n != 1) return CAPS_IOERR; |
616 | |
617 | if (string == NULL) return CAPS_SUCCESS; |
618 | n = fwrite(string, sizeof(char), len, fp); |
619 | if (n != len) return CAPS_IOERR; |
620 | |
621 | return CAPS_SUCCESS; |
622 | } |
623 | |
624 | |
625 | static int |
626 | caps_writeStrings(FILE *fp, int len, const char *string) |
627 | { |
628 | int slen = 0, i; |
629 | size_t n; |
630 | |
631 | if (string != NULL) |
632 | for (i = 0; i < len; i++) |
633 | slen += strlen(string + slen) + 1; |
634 | n = fwrite(&slen, sizeof(int), 1, fp); |
635 | if (n != 1) return CAPS_IOERR; |
636 | |
637 | if (string == NULL) return CAPS_SUCCESS; |
638 | n = fwrite(string, sizeof(char), slen, fp); |
639 | if (n != slen) return CAPS_IOERR; |
640 | |
641 | return CAPS_SUCCESS; |
642 | } |
643 | |
644 | |
645 | static int |
646 | caps_writeTuple(FILE *fp, int len, enum capsNull nullVal, |
647 | capsTuple *tuple) |
648 | { |
649 | int i, stat; |
650 | |
651 | if (len < 0) return CAPS_BADINDEX; |
652 | if ((tuple == NULL) && (len != 0) && (nullVal != IsNull)) |
653 | return CAPS_NULLVALUE; |
654 | |
655 | if (tuple == NULL) return CAPS_SUCCESS; |
656 | for (i = 0; i < len; i++) { |
657 | stat = caps_writeString(fp, tuple[i].name); |
658 | if (stat != CAPS_SUCCESS) return stat; |
659 | stat = caps_writeString(fp, tuple[i].value); |
660 | if (stat != CAPS_SUCCESS) return stat; |
661 | } |
662 | |
663 | return CAPS_SUCCESS; |
664 | } |
665 | |
666 | |
667 | static int |
668 | caps_writeOwn(FILE *fp, capsOwn writer, capsOwn own) |
669 | { |
670 | int i, stat, nLines; |
671 | size_t n; |
672 | |
673 | nLines = 0; |
674 | if (own.lines != NULL) nLines = own.nLines; |
675 | n = fwrite(&nLines, sizeof(int), 1, fp); |
676 | if (n != 1) return CAPS_IOERR; |
677 | if (own.lines != NULL) |
678 | for (i = 0; i < nLines; i++) { |
679 | stat = caps_writeString(fp, own.lines[i]); |
680 | if (stat != CAPS_SUCCESS) return stat; |
681 | } |
682 | |
683 | if (own.pname == NULL) { |
684 | stat = caps_writeString(fp, writer.pname); |
685 | } else { |
686 | stat = caps_writeString(fp, own.pname); |
687 | } |
688 | if (stat != CAPS_SUCCESS) return stat; |
689 | if (own.pID == NULL) { |
690 | stat = caps_writeString(fp, writer.pID); |
691 | } else { |
692 | stat = caps_writeString(fp, own.pID); |
693 | } |
694 | if (stat != CAPS_SUCCESS) return stat; |
695 | if (own.user == NULL) { |
696 | stat = caps_writeString(fp, writer.user); |
697 | } else { |
698 | stat = caps_writeString(fp, own.user); |
699 | } |
700 | if (stat != CAPS_SUCCESS) return stat; |
701 | |
702 | n = fwrite(own.datetime, sizeof(short), 6, fp); |
703 | if (n != 6) return CAPS_IOERR; |
704 | |
705 | n = fwrite(&own.sNum, sizeof(CAPSLONG), 1, fp); |
706 | if (n != 1) return CAPS_IOERR; |
707 | |
708 | return CAPS_SUCCESS; |
709 | } |
710 | |
711 | |
712 | static int |
713 | caps_writeHistory(FILE *fp, const capsObject *obj) |
714 | { |
715 | int i, j, nHistory, nLines, stat; |
716 | size_t n; |
717 | |
718 | nHistory = obj->nHistory; |
719 | if (obj->history == NULL) nHistory = 0; |
720 | n = fwrite(&nHistory, sizeof(int), 1, fp); |
721 | if (n != 1) return CAPS_IOERR; |
722 | if (nHistory == 0) return CAPS_SUCCESS; |
723 | |
724 | if (obj->history != NULL) |
725 | for (j = 0; j < nHistory; j++) { |
726 | nLines = 0; |
727 | if (obj->history[j].lines != NULL) nLines = obj->history[j].nLines; |
728 | n = fwrite(&nLines, sizeof(int), 1, fp); |
729 | if (n != 1) return CAPS_IOERR; |
730 | if (obj->history[j].lines != NULL) |
731 | for (i = 0; i < nLines; i++) { |
732 | stat = caps_writeString(fp, obj->history[j].lines[i]); |
733 | if (stat != CAPS_SUCCESS) return stat; |
734 | } |
735 | |
736 | stat = caps_writeString(fp, obj->history[j].pname); |
737 | if (stat != CAPS_SUCCESS) return stat; |
738 | stat = caps_writeString(fp, obj->history[j].pID); |
739 | if (stat != CAPS_SUCCESS) return stat; |
740 | stat = caps_writeString(fp, obj->history[j].user); |
741 | if (stat != CAPS_SUCCESS) return stat; |
742 | |
743 | n = fwrite(obj->history[j].datetime, sizeof(short), 6, fp); |
744 | if (n != 6) return CAPS_IOERR; |
745 | |
746 | n = fwrite(&obj->history[j].sNum, sizeof(CAPSLONG), 1, fp); |
747 | if (n != 1) return CAPS_IOERR; |
748 | } |
749 | |
750 | return CAPS_SUCCESS; |
751 | } |
752 | |
753 | |
754 | static int |
755 | caps_writeAttrs(FILE *fp, egAttrs *attrs) |
756 | { |
757 | int nattr, i, stat; |
758 | size_t n; |
759 | egAttr *attr; |
760 | |
761 | nattr = 0; |
762 | if (attrs != NULL) nattr = attrs->nattrs; |
763 | n = fwrite(&nattr, sizeof(int), 1, fp); |
764 | if (n != 1) return CAPS_IOERR; |
765 | if ((nattr == 0) || (attrs == NULL)) return CAPS_SUCCESS; |
766 | |
767 | attr = attrs->attrs; |
768 | for (i = 0; i < nattr; i++) { |
769 | n = fwrite(&attr[i].type, sizeof(int), 1, fp); |
770 | if (n != 1) return CAPS_IOERR; |
771 | n = fwrite(&attr[i].length, sizeof(int), 1, fp); |
772 | if (n != 1) return CAPS_IOERR; |
773 | stat = caps_writeString(fp, attr[i].name); |
774 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
775 | if (attr[i].type == ATTRINT) { |
776 | n = attr[i].length; |
777 | if (attr[i].length == 1) { |
778 | n = fwrite(&attr[i].vals.integer, sizeof(int), 1, fp); |
779 | } else if (attr[i].length > 1) { |
780 | n = fwrite(attr[i].vals.integers, sizeof(int), attr[i].length, fp); |
781 | } |
782 | if (n != attr[i].length) return CAPS_IOERR; |
783 | } else if (attr[i].type == ATTRREAL) { |
784 | n = attr[i].length; |
785 | if (attr[i].length == 1) { |
786 | n = fwrite(&attr[i].vals.real, sizeof(double), 1, fp); |
787 | } else if (attr[i].length > 1) { |
788 | n = fwrite(attr[i].vals.reals, sizeof(double), attr[i].length, fp); |
789 | } |
790 | if (n != attr[i].length) return CAPS_IOERR; |
791 | } else { |
792 | stat = caps_writeStrings(fp, attr[i].length, attr[i].vals.string); |
793 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
794 | } |
795 | } |
796 | |
797 | return CAPS_SUCCESS; |
798 | } |
799 | |
800 | |
801 | static int |
802 | caps_writeValue(FILE *fp, capsOwn writer, capsObject *obj) |
803 | { |
804 | int i, j, stat; |
805 | char *name; |
806 | size_t n; |
807 | capsValue *value; |
808 | |
809 | stat = caps_writeHistory(fp, obj); |
810 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
811 | stat = caps_writeOwn(fp, writer, obj->last); |
812 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
813 | stat = caps_writeAttrs(fp, obj->attrs); |
814 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
815 | stat = caps_writeString(fp, obj->name); |
816 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
817 | stat = caps_hierarchy(obj, &name); |
818 | if (stat != CAPS_SUCCESS) return stat; |
819 | stat = caps_writeString(fp, name); |
820 | EG_free(name); |
821 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
822 | |
823 | value = (capsValue *) obj->blind; |
824 | if (value == NULL) return CAPS_NULLVALUE; |
825 | |
826 | n = fwrite(&value->type, sizeof(int), 1, fp); |
827 | if (n != 1) return CAPS_IOERR; |
828 | n = fwrite(&value->length, sizeof(int), 1, fp); |
829 | if (n != 1) return CAPS_IOERR; |
830 | n = fwrite(&value->dim, sizeof(int), 1, fp); |
831 | if (n != 1) return CAPS_IOERR; |
832 | n = fwrite(&value->nrow, sizeof(int), 1, fp); |
833 | if (n != 1) return CAPS_IOERR; |
834 | n = fwrite(&value->ncol, sizeof(int), 1, fp); |
835 | if (n != 1) return CAPS_IOERR; |
836 | n = fwrite(&value->lfixed, sizeof(int), 1, fp); |
837 | if (n != 1) return CAPS_IOERR; |
838 | n = fwrite(&value->sfixed, sizeof(int), 1, fp); |
839 | if (n != 1) return CAPS_IOERR; |
840 | n = fwrite(&value->nullVal, sizeof(int), 1, fp); |
841 | if (n != 1) return CAPS_IOERR; |
842 | n = fwrite(&value->index, sizeof(int), 1, fp); |
843 | if (n != 1) return CAPS_IOERR; |
844 | n = fwrite(&value->pIndex, sizeof(int), 1, fp); |
845 | if (n != 1) return CAPS_IOERR; |
846 | n = fwrite(&value->gInType, sizeof(int), 1, fp); |
847 | if (n != 1) return CAPS_IOERR; |
848 | n = fwrite(&value->nderiv, sizeof(int), 1, fp); |
849 | if (n != 1) return CAPS_IOERR; |
850 | |
851 | if (value->type == Integer) { |
852 | n = fwrite(value->limits.ilims, sizeof(int), 2, fp); |
853 | if (n != 2) return CAPS_IOERR; |
854 | } else if ((value->type == Double) || (value->type == DoubleDeriv)) { |
855 | n = fwrite(value->limits.dlims, sizeof(double), 2, fp); |
856 | if (n != 2) return CAPS_IOERR; |
857 | } |
858 | |
859 | stat = caps_writeString(fp, value->units); |
860 | if (stat != CAPS_SUCCESS) return stat; |
861 | stat = caps_writeString(fp, value->meshWriter); |
862 | if (stat != CAPS_SUCCESS) return stat; |
863 | name = NULL; |
864 | if (value->link != NULL) { |
865 | stat = caps_hierarchy(value->link, &name); |
866 | if (stat != CAPS_SUCCESS) return stat; |
867 | } |
868 | stat = caps_writeString(fp, name); |
869 | EG_free(name); |
870 | if (stat != CAPS_SUCCESS) return stat; |
871 | n = fwrite(&value->linkMethod, sizeof(int), 1, fp); |
872 | if (n != 1) return CAPS_IOERR; |
873 | |
874 | if ((value->length == 1) && (value->type != String) && |
875 | (value->type != Pointer) && (value->type != Tuple) && |
876 | (value->type != PointerMesh)) { |
877 | if ((value->type == Double) || (value->type == DoubleDeriv)) { |
878 | n = fwrite(&value->vals.real, sizeof(double), 1, fp); |
879 | if (n != 1) return CAPS_IOERR; |
880 | } else { |
881 | n = fwrite(&value->vals.integer, sizeof(int), 1, fp); |
882 | if (n != 1) return CAPS_IOERR; |
883 | } |
884 | } else { |
885 | if ((value->type == Pointer) || (value->type == PointerMesh)) { |
886 | |
887 | } else if ((value->type == Double) || (value->type == DoubleDeriv)) { |
888 | n = fwrite(value->vals.reals, sizeof(double), value->length, fp); |
889 | if (n != value->length) return CAPS_IOERR; |
890 | } else if (value->type == String) { |
891 | stat = caps_writeStrings(fp, value->length, value->vals.string); |
892 | if (stat != CAPS_SUCCESS) return stat; |
893 | } else if (value->type == Tuple) { |
894 | stat = caps_writeTuple(fp, value->length, value->nullVal, |
895 | value->vals.tuple); |
896 | if (stat != CAPS_SUCCESS) return stat; |
897 | } else { |
898 | n = fwrite(value->vals.integers, sizeof(int), value->length, fp); |
899 | if (n != value->length) return CAPS_IOERR; |
900 | } |
901 | } |
902 | |
903 | if (value->nullVal == IsPartial) { |
904 | n = fwrite(value->partial, sizeof(int), value->length, fp); |
905 | if (n != value->length) return CAPS_IOERR; |
906 | } |
907 | |
908 | if (value->nderiv != 0) { |
909 | for (i = 0; i < value->nderiv; i++) { |
910 | stat = caps_writeString(fp, value->derivs[i].name); |
911 | if (stat != CAPS_SUCCESS) return stat; |
912 | n = fwrite(&value->derivs[i].len_wrt, sizeof(int), 1, fp); |
913 | if (n != 1) return CAPS_IOERR; |
914 | j = value->length*value->derivs[i].len_wrt; |
915 | if (value->derivs[i].deriv == NULL) j = 0; |
916 | n = fwrite(&j, sizeof(int), 1, fp); |
917 | if (n != 1) return CAPS_IOERR; |
918 | if (j != 0) { |
919 | n = fwrite(value->derivs[i].deriv, sizeof(double), j, fp); |
920 | if (n != j) return CAPS_IOERR; |
921 | } |
922 | } |
923 | } |
924 | |
925 | return CAPS_SUCCESS; |
926 | } |
927 | |
928 | |
929 | int |
930 | caps_writeValueObj(capsProblem *problem, capsObject *valobj) |
931 | { |
932 | int status; |
933 | char filename[PATH_MAX], temp[PATH_MAX], *full; |
934 | FILE *fp; |
935 | |
936 | status = caps_hierarchy(valobj, &full); |
937 | if (status != CAPS_SUCCESS) { |
938 | printf(" CAPS Warning: caps_hierarchy = %d\n", status); |
939 | return status; |
940 | } |
941 | #ifdef WIN32 |
942 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\%s", problem->root, full); |
943 | snprintf(temp, PATH_MAX, "%s\\capsRestart\\xxTempxx", problem->root); |
944 | #else |
945 | snprintf(filename, PATH_MAX, "%s/capsRestart/%s", problem->root, full); |
946 | snprintf(temp, PATH_MAX, "%s/capsRestart/xxTempxx", problem->root); |
947 | #endif |
948 | EG_free(full); |
949 | |
950 | fp = fopen(temp, "wb"); |
951 | if (fp == NULL) { |
952 | printf(" CAPS Error: Cannot open %s!\n", filename); |
953 | return CAPS_DIRERR; |
954 | } |
955 | status = caps_writeValue(fp, problem->writer, valobj); |
956 | fclose(fp); |
957 | if (status != CAPS_SUCCESS) { |
958 | printf(" CAPS Error: Cannot write %s!\n", filename); |
959 | return status; |
960 | } |
961 | status = caps_rename(temp, filename); |
962 | if (status != CAPS_SUCCESS) { |
963 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
964 | return status; |
965 | } |
966 | |
967 | return CAPS_SUCCESS; |
968 | } |
969 | |
970 | |
971 | int |
972 | caps_dumpGeomVals(capsProblem *problem, int flag) |
973 | { |
974 | int i, status; |
975 | char filename[PATH_MAX], current[PATH_MAX], temp[PATH_MAX]; |
976 | FILE *fp; |
977 | |
978 | #ifdef WIN32 |
979 | snprintf(current, PATH_MAX, "%s\\capsRestart", problem->root); |
980 | snprintf(temp, PATH_MAX, "%s\\xxTempxx", current); |
981 | #else |
982 | snprintf(current, PATH_MAX, "%s/capsRestart", problem->root); |
983 | snprintf(temp, PATH_MAX, "%s/xxTempxx", current); |
984 | #endif |
985 | |
986 | if ((flag == 0) || (flag == 1)) |
987 | for (i = 0; i < problem->nGeomIn; i++) { |
988 | #ifdef WIN32 |
989 | snprintf(filename, PATH_MAX, "%s\\VI-%4.4d", current, i+1); |
990 | #else |
991 | snprintf(filename, PATH_MAX, "%s/VI-%4.4d", current, i+1); |
992 | #endif |
993 | fp = fopen(temp, "wb"); |
994 | if (fp == NULL) { |
995 | printf(" CAPS Error: Cannot open %s!\n", filename); |
996 | return CAPS_DIRERR; |
997 | } |
998 | status = caps_writeValue(fp, problem->writer, problem->geomIn[i]); |
999 | fclose(fp); |
1000 | if (status != CAPS_SUCCESS) { |
1001 | printf(" CAPS Error: Cannot write %s!\n", filename); |
1002 | return status; |
1003 | } |
1004 | status = caps_rename(temp, filename); |
1005 | if (status != CAPS_SUCCESS) { |
1006 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1007 | return status; |
1008 | } |
1009 | } |
1010 | |
1011 | if ((flag == 0) || (flag == 2)) |
1012 | for (i = 0; i < problem->nGeomOut; i++) { |
1013 | #ifdef WIN32 |
1014 | snprintf(filename, PATH_MAX, "%s\\VO-%4.4d", current, i+1); |
1015 | #else |
1016 | snprintf(filename, PATH_MAX, "%s/VO-%4.4d", current, i+1); |
1017 | #endif |
1018 | fp = fopen(temp, "wb"); |
1019 | if (fp == NULL) { |
1020 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1021 | return CAPS_DIRERR; |
1022 | } |
1023 | status = caps_writeValue(fp, problem->writer, problem->geomOut[i]); |
1024 | fclose(fp); |
1025 | if (status != CAPS_SUCCESS) { |
1026 | printf(" CAPS Error: Cannot write %s!\n", filename); |
1027 | return status; |
1028 | } |
1029 | status = caps_rename(temp, filename); |
1030 | if (status != CAPS_SUCCESS) { |
1031 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1032 | return status; |
1033 | } |
1034 | } |
1035 | |
1036 | return CAPS_SUCCESS; |
1037 | } |
1038 | |
1039 | |
1040 | static int |
1041 | caps_writeAnalysis(FILE *fp, capsProblem *problem, capsObject *aobject) |
1042 | { |
1043 | int i, stat; |
1044 | capsAnalysis *analysis; |
1045 | size_t n; |
1046 | |
1047 | analysis = (capsAnalysis *) aobject->blind; |
1048 | |
1049 | stat = caps_writeHistory(fp, aobject); |
1050 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
1051 | stat = caps_writeOwn(fp, problem->writer, aobject->last); |
1052 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
1053 | stat = caps_writeOwn(fp, problem->writer, analysis->pre); |
1054 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
1055 | stat = caps_writeAttrs(fp, aobject->attrs); |
1056 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
1057 | stat = caps_writeString(fp, aobject->name); |
1058 | if (stat != CAPS_SUCCESS) return stat; |
1059 | stat = caps_writeString(fp, analysis->loadName); |
1060 | if (stat != CAPS_SUCCESS) return stat; |
1061 | stat = caps_writeString(fp, analysis->path); |
1062 | if (stat != CAPS_SUCCESS) return stat; |
1063 | stat = caps_writeString(fp, analysis->unitSys); |
1064 | if (stat != CAPS_SUCCESS) return stat; |
1065 | stat = caps_writeString(fp, analysis->intents); |
1066 | if (stat != CAPS_SUCCESS) return stat; |
1067 | n = fwrite(&analysis->major, sizeof(int), 1, fp); |
1068 | if (n != 1) return CAPS_IOERR; |
1069 | n = fwrite(&analysis->minor, sizeof(int), 1, fp); |
1070 | if (n != 1) return CAPS_IOERR; |
1071 | n = fwrite(&analysis->autoexec, sizeof(int), 1, fp); |
1072 | if (n != 1) return CAPS_IOERR; |
1073 | n = fwrite(&analysis->nField, sizeof(int), 1, fp); |
1074 | if (n != 1) return CAPS_IOERR; |
1075 | for (i = 0; i < analysis->nField; i++) { |
1076 | stat = caps_writeString(fp, analysis->fields[i]); |
1077 | if (stat != CAPS_SUCCESS) return stat; |
1078 | } |
1079 | if (analysis->nField != 0) { |
1080 | n = fwrite(analysis->ranks, sizeof(int), analysis->nField, fp); |
1081 | if (n != analysis->nField) return CAPS_IOERR; |
1082 | n = fwrite(analysis->fInOut, sizeof(int), analysis->nField, fp); |
1083 | if (n != analysis->nField) return CAPS_IOERR; |
1084 | } |
1085 | n = fwrite(&analysis->nAnalysisDynO, sizeof(int), 1, fp); |
1086 | if (n != 1) return CAPS_IOERR; |
1087 | |
1088 | return CAPS_SUCCESS; |
1089 | } |
1090 | |
1091 | |
1092 | static int |
1093 | caps_writeAnalysisObj(capsProblem *problem, capsObject *aobject) |
1094 | { |
1095 | int status; |
1096 | char filename[PATH_MAX], current[PATH_MAX], temp[PATH_MAX]; |
1097 | FILE *fp; |
1098 | |
1099 | #ifdef WIN32 |
1100 | snprintf(current, PATH_MAX, "%s\\capsRestart\\AN-%s", |
1101 | problem->root, aobject->name); |
1102 | snprintf(temp, PATH_MAX, "%s\\xxTempxx", current); |
1103 | snprintf(filename, PATH_MAX, "%s\\analysis", current); |
1104 | #else |
1105 | snprintf(current, PATH_MAX, "%s/capsRestart/AN-%s", |
1106 | problem->root, aobject->name); |
1107 | snprintf(temp, PATH_MAX, "%s/xxTempxx", current); |
1108 | snprintf(filename, PATH_MAX, "%s/analysis", current); |
1109 | #endif |
1110 | |
1111 | fp = fopen(temp, "wb"); |
1112 | if (fp == NULL) { |
1113 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1114 | return CAPS_DIRERR; |
1115 | } |
1116 | status = caps_writeAnalysis(fp, problem, aobject); |
1117 | fclose(fp); |
1118 | if (status != CAPS_SUCCESS) { |
1119 | printf(" CAPS Error: Cannot write Analysis %s!\n", filename); |
1120 | return status; |
1121 | } |
1122 | status = caps_rename(temp, filename); |
1123 | if (status != CAPS_SUCCESS) { |
1124 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1125 | return status; |
1126 | } |
1127 | |
1128 | return CAPS_SUCCESS; |
1129 | } |
1130 | |
1131 | |
1132 | int |
1133 | caps_dumpAnalysis(capsProblem *problem, capsObject *aobject) |
1134 | { |
1135 | int i, status; |
1136 | char filename[PATH_MAX], current[PATH_MAX], temp[PATH_MAX]; |
1137 | capsAnalysis *analysis; |
1138 | FILE *fp; |
1139 | |
1140 | analysis = (capsAnalysis *) aobject->blind; |
1141 | #ifdef WIN32 |
1142 | snprintf(current, PATH_MAX, "%s\\capsRestart\\AN-%s", |
1143 | problem->root, aobject->name); |
1144 | snprintf(temp, PATH_MAX, "%s\\xxTempxx", current); |
1145 | snprintf(filename, PATH_MAX, "%s\\analysis", current); |
1146 | #else |
1147 | snprintf(current, PATH_MAX, "%s/capsRestart/AN-%s", |
1148 | problem->root, aobject->name); |
1149 | snprintf(temp, PATH_MAX, "%s/xxTempxx", current); |
1150 | snprintf(filename, PATH_MAX, "%s/analysis", current); |
1151 | #endif |
1152 | |
1153 | fp = fopen(temp, "wb"); |
1154 | if (fp == NULL) { |
1155 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1156 | return CAPS_DIRERR; |
1157 | } |
1158 | status = caps_writeAnalysis(fp, problem, aobject); |
1159 | fclose(fp); |
1160 | if (status != CAPS_SUCCESS) { |
1161 | printf(" CAPS Error: Cannot write Analysis %s!\n", filename); |
1162 | return status; |
1163 | } |
1164 | status = caps_rename(temp, filename); |
1165 | if (status != CAPS_SUCCESS) { |
1166 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1167 | return status; |
1168 | } |
1169 | |
1170 | #ifdef WIN32 |
1171 | snprintf(filename, PATH_MAX, "%s\\analysis.txt", current); |
1172 | snprintf(temp, PATH_MAX, "%s\\xxTempxx", current); |
1173 | #else |
1174 | snprintf(filename, PATH_MAX, "%s/analysis.txt", current); |
1175 | snprintf(temp, PATH_MAX, "%s/xxTempxx", current); |
1176 | #endif |
1177 | fp = fopen(temp, "w"); |
1178 | if (fp == NULL) { |
1179 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1180 | return CAPS_DIRERR; |
1181 | } |
1182 | fprintf(fp, "%d %d %d\n", analysis->nAnalysisIn, analysis->nAnalysisOut, |
1183 | analysis->nAnalysisDynO); |
1184 | if (analysis->analysisIn != NULL) |
1185 | for (i = 0; i < analysis->nAnalysisIn; i++) |
1186 | fprintf(fp, "%s\n", analysis->analysisIn[i]->name); |
1187 | if (analysis->analysisOut != NULL) |
1188 | for (i = 0; i < analysis->nAnalysisOut; i++) |
1189 | fprintf(fp, "%s\n", analysis->analysisOut[i]->name); |
1190 | if (analysis->analysisDynO != NULL) |
1191 | for (i = 0; i < analysis->nAnalysisDynO; i++) |
1192 | fprintf(fp, "%s\n", analysis->analysisDynO[i]->name); |
1193 | fclose(fp); |
1194 | status = caps_rename(temp, filename); |
1195 | if (status != CAPS_SUCCESS) { |
1196 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1197 | return status; |
1198 | } |
1199 | |
1200 | |
1201 | #ifdef WIN32 |
1202 | snprintf(filename, PATH_MAX, "%s\\VD-*", current); |
1203 | #else |
1204 | snprintf(filename, PATH_MAX, "%s/VD-*", current); |
1205 | #endif |
1206 | caps_rmWild(filename); |
1207 | |
1208 | |
1209 | |
1210 | if (analysis->analysisIn != NULL) |
1211 | for (i = 0; i < analysis->nAnalysisIn; i++) { |
1212 | #ifdef WIN32 |
1213 | snprintf(filename, PATH_MAX, "%s\\VI-%4.4d", current, i+1); |
1214 | #else |
1215 | snprintf(filename, PATH_MAX, "%s/VI-%4.4d", current, i+1); |
1216 | #endif |
1217 | fp = fopen(temp, "wb"); |
1218 | if (fp == NULL) { |
1219 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1220 | return CAPS_DIRERR; |
1221 | } |
1222 | status = caps_writeValue(fp, problem->writer, analysis->analysisIn[i]); |
1223 | fclose(fp); |
1224 | if (status != CAPS_SUCCESS) { |
1225 | printf(" CAPS Error: Cannot write %s!\n", filename); |
1226 | return status; |
1227 | } |
1228 | status = caps_rename(temp, filename); |
1229 | if (status != CAPS_SUCCESS) { |
1230 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1231 | return status; |
1232 | } |
1233 | } |
1234 | |
1235 | if (analysis->analysisOut != NULL) |
1236 | for (i = 0; i < analysis->nAnalysisOut; i++) { |
1237 | #ifdef WIN32 |
1238 | snprintf(filename, PATH_MAX, "%s\\VO-%4.4d", current, i+1); |
1239 | #else |
1240 | snprintf(filename, PATH_MAX, "%s/VO-%4.4d", current, i+1); |
1241 | #endif |
1242 | fp = fopen(temp, "wb"); |
1243 | if (fp == NULL) { |
1244 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1245 | return CAPS_DIRERR; |
1246 | } |
1247 | status = caps_writeValue(fp, problem->writer, analysis->analysisOut[i]); |
1248 | fclose(fp); |
1249 | if (status != CAPS_SUCCESS) { |
1250 | printf(" CAPS Error: Cannot write %d %s!\n", status, filename); |
1251 | return status; |
1252 | } |
1253 | status = caps_rename(temp, filename); |
1254 | if (status != CAPS_SUCCESS) { |
1255 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1256 | return status; |
1257 | } |
1258 | } |
1259 | |
1260 | |
1261 | if (analysis->analysisDynO != NULL) |
1262 | for (i = 0; i < analysis->nAnalysisDynO; i++) { |
1263 | #ifdef WIN32 |
1264 | snprintf(filename, PATH_MAX, "%s\\VD-%4.4d", current, i+1); |
1265 | #else |
1266 | snprintf(filename, PATH_MAX, "%s/VD-%4.4d", current, i+1); |
1267 | #endif |
1268 | fp = fopen(temp, "wb"); |
1269 | if (fp == NULL) { |
1270 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1271 | return CAPS_DIRERR; |
1272 | } |
1273 | status = caps_writeValue(fp, problem->writer, analysis->analysisDynO[i]); |
1274 | fclose(fp); |
1275 | if (status != CAPS_SUCCESS) { |
1276 | printf(" CAPS Error: Cannot write %d %s!\n", status, filename); |
1277 | return status; |
1278 | } |
1279 | status = caps_rename(temp, filename); |
1280 | if (status != CAPS_SUCCESS) { |
1281 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1282 | return status; |
1283 | } |
1284 | } |
1285 | |
1286 | return CAPS_SUCCESS; |
1287 | } |
1288 | |
1289 | |
1290 | int |
1291 | caps_writeDataSet(capsObject *dobject) |
1292 | { |
1293 | int stat; |
1294 | char filename[PATH_MAX], temp[PATH_MAX], *full, *name=NULL; |
1295 | capsObject *pobject; |
1296 | capsProblem *problem; |
1297 | capsDataSet *ds; |
1298 | size_t n; |
1299 | FILE *fp; |
1300 | |
1301 | stat = caps_findProblem(dobject, 9999, &pobject); |
1302 | if (stat != CAPS_SUCCESS) return stat; |
1303 | |
1304 | ds = (capsDataSet *) dobject->blind; |
1305 | problem = (capsProblem *) pobject->blind; |
1306 | stat = caps_hierarchy(dobject, &full); |
1307 | if (stat != CAPS_SUCCESS) return stat; |
1308 | #ifdef WIN32 |
1309 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\%s", problem->root, full); |
1310 | snprintf(temp, PATH_MAX, "%s\\capsRestart\\xxTempxx", problem->root); |
1311 | #else |
1312 | snprintf(filename, PATH_MAX, "%s/capsRestart/%s", problem->root, full); |
1313 | snprintf(temp, PATH_MAX, "%s/capsRestart/xxTempxx", problem->root); |
1314 | #endif |
1315 | EG_free(full); |
1316 | |
1317 | fp = fopen(temp, "wb"); |
1318 | if (fp == NULL) { |
1319 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1320 | return CAPS_DIRERR; |
1321 | } |
1322 | |
1323 | stat = caps_writeHistory(fp, dobject); |
1324 | if (stat != CAPS_SUCCESS) goto wrterrs; |
1325 | stat = caps_writeOwn(fp, problem->writer, dobject->last); |
1326 | if (stat != CAPS_SUCCESS) goto wrterrs; |
1327 | stat = caps_writeAttrs(fp, dobject->attrs); |
1328 | if (stat != CAPS_SUCCESS) goto wrterrs; |
1329 | stat = caps_writeString(fp, dobject->name); |
1330 | if (stat != CAPS_SUCCESS) goto wrterrs; |
1331 | |
1332 | n = fwrite(&ds->ftype, sizeof(int), 1, fp); |
1333 | if (n != 1) goto wrterrs; |
1334 | n = fwrite(&ds->npts, sizeof(int), 1, fp); |
1335 | if (n != 1) goto wrterrs; |
1336 | n = fwrite(&ds->rank, sizeof(int), 1, fp); |
1337 | if (n != 1) goto wrterrs; |
1338 | stat = caps_writeString(fp, ds->units); |
1339 | if (stat != CAPS_SUCCESS) goto wrterrs; |
1340 | |
1341 | stat = caps_writeDoubles(fp, ds->npts*ds->rank, ds->data); |
1342 | if (stat != CAPS_SUCCESS) goto wrterrs; |
1343 | |
1344 | name = NULL; |
1345 | if (ds->link != NULL) { |
1346 | stat = caps_hierarchy(ds->link, &name); |
1347 | if (stat != CAPS_SUCCESS) return stat; |
1348 | } |
1349 | stat = caps_writeString(fp, name); |
1350 | EG_free(name); |
1351 | if (stat != CAPS_SUCCESS) return stat; |
1352 | n = fwrite(&ds->linkMethod, sizeof(int), 1, fp); |
1353 | if (n != 1) goto wrterrs; |
1354 | fclose(fp); |
1355 | |
1356 | stat = caps_rename(temp, filename); |
1357 | if (stat != CAPS_SUCCESS) { |
1358 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1359 | return stat; |
1360 | } |
1361 | |
1362 | return CAPS_SUCCESS; |
1363 | |
1364 | wrterrs: |
1365 | fclose(fp); |
1366 | return CAPS_IOERR; |
1367 | } |
1368 | |
1369 | |
1370 | int |
1371 | caps_dumpBound(capsObject *pobject, capsObject *bobject) |
1372 | { |
1373 | int i, j, status; |
1374 | char filename[PATH_MAX], temp[PATH_MAX], *full; |
1375 | capsProblem *problem; |
1376 | capsBound *bound; |
1377 | capsVertexSet *vs; |
1378 | FILE *fp; |
1379 | |
1380 | problem = (capsProblem *) pobject->blind; |
1381 | bound = (capsBound *) bobject->blind; |
1382 | |
1383 | #ifdef WIN32 |
1384 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\BN-%4.4d\\vSets.txt", |
1385 | problem->root, bound->index); |
1386 | snprintf(temp, PATH_MAX, "%s\\capsRestart\\BN-%4.4d\\xxTempxx", |
1387 | problem->root, bound->index); |
1388 | #else |
1389 | snprintf(filename, PATH_MAX, "%s/capsRestart/BN-%4.4d/vSets.txt", |
1390 | problem->root, bound->index); |
1391 | snprintf(temp, PATH_MAX, "%s/capsRestart/BN-%4.4d/xxTempxx", |
1392 | problem->root, bound->index); |
1393 | #endif |
1394 | fp = fopen(temp, "w"); |
1395 | if (fp == NULL) { |
1396 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1397 | return CAPS_DIRERR; |
1398 | } |
1399 | fprintf(fp, "%d\n", bound->nVertexSet); |
1400 | if (bound->vertexSet != NULL) |
1401 | for (i = 0; i < bound->nVertexSet; i++) |
1402 | fprintf(fp, "%d %s\n", bound->vertexSet[i]->subtype, |
1403 | bound->vertexSet[i]->name); |
1404 | fclose(fp); |
1405 | status = caps_rename(temp, filename); |
1406 | if (status != CAPS_SUCCESS) { |
1407 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1408 | return status; |
1409 | } |
1410 | |
1411 | if (bound->vertexSet != NULL) |
1412 | for (i = 0; i < bound->nVertexSet; i++) { |
1413 | status = caps_hierarchy(bound->vertexSet[i], &full); |
1414 | if (status != CAPS_SUCCESS) { |
1415 | printf(" CAPS Warning: caps_hierarchy = %d\n", status); |
1416 | continue; |
1417 | } |
1418 | #ifdef WIN32 |
1419 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\%s", problem->root, full); |
1420 | #else |
1421 | snprintf(filename, PATH_MAX, "%s/capsRestart/%s", problem->root, full); |
1422 | #endif |
1423 | status = caps_mkDir(filename); |
1424 | if (status != CAPS_SUCCESS) { |
1425 | printf(" CAPS Warning: Cannot mkdir %s (caps_dumpBound)\n", filename); |
1426 | EG_free(full); |
1427 | continue; |
1428 | } |
1429 | #ifdef WIN32 |
1430 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\%s\\dSets.txt", |
1431 | problem->root, full); |
1432 | snprintf(temp, PATH_MAX, "%s\\capsRestart\\%s\\xxTempxx", |
1433 | problem->root, full); |
1434 | #else |
1435 | snprintf(filename, PATH_MAX, "%s/capsRestart/%s/dSets.txt", |
1436 | problem->root, full); |
1437 | snprintf(temp, PATH_MAX, "%s/capsRestart/%s/xxTempxx", |
1438 | problem->root, full); |
1439 | #endif |
1440 | EG_free(full); |
1441 | vs = (capsVertexSet *) bound->vertexSet[i]->blind; |
1442 | if (vs == NULL) continue; |
1443 | |
1444 | fp = fopen(temp, "w"); |
1445 | if (fp == NULL) { |
1446 | printf(" CAPS Warning: Cannot open %s!\n", filename); |
1447 | continue; |
1448 | } |
1449 | fprintf(fp, "%d\n", vs->nDataSets); |
1450 | if (vs->dataSets != NULL) |
1451 | for (j = 0; j < vs->nDataSets; j++) { |
1452 | fprintf(fp, "%s\n", vs->dataSets[j]->name); |
1453 | status = caps_writeDataSet(vs->dataSets[j]); |
1454 | if (status != CAPS_SUCCESS) { |
1455 | printf(" CAPS Warning: Writing %s = %d\n", |
1456 | vs->dataSets[j]->name, status); |
1457 | continue; |
1458 | } |
1459 | } |
1460 | fclose(fp); |
1461 | status = caps_rename(temp, filename); |
1462 | if (status != CAPS_SUCCESS) |
1463 | printf(" CAPS Warning: Cannot rename %s!\n", filename); |
1464 | } |
1465 | |
1466 | return CAPS_SUCCESS; |
1467 | } |
1468 | |
1469 | |
1470 | int |
1471 | caps_writeProblem(const capsObject *pobject) |
1472 | { |
1473 | int i, ivec[2], stat; |
1474 | char filename[PATH_MAX], temp[PATH_MAX]; |
1475 | capsProblem *problem; |
1476 | size_t n; |
1477 | FILE *fp; |
1478 | |
1479 | problem = (capsProblem *) pobject->blind; |
1480 | #ifdef WIN32 |
1481 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\Problem", problem->root); |
1482 | snprintf(temp, PATH_MAX, "%s\\capsRestart\\xxTempxx", problem->root); |
1483 | #else |
1484 | snprintf(filename, PATH_MAX, "%s/capsRestart/Problem", problem->root); |
1485 | snprintf(temp, PATH_MAX, "%s/capsRestart/xxTempxx", problem->root); |
1486 | #endif |
1487 | |
1488 | fp = fopen(temp, "wb"); |
1489 | if (fp == NULL) { |
1490 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1491 | return CAPS_DIRERR; |
1492 | } |
1493 | ivec[0] = CAPSMAJOR; |
1494 | ivec[1] = CAPSMINOR; |
1495 | |
1496 | n = fwrite(ivec, sizeof(int), 2, fp); |
1497 | if (n != 2) goto writerr; |
1498 | n = fwrite(&pobject->subtype, sizeof(int), 1, fp); |
1499 | if (n != 1) goto writerr; |
1500 | stat = caps_writeHistory(fp, pobject); |
1501 | if (stat != CAPS_SUCCESS) goto writerr; |
1502 | stat = caps_writeOwn(fp, problem->writer, pobject->last); |
1503 | if (stat != CAPS_SUCCESS) goto writerr; |
1504 | stat = caps_writeAttrs(fp, pobject->attrs); |
1505 | if (stat != CAPS_SUCCESS) goto writerr; |
1506 | stat = caps_writeString(fp, pobject->name); |
1507 | if (stat != CAPS_SUCCESS) goto writerr; |
1508 | stat = caps_writeString(fp, problem->phName); |
1509 | if (stat != CAPS_SUCCESS) goto writerr; |
1510 | stat = caps_writeOwn(fp, problem->writer, problem->geometry); |
1511 | if (stat != CAPS_SUCCESS) goto writerr; |
1512 | n = fwrite(&problem->sNum, sizeof(CAPSLONG), 1, fp); |
1513 | if (n != 1) goto writerr; |
1514 | #ifdef WIN32 |
1515 | n = fwrite(&problem->jpos, sizeof(__int64), 1, fp); |
1516 | #else |
1517 | n = fwrite(&problem->jpos, sizeof(long), 1, fp); |
1518 | #endif |
1519 | if (n != 1) goto writerr; |
1520 | n = fwrite(&problem->outLevel, sizeof(int), 1, fp); |
1521 | if (n != 1) goto writerr; |
1522 | n = fwrite(&problem->nEGADSmdl, sizeof(int), 1, fp); |
1523 | if (n != 1) goto writerr; |
1524 | i = problem->nRegGIN; |
1525 | if (problem->regGIN == NULL) i = 0; |
1526 | n = fwrite(&i, sizeof(int), 1, fp); |
1527 | if (n != 1) goto writerr; |
1528 | |
1529 | if (problem->regGIN != NULL) |
1530 | for (i = 0; i < problem->nRegGIN; i++) { |
1531 | stat = caps_writeString(fp, problem->regGIN[i].name); |
1532 | if (stat != CAPS_SUCCESS) goto writerr; |
1533 | n = fwrite(&problem->regGIN[i].index, sizeof(int), 1, fp); |
1534 | if (n != 1) goto writerr; |
1535 | n = fwrite(&problem->regGIN[i].irow, sizeof(int), 1, fp); |
1536 | if (n != 1) goto writerr; |
1537 | n = fwrite(&problem->regGIN[i].icol, sizeof(int), 1, fp); |
1538 | if (n != 1) goto writerr; |
1539 | } |
1540 | |
1541 | fclose(fp); |
1542 | stat = caps_rename(temp, filename); |
1543 | #ifdef WIN32 |
1544 | if (stat != CAPS_SUCCESS) { |
1545 | Sleep(100); |
1546 | stat = caps_rename(temp, filename); |
1547 | } |
1548 | #endif |
1549 | if (stat != CAPS_SUCCESS) |
1550 | printf(" CAPS Warning: Cannot rename %s!\n", filename); |
1551 | |
1552 | return CAPS_SUCCESS; |
1553 | |
1554 | writerr: |
1555 | fclose(fp); |
1556 | return CAPS_IOERR; |
1557 | } |
1558 | |
1559 | |
1560 | int |
1561 | caps_writeVertexSet(capsObject *vobject) |
1562 | { |
1563 | int i, dim, status; |
1564 | char filename[PATH_MAX], temp[PATH_MAX], *full; |
1565 | capsObject *pobject; |
1566 | capsProblem *problem; |
1567 | capsVertexSet *vs; |
1568 | size_t n; |
1569 | FILE *fp; |
1570 | |
1571 | status = caps_findProblem(vobject, 9999, &pobject); |
1572 | if (status != CAPS_SUCCESS) return status; |
1573 | |
1574 | vs = (capsVertexSet *) vobject->blind; |
1575 | problem = (capsProblem *) pobject->blind; |
1576 | status = caps_hierarchy(vobject, &full); |
1577 | if (status != CAPS_SUCCESS) return status; |
1578 | #ifdef WIN32 |
1579 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\%s\\vs", problem->root, full); |
1580 | snprintf(temp, PATH_MAX, "%s\\capsRestart\\xxTempxx", problem->root); |
1581 | #else |
1582 | snprintf(filename, PATH_MAX, "%s/capsRestart/%s/vs", problem->root, full); |
1583 | snprintf(temp, PATH_MAX, "%s/capsRestart/xxTempxx", problem->root); |
1584 | #endif |
1585 | EG_free(full); |
1586 | |
1587 | fp = fopen(temp, "wb"); |
1588 | if (fp == NULL) { |
1589 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1590 | return CAPS_DIRERR; |
1591 | } |
1592 | |
1593 | status = caps_writeHistory(fp, vobject); |
1594 | if (status != CAPS_SUCCESS) goto wrterr; |
1595 | status = caps_writeOwn(fp, problem->writer, vobject->last); |
1596 | if (status != CAPS_SUCCESS) goto wrterr; |
1597 | status = caps_writeAttrs(fp, vobject->attrs); |
1598 | if (status != CAPS_SUCCESS) goto wrterr; |
1599 | status = caps_writeString(fp, vobject->name); |
1600 | if (status != CAPS_SUCCESS) goto wrterr; |
1601 | |
1602 | |
1603 | dim = 0; |
1604 | if (vs->discr != NULL) dim = vs->discr->dim; |
1605 | n = fwrite(&dim, sizeof(int), 1, fp); |
1606 | if (n != 1) goto wrterr; |
1607 | if (vs->analysis != NULL) dim = 0; |
1608 | |
1609 | if (dim != 0) { |
1610 | |
1611 | #ifndef __clang_analyzer__ |
1612 | n = fwrite(&vs->discr->nVerts, sizeof(int), 1, fp); |
1613 | if (n != 1) goto wrterr; |
1614 | for (i = 0; i < vs->discr->nVerts; i++) { |
1615 | n = fwrite(&vs->discr->verts[3*i], sizeof(double), 3, fp); |
1616 | if (n != 3) goto wrterr; |
1617 | } |
1618 | #endif |
1619 | |
1620 | } |
1621 | fclose(fp); |
1622 | |
1623 | status = caps_rename(temp, filename); |
1624 | if (status != CAPS_SUCCESS) { |
1625 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1626 | return status; |
1627 | } |
1628 | |
1629 | return CAPS_SUCCESS; |
1630 | |
1631 | wrterr: |
1632 | fclose(fp); |
1633 | return CAPS_IOERR; |
1634 | } |
1635 | |
1636 | |
1637 | int |
1638 | caps_writeBound(const capsObject *bobject) |
1639 | { |
1640 | int i, status; |
1641 | char filename[PATH_MAX], temp[PATH_MAX]; |
1642 | capsObject *pobject; |
1643 | capsProblem *problem; |
1644 | capsBound *bound; |
1645 | size_t n; |
1646 | FILE *fp; |
1647 | |
1648 | bound = (capsBound *) bobject->blind; |
1649 | pobject = bobject->parent; |
1650 | problem = (capsProblem *) pobject->blind; |
1651 | |
1652 | #ifdef WIN32 |
1653 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\BN-%4.4d\\bound", |
1654 | problem->root, bound->index); |
1655 | snprintf(temp, PATH_MAX, "%s\\capsRestart\\BN-%4.4d\\xxTempxx", |
1656 | problem->root, bound->index); |
1657 | #else |
1658 | snprintf(filename, PATH_MAX, "%s/capsRestart/BN-%4.4d/bound", |
1659 | problem->root, bound->index); |
1660 | snprintf(temp, PATH_MAX, "%s/capsRestart/BN-%4.4d/xxTempxx", |
1661 | problem->root, bound->index); |
1662 | #endif |
1663 | fp = fopen(temp, "wb"); |
1664 | if (fp == NULL) { |
1665 | printf(" CAPS Error: Cannot open %s!\n", filename); |
1666 | return CAPS_DIRERR; |
1667 | } |
1668 | |
1669 | status = caps_writeHistory(fp, bobject); |
1670 | if (status != CAPS_SUCCESS) goto werror; |
1671 | status = caps_writeOwn(fp, problem->writer, bobject->last); |
1672 | if (status != CAPS_SUCCESS) goto werror; |
1673 | status = caps_writeAttrs(fp, bobject->attrs); |
1674 | if (status != CAPS_SUCCESS) goto werror; |
1675 | status = caps_writeString(fp, bobject->name); |
1676 | if (status != CAPS_SUCCESS) goto werror; |
1677 | n = fwrite(&bound->dim, sizeof(int), 1, fp); |
1678 | if (n != 1) goto werror; |
1679 | n = fwrite(&bound->state, sizeof(int), 1, fp); |
1680 | if (n != 1) goto werror; |
1681 | n = fwrite(&bound->plimits, sizeof(double), 4, fp); |
1682 | if (n != 4) goto werror; |
1683 | n = fwrite(&bound->iBody, sizeof(int), 1, fp); |
1684 | if (n != 1) goto werror; |
1685 | n = fwrite(&bound->iEnt, sizeof(int), 1, fp); |
1686 | if (n != 1) goto werror; |
1687 | n = fwrite(&bound->index, sizeof(int), 1, fp); |
1688 | if (n != 1) goto werror; |
1689 | |
1690 | i = 0; |
1691 | if (bound->curve != NULL) i = bound->curve->nrank; |
1692 | n = fwrite(&i, sizeof(int), 1, fp); |
1693 | if (n != 1) goto werror; |
1694 | if (bound->curve != NULL) { |
1695 | n = fwrite(&bound->curve->periodic, sizeof(int), 1, fp); |
1696 | if (n != 1) goto werror; |
1697 | n = fwrite(&bound->curve->nts, sizeof(int), 1, fp); |
1698 | if (n != 1) goto werror; |
1699 | n = 2*bound->curve->nts*bound->curve->nrank; |
1700 | status = caps_writeDoubles(fp, n, bound->curve->interp); |
1701 | if (status != CAPS_SUCCESS) goto werror; |
1702 | n = fwrite(bound->curve->trange, sizeof(double), 2, fp); |
1703 | if (n != 2) goto werror; |
1704 | n = fwrite(&bound->curve->ntm, sizeof(int), 1, fp); |
1705 | if (n != 1) goto werror; |
1706 | n = 2*bound->curve->ntm; |
1707 | status = caps_writeDoubles(fp, n, bound->curve->tmap); |
1708 | if (status != CAPS_SUCCESS) goto werror; |
1709 | } |
1710 | |
1711 | i = 0; |
1712 | if (bound->surface != NULL) i = bound->surface->nrank; |
1713 | n = fwrite(&i, sizeof(int), 1, fp); |
1714 | if (n != 1) goto werror; |
1715 | if (bound->surface != NULL) { |
1716 | n = fwrite(&bound->surface->periodic, sizeof(int), 1, fp); |
1717 | if (n != 1) goto werror; |
1718 | n = fwrite(&bound->surface->nus, sizeof(int), 1, fp); |
1719 | if (n != 1) goto werror; |
1720 | n = fwrite(&bound->surface->nvs, sizeof(int), 1, fp); |
1721 | if (n != 1) goto werror; |
1722 | n = 4*bound->surface->nus*bound->surface->nvs*bound->surface->nrank; |
1723 | status = caps_writeDoubles(fp, n, bound->surface->interp); |
1724 | if (status != CAPS_SUCCESS) goto werror; |
1725 | n = fwrite(bound->surface->urange, sizeof(double), 2, fp); |
1726 | if (n != 2) goto werror; |
1727 | n = fwrite(bound->surface->vrange, sizeof(double), 2, fp); |
1728 | if (n != 2) goto werror; |
1729 | n = fwrite(&bound->surface->num, sizeof(int), 1, fp); |
1730 | if (n != 1) goto werror; |
1731 | n = fwrite(&bound->surface->nvm, sizeof(int), 1, fp); |
1732 | if (n != 1) goto werror; |
1733 | n = 8*bound->surface->num*bound->surface->nvm; |
1734 | status = caps_writeDoubles(fp, n, bound->surface->uvmap); |
1735 | if (status != CAPS_SUCCESS) goto werror; |
1736 | } |
1737 | fclose(fp); |
1738 | |
1739 | status = caps_rename(temp, filename); |
1740 | if (status != CAPS_SUCCESS) { |
1741 | printf(" CAPS Error: Cannot rename %s!\n", filename); |
1742 | return status; |
1743 | } |
1744 | |
1745 | return CAPS_SUCCESS; |
1746 | |
1747 | werror: |
1748 | fclose(fp); |
1749 | return CAPS_IOERR; |
1750 | } |
1751 | |
1752 | |
1753 | int |
1754 | caps_writeObject(capsObject *object) |
1755 | { |
1756 | int status = CAPS_SUCCESS; |
1757 | capsObject *pobject; |
1758 | capsProblem *problem; |
1759 | |
1760 | if (object->type == PROBLEM) { |
1761 | status = caps_writeProblem(object); |
1762 | } else if (object->type == VALUE) { |
1763 | status = caps_findProblem(object, 9999, &pobject); |
1764 | if (status != CAPS_SUCCESS) return status; |
1765 | problem = (capsProblem *) pobject->blind; |
1766 | status = caps_writeValueObj(problem, object); |
1767 | } else if (object->type == ANALYSIS) { |
1768 | status = caps_findProblem(object, 9999, &pobject); |
1769 | if (status != CAPS_SUCCESS) return status; |
1770 | problem = (capsProblem *) pobject->blind; |
1771 | status = caps_writeAnalysisObj(problem, object); |
1772 | } else if (object->type == BOUND) { |
1773 | status = caps_writeBound(object); |
1774 | } else if (object->type == VERTEXSET) { |
1775 | status = caps_writeVertexSet(object); |
1776 | } else if (object->type == DATASET) { |
1777 | status = caps_writeDataSet(object); |
1778 | } |
1779 | |
1780 | return status; |
1781 | } |
1782 | |
1783 | |
1784 | static int |
1785 | caps_writeErrs(FILE *fp, capsErrs *errs) |
1786 | { |
1787 | int i, j, nError, stat; |
1788 | char *full; |
1789 | size_t n; |
1790 | |
1791 | nError = 0; |
1792 | if (errs != NULL) nError = errs->nError; |
1793 | n = fwrite(&nError, sizeof(int), 1, fp); |
1794 | if (n != 1) return CAPS_IOERR; |
1795 | if ((nError == 0) || (errs == NULL)) return CAPS_SUCCESS; |
1796 | |
1797 | for (i = 0; i < nError; i++) { |
1798 | full = NULL; |
1799 | if (errs->errors[i].errObj != NULL) { |
1800 | stat = caps_hierarchy(errs->errors[i].errObj, &full); |
1801 | if (stat != CAPS_SUCCESS) |
1802 | printf(" CAPS Warning: caps_hierarchy = %d (caps_writeErrs)\n", stat); |
1803 | } |
1804 | stat = caps_writeString(fp, full); |
1805 | if (stat != CAPS_SUCCESS) { |
1806 | printf(" CAPS Warning: caps_writeString = %d (caps_writeErrs)\n", stat); |
1807 | return CAPS_IOERR; |
1808 | } |
1809 | n = fwrite(&errs->errors[i].eType, sizeof(int), 1, fp); |
1810 | if (n != 1) return CAPS_IOERR; |
1811 | n = fwrite(&errs->errors[i].index, sizeof(int), 1, fp); |
1812 | if (n != 1) return CAPS_IOERR; |
1813 | n = fwrite(&errs->errors[i].nLines, sizeof(int), 1, fp); |
1814 | if (n != 1) return CAPS_IOERR; |
1815 | for (j = 0; j < errs->errors[i].nLines; j++) { |
1816 | stat = caps_writeString(fp, errs->errors[i].lines[j]); |
1817 | if (stat != CAPS_SUCCESS) { |
1818 | printf(" CAPS Warning: %d caps_writeString = %d (caps_writeErrs)\n", |
1819 | j, stat); |
1820 | return CAPS_IOERR; |
1821 | } |
1822 | } |
1823 | } |
1824 | |
1825 | return CAPS_SUCCESS; |
1826 | } |
1827 | |
1828 | |
1829 | void |
1830 | caps_jrnlWrite(capsProblem *problem, capsObject *obj, int status, |
1831 | int nargs, capsJrnl *args, CAPSLONG sNum0, CAPSLONG sNum) |
1832 | { |
1833 | int i, j, stat; |
1834 | char filename[PATH_MAX], *full; |
1835 | capsFList *flist; |
1836 | size_t n; |
1837 | |
1838 | if (problem->jrnl == NULL) return; |
1839 | if (problem->stFlag == CAPS_JOURNALERR) return; |
1840 | |
1841 | n = fwrite(&problem->funID, sizeof(int), 1, problem->jrnl); |
1842 | if (n != 1) goto jwrterr; |
1843 | n = fwrite(&sNum0, sizeof(CAPSLONG), 1, problem->jrnl); |
1844 | if (n != 1) goto jwrterr; |
1845 | n = fwrite(&status, sizeof(int), 1, problem->jrnl); |
1846 | if (n != 1) goto jwrterr; |
1847 | |
1848 | |
1849 | |
1850 | |
1851 | if (status == CAPS_SUCCESS) { |
1852 | n = fwrite(&obj->last.sNum, sizeof(CAPSLONG), 1, problem->jrnl); |
1853 | if (n != 1) goto jwrterr; |
1854 | |
1855 | if (obj->flist != NULL) { |
1856 | flist = (capsFList *) obj->flist; |
1857 | if (obj->last.sNum > flist->sNum) caps_freeFList(obj); |
1858 | } |
1859 | |
1860 | for (i = 0; i < nargs; i++) |
1861 | switch (args[i].type) { |
1862 | |
1863 | case jInteger: |
1864 | n = fwrite(&args[i].members.integer, sizeof(int), 1, problem->jrnl); |
1865 | if (n != 1) goto jwrterr; |
1866 | break; |
1867 | |
1868 | case jDouble: |
1869 | n = fwrite(&args[i].members.real, sizeof(double), 1, problem->jrnl); |
1870 | if (n != 1) goto jwrterr; |
1871 | break; |
1872 | |
1873 | case jString: |
1874 | stat = caps_writeString(problem->jrnl, args[i].members.string); |
1875 | if (stat != CAPS_SUCCESS) { |
1876 | printf(" CAPS Warning: Journal caps_writeString = %d!\n", stat); |
1877 | goto jwrterr; |
1878 | } |
1879 | break; |
1880 | |
1881 | case jStrings: |
1882 | n = fwrite(&args[i].num, sizeof(int), 1, problem->jrnl); |
1883 | if (n != 1) goto jwrterr; |
1884 | for (j = 0; j < args[i].num; j++) { |
1885 | stat = caps_writeString(problem->jrnl, args[i].members.strings[j]); |
1886 | if (stat != CAPS_SUCCESS) { |
1887 | printf(" CAPS Warning: Journal %d caps_writeString = %d!\n", |
1888 | j, stat); |
1889 | goto jwrterr; |
1890 | } |
1891 | } |
1892 | break; |
1893 | |
1894 | case jTuple: |
1895 | n = fwrite(&args[i].num, sizeof(int), 1, problem->jrnl); |
1896 | if (n != 1) goto jwrterr; |
1897 | stat = caps_writeTuple(problem->jrnl, args[i].num, NotNull, |
1898 | args[i].members.tuple); |
1899 | if (stat != CAPS_SUCCESS) { |
1900 | printf(" CAPS Warning: Journal caps_writeTuple = %d!\n", stat); |
1901 | goto jwrterr; |
1902 | } |
1903 | break; |
1904 | |
1905 | case jPointer: |
1906 | case jPtrFree: |
1907 | n = fwrite(&args[i].length, sizeof(size_t), 1, problem->jrnl); |
1908 | if (n != 1) goto jwrterr; |
1909 | if (args[i].length != 0) { |
1910 | n = fwrite(args[i].members.pointer, sizeof(char), args[i].length, |
1911 | problem->jrnl); |
1912 | if (n != args[i].length) goto jwrterr; |
1913 | } |
1914 | break; |
1915 | |
1916 | case jObject: |
1917 | stat = caps_hierarchy(args[i].members.obj, &full); |
1918 | if (stat != CAPS_SUCCESS) { |
1919 | printf(" CAPS Warning: Journal caps_hierarchy = %d!\n", stat); |
1920 | goto jwrterr; |
1921 | } |
1922 | stat = caps_writeString(problem->jrnl, full); |
1923 | EG_free(full); |
1924 | if (stat != CAPS_SUCCESS) { |
1925 | printf(" CAPS Warning: Jrnl caps_writeString Obj = %d!\n", stat); |
1926 | goto jwrterr; |
1927 | } |
1928 | break; |
1929 | |
1930 | case jObjs: |
1931 | n = fwrite(&args[i].num, sizeof(int), 1, problem->jrnl); |
1932 | if (n != 1) goto jwrterr; |
1933 | if (args[i].num != 0) { |
1934 | for (j = 0; j < args[i].num; j++) { |
1935 | stat = caps_hierarchy(args[i].members.objs[j], &full); |
1936 | if (stat != CAPS_SUCCESS) { |
1937 | printf(" CAPS Warning: Journal caps_hierarchy = %d!\n", stat); |
1938 | goto jwrterr; |
1939 | } |
1940 | stat = caps_writeString(problem->jrnl, full); |
1941 | EG_free(full); |
1942 | if (stat != CAPS_SUCCESS) { |
1943 | printf(" CAPS Warning: Jrnl caps_writeString Obj = %d!\n", stat); |
1944 | goto jwrterr; |
1945 | } |
1946 | } |
1947 | } |
1948 | break; |
1949 | |
1950 | case jValObj: |
1951 | stat = caps_writeValue(problem->jrnl, problem->writer, |
1952 | args[i].members.obj); |
1953 | if (stat != CAPS_SUCCESS) { |
1954 | printf(" CAPS Warning: Jrnl caps_writeValue = %d!\n", stat); |
1955 | goto jwrterr; |
1956 | } |
1957 | break; |
1958 | |
1959 | case jErr: |
1960 | stat = caps_writeErrs(problem->jrnl, args[i].members.errs); |
1961 | if (stat != CAPS_SUCCESS) { |
1962 | printf(" CAPS Warning: Journal caps_writeErrs = %d!\n", stat); |
1963 | goto jwrterr; |
1964 | } |
1965 | break; |
1966 | |
1967 | case jOwn: |
1968 | stat = caps_writeOwn(problem->jrnl, problem->writer, |
1969 | args[i].members.own); |
1970 | if (stat != CAPS_SUCCESS) { |
1971 | printf(" CAPS Warning: Journal caps_Own = %d!\n", stat); |
1972 | goto jwrterr; |
1973 | } |
1974 | break; |
1975 | |
1976 | case jOwns: |
1977 | n = fwrite(&args[i].num, sizeof(int), 1, problem->jrnl); |
1978 | if (n != 1) goto jwrterr; |
1979 | if (args[i].num != 0) { |
1980 | for (j = 0; j < args[i].num; j++) { |
1981 | stat = caps_writeOwn(problem->jrnl, problem->writer, |
1982 | args[i].members.owns[j]); |
1983 | if (stat != CAPS_SUCCESS) { |
1984 | printf(" CAPS Warning: Journal caps_Owns %d = %d!\n", j, stat); |
1985 | goto jwrterr; |
1986 | } |
1987 | } |
1988 | } |
1989 | break; |
1990 | |
1991 | case jEgos: |
1992 | if (args[i].members.model == NULL) { |
1993 | j = -1; |
1994 | n = fwrite(&j, sizeof(int), 1, problem->jrnl); |
1995 | if (n != 1) goto jwrterr; |
1996 | } else { |
1997 | n = fwrite(&problem->nEGADSmdl, sizeof(int), 1, problem->jrnl); |
1998 | if (n != 1) goto jwrterr; |
1999 | #ifdef WIN32 |
2000 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\model%4.4d.egads", |
2001 | problem->root, problem->nEGADSmdl); |
2002 | #else |
2003 | snprintf(filename, PATH_MAX, "%s/capsRestart/model%4.4d.egads", |
2004 | problem->root, problem->nEGADSmdl); |
2005 | #endif |
2006 | stat = EG_saveModel(args[i].members.model, filename); |
2007 | if (stat != CAPS_SUCCESS) |
2008 | printf(" CAPS Warning: EG_saveModel = %d (caps_jrnlWrite)!\n", |
2009 | stat); |
2010 | if (args[i].members.model->oclass == MODEL) |
2011 | EG_deleteObject(args[i].members.model); |
2012 | problem->nEGADSmdl++; |
2013 | } |
2014 | } |
2015 | } |
2016 | |
2017 | n = fwrite(&sNum, sizeof(CAPSLONG), 1, problem->jrnl); |
2018 | if (n != 1) goto jwrterr; |
2019 | n = fwrite(&problem->funID, sizeof(int), 1, problem->jrnl); |
2020 | if (n != 1) goto jwrterr; |
2021 | if (status == CAPS_SUCCESS) { |
2022 | #ifdef WIN32 |
2023 | problem->jpos = _ftelli64(problem->jrnl); |
2024 | #else |
2025 | problem->jpos = ftell(problem->jrnl); |
2026 | #endif |
2027 | } |
2028 | fflush(problem->jrnl); |
2029 | |
2030 | stat = caps_writeProblem(problem->mySelf); |
2031 | if (stat != CAPS_SUCCESS) |
2032 | printf(" CAPS Warning: caps_writeProblem = %d (caps_jrnlWrite)!\n", stat); |
2033 | |
2034 | return; |
2035 | |
2036 | jwrterr: |
2037 | printf(" CAPS ERROR: Writing Journal File -- disabled (funID = %d)\n", |
2038 | problem->funID); |
2039 | fclose(problem->jrnl); |
2040 | problem->jrnl = NULL; |
2041 | } |
2042 | |
2043 | |
2044 | static void |
2045 | caps_sizeCB(void *modl, int ipmtr, int nrow, int ncol) |
2046 | { |
2047 | int index, j, k, n, status; |
2048 | double *reals, dot; |
2049 | modl_T *MODL; |
2050 | capsObject *object; |
2051 | capsValue *value; |
2052 | capsProblem *problem; |
2053 | |
2054 | MODL = (modl_T *) modl; |
2055 | problem = (capsProblem *) MODL->userdata; |
2056 | if ((problem->funID != CAPS_SETVALUE) && |
2057 | (problem->funID != CAPS_READPARAMETERS)) { |
2058 | printf(" CAPS Internal: caps_sizeCB called from funID = %d!\n", |
2059 | problem->funID); |
2060 | return; |
2061 | } |
2062 | if (problem->funID == CAPS_READPARAMETERS) return; |
2063 | |
2064 | |
2065 | for (index = 0; index < problem->nGeomIn; index++) { |
2066 | object = problem->geomIn[index]; |
2067 | if (object == NULL) continue; |
2068 | if (object->blind == NULL) continue; |
2069 | value = (capsValue *) object->blind; |
2070 | if (value->pIndex == ipmtr) break; |
2071 | } |
2072 | if (index == problem->nGeomIn) { |
2073 | printf(" CAPS Warning: cant find ocsm ipmtr = %d (caps_sizeCB)!\n", ipmtr); |
2074 | return; |
2075 | } |
2076 | object = problem->geomIn[index]; |
2077 | value = (capsValue *) object->blind; |
2078 | |
2079 | |
2080 | |
2081 | |
2082 | |
2083 | reals = NULL; |
2084 | if (nrow*ncol != 1) { |
2085 | reals = (double *) EG_alloc(nrow*ncol*sizeof(double)); |
2086 | if (reals == NULL) { |
2087 | printf(" CAPS Warning: %s resize %d %d Malloc(caps_sizeCB)\n", |
2088 | object->name, nrow, ncol); |
2089 | return; |
2090 | } |
2091 | } |
2092 | if (value->length != 1) EG_free(value->vals.reals); |
2093 | value->length = nrow*ncol; |
2094 | value->nrow = nrow; |
2095 | value->ncol = ncol; |
2096 | if (value->length != 1) value->vals.reals = reals; |
2097 | |
2098 | reals = value->vals.reals; |
2099 | if (value->length == 1) reals = &value->vals.real; |
2100 | for (n = k = 0; k < nrow; k++) |
2101 | for (j = 0; j < ncol; j++, n++) |
2102 | ocsmGetValu(problem->modl, ipmtr, k+1, j+1, &reals[n], &dot); |
2103 | |
2104 | value->dim = Scalar; |
2105 | if ((ncol > 1) && (nrow > 1)) { |
2106 | value->dim = Array2D; |
2107 | } else if ((ncol > 1) || (nrow > 1)) { |
2108 | value->dim = Vector; |
2109 | } |
2110 | |
2111 | caps_freeOwner(&object->last); |
2112 | object->last.sNum = problem->sNum; |
2113 | caps_fillDateTime(object->last.datetime); |
2114 | status = caps_writeValueObj(problem, object); |
2115 | if (status != CAPS_SUCCESS) |
2116 | printf(" CAPS Warning: caps_writeValueObj = %d\n", status); |
2117 | } |
2118 | |
2119 | |
2120 | static int |
2121 | caps_readString(FILE *fp, char **string) |
2122 | { |
2123 | int len; |
2124 | size_t n; |
2125 | |
2126 | *string = NULL; |
2127 | n = fread(&len, sizeof(int), 1, fp); |
2128 | if (n != 1) return CAPS_IOERR; |
2129 | if (len < 0) return CAPS_IOERR; |
2130 | if (len == 0) return CAPS_SUCCESS; |
2131 | |
2132 | *string = (char *) EG_alloc(len*sizeof(char)); |
2133 | if (*string == NULL) return EGADS_MALLOC; |
2134 | |
2135 | n = fread(*string, sizeof(char), len, fp); |
2136 | if (n != len) { |
2137 | EG_free(*string); |
2138 | *string = NULL; |
2139 | return CAPS_IOERR; |
2140 | } |
2141 | |
2142 | return CAPS_SUCCESS; |
2143 | } |
2144 | |
2145 | |
2146 | static int |
2147 | caps_readStrings(FILE *fp, int len, char **string) |
2148 | { |
2149 | int slen; |
2150 | size_t n; |
2151 | |
2152 | *string = NULL; |
2153 | n = fread(&slen, sizeof(int), 1, fp); |
2154 | if (n != 1) return CAPS_IOERR; |
2155 | if (len < 0) return CAPS_IOERR; |
2156 | if (len == 0) return CAPS_SUCCESS; |
2157 | |
2158 | *string = (char *) EG_alloc(slen*sizeof(char)); |
2159 | if (*string == NULL) return EGADS_MALLOC; |
2160 | |
2161 | n = fread(*string, sizeof(char), slen, fp); |
2162 | if (n != slen) { |
2163 | EG_free(*string); |
2164 | *string = NULL; |
2165 | return CAPS_IOERR; |
2166 | } |
2167 | |
2168 | return CAPS_SUCCESS; |
2169 | } |
2170 | |
2171 | |
2172 | static int |
2173 | caps_readDoubles(FILE *fp, int *len, double **reals) |
2174 | { |
2175 | size_t n; |
2176 | |
2177 | *reals = NULL; |
2178 | n = fread(len, sizeof(int), 1, fp); |
2179 | if (n != 1) return CAPS_IOERR; |
2180 | if (*len < 0) return CAPS_IOERR; |
2181 | if (*len == 0) return CAPS_SUCCESS; |
2182 | |
2183 | *reals = (double *) EG_alloc(*len*sizeof(double)); |
2184 | if (*reals == NULL) return EGADS_MALLOC; |
2185 | |
2186 | n = fread(*reals, sizeof(double), *len, fp); |
2187 | if (n != *len) { |
2188 | EG_free(*reals); |
2189 | *reals = NULL; |
2190 | return CAPS_IOERR; |
2191 | } |
2192 | |
2193 | return CAPS_SUCCESS; |
2194 | } |
2195 | |
2196 | |
2197 | static int |
2198 | caps_readTuple(FILE *fp, int len, enum capsNull nullVal, capsTuple **tuple) |
2199 | { |
2200 | int i, stat; |
2201 | capsTuple *tmp; |
2202 | |
2203 | *tuple = NULL; |
2204 | if (nullVal == IsNull) return CAPS_SUCCESS; |
2205 | stat = caps_makeTuple(len, &tmp); |
2206 | if (stat != CAPS_SUCCESS) return stat; |
2207 | |
2208 | for (i = 0; i < len; i++) { |
2209 | stat = caps_readString(fp, &tmp[i].name); |
2210 | if (stat != CAPS_SUCCESS) { |
2211 | caps_freeTuple(len, tmp); |
2212 | return stat; |
2213 | } |
2214 | stat = caps_readString(fp, &tmp[i].value); |
2215 | if (stat != CAPS_SUCCESS) { |
2216 | caps_freeTuple(len, tmp); |
2217 | return stat; |
2218 | } |
2219 | } |
2220 | *tuple = tmp; |
2221 | |
2222 | return CAPS_SUCCESS; |
2223 | } |
2224 | |
2225 | |
2226 | static int |
2227 | caps_readOwn(FILE *fp, capsOwn *own) |
2228 | { |
2229 | int i, stat; |
2230 | size_t n; |
2231 | |
2232 | own->nLines = 0; |
2233 | own->lines = NULL; |
2234 | own->pname = NULL; |
2235 | own->pID = NULL; |
2236 | own->user = NULL; |
2237 | |
2238 | n = fread(&own->nLines, sizeof(int), 1, fp); |
2239 | if (n != 1) { |
2240 | caps_freeOwner(own); |
2241 | return CAPS_IOERR; |
2242 | } |
2243 | if (own->nLines != 0) { |
2244 | own->lines = (char **) EG_alloc(own->nLines*sizeof(char *)); |
2245 | if (own->lines == NULL) { |
2246 | own->nLines = 0; |
2247 | caps_freeOwner(own); |
2248 | return EGADS_MALLOC; |
2249 | } |
2250 | for (i = 0; i < own->nLines; i++) { |
2251 | stat = caps_readString(fp, &own->lines[i]); |
2252 | if (stat != CAPS_SUCCESS) return stat; |
2253 | } |
2254 | } |
2255 | |
2256 | stat = caps_readString(fp, &own->pname); |
2257 | if (stat != CAPS_SUCCESS) return stat; |
2258 | stat = caps_readString(fp, &own->pID); |
2259 | if (stat != CAPS_SUCCESS) { |
2260 | caps_freeOwner(own); |
2261 | return stat; |
2262 | } |
2263 | stat = caps_readString(fp, &own->user); |
2264 | if (stat != CAPS_SUCCESS) { |
2265 | caps_freeOwner(own); |
2266 | return stat; |
2267 | } |
2268 | |
2269 | n = fread(own->datetime, sizeof(short), 6, fp); |
2270 | if (n != 6) { |
2271 | caps_freeOwner(own); |
2272 | return CAPS_IOERR; |
2273 | } |
2274 | |
2275 | n = fread(&own->sNum, sizeof(CAPSLONG), 1, fp); |
2276 | if (n != 1) { |
2277 | caps_freeOwner(own); |
2278 | return CAPS_IOERR; |
2279 | } |
2280 | |
2281 | return CAPS_SUCCESS; |
2282 | } |
2283 | |
2284 | |
2285 | static int |
2286 | caps_readHistory(FILE *fp, capsObject *obj) |
2287 | { |
2288 | int i, j, stat; |
2289 | size_t n; |
2290 | |
2291 | n = fread(&obj->nHistory, sizeof(int), 1, fp); |
2292 | if (n != 1) return CAPS_IOERR; |
2293 | if (obj->nHistory == 0) return CAPS_SUCCESS; |
2294 | |
2295 | obj->history = (capsOwn *) EG_alloc(obj->nHistory*sizeof(capsOwn)); |
2296 | if (obj->history == NULL) { |
2297 | obj->nHistory = 0; |
2298 | return EGADS_MALLOC; |
2299 | } |
2300 | |
2301 | for (j = 0; j < obj->nHistory; j++) { |
2302 | obj->history[j].nLines = 0; |
2303 | obj->history[j].lines = NULL; |
2304 | obj->history[j].pname = NULL; |
2305 | obj->history[j].pID = NULL; |
2306 | obj->history[j].user = NULL; |
2307 | } |
2308 | |
2309 | for (j = 0; j < obj->nHistory; j++) { |
2310 | n = fread(&obj->history[j].nLines, sizeof(int), 1, fp); |
2311 | if (n != 1) return CAPS_IOERR; |
2312 | if (obj->history[j].nLines != 0) { |
2313 | obj->history[j].lines = (char **) |
2314 | EG_alloc(obj->history[j].nLines*sizeof(char *)); |
2315 | if (obj->history[j].lines == NULL) { |
2316 | obj->history[j].nLines = 0; |
2317 | return EGADS_MALLOC; |
2318 | } |
2319 | for (i = 0; i < obj->history[j].nLines; i++) { |
2320 | stat = caps_readString(fp, &obj->history[j].lines[i]); |
2321 | if (stat != CAPS_SUCCESS) return stat; |
2322 | } |
2323 | } |
2324 | |
2325 | stat = caps_readString(fp, &obj->history[j].pname); |
2326 | if (stat != CAPS_SUCCESS) return stat; |
2327 | stat = caps_readString(fp, &obj->history[j].pID); |
2328 | if (stat != CAPS_SUCCESS) return stat; |
2329 | stat = caps_readString(fp, &obj->history[j].user); |
2330 | if (stat != CAPS_SUCCESS) return stat; |
2331 | |
2332 | n = fread(obj->history[j].datetime, sizeof(short), 6, fp); |
2333 | if (n != 6) return CAPS_IOERR; |
2334 | |
2335 | n = fread(&obj->history[j].sNum, sizeof(CAPSLONG), 1, fp); |
2336 | if (n != 1) return CAPS_IOERR; |
2337 | } |
2338 | |
2339 | return CAPS_SUCCESS; |
2340 | } |
2341 | |
2342 | |
2343 | static int |
2344 | caps_readAttrs(FILE *fp, egAttrs **attrx) |
2345 | { |
2346 | int nattr, i, stat; |
2347 | size_t n; |
2348 | egAttr *attr; |
2349 | egAttrs *attrs; |
2350 | |
2351 | *attrx = NULL; |
2352 | n = fread(&nattr, sizeof(int), 1, fp); |
2353 | if (n != 1) return CAPS_IOERR; |
2354 | if (nattr == 0) return CAPS_SUCCESS; |
2355 | |
2356 | attrs = (egAttrs *) EG_alloc(sizeof(egAttrs)); |
2357 | if (attrs == NULL) return EGADS_MALLOC; |
2358 | attr = (egAttr *) EG_alloc(nattr*sizeof(egAttr)); |
2359 | if (attr == NULL) { |
2360 | EG_free(attrs); |
2361 | return EGADS_MALLOC; |
2362 | } |
2363 | attrs->nattrs = nattr; |
2364 | attrs->attrs = attr; |
2365 | attrs->nseqs = 0; |
2366 | attrs->seqs = NULL; |
2367 | for (i = 0; i < nattr; i++) { |
2368 | attr[i].name = NULL; |
2369 | attr[i].length = 1; |
2370 | attr[i].type = ATTRINT; |
2371 | } |
2372 | |
2373 | |
2374 | for (i = 0; i < nattr; i++) { |
2375 | n = fread(&attr[i].type, sizeof(int), 1, fp); |
2376 | if (n != 1) { |
2377 | caps_freeAttrs(&attrs); |
2378 | return CAPS_IOERR; |
2379 | } |
2380 | n = fread(&attr[i].length, sizeof(int), 1, fp); |
2381 | if (n != 1) { |
2382 | caps_freeAttrs(&attrs); |
2383 | return CAPS_IOERR; |
2384 | } |
2385 | stat = caps_readString(fp, &attr[i].name); |
2386 | if (stat != CAPS_SUCCESS) { |
2387 | caps_freeAttrs(&attrs); |
2388 | return CAPS_IOERR; |
2389 | } |
2390 | if (attr[i].type == ATTRINT) { |
2391 | n = attr[i].length; |
2392 | if (attr[i].length == 1) { |
2393 | n = fread(&attr[i].vals.integer, sizeof(int), 1, fp); |
2394 | } else if (attr[i].length > 1) { |
2395 | attr[i].vals.integers = (int *) EG_alloc(attr[i].length*sizeof(int)); |
2396 | if (attr[i].vals.integers == NULL) { |
2397 | caps_freeAttrs(&attrs); |
2398 | return EGADS_MALLOC; |
2399 | } |
2400 | n = fread(attr[i].vals.integers, sizeof(int), attr[i].length, fp); |
2401 | } |
2402 | if (n != attr[i].length) { |
2403 | caps_freeAttrs(&attrs); |
2404 | return CAPS_IOERR; |
2405 | } |
2406 | } else if (attr[i].type == ATTRREAL) { |
2407 | n = attr[i].length; |
2408 | if (attr[i].length == 1) { |
2409 | n = fread(&attr[i].vals.real, sizeof(double), 1, fp); |
2410 | } else if (attr[i].length > 1) { |
2411 | attr[i].vals.reals = (double *) EG_alloc(attr[i].length*sizeof(double)); |
2412 | if (attr[i].vals.reals == NULL) { |
2413 | caps_freeAttrs(&attrs); |
2414 | return EGADS_MALLOC; |
2415 | } |
2416 | n = fread(attr[i].vals.reals, sizeof(double), attr[i].length, fp); |
2417 | } |
2418 | if (n != attr[i].length) return CAPS_IOERR; |
2419 | } else { |
2420 | stat = caps_readStrings(fp, attr[i].length, &attr[i].vals.string); |
2421 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
2422 | } |
2423 | } |
2424 | |
2425 | |
2426 | *attrx = attrs; |
2427 | return CAPS_SUCCESS; |
2428 | } |
2429 | |
2430 | |
2431 | static int |
2432 | caps_readValue(FILE *fp, capsProblem *problem, capsObject *obj) |
2433 | { |
2434 | int i, stat; |
2435 | char *name; |
2436 | size_t n; |
2437 | capsValue *value; |
2438 | |
2439 | value = (capsValue *) obj->blind; |
2440 | |
2441 | stat = caps_readHistory(fp, obj); |
2442 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
2443 | stat = caps_readOwn(fp, &obj->last); |
2444 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
2445 | stat = caps_readAttrs(fp, &obj->attrs); |
2446 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
2447 | stat = caps_readString(fp, &obj->name); |
2448 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
2449 | stat = caps_readString(fp, &name); |
2450 | EG_free(name); |
2451 | if (stat != CAPS_SUCCESS) return CAPS_IOERR; |
2452 | |
2453 | n = fread(&value->type, sizeof(int), 1, fp); |
2454 | if (n != 1) return CAPS_IOERR; |
2455 | n = fread(&value->length, sizeof(int), 1, fp); |
2456 | if (n != 1) return CAPS_IOERR; |
2457 | n = fread(&value->dim, sizeof(int), 1, fp); |
2458 | if (n != 1) return CAPS_IOERR; |
2459 | n = fread(&value->nrow, sizeof(int), 1, fp); |
2460 | if (n != 1) return CAPS_IOERR; |
2461 | n = fread(&value->ncol, sizeof(int), 1, fp); |
2462 | if (n != 1) return CAPS_IOERR; |
2463 | n = fread(&value->lfixed, sizeof(int), 1, fp); |
2464 | if (n != 1) return CAPS_IOERR; |
2465 | n = fread(&value->sfixed, sizeof(int), 1, fp); |
2466 | if (n != 1) return CAPS_IOERR; |
2467 | n = fread(&value->nullVal, sizeof(int), 1, fp); |
2468 | if (n != 1) return CAPS_IOERR; |
2469 | n = fread(&value->index, sizeof(int), 1, fp); |
2470 | if (n != 1) return CAPS_IOERR; |
2471 | n = fread(&value->pIndex, sizeof(int), 1, fp); |
2472 | if (n != 1) return CAPS_IOERR; |
2473 | n = fread(&value->gInType, sizeof(int), 1, fp); |
2474 | if (n != 1) return CAPS_IOERR; |
2475 | n = fread(&value->nderiv, sizeof(int), 1, fp); |
2476 | if (n != 1) return CAPS_IOERR; |
2477 | |
2478 | if (value->type == Integer) { |
2479 | n = fread(value->limits.ilims, sizeof(int), 2, fp); |
2480 | if (n != 2) return CAPS_IOERR; |
2481 | } else if ((value->type == Double) || (value->type == DoubleDeriv)) { |
2482 | n = fread(value->limits.dlims, sizeof(double), 2, fp); |
2483 | if (n != 2) return CAPS_IOERR; |
2484 | } |
2485 | |
2486 | stat = caps_readString(fp, &value->units); |
2487 | if (stat != CAPS_SUCCESS) return stat; |
2488 | stat = caps_readString(fp, &value->meshWriter); |
2489 | if (stat != CAPS_SUCCESS) return stat; |
2490 | stat = caps_readString(fp, &name); |
2491 | if (stat != CAPS_SUCCESS) return stat; |
2492 | stat = caps_string2obj(problem, name, &value->link); |
2493 | EG_free(name); |
2494 | if (stat != CAPS_SUCCESS) return stat; |
2495 | n = fread(&value->linkMethod, sizeof(int), 1, fp); |
2496 | if (n != 1) return CAPS_IOERR; |
2497 | |
2498 | if ((value->length == 1) && (value->type != String) && |
2499 | (value->type != Pointer) && (value->type != Tuple) && |
2500 | (value->type != PointerMesh)) { |
2501 | if ((value->type == Double) || (value->type == DoubleDeriv)) { |
2502 | n = fread(&value->vals.real, sizeof(double), 1, fp); |
2503 | if (n != 1) return CAPS_IOERR; |
2504 | } else { |
2505 | n = fread(&value->vals.integer, sizeof(int), 1, fp); |
2506 | if (n != 1) return CAPS_IOERR; |
2507 | } |
2508 | } else { |
2509 | if ((value->type == Pointer) || (value->type == PointerMesh)) { |
2510 | |
2511 | } else if ((value->type == Double) || (value->type == DoubleDeriv)) { |
2512 | value->vals.reals = EG_alloc(value->length*sizeof(double)); |
2513 | if (value->vals.reals == NULL) return EGADS_MALLOC; |
2514 | n = fread(value->vals.reals, sizeof(double), value->length, fp); |
2515 | if (n != value->length) return CAPS_IOERR; |
2516 | } else if (value->type == String) { |
2517 | stat = caps_readStrings(fp, value->length, &value->vals.string); |
2518 | if (stat != CAPS_SUCCESS) return stat; |
2519 | } else if (value->type == Tuple) { |
2520 | value->vals.tuple = NULL; |
2521 | if (value->length != 0) { |
2522 | stat = caps_readTuple(fp, value->length, value->nullVal, |
2523 | &value->vals.tuple); |
2524 | if (stat != CAPS_SUCCESS) return stat; |
2525 | } |
2526 | } else { |
2527 | value->vals.integers = EG_alloc(value->length*sizeof(int)); |
2528 | if (value->vals.integers == NULL) return EGADS_MALLOC; |
2529 | n = fread(value->vals.integers, sizeof(int), value->length, fp); |
2530 | if (n != value->length) return CAPS_IOERR; |
2531 | } |
2532 | } |
2533 | |
2534 | if (value->nullVal == IsPartial) { |
2535 | value->partial = EG_alloc(value->length*sizeof(int)); |
2536 | if (value->partial == NULL) return EGADS_MALLOC; |
2537 | n = fread(value->partial, sizeof(int), value->length, fp); |
2538 | if (n != value->length) return CAPS_IOERR; |
2539 | } |
2540 | |
2541 | if (value->nderiv != 0) { |
2542 | value->derivs = (capsDeriv *) EG_alloc(value->nderiv*sizeof(capsDeriv)); |
2543 | if (value->derivs == NULL) return EGADS_MALLOC; |
2544 | for (i = 0; i < value->nderiv; i++) { |
2545 | value->derivs[i].name = NULL; |
2546 | value->derivs[i].len_wrt = 0; |
2547 | value->derivs[i].deriv = NULL; |
2548 | } |
2549 | for (i = 0; i < value->nderiv; i++) { |
2550 | stat = caps_readString(fp, &value->derivs[i].name); |
2551 | if (stat != CAPS_SUCCESS) return stat; |
2552 | n = fread(&value->derivs[i].len_wrt, sizeof(int), 1, fp); |
2553 | if (n != 1) return CAPS_IOERR; |
2554 | value->derivs[i].deriv = (double *) EG_alloc( |
2555 | value->length*value->derivs[i].len_wrt*sizeof(double)); |
2556 | if (value->derivs[i].deriv == NULL) return EGADS_MALLOC; |
2557 | n = fread(value->derivs[i].deriv, sizeof(double), |
2558 | value->length*value->derivs[i].len_wrt, fp); |
2559 | if (n != value->length*value->derivs[i].len_wrt) return CAPS_IOERR; |
2560 | } |
2561 | } |
2562 | |
2563 | return CAPS_SUCCESS; |
2564 | } |
2565 | |
2566 | |
2567 | static int |
2568 | caps_readErrs(capsProblem *problem, capsErrs **errx) |
2569 | { |
2570 | int i, j, nError, stat; |
2571 | char *full; |
2572 | capsErrs *errs; |
2573 | size_t n; |
2574 | FILE *fp; |
2575 | |
2576 | *errx = NULL; |
2577 | fp = problem->jrnl; |
2578 | n = fread(&nError, sizeof(int), 1, fp); |
2579 | if (n != 1) return CAPS_IOERR; |
2580 | if (nError == 0) return CAPS_SUCCESS; |
2581 | |
2582 | errs = (capsErrs *) EG_alloc(sizeof(capsErrs)); |
2583 | if (errs == NULL) return EGADS_MALLOC; |
2584 | errs->nError = nError; |
2585 | errs->errors = (capsError *) EG_alloc(nError*sizeof(capsError)); |
2586 | if (errs->errors == NULL) { |
2587 | EG_free(errs); |
2588 | return EGADS_MALLOC; |
2589 | } |
2590 | for (i = 0; i < nError; i++) { |
2591 | errs->errors[i].nLines = 0; |
2592 | errs->errors[i].lines = NULL; |
2593 | } |
2594 | |
2595 | for (i = 0; i < nError; i++) { |
2596 | stat = caps_readString(fp, &full); |
2597 | if (stat != CAPS_SUCCESS) { |
2598 | printf(" CAPS Warning: caps_readString = %d (caps_readErrs)\n", stat); |
2599 | caps_freeError(errs); |
2600 | return CAPS_IOERR; |
2601 | } |
2602 | stat = caps_string2obj(problem, full, &errs->errors[i].errObj); |
2603 | EG_free(full); |
2604 | if (stat != CAPS_SUCCESS) |
2605 | printf(" CAPS Warning: caps_string2obj = %d (caps_readErrs)\n", stat); |
2606 | |
2607 | n = fread(&errs->errors[i].eType, sizeof(int), 1, fp); |
2608 | if (n != 1) goto readErr; |
2609 | n = fread(&errs->errors[i].index, sizeof(int), 1, fp); |
2610 | if (n != 1) goto readErr; |
2611 | n = fread(&errs->errors[i].nLines, sizeof(int), 1, fp); |
2612 | if (n != 1) goto readErr; |
2613 | errs->errors[i].lines = (char **) EG_alloc(errs->errors[i].nLines* |
2614 | sizeof(char *)); |
2615 | if (errs->errors[i].lines == NULL) { |
2616 | caps_freeError(errs); |
2617 | return EGADS_MALLOC; |
2618 | } |
2619 | for (j = 0; j < errs->errors[i].nLines; j++) { |
2620 | stat = caps_readString(fp, &errs->errors[i].lines[j]); |
2621 | if (stat != CAPS_SUCCESS) { |
2622 | printf(" CAPS Warning: %d caps_readString = %d (caps_readErrs)\n", |
2623 | j, stat); |
2624 | goto readErr; |
2625 | } |
2626 | } |
2627 | } |
2628 | |
2629 | *errx = errs; |
2630 | return CAPS_SUCCESS; |
2631 | |
2632 | readErr: |
2633 | |
2634 | caps_freeError(errs); |
2635 | |
2636 | return CAPS_IOERR; |
2637 | } |
2638 | |
2639 | |
2640 | int |
2641 | caps_jrnlRead(capsProblem *problem, capsObject *obj, int nargs, capsJrnl *args, |
2642 | CAPSLONG *serial, int *status) |
2643 | { |
2644 | int i, j, k, stat, funID; |
2645 | char filename[PATH_MAX], *full; |
2646 | CAPSLONG sNum0, sNum, objSN; |
2647 | capsFList *flist; |
2648 | size_t n; |
2649 | #ifdef WIN32 |
2650 | __int64 fpos; |
2651 | #else |
2652 | long fpos; |
2653 | #endif |
2654 | |
2655 | *serial = 0; |
2656 | *status = CAPS_SUCCESS; |
2657 | if (problem->jrnl == NULL) return CAPS_SUCCESS; |
2658 | if (problem->stFlag == CAPS_JOURNALERR) return CAPS_JOURNALERR; |
2659 | if (problem->stFlag != 4) return CAPS_SUCCESS; |
2660 | |
2661 | #ifdef WIN32 |
2662 | fpos = _ftelli64(problem->jrnl); |
2663 | #else |
2664 | fpos = ftell(problem->jrnl); |
2665 | #endif |
2666 | |
2667 | |
2668 | if (fpos >= problem->jpos) { |
2669 | printf(" CAPS Info: Hit last success -- going live!\n"); |
2670 | problem->stFlag = 0; |
2671 | fclose(problem->jrnl); |
2672 | #ifdef WIN32 |
2673 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\capsJournal", problem->root); |
2674 | #else |
2675 | snprintf(filename, PATH_MAX, "%s/capsRestart/capsJournal", problem->root); |
2676 | #endif |
2677 | |
2678 | problem->jrnl = fopen(filename, "ab"); |
2679 | |
2680 | if (problem->jrnl == NULL) { |
2681 | printf(" CAPS Error: Cannot open %s (caps_readJrnl)\n", filename); |
2682 | return CAPS_DIRERR; |
2683 | } |
2684 | #ifdef WIN32 |
2685 | _fseeki64(problem->jrnl, problem->jpos, SEEK_SET); |
2686 | #else |
2687 | fseek(problem->jrnl, problem->jpos, SEEK_SET); |
2688 | #endif |
2689 | return CAPS_SUCCESS; |
2690 | } |
2691 | |
2692 | |
2693 | n = fread(&funID, sizeof(int), 1, problem->jrnl); |
2694 | if (n != 1) goto jreaderr; |
2695 | if (funID != problem->funID) { |
2696 | printf(" CAPS Fatal: FunID = %s, should be '%s'!\n", caps_funID[funID], caps_funID[problem->funID]); |
2697 | goto jreadfatal; |
2698 | } |
2699 | n = fread(&sNum0, sizeof(CAPSLONG), 1, problem->jrnl); |
2700 | if (n != 1) goto jreaderr; |
2701 | n = fread(status, sizeof(int), 1, problem->jrnl); |
2702 | if (n != 1) goto jreaderr; |
2703 | |
2704 | |
2705 | |
2706 | if (*status == CAPS_SUCCESS) { |
2707 | n = fread(&objSN, sizeof(CAPSLONG), 1, problem->jrnl); |
2708 | if (n != 1) goto jreaderr; |
2709 | |
2710 | if (obj != NULL) |
2711 | if (obj->flist != NULL) { |
2712 | flist = (capsFList *) obj->flist; |
2713 | if (objSN > flist->sNum) caps_freeFList(obj); |
2714 | } |
2715 | |
2716 | for (i = 0; i < nargs; i++) |
2717 | switch (args[i].type) { |
2718 | |
2719 | case jInteger: |
2720 | n = fread(&args[i].members.integer, sizeof(int), 1, problem->jrnl); |
2721 | if (n != 1) goto jreaderr; |
2722 | break; |
2723 | |
2724 | case jDouble: |
2725 | n = fread(&args[i].members.real, sizeof(double), 1, problem->jrnl); |
2726 | if (n != 1) goto jreaderr; |
2727 | break; |
2728 | |
2729 | case jString: |
2730 | stat = caps_readString(problem->jrnl, &args[i].members.string); |
2731 | if (stat == CAPS_IOERR) goto jreaderr; |
2732 | if (stat != CAPS_SUCCESS) { |
2733 | printf(" CAPS Warning: Journal caps_readString = %d!\n", stat); |
2734 | goto jreadfatal; |
2735 | } |
2736 | if (obj != NULL) { |
2737 | flist = (capsFList *) EG_alloc(sizeof(capsFList)); |
2738 | if (flist == NULL) { |
2739 | printf(" CAPS Warning: Cannot Allocate Journal Free List!\n"); |
2740 | } else { |
2741 | flist->type = jPointer; |
2742 | flist->num = 1; |
2743 | flist->member.pointer = args[i].members.string; |
2744 | flist->sNum = objSN; |
2745 | flist->next = NULL; |
2746 | if (obj->flist != NULL) flist->next = obj->flist; |
2747 | obj->flist = flist; |
2748 | } |
2749 | } |
2750 | break; |
2751 | |
2752 | case jStrings: |
2753 | n = fread(&args[i].num, sizeof(int), 1, problem->jrnl); |
2754 | if (n != 1) goto jreaderr; |
2755 | args[i].members.strings = (char **) EG_alloc(args[i].num* |
2756 | sizeof(char *)); |
2757 | if (args[i].members.strings == NULL) { |
2758 | printf(" CAPS Warning: Journal strings Malloc Error!\n"); |
2759 | goto jreadfatal; |
2760 | } |
2761 | for (j = 0; j < args[i].num; j++) { |
2762 | stat = caps_readString(problem->jrnl, &args[i].members.strings[j]); |
2763 | if (stat != CAPS_SUCCESS) { |
2764 | printf(" CAPS Warning: Jrnl %d caps_readString Str = %d!\n", |
2765 | j, stat); |
2766 | for (k = 0; k < j; k++) EG_free(args[i].members.strings[k]); |
2767 | EG_free(args[i].members.strings); |
2768 | args[i].members.strings = NULL; |
2769 | goto jreaderr; |
2770 | } |
2771 | } |
2772 | if (obj != NULL) { |
2773 | flist = (capsFList *) EG_alloc(sizeof(capsFList)); |
2774 | if (flist == NULL) { |
2775 | printf(" CAPS Warning: Cannot Allocate Journal Free List!\n"); |
2776 | } else { |
2777 | flist->type = jStrings; |
2778 | flist->num = args[i].num; |
2779 | flist->member.strings = args[i].members.strings; |
2780 | flist->sNum = objSN; |
2781 | flist->next = NULL; |
2782 | if (obj->flist != NULL) flist->next = obj->flist; |
2783 | obj->flist = flist; |
2784 | } |
2785 | } |
2786 | break; |
2787 | |
2788 | case jTuple: |
2789 | n = fread(&args[i].num, sizeof(int), 1, problem->jrnl); |
2790 | if (n != 1) goto jreaderr; |
2791 | stat = caps_readTuple(problem->jrnl, args[i].num, NotNull, |
2792 | &args[i].members.tuple); |
2793 | if (stat != CAPS_SUCCESS) { |
2794 | printf(" CAPS Warning: Journal caps_readTuple = %d!\n", stat); |
2795 | goto jreaderr; |
2796 | } |
2797 | if (obj != NULL) { |
2798 | flist = (capsFList *) EG_alloc(sizeof(capsFList)); |
2799 | if (flist == NULL) { |
2800 | printf(" CAPS Warning: Cannot Allocate Journal Free List!\n"); |
2801 | } else { |
2802 | flist->type = jTuple; |
2803 | flist->num = args[i].num; |
2804 | flist->member.tuple = args[i].members.tuple; |
2805 | flist->sNum = objSN; |
2806 | flist->next = NULL; |
2807 | if (obj->flist != NULL) flist->next = obj->flist; |
2808 | obj->flist = flist; |
2809 | } |
2810 | } |
2811 | break; |
2812 | |
2813 | case jPointer: |
2814 | case jPtrFree: |
2815 | n = fread(&args[i].length, sizeof(size_t), 1, problem->jrnl); |
2816 | if (n != 1) goto jreaderr; |
2817 | args[i].members.pointer = NULL; |
2818 | if (args[i].length != 0) { |
2819 | args[i].members.pointer = (char *) EG_alloc(args[i].length* |
2820 | sizeof(char)); |
2821 | if (args[i].members.pointer == NULL) { |
2822 | printf(" CAPS Warning: Journal Pointer Malloc Error!\n"); |
2823 | goto jreadfatal; |
2824 | } |
2825 | n = fread(args[i].members.pointer, sizeof(char), args[i].length, |
2826 | problem->jrnl); |
2827 | if (n != args[i].length) { |
2828 | EG_free(args[i].members.pointer); |
2829 | args[i].members.pointer = NULL; |
2830 | goto jreaderr; |
2831 | } |
2832 | if ((obj != NULL) && (args[i].type == jPointer)) { |
2833 | flist = (capsFList *) EG_alloc(sizeof(capsFList)); |
2834 | if (flist == NULL) { |
2835 | printf(" CAPS Warning: Cannot Allocate Journal Free List!\n"); |
2836 | } else { |
2837 | flist->type = jPointer; |
2838 | flist->num = 1; |
2839 | flist->member.pointer = args[i].members.pointer; |
2840 | flist->sNum = objSN; |
2841 | flist->next = NULL; |
2842 | if (obj->flist != NULL) flist->next = obj->flist; |
2843 | obj->flist = flist; |
2844 | } |
2845 | } |
2846 | } |
2847 | break; |
2848 | |
2849 | case jObject: |
2850 | stat = caps_readString(problem->jrnl, &full); |
2851 | if (stat != CAPS_SUCCESS) { |
2852 | printf(" CAPS Warning: Jrnl caps_readString Obj = %d!\n", stat); |
2853 | goto jreaderr; |
2854 | } |
2855 | stat = caps_string2obj(problem, full, &args[i].members.obj); |
2856 | EG_free(full); |
2857 | if (stat != CAPS_SUCCESS) { |
2858 | printf(" CAPS Warning: Journal caps_string2obj = %d!\n", stat); |
2859 | goto jreaderr; |
2860 | } |
2861 | break; |
2862 | |
2863 | case jObjs: |
2864 | n = fread(&args[i].num, sizeof(int), 1, problem->jrnl); |
2865 | if (n != 1) goto jreaderr; |
2866 | if (args[i].num != 0) { |
2867 | args[i].members.objs = (capsObject **) EG_alloc(args[i].num* |
2868 | sizeof(capsObject *)); |
2869 | if (args[i].members.objs == NULL) { |
2870 | printf(" CAPS Warning: Journal Objects Malloc Error!\n"); |
2871 | goto jreadfatal; |
2872 | } |
2873 | for (j = 0; j < args[i].num; j++) { |
2874 | stat = caps_readString(problem->jrnl, &full); |
2875 | if (stat != CAPS_SUCCESS) { |
2876 | printf(" CAPS Warning: Jrnl caps_readString Obj = %d!\n", stat); |
2877 | EG_free(args[i].members.objs); |
2878 | args[i].members.objs = NULL; |
2879 | goto jreaderr; |
2880 | } |
2881 | stat = caps_string2obj(problem, full, &args[i].members.objs[j]); |
2882 | EG_free(full); |
2883 | if (stat != CAPS_SUCCESS) { |
2884 | printf(" CAPS Warning: Journal caps_string2obj = %d!\n", stat); |
2885 | EG_free(args[i].members.objs); |
2886 | args[i].members.objs = NULL; |
2887 | goto jreaderr; |
2888 | } |
2889 | } |
2890 | if (obj != NULL) { |
2891 | flist = (capsFList *) EG_alloc(sizeof(capsFList)); |
2892 | if (flist == NULL) { |
2893 | printf(" CAPS Warning: Cannot Allocate Journal Free List!\n"); |
2894 | } else { |
2895 | flist->type = jPointer; |
2896 | flist->num = 1; |
2897 | flist->member.pointer = args[i].members.objs; |
2898 | flist->sNum = objSN; |
2899 | flist->next = NULL; |
2900 | if (obj->flist != NULL) flist->next = obj->flist; |
2901 | obj->flist = flist; |
2902 | } |
2903 | } |
2904 | } |
2905 | break; |
2906 | |
2907 | case jValObj: |
2908 | stat = caps_readValue(problem->jrnl, problem, args[i].members.obj); |
2909 | if (stat != CAPS_SUCCESS) { |
2910 | printf(" CAPS Warning: Jrnl caps_readValue = %d!\n", stat); |
2911 | caps_delete(args[i].members.obj); |
2912 | goto jreaderr; |
2913 | } |
2914 | break; |
2915 | |
2916 | case jErr: |
2917 | stat = caps_readErrs(problem, &args[i].members.errs); |
2918 | if (stat != CAPS_SUCCESS) { |
2919 | printf(" CAPS Warning: Journal caps_readErrs = %d!\n", stat); |
2920 | goto jreaderr; |
2921 | } |
2922 | break; |
2923 | |
2924 | case jOwn: |
2925 | stat = caps_readOwn(problem->jrnl, &args[i].members.own); |
2926 | if (stat != CAPS_SUCCESS) { |
2927 | printf(" CAPS Warning: Journal caps_Own = %d!\n", stat); |
2928 | goto jreaderr; |
2929 | } |
2930 | if (obj != NULL) { |
2931 | flist = (capsFList *) EG_alloc(sizeof(capsFList)); |
2932 | if (flist == NULL) { |
2933 | printf(" CAPS Warning: Cannot Allocate Journal Free List!\n"); |
2934 | } else { |
2935 | flist->type = jOwn; |
2936 | flist->member.own = args[i].members.own; |
2937 | flist->sNum = objSN; |
2938 | flist->next = NULL; |
2939 | if (obj->flist != NULL) flist->next = obj->flist; |
2940 | obj->flist = flist; |
2941 | } |
2942 | } |
2943 | break; |
2944 | |
2945 | case jOwns: |
2946 | n = fread(&args[i].num, sizeof(int), 1, problem->jrnl); |
2947 | if (n != 1) goto jreaderr; |
2948 | if (args[i].num != 0) { |
2949 | args[i].members.owns = (capsOwn *) EG_alloc(args[i].num* |
2950 | sizeof(capsOwn)); |
2951 | if (args[i].members.owns == NULL) { |
2952 | printf(" CAPS Warning: Journal Owner Malloc Error!\n"); |
2953 | goto jreadfatal; |
2954 | } |
2955 | for (j = 0; j < args[i].num; j++) { |
2956 | stat = caps_readOwn(problem->jrnl, &args[i].members.owns[j]); |
2957 | if (stat != CAPS_SUCCESS) { |
2958 | printf(" CAPS Warning: Journal caps_Owns %d = %d!\n", j, stat); |
2959 | EG_free(args[i].members.owns); |
2960 | args[i].members.owns = NULL; |
2961 | goto jreaderr; |
2962 | } |
2963 | } |
2964 | if (obj != NULL) { |
2965 | flist = (capsFList *) EG_alloc(sizeof(capsFList)); |
2966 | if (flist == NULL) { |
2967 | printf(" CAPS Warning: Cannot Allocate Journal Free List!\n"); |
2968 | } else { |
2969 | flist->type = jOwns; |
2970 | flist->num = args[i].num; |
2971 | flist->member.owns = args[i].members.owns; |
2972 | flist->sNum = objSN; |
2973 | flist->next = NULL; |
2974 | if (obj->flist != NULL) flist->next = obj->flist; |
2975 | obj->flist = flist; |
2976 | } |
2977 | } |
2978 | } |
2979 | break; |
2980 | |
2981 | case jEgos: |
2982 | args[i].members.model = NULL; |
2983 | n = fread(&args[i].num, sizeof(int), 1, problem->jrnl); |
2984 | if (n != 1) goto jreaderr; |
2985 | if (args[i].num != -1) { |
2986 | #ifdef WIN32 |
2987 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\model%4.4d.egads", |
2988 | problem->root, args[i].num); |
2989 | #else |
2990 | snprintf(filename, PATH_MAX, "%s/capsRestart/model%4.4d.egads", |
2991 | problem->root, args[i].num); |
2992 | #endif |
2993 | stat = EG_loadModel(problem->context, 1, filename, |
2994 | &args[i].members.model); |
2995 | if (stat != CAPS_SUCCESS) { |
2996 | printf(" CAPS Warning: EG_loadModel = %d (caps_jrnlRead)!\n", |
2997 | stat); |
2998 | goto jreaderr; |
2999 | } |
3000 | if (obj != NULL) { |
3001 | flist = (capsFList *) EG_alloc(sizeof(capsFList)); |
3002 | if (flist == NULL) { |
3003 | printf(" CAPS Warning: Cannot Allocate Journal Free List!\n"); |
3004 | } else { |
3005 | flist->type = jEgos; |
3006 | flist->num = args[i].num; |
3007 | flist->member.model = args[i].members.model; |
3008 | flist->sNum = objSN; |
3009 | flist->next = NULL; |
3010 | if (obj->flist != NULL) flist->next = obj->flist; |
3011 | obj->flist = flist; |
3012 | } |
3013 | } |
3014 | } |
3015 | |
3016 | } |
3017 | } |
3018 | |
3019 | n = fread(&sNum, sizeof(CAPSLONG), 1, problem->jrnl); |
3020 | if (n != 1) goto jreaderr; |
3021 | n = fread(&funID, sizeof(int), 1, problem->jrnl); |
3022 | if (n != 1) goto jreaderr; |
3023 | if (funID != problem->funID) { |
3024 | printf(" CAPS Fatal: Ending FunID = %d, should be %d!\n", |
3025 | funID, problem->funID); |
3026 | goto jreadfatal; |
3027 | } |
3028 | if (sNum > problem->sNum) { |
3029 | printf(" CAPS Info: Hit ending serial number -- going live!\n"); |
3030 | problem->stFlag = 0; |
3031 | fclose(problem->jrnl); |
3032 | #ifdef WIN32 |
3033 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\capsJournal", problem->root); |
3034 | #else |
3035 | snprintf(filename, PATH_MAX, "%s/capsRestart/capsJournal", problem->root); |
3036 | #endif |
3037 | |
3038 | problem->jrnl = fopen(filename, "ab"); |
3039 | |
3040 | if (problem->jrnl == NULL) { |
3041 | printf(" CAPS Error: Cannot open %s (caps_readJrnl)\n", filename); |
3042 | return CAPS_DIRERR; |
3043 | } |
3044 | } |
3045 | |
3046 | *serial = sNum; |
3047 | return CAPS_JOURNAL; |
3048 | |
3049 | jreaderr: |
3050 | printf(" CAPS Info: Incomplete Journal Record @ %d -- going live!\n", |
3051 | problem->funID); |
3052 | problem->stFlag = 0; |
3053 | fclose(problem->jrnl); |
3054 | #ifdef WIN32 |
3055 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\capsJournal", problem->root); |
3056 | #else |
3057 | snprintf(filename, PATH_MAX, "%s/capsRestart/capsJournal", problem->root); |
3058 | #endif |
3059 | |
3060 | problem->jrnl = fopen(filename, "ab"); |
3061 | |
3062 | if (problem->jrnl == NULL) { |
3063 | printf(" CAPS Error: Cannot open %s (caps_readJrnl)\n", filename); |
3064 | return CAPS_DIRERR; |
3065 | } |
3066 | #ifdef WIN32 |
3067 | _fseeki64(problem->jrnl, fpos, SEEK_SET); |
3068 | #else |
3069 | fseek(problem->jrnl, fpos, SEEK_SET); |
3070 | #endif |
3071 | return CAPS_SUCCESS; |
3072 | |
3073 | jreadfatal: |
3074 | fclose(problem->jrnl); |
3075 | problem->jrnl = NULL; |
3076 | problem->stFlag = CAPS_JOURNALERR; |
3077 | return CAPS_JOURNALERR; |
3078 | } |
3079 | |
3080 | |
3081 | static int |
3082 | caps_readInitObj(capsObject **obj, int type, int subtype, char *name, |
3083 | capsObject *parent) |
3084 | { |
3085 | int status; |
3086 | capsObject *object; |
3087 | |
3088 | status = caps_makeObject(obj); |
3089 | if (status != CAPS_SUCCESS) return status; |
3090 | |
3091 | object = *obj; |
3092 | object->magicnumber = CAPSMAGIC; |
3093 | object->type = type; |
3094 | object->subtype = subtype; |
3095 | object->name = EG_strdup(name); |
3096 | object->attrs = NULL; |
3097 | object->blind = NULL; |
3098 | object->flist = NULL; |
3099 | object->parent = parent; |
3100 | |
3101 | return CAPS_SUCCESS; |
3102 | } |
3103 | |
3104 | |
3105 | static int |
3106 | caps_readDataSet(capsProblem *problem, const char *base, capsObject *dobject) |
3107 | { |
3108 | int i, stat; |
3109 | char filename[PATH_MAX], *name = NULL; |
3110 | capsDataSet *ds; |
3111 | size_t n; |
3112 | FILE *fp; |
3113 | |
3114 | ds = (capsDataSet *) EG_alloc(sizeof(capsDataSet)); |
3115 | if (ds == NULL) return EGADS_MALLOC; |
3116 | ds->ftype = BuiltIn; |
3117 | ds->npts = 0; |
3118 | ds->rank = 0; |
3119 | ds->data = NULL; |
3120 | ds->units = NULL; |
3121 | ds->startup = NULL; |
3122 | ds->linkMethod = Interpolate; |
3123 | ds->link = NULL; |
3124 | dobject->blind = ds; |
3125 | #ifdef WIN32 |
3126 | snprintf(filename, PATH_MAX, "%s\\DN-%s", base, dobject->name); |
3127 | #else |
3128 | snprintf(filename, PATH_MAX, "%s/DN-%s", base, dobject->name); |
3129 | #endif |
3130 | |
3131 | fp = fopen(filename, "rb"); |
3132 | if (fp == NULL) { |
3133 | printf(" CAPS Error: Cannot open %s!\n", filename); |
3134 | return CAPS_DIRERR; |
3135 | } |
3136 | |
3137 | stat = caps_readHistory(fp, dobject); |
3138 | if (stat != CAPS_SUCCESS) goto rderrs; |
3139 | stat = caps_readOwn(fp, &dobject->last); |
3140 | if (stat != CAPS_SUCCESS) goto rderrs; |
3141 | stat = caps_readAttrs(fp, &dobject->attrs); |
3142 | if (stat != CAPS_SUCCESS) goto rderrs; |
3143 | stat = caps_readString(fp, &name); |
3144 | if (stat != CAPS_SUCCESS) goto rderrs; |
3145 | |
3146 | n = fread(&ds->ftype, sizeof(int), 1, fp); |
3147 | if (n != 1) goto rderrs; |
3148 | n = fread(&ds->npts, sizeof(int), 1, fp); |
3149 | if (n != 1) goto rderrs; |
3150 | n = fread(&ds->rank, sizeof(int), 1, fp); |
3151 | if (n != 1) goto rderrs; |
3152 | stat = caps_readString(fp, &ds->units); |
3153 | if (stat != CAPS_SUCCESS) goto rderrs; |
3154 | |
3155 | stat = caps_readDoubles(fp, &i, &ds->data); |
3156 | if (stat != CAPS_SUCCESS) goto rderrs; |
3157 | if (i != ds->npts*ds->rank) { |
3158 | printf(" CAPS Error: %s len mismatch %d %d (caps_readDataSet)!\n", |
3159 | name, i, ds->npts*ds->rank); |
3160 | goto rderrs; |
3161 | } |
3162 | EG_free(name); |
3163 | name = NULL; |
3164 | |
3165 | stat = caps_readString(fp, &name); |
3166 | if (stat != CAPS_SUCCESS) goto rderrs; |
3167 | if (name != NULL) { |
3168 | stat = caps_string2obj(problem, name, &ds->link); |
3169 | EG_free(name); |
3170 | name = NULL; |
3171 | if (stat != CAPS_SUCCESS) goto rderrs; |
3172 | } |
3173 | n = fread(&ds->linkMethod, sizeof(int), 1, fp); |
3174 | if (n != 1) goto rderrs; |
3175 | fclose(fp); |
3176 | |
3177 | return CAPS_SUCCESS; |
3178 | |
3179 | rderrs: |
3180 | if (name != NULL) EG_free(name); |
3181 | fclose(fp); |
3182 | return CAPS_IOERR; |
3183 | } |
3184 | |
3185 | |
3186 | static int |
3187 | caps_readVertexSet(capsProblem *problem, capsObject *bobject, |
3188 | capsObject *vobject) |
3189 | { |
3190 | int i, dim, status; |
3191 | char base[PATH_MAX], filename[PATH_MAX], cstype, *name; |
3192 | capsBound *bound; |
3193 | capsAnalysis *analysis; |
3194 | capsVertexSet *vs; |
3195 | capsObject *aobject; |
3196 | size_t n; |
3197 | FILE *fp; |
3198 | |
3199 | bound = (capsBound *) bobject->blind; |
3200 | vs = (capsVertexSet *) vobject->blind; |
3201 | cstype = 'U'; |
3202 | if (vobject->subtype == CONNECTED) { |
3203 | cstype = 'C'; |
3204 | aobject = vs->analysis; |
3205 | analysis = (capsAnalysis *) aobject->blind; |
3206 | vs->discr->aInfo = &analysis->info; |
3207 | vs->discr->instStore = analysis->instStore; |
3208 | } |
3209 | |
3210 | #ifdef WIN32 |
3211 | snprintf(base, PATH_MAX, "%s\\capsRestart\\BN-%4.4d\\S%c-%s", |
3212 | problem->root, bound->index, cstype, vobject->name); |
3213 | snprintf(filename, PATH_MAX, "%s\\vs", base); |
3214 | #else |
3215 | snprintf(base, PATH_MAX, "%s/capsRestart/BN-%4.4d/S%c-%s", |
3216 | problem->root, bound->index, cstype, vobject->name); |
3217 | snprintf(filename, PATH_MAX, "%s/vs", base); |
3218 | #endif |
3219 | |
3220 | fp = fopen(filename, "rb"); |
3221 | if (fp == NULL) { |
3222 | printf(" CAPS Error: Cannot open %s!\n", filename); |
3223 | return CAPS_DIRERR; |
3224 | } |
3225 | |
3226 | status = caps_readHistory(fp, vobject); |
3227 | if (status != CAPS_SUCCESS) goto readerr; |
3228 | status = caps_readOwn(fp, &vobject->last); |
3229 | if (status != CAPS_SUCCESS) goto readerr; |
3230 | status = caps_readAttrs(fp, &vobject->attrs); |
3231 | if (status != CAPS_SUCCESS) goto readerr; |
3232 | status = caps_readString(fp, &name); |
3233 | if (status != CAPS_SUCCESS) goto readerr; |
3234 | EG_free(name); |
3235 | |
3236 | |
3237 | n = fread(&dim, sizeof(int), 1, fp); |
3238 | if (n != 1) goto readerr; |
3239 | vs->discr->dim = dim; |
3240 | if (vobject->subtype == CONNECTED) dim = 0; |
3241 | |
3242 | if (dim != 0) { |
3243 | n = fread(&vs->discr->nVerts, sizeof(int), 1, fp); |
3244 | if (n != 1) goto readerr; |
3245 | vs->discr->verts = (double *) EG_alloc(3*vs->discr->nVerts*sizeof(double)); |
3246 | if (vs->discr->verts == NULL) { |
3247 | fclose(fp); |
3248 | return EGADS_MALLOC; |
3249 | } |
3250 | for (i = 0; i < vs->discr->nVerts; i++) { |
3251 | n = fread(&vs->discr->verts[3*i], sizeof(double), 3, fp); |
3252 | if (n != 3) goto readerr; |
3253 | } |
3254 | } |
3255 | fclose(fp); |
3256 | |
3257 | |
3258 | for (i = 0; i < vs->nDataSets; i++) { |
3259 | status = caps_readDataSet(problem, base, vs->dataSets[i]); |
3260 | if (status != CAPS_SUCCESS) { |
3261 | printf(" CAPS Error: %s caps_readDataSet = %d\n", |
3262 | vs->dataSets[i]->name, status); |
3263 | return status; |
3264 | } |
3265 | } |
3266 | |
3267 | return CAPS_SUCCESS; |
3268 | |
3269 | readerr: |
3270 | fclose(fp); |
3271 | return CAPS_IOERR; |
3272 | } |
3273 | |
3274 | |
3275 | static int |
3276 | caps_readInitDSets(capsProblem *problem, capsObject *bobject, |
3277 | capsObject *vobject) |
3278 | { |
3279 | int i, status; |
3280 | char filename[PATH_MAX], name[PATH_MAX], cstype; |
3281 | capsBound *bound; |
3282 | capsVertexSet *vs; |
3283 | FILE *fp; |
3284 | |
3285 | cstype = 'U'; |
3286 | if (vobject->subtype == CONNECTED) cstype = 'C'; |
3287 | |
3288 | bound = (capsBound *) bobject->blind; |
3289 | vs = (capsVertexSet *) vobject->blind; |
3290 | #ifdef WIN32 |
3291 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\BN-%4.4d\\S%c-%s\\dSets.txt", |
3292 | problem->root, bound->index, cstype, vobject->name); |
3293 | #else |
3294 | snprintf(filename, PATH_MAX, "%s/capsRestart/BN-%4.4d/S%c-%s/dSets.txt", |
3295 | problem->root, bound->index, cstype, vobject->name); |
3296 | #endif |
3297 | |
3298 | fp = fopen(filename, "r"); |
3299 | if (fp == NULL) { |
3300 | printf(" CAPS Error: Cannot open %s (caps_readInitDSets)!\n", filename); |
3301 | return CAPS_DIRERR; |
3302 | } |
3303 | fscanf(fp, "%d", &vs->nDataSets); |
3304 | vs->dataSets = (capsObject **) EG_alloc(vs->nDataSets*sizeof(capsObject *)); |
3305 | if (vs->dataSets == NULL) { |
3306 | fclose(fp); |
3307 | return EGADS_MALLOC; |
3308 | } |
3309 | for (i = 0; i < vs->nDataSets; i++) vs->dataSets[i] = NULL; |
3310 | for (i = 0; i < vs->nDataSets; i++) { |
3311 | fscanf(fp, "%s", name); |
3312 | status = caps_readInitObj(&vs->dataSets[i], DATASET, NONE, name, vobject); |
3313 | if (status != CAPS_SUCCESS) { |
3314 | printf(" CAPS Error: %s caps_readInitObj = %d (caps_readInitDSets)!\n", |
3315 | name, status); |
3316 | fclose(fp); |
3317 | return status; |
3318 | } |
3319 | } |
3320 | fclose(fp); |
3321 | |
3322 | return CAPS_SUCCESS; |
3323 | } |
3324 | |
3325 | |
3326 | static int |
3327 | caps_readInitVSets(capsProblem *problem, capsObject *bobject) |
3328 | { |
3329 | int i, j, type, status; |
3330 | char filename[PATH_MAX], name[PATH_MAX]; |
3331 | capsObject *aobject; |
3332 | capsBound *bound; |
3333 | capsVertexSet *vs; |
3334 | FILE *fp; |
3335 | |
3336 | bound = (capsBound *) bobject->blind; |
3337 | |
3338 | #ifdef WIN32 |
3339 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\BN-%4.4d\\vSets.txt", |
3340 | problem->root, bound->index); |
3341 | #else |
3342 | snprintf(filename, PATH_MAX, "%s/capsRestart/BN-%4.4d/vSets.txt", |
3343 | problem->root, bound->index); |
3344 | #endif |
3345 | fp = fopen(filename, "r"); |
3346 | if (fp == NULL) { |
3347 | printf(" CAPS Error: Cannot open %s (caps_readInitVSets)!\n", filename); |
3348 | return CAPS_DIRERR; |
3349 | } |
3350 | fscanf(fp, "%d", &bound->nVertexSet); |
3351 | bound->vertexSet = (capsObject **) |
3352 | EG_alloc(bound->nVertexSet*sizeof(capsObject *)); |
3353 | if (bound->vertexSet == NULL) { |
3354 | fclose(fp); |
3355 | return EGADS_MALLOC; |
3356 | } |
3357 | for (i = 0; i < bound->nVertexSet; i++) bound->vertexSet[i] = NULL; |
3358 | for (i = 0; i < bound->nVertexSet; i++) { |
3359 | fscanf(fp, "%d %s", &type, name); |
3360 | aobject = NULL; |
3361 | if (type == CONNECTED) { |
3362 | for (j = 0; j < problem->nAnalysis; j++) |
3363 | if (strcmp(name, problem->analysis[j]->name) == 0) { |
3364 | aobject = problem->analysis[j]; |
3365 | break; |
3366 | } |
3367 | if (aobject == NULL) { |
3368 | fclose(fp); |
3369 | printf(" CAPS Error: Analysis %s Not Found (caps_readInitVSets)\n", |
3370 | name); |
3371 | return CAPS_NOTFOUND; |
3372 | } |
3373 | } |
3374 | status = caps_readInitObj(&bound->vertexSet[i], VERTEXSET, type, name, |
3375 | bobject); |
3376 | if (status != CAPS_SUCCESS) { |
3377 | fclose(fp); |
3378 | printf(" CAPS Error: caps_readInitObj = %d (caps_readInitVSets)\n", |
3379 | status); |
3380 | return status; |
3381 | } |
3382 | vs = (capsVertexSet *) EG_alloc(sizeof(capsVertexSet)); |
3383 | if (vs == NULL) { |
3384 | fclose(fp); |
3385 | return EGADS_MALLOC; |
3386 | } |
3387 | vs->analysis = aobject; |
3388 | vs->nDataSets = 0; |
3389 | vs->dataSets = NULL; |
3390 | vs->discr = (capsDiscr *) EG_alloc(sizeof(capsDiscr)); |
3391 | if (vs->discr == NULL) { |
3392 | EG_free(vs); |
3393 | fclose(fp); |
3394 | return EGADS_MALLOC; |
3395 | } |
3396 | vs->discr->dim = 0; |
3397 | vs->discr->instStore = NULL; |
3398 | vs->discr->aInfo = NULL; |
3399 | vs->discr->nVerts = 0; |
3400 | vs->discr->verts = NULL; |
3401 | vs->discr->celem = NULL; |
3402 | vs->discr->nDtris = 0; |
3403 | vs->discr->dtris = NULL; |
3404 | vs->discr->nPoints = 0; |
3405 | vs->discr->nTypes = 0; |
3406 | vs->discr->types = NULL; |
3407 | vs->discr->nBodys = 0; |
3408 | vs->discr->bodys = NULL; |
3409 | vs->discr->tessGlobal = NULL; |
3410 | vs->discr->ptrm = NULL; |
3411 | bound->vertexSet[i]->blind = vs; |
3412 | |
3413 | status = caps_readInitDSets(problem, bobject, bound->vertexSet[i]); |
3414 | if (status != CAPS_SUCCESS) { |
3415 | printf(" CAPS Error: Bound %d caps_readInitDSets = %d (caps_open)!\n", |
3416 | i, status); |
3417 | fclose(fp); |
3418 | return status; |
3419 | } |
3420 | |
3421 | } |
3422 | fclose(fp); |
3423 | |
3424 | return CAPS_SUCCESS; |
3425 | } |
3426 | |
3427 | |
3428 | static int |
3429 | caps_readBound(capsObject *bobject) |
3430 | { |
3431 | int i, status; |
3432 | char filename[PATH_MAX]; |
3433 | capsObject *pobject; |
3434 | capsProblem *problem; |
3435 | capsBound *bound; |
3436 | size_t n; |
3437 | FILE *fp; |
3438 | |
3439 | pobject = bobject->parent; |
3440 | problem = (capsProblem *) pobject->blind; |
3441 | bound = (capsBound *) bobject->blind; |
3442 | |
3443 | #ifdef WIN32 |
3444 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\BN-%4.4d\\bound", |
3445 | problem->root, bound->index); |
3446 | #else |
3447 | snprintf(filename, PATH_MAX, "%s/capsRestart/BN-%4.4d/bound", |
3448 | problem->root, bound->index); |
3449 | #endif |
3450 | fp = fopen(filename, "rb"); |
3451 | if (fp == NULL) { |
3452 | printf(" CAPS Error: Cannot open bound %s!\n", filename); |
3453 | return CAPS_DIRERR; |
3454 | } |
3455 | |
3456 | status = caps_readHistory(fp, bobject); |
3457 | if (status != CAPS_SUCCESS) goto rerror; |
3458 | status = caps_readOwn(fp, &bobject->last); |
3459 | if (status != CAPS_SUCCESS) goto rerror; |
3460 | status = caps_readAttrs(fp, &bobject->attrs); |
3461 | if (status != CAPS_SUCCESS) goto rerror; |
3462 | status = caps_readString(fp, &bobject->name); |
3463 | if (status != CAPS_SUCCESS) goto rerror; |
3464 | n = fread(&bound->dim, sizeof(int), 1, fp); |
3465 | if (n != 1) goto rerror; |
3466 | n = fread(&bound->state, sizeof(int), 1, fp); |
3467 | if (n != 1) goto rerror; |
3468 | n = fread(&bound->plimits, sizeof(double), 4, fp); |
3469 | if (n != 4) goto rerror; |
3470 | n = fread(&bound->iBody, sizeof(int), 1, fp); |
3471 | if (n != 1) goto rerror; |
3472 | n = fread(&bound->iEnt, sizeof(int), 1, fp); |
3473 | if (n != 1) goto rerror; |
3474 | n = fread(&bound->index, sizeof(int), 1, fp); |
3475 | if (n != 1) goto rerror; |
3476 | |
3477 | n = fread(&i, sizeof(int), 1, fp); |
3478 | if (n != 1) goto rerror; |
3479 | if (i != 0) { |
3480 | bound->curve = (capsAprx1D *) EG_alloc(sizeof(capsAprx1D)); |
3481 | if (bound->curve == NULL) { |
3482 | fclose(fp); |
3483 | return EGADS_MALLOC; |
3484 | } |
3485 | bound->curve->nrank = i; |
3486 | } |
3487 | |
3488 | if (bound->curve != NULL) { |
3489 | n = fread(&bound->curve->periodic, sizeof(int), 1, fp); |
3490 | if (n != 1) goto rerror; |
3491 | n = fread(&bound->curve->nts, sizeof(int), 1, fp); |
3492 | if (n != 1) goto rerror; |
3493 | status = caps_readDoubles(fp, &i, &bound->curve->interp); |
3494 | if (status != CAPS_SUCCESS) goto rerror; |
3495 | n = fread(bound->curve->trange, sizeof(double), 2, fp); |
3496 | if (n != 2) goto rerror; |
3497 | n = fread(&bound->curve->ntm, sizeof(int), 1, fp); |
3498 | if (n != 1) goto rerror; |
3499 | status = caps_readDoubles(fp, &i, &bound->curve->tmap); |
3500 | if (status != CAPS_SUCCESS) goto rerror; |
3501 | } |
3502 | |
3503 | n = fread(&i, sizeof(int), 1, fp); |
3504 | if (n != 1) goto rerror; |
3505 | if (i != 0) { |
3506 | bound->surface = (capsAprx2D *) EG_alloc(sizeof(capsAprx2D)); |
3507 | if (bound->surface == NULL) { |
3508 | fclose(fp); |
3509 | return EGADS_MALLOC; |
3510 | } |
3511 | bound->surface->nrank = i; |
3512 | } |
3513 | if (bound->surface != NULL) { |
3514 | n = fread(&bound->surface->periodic, sizeof(int), 1, fp); |
3515 | if (n != 1) goto rerror; |
3516 | n = fread(&bound->surface->nus, sizeof(int), 1, fp); |
3517 | if (n != 1) goto rerror; |
3518 | n = fread(&bound->surface->nvs, sizeof(int), 1, fp); |
3519 | if (n != 1) goto rerror; |
3520 | status = caps_readDoubles(fp, &i, &bound->surface->interp); |
3521 | if (status != CAPS_SUCCESS) goto rerror; |
3522 | n = fread(bound->surface->urange, sizeof(double), 2, fp); |
3523 | if (n != 2) goto rerror; |
3524 | n = fread(bound->surface->vrange, sizeof(double), 2, fp); |
3525 | if (n != 2) goto rerror; |
3526 | n = fread(&bound->surface->num, sizeof(int), 1, fp); |
3527 | if (n != 1) goto rerror; |
3528 | n = fread(&bound->surface->nvm, sizeof(int), 1, fp); |
3529 | if (n != 1) goto rerror; |
3530 | status = caps_readDoubles(fp, &i, &bound->surface->uvmap); |
3531 | if (status != CAPS_SUCCESS) goto rerror; |
3532 | } |
3533 | fclose(fp); |
3534 | |
3535 | |
3536 | for (i = 0; i < bound->nVertexSet; i++) { |
3537 | status = caps_readVertexSet(problem, bobject, bound->vertexSet[i]); |
3538 | if (status != CAPS_SUCCESS) { |
3539 | printf(" CAPS Error: caps_readVertexSet = %d (caps_readBound)\n", status); |
3540 | return status; |
3541 | } |
3542 | } |
3543 | |
3544 | return CAPS_SUCCESS; |
3545 | |
3546 | rerror: |
3547 | fclose(fp); |
3548 | return CAPS_IOERR; |
3549 | } |
3550 | |
3551 | |
3552 | static int |
3553 | caps_readAnalysis(capsProblem *problem, capsObject *aobject) |
3554 | { |
3555 | int i, j, stat, eFlag, nIn, nOut, nField, *ranks, *fInOut; |
3556 | size_t n; |
3557 | char **fields, base[PATH_MAX], filename[PATH_MAX], *name; |
3558 | void *instStore; |
3559 | capsValue *value; |
3560 | capsAnalysis *analysis; |
3561 | FILE *fp; |
3562 | |
3563 | analysis = (capsAnalysis *) aobject->blind; |
3564 | |
3565 | #ifdef WIN32 |
3566 | snprintf(base, PATH_MAX, "%s\\capsRestart\\AN-%s", |
3567 | problem->root, aobject->name); |
3568 | snprintf(filename, PATH_MAX, "%s\\analysis", base); |
3569 | #else |
3570 | snprintf(base, PATH_MAX, "%s/capsRestart/AN-%s", |
3571 | problem->root, aobject->name); |
3572 | snprintf(filename, PATH_MAX, "%s/analysis", base); |
3573 | #endif |
3574 | |
3575 | fp = fopen(filename, "rb"); |
3576 | if (fp == NULL) { |
3577 | printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename); |
3578 | return CAPS_DIRERR; |
3579 | } |
3580 | |
3581 | stat = caps_readHistory(fp, aobject); |
3582 | if (stat != CAPS_SUCCESS) goto raerr; |
3583 | stat = caps_readOwn(fp, &aobject->last); |
3584 | if (stat != CAPS_SUCCESS) goto raerr; |
3585 | stat = caps_readOwn(fp, &analysis->pre); |
3586 | if (stat != CAPS_SUCCESS) goto raerr; |
3587 | stat = caps_readAttrs(fp, &aobject->attrs); |
3588 | if (stat != CAPS_SUCCESS) goto raerr; |
3589 | stat = caps_readString(fp, &name); |
3590 | if (stat != CAPS_SUCCESS) goto raerr; |
3591 | EG_free(name); |
3592 | |
3593 | stat = caps_readString(fp, &analysis->loadName); |
3594 | if (stat != CAPS_SUCCESS) goto raerr; |
3595 | if (analysis->loadName == NULL) { |
3596 | fclose(fp); |
3597 | return CAPS_NULLNAME; |
3598 | } |
3599 | stat = caps_readString(fp, &analysis->path); |
3600 | if (stat != CAPS_SUCCESS) goto raerr; |
3601 | stat = caps_readString(fp, &analysis->unitSys); |
3602 | if (stat != CAPS_SUCCESS) goto raerr; |
3603 | stat = caps_readString(fp, &analysis->intents); |
3604 | if (stat != CAPS_SUCCESS) goto raerr; |
3605 | n = fread(&analysis->major, sizeof(int), 1, fp); |
3606 | if (n != 1) goto raerr; |
3607 | n = fread(&analysis->minor, sizeof(int), 1, fp); |
3608 | if (n != 1) goto raerr; |
3609 | n = fread(&analysis->autoexec, sizeof(int), 1, fp); |
3610 | if (n != 1) goto raerr; |
3611 | n = fread(&analysis->nField, sizeof(int), 1, fp); |
3612 | if (n != 1) goto raerr; |
3613 | if (analysis->nField != 0) { |
3614 | analysis->fields = (char **) EG_alloc(analysis->nField*sizeof(char *)); |
3615 | if (analysis->fields == NULL) { |
3616 | fclose(fp); |
3617 | return EGADS_MALLOC; |
3618 | } |
3619 | for (i = 0; i < analysis->nField; i++) { |
3620 | stat = caps_readString(fp, &analysis->fields[i]); |
3621 | if (stat != CAPS_SUCCESS) goto raerr; |
3622 | } |
3623 | analysis->ranks = (int *) EG_alloc(analysis->nField*sizeof(int)); |
3624 | if (analysis->ranks == NULL) { |
3625 | fclose(fp); |
3626 | return EGADS_MALLOC; |
3627 | } |
3628 | n = fread(analysis->ranks, sizeof(int), analysis->nField, fp); |
3629 | if (n != analysis->nField) goto raerr; |
3630 | analysis->fInOut = (int *) EG_alloc(analysis->nField*sizeof(int)); |
3631 | if (analysis->fInOut == NULL) { |
3632 | fclose(fp); |
3633 | return EGADS_MALLOC; |
3634 | } |
3635 | n = fread(analysis->fInOut, sizeof(int), analysis->nField, fp); |
3636 | if (n != analysis->nField) goto raerr; |
3637 | } |
3638 | n = fread(&analysis->nAnalysisDynO, sizeof(int), 1, fp); |
3639 | if (n != 1) goto raerr; |
3640 | fclose(fp); |
3641 | #ifdef WIN32 |
3642 | snprintf(filename, PATH_MAX, "%s\\%s", problem->root, analysis->path); |
3643 | #else |
3644 | snprintf(filename, PATH_MAX, "%s/%s", problem->root, analysis->path); |
3645 | #endif |
3646 | analysis->fullPath = EG_strdup(filename); |
3647 | |
3648 | |
3649 | eFlag = 0; |
3650 | nField = 0; |
3651 | fields = NULL; |
3652 | ranks = NULL; |
3653 | fInOut = NULL; |
3654 | instStore = NULL; |
3655 | stat = aim_Initialize(&problem->aimFPTR, analysis->loadName, &eFlag, |
3656 | analysis->unitSys, &analysis->info, |
3657 | &analysis->major, &analysis->minor, &nIn, &nOut, |
3658 | &nField, &fields, &ranks, &fInOut, &instStore); |
3659 | if (stat < CAPS_SUCCESS) { |
3660 | if (fields != NULL) { |
3661 | for (i = 0; i < nField; i++) EG_free(fields[i]); |
3662 | EG_free(fields); |
3663 | } |
3664 | EG_free(ranks); |
3665 | EG_free(fInOut); |
3666 | return stat; |
3667 | } |
3668 | if (nIn <= 0) { |
3669 | if (fields != NULL) { |
3670 | for (i = 0; i < nField; i++) EG_free(fields[i]); |
3671 | EG_free(fields); |
3672 | } |
3673 | EG_free(ranks); |
3674 | EG_free(fInOut); |
3675 | return CAPS_BADINIT; |
3676 | } |
3677 | analysis->info.instance = stat; |
3678 | analysis->instStore = instStore; |
3679 | analysis->eFlag = eFlag; |
3680 | if ((analysis->autoexec == 1) && (eFlag == 0)) analysis->autoexec = 0; |
3681 | if (fields != NULL) { |
3682 | for (i = 0; i < nField; i++) EG_free(fields[i]); |
3683 | EG_free(fields); |
3684 | } |
3685 | EG_free(ranks); |
3686 | EG_free(fInOut); |
3687 | if (nField != analysis->nField) { |
3688 | printf(" CAPS Error: %s # Fields = %d -- from file = %d (caps_open)!\n", |
3689 | analysis->loadName, nField, analysis->nField); |
3690 | return CAPS_MISMATCH; |
3691 | } |
3692 | if (nIn != analysis->nAnalysisIn) { |
3693 | printf(" CAPS Error: %s # Inputs = %d -- from file = %d (caps_open)!\n", |
3694 | analysis->loadName, nIn, analysis->nAnalysisIn); |
3695 | return CAPS_MISMATCH; |
3696 | } |
3697 | if (nOut != analysis->nAnalysisOut) { |
3698 | printf(" CAPS Error: %s # Outputs = %d -- from file = %d (caps_open)!\n", |
3699 | analysis->loadName, nOut, analysis->nAnalysisOut); |
3700 | return CAPS_MISMATCH; |
3701 | } |
3702 | |
3703 | |
3704 | |
3705 | if (analysis->analysisIn != NULL) { |
3706 | for (i = 0; i < analysis->nAnalysisIn; i++) { |
3707 | #ifdef WIN32 |
3708 | snprintf(filename, PATH_MAX, "%s\\VI-%4.4d", base, i+1); |
3709 | #else |
3710 | snprintf(filename, PATH_MAX, "%s/VI-%4.4d", base, i+1); |
3711 | #endif |
3712 | fp = fopen(filename, "rb"); |
3713 | if (fp == NULL) { |
3714 | printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename); |
3715 | return CAPS_DIRERR; |
3716 | } |
3717 | stat = caps_readValue(fp, problem, analysis->analysisIn[i]); |
3718 | fclose(fp); |
3719 | if (stat != CAPS_SUCCESS) { |
3720 | printf(" CAPS Error: %s AnalysisIn %d/%d readValue = %d (caps_open)!\n", |
3721 | aobject->name, i+1, analysis->nAnalysisIn, stat); |
3722 | return stat; |
3723 | } |
3724 | } |
3725 | } |
3726 | |
3727 | if (analysis->analysisOut != NULL) { |
3728 | for (i = 0; i < analysis->nAnalysisOut; i++) { |
3729 | #ifdef WIN32 |
3730 | snprintf(filename, PATH_MAX, "%s\\VO-%4.4d", base, i+1); |
3731 | #else |
3732 | snprintf(filename, PATH_MAX, "%s/VO-%4.4d", base, i+1); |
3733 | #endif |
3734 | fp = fopen(filename, "rb"); |
3735 | if (fp == NULL) { |
3736 | printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename); |
3737 | return CAPS_DIRERR; |
3738 | } |
3739 | stat = caps_readValue(fp, problem, analysis->analysisOut[i]); |
3740 | fclose(fp); |
3741 | if (stat != CAPS_SUCCESS) { |
3742 | printf(" CAPS Error: %s AnalysisOut %d/%d readValue = %d (caps_open)!\n", |
3743 | aobject->name, i+1, analysis->nAnalysisOut, stat); |
3744 | return stat; |
3745 | } |
3746 | } |
3747 | } |
3748 | |
3749 | if (analysis->nAnalysisDynO != 0) { |
3750 | analysis->analysisDynO = (capsObject **) EG_alloc(analysis->nAnalysisDynO* |
3751 | sizeof(capsObject *)); |
3752 | if (analysis->analysisDynO == NULL) { |
3753 | printf(" CAPS Error: Allocation for %s %d AnalysisDynO (caps_open)!\n", |
3754 | aobject->name, analysis->nAnalysisDynO); |
3755 | return EGADS_MALLOC; |
3756 | } |
3757 | |
3758 | for (j = 0; j < analysis->nAnalysisDynO; j++) |
3759 | analysis->analysisDynO[j] = NULL; |
3760 | for (j = 0; j < analysis->nAnalysisDynO; j++) { |
3761 | stat = caps_readInitObj(&analysis->analysisDynO[j], VALUE, ANALYSISDYNO, |
3762 | NULL, aobject); |
3763 | if (stat != CAPS_SUCCESS) { |
3764 | printf(" CAPS Error: aDynO %d/%d caps_readInitObj = %d (caps_open)!\n", |
3765 | j, analysis->nAnalysisDynO, stat); |
3766 | return stat; |
3767 | } |
3768 | value = (capsValue *) EG_alloc(sizeof(capsValue)); |
3769 | if (value == NULL) { |
3770 | printf(" CAPS Error: Allocation for %s %d/%d AnalysisDynO (caps_open)!\n", |
3771 | aobject->name, j, analysis->nAnalysisDynO); |
3772 | return EGADS_MALLOC; |
3773 | } |
3774 | value->length = value->nrow = value->ncol = 1; |
3775 | value->type = Integer; |
3776 | value->dim = value->pIndex = 0; |
3777 | value->index = j+1; |
3778 | value->lfixed = value->sfixed = Fixed; |
3779 | value->nullVal = NotAllowed; |
3780 | value->units = NULL; |
3781 | value->meshWriter = NULL; |
3782 | value->link = NULL; |
3783 | value->vals.reals = NULL; |
3784 | value->limits.dlims[0] = value->limits.dlims[1] = 0.0; |
3785 | value->linkMethod = Copy; |
3786 | value->gInType = 0; |
3787 | value->partial = NULL; |
3788 | value->nderiv = 0; |
3789 | value->derivs = NULL; |
3790 | analysis->analysisDynO[j]->blind = value; |
3791 | } |
3792 | |
3793 | for (i = 0; i < analysis->nAnalysisDynO; i++) { |
3794 | #ifdef WIN32 |
3795 | snprintf(filename, PATH_MAX, "%s\\VD-%4.4d", base, i+1); |
3796 | #else |
3797 | snprintf(filename, PATH_MAX, "%s/VD-%4.4d", base, i+1); |
3798 | #endif |
3799 | fp = fopen(filename, "rb"); |
3800 | if (fp == NULL) { |
3801 | printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename); |
3802 | return CAPS_DIRERR; |
3803 | } |
3804 | stat = caps_readValue(fp, problem, analysis->analysisDynO[i]); |
3805 | fclose(fp); |
3806 | if (stat != CAPS_SUCCESS) { |
3807 | printf(" CAPS Error: %s AnalysisDynO %d/%d readValue = %d (caps_open)!\n", |
3808 | aobject->name, i+1, analysis->nAnalysisDynO, stat); |
3809 | return stat; |
3810 | } |
3811 | } |
3812 | } |
3813 | |
3814 | return CAPS_SUCCESS; |
3815 | |
3816 | raerr: |
3817 | fclose(fp); |
3818 | return CAPS_IOERR; |
3819 | } |
3820 | |
3821 | |
3822 | static int |
3823 | caps_readState(capsObject *pobject) |
3824 | { |
3825 | int i, j, ivec[2], nIn, nOut, stat; |
3826 | char filename[PATH_MAX], name[PATH_MAX], *phName; |
3827 | capsProblem *problem; |
3828 | capsAnalysis *analysis; |
3829 | capsBound *bound; |
3830 | capsValue *value; |
3831 | size_t n; |
3832 | FILE *fp, *fptxt = NULL; |
3833 | |
3834 | problem = (capsProblem *) pobject->blind; |
3835 | #ifdef WIN32 |
3836 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\Problem", problem->root); |
3837 | #else |
3838 | snprintf(filename, PATH_MAX, "%s/capsRestart/Problem", problem->root); |
3839 | #endif |
3840 | |
3841 | fp = fopen(filename, "rb"); |
3842 | if (fp == NULL) { |
3843 | printf(" CAPS Error: Cannot open %s!\n", filename); |
3844 | return CAPS_DIRERR; |
3845 | } |
3846 | ivec[0] = CAPSMAJOR; |
3847 | ivec[1] = CAPSMINOR; |
3848 | |
3849 | n = fread(ivec, sizeof(int), 2, fp); |
3850 | if (n != 2) goto readerr; |
3851 | #ifdef DEBUG |
3852 | printf(" CAPS Info: Reading files written by Major = %d Minor = %d\n", |
3853 | ivec[0], ivec[1]); |
3854 | #endif |
3855 | n = fread(&pobject->subtype, sizeof(int), 1, fp); |
3856 | if (n != 1) goto readerr; |
3857 | stat = caps_readHistory(fp, pobject); |
3858 | if (stat != CAPS_SUCCESS) goto readerr; |
3859 | stat = caps_readOwn(fp, &pobject->last); |
3860 | if (stat != CAPS_SUCCESS) goto readerr; |
3861 | stat = caps_readAttrs(fp, &pobject->attrs); |
3862 | if (stat != CAPS_SUCCESS) goto readerr; |
3863 | if (pobject->name != NULL) EG_free(pobject->name); |
3864 | stat = caps_readString(fp, &pobject->name); |
3865 | if (stat != CAPS_SUCCESS) goto readerr; |
3866 | stat = caps_readString(fp, &phName); |
3867 | if (stat != CAPS_SUCCESS) goto readerr; |
3868 | if (phName != NULL) EG_free(phName); |
3869 | stat = caps_readOwn(fp, &problem->geometry); |
3870 | if (stat != CAPS_SUCCESS) goto readerr; |
3871 | n = fread(&problem->sNum, sizeof(CAPSLONG), 1, fp); |
3872 | if (n != 1) goto readerr; |
3873 | #ifdef WIN32 |
3874 | n = fread(&problem->jpos, sizeof(__int64), 1, fp); |
3875 | #else |
3876 | n = fread(&problem->jpos, sizeof(long), 1, fp); |
3877 | #endif |
3878 | if (n != 1) goto readerr; |
3879 | n = fread(&problem->outLevel, sizeof(int), 1, fp); |
3880 | if (n != 1) goto readerr; |
3881 | n = fread(&problem->nEGADSmdl, sizeof(int), 1, fp); |
3882 | if (n != 1) goto readerr; |
3883 | n = fread(&problem->nRegGIN, sizeof(int), 1, fp); |
3884 | if (n != 1) goto readerr; |
3885 | |
3886 | for (i = 0; i < problem->nRegGIN; i++) { |
3887 | stat = caps_readString(fp, &problem->regGIN[i].name); |
3888 | if (stat != CAPS_SUCCESS) goto readerr; |
3889 | n = fread(&problem->regGIN[i].index, sizeof(int), 1, fp); |
3890 | if (n != 1) goto readerr; |
3891 | n = fread(&problem->regGIN[i].irow, sizeof(int), 1, fp); |
3892 | if (n != 1) goto readerr; |
3893 | n = fread(&problem->regGIN[i].icol, sizeof(int), 1, fp); |
3894 | if (n != 1) goto readerr; |
3895 | } |
3896 | fclose(fp); |
3897 | |
3898 | |
3899 | |
3900 | #ifdef WIN32 |
3901 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\param.txt", problem->root); |
3902 | #else |
3903 | snprintf(filename, PATH_MAX, "%s/capsRestart/param.txt", problem->root); |
3904 | #endif |
3905 | fptxt = fopen(filename, "r"); |
3906 | if (fptxt != NULL) { |
3907 | fscanf(fptxt, "%d", &problem->nParam); |
3908 | fclose(fptxt); |
3909 | } |
3910 | |
3911 | #ifdef WIN32 |
3912 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\geom.txt", problem->root); |
3913 | #else |
3914 | snprintf(filename, PATH_MAX, "%s/capsRestart/geom.txt", problem->root); |
3915 | #endif |
3916 | fptxt = fopen(filename, "r"); |
3917 | if (fptxt != NULL) { |
3918 | fscanf(fptxt, "%d %d", &problem->nGeomIn, &problem->nGeomOut); |
3919 | fclose(fptxt); |
3920 | } |
3921 | |
3922 | #ifdef WIN32 |
3923 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\analy.txt", problem->root); |
3924 | #else |
3925 | snprintf(filename, PATH_MAX, "%s/capsRestart/analy.txt", problem->root); |
3926 | #endif |
3927 | fptxt = fopen(filename, "r"); |
3928 | if (fptxt != NULL) { |
3929 | fscanf(fptxt, "%d", &problem->nAnalysis); |
3930 | if (problem->nAnalysis > 0) { |
3931 | problem->analysis = (capsObject **) |
3932 | EG_alloc(problem->nAnalysis*sizeof(capsObject *)); |
3933 | if (problem->analysis == NULL) return EGADS_MALLOC; |
3934 | for (i = 0; i < problem->nAnalysis; i++) problem->analysis[i] = NULL; |
3935 | for (i = 0; i < problem->nAnalysis; i++) { |
3936 | stat = caps_readInitObj(&problem->analysis[i], ANALYSIS, NONE, NULL, |
3937 | problem->mySelf); |
3938 | if (stat != CAPS_SUCCESS) { |
3939 | printf(" CAPS Error: Analysis %d caps_readInitObj = %d (caps_open)!\n", |
3940 | i, stat); |
3941 | fclose(fptxt); |
3942 | return stat; |
3943 | } |
3944 | } |
3945 | for (i = 0; i < problem->nAnalysis; i++) { |
3946 | fscanf(fptxt, "%d %d %s", &nIn, &nOut, name); |
3947 | analysis = (capsAnalysis *) EG_alloc(sizeof(capsAnalysis)); |
3948 | if (analysis == NULL) { |
3949 | fclose(fptxt); |
3950 | return EGADS_MALLOC; |
3951 | } |
3952 | problem->analysis[i]->name = EG_strdup(name); |
3953 | problem->analysis[i]->blind = analysis; |
3954 | analysis->loadName = NULL; |
3955 | analysis->fullPath = NULL; |
3956 | analysis->path = NULL; |
3957 | analysis->unitSys = NULL; |
3958 | analysis->major = CAPSMAJOR; |
3959 | analysis->minor = CAPSMINOR; |
3960 | analysis->instStore = NULL; |
3961 | analysis->intents = NULL; |
3962 | analysis->autoexec = 0; |
3963 | analysis->eFlag = 0; |
3964 | analysis->nField = 0; |
3965 | analysis->fields = NULL; |
3966 | analysis->ranks = NULL; |
3967 | analysis->fInOut = NULL; |
3968 | analysis->nAnalysisIn = nIn; |
3969 | analysis->analysisIn = NULL; |
3970 | analysis->nAnalysisOut = nOut; |
3971 | analysis->analysisOut = NULL; |
3972 | analysis->nAnalysisDynO = 0; |
3973 | analysis->analysisDynO = NULL; |
3974 | analysis->nBody = 0; |
3975 | analysis->bodies = NULL; |
3976 | analysis->nTess = 0; |
3977 | analysis->tess = NULL; |
3978 | analysis->pre.nLines = 0; |
3979 | analysis->pre.lines = NULL; |
3980 | analysis->pre.pname = NULL; |
3981 | analysis->pre.pID = NULL; |
3982 | analysis->pre.user = NULL; |
3983 | analysis->pre.sNum = 0; |
3984 | analysis->info.magicnumber = CAPSMAGIC; |
3985 | analysis->info.instance = stat; |
3986 | analysis->info.problem = problem; |
3987 | analysis->info.analysis = analysis; |
3988 | analysis->info.pIndex = 0; |
3989 | analysis->info.irow = 0; |
3990 | analysis->info.icol = 0; |
3991 | analysis->info.errs.nError = 0; |
3992 | analysis->info.errs.errors = NULL; |
3993 | analysis->info.wCntxt.aimWriterNum = 0; |
3994 | for (j = 0; j < 6; j++) analysis->pre.datetime[j] = 0; |
3995 | |
3996 | |
3997 | if (nIn > 0) { |
3998 | analysis->analysisIn = (capsObject **) |
3999 | EG_alloc(nIn*sizeof(capsObject *)); |
4000 | if (analysis->analysisIn == NULL) { |
4001 | fclose(fptxt); |
4002 | return EGADS_MALLOC; |
4003 | } |
4004 | for (j = 0; j < nIn; j++) analysis->analysisIn[j] = NULL; |
4005 | value = (capsValue *) EG_alloc(nIn*sizeof(capsValue)); |
4006 | if (value == NULL) { |
4007 | fclose(fptxt); |
4008 | EG_free(analysis->analysisIn); |
4009 | analysis->analysisIn = NULL; |
4010 | return EGADS_MALLOC; |
4011 | } |
4012 | for (j = 0; j < nIn; j++) { |
4013 | value[j].length = value[j].nrow = value[j].ncol = 1; |
4014 | value[j].type = Integer; |
4015 | value[j].dim = value[j].pIndex = 0; |
4016 | value[j].index = j+1; |
4017 | value[j].lfixed = value[j].sfixed = Fixed; |
4018 | value[j].nullVal = NotAllowed; |
4019 | value[j].units = NULL; |
4020 | value[j].meshWriter = NULL; |
4021 | value[j].link = NULL; |
4022 | value[j].vals.reals = NULL; |
4023 | value[j].limits.dlims[0] = value[j].limits.dlims[1] = 0.0; |
4024 | value[j].linkMethod = Copy; |
4025 | value[j].gInType = 0; |
4026 | value[j].partial = NULL; |
4027 | value[j].nderiv = 0; |
4028 | value[j].derivs = NULL; |
4029 | } |
4030 | for (j = 0; j < nIn; j++) { |
4031 | stat = caps_readInitObj(&analysis->analysisIn[j], VALUE, ANALYSISIN, |
4032 | NULL, problem->analysis[i]); |
4033 | if (stat != CAPS_SUCCESS) { |
4034 | printf(" CAPS Error: aIn %d caps_readInitObj = %d (caps_open)!\n", |
4035 | j, stat); |
4036 | fclose(fptxt); |
4037 | |
4038 | EG_free(value); |
4039 | |
4040 | EG_free(analysis->analysisIn); |
4041 | analysis->analysisIn = NULL; |
4042 | return stat; |
4043 | } |
4044 | |
4045 | analysis->analysisIn[j]->blind = &value[j]; |
4046 | |
4047 | } |
4048 | analysis->analysisIn[0]->blind = value; |
4049 | } |
4050 | if (nOut > 0) { |
4051 | analysis->analysisOut = (capsObject **) |
4052 | EG_alloc(nOut*sizeof(capsObject *)); |
4053 | if (analysis->analysisOut == NULL) { |
4054 | fclose(fptxt); |
4055 | return EGADS_MALLOC; |
4056 | } |
4057 | for (j = 0; j < nOut; j++) analysis->analysisOut[j] = NULL; |
4058 | value = (capsValue *) EG_alloc(nIn*sizeof(capsValue)); |
4059 | if (value == NULL) { |
4060 | fclose(fptxt); |
4061 | EG_free(analysis->analysisOut); |
4062 | analysis->analysisOut = NULL; |
4063 | return EGADS_MALLOC; |
4064 | } |
4065 | for (j = 0; j < nOut; j++) { |
4066 | value[j].length = value[j].nrow = value[j].ncol = 1; |
4067 | value[j].type = Integer; |
4068 | value[j].dim = value[j].pIndex = 0; |
4069 | value[j].index = j+1; |
4070 | value[j].lfixed = value[j].sfixed = Fixed; |
4071 | value[j].nullVal = NotAllowed; |
4072 | value[j].units = NULL; |
4073 | value[j].meshWriter = NULL; |
4074 | value[j].link = NULL; |
4075 | value[j].vals.reals = NULL; |
4076 | value[j].limits.dlims[0] = value[j].limits.dlims[1] = 0.0; |
4077 | value[j].linkMethod = Copy; |
4078 | value[j].gInType = 0; |
4079 | value[j].partial = NULL; |
4080 | value[j].nderiv = 0; |
4081 | value[j].derivs = NULL; |
4082 | } |
4083 | for (j = 0; j < nOut; j++) { |
4084 | stat = caps_readInitObj(&analysis->analysisOut[j], VALUE, ANALYSISOUT, |
4085 | NULL, problem->analysis[i]); |
4086 | if (stat != CAPS_SUCCESS) { |
4087 | printf(" CAPS Error: aOut %d caps_readInitObj = %d (caps_open)!\n", |
4088 | j, stat); |
4089 | fclose(fptxt); |
4090 | |
4091 | EG_free(value); |
4092 | |
4093 | EG_free(analysis->analysisOut); |
4094 | analysis->analysisOut = NULL; |
4095 | return stat; |
4096 | } |
4097 | |
4098 | analysis->analysisOut[j]->blind = &value[j]; |
4099 | |
4100 | } |
4101 | analysis->analysisOut[0]->blind = value; |
4102 | } |
4103 | } |
4104 | } |
4105 | fclose(fptxt); |
4106 | } |
4107 | |
4108 | #ifdef WIN32 |
4109 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\bound.txt", problem->root); |
4110 | #else |
4111 | snprintf(filename, PATH_MAX, "%s/capsRestart/bound.txt", problem->root); |
4112 | #endif |
4113 | fptxt = fopen(filename, "r"); |
4114 | if (fptxt != NULL) { |
4115 | fscanf(fptxt, "%d %d", &problem->nBound, &problem->mBound); |
4116 | if (problem->nBound > 0) { |
4117 | problem->bounds = (capsObject **) |
4118 | EG_alloc(problem->nBound*sizeof(capsObject *)); |
4119 | if (problem->bounds == NULL) { |
4120 | fclose(fptxt); |
4121 | return EGADS_MALLOC; |
4122 | } |
4123 | for (i = 0; i < problem->nBound; i++) problem->bounds[i] = NULL; |
4124 | for (i = 0; i < problem->nBound; i++) { |
4125 | fscanf(fptxt, "%d %s", &j, name); |
4126 | bound = (capsBound *) EG_alloc(sizeof(capsBound)); |
4127 | if (bound == NULL) { |
4128 | fclose(fptxt); |
4129 | return EGADS_MALLOC; |
4130 | } |
4131 | bound->dim = 0; |
4132 | bound->state = Empty; |
4133 | bound->lunits = NULL; |
4134 | bound->plimits[0] = bound->plimits[1] = bound->plimits[2] = |
4135 | bound->plimits[3] = 0.0; |
4136 | bound->geom = NULL; |
4137 | bound->iBody = 0; |
4138 | bound->iEnt = 0; |
4139 | bound->curve = NULL; |
4140 | bound->surface = NULL; |
4141 | bound->index = j; |
4142 | bound->nVertexSet = 0; |
4143 | bound->vertexSet = NULL; |
4144 | |
4145 | stat = caps_readInitObj(&problem->bounds[i], BOUND, NONE, NULL, |
4146 | problem->mySelf); |
4147 | if (stat != CAPS_SUCCESS) { |
4148 | printf(" CAPS Error: Bound %d caps_readInitObj = %d (caps_open)!\n", |
4149 | i, stat); |
4150 | EG_free(bound); |
4151 | fclose(fptxt); |
4152 | return stat; |
4153 | } |
4154 | problem->bounds[i]->blind = bound; |
4155 | stat = caps_readInitVSets(problem, problem->bounds[i]); |
4156 | if (stat != CAPS_SUCCESS) { |
4157 | printf(" CAPS Error: Bound %d caps_readInitVSets = %d (caps_open)!\n", |
4158 | i, stat); |
4159 | fclose(fptxt); |
4160 | return stat; |
4161 | } |
4162 | } |
4163 | } |
4164 | fclose(fptxt); |
4165 | } |
4166 | |
4167 | |
4168 | |
4169 | if (problem->nParam > 0) { |
4170 | problem->params = (capsObject **) |
4171 | EG_alloc(problem->nParam*sizeof(capsObject *)); |
4172 | if (problem->params == NULL) return EGADS_MALLOC; |
4173 | for (i = 0; i < problem->nParam; i++) problem->params[i] = NULL; |
4174 | for (i = 0; i < problem->nParam; i++) { |
4175 | stat = caps_makeVal(Integer, 1, &i, &value); |
4176 | if (stat != CAPS_SUCCESS) return stat; |
4177 | stat = caps_readInitObj(&problem->params[i], VALUE, PARAMETER, NULL, |
4178 | problem->mySelf); |
4179 | if (stat != CAPS_SUCCESS) { |
4180 | printf(" CAPS Error: Param %d caps_readInitObj = %d (caps_open)!\n", |
4181 | i, stat); |
4182 | |
4183 | EG_free(value); |
4184 | |
4185 | return stat; |
4186 | } |
4187 | |
4188 | problem->params[i]->blind = value; |
4189 | |
4190 | } |
4191 | } |
4192 | |
4193 | if (problem->nGeomIn > 0) { |
4194 | problem->geomIn = (capsObject **) |
4195 | EG_alloc(problem->nGeomIn*sizeof(capsObject *)); |
4196 | if (problem->geomIn == NULL) return EGADS_MALLOC; |
4197 | for (i = 0; i < problem->nGeomIn; i++) problem->geomIn[i] = NULL; |
4198 | value = (capsValue *) EG_alloc(problem->nGeomIn*sizeof(capsValue)); |
4199 | if (value == NULL) return EGADS_MALLOC; |
4200 | for (i = 0; i < problem->nGeomIn; i++) { |
4201 | value[i].nrow = 1; |
4202 | value[i].ncol = 1; |
4203 | value[i].type = Double; |
4204 | value[i].dim = Scalar; |
4205 | value[i].index = i+1; |
4206 | value[i].pIndex = 0; |
4207 | value[i].lfixed = value[i].sfixed = Fixed; |
4208 | value[i].nullVal = NotAllowed; |
4209 | value[i].units = NULL; |
4210 | value[i].meshWriter = NULL; |
4211 | value[i].link = NULL; |
4212 | value[i].vals.reals = NULL; |
4213 | value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0; |
4214 | value[i].linkMethod = Copy; |
4215 | value[i].length = 1; |
4216 | value[i].gInType = 0; |
4217 | value[i].partial = NULL; |
4218 | value[i].nderiv = 0; |
4219 | value[i].derivs = NULL; |
4220 | } |
4221 | for (i = 0; i < problem->nGeomIn; i++) { |
4222 | stat = caps_readInitObj(&problem->geomIn[i], VALUE, GEOMETRYIN, NULL, |
4223 | problem->mySelf); |
4224 | if (stat != CAPS_SUCCESS) { |
4225 | printf(" CAPS Error: GeomIn %d caps_readInitObj = %d (caps_open)!\n", |
4226 | i, stat); |
4227 | EG_free(value); |
4228 | EG_free(problem->geomIn); |
4229 | problem->geomIn = NULL; |
4230 | return stat; |
4231 | } |
4232 | |
4233 | problem->geomIn[i]->blind = &value[i]; |
4234 | |
4235 | } |
4236 | } |
4237 | |
4238 | if (problem->nGeomOut > 0) { |
4239 | problem->geomOut = (capsObject **) |
4240 | EG_alloc(problem->nGeomOut*sizeof(capsObject *)); |
4241 | if (problem->geomOut == NULL) return EGADS_MALLOC; |
4242 | for (i = 0; i < problem->nGeomOut; i++) problem->geomOut[i] = NULL; |
4243 | value = (capsValue *) EG_alloc(problem->nGeomOut*sizeof(capsValue)); |
4244 | if (value == NULL) return EGADS_MALLOC; |
4245 | for (i = 0; i < problem->nGeomOut; i++) { |
4246 | value[i].length = 1; |
4247 | value[i].type = DoubleDeriv; |
4248 | value[i].nrow = 1; |
4249 | value[i].ncol = 1; |
4250 | value[i].dim = Scalar; |
4251 | value[i].index = i+1; |
4252 | value[i].pIndex = 0; |
4253 | value[i].lfixed = value[i].sfixed = Change; |
4254 | value[i].nullVal = IsNull; |
4255 | value[i].units = NULL; |
4256 | value[i].meshWriter = NULL; |
4257 | value[i].link = NULL; |
4258 | value[i].vals.reals = NULL; |
4259 | value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0; |
4260 | value[i].linkMethod = Copy; |
4261 | value[i].gInType = 0; |
4262 | value[i].partial = NULL; |
4263 | value[i].nderiv = 0; |
4264 | value[i].derivs = NULL; |
4265 | } |
4266 | for (i = 0; i < problem->nGeomOut; i++) { |
4267 | stat = caps_readInitObj(&problem->geomOut[i], VALUE, GEOMETRYOUT, NULL, |
4268 | problem->mySelf); |
4269 | if (stat != CAPS_SUCCESS) { |
4270 | printf(" CAPS Error: GeomOut %d caps_readInitObj = %d (caps_open)!\n", |
4271 | i, stat); |
4272 | EG_free(value); |
4273 | EG_free(problem->geomOut); |
4274 | problem->geomOut = NULL; |
4275 | return stat; |
4276 | } |
4277 | |
4278 | problem->geomOut[i]->blind = &value[i]; |
4279 | |
4280 | } |
4281 | } |
4282 | |
4283 | |
4284 | |
4285 | if (problem->params != NULL) { |
4286 | for (i = 0; i < problem->nParam; i++) { |
4287 | #ifdef WIN32 |
4288 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\VP-%4.4d", |
4289 | problem->root, i+1); |
4290 | #else |
4291 | snprintf(filename, PATH_MAX, "%s/capsRestart/VP-%4.4d", |
4292 | problem->root, i+1); |
4293 | #endif |
4294 | fp = fopen(filename, "rb"); |
4295 | if (fp == NULL) { |
4296 | printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename); |
4297 | return CAPS_DIRERR; |
4298 | } |
4299 | stat = caps_readValue(fp, problem, problem->params[i]); |
4300 | fclose(fp); |
4301 | if (stat != CAPS_SUCCESS) { |
4302 | printf(" CAPS Error: parameter %d/%d readValue = %d (caps_open)!\n", |
4303 | i+1, problem->nParam, stat); |
4304 | return stat; |
4305 | } |
4306 | } |
4307 | } |
4308 | |
4309 | if (problem->geomIn != NULL) { |
4310 | for (i = 0; i < problem->nGeomIn; i++) { |
4311 | #ifdef WIN32 |
4312 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\VI-%4.4d", |
4313 | problem->root, i+1); |
4314 | #else |
4315 | snprintf(filename, PATH_MAX, "%s/capsRestart/VI-%4.4d", |
4316 | problem->root, i+1); |
4317 | #endif |
4318 | fp = fopen(filename, "rb"); |
4319 | if (fp == NULL) { |
4320 | printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename); |
4321 | return CAPS_DIRERR; |
4322 | } |
4323 | stat = caps_readValue(fp, problem, problem->geomIn[i]); |
4324 | fclose(fp); |
4325 | if (stat != CAPS_SUCCESS) { |
4326 | printf(" CAPS Error: geomIn %d/%d readValue = %d (caps_open)!\n", |
4327 | i+1, problem->nGeomIn, stat); |
4328 | return stat; |
4329 | } |
4330 | } |
4331 | } |
4332 | |
4333 | if (problem->geomOut != NULL) { |
4334 | for (i = 0; i < problem->nGeomOut; i++) { |
4335 | #ifdef WIN32 |
4336 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\VO-%4.4d", |
4337 | problem->root, i+1); |
4338 | #else |
4339 | snprintf(filename, PATH_MAX, "%s/capsRestart/VO-%4.4d", |
4340 | problem->root, i+1); |
4341 | #endif |
4342 | fp = fopen(filename, "rb"); |
4343 | if (fp == NULL) { |
4344 | printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename); |
4345 | return CAPS_DIRERR; |
4346 | } |
4347 | stat = caps_readValue(fp, problem, problem->geomOut[i]); |
4348 | fclose(fp); |
4349 | if (stat != CAPS_SUCCESS) { |
4350 | printf(" CAPS Error: geomOut %d/%d readValue = %d (caps_open)!\n", |
4351 | i+1, problem->nGeomOut, stat); |
4352 | return stat; |
4353 | } |
4354 | } |
4355 | } |
4356 | |
4357 | if (problem->analysis != NULL) { |
4358 | for (i = 0; i < problem->nAnalysis; i++) { |
4359 | stat = caps_readAnalysis(problem, problem->analysis[i]); |
4360 | if (stat != CAPS_SUCCESS) { |
4361 | printf(" CAPS Error: Analysis %d/%d readAnalysis = %d (caps_open)!\n", |
4362 | i+1, problem->nAnalysis, stat); |
4363 | return stat; |
4364 | } |
4365 | } |
4366 | } |
4367 | |
4368 | if (problem->bounds != NULL) { |
4369 | for (i = 0; i < problem->nBound; i++) { |
4370 | stat = caps_readBound(problem->bounds[i]); |
4371 | if (stat != CAPS_SUCCESS) { |
4372 | printf(" CAPS Error: bound index %d -- readBound = %d (caps_open)!\n", |
4373 | i+1, stat); |
4374 | return stat; |
4375 | } |
4376 | } |
4377 | } |
4378 | |
4379 | return CAPS_SUCCESS; |
4380 | |
4381 | readerr: |
4382 | fclose(fp); |
4383 | return CAPS_IOERR; |
4384 | } |
4385 | |
4386 | |
4387 | int |
4388 | caps_close(capsObject *pobject, int complete, const char *phName) |
4389 | { |
4390 | int i, j, stat, state, npts; |
4391 | char path[PATH_MAX]; |
4392 | ego model, body; |
4393 | capsProblem *problem; |
4394 | capsAnalysis *analysis; |
4395 | FILE *fp; |
4396 | |
4397 | if (pobject == NULL) return CAPS_NULLOBJ; |
4398 | if (pobject->magicnumber != CAPSMAGIC) return CAPS_BADOBJECT; |
4399 | if (pobject->type != PROBLEM) return CAPS_BADTYPE; |
4400 | if (pobject->blind == NULL) return CAPS_NULLBLIND; |
4401 | stat = caps_writeProblem(pobject); |
4402 | if (stat != CAPS_SUCCESS) |
4403 | printf(" CAPS Warning: caps_writeProblem = %d (caps_close)!\n", stat); |
4404 | problem = (capsProblem *) pobject->blind; |
4405 | problem->funID = CAPS_CLOSE; |
4406 | if (problem->jrnl != NULL) fclose(problem->jrnl); |
4407 | |
4408 | if (complete == 1) { |
4409 | #ifdef WIN32 |
4410 | snprintf(path, PATH_MAX, "%s\\capsClosed", problem->root); |
4411 | #else |
4412 | snprintf(path, PATH_MAX, "%s/capsClosed", problem->root); |
4413 | #endif |
4414 | fp = fopen(path, "w"); |
4415 | if (fp == NULL) { |
4416 | printf(" CAPS Warning: Failed to open capsClosed!\n"); |
4417 | } else { |
4418 | fclose(fp); |
4419 | } |
4420 | } |
4421 | |
4422 | if ((phName != NULL) && (complete == 1)) { |
4423 | if (problem->phName == NULL) { |
4424 | #ifdef WIN32 |
4425 | snprintf(path, PATH_MAX, "%s\\..\\%s", problem->root, phName); |
4426 | #else |
4427 | snprintf(path, PATH_MAX, "%s/../%s", problem->root, phName); |
4428 | #endif |
4429 | caps_prunePath(path); |
4430 | stat = caps_statFile(path); |
4431 | if (stat != EGADS_NOTFOUND) { |
4432 | printf(" CAPS Warning: %s is not empty -- not renamed!\n", path); |
4433 | } else { |
4434 | stat = caps_rename(problem->root, path); |
4435 | if (stat != CAPS_SUCCESS) { |
4436 | printf(" CAPS Warning: Cannot rename %s!\n", path); |
4437 | return stat; |
4438 | } |
4439 | } |
4440 | } else { |
4441 | printf("CAPS Warning: New Phase Name not available for nonScratch!\n"); |
4442 | } |
4443 | } |
4444 | |
4445 | |
4446 | caps_rmLockOnClose(problem->root); |
4447 | |
4448 | if (problem->phName != NULL) EG_free(problem->phName); |
4449 | if (problem->lunits != NULL) { |
4450 | for (i = 0; i < problem->nBodies; i++) |
4451 | if (problem->lunits[i] != NULL) EG_free(problem->lunits[i]); |
4452 | EG_free(problem->lunits); |
4453 | } |
4454 | caps_freeFList(pobject); |
4455 | caps_freeOwner(&problem->writer); |
4456 | caps_freeOwner(&problem->geometry); |
4457 | |
4458 | |
4459 | if (problem->modl != NULL) { |
4460 | if (pobject->subtype == PARAMETRIC) { |
4461 | if (problem->analysis != NULL) { |
4462 | for (i = 0; i < problem->nAnalysis; i++) { |
4463 | analysis = (capsAnalysis *) problem->analysis[i]->blind; |
4464 | if (analysis == NULL) continue; |
4465 | if (analysis->tess != NULL) { |
4466 | for (j = 0; j < analysis->nTess; j++) |
4467 | if (analysis->tess[j] != NULL) { |
4468 | |
4469 | body = NULL; |
4470 | if (j >= analysis->nBody) { |
4471 | stat = EG_statusTessBody(analysis->tess[j], &body, &state, |
4472 | &npts); |
4473 | if (stat < EGADS_SUCCESS) return stat; |
4474 | if (stat == EGADS_OUTSIDE) return CAPS_SOURCEERR; |
4475 | } |
4476 | EG_deleteObject(analysis->tess[j]); |
4477 | if (body != NULL) EG_deleteObject(body); |
4478 | analysis->tess[j] = NULL; |
4479 | } |
4480 | EG_free(analysis->tess); |
4481 | analysis->tess = NULL; |
4482 | analysis->nTess = 0; |
4483 | } |
4484 | } |
4485 | } |
4486 | if (problem->stFlag != 1) { |
4487 | |
4488 | ocsmFree(problem->modl); |
4489 | } |
4490 | if (problem->bodies != NULL) EG_free(problem->bodies); |
4491 | } else { |
4492 | if (problem->stFlag != 2) { |
4493 | model = (ego) problem->modl; |
4494 | EG_deleteObject(model); |
4495 | } |
4496 | } |
4497 | } |
4498 | |
4499 | |
4500 | caps_freeValueObjects(1, problem->nParam, problem->params); |
4501 | caps_freeValueObjects(0, problem->nGeomIn, problem->geomIn); |
4502 | caps_freeValueObjects(0, problem->nGeomOut, problem->geomOut); |
4503 | |
4504 | if (problem->bounds != NULL) { |
4505 | while (problem->nBound > 0) caps_delete(problem->bounds[0]); |
4506 | EG_free(problem->bounds); |
4507 | } |
4508 | |
4509 | if (problem->regGIN != NULL) { |
4510 | for (i = 0; i < problem->nRegGIN; i++) EG_free(problem->regGIN[i].name); |
4511 | EG_free(problem->regGIN); |
4512 | } |
4513 | |
4514 | |
4515 | if (problem->analysis != NULL) { |
4516 | for (i = 0; i < problem->nAnalysis; i++) { |
4517 | caps_freeFList(problem->analysis[i]); |
4518 | analysis = (capsAnalysis *) problem->analysis[i]->blind; |
4519 | caps_freeAnalysis(0, analysis); |
4520 | caps_freeOwner(&problem->analysis[i]->last); |
4521 | caps_freeAttrs(&problem->analysis[i]->attrs); |
4522 | problem->analysis[i]->magicnumber = 0; |
4523 | EG_free(problem->analysis[i]->name); |
4524 | problem->analysis[i]->name = NULL; |
4525 | EG_free(problem->analysis[i]); |
4526 | } |
4527 | EG_free(problem->analysis); |
4528 | } |
4529 | |
4530 | |
4531 | aim_cleanupAll(&problem->aimFPTR); |
4532 | |
4533 | |
4534 | if (problem->root != NULL) EG_free(problem->root); |
4535 | if ((problem->context != NULL) && (problem->stFlag != 2)) |
4536 | EG_close(problem->context); |
4537 | EG_free(problem->execs); |
4538 | EG_free(problem); |
4539 | |
4540 | |
4541 | caps_freeAttrs(&pobject->attrs); |
4542 | caps_freeOwner(&pobject->last); |
4543 | pobject->magicnumber = 0; |
4544 | EG_free(pobject->name); |
4545 | pobject->name = NULL; |
4546 | EG_free(pobject); |
4547 | |
4548 | return CAPS_SUCCESS; |
4549 | } |
4550 | |
4551 | |
4552 | int |
4553 | caps_phaseState(const char *prPath, const char *phName, int *bFlag) |
4554 | { |
4555 | int i, n, len, status; |
4556 | char root[PATH_MAX], current[PATH_MAX]; |
4557 | const char *prName; |
4558 | |
4559 | *bFlag = 0; |
4560 | if (prPath == NULL) return CAPS_NULLNAME; |
4561 | if (phName != NULL) { |
4562 | if (strcmp(phName, "Scratch") == 0) { |
4563 | printf(" CAPS Error: Cannot use the phase Scratch!\n"); |
4564 | return CAPS_BADNAME; |
4565 | } |
4566 | len = strlen(phName); |
4567 | for (i = 0; i < len; i++) |
4568 | if ((phName[i] == '/') || (phName[i] == '\\')) { |
4569 | printf(" CAPS Error: Cannot use slashes in phase name: %s\n", phName); |
4570 | return CAPS_BADNAME; |
4571 | } |
4572 | } |
4573 | |
4574 | |
4575 | len = strlen(prPath); |
4576 | for (i = len-1; i > 0; i--) |
4577 | if ((prPath[i] == '/') || (prPath[i] == '\\')) break; |
4578 | if (i != 0) i++; |
4579 | prName = &prPath[i]; |
4580 | status = caps_isNameOK(prName); |
4581 | if (status != CAPS_SUCCESS) { |
4582 | printf(" CAPS Error: %s is not a valid Problem Name!\n", prName); |
4583 | return status; |
4584 | } |
4585 | n = -1; |
4586 | #ifdef WIN32 |
4587 | |
4588 | if (prPath[1] == ':') { |
4589 | int drive, oldrive; |
4590 | if (prPath[0] >= 97) { |
4591 | drive = prPath[0] - 96; |
4592 | } else { |
4593 | drive = prPath[0] - 64; |
4594 | } |
4595 | oldrive = _getdrive(); |
4596 | status = _chdrive(drive); |
4597 | if (status == -1) { |
4598 | printf(" CAPS Error: Cannot change drive to %c!\n", prPath[0]); |
4599 | return CAPS_DIRERR; |
4600 | } |
4601 | (void) _chdrive(oldrive); |
4602 | n = 0; |
4603 | } |
4604 | #endif |
4605 | if (n == -1) |
4606 | if ((prPath[0] == '/') || (prPath[0] == '\\')) n = 0; |
4607 | if (n == 0) { |
4608 | |
4609 | status = caps_statFile(prPath); |
4610 | if (status == EGADS_SUCCESS) { |
4611 | printf(" CAPS Info: %s lands on a flat file!\n", prPath); |
4612 | return CAPS_DIRERR; |
4613 | } else if (status == EGADS_NOTFOUND) { |
4614 | printf(" CAPS Info: Path %s does not exist\n", prPath); |
4615 | return status; |
4616 | } |
4617 | #ifdef WIN32 |
4618 | if (prPath[1] == ':') { |
4619 | if (phName == NULL) { |
4620 | snprintf(root, PATH_MAX, "%s\\Scratch", prPath); |
4621 | } else { |
4622 | snprintf(root, PATH_MAX, "%s\\%s", prPath, phName); |
4623 | } |
4624 | } else { |
4625 | if (phName == NULL) { |
4626 | snprintf(root, PATH_MAX, "%c:%s\\Scratch", _getdrive()+64, prPath); |
4627 | } else { |
4628 | snprintf(root, PATH_MAX, "%c:%s\\%s", _getdrive()+64, prPath, phName); |
4629 | } |
4630 | } |
4631 | #else |
4632 | if (phName == NULL) { |
4633 | snprintf(root, PATH_MAX, "%s/Scratch", prPath); |
4634 | } else { |
4635 | snprintf(root, PATH_MAX, "%s/%s", prPath, phName); |
4636 | } |
4637 | #endif |
4638 | } else { |
4639 | |
4640 | (void) getcwd(current, PATH_MAX); |
4641 | #ifdef WIN32 |
4642 | snprintf(root, PATH_MAX, "%s\\%s", current, prPath); |
4643 | #else |
4644 | snprintf(root, PATH_MAX, "%s/%s", current, prPath); |
4645 | #endif |
4646 | status = caps_statFile(root); |
4647 | if (status == EGADS_SUCCESS) { |
4648 | printf(" CAPS Info: Path %s lands on a flat file\n", root); |
4649 | return status; |
4650 | } else if (status == EGADS_NOTFOUND) { |
4651 | printf(" CAPS Info: Path %s does not exist\n", root); |
4652 | return status; |
4653 | } |
4654 | #ifdef WIN32 |
4655 | if (phName == NULL) { |
4656 | snprintf(root, PATH_MAX, "%s\\%s\\Scratch", current, prPath); |
4657 | } else { |
4658 | snprintf(root, PATH_MAX, "%s\\%s\\%s", current, prPath, phName); |
4659 | } |
4660 | #else |
4661 | if (phName == NULL) { |
4662 | snprintf(root, PATH_MAX, "%s/%s/Scratch", current, prPath); |
4663 | } else { |
4664 | snprintf(root, PATH_MAX, "%s/%s/%s", current, prPath, phName); |
4665 | } |
4666 | #endif |
4667 | } |
4668 | caps_prunePath(root); |
4669 | status = caps_statFile(root); |
4670 | if (status == EGADS_SUCCESS) { |
4671 | printf(" CAPS Info: Path %s lands on a flat file\n", root); |
4672 | return status; |
4673 | } else if (status == EGADS_NOTFOUND) { |
4674 | printf(" CAPS Info: Path %s does not exist\n", root); |
4675 | return status; |
4676 | } |
4677 | |
4678 | #ifdef WIN32 |
4679 | snprintf(current, PATH_MAX, "%s\\capsLock", root); |
4680 | #else |
4681 | snprintf(current, PATH_MAX, "%s/capsLock", root); |
4682 | #endif |
4683 | status = caps_statFile(current); |
4684 | if (status == EGADS_SUCCESS) *bFlag += 1; |
4685 | |
4686 | #ifdef WIN32 |
4687 | snprintf(current, PATH_MAX, "%s\\capsClosed", root); |
4688 | #else |
4689 | snprintf(current, PATH_MAX, "%s/capsClosed", root); |
4690 | #endif |
4691 | status = caps_statFile(current); |
4692 | if (status == EGADS_SUCCESS) *bFlag += 2; |
4693 | |
4694 | return CAPS_SUCCESS; |
4695 | } |
4696 | |
4697 | |
4698 | int |
4699 | caps_journalState(const capsObject *pobject) |
4700 | { |
4701 | capsProblem *problem; |
4702 | |
4703 | if (pobject == NULL) return CAPS_NULLOBJ; |
4704 | if (pobject->magicnumber != CAPSMAGIC) return CAPS_BADOBJECT; |
4705 | if (pobject->type != PROBLEM) return CAPS_BADTYPE; |
4706 | if (pobject->blind == NULL) return CAPS_NULLBLIND; |
4707 | problem = (capsProblem *) pobject->blind; |
4708 | |
4709 | return problem->stFlag; |
4710 | } |
4711 | |
4712 | |
4713 | int |
4714 | caps_build(capsObject *pobject, int *nErr, capsErrs **errors) |
4715 | { |
4716 | int i, j, k, m, n, stat, status, gstatus, state, npts; |
4717 | int type, nrow, ncol, buildTo, builtTo, nbody, ibody; |
4718 | char name[MAX_NAME_LEN], error[129], vstr[MAX_STRVAL_LEN], *units; |
4719 | double dot, *values; |
4720 | ego body; |
4721 | modl_T *MODL; |
4722 | capsValue *value; |
4723 | capsProblem *problem; |
4724 | capsAnalysis *analy; |
4725 | capsObject *source, *object, *last; |
4726 | capsErrs *errs; |
4727 | |
4728 | *nErr = 0; |
4729 | *errors = NULL; |
4730 | if (pobject == NULL) return CAPS_NULLOBJ; |
4731 | if (pobject->magicnumber != CAPSMAGIC) return CAPS_BADOBJECT; |
4732 | if (pobject->type != PROBLEM) return CAPS_BADOBJECT; |
4733 | if (pobject->blind == NULL) return CAPS_NULLBLIND; |
4734 | problem = (capsProblem *) pobject->blind; |
4735 | |
4736 | |
4737 | if (pobject->subtype == STATIC) return CAPS_CLEAN; |
4738 | |
4739 | |
4740 | |
4741 | gstatus = 0; |
4742 | for (i = 0; i < problem->nGeomIn; i++) { |
4743 | source = object = problem->geomIn[i]; |
4744 | do { |
4745 | if (source->magicnumber != CAPSMAGIC) return CAPS_BADOBJECT; |
4746 | if (source->type != VALUE) return CAPS_BADTYPE; |
4747 | if (source->blind == NULL) return CAPS_NULLBLIND; |
4748 | value = (capsValue *) source->blind; |
4749 | if (value->link == object) return CAPS_CIRCULARLINK; |
4750 | last = source; |
4751 | source = value->link; |
4752 | } while (value->link != NULL); |
4753 | if (last->last.sNum > problem->geometry.sNum) { |
4754 | gstatus = 1; |
4755 | break; |
4756 | } |
4757 | } |
4758 | if ((gstatus == 0) && (problem->geometry.sNum > 0)) return CAPS_CLEAN; |
4759 | |
4760 | |
4761 | MODL = (modl_T *) problem->modl; |
4762 | MODL->context = problem->context; |
4763 | MODL->userdata = problem; |
4764 | |
4765 | |
4766 | |
4767 | |
4768 | if (problem->bodies != NULL) { |
4769 | for (i = 0; i < problem->nBodies; i++) |
4770 | if (problem->lunits[i] != NULL) EG_free(problem->lunits[i]); |
4771 | |
4772 | for (i = 0; i < problem->nAnalysis; i++) { |
4773 | analy = (capsAnalysis *) problem->analysis[i]->blind; |
4774 | if (analy == NULL) continue; |
4775 | if (analy->tess != NULL) { |
4776 | for (j = 0; j < analy->nTess; j++) |
4777 | if (analy->tess[j] != NULL) { |
4778 | |
4779 | body = NULL; |
4780 | if (j >= analy->nBody) { |
4781 | stat = EG_statusTessBody(analy->tess[j], &body, &state, &npts); |
4782 | if (stat < EGADS_SUCCESS) return stat; |
4783 | if (stat == EGADS_OUTSIDE) return CAPS_SOURCEERR; |
4784 | } |
4785 | EG_deleteObject(analy->tess[j]); |
4786 | if (body != NULL) EG_deleteObject(body); |
4787 | analy->tess[j] = NULL; |
4788 | } |
4789 | EG_free(analy->tess); |
4790 | analy->tess = NULL; |
4791 | analy->nTess = 0; |
4792 | } |
4793 | if (analy->bodies != NULL) { |
4794 | EG_free(analy->bodies); |
4795 | analy->bodies = NULL; |
4796 | analy->nBody = 0; |
4797 | } |
4798 | |
4799 | analy->info.pIndex = 0; |
4800 | analy->info.irow = 0; |
4801 | analy->info.icol = 0; |
4802 | } |
4803 | EG_free(problem->bodies); |
4804 | EG_free(problem->lunits); |
4805 | problem->nBodies = 0; |
4806 | problem->bodies = NULL; |
4807 | problem->lunits = NULL; |
4808 | problem->geometry.sNum = 0; |
4809 | } |
4810 | buildTo = 0; |
4811 | nbody = 0; |
4812 | status = ocsmBuild(problem->modl, buildTo, &builtTo, &nbody, NULL); |
4813 | fflush(stdout); |
4814 | if (status != SUCCESS) { |
4815 | caps_makeSimpleErr(pobject, CERROR, |
4816 | "caps_build Error: ocsmBuild fails!", |
4817 | NULL, NULL, errors); |
4818 | if (*errors != NULL) { |
4819 | errs = *errors; |
4820 | *nErr = errs->nError; |
4821 | } |
4822 | return status; |
4823 | } |
4824 | nbody = 0; |
4825 | for (ibody = 1; ibody <= MODL->nbody; ibody++) { |
4826 | if (MODL->body[ibody].onstack != 1) continue; |
4827 | if (MODL->body[ibody].botype == OCSM_NULL_BODY) continue; |
4828 | nbody++; |
4829 | } |
4830 | |
4831 | units = NULL; |
4832 | if (nbody > 0) { |
4833 | problem->lunits = (char **) EG_alloc(nbody*sizeof(char *)); |
4834 | problem->bodies = (ego *) EG_alloc(nbody*sizeof(ego)); |
4835 | if ((problem->bodies == NULL) || (problem->lunits == NULL)) { |
4836 | if (problem->bodies != NULL) EG_free(problem->bodies); |
4837 | if (problem->lunits != NULL) EG_free(problem->lunits); |
4838 | for (ibody = 1; ibody <= MODL->nbody; ibody++) { |
4839 | if (MODL->body[ibody].onstack != 1) continue; |
4840 | if (MODL->body[ibody].botype == OCSM_NULL_BODY) continue; |
4841 | EG_deleteObject(MODL->body[ibody].ebody); |
4842 | } |
4843 | caps_makeSimpleErr(pobject, CERROR, |
4844 | "caps_build: Error on Body memory allocation!", |
4845 | NULL, NULL, errors); |
4846 | if (*errors != NULL) { |
4847 | errs = *errors; |
4848 | *nErr = errs->nError; |
4849 | } |
4850 | return EGADS_MALLOC; |
4851 | } |
4852 | problem->nBodies = nbody; |
4853 | i = 0; |
4854 | for (ibody = 1; ibody <= MODL->nbody; ibody++) { |
4855 | if (MODL->body[ibody].onstack != 1) continue; |
4856 | if (MODL->body[ibody].botype == OCSM_NULL_BODY) continue; |
4857 | problem->bodies[i] = MODL->body[ibody].ebody; |
4858 | caps_fillLengthUnits(problem, problem->bodies[i], &problem->lunits[i]); |
4859 | i++; |
4860 | } |
4861 | units = problem->lunits[nbody-1]; |
4862 | } |
4863 | caps_freeOwner(&problem->geometry); |
4864 | problem->sNum += 1; |
4865 | problem->geometry.sNum = problem->sNum; |
4866 | caps_fillDateTime(problem->geometry.datetime); |
4867 | |
4868 | |
4869 | if (problem->regGIN != NULL) { |
4870 | for (i = 0; i < problem->nRegGIN; i++) EG_free(problem->regGIN[i].name); |
4871 | EG_free(problem->regGIN); |
4872 | problem->regGIN = NULL; |
4873 | problem->nRegGIN = 0; |
4874 | } |
4875 | |
4876 | |
4877 | for (i = 0; i < problem->nGeomOut; i++) { |
4878 | if (problem->geomOut[i]->magicnumber != CAPSMAGIC) continue; |
4879 | if (problem->geomOut[i]->type != VALUE) continue; |
4880 | if (problem->geomOut[i]->blind == NULL) continue; |
4881 | value = (capsValue *) problem->geomOut[i]->blind; |
4882 | if (value->derivs != NULL) { |
4883 | |
4884 | for (j = 0; j < value->nderiv; j++) { |
4885 | if (value->derivs[j].name != NULL) EG_free(value->derivs[j].name); |
4886 | if (value->derivs[j].deriv != NULL) EG_free(value->derivs[j].deriv); |
4887 | } |
4888 | EG_free(value->derivs); |
4889 | value->derivs = NULL; |
4890 | value->nderiv = 0; |
4891 | } |
4892 | if (value->type == String) { |
4893 | EG_free(value->vals.string); |
4894 | value->vals.string = NULL; |
4895 | } else { |
4896 | if (value->length != 1) |
4897 | EG_free(value->vals.reals); |
4898 | value->vals.reals = NULL; |
4899 | } |
4900 | if (value->partial != NULL) { |
4901 | EG_free(value->partial); |
4902 | value->partial = NULL; |
4903 | } |
4904 | status = ocsmGetPmtr(problem->modl, value->pIndex, &type, &nrow, &ncol, |
4905 | name); |
4906 | if (status != SUCCESS) { |
4907 | snprintf(error, 129, "Cannot get info on Output %s", |
4908 | problem->geomOut[i]->name); |
4909 | caps_makeSimpleErr(problem->geomOut[i], CERROR, |
4910 | "caps_build Error: ocsmGetPmtr fails!", |
4911 | error, NULL, errors); |
4912 | if (*errors != NULL) { |
4913 | errs = *errors; |
4914 | *nErr = errs->nError; |
4915 | } |
4916 | return status; |
4917 | } |
4918 | if (strcmp(name,problem->geomOut[i]->name) != 0) { |
4919 | snprintf(error, 129, "Cannot Geom Output[%d] %s != %s", |
4920 | i, problem->geomOut[i]->name, name); |
4921 | caps_makeSimpleErr(problem->geomOut[i], CERROR, |
4922 | "caps_build Error: ocsmGetPmtr MisMatch!", |
4923 | error, NULL, errors); |
4924 | if (*errors != NULL) { |
4925 | errs = *errors; |
4926 | *nErr = errs->nError; |
4927 | } |
4928 | return CAPS_MISMATCH; |
4929 | } |
4930 | if ((nrow == 0) || (ncol == 0)) { |
4931 | status = ocsmGetValuS(problem->modl, value->pIndex, vstr); |
4932 | if (status != SUCCESS) { |
4933 | snprintf(error, 129, "Cannot get string on Output %s", |
4934 | problem->geomOut[i]->name); |
4935 | caps_makeSimpleErr(problem->geomOut[i], CERROR, |
4936 | "caps_build Error: ocsmGetValuSfails!", |
4937 | error, NULL, errors); |
4938 | if (*errors != NULL) { |
4939 | errs = *errors; |
4940 | *nErr = errs->nError; |
4941 | } |
4942 | return status; |
4943 | } |
4944 | value->nullVal = NotNull; |
4945 | value->type = String; |
4946 | value->length = 1; |
4947 | value->nrow = 1; |
4948 | value->ncol = 1; |
4949 | value->dim = Scalar; |
4950 | value->vals.string = EG_strdup(vstr); |
4951 | if (value->vals.string == NULL) value->nullVal = IsNull; |
4952 | } else { |
4953 | value->nullVal = NotNull; |
4954 | value->type = DoubleDeriv; |
4955 | value->nrow = nrow; |
4956 | value->ncol = ncol; |
4957 | value->length = nrow*ncol; |
4958 | value->dim = Scalar; |
4959 | if ((nrow > 1) || (ncol > 1)) value->dim = Vector; |
4960 | if ((nrow > 1) && (ncol > 1)) value->dim = Array2D; |
4961 | if (value->length == 1) { |
4962 | values = &value->vals.real; |
4963 | } else { |
4964 | values = (double *) EG_alloc(value->length*sizeof(double)); |
4965 | if (values == NULL) { |
4966 | value->nullVal = IsNull; |
4967 | snprintf(error, 129, "length = %d doubles for %s", |
4968 | value->length, problem->geomOut[i]->name); |
4969 | caps_makeSimpleErr(problem->geomOut[i], CERROR, |
4970 | "caps_build Error: Memory Allocation fails!", |
4971 | error, NULL, errors); |
4972 | if (*errors != NULL) { |
4973 | errs = *errors; |
4974 | *nErr = errs->nError; |
4975 | } |
4976 | return EGADS_MALLOC; |
4977 | } |
4978 | value->vals.reals = values; |
4979 | } |
4980 | |
4981 | |
4982 | |
4983 | for (n = m = k = 0; k < nrow; k++) |
4984 | for (j = 0; j < ncol; j++, n++) { |
4985 | status = ocsmGetValu(problem->modl, value->pIndex, k+1, j+1, |
4986 | &values[n], &dot); |
4987 | if (status != SUCCESS) { |
4988 | snprintf(error, 129, "irow = %d icol = %d on %s", |
4989 | k+1, j+1, problem->geomOut[i]->name); |
4990 | caps_makeSimpleErr(problem->geomOut[i], CERROR, |
4991 | "caps_build Error: Output ocsmGetValu fails!", |
4992 | error, NULL, errors); |
4993 | if (*errors != NULL) { |
4994 | errs = *errors; |
4995 | *nErr = errs->nError; |
4996 | } |
4997 | return status; |
4998 | } |
4999 | if (values[n] == -HUGEQ) m++; |
5000 | } |
5001 | if (m != 0) { |
5002 | value->nullVal = IsNull; |
5003 | if (m != nrow*ncol) { |
5004 | value->partial = (int *) EG_alloc(nrow*ncol*sizeof(int)); |
5005 | if (value->partial == NULL) { |
5006 | snprintf(error, 129, "nrow = %d ncol = %d on %s", |
5007 | nrow, ncol, problem->geomOut[i]->name); |
5008 | caps_makeSimpleErr(problem->geomOut[i], CERROR, |
5009 | "caps_build Error: Alloc of partial fails!", |
5010 | error, NULL, errors); |
5011 | if (*errors != NULL) { |
5012 | errs = *errors; |
5013 | *nErr = errs->nError; |
5014 | } |
5015 | return EGADS_MALLOC; |
5016 | } |
5017 | for (n = k = 0; k < nrow; k++) |
5018 | for (j = 0; j < ncol; j++, n++) { |
5019 | value->partial[n] = NotNull; |
5020 | if (values[n] == -HUGEQ) value->partial[n] = IsNull; |
5021 | } |
5022 | value->nullVal = IsPartial; |
5023 | } |
5024 | } |
5025 | } |
5026 | |
5027 | if (value->units != NULL) EG_free(value->units); |
5028 | value->units = NULL; |
5029 | caps_geomOutUnits(name, units, &value->units); |
5030 | |
5031 | caps_freeOwner(&problem->geomOut[i]->last); |
5032 | problem->geomOut[i]->last.sNum = problem->sNum; |
5033 | caps_fillDateTime(problem->geomOut[i]->last.datetime); |
5034 | } |
5035 | |
5036 | |
5037 | status = caps_writeProblem(pobject); |
5038 | if (status != CAPS_SUCCESS) |
5039 | printf(" CAPS Warning: caps_writeProblem = %d (caps_build)\n", status); |
5040 | status = caps_dumpGeomVals(problem, 2); |
5041 | if (status != CAPS_SUCCESS) |
5042 | printf(" CAPS Warning: caps_dumpGeomVals = %d (caps_build)\n", status); |
5043 | |
5044 | if (problem->nBodies == 0) |
5045 | printf(" CAPS Warning: No bodies generated (caps_build)!\n"); |
5046 | |
5047 | return CAPS_SUCCESS; |
5048 | } |
5049 | |
5050 | |
5051 | int |
5052 | caps_brokenLink( blCB callBack) |
5053 | { |
5054 | CAPScallBack = callBack; |
5055 | return CAPS_SUCCESS; |
5056 | } |
5057 | |
5058 | |
5059 | static void |
5060 | caps_findGeomVal(int nObjs, capsObject **objects, int index, const char *name, |
5061 | int *n) |
5062 | { |
5063 | int i; |
5064 | |
5065 | *n = -1; |
5066 | |
5067 | |
5068 | if (index < nObjs) |
5069 | if (objects[index]->name != NULL) |
5070 | if (strcmp(name,objects[index]->name) == 0) { |
5071 | *n = index; |
5072 | return; |
5073 | } |
5074 | |
5075 | |
5076 | for (i = 0; i < nObjs; i++) |
5077 | if (objects[i]->name != NULL) |
5078 | if (strcmp(name,objects[i]->name) == 0) { |
5079 | *n = index; |
5080 | return; |
5081 | } |
5082 | |
5083 | } |
5084 | |
5085 | |
5086 | static int |
5087 | caps_phaseCSMreload(capsObject *object, int *nErr, capsErrs **errors) |
5088 | { |
5089 | int i, j, jj, k, n, status, nbrch, npmtr, nbody, ngOut, ngIn; |
5090 | int nrow, ncol, type, npts, state; |
5091 | char filename[PATH_MAX], current[PATH_MAX], temp[PATH_MAX], *env; |
5092 | char name[MAX_NAME_LEN], *units, *fileList; |
5093 | double dot, lower, upper, *reals; |
5094 | void *modl; |
5095 | ego body; |
5096 | capsObject *objs, **geomIn = NULL, **geomOut = NULL; |
5097 | capsValue *value, *val; |
5098 | capsProblem *problem; |
5099 | capsAnalysis *analysis; |
5100 | modl_T *MODL = NULL; |
5101 | FILE *fp; |
5102 | |
5103 | problem = (capsProblem *) object->blind; |
5104 | |
5105 | |
5106 | #ifdef WIN32 |
5107 | snprintf(filename, PATH_MAX, "%s\\capsCSMFilePath", problem->root); |
5108 | #else |
5109 | snprintf(filename, PATH_MAX, "%s/capsCSMFilePath", problem->root); |
5110 | #endif |
5111 | fp = fopen(filename, "r"); |
5112 | if (fp == NULL) { |
| 1 | Assuming 'fp' is not equal to NULL | |
|
| |
5113 | snprintf(temp, PATH_MAX, "Cannot open %s (caps_open)\n", filename); |
5114 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
5115 | if (*errors != NULL) *nErr = (*errors)->nError; |
5116 | return CAPS_IOERR; |
5117 | } |
5118 | for (i = 0; i < PATH_MAX; i++) { |
| 3 | | Loop condition is true. Entering loop body | |
|
5119 | fscanf(fp, "%c", ¤t[i]); |
5120 | if (current[i] == '|') break; |
| 4 | | Assuming the condition is true | |
|
| |
| 6 | | Execution continues on line 5122 | |
|
5121 | } |
5122 | fclose(fp); |
5123 | if (i == PATH_MAX) return CAPS_DIRERR; |
| |
5124 | current[i] = 0; |
5125 | |
5126 | |
5127 | status = ocsmLoad((char *) current, &modl); |
5128 | if (status < SUCCESS) { |
| 8 | | Assuming 'status' is >= SUCCESS | |
|
| |
5129 | snprintf(temp, PATH_MAX, "Cannot Load %s (caps_open)!", current); |
5130 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
5131 | if (*errors != NULL) *nErr = (*errors)->nError; |
5132 | return status; |
5133 | } |
5134 | MODL = (modl_T *) modl; |
5135 | if (MODL == NULL) { |
| 10 | | Assuming 'MODL' is not equal to NULL | |
|
| |
5136 | caps_makeSimpleErr(NULL, CERROR, "Cannot get OpenCSM MODL (caps_open)!", |
5137 | NULL, NULL, errors); |
5138 | if (*errors != NULL) *nErr = (*errors)->nError; |
5139 | return CAPS_NOTFOUND; |
5140 | } |
5141 | MODL->context = problem->context; |
5142 | |
5143 | MODL->userdata = problem; |
5144 | |
5145 | MODL->tessAtEnd = 0; |
5146 | env = getenv("DUMPEGADS"); |
5147 | if (env != NULL) { |
| 12 | | Assuming 'env' is equal to NULL | |
|
| |
5148 | MODL->dumpEgads = 1; |
5149 | MODL->loadEgads = 1; |
5150 | } |
5151 | |
5152 | |
5153 | status = ocsmCheck(modl); |
5154 | if (status < SUCCESS) { |
| 14 | | Assuming 'status' is >= SUCCESS | |
|
| |
5155 | snprintf(temp, PATH_MAX, "ocsmCheck = %d (caps_open)!", status); |
5156 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
5157 | if (*errors != NULL) *nErr = (*errors)->nError; |
5158 | ocsmFree(modl); |
5159 | return status; |
5160 | } |
5161 | fflush(stdout); |
5162 | |
5163 | |
5164 | status = ocsmInfo(modl, &nbrch, &npmtr, &nbody); |
5165 | if (status != SUCCESS) { |
| 16 | | Assuming 'status' is equal to SUCCESS | |
|
| |
5166 | snprintf(temp, PATH_MAX, "ocsmInfo returns %d (caps_open)!", status); |
5167 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
5168 | if (*errors != NULL) *nErr = (*errors)->nError; |
5169 | ocsmFree(modl); |
5170 | return status; |
5171 | } |
5172 | |
5173 | |
5174 | for (ngIn = ngOut = i = 0; i < npmtr; i++) { |
| 18 | | Assuming 'i' is < 'npmtr' | |
|
| 19 | | Loop condition is true. Entering loop body | |
|
| 28 | | Assuming 'i' is >= 'npmtr' | |
|
| 29 | | Loop condition is false. Execution continues on line 5187 | |
|
5175 | status = ocsmGetPmtr(modl, i+1, &type, &nrow, &ncol, name); |
5176 | if (status != SUCCESS) { |
| 20 | | Assuming 'status' is equal to SUCCESS | |
|
| |
5177 | ocsmFree(modl); |
5178 | return status; |
5179 | } |
5180 | if (type == OCSM_OUTPMTR) ngOut++; |
| 22 | | Assuming 'type' is not equal to OCSM_OUTPMTR | |
|
| |
5181 | if (type == OCSM_DESPMTR) ngIn++; |
| 24 | | Assuming 'type' is equal to OCSM_DESPMTR | |
|
| |
5182 | if (type == OCSM_CFGPMTR) ngIn++; |
| |
5183 | if (type == OCSM_CONPMTR) ngIn++; |
| |
5184 | } |
5185 | |
5186 | |
5187 | if (ngIn != 0) { |
| |
5188 | geomIn = (capsObject **) EG_alloc(ngIn*sizeof(capsObject *)); |
5189 | if (geomIn == NULL) { |
| 31 | | Assuming 'geomIn' is not equal to NULL | |
|
| |
5190 | return EGADS_MALLOC; |
5191 | } |
5192 | for (i = 0; i < ngIn; i++) geomIn[i] = NULL; |
| 33 | | Loop condition is true. Entering loop body | |
|
| 34 | | Storing null pointer value | |
|
| 35 | | Loop condition is false. Execution continues on line 5193 | |
|
5193 | value = (capsValue *) EG_alloc(ngIn*sizeof(capsValue)); |
5194 | if (value == NULL) { |
| 36 | | Assuming 'value' is not equal to NULL | |
|
| |
5195 | EG_free(geomIn); |
5196 | return EGADS_MALLOC; |
5197 | } |
5198 | for (i = j = 0; j < npmtr; j++) { |
| 38 | | Loop condition is true. Entering loop body | |
|
| 42 | | Loop condition is false. Execution continues on line 5250 | |
|
5199 | ocsmGetPmtr(modl, j+1, &type, &nrow, &ncol, name); |
5200 | if ((type != OCSM_DESPMTR) && (type != OCSM_CFGPMTR) && |
| 39 | | Assuming 'type' is equal to OCSM_DESPMTR | |
|
5201 | (type != OCSM_CONPMTR)) continue; |
5202 | if ((nrow == 0) || (ncol == 0)) continue; |
| 40 | | Assuming 'nrow' is equal to 0 | |
|
| 41 | | Execution continues on line 5198 | |
|
5203 | value[i].nrow = nrow; |
5204 | value[i].ncol = ncol; |
5205 | value[i].type = Double; |
5206 | value[i].dim = Scalar; |
5207 | value[i].index = i+1; |
5208 | value[i].pIndex = j+1; |
5209 | value[i].lfixed = value[i].sfixed = Fixed; |
5210 | value[i].nullVal = NotAllowed; |
5211 | value[i].units = NULL; |
5212 | value[i].meshWriter = NULL; |
5213 | value[i].link = NULL; |
5214 | value[i].vals.reals = NULL; |
5215 | value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0; |
5216 | value[i].linkMethod = Copy; |
5217 | value[i].length = value[i].nrow*value[i].ncol; |
5218 | if ((ncol > 1) && (nrow > 1)) { |
5219 | value[i].dim = Array2D; |
5220 | } else if ((ncol > 1) || (nrow > 1)) { |
5221 | value[i].dim = Vector; |
5222 | } |
5223 | value[i].gInType = 0; |
5224 | if (type == OCSM_CFGPMTR) value[i].gInType = 1; |
5225 | if (type == OCSM_CONPMTR) value[i].gInType = 2; |
5226 | value[i].partial = NULL; |
5227 | value[i].nderiv = 0; |
5228 | value[i].derivs = NULL; |
5229 | |
5230 | status = caps_makeObject(&objs); |
5231 | if (status != CAPS_SUCCESS) { |
5232 | EG_free(geomIn); |
5233 | EG_free(value); |
5234 | return EGADS_MALLOC; |
5235 | } |
5236 | if (i == 0) objs->blind = value; |
5237 | |
5238 | objs->parent = object; |
5239 | |
5240 | objs->name = NULL; |
5241 | objs->type = VALUE; |
5242 | objs->subtype = GEOMETRYIN; |
5243 | objs->last.sNum = problem->sNum + 1; |
5244 | |
5245 | objs->blind = &value[i]; |
5246 | |
5247 | geomIn[i] = objs; |
5248 | i++; |
5249 | } |
5250 | for (i = 0; i < ngIn; i++) { |
| 43 | | Loop condition is true. Entering loop body | |
|
5251 | ocsmGetPmtr(modl, value[i].pIndex, &type, &nrow, &ncol, name); |
5252 | caps_findGeomVal(problem->nGeomIn, problem->geomIn, i, name, &n); |
5253 | if (n == -1) { |
| |
5254 | |
5255 | if (nrow*ncol > 1) { |
| 45 | | Assuming the condition is false | |
|
| |
5256 | reals = (double *) EG_alloc(nrow*ncol*sizeof(double)); |
5257 | if (reals == NULL) { |
5258 | for (j = 0; j < i; j++) { |
5259 | if (value[j].length != 1) EG_free(value[j].vals.reals); |
5260 | EG_free(geomIn[j]->name); |
5261 | } |
5262 | EG_free(geomIn); |
5263 | |
5264 | EG_free(value); |
5265 | |
5266 | return EGADS_MALLOC; |
5267 | } |
5268 | value[i].vals.reals = reals; |
5269 | } else { |
5270 | reals = &value[i].vals.real; |
5271 | } |
5272 | if (geomIn[i] != NULL) geomIn[i]->name = EG_strdup(name); |
| |
5273 | |
5274 | |
5275 | |
5276 | for (n = k = 0; k < nrow; k++) |
| 48 | | Assuming 'k' is < 'nrow' | |
|
| 49 | | Loop condition is true. Entering loop body | |
|
5277 | for (j = 0; j < ncol; j++, n++) { |
| 50 | | Assuming 'j' is < 'ncol' | |
|
| 51 | | Loop condition is true. Entering loop body | |
|
5278 | status = ocsmGetValu(modl, value[i].pIndex, k+1, j+1, &reals[n], |
5279 | &dot); |
5280 | if (status != SUCCESS) { |
| 52 | | Assuming 'status' is not equal to SUCCESS | |
|
| |
5281 | for (jj = 0; jj <= i; jj++) { |
| 54 | | The value 0 is assigned to 'jj' | |
|
| 55 | | Loop condition is true. Entering loop body | |
|
5282 | if (value[jj].length != 1) EG_free(value[jj].vals.reals); |
| 56 | | Assuming field 'length' is equal to 1 | |
|
| |
5283 | EG_free(geomIn[jj]->name); |
| 58 | | Access to field 'name' results in a dereference of a null pointer |
|
5284 | } |
5285 | EG_free(geomIn); |
5286 | |
5287 | EG_free(value); |
5288 | |
5289 | return status; |
5290 | } |
5291 | } |
5292 | if (type == OCSM_CFGPMTR) continue; |
5293 | status = ocsmGetBnds(modl, value[i].pIndex, 1, 1, &lower, &upper); |
5294 | if (status != SUCCESS) continue; |
5295 | if ((lower != -HUGEQ) || (upper != HUGEQ)) { |
5296 | value[i].limits.dlims[0] = lower; |
5297 | value[i].limits.dlims[1] = upper; |
5298 | } |
5299 | } else { |
5300 | |
5301 | val = (capsValue *) problem->geomIn[n]->blind; |
5302 | if (geomIn[i] != NULL) geomIn[i]->name = EG_strdup(name); |
5303 | val->pIndex = 0; |
5304 | value[i].nrow = val->nrow; |
5305 | value[i].ncol = val->ncol; |
5306 | value[i].length = value[i].nrow*value[i].ncol; |
5307 | if (value[i].length > 1) { |
5308 | value[i].vals.reals = val->vals.reals; |
5309 | val->vals.reals = NULL; |
5310 | reals = value[i].vals.reals; |
5311 | } else { |
5312 | value[i].vals.real = val->vals.real; |
5313 | reals = &value[i].vals.real; |
5314 | } |
5315 | |
5316 | |
5317 | |
5318 | for (n = k = 0; k < value[i].nrow; k++) |
5319 | for (j = 0; j < value[i].ncol; j++, n++) { |
5320 | status = ocsmSetValuD(modl, value[i].pIndex, k+1, j+1, reals[n]); |
5321 | if (status != SUCCESS) { |
5322 | snprintf(temp, PATH_MAX, "%d ocsmSetValuD[%d,%d] fails with %d!", |
5323 | value->pIndex, k+1, j+1, status); |
5324 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
5325 | if (*errors != NULL) *nErr = (*errors)->nError; |
5326 | for (jj = 0; jj <= i; jj++) { |
5327 | if (value[jj].length != 1) EG_free(value[jj].vals.reals); |
5328 | EG_free(geomIn[jj]->name); |
5329 | } |
5330 | EG_free(geomIn); |
5331 | |
5332 | EG_free(value); |
5333 | |
5334 | return status; |
5335 | } |
5336 | } |
5337 | if (value[i].gInType != val->gInType) |
5338 | printf(" CAPS Info: %s Change of GeometryIn type from %d to %d\n", |
5339 | name, val->gInType, value[i].gInType); |
5340 | } |
5341 | } |
5342 | } |
5343 | |
5344 | |
5345 | for (i = 0; i < problem->nGeomIn; i++) { |
5346 | val = (capsValue *) problem->geomIn[i]->blind; |
5347 | if (val->pIndex == 0) continue; |
5348 | if (val->link == NULL) continue; |
5349 | if (CAPScallBack == NULL) { |
5350 | caps_brokenLinkCB(object, val->link, 0, val->linkMethod, |
5351 | problem->geomIn[i]->name, GEOMETRYIN); |
5352 | } else { |
5353 | CAPScallBack(object, val->link, 0, val->linkMethod, |
5354 | problem->geomIn[i]->name, GEOMETRYIN); |
5355 | } |
5356 | } |
5357 | |
5358 | |
5359 | caps_freeValueObjects(0, problem->nGeomIn, problem->geomIn); |
5360 | problem->nGeomIn = ngIn; |
5361 | problem->geomIn = geomIn; |
5362 | |
5363 | |
5364 | if (ngOut != 0) { |
5365 | units = NULL; |
5366 | if (problem->lunits != NULL) units = problem->lunits[problem->nBodies-1]; |
5367 | geomOut = (capsObject **) EG_alloc(ngOut*sizeof(capsObject *)); |
5368 | if (geomOut == NULL) { |
5369 | return EGADS_MALLOC; |
5370 | } |
5371 | for (i = 0; i < ngOut; i++) geomOut[i] = NULL; |
5372 | value = (capsValue *) EG_alloc(ngOut*sizeof(capsValue)); |
5373 | if (value == NULL) { |
5374 | EG_free(geomOut); |
5375 | return EGADS_MALLOC; |
5376 | } |
5377 | for (i = j = 0; j < npmtr; j++) { |
5378 | ocsmGetPmtr(modl, j+1, &type, &nrow, &ncol, name); |
5379 | if (type != OCSM_OUTPMTR) continue; |
5380 | value[i].length = 1; |
5381 | value[i].type = DoubleDeriv; |
5382 | value[i].nrow = 1; |
5383 | value[i].ncol = 1; |
5384 | value[i].dim = Scalar; |
5385 | value[i].index = i+1; |
5386 | value[i].pIndex = j+1; |
5387 | value[i].lfixed = value[i].sfixed = Change; |
5388 | value[i].nullVal = IsNull; |
5389 | value[i].units = NULL; |
5390 | value[i].meshWriter = NULL; |
5391 | value[i].link = NULL; |
5392 | value[i].vals.reals = NULL; |
5393 | value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0; |
5394 | value[i].linkMethod = Copy; |
5395 | value[i].gInType = 0; |
5396 | value[i].partial = NULL; |
5397 | value[i].nderiv = 0; |
5398 | value[i].derivs = NULL; |
5399 | caps_geomOutUnits(name, units, &value[i].units); |
5400 | |
5401 | status = caps_makeObject(&objs); |
5402 | if (status != CAPS_SUCCESS) { |
5403 | for (k = 0; k < i; k++) |
5404 | if (value[k].length > 1) EG_free(value[k].vals.reals); |
5405 | EG_free(geomOut); |
5406 | EG_free(value); |
5407 | return EGADS_MALLOC; |
5408 | } |
5409 | |
5410 | objs->parent = object; |
5411 | |
5412 | objs->name = EG_strdup(name); |
5413 | objs->type = VALUE; |
5414 | objs->subtype = GEOMETRYOUT; |
5415 | objs->last.sNum = 0; |
5416 | |
5417 | objs->blind = &value[i]; |
5418 | |
5419 | geomOut[i] = objs; |
5420 | geomOut[i]->last.sNum = problem->sNum; |
5421 | i++; |
5422 | } |
5423 | |
5424 | |
5425 | for (i = 0; i < problem->nAnalysis; i++) { |
5426 | analysis = (capsAnalysis *) problem->analysis[i]->blind; |
5427 | if (analysis == NULL) continue; |
5428 | for (j = 0; j < analysis->nAnalysisIn; j++) { |
5429 | val = (capsValue *) analysis->analysisIn[j]->blind; |
5430 | if (val->link == NULL) continue; |
5431 | if (val->link->subtype != GEOMETRYOUT) continue; |
5432 | caps_findGeomVal(ngOut, geomOut, ngOut, val->link->name, &n); |
5433 | if (n == -1) { |
5434 | if (CAPScallBack == NULL) { |
5435 | caps_brokenLinkCB(object, val->link, 1, val->linkMethod, |
5436 | val->link->name, GEOMETRYOUT); |
5437 | } else { |
5438 | CAPScallBack(object, val->link, 1, val->linkMethod, |
5439 | val->link->name, GEOMETRYOUT); |
5440 | } |
5441 | } else { |
5442 | val->link = geomOut[n]; |
5443 | } |
5444 | } |
5445 | } |
5446 | } |
5447 | |
5448 | |
5449 | caps_freeValueObjects(0, problem->nGeomOut, problem->geomOut); |
5450 | problem->nGeomOut = ngOut; |
5451 | problem->geomOut = geomOut; |
5452 | |
5453 | |
5454 | #ifdef WIN32 |
5455 | snprintf(current, PATH_MAX, "%s\\capsCSMFilePath", problem->root); |
5456 | #else |
5457 | snprintf(current, PATH_MAX, "%s/capsCSMFilePath", problem->root); |
5458 | #endif |
5459 | caps_rmFile(current); |
5460 | status = ocsmGetFilelist(modl, &fileList); |
5461 | if (status != CAPS_SUCCESS) { |
5462 | return status; |
5463 | } |
5464 | fp = fopen(current, "w"); |
5465 | if (fp == NULL) { |
5466 | EG_free(fileList); |
5467 | return CAPS_IOERR; |
5468 | } |
5469 | fprintf(fp, "%s\n", fileList); |
5470 | fclose(fp); |
5471 | EG_free(fileList); |
5472 | fflush(stdout); |
5473 | |
5474 | |
5475 | #ifdef WIN32 |
5476 | snprintf(current, PATH_MAX, "%s\\capsRestart.cpc", problem->root); |
5477 | #else |
5478 | snprintf(current, PATH_MAX, "%s/capsRestart.cpc", problem->root); |
5479 | #endif |
5480 | caps_rmFile(current); |
5481 | status = ocsmSave(modl, current); |
5482 | if (status != CAPS_SUCCESS) { |
5483 | return status; |
5484 | } |
5485 | fflush(stdout); |
5486 | |
5487 | |
5488 | if (problem->bodies != NULL) { |
5489 | if (problem->lunits != NULL) |
5490 | for (i = 0; i < problem->nBodies; i++) |
5491 | if (problem->lunits[i] != NULL) EG_free(problem->lunits[i]); |
5492 | |
5493 | for (i = 0; i < problem->nAnalysis; i++) { |
5494 | analysis = (capsAnalysis *) problem->analysis[i]->blind; |
5495 | if (analysis == NULL) continue; |
5496 | if (analysis->tess != NULL) { |
5497 | for (j = 0; j < analysis->nTess; j++) |
5498 | if (analysis->tess[j] != NULL) { |
5499 | |
5500 | body = NULL; |
5501 | if (j >= analysis->nBody) { |
5502 | status = EG_statusTessBody(analysis->tess[j], &body, &state, |
5503 | &npts); |
5504 | if (status != CAPS_SUCCESS) |
5505 | printf(" CAPS Warning: statusTessBody = %d (caps_phaseCSMreload)\n", |
5506 | status); |
5507 | } |
5508 | EG_deleteObject(analysis->tess[j]); |
5509 | if (body != NULL) EG_deleteObject(body); |
5510 | analysis->tess[j] = NULL; |
5511 | } |
5512 | EG_free(analysis->tess); |
5513 | analysis->tess = NULL; |
5514 | analysis->nTess = 0; |
5515 | } |
5516 | if (analysis->bodies != NULL) { |
5517 | EG_free(analysis->bodies); |
5518 | analysis->bodies = NULL; |
5519 | analysis->nBody = 0; |
5520 | } |
5521 | |
5522 | analysis->info.pIndex = 0; |
5523 | analysis->info.irow = 0; |
5524 | analysis->info.icol = 0; |
5525 | } |
5526 | EG_free(problem->bodies); |
5527 | EG_free(problem->lunits); |
5528 | problem->bodies = NULL; |
5529 | problem->lunits = NULL; |
5530 | } |
5531 | problem->nBodies = 0; |
5532 | ocsmFree(problem->modl); |
5533 | problem->modl = modl; |
5534 | problem->sNum = problem->sNum + 1; |
5535 | |
5536 | |
5537 | #ifdef WIN32 |
5538 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\VI-*", problem->root); |
5539 | snprintf(current, PATH_MAX, "%s\\capsRestart\\VO-*", problem->root); |
5540 | #else |
5541 | snprintf(filename, PATH_MAX, "%s/capsRestart/VI-*", problem->root); |
5542 | snprintf(current, PATH_MAX, "%s/capsRestart/VO-*", problem->root); |
5543 | #endif |
5544 | caps_rmWild(filename); |
5545 | caps_rmWild(current); |
5546 | |
5547 | jj = caps_build(object, nErr, errors); |
5548 | if (jj == CAPS_SUCCESS) { |
5549 | status = caps_dumpGeomVals(problem, 1); |
5550 | if (status != CAPS_SUCCESS) |
5551 | printf(" CAPS Warning: caps_dumpGeomVals = %d (caps_phaseCSMreload)\n", |
5552 | status); |
5553 | } else { |
5554 | printf(" CAPS Warning: caps_build = %d (caps_phaseCSMreload)\n", jj); |
5555 | } |
5556 | |
5557 | return jj; |
5558 | } |
5559 | |
5560 | |
5561 | int |
5562 | caps_open(const char *prPath, const char *phName, int flag, |
5563 | void *ptr, int outLevel, capsObject **pobject, |
5564 | int *nErr, capsErrs **errors) |
5565 | { |
5566 | int i, j, k, n, len, status, oclass, mtype, *senses, idot = 0; |
5567 | int type, nattr, ngIn, ngOut, buildTo, builtTo, ibody; |
5568 | int nrow, ncol, nbrch, npmtr, nbody, ivec[2]; |
5569 | char byte, *units, *env, root[PATH_MAX], current[PATH_MAX]; |
5570 | char name[MAX_NAME_LEN], *fileList; |
5571 | char filename[PATH_MAX], temp[PATH_MAX], **tmp, line[129]; |
5572 | CAPSLONG fileLen, ret, sNum; |
5573 | double dot, lower, upper, data[4], *reals; |
5574 | ego model, ref, *childs; |
5575 | capsObject *object, *aobject, *objs; |
5576 | capsProblem *problem; |
5577 | capsAnalysis *analysis; |
5578 | capsBound *bound; |
5579 | capsVertexSet *vertexset; |
5580 | capsDataSet *dataset; |
5581 | capsValue *value, *valIn = NULL; |
5582 | modl_T *MODL = NULL; |
5583 | size_t nw; |
5584 | FILE *fp; |
5585 | const char *aname, *astring, *prName, *fname = NULL; |
5586 | const int *aints; |
5587 | const double *areals; |
5588 | |
5589 | if (nErr == NULL) return CAPS_NULLVALUE; |
5590 | if (errors == NULL) return CAPS_NULLVALUE; |
5591 | *pobject = NULL; |
5592 | *nErr = 0; |
5593 | *errors = NULL; |
5594 | if (prPath == NULL) return CAPS_NULLNAME; |
5595 | len = strlen(prPath); |
5596 | for (i = 0; i < len; i++) |
5597 | if (prPath[i] == ' ') { |
5598 | caps_makeSimpleErr(NULL, CERROR, "Cannot use spaces in path (caps_open):", |
5599 | prPath, NULL, errors); |
5600 | if (*errors != NULL) *nErr = (*errors)->nError; |
5601 | return CAPS_BADNAME; |
5602 | } |
5603 | if (phName != NULL) { |
5604 | if (strcmp(phName, "Scratch") == 0) { |
5605 | caps_makeSimpleErr(NULL, CERROR, "Cannot use the phase Scratch (caps_open)!", |
5606 | NULL, NULL, errors); |
5607 | if (*errors != NULL) *nErr = (*errors)->nError; |
5608 | return CAPS_BADNAME; |
5609 | } |
5610 | len = strlen(phName); |
5611 | for (i = 0; i < len; i++) |
5612 | if ((phName[i] == '/') || (phName[i] == '\\')) { |
5613 | caps_makeSimpleErr(NULL, CERROR, |
5614 | "Cannot use slashes in phase name (caps_open):", |
5615 | phName, NULL, errors); |
5616 | if (*errors != NULL) *nErr = (*errors)->nError; |
5617 | return CAPS_BADNAME; |
5618 | } |
5619 | } |
5620 | for (i = 0; i < PATH_MAX-1; i++) filename[i] = ' '; |
5621 | filename[PATH_MAX-1] = 0; |
5622 | |
5623 | if (flag == oFileName) { |
5624 | |
5625 | fname = (const char *) ptr; |
5626 | if (fname == NULL) return CAPS_NULLNAME; |
5627 | n = -1; |
5628 | #ifdef WIN32 |
5629 | |
5630 | if (fname[1] == ':') { |
5631 | int id, oldrive; |
5632 | if (fname[0] >= 97) { |
5633 | id = fname[0] - 96; |
5634 | } else { |
5635 | id = fname[0] - 64; |
5636 | } |
5637 | oldrive = _getdrive(); |
5638 | status = _chdrive(id); |
5639 | if (status == -1) { |
5640 | snprintf(temp, PATH_MAX, "Cannot change drive to %c (caps_open)!", |
5641 | fname[0]); |
5642 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
5643 | if (*errors != NULL) *nErr = (*errors)->nError; |
5644 | return CAPS_DIRERR; |
5645 | } |
5646 | (void) _chdrive(oldrive); |
5647 | n = 0; |
5648 | } |
5649 | #endif |
5650 | if (n == -1) |
5651 | if ((fname[0] == '/') || (fname[0] == '\\')) n = 0; |
5652 | if (n == 0) { |
5653 | |
5654 | #ifdef WIN32 |
5655 | if (fname[1] == ':') { |
5656 | snprintf(filename, PATH_MAX, "%s", fname); |
5657 | } else { |
5658 | snprintf(filename, PATH_MAX, "%c:%s", _getdrive()+64, fname); |
5659 | } |
5660 | #else |
5661 | snprintf(filename, PATH_MAX, "%s", fname); |
5662 | #endif |
5663 | } else { |
5664 | |
5665 | (void) getcwd(current, PATH_MAX); |
5666 | #ifdef WIN32 |
5667 | snprintf(filename, PATH_MAX, "%s\\%s", current, fname); |
5668 | #else |
5669 | snprintf(filename, PATH_MAX, "%s/%s", current, fname); |
5670 | #endif |
5671 | } |
5672 | caps_prunePath(filename); |
5673 | } else if (flag == oMODL) { |
5674 | MODL = (modl_T *) ptr; |
5675 | } else if (flag == oEGO) { |
5676 | model = (ego) ptr; |
5677 | status = EG_getTopology(model, &ref, &oclass, &mtype, data, &len, &childs, |
5678 | &senses); |
5679 | if (status != EGADS_SUCCESS) return status; |
5680 | } else if ((flag == oPhaseName) || (flag == oPNreload)) { |
5681 | if (phName == NULL) { |
5682 | caps_makeSimpleErr(NULL, CERROR, |
5683 | "Cannot start with a NULL PhaseName (caps_open)!", |
5684 | NULL, NULL, errors); |
5685 | if (*errors != NULL) *nErr = (*errors)->nError; |
5686 | return CAPS_DIRERR; |
5687 | } |
5688 | fname = (const char *) ptr; |
5689 | if (fname == NULL) return CAPS_NULLNAME; |
5690 | } else if (flag != oContinue) { |
5691 | |
5692 | return CAPS_NOTIMPLEMENT; |
5693 | } |
5694 | |
5695 | |
5696 | fileLen = 0; |
5697 | if (flag == oFileName) { |
5698 | fp = fopen(filename, "rb"); |
5699 | if (fp == NULL) return CAPS_NOTFOUND; |
5700 | do { |
5701 | ret = fread(&byte, sizeof(char), 1, fp); |
5702 | fileLen++; |
5703 | } while (ret != 0); |
5704 | fclose(fp); |
5705 | if (fileLen > 0) fileLen--; |
5706 | if (fileLen == 0) return CAPS_BADVALUE; |
5707 | |
5708 | |
5709 | len = strlen(filename); |
5710 | for (idot = len-1; idot > 0; idot--) |
5711 | if (filename[idot] == '.') break; |
5712 | if (idot == 0) return CAPS_BADNAME; |
5713 | |
5714 | if ((strcasecmp(&filename[idot],".csm") != 0) && |
5715 | (strcasecmp(&filename[idot],".egads") != 0)) return CAPS_BADTYPE; |
5716 | |
5717 | } |
5718 | |
5719 | |
5720 | len = strlen(prPath); |
5721 | for (i = len-1; i > 0; i--) |
5722 | if ((prPath[i] == '/') || (prPath[i] == '\\')) break; |
5723 | if (i != 0) i++; |
5724 | prName = &prPath[i]; |
5725 | status = caps_isNameOK(prName); |
5726 | if (status != CAPS_SUCCESS) { |
5727 | caps_makeSimpleErr(NULL, CERROR, "Not a valid Problem Name (caps_open):", |
5728 | prName, NULL, errors); |
5729 | if (*errors != NULL) *nErr = (*errors)->nError; |
5730 | return status; |
5731 | } |
5732 | n = -1; |
5733 | #ifdef WIN32 |
5734 | |
5735 | if (prPath[1] == ':') { |
5736 | int drive, oldrive; |
5737 | if (prPath[0] >= 97) { |
5738 | drive = prPath[0] - 96; |
5739 | } else { |
5740 | drive = prPath[0] - 64; |
5741 | } |
5742 | oldrive = _getdrive(); |
5743 | status = _chdrive(drive); |
5744 | if (status == -1) { |
5745 | snprintf(temp, PATH_MAX, "Cannot change drive to %c (caps_open)!", |
5746 | prPath[0]); |
5747 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
5748 | if (*errors != NULL) *nErr = (*errors)->nError; |
5749 | return CAPS_DIRERR; |
5750 | } |
5751 | (void) _chdrive(oldrive); |
5752 | n = 0; |
5753 | } |
5754 | #endif |
5755 | if (n == -1) |
5756 | if ((prPath[0] == '/') || (prPath[0] == '\\')) n = 0; |
5757 | if (n == 0) { |
5758 | |
5759 | status = caps_statFile(prPath); |
5760 | if (status == EGADS_SUCCESS) { |
5761 | caps_makeSimpleErr(NULL, CERROR, "Lands on a flat file (caps_open):", |
5762 | prPath, NULL, errors); |
5763 | if (*errors != NULL) *nErr = (*errors)->nError; |
5764 | return CAPS_DIRERR; |
5765 | } else if (status == EGADS_NOTFOUND) { |
5766 | status = caps_mkDir(prPath); |
5767 | if (status != EGADS_SUCCESS) { |
5768 | caps_makeSimpleErr(NULL, CERROR, "Cannot mkDir (caps_open):", |
5769 | prPath, NULL, errors); |
5770 | if (*errors != NULL) *nErr = (*errors)->nError; |
5771 | return status; |
5772 | } |
5773 | } |
5774 | #ifdef WIN32 |
5775 | if (prPath[1] == ':') { |
5776 | if (phName == NULL) { |
5777 | snprintf(root, PATH_MAX, "%s\\Scratch", prPath); |
5778 | } else { |
5779 | snprintf(root, PATH_MAX, "%s\\%s", prPath, phName); |
5780 | if ((flag == oPhaseName) || (flag == oPNreload)) |
5781 | snprintf(filename, PATH_MAX, "%s\\%s", prPath, fname); |
5782 | } |
5783 | } else { |
5784 | if (phName == NULL) { |
5785 | snprintf(root, PATH_MAX, "%c:%s\\Scratch", _getdrive()+64, prPath); |
5786 | } else { |
5787 | snprintf(root, PATH_MAX, "%c:%s\\%s", _getdrive()+64, prPath, phName); |
5788 | if ((flag == oPhaseName) || (flag == oPNreload)) |
5789 | snprintf(filename, PATH_MAX, "%c:%s\\%s", _getdrive()+64, prPath, |
5790 | fname); |
5791 | } |
5792 | } |
5793 | #else |
5794 | if (phName == NULL) { |
5795 | snprintf(root, PATH_MAX, "%s/Scratch", prPath); |
5796 | } else { |
5797 | snprintf(root, PATH_MAX, "%s/%s", prPath, phName); |
5798 | if ((flag == oPhaseName) || (flag == oPNreload)) |
5799 | snprintf(filename, PATH_MAX, "%s/%s", prPath, fname); |
5800 | } |
5801 | #endif |
5802 | } else { |
5803 | |
5804 | (void) getcwd(current, PATH_MAX); |
5805 | #ifdef WIN32 |
5806 | snprintf(root, PATH_MAX, "%s\\%s", current, prPath); |
5807 | #else |
5808 | snprintf(root, PATH_MAX, "%s/%s", current, prPath); |
5809 | #endif |
5810 | status = caps_statFile(root); |
5811 | if (status == EGADS_SUCCESS) { |
5812 | caps_makeSimpleErr(NULL, CERROR, "Path lands on a flat file (caps_open):", |
5813 | root, NULL, errors); |
5814 | if (*errors != NULL) *nErr = (*errors)->nError; |
5815 | return CAPS_DIRERR; |
5816 | } else if (status == EGADS_NOTFOUND) { |
5817 | status = caps_mkDir(root); |
5818 | if (status != EGADS_SUCCESS) { |
5819 | caps_makeSimpleErr(NULL, CERROR, "Cannot make Path (caps_open):", |
5820 | root, NULL, errors); |
5821 | if (*errors != NULL) *nErr = (*errors)->nError; |
5822 | return status; |
5823 | } |
5824 | } |
5825 | #ifdef WIN32 |
5826 | if (phName == NULL) { |
5827 | snprintf(root, PATH_MAX, "%s\\%s\\Scratch", current, prPath); |
5828 | } else { |
5829 | snprintf(root, PATH_MAX, "%s\\%s\\%s", current, prPath, phName); |
5830 | if ((flag == oPhaseName) || (flag == oPNreload)) |
5831 | snprintf(filename, PATH_MAX, "%s\\%s\\%s", current, prPath, fname); |
5832 | } |
5833 | #else |
5834 | if (phName == NULL) { |
5835 | snprintf(root, PATH_MAX, "%s/%s/Scratch", current, prPath); |
5836 | } else { |
5837 | snprintf(root, PATH_MAX, "%s/%s/%s", current, prPath, phName); |
5838 | if ((flag == oPhaseName) || (flag == oPNreload)) |
5839 | snprintf(filename, PATH_MAX, "%s/%s/%s", current, prPath, fname); |
5840 | } |
5841 | #endif |
5842 | } |
5843 | caps_prunePath(root); |
5844 | |
5845 | if ((flag == oPhaseName) || (flag == oPNreload)) { |
5846 | caps_prunePath(filename); |
5847 | nw = strlen(filename)+1; |
5848 | memcpy(temp, filename, nw); |
5849 | nw = strlen(root)+1; |
5850 | memcpy(filename, root, nw); |
5851 | nw = strlen(temp)+1; |
5852 | memcpy(root, temp, nw); |
5853 | status = caps_statFile(root); |
5854 | if (status == EGADS_SUCCESS) { |
5855 | caps_makeSimpleErr(NULL, CERROR, "Lands on a flat file (caps_open):", |
5856 | root, NULL, errors); |
5857 | if (*errors != NULL) *nErr = (*errors)->nError; |
5858 | return CAPS_DIRERR; |
5859 | } else if (status != EGADS_NOTFOUND) { |
5860 | caps_makeSimpleErr(NULL, CERROR, "Path already exists (caps_open):", |
5861 | root, NULL, errors); |
5862 | if (*errors != NULL) *nErr = (*errors)->nError; |
5863 | return EGADS_EXISTS; |
5864 | } |
5865 | #ifdef WIN32 |
5866 | snprintf(current, PATH_MAX, "%s\\capsClosed", filename); |
5867 | #else |
5868 | snprintf(current, PATH_MAX, "%s/capsClosed", filename); |
5869 | #endif |
5870 | status = caps_statFile(current); |
5871 | if (status != EGADS_SUCCESS) { |
5872 | caps_makeSimpleErr(NULL, CERROR, "Not closed (caps_open):", |
5873 | filename, NULL, errors); |
5874 | if (*errors != NULL) *nErr = (*errors)->nError; |
5875 | return CAPS_DIRERR; |
5876 | } |
5877 | status = caps_cpDir(filename, root); |
5878 | if (status != EGADS_SUCCESS) { |
5879 | snprintf(temp, PATH_MAX, "Copy directory = %d (caps_open)", status); |
5880 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
5881 | if (*errors != NULL) *nErr = (*errors)->nError; |
5882 | return status; |
5883 | } |
5884 | |
5885 | #ifdef WIN32 |
5886 | snprintf(current, PATH_MAX, "%s\\capsClosed", root); |
5887 | #else |
5888 | snprintf(current, PATH_MAX, "%s/capsClosed", root); |
5889 | #endif |
5890 | status = caps_rmFile(current); |
5891 | if ((status != EGADS_SUCCESS) && (status != EGADS_NOTFOUND)) |
5892 | printf(" CAPS Warning: Cannot remove Closed file!\n"); |
5893 | #ifdef WIN32 |
5894 | snprintf(current, PATH_MAX, "%s\\capsLock", root); |
5895 | #else |
5896 | snprintf(current, PATH_MAX, "%s/capsLock", root); |
5897 | #endif |
5898 | status = caps_rmFile(current); |
5899 | if ((status != EGADS_SUCCESS) && (status != EGADS_NOTFOUND)) |
5900 | printf(" CAPS Warning: Cannot remove Lock file (caps_open)\n"); |
5901 | } else if (flag == oContinue) { |
5902 | |
5903 | #ifdef WIN32 |
5904 | snprintf(current, PATH_MAX, "%s\\capsClosed", root); |
5905 | #else |
5906 | snprintf(current, PATH_MAX, "%s/capsClosed", root); |
5907 | #endif |
5908 | status = caps_statFile(current); |
5909 | if (status != EGADS_NOTFOUND) { |
5910 | caps_makeSimpleErr(NULL, CERROR, |
5911 | "Found Closed file on continuation (caps_open)!", |
5912 | NULL, NULL, errors); |
5913 | if (*errors != NULL) *nErr = (*errors)->nError; |
5914 | return CAPS_EXISTS; |
5915 | } |
5916 | } else { |
5917 | status = caps_statFile(root); |
5918 | if (status == EGADS_SUCCESS) { |
5919 | caps_makeSimpleErr(NULL, CERROR, "Lands on a flat file (caps_open):", |
5920 | root, NULL, errors); |
5921 | if (*errors != NULL) *nErr = (*errors)->nError; |
5922 | return CAPS_DIRERR; |
5923 | } else if (status != EGADS_NOTFOUND) { |
5924 | if (phName != NULL) { |
5925 | caps_makeSimpleErr(NULL, CERROR, "Already exists (caps_open):", |
5926 | root, NULL, errors); |
5927 | if (*errors != NULL) *nErr = (*errors)->nError; |
5928 | return EGADS_EXISTS; |
5929 | } else { |
5930 | #ifdef WIN32 |
5931 | snprintf(current, PATH_MAX, "%s\\capsLock", root); |
5932 | #else |
5933 | snprintf(current, PATH_MAX, "%s/capsLock", root); |
5934 | #endif |
5935 | if (caps_statFile(current) != EGADS_NOTFOUND) { |
5936 | caps_makeSimpleErr(NULL, CERROR, "Lock file exists (caps_open)!", |
5937 | "If you believe that no one else is running here remove:", |
5938 | current, errors); |
5939 | if (*errors != NULL) *nErr = (*errors)->nError; |
5940 | return CAPS_DIRERR; |
5941 | } |
5942 | caps_rmDir(root); |
5943 | } |
5944 | } |
5945 | status = caps_mkDir(root); |
5946 | if (status != EGADS_SUCCESS) { |
5947 | caps_makeSimpleErr(NULL, CERROR, "Cannot mkDir (caps_open)!", |
5948 | root, NULL, errors); |
5949 | if (*errors != NULL) *nErr = (*errors)->nError; |
5950 | return status; |
5951 | } |
5952 | } |
5953 | |
5954 | |
5955 | #ifdef WIN32 |
5956 | snprintf(current, PATH_MAX, "%s\\capsLock", root); |
5957 | #else |
5958 | snprintf(current, PATH_MAX, "%s/capsLock", root); |
5959 | #endif |
5960 | if (caps_statFile(current) != EGADS_NOTFOUND) { |
5961 | caps_makeSimpleErr(NULL, CERROR, "Lock file exists (caps_open)!", |
5962 | "If you believe that no one else is running here remove:", |
5963 | current, errors); |
5964 | if (*errors != NULL) *nErr = (*errors)->nError; |
5965 | return CAPS_DIRERR; |
5966 | } |
5967 | tmp = (char **) EG_reall(CAPSlocks, (CAPSnLock+1)*sizeof(char *)); |
5968 | if (tmp == NULL) { |
5969 | caps_makeSimpleErr(NULL, CERROR, "ReAllocating Locks storage (caps_open)!", |
5970 | NULL, NULL, errors); |
5971 | if (*errors != NULL) *nErr = (*errors)->nError; |
5972 | return EGADS_MALLOC; |
5973 | } |
5974 | CAPSlocks = tmp; |
5975 | CAPSlocks[CAPSnLock] = EG_strdup(current); |
5976 | CAPSnLock++; |
5977 | fp = fopen(current, "w"); |
5978 | if (fp == NULL) { |
5979 | caps_makeSimpleErr(NULL, CERROR, "Cannot open Lock file (caps_open)!", |
5980 | NULL, NULL, errors); |
5981 | if (*errors != NULL) *nErr = (*errors)->nError; |
5982 | return CAPS_DIRERR; |
5983 | } |
5984 | fclose(fp); |
5985 | caps_initSignals(); |
5986 | |
5987 | |
5988 | env = getenv("CAPS_OUTLEVEL"); |
5989 | if (env != NULL && (env[0] == '0' || |
5990 | env[0] == '1' || |
5991 | env[0] == '2')) { |
5992 | outLevel = atoi(env); |
5993 | } |
5994 | |
5995 | |
5996 | |
5997 | problem = (capsProblem *) EG_alloc(sizeof(capsProblem)); |
5998 | if (problem == NULL) return EGADS_MALLOC; |
5999 | |
6000 | |
6001 | problem->signature = NULL; |
6002 | problem->context = NULL; |
6003 | problem->utsystem = NULL; |
6004 | problem->root = EG_strdup(root); |
6005 | problem->phName = NULL; |
6006 | problem->stFlag = flag; |
6007 | problem->jrnl = NULL; |
6008 | problem->outLevel = outLevel; |
6009 | problem->funID = CAPS_OPEN; |
6010 | problem->modl = NULL; |
6011 | problem->nParam = 0; |
6012 | problem->params = NULL; |
6013 | problem->nGeomIn = 0; |
6014 | problem->geomIn = NULL; |
6015 | problem->nGeomOut = 0; |
6016 | problem->geomOut = NULL; |
6017 | problem->nAnalysis = 0; |
6018 | problem->analysis = NULL; |
6019 | problem->mBound = 0; |
6020 | problem->nBound = 0; |
6021 | problem->bounds = NULL; |
6022 | problem->geometry.nLines = 0; |
6023 | problem->geometry.lines = NULL; |
6024 | problem->geometry.pname = NULL; |
6025 | problem->geometry.pID = NULL; |
6026 | problem->geometry.user = NULL; |
6027 | problem->geometry.sNum = 0; |
6028 | for (j = 0; j < 6; j++) problem->geometry.datetime[j] = 0; |
6029 | problem->nBodies = 0; |
6030 | problem->bodies = NULL; |
6031 | problem->lunits = NULL; |
6032 | problem->nEGADSmdl = 0; |
6033 | problem->nRegGIN = 0; |
6034 | problem->regGIN = NULL; |
6035 | problem->nExec = 0; |
6036 | problem->execs = NULL; |
6037 | problem->sNum = problem->writer.sNum = 1; |
6038 | problem->jpos = 0; |
6039 | problem->writer.nLines = 0; |
6040 | problem->writer.lines = NULL; |
6041 | problem->writer.pname = EG_strdup(prName); |
6042 | caps_getStaticStrings(&problem->signature, &problem->writer.pID, |
6043 | &problem->writer.user); |
6044 | for (j = 0; j < 6; j++) problem->writer.datetime[j] = 0; |
6045 | problem->aimFPTR.aim_nAnal = 0; |
6046 | for (j = 0; j < MAXANAL; j++) { |
6047 | problem->aimFPTR.aimName[j] = NULL; |
6048 | problem->aimFPTR.aimDLL[j] = NULL; |
6049 | problem->aimFPTR.aimInit[j] = NULL; |
6050 | problem->aimFPTR.aimDiscr[j] = NULL; |
6051 | problem->aimFPTR.aimFreeD[j] = NULL; |
6052 | problem->aimFPTR.aimLoc[j] = NULL; |
6053 | problem->aimFPTR.aimInput[j] = NULL; |
6054 | problem->aimFPTR.aimPAnal[j] = NULL; |
6055 | problem->aimFPTR.aimPost[j] = NULL; |
6056 | problem->aimFPTR.aimOutput[j] = NULL; |
6057 | problem->aimFPTR.aimCalc[j] = NULL; |
6058 | problem->aimFPTR.aimXfer[j] = NULL; |
6059 | problem->aimFPTR.aimIntrp[j] = NULL; |
6060 | problem->aimFPTR.aimIntrpBar[j] = NULL; |
6061 | problem->aimFPTR.aimIntgr[j] = NULL; |
6062 | problem->aimFPTR.aimIntgrBar[j] = NULL; |
6063 | problem->aimFPTR.aimBdoor[j] = NULL; |
6064 | problem->aimFPTR.aimClean[j] = NULL; |
6065 | } |
6066 | if (phName != NULL) problem->phName = EG_strdup(phName); |
6067 | |
6068 | status = caps_makeObject(&object); |
6069 | if (status != CAPS_SUCCESS) { |
6070 | EG_free(problem); |
6071 | return status; |
6072 | } |
6073 | problem->mySelf = object; |
6074 | object->type = PROBLEM; |
6075 | object->blind = problem; |
6076 | |
6077 | problem->utsystem = caps_initUnits(); |
6078 | if (problem->utsystem == NULL) { |
6079 | caps_close(object, 0, NULL); |
6080 | return CAPS_UNITERR; |
6081 | } |
6082 | |
6083 | |
6084 | if (flag == oEGO) { |
6085 | status = EG_getContext(model, &problem->context); |
6086 | } else { |
6087 | status = EG_open(&problem->context); |
6088 | } |
6089 | if (status != EGADS_SUCCESS) { |
6090 | caps_close(object, 0, NULL); |
6091 | return status; |
6092 | } |
6093 | if (problem->context == NULL) { |
6094 | caps_close(object, 0, NULL); |
6095 | return EGADS_NOTCNTX; |
6096 | } |
6097 | |
6098 | |
6099 | if (flag > oEGO) { |
6100 | status = caps_readState(object); |
6101 | if (status != CAPS_SUCCESS) { |
6102 | caps_close(object, 0, NULL); |
6103 | caps_rmDir(root); |
6104 | return status; |
6105 | } |
6106 | |
6107 | |
6108 | if (object->subtype == PARAMETRIC) { |
6109 | #ifdef WIN32 |
6110 | snprintf(current, PATH_MAX, "%s\\capsRestart.cpc", root); |
6111 | #else |
6112 | snprintf(current, PATH_MAX, "%s/capsRestart.cpc", root); |
6113 | #endif |
6114 | if (problem->outLevel != 1) ocsmSetOutLevel(problem->outLevel); |
6115 | status = ocsmLoad(current, &problem->modl); |
6116 | if (status < SUCCESS) { |
6117 | printf(" CAPS Error: Cannot ocsmLoad %s (caps_open)!\n", current); |
6118 | caps_close(object, 0, NULL); |
6119 | caps_rmDir(root); |
6120 | return status; |
6121 | } |
6122 | MODL = (modl_T *) problem->modl; |
6123 | if (MODL == NULL) { |
6124 | caps_makeSimpleErr(NULL, CERROR, "Cannot get OpenCSM MODL (caps_open)!", |
6125 | NULL, NULL, errors); |
6126 | if (*errors != NULL) *nErr = (*errors)->nError; |
6127 | caps_close(object, 0, NULL); |
6128 | caps_rmDir(root); |
6129 | return CAPS_NOTFOUND; |
6130 | } |
6131 | MODL->context = problem->context; |
6132 | |
6133 | MODL->userdata = problem; |
6134 | |
6135 | MODL->tessAtEnd = 0; |
6136 | status = ocsmRegSizeCB(problem->modl, caps_sizeCB); |
6137 | if (status != SUCCESS) |
6138 | printf(" CAPS Warning: ocsmRegSizeCB = %d (caps_open)!", status); |
6139 | |
6140 | status = ocsmCheck(problem->modl); |
6141 | if (status < SUCCESS) { |
6142 | snprintf(temp, PATH_MAX, "ocsmCheck = %d (caps_open)!", status); |
6143 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6144 | if (*errors != NULL) *nErr = (*errors)->nError; |
6145 | caps_close(object, 0, NULL); |
6146 | caps_rmDir(root); |
6147 | return status; |
6148 | } |
6149 | fflush(stdout); |
6150 | |
6151 | if (problem->geomIn != NULL) |
6152 | for (i = 0; i < problem->nGeomIn; i++) { |
6153 | if (problem->geomIn[i] == NULL) continue; |
6154 | value = (capsValue *) problem->geomIn[i]->blind; |
6155 | reals = value->vals.reals; |
6156 | if (value->length == 1) reals = &value->vals.real; |
6157 | status = ocsmGetPmtr(problem->modl, value->pIndex, &type, |
6158 | &nrow, &ncol, name); |
6159 | if (status != SUCCESS) { |
6160 | snprintf(temp, PATH_MAX, "ocsmGetPmtr %d fails with %d (caps_open)!", |
6161 | value->pIndex, status); |
6162 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6163 | if (*errors != NULL) *nErr = (*errors)->nError; |
6164 | caps_close(object, 0, NULL); |
6165 | caps_rmDir(root); |
6166 | return status; |
6167 | } |
6168 | if ((ncol != value->ncol) || (nrow != value->nrow)) { |
6169 | snprintf(temp, PATH_MAX, "%s ncol = %d %d, nrow = %d %d (caps_open)!", |
6170 | name, ncol, value->ncol, nrow, value->nrow); |
6171 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6172 | if (*errors != NULL) *nErr = (*errors)->nError; |
6173 | caps_close(object, 0, NULL); |
6174 | caps_rmDir(root); |
6175 | return CAPS_MISMATCH; |
6176 | } |
6177 | |
6178 | |
6179 | |
6180 | for (n = k = 0; k < nrow; k++) |
6181 | for (j = 0; j < ncol; j++, n++) { |
6182 | status = ocsmSetValuD(problem->modl, value->pIndex, |
6183 | k+1, j+1, reals[n]); |
6184 | if (status != SUCCESS) { |
6185 | snprintf(temp, PATH_MAX, "%d ocsmSetValuD[%d,%d] fails with %d!", |
6186 | value->pIndex, k+1, j+1, status); |
6187 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6188 | if (*errors != NULL) *nErr = (*errors)->nError; |
6189 | caps_close(object, 0, NULL); |
6190 | caps_rmDir(root); |
6191 | return status; |
6192 | } |
6193 | } |
6194 | } |
6195 | |
6196 | buildTo = 0; |
6197 | nbody = 0; |
6198 | status = ocsmBuild(problem->modl, buildTo, &builtTo, &nbody, NULL); |
6199 | fflush(stdout); |
6200 | if (status != SUCCESS) { |
6201 | snprintf(temp, PATH_MAX, "ocsmBuild to %d fails with %d (caps_open)!", |
6202 | builtTo, status); |
6203 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6204 | if (*errors != NULL) *nErr = (*errors)->nError; |
6205 | caps_close(object, 0, NULL); |
6206 | caps_rmDir(root); |
6207 | return status; |
6208 | } |
6209 | nbody = 0; |
6210 | for (ibody = 1; ibody <= MODL->nbody; ibody++) { |
6211 | if (MODL->body[ibody].onstack != 1) continue; |
6212 | if (MODL->body[ibody].botype == OCSM_NULL_BODY) continue; |
6213 | nbody++; |
6214 | } |
6215 | |
6216 | if (nbody > 0) { |
6217 | problem->bodies = (ego *) EG_alloc(nbody*sizeof(ego)); |
6218 | problem->lunits = (char **) EG_alloc(nbody*sizeof(char *)); |
6219 | if ((problem->bodies != NULL) && (problem->lunits != NULL)) { |
6220 | problem->nBodies = nbody; |
6221 | i = 0; |
6222 | for (ibody = 1; ibody <= MODL->nbody; ibody++) { |
6223 | if (MODL->body[ibody].onstack != 1) continue; |
6224 | if (MODL->body[ibody].botype == OCSM_NULL_BODY) continue; |
6225 | problem->bodies[i] = MODL->body[ibody].ebody; |
6226 | caps_fillLengthUnits(problem, problem->bodies[i], |
6227 | &problem->lunits[i]); |
6228 | i++; |
6229 | } |
6230 | } else { |
6231 | if (problem->lunits != NULL) EG_free(problem->lunits); |
6232 | problem->lunits = NULL; |
6233 | snprintf(temp, PATH_MAX, "Malloc on %d Body (caps_open)!\n", nbody); |
6234 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6235 | if (*errors != NULL) *nErr = (*errors)->nError; |
6236 | caps_close(object, 0, NULL); |
6237 | caps_rmDir(root); |
6238 | return EGADS_MALLOC; |
6239 | } |
6240 | } |
6241 | status = ocsmInfo(problem->modl, &nbrch, &npmtr, &nbody); |
6242 | if (status != SUCCESS) { |
6243 | caps_close(object, 0, NULL); |
6244 | caps_rmDir(root); |
6245 | snprintf(temp, PATH_MAX, "ocsmInfo returns %d (caps_open)!", status); |
6246 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6247 | if (*errors != NULL) *nErr = (*errors)->nError; |
6248 | return status; |
6249 | } |
6250 | for (ngIn = ngOut = i = 0; i < npmtr; i++) { |
6251 | status = ocsmGetPmtr(problem->modl, i+1, &type, &nrow, &ncol, name); |
6252 | if (status != SUCCESS) { |
6253 | caps_close(object, 0, NULL); |
6254 | caps_rmDir(root); |
6255 | return status; |
6256 | } |
6257 | if (type == OCSM_OUTPMTR) ngOut++; |
6258 | if (type == OCSM_DESPMTR) ngIn++; |
6259 | if (type == OCSM_CFGPMTR) ngIn++; |
6260 | if (type == OCSM_CONPMTR) ngIn++; |
6261 | } |
6262 | if (ngIn != problem->nGeomIn) { |
6263 | snprintf(temp, PATH_MAX, "# Design Vars = %d -- from %s = %d (caps_open)!", |
6264 | ngIn, filename, problem->nGeomIn); |
6265 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6266 | if (*errors != NULL) *nErr = (*errors)->nError; |
6267 | caps_close(object, 0, NULL); |
6268 | caps_rmDir(root); |
6269 | return CAPS_MISMATCH; |
6270 | } |
6271 | if (ngOut != problem->nGeomOut) { |
6272 | snprintf(temp, PATH_MAX, "# Geometry Outs = %d -- from %s = %d (caps_open)!", |
6273 | ngOut, filename, problem->nGeomOut); |
6274 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6275 | if (*errors != NULL) *nErr = (*errors)->nError; |
6276 | caps_close(object, 0, NULL); |
6277 | caps_rmDir(root); |
6278 | return CAPS_MISMATCH; |
6279 | } |
6280 | |
6281 | if (problem->geomOut != NULL) |
6282 | for (i = j = 0; j < npmtr; j++) { |
6283 | ocsmGetPmtr(problem->modl, j+1, &type, &nrow, &ncol, name); |
6284 | if (type != OCSM_OUTPMTR) continue; |
6285 | if (strcmp(name, problem->geomOut[i]->name) != 0) { |
6286 | snprintf(temp, PATH_MAX, "%d Geometry Outs %s != %s (caps_open)!", |
6287 | i+1, name, problem->geomOut[i]->name); |
6288 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6289 | if (*errors != NULL) *nErr = (*errors)->nError; |
6290 | caps_close(object, 0, NULL); |
6291 | caps_rmDir(root); |
6292 | return CAPS_MISMATCH; |
6293 | } |
6294 | i++; |
6295 | } |
6296 | |
6297 | } else { |
6298 | |
6299 | |
6300 | if (problem->outLevel != 1) |
6301 | EG_setOutLevel(problem->context, problem->outLevel); |
6302 | #ifdef WIN32 |
6303 | snprintf(current, PATH_MAX, "%s\\capsRestart.egads", root); |
6304 | #else |
6305 | snprintf(current, PATH_MAX, "%s/capsRestart.egads", root); |
6306 | #endif |
6307 | status = EG_loadModel(problem->context, 1, current, &model); |
6308 | if (status != EGADS_SUCCESS) { |
6309 | snprintf(temp, PATH_MAX, "%s EG_loadModel = %d (caps_open)!", |
6310 | current, status); |
6311 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6312 | if (*errors != NULL) *nErr = (*errors)->nError; |
6313 | caps_close(object, 0, NULL); |
6314 | return status; |
6315 | } |
6316 | problem->modl = model; |
6317 | status = EG_getTopology(model, &ref, &oclass, &mtype, data, |
6318 | &problem->nBodies, &problem->bodies, &senses); |
6319 | if (status != EGADS_SUCCESS) { |
6320 | snprintf(temp, PATH_MAX, "%s EG_getTopology = %d (caps_open)!", |
6321 | current, status); |
6322 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6323 | if (*errors != NULL) *nErr = (*errors)->nError; |
6324 | caps_close(object, 0, NULL); |
6325 | return status; |
6326 | } |
6327 | nbody = problem->nBodies; |
6328 | |
6329 | if (problem->nBodies > 0) { |
6330 | problem->lunits = (char **) EG_alloc(problem->nBodies*sizeof(char *)); |
6331 | if ((problem->lunits != NULL) && (problem->bodies != NULL)) |
6332 | for (i = 0; i < problem->nBodies; i++) |
6333 | caps_fillLengthUnits(problem, problem->bodies[i], |
6334 | &problem->lunits[i]); |
6335 | } |
6336 | } |
6337 | |
6338 | |
6339 | if ((nbody > 0) && (problem->bodies != NULL) && |
6340 | (problem->analysis != NULL)) |
6341 | for (i = 0; i < problem->nAnalysis; i++) { |
6342 | analysis = (capsAnalysis *) problem->analysis[i]->blind; |
6343 | if (analysis == NULL) continue; |
6344 | status = caps_filter(problem, analysis); |
6345 | if (status != CAPS_SUCCESS) |
6346 | printf(" CAPS Warning: %s caps_filter = %d (caps_open)!\n", |
6347 | problem->analysis[i]->name, status); |
6348 | } |
6349 | |
6350 | |
6351 | if (problem->bounds != NULL) |
6352 | for (i = 0; i < problem->nBound; i++) { |
6353 | if (problem->bounds[i] == NULL) continue; |
6354 | if (problem->bounds[i]->magicnumber != CAPSMAGIC) continue; |
6355 | if (problem->bounds[i]->type != BOUND) continue; |
6356 | if (problem->bounds[i]->blind == NULL) continue; |
6357 | bound = (capsBound *) problem->bounds[i]->blind; |
6358 | for (j = 0; j < bound->nVertexSet; j++) { |
6359 | if (bound->vertexSet[j] == NULL) continue; |
6360 | if (bound->vertexSet[j]->magicnumber != CAPSMAGIC) continue; |
6361 | if (bound->vertexSet[j]->type != VERTEXSET) continue; |
6362 | if (bound->vertexSet[j]->blind == NULL) continue; |
6363 | vertexset = (capsVertexSet *) bound->vertexSet[j]->blind; |
6364 | if (vertexset->analysis != NULL) |
6365 | if (vertexset->analysis->blind != NULL) { |
6366 | analysis = (capsAnalysis *) vertexset->analysis->blind; |
6367 | vertexset->discr->dim = bound->dim; |
6368 | vertexset->discr->instStore = analysis->instStore; |
6369 | status = aim_Discr(problem->aimFPTR, analysis->loadName, |
6370 | problem->bounds[i]->name, vertexset->discr); |
6371 | if (status != CAPS_SUCCESS) { |
6372 | aim_FreeDiscr(problem->aimFPTR, analysis->loadName, |
6373 | vertexset->discr); |
6374 | snprintf(temp, PATH_MAX, "Bound = %s, Analysis = %s aimDiscr = %d", |
6375 | problem->bounds[i]->name, analysis->loadName, status); |
6376 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6377 | if (*errors != NULL) *nErr = (*errors)->nError; |
6378 | caps_close(object, 0, NULL); |
6379 | return status; |
6380 | } else { |
6381 | |
6382 | status = caps_checkDiscr(vertexset->discr, 129, line); |
6383 | if (status != CAPS_SUCCESS) { |
6384 | snprintf(temp, PATH_MAX, "Bound = %s, Analysis = %s chkDiscr=%d", |
6385 | problem->bounds[i]->name, analysis->loadName, status); |
6386 | caps_makeSimpleErr(NULL, CERROR, temp, line, NULL, errors); |
6387 | if (*errors != NULL) *nErr = (*errors)->nError; |
6388 | aim_FreeDiscr(problem->aimFPTR, analysis->loadName, |
6389 | vertexset->discr); |
6390 | caps_close(object, 0, NULL); |
6391 | return status; |
6392 | } |
6393 | } |
6394 | |
6395 | if (vertexset->nDataSets > 0) { |
6396 | dataset = (capsDataSet *) vertexset->dataSets[0]->blind; |
6397 | if (dataset->npts != vertexset->discr->nPoints) { |
6398 | snprintf(temp, PATH_MAX, "DataSet = %s, npts = %d %d!", |
6399 | vertexset->dataSets[0]->name, dataset->npts, |
6400 | vertexset->discr->nPoints); |
6401 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6402 | if (*errors != NULL) *nErr = (*errors)->nError; |
6403 | aim_FreeDiscr(problem->aimFPTR, analysis->loadName, |
6404 | vertexset->discr); |
6405 | caps_close(object, 0, NULL); |
6406 | return CAPS_MISMATCH; |
6407 | } |
6408 | } |
6409 | if (vertexset->nDataSets > 1) { |
6410 | dataset = (capsDataSet *) vertexset->dataSets[1]->blind; |
6411 | if (dataset->npts != vertexset->discr->nVerts) { |
6412 | snprintf(temp, PATH_MAX, "DataSet = %s, npts = %d %d!", |
6413 | vertexset->dataSets[1]->name, dataset->npts, |
6414 | vertexset->discr->nVerts); |
6415 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6416 | if (*errors != NULL) *nErr = (*errors)->nError; |
6417 | aim_FreeDiscr(problem->aimFPTR, analysis->loadName, |
6418 | vertexset->discr); |
6419 | caps_close(object, 0, NULL); |
6420 | return CAPS_MISMATCH; |
6421 | } |
6422 | } |
6423 | } |
6424 | } |
6425 | } |
6426 | |
6427 | } else if ((flag == oMODL) || (strcasecmp(&filename[idot],".csm") == 0)) { |
6428 | object->subtype = PARAMETRIC; |
6429 | object->name = EG_strdup(prName); |
6430 | object->last.nLines = 0; |
6431 | object->last.lines = NULL; |
6432 | object->last.pname = EG_strdup(prName); |
6433 | object->last.sNum = problem->sNum; |
6434 | caps_getStaticStrings(&problem->signature, &object->last.pID, |
6435 | &object->last.user); |
6436 | |
6437 | if (problem->outLevel != 1) ocsmSetOutLevel(problem->outLevel); |
6438 | |
6439 | if (flag == oFileName) { |
6440 | |
6441 | status = ocsmLoad((char *) filename, &problem->modl); |
6442 | if (status < SUCCESS) { |
6443 | snprintf(temp, PATH_MAX, "Cannot Load %s (caps_open)!", filename); |
6444 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6445 | if (*errors != NULL) *nErr = (*errors)->nError; |
6446 | caps_close(object, 0, NULL); |
6447 | return status; |
6448 | } |
6449 | MODL = (modl_T *) problem->modl; |
6450 | } else { |
6451 | problem->modl = MODL; |
6452 | } |
6453 | if (MODL == NULL) { |
6454 | caps_makeSimpleErr(NULL, CERROR, "Cannot get OpenCSM MODL (caps_open)!", |
6455 | NULL, NULL, errors); |
6456 | if (*errors != NULL) *nErr = (*errors)->nError; |
6457 | caps_close(object, 0, NULL); |
6458 | return CAPS_NOTFOUND; |
6459 | } |
6460 | MODL->context = problem->context; |
6461 | |
6462 | MODL->userdata = problem; |
6463 | |
6464 | MODL->tessAtEnd = 0; |
6465 | status = ocsmRegSizeCB(problem->modl, caps_sizeCB); |
6466 | if (status != SUCCESS) |
6467 | printf(" CAPS Warning: ocsmRegSizeCB = %d (caps_open)!\n", status); |
6468 | |
6469 | env = getenv("DUMPEGADS"); |
6470 | if (env != NULL) { |
6471 | MODL->dumpEgads = 1; |
6472 | MODL->loadEgads = 1; |
6473 | } |
6474 | |
6475 | |
6476 | status = ocsmCheck(problem->modl); |
6477 | if (status < SUCCESS) { |
6478 | snprintf(temp, PATH_MAX, "ocsmCheck = %d (caps_open)!", status); |
6479 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6480 | if (*errors != NULL) *nErr = (*errors)->nError; |
6481 | caps_close(object, 0, NULL); |
6482 | return status; |
6483 | } |
6484 | fflush(stdout); |
6485 | |
6486 | status = ocsmInfo(problem->modl, &nbrch, &npmtr, &nbody); |
6487 | if (status != SUCCESS) { |
6488 | snprintf(temp, PATH_MAX, "ocsmInfo returns %d (caps_open)!", status); |
6489 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6490 | if (*errors != NULL) *nErr = (*errors)->nError; |
6491 | caps_close(object, 0, NULL); |
6492 | return status; |
6493 | } |
6494 | |
6495 | |
6496 | for (ngIn = ngOut = i = 0; i < npmtr; i++) { |
6497 | status = ocsmGetPmtr(problem->modl, i+1, &type, &nrow, &ncol, name); |
6498 | if (status != SUCCESS) { |
6499 | caps_close(object, 0, NULL); |
6500 | return status; |
6501 | } |
6502 | if (type == OCSM_OUTPMTR) ngOut++; |
6503 | if (type == OCSM_DESPMTR) ngIn++; |
6504 | if (type == OCSM_CFGPMTR) ngIn++; |
6505 | if (type == OCSM_CONPMTR) ngIn++; |
6506 | } |
6507 | |
6508 | |
6509 | if (ngIn != 0) { |
6510 | problem->geomIn = (capsObject **) EG_alloc(ngIn*sizeof(capsObject *)); |
6511 | if (problem->geomIn == NULL) { |
6512 | caps_close(object, 0, NULL); |
6513 | return EGADS_MALLOC; |
6514 | } |
6515 | for (i = 0; i < ngIn; i++) problem->geomIn[i] = NULL; |
6516 | value = (capsValue *) EG_alloc(ngIn*sizeof(capsValue)); |
6517 | if (value == NULL) { |
6518 | caps_close(object, 0, NULL); |
6519 | return EGADS_MALLOC; |
6520 | } |
6521 | for (i = j = 0; j < npmtr; j++) { |
6522 | ocsmGetPmtr(problem->modl, j+1, &type, &nrow, &ncol, name); |
6523 | if ((type != OCSM_DESPMTR) && (type != OCSM_CFGPMTR) && |
6524 | (type != OCSM_CONPMTR)) continue; |
6525 | if ((nrow == 0) || (ncol == 0)) continue; |
6526 | value[i].nrow = nrow; |
6527 | value[i].ncol = ncol; |
6528 | value[i].type = Double; |
6529 | value[i].dim = Scalar; |
6530 | value[i].index = i+1; |
6531 | value[i].pIndex = j+1; |
6532 | value[i].lfixed = value[i].sfixed = Fixed; |
6533 | value[i].nullVal = NotAllowed; |
6534 | value[i].units = NULL; |
6535 | value[i].meshWriter = NULL; |
6536 | value[i].link = NULL; |
6537 | value[i].vals.reals = NULL; |
6538 | value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0; |
6539 | value[i].linkMethod = Copy; |
6540 | value[i].length = value[i].nrow*value[i].ncol; |
6541 | if ((ncol > 1) && (nrow > 1)) { |
6542 | value[i].dim = Array2D; |
6543 | } else if ((ncol > 1) || (nrow > 1)) { |
6544 | value[i].dim = Vector; |
6545 | } |
6546 | value[i].gInType = 0; |
6547 | if (type == OCSM_CFGPMTR) value[i].gInType = 1; |
6548 | if (type == OCSM_CONPMTR) value[i].gInType = 2; |
6549 | value[i].partial = NULL; |
6550 | value[i].nderiv = 0; |
6551 | value[i].derivs = NULL; |
6552 | |
6553 | status = caps_makeObject(&objs); |
6554 | if (status != CAPS_SUCCESS) { |
6555 | EG_free(value); |
6556 | caps_close(object, 0, NULL); |
6557 | return EGADS_MALLOC; |
6558 | } |
6559 | if (i == 0) objs->blind = value; |
6560 | |
6561 | objs->parent = object; |
6562 | |
6563 | objs->name = NULL; |
6564 | objs->type = VALUE; |
6565 | objs->subtype = GEOMETRYIN; |
6566 | objs->last.sNum = 1; |
6567 | |
6568 | objs->blind = &value[i]; |
6569 | |
6570 | problem->geomIn[i] = objs; |
6571 | i++; |
6572 | } |
6573 | problem->nGeomIn = ngIn; |
6574 | for (i = 0; i < ngIn; i++) { |
6575 | ocsmGetPmtr(problem->modl, value[i].pIndex, &type, &nrow, &ncol, name); |
6576 | if (nrow*ncol > 1) { |
6577 | reals = (double *) EG_alloc(nrow*ncol*sizeof(double)); |
6578 | if (reals == NULL) { |
6579 | caps_close(object, 0, NULL); |
6580 | return EGADS_MALLOC; |
6581 | } |
6582 | value[i].vals.reals = reals; |
6583 | } else { |
6584 | reals = &value[i].vals.real; |
6585 | } |
6586 | problem->geomIn[i]->name = EG_strdup(name); |
6587 | |
6588 | |
6589 | |
6590 | for (n = k = 0; k < nrow; k++) |
6591 | for (j = 0; j < ncol; j++, n++) { |
6592 | status = ocsmGetValu(problem->modl, value[i].pIndex, k+1, j+1, |
6593 | &reals[n], &dot); |
6594 | if (status != SUCCESS) { |
6595 | caps_close(object, 0, NULL); |
6596 | return status; |
6597 | } |
6598 | } |
6599 | if (type == OCSM_CFGPMTR) continue; |
6600 | status = ocsmGetBnds(problem->modl, value[i].pIndex, 1, 1, |
6601 | &lower, &upper); |
6602 | if (status != SUCCESS) continue; |
6603 | if ((lower != -HUGEQ) || (upper != HUGEQ)) { |
6604 | value[i].limits.dlims[0] = lower; |
6605 | value[i].limits.dlims[1] = upper; |
6606 | } |
6607 | } |
6608 | } |
6609 | |
6610 | |
6611 | if (ngOut != 0) { |
6612 | units = NULL; |
6613 | if (problem->lunits != NULL) units = problem->lunits[problem->nBodies-1]; |
6614 | problem->geomOut = (capsObject **) EG_alloc(ngOut*sizeof(capsObject *)); |
6615 | if (problem->geomOut == NULL) { |
6616 | caps_close(object, 0, NULL); |
6617 | return EGADS_MALLOC; |
6618 | } |
6619 | for (i = 0; i < ngOut; i++) problem->geomOut[i] = NULL; |
6620 | value = (capsValue *) EG_alloc(ngOut*sizeof(capsValue)); |
6621 | if (value == NULL) { |
6622 | caps_close(object, 0, NULL); |
6623 | return EGADS_MALLOC; |
6624 | } |
6625 | for (i = j = 0; j < npmtr; j++) { |
6626 | ocsmGetPmtr(problem->modl, j+1, &type, &nrow, &ncol, name); |
6627 | if (type != OCSM_OUTPMTR) continue; |
6628 | value[i].length = 1; |
6629 | value[i].type = DoubleDeriv; |
6630 | value[i].nrow = 1; |
6631 | value[i].ncol = 1; |
6632 | value[i].dim = Scalar; |
6633 | value[i].index = i+1; |
6634 | value[i].pIndex = j+1; |
6635 | value[i].lfixed = value[i].sfixed = Change; |
6636 | value[i].nullVal = IsNull; |
6637 | value[i].units = NULL; |
6638 | value[i].meshWriter = NULL; |
6639 | value[i].link = NULL; |
6640 | value[i].vals.reals = NULL; |
6641 | value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0; |
6642 | value[i].linkMethod = Copy; |
6643 | value[i].gInType = 0; |
6644 | value[i].partial = NULL; |
6645 | value[i].nderiv = 0; |
6646 | value[i].derivs = NULL; |
6647 | caps_geomOutUnits(name, units, &value[i].units); |
6648 | |
6649 | status = caps_makeObject(&objs); |
6650 | if (status != CAPS_SUCCESS) { |
6651 | for (k = 0; k < i; k++) |
6652 | if (value[k].length > 1) EG_free(value[k].vals.reals); |
6653 | EG_free(value); |
6654 | caps_close(object, 0, NULL); |
6655 | return EGADS_MALLOC; |
6656 | } |
6657 | |
6658 | objs->parent = object; |
6659 | |
6660 | objs->name = EG_strdup(name); |
6661 | objs->type = VALUE; |
6662 | objs->subtype = GEOMETRYOUT; |
6663 | objs->last.sNum = 0; |
6664 | |
6665 | objs->blind = &value[i]; |
6666 | |
6667 | problem->geomOut[i] = objs; |
6668 | problem->geomOut[i]->last.sNum = problem->sNum; |
6669 | i++; |
6670 | } |
6671 | problem->nGeomOut = ngOut; |
6672 | } |
6673 | |
6674 | |
6675 | #ifdef WIN32 |
6676 | snprintf(current, PATH_MAX, "%s\\capsCSMFilePath", root); |
6677 | #else |
6678 | snprintf(current, PATH_MAX, "%s/capsCSMFilePath", root); |
6679 | #endif |
6680 | caps_rmFile(current); |
6681 | status = ocsmGetFilelist(problem->modl, &fileList); |
6682 | if (status != CAPS_SUCCESS) { |
6683 | caps_close(object, 0, NULL); |
6684 | return status; |
6685 | } |
6686 | fp = fopen(current, "w"); |
6687 | if (fp == NULL) { |
6688 | EG_free(fileList); |
6689 | caps_close(object, 0, NULL); |
6690 | return CAPS_IOERR; |
6691 | } |
6692 | fprintf(fp, "%s\n", fileList); |
6693 | fclose(fp); |
6694 | EG_free(fileList); |
6695 | fflush(stdout); |
6696 | |
6697 | |
6698 | #ifdef WIN32 |
6699 | snprintf(current, PATH_MAX, "%s\\capsRestart.cpc", root); |
6700 | #else |
6701 | snprintf(current, PATH_MAX, "%s/capsRestart.cpc", root); |
6702 | #endif |
6703 | caps_rmFile(current); |
6704 | status = ocsmSave(problem->modl, current); |
6705 | if (status != CAPS_SUCCESS) { |
6706 | caps_close(object, 0, NULL); |
6707 | return status; |
6708 | } |
6709 | fflush(stdout); |
6710 | |
6711 | } else if ((flag == oEGO) || (strcasecmp(&filename[idot],".egads") == 0)) { |
6712 | object->subtype = STATIC; |
6713 | object->name = EG_strdup(prName); |
6714 | object->last.nLines = 0; |
6715 | object->last.lines = NULL; |
6716 | object->last.pname = EG_strdup(prName); |
6717 | object->last.sNum = problem->sNum; |
6718 | caps_getStaticStrings(&problem->signature, &object->last.pID, |
6719 | &object->last.user); |
6720 | if (flag == oFileName) { |
6721 | status = EG_loadModel(problem->context, 1, filename, &model); |
6722 | if (status != EGADS_SUCCESS) { |
6723 | caps_close(object, 0, NULL); |
6724 | return status; |
6725 | } |
6726 | } |
6727 | problem->modl = model; |
6728 | status = EG_getTopology(model, &ref, &oclass, &mtype, data, |
6729 | &problem->nBodies, &problem->bodies, &senses); |
6730 | if (status != EGADS_SUCCESS) { |
6731 | caps_close(object, 0, NULL); |
6732 | return status; |
6733 | } |
6734 | |
6735 | if (problem->nBodies > 0) { |
6736 | problem->lunits = (char **) EG_alloc(problem->nBodies*sizeof(char *)); |
6737 | if ((problem->lunits != NULL) && (problem->bodies != NULL)) |
6738 | for (i = 0; i < problem->nBodies; i++) |
6739 | caps_fillLengthUnits(problem, problem->bodies[i], |
6740 | &problem->lunits[i]); |
6741 | } |
6742 | |
6743 | |
6744 | status = EG_attributeNum(model, &nattr); |
6745 | if ((status == EGADS_SUCCESS) && (nattr != 0)) { |
6746 | for (ngIn = ngOut = i = 0; i < nattr; i++) { |
6747 | status = EG_attributeGet(model, i+1, &aname, &type, &len, &aints, |
6748 | &areals, &astring); |
6749 | if (status != EGADS_SUCCESS) continue; |
6750 | if (type != ATTRREAL) continue; |
6751 | if (strncmp(aname, "_outpmtr_", 9) == 0) ngOut++; |
6752 | if (strncmp(aname, "_despmtr_", 9) == 0) ngIn++; |
6753 | if (strncmp(aname, "_cfgpmtr_", 9) == 0) ngIn++; |
6754 | } |
6755 | |
6756 | |
6757 | if (ngIn != 0) { |
6758 | problem->geomIn = (capsObject **) EG_alloc(ngIn*sizeof(capsObject *)); |
6759 | if (problem->geomIn == NULL) { |
6760 | caps_close(object, 0, NULL); |
6761 | return EGADS_MALLOC; |
6762 | } |
6763 | for (i = 0; i < ngIn; i++) problem->geomIn[i] = NULL; |
6764 | value = (capsValue *) EG_alloc(ngIn*sizeof(capsValue)); |
6765 | if (value == NULL) { |
6766 | caps_close(object, 0, NULL); |
6767 | return EGADS_MALLOC; |
6768 | } |
6769 | for (i = j = 0; j < nattr; j++) { |
6770 | status = EG_attributeGet(model, j+1, &aname, &type, &len, &aints, |
6771 | &areals, &astring); |
6772 | if (status != EGADS_SUCCESS) continue; |
6773 | if (type != ATTRREAL) continue; |
6774 | if ((strncmp(aname, "_despmtr_", 9) != 0) && |
6775 | (strncmp(aname, "_cfgpmtr_", 9) != 0)) continue; |
6776 | value[i].nrow = len; |
6777 | value[i].ncol = 1; |
6778 | value[i].type = Double; |
6779 | value[i].dim = Scalar; |
6780 | value[i].index = value[i].pIndex = j+1; |
6781 | value[i].lfixed = value[i].sfixed = Fixed; |
6782 | value[i].nullVal = NotAllowed; |
6783 | value[i].units = NULL; |
6784 | value[i].meshWriter = NULL; |
6785 | value[i].link = NULL; |
6786 | value[i].vals.reals = NULL; |
6787 | value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0; |
6788 | value[i].linkMethod = Copy; |
6789 | value[i].gInType = (strncmp(aname, "_cfgpmtr_", 9) == 0) ? 1 : 0; |
6790 | value[i].partial = NULL; |
6791 | value[i].nderiv = 0; |
6792 | value[i].derivs = NULL; |
6793 | value[i].length = len; |
6794 | if (len > 1) value[i].dim = Vector; |
6795 | |
6796 | status = caps_makeObject(&objs); |
6797 | if (status != CAPS_SUCCESS) { |
6798 | EG_free(value); |
6799 | caps_close(object, 0, NULL); |
6800 | return EGADS_MALLOC; |
6801 | } |
6802 | if (i == 0) objs->blind = value; |
6803 | |
6804 | objs->parent = object; |
6805 | |
6806 | objs->name = NULL; |
6807 | objs->type = VALUE; |
6808 | objs->subtype = GEOMETRYIN; |
6809 | objs->last.sNum = 1; |
6810 | |
6811 | objs->blind = &value[i]; |
6812 | |
6813 | problem->geomIn[i] = objs; |
6814 | i++; |
6815 | } |
6816 | problem->nGeomIn = ngIn; |
6817 | for (i = 0; i < ngIn; i++) { |
6818 | EG_attributeGet(model, value[i].pIndex, &aname, &type, &len, &aints, |
6819 | &areals, &astring); |
6820 | if (len > 1) { |
6821 | reals = (double *) EG_alloc(len*sizeof(double)); |
6822 | if (reals == NULL) { |
6823 | caps_close(object, 0, NULL); |
6824 | return EGADS_MALLOC; |
6825 | } |
6826 | value[i].vals.reals = reals; |
6827 | } else { |
6828 | reals = &value[i].vals.real; |
6829 | } |
6830 | problem->geomIn[i]->name = EG_strdup(&aname[9]); |
6831 | for (j = 0; j < len; j++) reals[j] = areals[j]; |
6832 | } |
6833 | } |
6834 | |
6835 | |
6836 | if (ngOut != 0) { |
6837 | problem->geomOut = (capsObject **) EG_alloc(ngOut*sizeof(capsObject *)); |
6838 | if (problem->geomOut == NULL) { |
6839 | caps_close(object, 0, NULL); |
6840 | return EGADS_MALLOC; |
6841 | } |
6842 | for (i = 0; i < ngOut; i++) problem->geomOut[i] = NULL; |
6843 | value = (capsValue *) EG_alloc(ngOut*sizeof(capsValue)); |
6844 | if (value == NULL) { |
6845 | caps_close(object, 0, NULL); |
6846 | return EGADS_MALLOC; |
6847 | } |
6848 | for (i = j = 0; j < nattr; j++) { |
6849 | status = EG_attributeGet(model, j+1, &aname, &type, &len, &aints, |
6850 | &areals, &astring); |
6851 | if (status != EGADS_SUCCESS) continue; |
6852 | if (type != ATTRREAL) continue; |
6853 | if (strncmp(aname, "_outpmtr_", 9) != 0) continue; |
6854 | value[i].nrow = len; |
6855 | value[i].ncol = 1; |
6856 | value[i].type = Double; |
6857 | value[i].dim = Scalar; |
6858 | value[i].index = value[i].pIndex = j+1; |
6859 | value[i].lfixed = value[i].sfixed = Fixed; |
6860 | value[i].nullVal = NotAllowed; |
6861 | value[i].units = NULL; |
6862 | value[i].meshWriter = NULL; |
6863 | value[i].link = NULL; |
6864 | value[i].vals.reals = NULL; |
6865 | value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0; |
6866 | value[i].linkMethod = Copy; |
6867 | value[i].gInType = 0; |
6868 | value[i].partial = NULL; |
6869 | value[i].nderiv = 0; |
6870 | value[i].derivs = NULL; |
6871 | value[i].length = len; |
6872 | if (len > 1) value[i].dim = Vector; |
6873 | |
6874 | status = caps_makeObject(&objs); |
6875 | if (status != CAPS_SUCCESS) { |
6876 | EG_free(value); |
6877 | caps_close(object, 0, NULL); |
6878 | return EGADS_MALLOC; |
6879 | } |
6880 | if (i == 0) objs->blind = value; |
6881 | |
6882 | objs->parent = object; |
6883 | |
6884 | objs->name = NULL; |
6885 | objs->type = VALUE; |
6886 | objs->subtype = GEOMETRYOUT; |
6887 | objs->last.sNum = 1; |
6888 | |
6889 | objs->blind = &value[i]; |
6890 | |
6891 | problem->geomOut[i] = objs; |
6892 | i++; |
6893 | } |
6894 | problem->nGeomOut = ngOut; |
6895 | for (i = 0; i < ngOut; i++) { |
6896 | EG_attributeGet(model, value[i].pIndex, &aname, &type, &len, &aints, |
6897 | &areals, &astring); |
6898 | if (len > 1) { |
6899 | reals = (double *) EG_alloc(len*sizeof(double)); |
6900 | if (reals == NULL) { |
6901 | caps_close(object, 0, NULL); |
6902 | return EGADS_MALLOC; |
6903 | } |
6904 | value[i].vals.reals = reals; |
6905 | } else { |
6906 | reals = &value[i].vals.real; |
6907 | } |
6908 | problem->geomOut[i]->name = EG_strdup(&aname[9]); |
6909 | for (j = 0; j < len; j++) reals[j] = areals[j]; |
6910 | } |
6911 | } |
6912 | |
6913 | #ifdef WIN32 |
6914 | snprintf(current, PATH_MAX, "%s\\capsRestart.egads", root); |
6915 | #else |
6916 | snprintf(current, PATH_MAX, "%s/capsRestart.egads", root); |
6917 | #endif |
6918 | caps_rmFile(current); |
6919 | status = EG_saveModel(model, current); |
6920 | if (status != EGADS_SUCCESS) |
6921 | printf(" CAPS Warning: Cannot save EGADS file = %d\n", status); |
6922 | |
6923 | |
6924 | problem->geometry.sNum = 1; |
6925 | } |
6926 | |
6927 | } else { |
6928 | if (flag == oFileName) { |
6929 | snprintf(temp, PATH_MAX, |
6930 | "Start Flag = %d filename = %s NOT initialized (caps_open)!", |
6931 | flag, filename); |
6932 | } else { |
6933 | snprintf(temp, PATH_MAX, "Start Flag = %d NOT initialized (caps_open)!", |
6934 | flag); |
6935 | } |
6936 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6937 | if (*errors != NULL) *nErr = (*errors)->nError; |
6938 | caps_close(object, 0, NULL); |
6939 | return CAPS_BADINIT; |
6940 | } |
6941 | |
6942 | |
6943 | if ((flag == oPhaseName) || (flag == oPNreload)) { |
6944 | #ifdef WIN32 |
6945 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\capsJournal.txt", |
6946 | problem->root); |
6947 | #else |
6948 | snprintf(filename, PATH_MAX, "%s/capsRestart/capsJournal.txt", |
6949 | problem->root); |
6950 | #endif |
6951 | fp = fopen(filename, "w"); |
6952 | if (fp == NULL) { |
6953 | snprintf(temp, PATH_MAX, "Cannot open %s on Phase (caps_open)", |
6954 | filename); |
6955 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6956 | if (*errors != NULL) *nErr = (*errors)->nError; |
6957 | caps_close(object, 0, NULL); |
6958 | caps_rmDir(problem->root); |
6959 | return CAPS_DIRERR; |
6960 | } |
6961 | fprintf(fp, "%d %d\n", CAPSMAJOR, CAPSMINOR); |
6962 | env = getenv("ESP_ARCH"); |
6963 | if (env == NULL) { |
6964 | snprintf(temp, PATH_MAX, "ESP_ARCH env variable is not set! (caps_open)"); |
6965 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6966 | if (*errors != NULL) *nErr = (*errors)->nError; |
6967 | caps_close(object, 0, NULL); |
6968 | caps_rmDir(problem->root); |
6969 | return CAPS_JOURNALERR; |
6970 | } |
6971 | fprintf(fp, "%s\n", env); |
6972 | env = getenv("CASREV"); |
6973 | if (env == NULL) { |
6974 | snprintf(temp, PATH_MAX, "CASREV env variable is not set! (caps_open)"); |
6975 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6976 | if (*errors != NULL) *nErr = (*errors)->nError; |
6977 | caps_close(object, 0, NULL); |
6978 | caps_rmDir(problem->root); |
6979 | return CAPS_JOURNALERR; |
6980 | } |
6981 | fprintf(fp, "%s\n", env); |
6982 | fclose(fp); |
6983 | #ifdef WIN32 |
6984 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\capsJournal", problem->root); |
6985 | #else |
6986 | snprintf(filename, PATH_MAX, "%s/capsRestart/capsJournal", problem->root); |
6987 | #endif |
6988 | status = caps_rmFile(filename); |
6989 | if (status != CAPS_SUCCESS) |
6990 | printf(" CAPS Warning: Cannot delete %s (caps_open)!\n", filename); |
6991 | |
6992 | problem->jrnl = fopen(filename, "wb"); |
6993 | |
6994 | if (problem->jrnl == NULL) { |
6995 | snprintf(temp, PATH_MAX, "Cannot open %s on Phase (caps_open)", filename); |
6996 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
6997 | if (*errors != NULL) *nErr = (*errors)->nError; |
6998 | caps_close(object, 0, NULL); |
6999 | caps_rmDir(problem->root); |
7000 | return CAPS_DIRERR; |
7001 | } |
7002 | i = CAPS_OPEN; |
7003 | nw = fwrite(&i, sizeof(int), 1, problem->jrnl); |
7004 | if (nw != 1) goto owrterr; |
7005 | ret = problem->sNum; |
7006 | nw = fwrite(&ret, sizeof(CAPSLONG), 1, problem->jrnl); |
7007 | if (nw != 1) goto owrterr; |
7008 | i = CAPS_SUCCESS; |
7009 | nw = fwrite(&i, sizeof(int), 1, problem->jrnl); |
7010 | if (nw != 1) goto owrterr; |
7011 | |
7012 | ivec[0] = CAPSMAJOR; |
7013 | ivec[1] = CAPSMINOR; |
7014 | nw = fwrite(ivec, sizeof(int), 2, problem->jrnl); |
7015 | if (nw != 2) goto owrterr; |
7016 | |
7017 | ret = problem->sNum; |
7018 | nw = fwrite(&ret, sizeof(CAPSLONG), 1, problem->jrnl); |
7019 | if (nw != 1) goto owrterr; |
7020 | i = CAPS_OPEN; |
7021 | nw = fwrite(&i, sizeof(int), 1, problem->jrnl); |
7022 | if (nw != 1) goto owrterr; |
7023 | fflush(problem->jrnl); |
7024 | |
7025 | |
7026 | for (i = 0; i < problem->nEGADSmdl; i++) { |
7027 | #ifdef WIN32 |
7028 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\model%4.4d.egads", |
7029 | problem->root, i); |
7030 | #else |
7031 | snprintf(filename, PATH_MAX, "%s/capsRestart/model%4.4d.egads", |
7032 | problem->root, i); |
7033 | #endif |
7034 | status = caps_rmFile(filename); |
7035 | if (status != EGADS_SUCCESS) |
7036 | printf(" CAPS Warning: Cannot remove file: %s\n", filename); |
7037 | } |
7038 | problem->nEGADSmdl = 0; |
7039 | |
7040 | |
7041 | ret = 0; |
7042 | do { |
7043 | n = -1; |
7044 | sNum = problem->sNum+1; |
7045 | for (i = 0; i < problem->nAnalysis; i++) { |
7046 | |
7047 | aobject = problem->analysis[i]; |
7048 | |
7049 | if (aobject == NULL) continue; |
7050 | analysis = (capsAnalysis *) aobject->blind; |
7051 | if (analysis == NULL) continue; |
7052 | if (analysis->pre.sNum == 0) continue; |
7053 | if (aobject->last.sNum > sNum) continue; |
7054 | if (aobject->last.sNum <= ret) continue; |
7055 | n = i; |
7056 | sNum = aobject->last.sNum; |
7057 | } |
7058 | if (n == -1) continue; |
7059 | |
7060 | aobject = problem->analysis[n]; |
7061 | |
7062 | analysis = (capsAnalysis *) aobject->blind; |
7063 | if (analysis->nAnalysisIn > 0) |
7064 | valIn = (capsValue *) analysis->analysisIn[0]->blind; |
7065 | |
7066 | status = aim_PostAnalysis(problem->aimFPTR, analysis->loadName, |
7067 | analysis->instStore, &analysis->info, 1, |
7068 | valIn); |
7069 | analysis->info.inPost = 0; |
7070 | if (status != CAPS_SUCCESS) { |
7071 | snprintf(temp, PATH_MAX, "Post Analysis on %s (%d) returns %d (caps_open)!", |
7072 | analysis->loadName, analysis->info.instance, status); |
7073 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7074 | if (*errors != NULL) *nErr = (*errors)->nError; |
7075 | caps_close(object, 0, NULL); |
7076 | caps_rmDir(problem->root); |
7077 | return CAPS_BADINIT; |
7078 | } |
7079 | for (i = 0; i < analysis->nAnalysisOut; i++) { |
7080 | value = analysis->analysisOut[i]->blind; |
7081 | if (value == NULL) continue; |
7082 | if ((value->type != Pointer) && (value->type != PointerMesh)) continue; |
7083 | status = aim_CalcOutput(problem->aimFPTR, analysis->loadName, |
7084 | analysis->instStore, &analysis->info, i+1, value); |
7085 | if (status != CAPS_SUCCESS) |
7086 | printf(" CAPS Warning: aim_CalcOutput = %d (caps_open)\n", status); |
7087 | } |
7088 | ret = sNum; |
7089 | } while (n != -1); |
7090 | |
7091 | |
7092 | if (flag == oPNreload) { |
7093 | status = caps_phaseCSMreload(object, nErr, errors); |
7094 | if (status != CAPS_SUCCESS) { |
7095 | caps_close(object, 0, NULL); |
7096 | caps_rmDir(problem->root); |
7097 | return status; |
7098 | } |
7099 | } |
7100 | |
7101 | problem->jpos = 0; |
7102 | status = caps_writeProblem(object); |
7103 | if (status != CAPS_SUCCESS) { |
7104 | caps_close(object, 0, NULL); |
7105 | caps_rmDir(problem->root); |
7106 | return status; |
7107 | } |
7108 | |
7109 | *pobject = object; |
7110 | return CAPS_SUCCESS; |
7111 | } |
7112 | |
7113 | |
7114 | if (flag == oContinue) { |
7115 | #ifdef WIN32 |
7116 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\capsJournal.txt", |
7117 | problem->root); |
7118 | #else |
7119 | snprintf(filename, PATH_MAX, "%s/capsRestart/capsJournal.txt", |
7120 | problem->root); |
7121 | #endif |
7122 | fp = fopen(filename, "r"); |
7123 | if (fp == NULL) { |
7124 | snprintf(temp, PATH_MAX, "Cannot open %s on Continuation (caps_open)", |
7125 | filename); |
7126 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7127 | if (*errors != NULL) *nErr = (*errors)->nError; |
7128 | caps_close(object, 0, NULL); |
7129 | return CAPS_BADINIT; |
7130 | } else { |
7131 | fscanf(fp, "%d %d", &ivec[0], &ivec[1]); |
7132 | env = getenv("ESP_ARCH"); |
7133 | fscanf(fp, "%s", temp); |
7134 | units = getenv("CASREV"); |
7135 | fscanf(fp, "%s", filename); |
7136 | fclose(fp); |
7137 | i = 0; |
7138 | if ((env == NULL) && (strlen(temp) != 0)) i = 1; |
7139 | if ((units == NULL) && (strlen(filename) != 0)) i = 1; |
7140 | if (i == 0) { |
7141 | if (strcmp(env, temp) != 0) i = 1; |
7142 | if (strcmp(units, filename) != 0) i = 1; |
7143 | } |
7144 | if ((ivec[0] != CAPSMAJOR) || (ivec[1] != CAPSMINOR) || (i == 1)) { |
7145 | snprintf(temp, PATH_MAX, "Journal from CAPS %d.%d and running %d.%d!", |
7146 | ivec[0], ivec[1], CAPSMAJOR, CAPSMINOR); |
7147 | snprintf(current, PATH_MAX, "Architecture %s vs %s\n", temp, env); |
7148 | snprintf(root, PATH_MAX, "OpenCASCADE %s vs %s\n", filename, units); |
7149 | caps_makeSimpleErr(NULL, CERROR, temp, current, root, errors); |
7150 | if (*errors != NULL) *nErr = (*errors)->nError; |
7151 | caps_close(object, 0, NULL); |
7152 | return CAPS_BADINIT; |
7153 | } |
7154 | } |
7155 | |
7156 | #ifdef WIN32 |
7157 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\capsJournal", problem->root); |
7158 | #else |
7159 | snprintf(filename, PATH_MAX, "%s/capsRestart/capsJournal", problem->root); |
7160 | #endif |
7161 | |
7162 | problem->jrnl = fopen(filename, "rb"); |
7163 | |
7164 | if (problem->jrnl == NULL) { |
7165 | printf(" CAPS Error: Cannot open %s for read (caps_open)!\n", filename); |
7166 | caps_close(object, 0, NULL); |
7167 | return CAPS_DIRERR; |
7168 | } |
7169 | nw = fread(&i, sizeof(int), 1, problem->jrnl); |
7170 | if (nw != 1) goto owrterr; |
7171 | if (i != CAPS_OPEN) { |
7172 | caps_makeSimpleErr(NULL, CERROR, "Journal Sequence Fail 0 (caps_open)!", |
7173 | NULL, NULL, errors); |
7174 | if (*errors != NULL) *nErr = (*errors)->nError; |
7175 | caps_close(object, 0, NULL); |
7176 | return CAPS_IOERR; |
7177 | } |
7178 | nw = fread(&ret, sizeof(CAPSLONG), 1, problem->jrnl); |
7179 | if (nw != 1) goto owrterr; |
7180 | nw = fread(&i, sizeof(int), 1, problem->jrnl); |
7181 | if (nw != 1) goto owrterr; |
7182 | if (i != CAPS_SUCCESS) { |
7183 | caps_makeSimpleErr(NULL, CERROR, "Journal Sequence Fail 1 (caps_open)!", |
7184 | NULL, NULL, errors); |
7185 | if (*errors != NULL) *nErr = (*errors)->nError; |
7186 | caps_close(object, 0, NULL); |
7187 | return CAPS_IOERR; |
7188 | } |
7189 | nw = fread(ivec, sizeof(int), 2, problem->jrnl); |
7190 | if (nw != 2) goto owrterr; |
7191 | if ((ivec[0] != CAPSMAJOR) || (ivec[1] != CAPSMINOR)) { |
7192 | snprintf(temp, PATH_MAX, "Journal Sequence Fail %d %d (caps_open)!", |
7193 | ivec[0], ivec[1]); |
7194 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7195 | if (*errors != NULL) *nErr = (*errors)->nError; |
7196 | caps_close(object, 0, NULL); |
7197 | return CAPS_IOERR; |
7198 | } |
7199 | nw = fread(&ret, sizeof(CAPSLONG), 1, problem->jrnl); |
7200 | if (nw != 1) goto owrterr; |
7201 | nw = fread(&i, sizeof(int), 1, problem->jrnl); |
7202 | if (nw != 1) goto owrterr; |
7203 | if (i != CAPS_OPEN) { |
7204 | caps_makeSimpleErr(NULL, CERROR, "Journal Sequence Fail 2 (caps_open)!", |
7205 | NULL, NULL, errors); |
7206 | if (*errors != NULL) *nErr = (*errors)->nError; |
7207 | caps_close(object, 0, NULL); |
7208 | return CAPS_IOERR; |
7209 | } |
7210 | |
7211 | *pobject = object; |
7212 | return CAPS_SUCCESS; |
7213 | } |
7214 | |
7215 | |
7216 | problem->writer.sNum = problem->sNum; |
7217 | caps_fillDateTime(problem->writer.datetime); |
7218 | |
7219 | |
7220 | #ifdef WIN32 |
7221 | snprintf(current, PATH_MAX, "%s\\capsRestart", root); |
7222 | #else |
7223 | snprintf(current, PATH_MAX, "%s/capsRestart", root); |
7224 | #endif |
7225 | status = caps_statFile(current); |
7226 | if (status == EGADS_SUCCESS) { |
7227 | snprintf(temp, PATH_MAX, "%s is a flat file (caps_open)", current); |
7228 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7229 | if (*errors != NULL) *nErr = (*errors)->nError; |
7230 | caps_close(object, 0, NULL); |
7231 | return CAPS_DIRERR; |
7232 | } else if (status == EGADS_NOTFOUND) { |
7233 | status = caps_mkDir(current); |
7234 | if (status != EGADS_SUCCESS) { |
7235 | snprintf(temp, PATH_MAX, "Cannot mkDir %s (caps_open)", current); |
7236 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7237 | if (*errors != NULL) *nErr = (*errors)->nError; |
7238 | caps_close(object, 0, NULL); |
7239 | return status; |
7240 | } |
7241 | |
7242 | #ifdef WIN32 |
7243 | snprintf(filename, PATH_MAX, "%s\\geom.txt", current); |
7244 | snprintf(temp, PATH_MAX, "%s\\xxTempxx", current); |
7245 | #else |
7246 | snprintf(filename, PATH_MAX, "%s/geom.txt", current); |
7247 | snprintf(temp, PATH_MAX, "%s/xxTempxx", current); |
7248 | #endif |
7249 | fp = fopen(temp, "w"); |
7250 | if (fp == NULL) { |
7251 | snprintf(temp, PATH_MAX, "Cannot open %s (caps_open)\n", filename); |
7252 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7253 | if (*errors != NULL) *nErr = (*errors)->nError; |
7254 | caps_close(object, 0, NULL); |
7255 | return CAPS_DIRERR; |
7256 | } |
7257 | fprintf(fp, "%d %d\n", problem->nGeomIn, problem->nGeomOut); |
7258 | if (problem->geomIn != NULL) |
7259 | for (i = 0; i < problem->nGeomIn; i++) |
7260 | fprintf(fp, "%s\n", problem->geomIn[i]->name); |
7261 | if (problem->geomOut != NULL) |
7262 | for (i = 0; i < problem->nGeomOut; i++) |
7263 | fprintf(fp, "%s\n", problem->geomOut[i]->name); |
7264 | fclose(fp); |
7265 | status = caps_rename(temp, filename); |
7266 | if (status != CAPS_SUCCESS) { |
7267 | snprintf(temp, PATH_MAX, "Cannot rename %s (caps_open)!\n", filename); |
7268 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7269 | if (*errors != NULL) *nErr = (*errors)->nError; |
7270 | caps_close(object, 0, NULL); |
7271 | return status; |
7272 | } |
7273 | status = caps_dumpGeomVals(problem, 0); |
7274 | if (status != CAPS_SUCCESS) { |
7275 | caps_close(object, 0, NULL); |
7276 | return CAPS_DIRERR; |
7277 | } |
7278 | } |
7279 | status = caps_writeProblem(object); |
7280 | if (status != CAPS_SUCCESS) { |
7281 | caps_close(object, 0, NULL); |
7282 | return status; |
7283 | } |
7284 | |
7285 | |
7286 | #ifdef WIN32 |
7287 | snprintf(filename, PATH_MAX, "%s\\capsRestart\\capsJournal.txt", |
7288 | problem->root); |
7289 | #else |
7290 | snprintf(filename, PATH_MAX, "%s/capsRestart/capsJournal.txt", |
7291 | problem->root); |
7292 | #endif |
7293 | fp = fopen(filename, "w"); |
7294 | if (fp == NULL) { |
7295 | snprintf(temp, PATH_MAX, "Cannot open %s on Phase (caps_open)", filename); |
7296 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7297 | if (*errors != NULL) *nErr = (*errors)->nError; |
7298 | caps_close(object, 0, NULL); |
7299 | return CAPS_DIRERR; |
7300 | } |
7301 | fprintf(fp, "%d %d\n", CAPSMAJOR, CAPSMINOR); |
7302 | env = getenv("ESP_ARCH"); |
7303 | if (env == NULL) { |
7304 | snprintf(temp, PATH_MAX, "ESP_ARCH env variable is not set! (caps_open)"); |
7305 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7306 | if (*errors != NULL) *nErr = (*errors)->nError; |
7307 | caps_close(object, 0, NULL); |
7308 | return CAPS_JOURNALERR; |
7309 | } |
7310 | fprintf(fp, "%s\n", env); |
7311 | env = getenv("CASREV"); |
7312 | if (env == NULL) { |
7313 | snprintf(temp, PATH_MAX, "CASREV env variable is not set! (caps_open)"); |
7314 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7315 | if (*errors != NULL) *nErr = (*errors)->nError; |
7316 | caps_close(object, 0, NULL); |
7317 | return CAPS_JOURNALERR; |
7318 | } |
7319 | fprintf(fp, "%s\n", env); |
7320 | fclose(fp); |
7321 | #ifdef WIN32 |
7322 | snprintf(filename, PATH_MAX, "%s\\capsJournal", current); |
7323 | #else |
7324 | snprintf(filename, PATH_MAX, "%s/capsJournal", current); |
7325 | #endif |
7326 | |
7327 | problem->jrnl = fopen(filename, "wb"); |
7328 | |
7329 | if (problem->jrnl == NULL) { |
7330 | snprintf(temp, PATH_MAX, "Cannot open %s (caps_open)", filename); |
7331 | caps_makeSimpleErr(NULL, CERROR, temp, NULL, NULL, errors); |
7332 | if (*errors != NULL) *nErr = (*errors)->nError; |
7333 | caps_close(object, 0, NULL); |
7334 | return CAPS_DIRERR; |
7335 | } |
7336 | i = CAPS_OPEN; |
7337 | nw = fwrite(&i, sizeof(int), 1, problem->jrnl); |
7338 | if (nw != 1) goto owrterr; |
7339 | ret = 0; |
7340 | nw = fwrite(&ret, sizeof(CAPSLONG), 1, problem->jrnl); |
7341 | if (nw != 1) goto owrterr; |
7342 | i = CAPS_SUCCESS; |
7343 | nw = fwrite(&i, sizeof(int), 1, problem->jrnl); |
7344 | if (nw != 1) goto owrterr; |
7345 | |
7346 | ivec[0] = CAPSMAJOR; |
7347 | ivec[1] = CAPSMINOR; |
7348 | nw = fwrite(ivec, sizeof(int), 2, problem->jrnl); |
7349 | if (nw != 2) goto owrterr; |
7350 | |
7351 | ret = problem->sNum; |
7352 | nw = fwrite(&ret, sizeof(CAPSLONG), 1, problem->jrnl); |
7353 | if (nw != 1) goto owrterr; |
7354 | i = CAPS_OPEN; |
7355 | nw = fwrite(&i, sizeof(int), 1, problem->jrnl); |
7356 | if (nw != 1) goto owrterr; |
7357 | fflush(problem->jrnl); |
7358 | |
7359 | *pobject = object; |
7360 | return CAPS_SUCCESS; |
7361 | |
7362 | owrterr: |
7363 | fclose(problem->jrnl); |
7364 | printf(" CAPS Error: IO error on journal file (caps_open)!\n"); |
7365 | caps_makeSimpleErr(NULL, CERROR, "IO error on journal file (caps_open)!", |
7366 | NULL, NULL, errors); |
7367 | if (*errors != NULL) *nErr = (*errors)->nError; |
7368 | caps_close(object, 0, NULL); |
7369 | return CAPS_IOERR; |
7370 | } |
7371 | |
7372 | |
7373 | int |
7374 | caps_outLevel(capsObject *pobject, int outLevel) |
7375 | { |
7376 | int old; |
7377 | capsProblem *problem; |
7378 | |
7379 | if (pobject == NULL) return CAPS_NULLOBJ; |
7380 | if (pobject->magicnumber != CAPSMAGIC) return CAPS_BADOBJECT; |
7381 | if (pobject->type != PROBLEM) return CAPS_BADTYPE; |
7382 | if (pobject->blind == NULL) return CAPS_NULLBLIND; |
7383 | if ((outLevel < 0) || (outLevel > 2)) return CAPS_RANGEERR; |
7384 | problem = (capsProblem *) pobject->blind; |
7385 | problem->funID = CAPS_OUTLEVEL; |
7386 | |
7387 | if (pobject->subtype == PARAMETRIC) { |
7388 | ocsmSetOutLevel(outLevel); |
7389 | old = problem->outLevel; |
7390 | } else { |
7391 | old = EG_setOutLevel(problem->context, outLevel); |
7392 | } |
7393 | if (old >= 0) problem->outLevel = outLevel; |
7394 | |
7395 | return old; |
7396 | } |
7397 | |
7398 | |
7399 | int |
7400 | caps_getRootPath(capsObject *pobject, const char **root) |
7401 | { |
7402 | capsProblem *problem; |
7403 | |
7404 | *root = NULL; |
7405 | if (pobject == NULL) return CAPS_NULLOBJ; |
7406 | if (pobject->magicnumber != CAPSMAGIC) return CAPS_BADOBJECT; |
7407 | if (pobject->type != PROBLEM) return CAPS_BADTYPE; |
7408 | if (pobject->blind == NULL) return CAPS_NULLBLIND; |
7409 | problem = (capsProblem *) pobject->blind; |
7410 | problem->funID = CAPS_GETROOTPATH; |
7411 | |
7412 | *root = problem->root; |
7413 | |
7414 | return CAPS_SUCCESS; |
7415 | } |