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