Bug Summary

File:capsProblem.c
Warning:line 5649, column 25
Access to field 'blind' results in a dereference of a null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

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 * CAPS: Computational Aircraft Prototype Syntheses
3 *
4 * Problem Object Functions
5 *
6 * Copyright 2014-2022, Massachusetts Institute of Technology
7 * Licensed under The GNU Lesser General Public License, version 2.1
8 * See http://www.opensource.org/licenses/lgpl-2.1.php
9 *
10 */
11
12#include <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_MAX4096 _MAX_PATH
25#endif
26
27
28#include "udunits.h"
29
30#include "capsBase.h"
31#include "capsAIM.h"
32
33/* OpenCSM Defines & Includes */
34#include "common.h"
35#include "OpenCSM.h"
36#include "udp.h"
37
38
39typedef void (*blCB)(capsObj problem, capsObj obj, enum capstMethod tmethod,
40 char *name, enum capssType stype);
41
42static int CAPSnLock = 0;
43static char **CAPSlocks = NULL((void*)0);
44static int CAPSextSgnl = 1;
45static blCB CAPScallBack = NULL((void*)0);
46
47extern /*@null@*/
48 void *caps_initUnits();
49extern void caps_initFunIDs();
50extern void caps_initDiscr(capsDiscr *discr);
51extern int caps_freeError(/*@only@*/ capsErrs *errs);
52extern int caps_checkDiscr(capsDiscr *discr, int l, char *line);
53extern int caps_filter(capsProblem *problem, capsAnalysis *analysis);
54extern int caps_statFile(const char *path);
55extern int caps_rmFile(const char *path);
56extern int caps_rmDir(const char *path);
57extern void caps_rmWild(const char *path, const char *wild);
58extern int caps_mkDir(const char *path);
59extern int caps_cpDir(const char *src, const char *dst);
60extern int caps_rename(const char *src, const char *dst);
61extern int caps_intentPhrase(capsObj pobject, int nLines,
62 /*@null@*/ const char **lines);
63
64
65
66void
67caps_rmLock(void)
68{
69 int i;
70
71 for (i = 0; i < CAPSnLock; i++)
72 if (CAPSlocks[i] != NULL((void*)0))
73 caps_rmFile(CAPSlocks[i]);
74
75 for (i = 0; i < CAPSnLock; i++)
76 if (CAPSlocks[i] != NULL((void*)0))
77 EG_free(CAPSlocks[i]);
78
79 EG_free(CAPSlocks);
80 CAPSnLock = 0;
81 CAPSlocks = NULL((void*)0);
82
83 /* cleanup udp storage */
84 ocsmFree(NULL((void*)0));
85}
86
87
88void
89caps_rmLockOnClose(const char *root)
90{
91 int i, j;
92
93 for (i = 0; i < CAPSnLock; i++) {
94 if ((CAPSlocks[i] != NULL((void*)0)) &&
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
107void
108caps_externSignal()
109{
110 if (CAPSextSgnl == 1) {
111 atexit(caps_rmLock);
112 caps_initFunIDs();
113 }
114
115 CAPSextSgnl = 0;
116}
117
118
119static void
120caps_intHandler(int sig)
121{
122 caps_rmLock();
123 (void) signal(sig, SIG_DFL((__sighandler_t) 0));
124 raise(sig);
125}
126
127
128static void
129caps_initSignals()
130{
131 if (CAPSextSgnl <= 0) return;
132 atexit(caps_rmLock);
133 (void) signal(SIGSEGV11, caps_intHandler);
134 (void) signal(SIGINT2, caps_intHandler);
135#ifdef WIN32
136 (void) signal(SIGABRT6, caps_intHandler);
137#else
138/*@-unrecog@*/
139 (void) signal(SIGHUP1, caps_intHandler);
140 (void) signal(SIGBUS7, caps_intHandler);
141/*@+unrecog@*/
142#endif
143 caps_initFunIDs();
144
145 CAPSextSgnl = -1;
146}
147
148
149static void
150caps_brokenLinkCB(/*@unused@*/ capsObj problem, capsObj obj,
151 /*@unused@*/ enum capstMethod tmethod, char *name,
152 enum capssType stype)
153{
154 if (stype == GEOMETRYIN) {
155 /* link to GeometryIn */
156 printf(" CAPS BrokenLink: %s to lost %s (stype = %d)!\n",
157 obj->name, name, stype);
158 } else if (stype == GEOMETRYOUT) {
159 /* link from GeometryOut */
160 printf(" CAPS BrokenLink: lost %s (stype = %d) to %s!\n",
161 name, stype, obj->name);
162 } else if (stype == ANALYSISIN) {
163 /* link to AnalysisIn */
164 printf(" CAPS BrokenLink: %s to lost %s (stype = %d)!\n",
165 obj->name, name, stype);
166 } else if (stype == ANALYSISOUT) {
167 /* link from AnalysisOut */
168 printf(" CAPS BrokenLink: lost %s (stype = %d) to %s!\n",
169 name, stype, obj->name);
170 } else if (stype == PARAMETER) {
171 /* link from Parameter */
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
181int
182caps_isNameOK(const char *name)
183{
184 int i, n;
185
186 if (name == NULL((void*)0)) return CAPS_NULLNAME-308;
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-317;
193
194 return CAPS_SUCCESS0;
195}
196
197
198static int
199caps_prunePath(char *path)
200{
201 int i, j, k, len, hit;
202
203 /* first remove any "./" */
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 /* remove the levels */
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_SUCCESS0;
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 /* backup */
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-333;
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_SUCCESS0;
250}
251
252
253void
254caps_freeValue(capsValue *value)
255{
256 int i;
257
258 if (value == NULL((void*)0)) return;
259
260 if (value->units != NULL((void*)0)) EG_free(value->units);
261 if (value->meshWriter != NULL((void*)0)) 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((void*)0)) EG_free(value->partial);
272 if (value->derivs == NULL((void*)0)) return;
273 for (i = 0; i < value->nderiv; i++) {
274 if (value->derivs[i].name != NULL((void*)0)) EG_free(value->derivs[i].name);
275 if (value->derivs[i].deriv != NULL((void*)0)) EG_free(value->derivs[i].deriv);
276 }
277 EG_free(value->derivs);
278}
279
280
281void
282caps_freeFList(capsObject *obj)
283{
284 int i;
285 capsFList *flist, *next;
286
287 if (obj->flist == NULL((void*)0)) 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((void*)0));
312
313 obj->flist = NULL((void*)0);
314}
315
316
317int
318caps_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((void*)0);
330 if (obj == NULL((void*)0)) return CAPS_SUCCESS0;
331 if (obj->type == PROBLEM) {
332 path = (char *) EG_alloc(2*sizeof(char));
333 if (path == NULL((void*)0)) return EGADS_MALLOC-4;
334 path[0] = '.';
335 path[1] = 0;
336 *full = path;
337 return CAPS_SUCCESS0;
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((void*)0)) return EGADS_MALLOC-4;
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_SUCCESS0;
385}
386
387
388static int
389caps_string2obj(capsProblem *problem, /*@null@*/ const char *full,
390 capsObject **object)
391{
392 int i, j, in, it, is, pos, len, index;
393 char name[PATH_MAX4096];
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((void*)0);
403 if (full == NULL((void*)0)) return CAPS_SUCCESS0;
404 len = strlen(full);
405 if ((len == 1) && (full[0] == '.')) {
406 *object = problem->mySelf;
407 return CAPS_SUCCESS0;
408 }
409
410 obj = NULL((void*)0);
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-310;
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-310;
425 }
426 pos++;
427 if (full[pos] != '-') {
428 printf(" CAPS Error: %c not a seperator (caps_string2obj)\n", full[pos]);
429 return CAPS_BADOBJECT-310;
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 /* look at index */
439 index = atoi(&full[in]);
440 if (obj == NULL((void*)0)) {
441 /* in the problem */
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-304;
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-304;
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-304;
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-304;
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-310;
475 }
476 } else {
477 for (i = 0; i < problem->nBound; i++) {
478 if (problem->bounds[i] == NULL((void*)0)) continue;
479 bound = (capsBound *) problem->bounds[i]->blind;
480 if (bound == NULL((void*)0)) 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-304;
490 }
491 }
492 } else {
493 /* in an object */
494 if (it == 4) {
495 printf(" CAPS Error: Bad Bound child %s (caps_string2obj)\n", full);
496 return CAPS_BADOBJECT-310;
497 }
498 if (obj->type != ANALYSIS) {
499 printf(" CAPS Error: Bad Value child %s (caps_string2obj)\n", full);
500 return CAPS_BADOBJECT-310;
501 }
502 analysis = (capsAnalysis *) obj->blind;
503 if (analysis == NULL((void*)0)) {
504 printf(" CAPS Error: NULL Analysis %s (caps_string2obj)\n", full);
505 return CAPS_BADOBJECT-310;
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-304;
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-304;
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-304;
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-310;
532 }
533 }
534
535 } else {
536
537 /* name is from in to pos-1 */
538 j = 0;
539 for (i = in; i < pos; i++, j++) name[j] = full[i];
540 name[j] = 0;
541 if (obj == NULL((void*)0)) {
542 /* in Problem */
543 if (it != 3) {
544 printf(" CAPS Error: Incorrect type %d for Problem (caps_string2obj)\n",
545 it);
546 return CAPS_BADOBJECT-310;
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-303;
556 }
557 } else {
558 /* in Bound or VertexSet? */
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-310;
563 }
564 bound = (capsBound *) obj->blind;
565 if (bound == NULL((void*)0)) {
566 printf(" CAPS Error: NULL Bound %s (caps_string2obj)\n", full);
567 return CAPS_BADOBJECT-310;
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-303;
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-310;
584 }
585 vs = (capsVertexSet *) obj->blind;
586 if (vs == NULL((void*)0)) {
587 printf(" CAPS Error: NULL VertexSet %s (caps_string2obj)\n", full);
588 return CAPS_BADOBJECT-310;
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-303;
599 }
600 } else {
601 printf(" CAPS Error: Incorrect type %d for child (caps_string2obj)\n",
602 it);
603 return CAPS_BADOBJECT-310;
604 }
605 }
606 }
607
608 pos++;
609 } while (pos < len);
610
611 *object = obj;
612
613 return CAPS_SUCCESS0;
614}
615
616
617static int
618caps_writeDoubles(FILE *fp, int len, /*@null@*/ const double *reals)
619{
620 size_t n;
621
622 if (len < 0) return CAPS_BADINDEX-304;
623 if ((reals == NULL((void*)0)) && (len != 0)) return CAPS_NULLVALUE-307;
624 n = fwrite(&len, sizeof(int), 1, fp);
625 if (n != 1) return CAPS_IOERR-332;
626
627 if (reals == NULL((void*)0)) return CAPS_SUCCESS0;
628 n = fwrite(reals, sizeof(double), len, fp);
629 if (n != len) return CAPS_IOERR-332;
630
631 return CAPS_SUCCESS0;
632}
633
634
635static int
636caps_writeString(FILE *fp, /*@null@*/ const char *string)
637{
638 int len = 0;
639 size_t n;
640
641 if (string != NULL((void*)0)) len = strlen(string) + 1;
642 n = fwrite(&len, sizeof(int), 1, fp);
643 if (n != 1) return CAPS_IOERR-332;
644
645 if (string == NULL((void*)0)) return CAPS_SUCCESS0;
646 n = fwrite(string, sizeof(char), len, fp);
647 if (n != len) return CAPS_IOERR-332;
648
649 return CAPS_SUCCESS0;
650}
651
652
653static int
654caps_writeStrings(FILE *fp, int len, /*@null@*/ const char *string)
655{
656 int slen = 0, i;
657 size_t n;
658
659 if (string != NULL((void*)0))
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-332;
664
665 if (string == NULL((void*)0)) return CAPS_SUCCESS0;
666 n = fwrite(string, sizeof(char), slen, fp);
667 if (n != slen) return CAPS_IOERR-332;
668
669 return CAPS_SUCCESS0;
670}
671
672
673static int
674caps_writeTuple(FILE *fp, int len, enum capsNull nullVal,
675 /*@null@*/ capsTuple *tuple)
676{
677 int i, stat;
678
679 if (len < 0) return CAPS_BADINDEX-304;
680 if ((tuple == NULL((void*)0)) && (len != 0) && (nullVal != IsNull))
681 return CAPS_NULLVALUE-307;
682
683 if (tuple == NULL((void*)0)) return CAPS_SUCCESS0;
684 for (i = 0; i < len; i++) {
685 stat = caps_writeString(fp, tuple[i].name);
686 if (stat != CAPS_SUCCESS0) return stat;
687 stat = caps_writeString(fp, tuple[i].value);
688 if (stat != CAPS_SUCCESS0) return stat;
689 }
690
691 return CAPS_SUCCESS0;
692}
693
694
695static int
696caps_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-332;
703
704 if (own.pname == NULL((void*)0)) {
705 stat = caps_writeString(fp, writer.pname);
706 } else {
707 stat = caps_writeString(fp, own.pname);
708 }
709 if (stat != CAPS_SUCCESS0) return stat;
710 if (own.pID == NULL((void*)0)) {
711 stat = caps_writeString(fp, writer.pID);
712 } else {
713 stat = caps_writeString(fp, own.pID);
714 }
715 if (stat != CAPS_SUCCESS0) return stat;
716 if (own.user == NULL((void*)0)) {
717 stat = caps_writeString(fp, writer.user);
718 } else {
719 stat = caps_writeString(fp, own.user);
720 }
721 if (stat != CAPS_SUCCESS0) return stat;
722
723 n = fwrite(own.datetime, sizeof(short), 6, fp);
724 if (n != 6) return CAPS_IOERR-332;
725
726 n = fwrite(&own.sNum, sizeof(CAPSLONGunsigned long), 1, fp);
727 if (n != 1) return CAPS_IOERR-332;
728
729 return CAPS_SUCCESS0;
730}
731
732
733static int
734caps_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-332;
741 n = fwrite(&problem->nPhrase, sizeof(int), 1, fp);
742 if (n != 1) return CAPS_IOERR-332;
743 if (problem->nPhrase == 0) return CAPS_SUCCESS0;
744
745 for (j = 0; j < problem->nPhrase; j++) {
746 stat = caps_writeString(fp, problem->phrases[j].phase);
747 if (stat != CAPS_SUCCESS0) return stat;
748 nLines = 0;
749 if (problem->phrases[j].lines != NULL((void*)0)) nLines = problem->phrases[j].nLines;
750 n = fwrite(&nLines, sizeof(int), 1, fp);
751 if (n != 1) return CAPS_IOERR-332;
752 if ((problem->phrases[j].lines != NULL((void*)0)) && (nLines != 0))
753 for (i = 0; i < nLines; i++) {
754 stat = caps_writeString(fp, problem->phrases[j].lines[i]);
755 if (stat != CAPS_SUCCESS0) return stat;
756 }
757 }
758
759 return CAPS_SUCCESS0;
760}
761
762
763static int
764caps_writeHistory(FILE *fp, const capsObject *obj)
765{
766 int j, nHistory, stat;
767 size_t n;
768
769 /* deal with marker for deletion */
770 n = fwrite(&obj->delMark, sizeof(int), 1, fp);
771 if (n != 1) return CAPS_IOERR-332;
772
773 nHistory = obj->nHistory;
774 if (obj->history == NULL((void*)0)) nHistory = 0;
775 n = fwrite(&nHistory, sizeof(int), 1, fp);
776 if (n != 1) return CAPS_IOERR-332;
777 if (nHistory == 0) return CAPS_SUCCESS0;
778
779 if (obj->history != NULL((void*)0))
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-332;
783
784 stat = caps_writeString(fp, obj->history[j].pname);
785 if (stat != CAPS_SUCCESS0) return stat;
786 stat = caps_writeString(fp, obj->history[j].pID);
787 if (stat != CAPS_SUCCESS0) return stat;
788 stat = caps_writeString(fp, obj->history[j].user);
789 if (stat != CAPS_SUCCESS0) return stat;
790
791 n = fwrite(obj->history[j].datetime, sizeof(short), 6, fp);
792 if (n != 6) return CAPS_IOERR-332;
793
794 n = fwrite(&obj->history[j].sNum, sizeof(CAPSLONGunsigned long), 1, fp);
795 if (n != 1) return CAPS_IOERR-332;
796 }
797
798 return CAPS_SUCCESS0;
799}
800
801
802static int
803caps_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((void*)0)) nattr = attrs->nattrs;
811 n = fwrite(&nattr, sizeof(int), 1, fp);
812 if (n != 1) return CAPS_IOERR-332;
813 if ((nattr == 0) || (attrs == NULL((void*)0))) return CAPS_SUCCESS0;
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-332;
819 n = fwrite(&attr[i].length, sizeof(int), 1, fp);
820 if (n != 1) return CAPS_IOERR-332;
821 stat = caps_writeString(fp, attr[i].name);
822 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
823 if (attr[i].type == ATTRINT1) {
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-332;
831 } else if (attr[i].type == ATTRREAL2) {
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-332;
839 } else {
840 stat = caps_writeStrings(fp, attr[i].length, attr[i].vals.string);
841 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
842 }
843 }
844
845 return CAPS_SUCCESS0;
846}
847
848
849static int
850caps_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_SUCCESS0) return CAPS_IOERR-332;
859 stat = caps_writeOwn(fp, writer, obj->last);
860 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
861 stat = caps_writeAttrs(fp, obj->attrs);
862 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
863 stat = caps_writeString(fp, obj->name);
864 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
865 stat = caps_hierarchy(obj, &name);
866 if (stat != CAPS_SUCCESS0) return stat;
867 stat = caps_writeString(fp, name);
868 EG_free(name);
869 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
870
871 value = (capsValue *) obj->blind;
872 if (value == NULL((void*)0)) return CAPS_NULLVALUE-307;
873
874 n = fwrite(&value->type, sizeof(int), 1, fp);
875 if (n != 1) return CAPS_IOERR-332;
876 n = fwrite(&value->length, sizeof(int), 1, fp);
877 if (n != 1) return CAPS_IOERR-332;
878 n = fwrite(&value->dim, sizeof(int), 1, fp);
879 if (n != 1) return CAPS_IOERR-332;
880 n = fwrite(&value->nrow, sizeof(int), 1, fp);
881 if (n != 1) return CAPS_IOERR-332;
882 n = fwrite(&value->ncol, sizeof(int), 1, fp);
883 if (n != 1) return CAPS_IOERR-332;
884 n = fwrite(&value->lfixed, sizeof(int), 1, fp);
885 if (n != 1) return CAPS_IOERR-332;
886 n = fwrite(&value->sfixed, sizeof(int), 1, fp);
887 if (n != 1) return CAPS_IOERR-332;
888 n = fwrite(&value->nullVal, sizeof(int), 1, fp);
889 if (n != 1) return CAPS_IOERR-332;
890 n = fwrite(&value->index, sizeof(int), 1, fp);
891 if (n != 1) return CAPS_IOERR-332;
892 n = fwrite(&value->pIndex, sizeof(int), 1, fp);
893 if (n != 1) return CAPS_IOERR-332;
894 n = fwrite(&value->gInType, sizeof(int), 1, fp);
895 if (n != 1) return CAPS_IOERR-332;
896 n = fwrite(&value->nderiv, sizeof(int), 1, fp);
897 if (n != 1) return CAPS_IOERR-332;
898
899 if (value->type == Integer) {
900 n = fwrite(value->limits.ilims, sizeof(int), 2, fp);
901 if (n != 2) return CAPS_IOERR-332;
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-332;
905 }
906
907 stat = caps_writeString(fp, value->units);
908 if (stat != CAPS_SUCCESS0) return stat;
909 stat = caps_writeString(fp, value->meshWriter);
910 if (stat != CAPS_SUCCESS0) return stat;
911 name = NULL((void*)0);
912 if (value->link != NULL((void*)0)) {
913 stat = caps_hierarchy(value->link, &name);
914 if (stat != CAPS_SUCCESS0) 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_SUCCESS0) return stat;
922 n = fwrite(&value->linkMethod, sizeof(int), 1, fp);
923 if (n != 1) return CAPS_IOERR-332;
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-332;
931 } else {
932 n = fwrite(&value->vals.integer, sizeof(int), 1, fp);
933 if (n != 1) return CAPS_IOERR-332;
934 }
935 } else {
936 if ((value->type == Pointer) || (value->type == PointerMesh)) {
937 /* what do we do? */
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-332;
941 } else if (value->type == String) {
942 stat = caps_writeStrings(fp, value->length, value->vals.string);
943 if (stat != CAPS_SUCCESS0) 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_SUCCESS0) return stat;
948 } else {
949 n = fwrite(value->vals.integers, sizeof(int), value->length, fp);
950 if (n != value->length) return CAPS_IOERR-332;
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-332;
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_SUCCESS0) return stat;
963 n = fwrite(&value->derivs[i].len_wrt, sizeof(int), 1, fp);
964 if (n != 1) return CAPS_IOERR-332;
965 j = value->length*value->derivs[i].len_wrt;
966 if (value->derivs[i].deriv == NULL((void*)0)) j = 0;
967 if (j != 0) {
968 n = fwrite(value->derivs[i].deriv, sizeof(double), j, fp);
969 if (n != j) return CAPS_IOERR-332;
970 }
971 }
972 }
973
974 return CAPS_SUCCESS0;
975}
976
977
978int
979caps_writeValueObj(capsProblem *problem, capsObject *valobj)
980{
981 int status;
982 char filename[PATH_MAX4096], temp[PATH_MAX4096], *full;
983 FILE *fp;
984
985 if (problem->dbFlag == 1) {
986 printf(" CAPS Internal: In Debug Mode (caps_writeValueObj)!\n");
987 return CAPS_SUCCESS0;
988 }
989
990 status = caps_hierarchy(valobj, &full);
991 if (status != CAPS_SUCCESS0) {
992 printf(" CAPS Warning: caps_hierarchy = %d\n", status);
993 return status;
994 }
995#ifdef WIN32
996 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\%s", problem->root, full);
997 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\xxTempxx", problem->root);
998#else
999 snprintf(filename, PATH_MAX4096, "%s/capsRestart/%s", problem->root, full);
1000 snprintf(temp, PATH_MAX4096, "%s/capsRestart/xxTempxx", problem->root);
1001#endif
1002 EG_free(full);
1003
1004 fp = fopen(temp, "wb");
1005 if (fp == NULL((void*)0)) {
1006 printf(" CAPS Error: Cannot open %s!\n", filename);
1007 return CAPS_DIRERR-333;
1008 }
1009 status = caps_writeValue(fp, problem->writer, valobj);
1010 fclose(fp);
1011 if (status != CAPS_SUCCESS0) {
1012 printf(" CAPS Error: Cannot write %s!\n", filename);
1013 return status;
1014 }
1015 status = caps_rename(temp, filename);
1016 if (status != CAPS_SUCCESS0) {
1017 printf(" CAPS Error: Cannot rename %s!\n", filename);
1018 return status;
1019 }
1020
1021 return CAPS_SUCCESS0;
1022}
1023
1024
1025int
1026caps_dumpGeomVals(capsProblem *problem, int flag)
1027{
1028 int i, status;
1029 char filename[PATH_MAX4096], current[PATH_MAX4096], temp[PATH_MAX4096];
1030 FILE *fp;
1031
1032 if (problem->dbFlag == 1) {
1033 printf(" CAPS Internal: In Debug Mode (caps_dumpGeomVals)!\n");
1034 return CAPS_SUCCESS0;
1035 }
1036
1037#ifdef WIN32
1038 snprintf(current, PATH_MAX4096, "%s\\capsRestart", problem->root);
1039 snprintf(temp, PATH_MAX4096, "%s\\xxTempxx", current);
1040#else
1041 snprintf(current, PATH_MAX4096, "%s/capsRestart", problem->root);
1042 snprintf(temp, PATH_MAX4096, "%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_MAX4096, "%s\\VI-%4.4d", current, i+1);
1049#else
1050 snprintf(filename, PATH_MAX4096, "%s/VI-%4.4d", current, i+1);
1051#endif
1052 fp = fopen(temp, "wb");
1053 if (fp == NULL((void*)0)) {
1054 printf(" CAPS Error: Cannot open %s!\n", filename);
1055 return CAPS_DIRERR-333;
1056 }
1057 status = caps_writeValue(fp, problem->writer, problem->geomIn[i]);
1058 fclose(fp);
1059 if (status != CAPS_SUCCESS0) {
1060 printf(" CAPS Error: Cannot write %s!\n", filename);
1061 return status;
1062 }
1063 status = caps_rename(temp, filename);
1064 if (status != CAPS_SUCCESS0) {
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_MAX4096, "%s\\VO-%4.4d", current, i+1);
1074#else
1075 snprintf(filename, PATH_MAX4096, "%s/VO-%4.4d", current, i+1);
1076#endif
1077 fp = fopen(temp, "wb");
1078 if (fp == NULL((void*)0)) {
1079 printf(" CAPS Error: Cannot open %s!\n", filename);
1080 return CAPS_DIRERR-333;
1081 }
1082 status = caps_writeValue(fp, problem->writer, problem->geomOut[i]);
1083 fclose(fp);
1084 if (status != CAPS_SUCCESS0) {
1085 printf(" CAPS Error: Cannot write %s!\n", filename);
1086 return status;
1087 }
1088 status = caps_rename(temp, filename);
1089 if (status != CAPS_SUCCESS0) {
1090 printf(" CAPS Error: Cannot rename %s!\n", filename);
1091 return status;
1092 }
1093 }
1094
1095 return CAPS_SUCCESS0;
1096}
1097
1098
1099static int
1100caps_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_SUCCESS0;
1109 }
1110
1111 analysis = (capsAnalysis *) aobject->blind;
1112
1113 stat = caps_writeHistory(fp, aobject);
1114 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
1115 stat = caps_writeOwn(fp, problem->writer, aobject->last);
1116 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
1117 stat = caps_writeOwn(fp, problem->writer, analysis->pre);
1118 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
1119 stat = caps_writeAttrs(fp, aobject->attrs);
1120 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
1121 stat = caps_writeString(fp, aobject->name);
1122 if (stat != CAPS_SUCCESS0) return stat;
1123 stat = caps_writeString(fp, analysis->loadName);
1124 if (stat != CAPS_SUCCESS0) return stat;
1125 stat = caps_writeString(fp, analysis->path);
1126 if (stat != CAPS_SUCCESS0) return stat;
1127 stat = caps_writeString(fp, analysis->unitSys);
1128 if (stat != CAPS_SUCCESS0) return stat;
1129 stat = caps_writeString(fp, analysis->intents);
1130 if (stat != CAPS_SUCCESS0) return stat;
1131 n = fwrite(&analysis->major, sizeof(int), 1, fp);
1132 if (n != 1) return CAPS_IOERR-332;
1133 n = fwrite(&analysis->minor, sizeof(int), 1, fp);
1134 if (n != 1) return CAPS_IOERR-332;
1135 n = fwrite(&analysis->autoexec, sizeof(int), 1, fp);
1136 if (n != 1) return CAPS_IOERR-332;
1137 n = fwrite(&analysis->nField, sizeof(int), 1, fp);
1138 if (n != 1) return CAPS_IOERR-332;
1139 for (i = 0; i < analysis->nField; i++) {
1140 stat = caps_writeString(fp, analysis->fields[i]);
1141 if (stat != CAPS_SUCCESS0) 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-332;
1146 n = fwrite(analysis->fInOut, sizeof(int), analysis->nField, fp);
1147 if (n != analysis->nField) return CAPS_IOERR-332;
1148 }
1149 n = fwrite(&analysis->nAnalysisDynO, sizeof(int), 1, fp);
1150 if (n != 1) return CAPS_IOERR-332;
1151
1152 return CAPS_SUCCESS0;
1153}
1154
1155
1156int
1157caps_writeAnalysisObj(capsProblem *problem, capsObject *aobject)
1158{
1159 int status;
1160 char filename[PATH_MAX4096], current[PATH_MAX4096], temp[PATH_MAX4096];
1161 FILE *fp;
1162
1163 if (problem->dbFlag == 1) {
1164 printf(" CAPS Internal: In Debug Mode (caps_writAnalysisObj)!\n");
1165 return CAPS_SUCCESS0;
1166 }
1167
1168#ifdef WIN32
1169 snprintf(current, PATH_MAX4096, "%s\\capsRestart\\AN-%s",
1170 problem->root, aobject->name);
1171 snprintf(temp, PATH_MAX4096, "%s\\xxTempxx", current);
1172 snprintf(filename, PATH_MAX4096, "%s\\analysis", current);
1173#else
1174 snprintf(current, PATH_MAX4096, "%s/capsRestart/AN-%s",
1175 problem->root, aobject->name);
1176 snprintf(temp, PATH_MAX4096, "%s/xxTempxx", current);
1177 snprintf(filename, PATH_MAX4096, "%s/analysis", current);
1178#endif
1179
1180 fp = fopen(temp, "wb");
1181 if (fp == NULL((void*)0)) {
1182 printf(" CAPS Error: Cannot open %s!\n", filename);
1183 return CAPS_DIRERR-333;
1184 }
1185 status = caps_writeAnalysis(fp, problem, aobject);
1186 fclose(fp);
1187 if (status != CAPS_SUCCESS0) {
1188 printf(" CAPS Error: Cannot write Analysis %s!\n", filename);
1189 return status;
1190 }
1191 status = caps_rename(temp, filename);
1192 if (status != CAPS_SUCCESS0) {
1193 printf(" CAPS Error: Cannot rename %s!\n", filename);
1194 return status;
1195 }
1196
1197 return CAPS_SUCCESS0;
1198}
1199
1200
1201int
1202caps_dumpAnalysis(capsProblem *problem, capsObject *aobject)
1203{
1204 int i, status;
1205 char filename[PATH_MAX4096], current[PATH_MAX4096], temp[PATH_MAX4096];
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_SUCCESS0;
1212 }
1213
1214 analysis = (capsAnalysis *) aobject->blind;
1215#ifdef WIN32
1216 snprintf(current, PATH_MAX4096, "%s\\capsRestart\\AN-%s",
1217 problem->root, aobject->name);
1218 snprintf(temp, PATH_MAX4096, "%s\\xxTempxx", current);
1219 snprintf(filename, PATH_MAX4096, "%s\\analysis", current);
1220#else
1221 snprintf(current, PATH_MAX4096, "%s/capsRestart/AN-%s",
1222 problem->root, aobject->name);
1223 snprintf(temp, PATH_MAX4096, "%s/xxTempxx", current);
1224 snprintf(filename, PATH_MAX4096, "%s/analysis", current);
1225#endif
1226
1227 fp = fopen(temp, "wb");
1228 if (fp == NULL((void*)0)) {
1229 printf(" CAPS Error: Cannot open %s!\n", filename);
1230 return CAPS_DIRERR-333;
1231 }
1232 status = caps_writeAnalysis(fp, problem, aobject);
1233 fclose(fp);
1234 if (status != CAPS_SUCCESS0) {
1235 printf(" CAPS Error: Cannot write Analysis %s!\n", filename);
1236 return status;
1237 }
1238 status = caps_rename(temp, filename);
1239 if (status != CAPS_SUCCESS0) {
1240 printf(" CAPS Error: Cannot rename %s!\n", filename);
1241 return status;
1242 }
1243
1244#ifdef WIN32
1245 snprintf(filename, PATH_MAX4096, "%s\\analysis.txt", current);
1246 snprintf(temp, PATH_MAX4096, "%s\\xxTempxx", current);
1247#else
1248 snprintf(filename, PATH_MAX4096, "%s/analysis.txt", current);
1249 snprintf(temp, PATH_MAX4096, "%s/xxTempxx", current);
1250#endif
1251 fp = fopen(temp, "w");
1252 if (fp == NULL((void*)0)) {
1253 printf(" CAPS Error: Cannot open %s!\n", filename);
1254 return CAPS_DIRERR-333;
1255 }
1256 fprintf(fp, "%d %d %d\n", analysis->nAnalysisIn, analysis->nAnalysisOut,
1257 analysis->nAnalysisDynO);
1258 if (analysis->analysisIn != NULL((void*)0))
1259 for (i = 0; i < analysis->nAnalysisIn; i++)
1260 fprintf(fp, "%s\n", analysis->analysisIn[i]->name);
1261 if (analysis->analysisOut != NULL((void*)0))
1262 for (i = 0; i < analysis->nAnalysisOut; i++)
1263 fprintf(fp, "%s\n", analysis->analysisOut[i]->name);
1264 if (analysis->analysisDynO != NULL((void*)0))
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_SUCCESS0) {
1270 printf(" CAPS Error: Cannot rename %s!\n", filename);
1271 return status;
1272 }
1273
1274 /* remove any Dynamic Value Objects */
1275 caps_rmWild(current, "VD-*");
1276
1277 /* write the Value Objects */
1278
1279 if (analysis->analysisIn != NULL((void*)0))
1280 for (i = 0; i < analysis->nAnalysisIn; i++) {
1281 #ifdef WIN32
1282 snprintf(filename, PATH_MAX4096, "%s\\VI-%4.4d", current, i+1);
1283 #else
1284 snprintf(filename, PATH_MAX4096, "%s/VI-%4.4d", current, i+1);
1285 #endif
1286 fp = fopen(temp, "wb");
1287 if (fp == NULL((void*)0)) {
1288 printf(" CAPS Error: Cannot open %s!\n", filename);
1289 return CAPS_DIRERR-333;
1290 }
1291 status = caps_writeValue(fp, problem->writer, analysis->analysisIn[i]);
1292 fclose(fp);
1293 if (status != CAPS_SUCCESS0) {
1294 printf(" CAPS Error: Cannot write %s!\n", filename);
1295 return status;
1296 }
1297 status = caps_rename(temp, filename);
1298 if (status != CAPS_SUCCESS0) {
1299 printf(" CAPS Error: Cannot rename %s!\n", filename);
1300 return status;
1301 }
1302 }
1303
1304 if (analysis->analysisOut != NULL((void*)0))
1305 for (i = 0; i < analysis->nAnalysisOut; i++) {
1306 #ifdef WIN32
1307 snprintf(filename, PATH_MAX4096, "%s\\VO-%4.4d", current, i+1);
1308 #else
1309 snprintf(filename, PATH_MAX4096, "%s/VO-%4.4d", current, i+1);
1310 #endif
1311 fp = fopen(temp, "wb");
1312 if (fp == NULL((void*)0)) {
1313 printf(" CAPS Error: Cannot open %s!\n", filename);
1314 return CAPS_DIRERR-333;
1315 }
1316 status = caps_writeValue(fp, problem->writer, analysis->analysisOut[i]);
1317 fclose(fp);
1318 if (status != CAPS_SUCCESS0) {
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_SUCCESS0) {
1324 printf(" CAPS Error: Cannot rename %s!\n", filename);
1325 return status;
1326 }
1327 }
1328
1329
1330 if (analysis->analysisDynO != NULL((void*)0))
1331 for (i = 0; i < analysis->nAnalysisDynO; i++) {
1332 #ifdef WIN32
1333 snprintf(filename, PATH_MAX4096, "%s\\VD-%4.4d", current, i+1);
1334 #else
1335 snprintf(filename, PATH_MAX4096, "%s/VD-%4.4d", current, i+1);
1336 #endif
1337 fp = fopen(temp, "wb");
1338 if (fp == NULL((void*)0)) {
1339 printf(" CAPS Error: Cannot open %s!\n", filename);
1340 return CAPS_DIRERR-333;
1341 }
1342 status = caps_writeValue(fp, problem->writer, analysis->analysisDynO[i]);
1343 fclose(fp);
1344 if (status != CAPS_SUCCESS0) {
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_SUCCESS0) {
1350 printf(" CAPS Error: Cannot rename %s!\n", filename);
1351 return status;
1352 }
1353 }
1354
1355 return CAPS_SUCCESS0;
1356}
1357
1358
1359int
1360caps_writeDataSet(capsObject *dobject)
1361{
1362 int stat;
1363 char filename[PATH_MAX4096], temp[PATH_MAX4096], *full, *name=NULL((void*)0);
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_SUCCESS0) 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_SUCCESS0;
1378 }
1379
1380 stat = caps_hierarchy(dobject, &full);
1381 if (stat != CAPS_SUCCESS0) return stat;
1382#ifdef WIN32
1383 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\%s", problem->root, full);
1384 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\xxTempxx", problem->root);
1385#else
1386 snprintf(filename, PATH_MAX4096, "%s/capsRestart/%s", problem->root, full);
1387 snprintf(temp, PATH_MAX4096, "%s/capsRestart/xxTempxx", problem->root);
1388#endif
1389 EG_free(full);
1390
1391 fp = fopen(temp, "wb");
1392 if (fp == NULL((void*)0)) {
1393 printf(" CAPS Error: Cannot open %s!\n", filename);
1394 return CAPS_DIRERR-333;
1395 }
1396
1397 stat = caps_writeHistory(fp, dobject);
1398 if (stat != CAPS_SUCCESS0) goto wrterrs;
1399 stat = caps_writeOwn(fp, problem->writer, dobject->last);
1400 if (stat != CAPS_SUCCESS0) goto wrterrs;
1401 stat = caps_writeAttrs(fp, dobject->attrs);
1402 if (stat != CAPS_SUCCESS0) goto wrterrs;
1403 stat = caps_writeString(fp, dobject->name);
1404 if (stat != CAPS_SUCCESS0) 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_SUCCESS0) goto wrterrs;
1414
1415 stat = caps_writeDoubles(fp, ds->npts*ds->rank, ds->data);
1416 if (stat != CAPS_SUCCESS0) goto wrterrs;
1417
1418 name = NULL((void*)0);
1419 if (ds->link != NULL((void*)0)) {
1420 stat = caps_hierarchy(ds->link, &name);
1421 if (stat != CAPS_SUCCESS0) return stat;
1422 }
1423 stat = caps_writeString(fp, name);
1424 EG_free(name);
1425 if (stat != CAPS_SUCCESS0) 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_SUCCESS0) {
1432 printf(" CAPS Error: Cannot rename %s!\n", filename);
1433 return stat;
1434 }
1435
1436 return CAPS_SUCCESS0;
1437
1438wrterrs:
1439 fclose(fp);
1440 return CAPS_IOERR-332;
1441}
1442
1443
1444int
1445caps_dumpBound(capsObject *pobject, capsObject *bobject)
1446{
1447 int i, j, status;
1448 char filename[PATH_MAX4096], temp[PATH_MAX4096], *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_SUCCESS0;
1460 }
1461
1462#ifdef WIN32
1463 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\BN-%4.4d\\vSets.txt",
1464 problem->root, bound->index);
1465 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\BN-%4.4d\\xxTempxx",
1466 problem->root, bound->index);
1467#else
1468 snprintf(filename, PATH_MAX4096, "%s/capsRestart/BN-%4.4d/vSets.txt",
1469 problem->root, bound->index);
1470 snprintf(temp, PATH_MAX4096, "%s/capsRestart/BN-%4.4d/xxTempxx",
1471 problem->root, bound->index);
1472#endif
1473 fp = fopen(temp, "w");
1474 if (fp == NULL((void*)0)) {
1475 printf(" CAPS Error: Cannot open %s!\n", filename);
1476 return CAPS_DIRERR-333;
1477 }
1478 fprintf(fp, "%d\n", bound->nVertexSet);
1479 if (bound->vertexSet != NULL((void*)0))
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_SUCCESS0) {
1486 printf(" CAPS Error: Cannot rename %s!\n", filename);
1487 return status;
1488 }
1489
1490 if (bound->vertexSet != NULL((void*)0))
1491 for (i = 0; i < bound->nVertexSet; i++) {
1492 status = caps_hierarchy(bound->vertexSet[i], &full);
1493 if (status != CAPS_SUCCESS0) {
1494 printf(" CAPS Warning: caps_hierarchy = %d\n", status);
1495 continue;
1496 }
1497#ifdef WIN32
1498 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\%s", problem->root, full);
1499#else
1500 snprintf(filename, PATH_MAX4096, "%s/capsRestart/%s", problem->root, full);
1501#endif
1502 status = caps_mkDir(filename);
1503 if (status != CAPS_SUCCESS0) {
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_MAX4096, "%s\\capsRestart\\%s\\dSets.txt",
1510 problem->root, full);
1511 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\%s\\xxTempxx",
1512 problem->root, full);
1513#else
1514 snprintf(filename, PATH_MAX4096, "%s/capsRestart/%s/dSets.txt",
1515 problem->root, full);
1516 snprintf(temp, PATH_MAX4096, "%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((void*)0)) continue;
1522
1523 fp = fopen(temp, "w");
1524 if (fp == NULL((void*)0)) {
1525 printf(" CAPS Warning: Cannot open %s!\n", filename);
1526 continue;
1527 }
1528 fprintf(fp, "%d\n", vs->nDataSets);
1529 if (vs->dataSets != NULL((void*)0))
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_SUCCESS0) {
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_SUCCESS0)
1542 printf(" CAPS Warning: Cannot rename %s!\n", filename);
1543 }
1544
1545 return CAPS_SUCCESS0;
1546}
1547
1548
1549static int
1550caps_writeProblem(const capsObject *pobject)
1551{
1552 int i, ivec[2], stat;
1553 char filename[PATH_MAX4096], temp[PATH_MAX4096];
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_SUCCESS0;
1562 }
1563
1564#ifdef WIN32
1565 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\Problem", problem->root);
1566 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\xxTempxx", problem->root);
1567#else
1568 snprintf(filename, PATH_MAX4096, "%s/capsRestart/Problem", problem->root);
1569 snprintf(temp, PATH_MAX4096, "%s/capsRestart/xxTempxx", problem->root);
1570#endif
1571
1572 fp = fopen(temp, "wb");
1573 if (fp == NULL((void*)0)) {
1574 printf(" CAPS Error: Cannot open %s!\n", filename);
1575 return CAPS_DIRERR-333;
1576 }
1577 ivec[0] = CAPSMAJOR1;
1578 ivec[1] = CAPSMINOR21;
1579
1580 n = fwrite(&problem->sNum, sizeof(CAPSLONGunsigned long), 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_SUCCESS0) goto writerr;
1588 stat = caps_writeOwn(fp, problem->writer, pobject->last);
1589 if (stat != CAPS_SUCCESS0) goto writerr;
1590 stat = caps_writeAttrs(fp, pobject->attrs);
1591 if (stat != CAPS_SUCCESS0) goto writerr;
1592 stat = caps_writeString(fp, pobject->name);
1593 if (stat != CAPS_SUCCESS0) goto writerr;
1594 stat = caps_writeString(fp, problem->phName);
1595 if (stat != CAPS_SUCCESS0) goto writerr;
1596 stat = caps_writePhrases(fp, problem);
1597 if (stat != CAPS_SUCCESS0) goto writerr;
1598 stat = caps_writeOwn(fp, problem->writer, problem->geometry);
1599 if (stat != CAPS_SUCCESS0) 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((void*)0)) i = 0;
1612 n = fwrite(&i, sizeof(int), 1, fp);
1613 if (n != 1) goto writerr;
1614
1615 if (problem->regGIN != NULL((void*)0))
1616 for (i = 0; i < problem->nRegGIN; i++) {
1617 stat = caps_writeString(fp, problem->regGIN[i].name);
1618 if (stat != CAPS_SUCCESS0) 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_SUCCESS0) {
1631 Sleep(100); /* VMware filesystem sync issue? */
1632 stat = caps_rename(temp, filename);
1633 }
1634#endif
1635 if (stat != CAPS_SUCCESS0)
1636 printf(" CAPS Warning: Cannot rename %s!\n", filename);
1637
1638 return CAPS_SUCCESS0;
1639
1640writerr:
1641 fclose(fp);
1642 return CAPS_IOERR-332;
1643}
1644
1645
1646int
1647caps_writeVertexSet(capsObject *vobject)
1648{
1649 int i, dim, status;
1650 char filename[PATH_MAX4096], temp[PATH_MAX4096], *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_SUCCESS0) 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_SUCCESS0;
1665 }
1666
1667 status = caps_hierarchy(vobject, &full);
1668 if (status != CAPS_SUCCESS0) return status;
1669#ifdef WIN32
1670 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\%s\\vs", problem->root, full);
1671 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\xxTempxx", problem->root);
1672#else
1673 snprintf(filename, PATH_MAX4096, "%s/capsRestart/%s/vs", problem->root, full);
1674 snprintf(temp, PATH_MAX4096, "%s/capsRestart/xxTempxx", problem->root);
1675#endif
1676 EG_free(full);
1677
1678 fp = fopen(temp, "wb");
1679 if (fp == NULL((void*)0)) {
1680 printf(" CAPS Error: Cannot open %s!\n", filename);
1681 return CAPS_DIRERR-333;
1682 }
1683
1684 status = caps_writeHistory(fp, vobject);
1685 if (status != CAPS_SUCCESS0) goto wrterr;
1686 status = caps_writeOwn(fp, problem->writer, vobject->last);
1687 if (status != CAPS_SUCCESS0) goto wrterr;
1688 status = caps_writeAttrs(fp, vobject->attrs);
1689 if (status != CAPS_SUCCESS0) goto wrterr;
1690 status = caps_writeString(fp, vobject->name);
1691 if (status != CAPS_SUCCESS0) goto wrterr;
1692
1693 /* write needed discr info */
1694 dim = 0;
1695 if (vs->discr != NULL((void*)0)) dim = vs->discr->dim;
1696 n = fwrite(&dim, sizeof(int), 1, fp);
1697 if (n != 1) goto wrterr;
1698 if (vs->analysis != NULL((void*)0)) dim = 0;
1699
1700 if (dim != 0) {
1701/*@-nullderef@*/
1702#ifndef __clang_analyzer__1
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/*@+nullderef@*/
1711 }
1712 fclose(fp);
1713
1714 status = caps_rename(temp, filename);
1715 if (status != CAPS_SUCCESS0) {
1716 printf(" CAPS Error: Cannot rename %s!\n", filename);
1717 return status;
1718 }
1719
1720 return CAPS_SUCCESS0;
1721
1722wrterr:
1723 fclose(fp);
1724 return CAPS_IOERR-332;
1725}
1726
1727
1728int
1729caps_writeBound(const capsObject *bobject)
1730{
1731 int i, status;
1732 char filename[PATH_MAX4096], temp[PATH_MAX4096];
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_SUCCESS0;
1746 }
1747
1748#ifdef WIN32
1749 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\BN-%4.4d\\bound",
1750 problem->root, bound->index);
1751 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\BN-%4.4d\\xxTempxx",
1752 problem->root, bound->index);
1753#else
1754 snprintf(filename, PATH_MAX4096, "%s/capsRestart/BN-%4.4d/bound",
1755 problem->root, bound->index);
1756 snprintf(temp, PATH_MAX4096, "%s/capsRestart/BN-%4.4d/xxTempxx",
1757 problem->root, bound->index);
1758#endif
1759 fp = fopen(temp, "wb");
1760 if (fp == NULL((void*)0)) {
1761 printf(" CAPS Error: Cannot open %s!\n", filename);
1762 return CAPS_DIRERR-333;
1763 }
1764
1765 status = caps_writeHistory(fp, bobject);
1766 if (status != CAPS_SUCCESS0) goto werror;
1767 status = caps_writeOwn(fp, problem->writer, bobject->last);
1768 if (status != CAPS_SUCCESS0) goto werror;
1769 status = caps_writeAttrs(fp, bobject->attrs);
1770 if (status != CAPS_SUCCESS0) goto werror;
1771 status = caps_writeString(fp, bobject->name);
1772 if (status != CAPS_SUCCESS0) 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((void*)0)) i = bound->curve->nrank;
1788 n = fwrite(&i, sizeof(int), 1, fp);
1789 if (n != 1) goto werror;
1790 if (bound->curve != NULL((void*)0)) {
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_SUCCESS0) 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_SUCCESS0) goto werror;
1805 }
1806
1807 i = 0;
1808 if (bound->surface != NULL((void*)0)) i = bound->surface->nrank;
1809 n = fwrite(&i, sizeof(int), 1, fp);
1810 if (n != 1) goto werror;
1811 if (bound->surface != NULL((void*)0)) {
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_SUCCESS0) 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_SUCCESS0) goto werror;
1832 }
1833 fclose(fp);
1834
1835 status = caps_rename(temp, filename);
1836 if (status != CAPS_SUCCESS0) {
1837 printf(" CAPS Error: Cannot rename %s!\n", filename);
1838 return status;
1839 }
1840
1841 return CAPS_SUCCESS0;
1842
1843werror:
1844 fclose(fp);
1845 return CAPS_IOERR-332;
1846}
1847
1848
1849int
1850caps_writeObject(capsObject *object)
1851{
1852 int status = CAPS_SUCCESS0;
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_SUCCESS0) 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_SUCCESS0) 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
1880static int
1881caps_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((void*)0)) nError = errs->nError;
1889 n = fwrite(&nError, sizeof(int), 1, fp);
1890 if (n != 1) return CAPS_IOERR-332;
1891 if ((nError == 0) || (errs == NULL((void*)0))) return CAPS_SUCCESS0;
1892
1893 for (i = 0; i < nError; i++) {
1894 full = NULL((void*)0);
1895 if (errs->errors[i].errObj != NULL((void*)0)) {
1896 stat = caps_hierarchy(errs->errors[i].errObj, &full);
1897 if (stat != CAPS_SUCCESS0)
1898 printf(" CAPS Warning: caps_hierarchy = %d (caps_writeErrs)\n", stat);
1899 }
1900 stat = caps_writeString(fp, full);
1901 if (stat != CAPS_SUCCESS0) {
1902 printf(" CAPS Warning: caps_writeString = %d (caps_writeErrs)\n", stat);
1903 return CAPS_IOERR-332;
1904 }
1905 n = fwrite(&errs->errors[i].eType, sizeof(int), 1, fp);
1906 if (n != 1) return CAPS_IOERR-332;
1907 n = fwrite(&errs->errors[i].index, sizeof(int), 1, fp);
1908 if (n != 1) return CAPS_IOERR-332;
1909 n = fwrite(&errs->errors[i].nLines, sizeof(int), 1, fp);
1910 if (n != 1) return CAPS_IOERR-332;
1911 for (j = 0; j < errs->errors[i].nLines; j++) {
1912 stat = caps_writeString(fp, errs->errors[i].lines[j]);
1913 if (stat != CAPS_SUCCESS0) {
1914 printf(" CAPS Warning: %d caps_writeString = %d (caps_writeErrs)\n",
1915 j, stat);
1916 return CAPS_IOERR-332;
1917 }
1918 }
1919 }
1920
1921 return CAPS_SUCCESS0;
1922}
1923
1924
1925void
1926caps_jrnlWrite(int funID, capsProblem *problem, capsObject *obj, int status,
1927 int nargs, capsJrnl *args, CAPSLONGunsigned long sNum0, CAPSLONGunsigned long sNum)
1928{
1929 int i, j, stat;
1930 char filename[PATH_MAX4096], *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((void*)0)) return;
1942 if (problem->stFlag == CAPS_JOURNALERR-343) return;
1943
1944 n = fwrite(&problem->funID, sizeof(int), 1, problem->jrnl);
1945 if (n != 1) goto jwrterr;
1946 n = fwrite(&sNum0, sizeof(CAPSLONGunsigned long), 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_SUCCESS0) {
1960 n = fwrite(&obj->last.sNum, sizeof(CAPSLONGunsigned long), 1, problem->jrnl);
1961 if (n != 1) goto jwrterr;
1962 /* cleanup? */
1963 if (obj->flist != NULL((void*)0)) {
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_SUCCESS0) {
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_SUCCESS0) {
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_SUCCESS0) {
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_SUCCESS0) {
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_SUCCESS0) {
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_SUCCESS0) {
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_SUCCESS0) {
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_SUCCESS0) {
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_SUCCESS0) {
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_SUCCESS0) {
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((void*)0)) {
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_MAX4096, "%s\\capsRestart\\model%4.4d.egads",
2100 problem->root, problem->nEGADSmdl);
2101#else
2102 snprintf(filename, PATH_MAX4096, "%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_SUCCESS0)
2107 printf(" CAPS Warning: EG_saveModel = %d (caps_jrnlWrite)!\n",
2108 stat);
2109 if (args[i].members.model->oclass == MODEL26)
2110 EG_deleteObject(args[i].members.model);
2111 problem->nEGADSmdl++;
2112 }
2113 }
2114 }
2115
2116 n = fwrite(&sNum, sizeof(CAPSLONGunsigned long), 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_SUCCESS0) {
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_SUCCESS0)
2131 printf(" CAPS Warning: caps_writeProblem = %d (caps_jrnlWrite)!\n", stat);
2132
2133 return;
2134
2135jwrterr:
2136 printf(" CAPS ERROR: Writing Journal File -- disabled (funID = %s)\n",
2137 caps_funID[problem->funID]);
2138 fclose(problem->jrnl);
2139 problem->jrnl = NULL((void*)0);
2140}
2141
2142
2143static void
2144caps_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_SETVALUE82) &&
2156 (problem->funID != CAPS_READPARAMETERS24)) {
2157 printf(" CAPS Internal: caps_sizeCB called from funID = %d!\n",
2158 problem->funID);
2159 return;
2160 }
2161 if (problem->funID == CAPS_READPARAMETERS24) return;
2162
2163 /* find our GeometryIn index */
2164 for (index = 0; index < problem->nGeomIn; index++) {
2165 object = problem->geomIn[index];
2166 if (object == NULL((void*)0)) continue;
2167 if (object->blind == NULL((void*)0)) 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 printf(" ###### caps_sizeCB = %s %d -> %d %d -> %d ######\n",
2179 object->name, value->nrow, nrow, value->ncol, ncol);
2180 */
2181
2182 /* do we already have the correct size? If so, assume the data is correct */
2183 if ((nrow == value->nrow) && (ncol == value->ncol)) return;
2184
2185 /* get the updated data from OpenCSM -- it should get changed later */
2186 reals = NULL((void*)0);
2187 if (nrow*ncol != 1) {
2188 reals = (double *) EG_alloc(nrow*ncol*sizeof(double));
2189 if (reals == NULL((void*)0)) {
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_SUCCESS0)
2219 printf(" CAPS Warning: caps_writeValueObj = %d\n", status);
2220}
2221
2222
2223static int
2224caps_readString(FILE *fp, char **string)
2225{
2226 int len;
2227 size_t n;
2228
2229 *string = NULL((void*)0);
2230 n = fread(&len, sizeof(int), 1, fp);
2231 if (n != 1) return CAPS_IOERR-332;
2232 if (len < 0) return CAPS_IOERR-332;
2233 if (len == 0) return CAPS_SUCCESS0;
2234
2235 *string = (char *) EG_alloc(len*sizeof(char));
2236 if (*string == NULL((void*)0)) return EGADS_MALLOC-4;
2237
2238 n = fread(*string, sizeof(char), len, fp);
2239 if (n != len) {
2240 EG_free(*string);
2241 *string = NULL((void*)0);
2242 return CAPS_IOERR-332;
2243 }
2244
2245 return CAPS_SUCCESS0;
2246}
2247
2248
2249static int
2250caps_readStrings(FILE *fp, int len, char **string)
2251{
2252 int slen, n0, i;
2253 size_t n;
2254
2255 *string = NULL((void*)0);
2256 n = fread(&slen, sizeof(int), 1, fp);
2257 if (n != 1) return CAPS_IOERR-332;
2258 if (slen < 0) return CAPS_IOERR-332;
2259 if (slen == 0) return CAPS_SUCCESS0;
2260
2261 *string = (char *) EG_alloc(slen*sizeof(char));
2262 if (*string == NULL((void*)0)) return EGADS_MALLOC-4;
2263
2264 n = fread(*string, sizeof(char), slen, fp);
2265 if (n != slen) {
2266 EG_free(*string);
2267 *string = NULL((void*)0);
2268 return CAPS_IOERR-332;
2269 }
2270
2271 // check the len termincation charachters
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((void*)0);
2278 return CAPS_IOERR-332;
2279 }
2280
2281 return CAPS_SUCCESS0;
2282}
2283
2284
2285static int
2286caps_readDoubles(FILE *fp, int *len, double **reals)
2287{
2288 size_t n;
2289
2290 *reals = NULL((void*)0);
2291 n = fread(len, sizeof(int), 1, fp);
2292 if (n != 1) return CAPS_IOERR-332;
2293 if (*len < 0) return CAPS_IOERR-332;
2294 if (*len == 0) return CAPS_SUCCESS0;
2295
2296 *reals = (double *) EG_alloc(*len*sizeof(double));
2297 if (*reals == NULL((void*)0)) return EGADS_MALLOC-4;
2298
2299 n = fread(*reals, sizeof(double), *len, fp);
2300 if (n != *len) {
2301 EG_free(*reals);
2302 *reals = NULL((void*)0);
2303 return CAPS_IOERR-332;
2304 }
2305
2306 return CAPS_SUCCESS0;
2307}
2308
2309
2310static int
2311caps_readTuple(FILE *fp, int len, enum capsNull nullVal, capsTuple **tuple)
2312{
2313 int i, stat;
2314 capsTuple *tmp;
2315
2316 *tuple = NULL((void*)0);
2317 if (nullVal == IsNull) return CAPS_SUCCESS0;
2318 stat = caps_makeTuple(len, &tmp);
2319 if (stat != CAPS_SUCCESS0) return stat;
2320
2321 for (i = 0; i < len; i++) {
2322 stat = caps_readString(fp, &tmp[i].name);
2323 if (stat != CAPS_SUCCESS0) {
2324 caps_freeTuple(len, tmp);
2325 return stat;
2326 }
2327 stat = caps_readString(fp, &tmp[i].value);
2328 if (stat != CAPS_SUCCESS0) {
2329 caps_freeTuple(len, tmp);
2330 return stat;
2331 }
2332 }
2333 *tuple = tmp;
2334
2335 return CAPS_SUCCESS0;
2336}
2337
2338
2339static int
2340caps_readOwn(FILE *fp, capsOwn *own)
2341{
2342 int stat;
2343 size_t n;
2344
2345 own->index = -1;
2346 own->pname = NULL((void*)0);
2347 own->pID = NULL((void*)0);
2348 own->user = NULL((void*)0);
2349
2350 n = fread(&own->index, sizeof(int), 1, fp);
2351 if (n != 1) {
2352 caps_freeOwner(own);
2353 return CAPS_IOERR-332;
2354 }
2355
2356 stat = caps_readString(fp, &own->pname);
2357 if (stat != CAPS_SUCCESS0) return stat;
2358 stat = caps_readString(fp, &own->pID);
2359 if (stat != CAPS_SUCCESS0) {
2360 caps_freeOwner(own);
2361 return stat;
2362 }
2363 stat = caps_readString(fp, &own->user);
2364 if (stat != CAPS_SUCCESS0) {
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-332;
2373 }
2374
2375 n = fread(&own->sNum, sizeof(CAPSLONGunsigned long), 1, fp);
2376 if (n != 1) {
2377 caps_freeOwner(own);
2378 return CAPS_IOERR-332;
2379 }
2380
2381 return CAPS_SUCCESS0;
2382}
2383
2384
2385static int
2386caps_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-332;
2393 n = fread(&problem->nPhrase, sizeof(int), 1, fp);
2394 if (n != 1) return CAPS_IOERR-332;
2395 if (problem->nPhrase == 0) return CAPS_SUCCESS0;
2396
2397 problem->phrases = (capsPhrase *) EG_alloc(problem->nPhrase*
2398 sizeof(capsPhrase));
2399 if (problem->phrases == NULL((void*)0)) return EGADS_MALLOC-4;
2400
2401 for (j = 0; j < problem->nPhrase; j++) {
2402 problem->phrases[j].phase = NULL((void*)0);
2403 problem->phrases[j].nLines = 0;
2404 problem->phrases[j].lines = NULL((void*)0);
2405 }
2406
2407 for (j = 0; j < problem->nPhrase; j++) {
2408 stat = caps_readString(fp, &problem->phrases[j].phase);
2409 if (stat != CAPS_SUCCESS0) return stat;
2410
2411 n = fread(&nLines, sizeof(int), 1, fp);
2412 if (n != 1) return CAPS_IOERR-332;
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((void*)0)) return EGADS_MALLOC-4;
2418 for (i = 0; i < nLines; i++) problem->phrases[j].lines[i] = NULL((void*)0);
2419 for (i = 0; i < nLines; i++) {
2420 stat = caps_readString(fp, &problem->phrases[j].lines[i]);
2421 if (stat != CAPS_SUCCESS0) return stat;
2422 }
2423 }
2424 }
2425
2426 return CAPS_SUCCESS0;
2427}
2428
2429
2430static int
2431caps_readHistory(FILE *fp, capsObject *obj)
2432{
2433 int j, stat;
2434 size_t n;
2435
2436 /* deal with marker for deletion */
2437 n = fread(&obj->delMark, sizeof(int), 1, fp);
2438 if (n != 1) return CAPS_IOERR-332;
2439
2440 n = fread(&obj->nHistory, sizeof(int), 1, fp);
2441 if (n != 1) return CAPS_IOERR-332;
2442 if (obj->nHistory == 0) return CAPS_SUCCESS0;
2443
2444 obj->history = (capsOwn *) EG_alloc(obj->nHistory*sizeof(capsOwn));
2445 if (obj->history == NULL((void*)0)) {
2446 obj->nHistory = 0;
2447 return EGADS_MALLOC-4;
2448 }
2449
2450 for (j = 0; j < obj->nHistory; j++) {
2451 obj->history[j].index = -1;
2452 obj->history[j].pname = NULL((void*)0);
2453 obj->history[j].pID = NULL((void*)0);
2454 obj->history[j].user = NULL((void*)0);
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-332;
2460
2461 stat = caps_readString(fp, &obj->history[j].pname);
2462 if (stat != CAPS_SUCCESS0) return stat;
2463 stat = caps_readString(fp, &obj->history[j].pID);
2464 if (stat != CAPS_SUCCESS0) return stat;
2465 stat = caps_readString(fp, &obj->history[j].user);
2466 if (stat != CAPS_SUCCESS0) return stat;
2467
2468 n = fread(obj->history[j].datetime, sizeof(short), 6, fp);
2469 if (n != 6) return CAPS_IOERR-332;
2470
2471 n = fread(&obj->history[j].sNum, sizeof(CAPSLONGunsigned long), 1, fp);
2472 if (n != 1) return CAPS_IOERR-332;
2473 }
2474
2475 return CAPS_SUCCESS0;
2476}
2477
2478
2479static int
2480caps_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((void*)0);
2488 n = fread(&nattr, sizeof(int), 1, fp);
2489 if (n != 1) return CAPS_IOERR-332;
2490 if (nattr == 0) return CAPS_SUCCESS0;
2491
2492 attrs = (egAttrs *) EG_alloc(sizeof(egAttrs));
2493 if (attrs == NULL((void*)0)) return EGADS_MALLOC-4;
2494 attr = (egAttr *) EG_alloc(nattr*sizeof(egAttr));
2495 if (attr == NULL((void*)0)) {
2496 EG_free(attrs);
2497 return EGADS_MALLOC-4;
2498 }
2499 attrs->nattrs = nattr;
2500 attrs->attrs = attr;
2501 attrs->nseqs = 0;
2502 attrs->seqs = NULL((void*)0);
2503 for (i = 0; i < nattr; i++) {
2504 attr[i].name = NULL((void*)0);
2505 attr[i].length = 1;
2506 attr[i].type = ATTRINT1;
2507 }
2508
2509/*@-mustfreefresh@*/
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-332;
2515 }
2516 n = fread(&attr[i].length, sizeof(int), 1, fp);
2517 if (n != 1) {
2518 caps_freeAttrs(&attrs);
2519 return CAPS_IOERR-332;
2520 }
2521 stat = caps_readString(fp, &attr[i].name);
2522 if (stat != CAPS_SUCCESS0) {
2523 caps_freeAttrs(&attrs);
2524 return CAPS_IOERR-332;
2525 }
2526 if (attr[i].type == ATTRINT1) {
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((void*)0)) {
2533 caps_freeAttrs(&attrs);
2534 return EGADS_MALLOC-4;
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-332;
2541 }
2542 } else if (attr[i].type == ATTRREAL2) {
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((void*)0)) {
2549 caps_freeAttrs(&attrs);
2550 return EGADS_MALLOC-4;
2551 }
2552 n = fread(attr[i].vals.reals, sizeof(double), attr[i].length, fp);
2553 }
2554 if (n != attr[i].length) return CAPS_IOERR-332;
2555 } else {
2556 stat = caps_readStrings(fp, attr[i].length, &attr[i].vals.string);
2557 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
2558 }
2559 }
2560/*@+mustfreefresh@*/
2561
2562 *attrx = attrs;
2563 return CAPS_SUCCESS0;
2564}
2565
2566
2567static int
2568caps_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_SUCCESS0) return CAPS_IOERR-332;
2579 stat = caps_readOwn(fp, &obj->last);
2580 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
2581 stat = caps_readAttrs(fp, &obj->attrs);
2582 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
2583 stat = caps_readString(fp, &obj->name);
2584 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
2585 stat = caps_readString(fp, &name);
2586 EG_free(name);
2587 if (stat != CAPS_SUCCESS0) return CAPS_IOERR-332;
2588
2589 n = fread(&value->type, sizeof(int), 1, fp);
2590 if (n != 1) return CAPS_IOERR-332;
2591 n = fread(&value->length, sizeof(int), 1, fp);
2592 if (n != 1) return CAPS_IOERR-332;
2593 n = fread(&value->dim, sizeof(int), 1, fp);
2594 if (n != 1) return CAPS_IOERR-332;
2595 n = fread(&value->nrow, sizeof(int), 1, fp);
2596 if (n != 1) return CAPS_IOERR-332;
2597 n = fread(&value->ncol, sizeof(int), 1, fp);
2598 if (n != 1) return CAPS_IOERR-332;
2599 n = fread(&value->lfixed, sizeof(int), 1, fp);
2600 if (n != 1) return CAPS_IOERR-332;
2601 n = fread(&value->sfixed, sizeof(int), 1, fp);
2602 if (n != 1) return CAPS_IOERR-332;
2603 n = fread(&value->nullVal, sizeof(int), 1, fp);
2604 if (n != 1) return CAPS_IOERR-332;
2605 n = fread(&value->index, sizeof(int), 1, fp);
2606 if (n != 1) return CAPS_IOERR-332;
2607 n = fread(&value->pIndex, sizeof(int), 1, fp);
2608 if (n != 1) return CAPS_IOERR-332;
2609 n = fread(&value->gInType, sizeof(int), 1, fp);
2610 if (n != 1) return CAPS_IOERR-332;
2611 n = fread(&value->nderiv, sizeof(int), 1, fp);
2612 if (n != 1) return CAPS_IOERR-332;
2613
2614 if (value->type == Integer) {
2615 n = fread(value->limits.ilims, sizeof(int), 2, fp);
2616 if (n != 2) return CAPS_IOERR-332;
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-332;
2620 }
2621
2622 stat = caps_readString(fp, &value->units);
2623 if (stat != CAPS_SUCCESS0) return stat;
2624 stat = caps_readString(fp, &value->meshWriter);
2625 if (stat != CAPS_SUCCESS0) return stat;
2626 stat = caps_readString(fp, &name);
2627 if (stat != CAPS_SUCCESS0) 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_SUCCESS0) return stat;
2634 n = fread(&value->linkMethod, sizeof(int), 1, fp);
2635 if (n != 1) return CAPS_IOERR-332;
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-332;
2643 } else {
2644 n = fread(&value->vals.integer, sizeof(int), 1, fp);
2645 if (n != 1) return CAPS_IOERR-332;
2646 }
2647 } else {
2648 if ((value->type == Pointer) || (value->type == PointerMesh)) {
2649 /* Indicate that the value object needs to be updated */
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((void*)0)) return EGADS_MALLOC-4;
2654 n = fread(value->vals.reals, sizeof(double), value->length, fp);
2655 if (n != value->length) return CAPS_IOERR-332;
2656 } else if (value->type == String) {
2657 stat = caps_readStrings(fp, value->length, &value->vals.string);
2658 if (stat != CAPS_SUCCESS0) return stat;
2659 } else if (value->type == Tuple) {
2660 value->vals.tuple = NULL((void*)0);
2661 if (value->length != 0) {
2662 stat = caps_readTuple(fp, value->length, value->nullVal,
2663 &value->vals.tuple);
2664 if (stat != CAPS_SUCCESS0) return stat;
2665 }
2666 } else {
2667 value->vals.integers = EG_alloc(value->length*sizeof(int));
2668 if (value->vals.integers == NULL((void*)0)) return EGADS_MALLOC-4;
2669 n = fread(value->vals.integers, sizeof(int), value->length, fp);
2670 if (n != value->length) return CAPS_IOERR-332;
2671 }
2672 }
2673
2674 if (value->nullVal == IsPartial) {
2675 value->partial = EG_alloc(value->length*sizeof(int));
2676 if (value->partial == NULL((void*)0)) return EGADS_MALLOC-4;
2677 n = fread(value->partial, sizeof(int), value->length, fp);
2678 if (n != value->length) return CAPS_IOERR-332;
2679 }
2680
2681 if (value->nderiv != 0) {
2682 value->derivs = (capsDeriv *) EG_alloc(value->nderiv*sizeof(capsDeriv));
2683 if (value->derivs == NULL((void*)0)) return EGADS_MALLOC-4;
2684 for (i = 0; i < value->nderiv; i++) {
2685 value->derivs[i].name = NULL((void*)0);
2686 value->derivs[i].len_wrt = 0;
2687 value->derivs[i].deriv = NULL((void*)0);
2688 }
2689 for (i = 0; i < value->nderiv; i++) {
2690 stat = caps_readString(fp, &value->derivs[i].name);
2691 if (stat != CAPS_SUCCESS0) return stat;
2692 n = fread(&value->derivs[i].len_wrt, sizeof(int), 1, fp);
2693 if (n != 1) return CAPS_IOERR-332;
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((void*)0)) return EGADS_MALLOC-4;
2698 n = fread(value->derivs[i].deriv, sizeof(double), j, fp);
2699 if (n != j) return CAPS_IOERR-332;
2700 }
2701 }
2702 }
2703
2704 return CAPS_SUCCESS0;
2705}
2706
2707
2708static int
2709caps_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((void*)0);
2718 fp = problem->jrnl;
2719 n = fread(&nError, sizeof(int), 1, fp);
2720 if (n != 1) return CAPS_IOERR-332;
2721 if (nError == 0) return CAPS_SUCCESS0;
2722
2723 errs = (capsErrs *) EG_alloc(sizeof(capsErrs));
2724 if (errs == NULL((void*)0)) return EGADS_MALLOC-4;
2725 errs->nError = nError;
2726 errs->errors = (capsError *) EG_alloc(nError*sizeof(capsError));
2727 if (errs->errors == NULL((void*)0)) {
2728 EG_free(errs);
2729 return EGADS_MALLOC-4;
2730 }
2731 for (i = 0; i < nError; i++) {
2732 errs->errors[i].nLines = 0;
2733 errs->errors[i].lines = NULL((void*)0);
2734 }
2735
2736 for (i = 0; i < nError; i++) {
2737 stat = caps_readString(fp, &full);
2738 if (stat != CAPS_SUCCESS0) {
2739 printf(" CAPS Warning: caps_readString = %d (caps_readErrs)\n", stat);
2740 caps_freeError(errs);
2741 return CAPS_IOERR-332;
2742 }
2743 stat = caps_string2obj(problem, full, &errs->errors[i].errObj);
2744 EG_free(full);
2745 if (stat != CAPS_SUCCESS0)
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((void*)0)) {
2757 caps_freeError(errs);
2758 return EGADS_MALLOC-4;
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_SUCCESS0) {
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_SUCCESS0;
2772
2773readErr:
2774/*@-dependenttrans@*/
2775 caps_freeError(errs);
2776/*@+dependenttrans@*/
2777 return CAPS_IOERR-332;
2778}
2779
2780
2781int
2782caps_jrnlEnd(capsProblem *problem)
2783{
2784#ifdef WIN32
2785 __int64 fpos;
2786#else
2787 long fpos;
2788#endif
2789
2790 if (problem->jrnl == NULL((void*)0)) return CAPS_STATEERR-329;
2791 if (problem->stFlag == CAPS_JOURNALERR-343) return CAPS_JOURNALERR-343;
2792 if (problem->stFlag != oContinue) return CAPS_STATEERR-329;
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-336;
2805 return CAPS_SUCCESS0;
2806}
2807
2808
2809int
2810caps_jrnlRead(int funID, capsProblem *problem, capsObject *obj, int nargs,
2811 capsJrnl *args, CAPSLONGunsigned long *serial, int *status)
2812{
2813 int i, j, k, stat;
2814 char filename[PATH_MAX4096], *full;
2815 CAPSLONGunsigned long 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_SUCCESS0;
2828 if (problem->jrnl == NULL((void*)0)) return CAPS_SUCCESS0;
2829 if (problem->stFlag == CAPS_JOURNALERR-343) return CAPS_JOURNALERR-343;
2830 if (problem->stFlag != oContinue) return CAPS_SUCCESS0;
2831
2832#ifdef WIN32
2833 fpos = _ftelli64(problem->jrnl);
2834#else
2835 fpos = ftell(problem->jrnl);
2836#endif
2837
2838 /* are we at the last success? */
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_MAX4096, "%s\\capsRestart\\capsJournal", problem->root);
2845#else
2846 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal", problem->root);
2847#endif
2848/*@-dependenttrans@*/
2849 problem->jrnl = fopen(filename, "ab");
2850/*@+dependenttrans@*/
2851 if (problem->jrnl == NULL((void*)0)) {
2852 printf(" CAPS Error: Cannot open %s (caps_jrnlRead)\n", filename);
2853 return CAPS_DIRERR-333;
2854 }
2855#ifdef WIN32
2856 _fseeki64(problem->jrnl, problem->jpos, SEEK_SET0);
2857#else
2858 fseek(problem->jrnl, problem->jpos, SEEK_SET0);
2859#endif
2860 return CAPS_SUCCESS0;
2861 }
2862
2863 /* lets get our record */
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(CAPSLONGunsigned long), 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_SUCCESS0) {
2880 n = fread(&objSN, sizeof(CAPSLONGunsigned long), 1, problem->jrnl);
2881 if (n != 1) goto jreaderr;
2882 /* cleanup? */
2883 if (obj != NULL((void*)0))
2884 if (obj->flist != NULL((void*)0)) {
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-332) goto jreaderr;
2905 if (stat != CAPS_SUCCESS0) {
2906 printf(" CAPS Warning: Journal caps_readString = %d!\n", stat);
2907 goto jreadfatal;
2908 }
2909 if (obj != NULL((void*)0)) {
2910 flist = (capsFList *) EG_alloc(sizeof(capsFList));
2911 if (flist == NULL((void*)0)) {
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((void*)0);
2919 if (obj->flist != NULL((void*)0)) 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((void*)0)) {
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_SUCCESS0) {
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((void*)0);
2942 goto jreaderr;
2943 }
2944 }
2945 if (obj != NULL((void*)0)) {
2946 flist = (capsFList *) EG_alloc(sizeof(capsFList));
2947 if (flist == NULL((void*)0)) {
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((void*)0);
2955 if (obj->flist != NULL((void*)0)) 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_SUCCESS0) {
2967 printf(" CAPS Warning: Journal caps_readTuple = %d!\n", stat);
2968 goto jreaderr;
2969 }
2970 if (obj != NULL((void*)0)) {
2971 flist = (capsFList *) EG_alloc(sizeof(capsFList));
2972 if (flist == NULL((void*)0)) {
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((void*)0);
2980 if (obj->flist != NULL((void*)0)) 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((void*)0);
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((void*)0)) {
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((void*)0);
3003 goto jreaderr;
3004 }
3005 if ((obj != NULL((void*)0)) && (args[i].type == jPointer)) {
3006 flist = (capsFList *) EG_alloc(sizeof(capsFList));
3007 if (flist == NULL((void*)0)) {
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((void*)0);
3015 if (obj->flist != NULL((void*)0)) 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_SUCCESS0) {
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_SUCCESS0) {
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((void*)0)) {
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_SUCCESS0) {
3049 printf(" CAPS Warning: Jrnl caps_readString Obj = %d!\n", stat);
3050 EG_free(args[i].members.objs);
3051 args[i].members.objs = NULL((void*)0);
3052 goto jreaderr;
3053 }
3054 stat = caps_string2obj(problem, full, &args[i].members.objs[j]);
3055 EG_free(full);
3056 if (stat != CAPS_SUCCESS0) {
3057 printf(" CAPS Warning: Journal caps_string2obj = %d!\n", stat);
3058 EG_free(args[i].members.objs);
3059 args[i].members.objs = NULL((void*)0);
3060 goto jreaderr;
3061 }
3062 }
3063 if (obj != NULL((void*)0)) {
3064 flist = (capsFList *) EG_alloc(sizeof(capsFList));
3065 if (flist == NULL((void*)0)) {
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((void*)0);
3073 if (obj->flist != NULL((void*)0)) 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_SUCCESS0) {
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_SUCCESS0) {
3091 printf(" CAPS Warning: Journal caps_Own = %d!\n", stat);
3092 goto jreaderr;
3093 }
3094 if (obj != NULL((void*)0)) {
3095 flist = (capsFList *) EG_alloc(sizeof(capsFList));
3096 if (flist == NULL((void*)0)) {
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((void*)0);
3103 if (obj->flist != NULL((void*)0)) 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((void*)0)) {
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_SUCCESS0) {
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((void*)0);
3125 goto jreaderr;
3126 }
3127 }
3128 if (obj != NULL((void*)0)) {
3129 flist = (capsFList *) EG_alloc(sizeof(capsFList));
3130 if (flist == NULL((void*)0)) {
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((void*)0);
3138 if (obj->flist != NULL((void*)0)) flist->next = obj->flist;
3139 obj->flist = flist;
3140 }
3141 }
3142 }
3143 break;
3144
3145 case jEgos:
3146 args[i].members.model = NULL((void*)0);
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_MAX4096, "%s\\capsRestart\\model%4.4d.egads",
3152 problem->root, args[i].num);
3153#else
3154 snprintf(filename, PATH_MAX4096, "%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_SUCCESS0) {
3160 printf(" CAPS Warning: EG_loadModel = %d (caps_jrnlRead)!\n",
3161 stat);
3162 goto jreaderr;
3163 }
3164 if (obj != NULL((void*)0)) {
3165 flist = (capsFList *) EG_alloc(sizeof(capsFList));
3166 if (flist == NULL((void*)0)) {
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((void*)0);
3174 if (obj->flist != NULL((void*)0)) flist->next = obj->flist;
3175 obj->flist = flist;
3176 }
3177 }
3178 }
3179
3180 }
3181 }
3182
3183 n = fread(&sNum, sizeof(CAPSLONGunsigned long), 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_MAX4096, "%s\\capsRestart\\capsJournal", problem->root);
3198#else
3199 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal", problem->root);
3200#endif
3201/*@-dependenttrans@*/
3202 problem->jrnl = fopen(filename, "ab");
3203/*@+dependenttrans@*/
3204 if (problem->jrnl == NULL((void*)0)) {
3205 printf(" CAPS Error: Cannot open %s (caps_jrnlRead)\n", filename);
3206 return CAPS_DIRERR-333;
3207 }
3208 }
3209
3210 *serial = sNum;
3211 return CAPS_JOURNAL-342;
3212
3213jreaderr:
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_MAX4096, "%s\\capsRestart\\capsJournal", problem->root);
3220#else
3221 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal", problem->root);
3222#endif
3223/*@-dependenttrans@*/
3224 problem->jrnl = fopen(filename, "ab");
3225/*@+dependenttrans@*/
3226 if (problem->jrnl == NULL((void*)0)) {
3227 printf(" CAPS Error: Cannot open %s (caps_jrnlRead)\n", filename);
3228 return CAPS_DIRERR-333;
3229 }
3230#ifdef WIN32
3231 _fseeki64(problem->jrnl, fpos, SEEK_SET0);
3232#else
3233 fseek(problem->jrnl, fpos, SEEK_SET0);
3234#endif
3235 return CAPS_SUCCESS0;
3236
3237jreadfatal:
3238 fclose(problem->jrnl);
3239 problem->jrnl = NULL((void*)0);
3240 problem->stFlag = CAPS_JOURNALERR-343;
3241 return CAPS_JOURNALERR-343;
3242}
3243
3244
3245static int
3246caps_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_SUCCESS0) return status;
3254
3255 object = *obj;
3256 object->magicnumber = CAPSMAGIC1234321;
3257 object->type = type;
3258 object->subtype = subtype;
3259 object->name = EG_strdup(name);
3260 object->attrs = NULL((void*)0);
3261 object->blind = NULL((void*)0);
3262 object->flist = NULL((void*)0);
3263 object->parent = parent;
3264
3265 return CAPS_SUCCESS0;
3266}
3267
3268
3269static int
3270caps_readDataSet(capsProblem *problem, const char *base, capsObject *dobject)
3271{
3272 int i, stat;
3273 char filename[PATH_MAX4096], *name = NULL((void*)0);
3274 capsDataSet *ds;
3275 size_t n;
3276 FILE *fp;
3277
3278 ds = (capsDataSet *) EG_alloc(sizeof(capsDataSet));
3279 if (ds == NULL((void*)0)) return EGADS_MALLOC-4;
3280 ds->ftype = BuiltIn;
3281 ds->npts = 0;
3282 ds->rank = 0;
3283 ds->data = NULL((void*)0);
3284 ds->units = NULL((void*)0);
3285 ds->startup = NULL((void*)0);
3286 ds->linkMethod = Interpolate;
3287 ds->link = NULL((void*)0);
3288 dobject->blind = ds;
3289#ifdef WIN32
3290 snprintf(filename, PATH_MAX4096, "%s\\DN-%s", base, dobject->name);
3291#else
3292 snprintf(filename, PATH_MAX4096, "%s/DN-%s", base, dobject->name);
3293#endif
3294
3295 fp = fopen(filename, "rb");
3296 if (fp == NULL((void*)0)) {
3297 printf(" CAPS Error: Cannot open %s!\n", filename);
3298 return CAPS_DIRERR-333;
3299 }
3300
3301 stat = caps_readHistory(fp, dobject);
3302 if (stat != CAPS_SUCCESS0) goto rderrs;
3303 stat = caps_readOwn(fp, &dobject->last);
3304 if (stat != CAPS_SUCCESS0) goto rderrs;
3305 stat = caps_readAttrs(fp, &dobject->attrs);
3306 if (stat != CAPS_SUCCESS0) goto rderrs;
3307 stat = caps_readString(fp, &name);
3308 if (stat != CAPS_SUCCESS0) 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_SUCCESS0) goto rderrs;
3318
3319 stat = caps_readDoubles(fp, &i, &ds->data);
3320 if (stat != CAPS_SUCCESS0) 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((void*)0);
3328
3329 stat = caps_readString(fp, &name);
3330 if (stat != CAPS_SUCCESS0) goto rderrs;
3331 if (name != NULL((void*)0)) {
3332 stat = caps_string2obj(problem, name, &ds->link);
3333 EG_free(name);
3334 name = NULL((void*)0);
3335 if (stat != CAPS_SUCCESS0) 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_SUCCESS0;
3342
3343rderrs:
3344 if (name != NULL((void*)0)) EG_free(name);
3345 fclose(fp);
3346 return CAPS_IOERR-332;
3347}
3348
3349
3350static int
3351caps_readVertexSet(capsProblem *problem, capsObject *bobject,
3352 capsObject *vobject)
3353{
3354 int i, dim, status;
3355 char base[PATH_MAX4096], filename[PATH_MAX4096], 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_MAX4096, "%s\\capsRestart\\BN-%4.4d\\S%c-%s",
3376 problem->root, bound->index, cstype, vobject->name);
3377 snprintf(filename, PATH_MAX4096, "%s\\vs", base);
3378#else
3379 snprintf(base, PATH_MAX4096, "%s/capsRestart/BN-%4.4d/S%c-%s",
3380 problem->root, bound->index, cstype, vobject->name);
3381 snprintf(filename, PATH_MAX4096, "%s/vs", base);
3382#endif
3383
3384 fp = fopen(filename, "rb");
3385 if (fp == NULL((void*)0)) {
3386 printf(" CAPS Error: Cannot open %s!\n", filename);
3387 return CAPS_DIRERR-333;
3388 }
3389
3390 status = caps_readHistory(fp, vobject);
3391 if (status != CAPS_SUCCESS0) goto readerr;
3392 status = caps_readOwn(fp, &vobject->last);
3393 if (status != CAPS_SUCCESS0) goto readerr;
3394 status = caps_readAttrs(fp, &vobject->attrs);
3395 if (status != CAPS_SUCCESS0) goto readerr;
3396 status = caps_readString(fp, &name);
3397 if (status != CAPS_SUCCESS0) goto readerr;
3398 EG_free(name);
3399
3400 /* read needed discr info */
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((void*)0)) {
3411 fclose(fp);
3412 return EGADS_MALLOC-4;
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 /* load the DataSets */
3422 for (i = 0; i < vs->nDataSets; i++) {
3423 status = caps_readDataSet(problem, base, vs->dataSets[i]);
3424 if (status != CAPS_SUCCESS0) {
3425 printf(" CAPS Error: %s caps_readDataSet = %d\n",
3426 vs->dataSets[i]->name, status);
3427 return status;
3428 }
3429 }
3430
3431 return CAPS_SUCCESS0;
3432
3433readerr:
3434 fclose(fp);
3435 return CAPS_IOERR-332;
3436}
3437
3438
3439static int
3440caps_readInitDSets(capsProblem *problem, capsObject *bobject,
3441 capsObject *vobject)
3442{
3443 int i, status;
3444 char filename[PATH_MAX4096], name[PATH_MAX4096], 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_MAX4096, "%s\\capsRestart\\BN-%4.4d\\S%c-%s\\dSets.txt",
3456 problem->root, bound->index, cstype, vobject->name);
3457#else
3458 snprintf(filename, PATH_MAX4096, "%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((void*)0)) {
3464 printf(" CAPS Error: Cannot open %s (caps_readInitDSets)!\n", filename);
3465 return CAPS_DIRERR-333;
3466 }
3467 fscanf(fp, "%d", &vs->nDataSets);
3468 vs->dataSets = (capsObject **) EG_alloc(vs->nDataSets*sizeof(capsObject *));
3469 if (vs->dataSets == NULL((void*)0)) {
3470 fclose(fp);
3471 return EGADS_MALLOC-4;
3472 }
3473 for (i = 0; i < vs->nDataSets; i++) vs->dataSets[i] = NULL((void*)0);
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_SUCCESS0) {
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_SUCCESS0;
3487}
3488
3489
3490static int
3491caps_readInitVSets(capsProblem *problem, capsObject *bobject)
3492{
3493 int i, j, type, status;
3494 char filename[PATH_MAX4096], name[PATH_MAX4096];
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_MAX4096, "%s\\capsRestart\\BN-%4.4d\\vSets.txt",
3504 problem->root, bound->index);
3505#else
3506 snprintf(filename, PATH_MAX4096, "%s/capsRestart/BN-%4.4d/vSets.txt",
3507 problem->root, bound->index);
3508#endif
3509 fp = fopen(filename, "r");
3510 if (fp == NULL((void*)0)) {
3511 printf(" CAPS Error: Cannot open %s (caps_readInitVSets)!\n", filename);
3512 return CAPS_DIRERR-333;
3513 }
3514 fscanf(fp, "%d", &bound->nVertexSet);
3515 bound->vertexSet = (capsObject **)
3516 EG_alloc(bound->nVertexSet*sizeof(capsObject *));
3517 if (bound->vertexSet == NULL((void*)0)) {
3518 fclose(fp);
3519 return EGADS_MALLOC-4;
3520 }
3521 for (i = 0; i < bound->nVertexSet; i++) bound->vertexSet[i] = NULL((void*)0);
3522 for (i = 0; i < bound->nVertexSet; i++) {
3523 fscanf(fp, "%d %s", &type, name);
3524 aobject = NULL((void*)0);
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((void*)0)) {
3532 fclose(fp);
3533 printf(" CAPS Error: Analysis %s Not Found (caps_readInitVSets)\n",
3534 name);
3535 return CAPS_NOTFOUND-303;
3536 }
3537 }
3538 status = caps_readInitObj(&bound->vertexSet[i], VERTEXSET, type, name,
3539 bobject);
3540 if (status != CAPS_SUCCESS0) {
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((void*)0)) {
3548 fclose(fp);
3549 return EGADS_MALLOC-4;
3550 }
3551 vs->analysis = aobject;
3552 vs->nDataSets = 0;
3553 vs->dataSets = NULL((void*)0);
3554 vs->discr = (capsDiscr *) EG_alloc(sizeof(capsDiscr));
3555 if (vs->discr == NULL((void*)0)) {
3556 EG_free(vs);
3557 fclose(fp);
3558 return EGADS_MALLOC-4;
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_SUCCESS0) {
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_SUCCESS0;
3575}
3576
3577
3578static int
3579caps_readBound(capsObject *bobject)
3580{
3581 int i, status;
3582 char filename[PATH_MAX4096];
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_MAX4096, "%s\\capsRestart\\BN-%4.4d\\bound",
3595 problem->root, bound->index);
3596#else
3597 snprintf(filename, PATH_MAX4096, "%s/capsRestart/BN-%4.4d/bound",
3598 problem->root, bound->index);
3599#endif
3600 fp = fopen(filename, "rb");
3601 if (fp == NULL((void*)0)) {
3602 printf(" CAPS Error: Cannot open bound %s!\n", filename);
3603 return CAPS_DIRERR-333;
3604 }
3605
3606 status = caps_readHistory(fp, bobject);
3607 if (status != CAPS_SUCCESS0) goto rerror;
3608 status = caps_readOwn(fp, &bobject->last);
3609 if (status != CAPS_SUCCESS0) goto rerror;
3610 status = caps_readAttrs(fp, &bobject->attrs);
3611 if (status != CAPS_SUCCESS0) goto rerror;
3612 status = caps_readString(fp, &bobject->name);
3613 if (status != CAPS_SUCCESS0) 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((void*)0)) {
3632 fclose(fp);
3633 return EGADS_MALLOC-4;
3634 }
3635 bound->curve->nrank = i;
3636 }
3637
3638 if (bound->curve != NULL((void*)0)) {
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_SUCCESS0) 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_SUCCESS0) 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((void*)0)) {
3658 fclose(fp);
3659 return EGADS_MALLOC-4;
3660 }
3661 bound->surface->nrank = i;
3662 }
3663 if (bound->surface != NULL((void*)0)) {
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_SUCCESS0) 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_SUCCESS0) goto rerror;
3682 }
3683 fclose(fp);
3684
3685 /* get VertexSets */
3686 for (i = 0; i < bound->nVertexSet; i++) {
3687 status = caps_readVertexSet(problem, bobject, bound->vertexSet[i]);
3688 if (status != CAPS_SUCCESS0) {
3689 printf(" CAPS Error: caps_readVertexSet = %d (caps_readBound)\n", status);
3690 return status;
3691 }
3692 }
3693
3694 return CAPS_SUCCESS0;
3695
3696rerror:
3697 fclose(fp);
3698 return CAPS_IOERR-332;
3699}
3700
3701
3702static int
3703caps_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_MAX4096], filename[PATH_MAX4096], *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_MAX4096, "%s\\capsRestart\\AN-%s",
3717 problem->root, aobject->name);
3718 snprintf(filename, PATH_MAX4096, "%s\\analysis", base);
3719#else
3720 snprintf(base, PATH_MAX4096, "%s/capsRestart/AN-%s",
3721 problem->root, aobject->name);
3722 snprintf(filename, PATH_MAX4096, "%s/analysis", base);
3723#endif
3724
3725 fp = fopen(filename, "rb");
3726 if (fp == NULL((void*)0)) {
3727 printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename);
3728 return CAPS_DIRERR-333;
3729 }
3730
3731 stat = caps_readHistory(fp, aobject);
3732 if (stat != CAPS_SUCCESS0) goto raerr;
3733 stat = caps_readOwn(fp, &aobject->last);
3734 if (stat != CAPS_SUCCESS0) goto raerr;
3735 stat = caps_readOwn(fp, &analysis->pre);
3736 if (stat != CAPS_SUCCESS0) goto raerr;
3737 stat = caps_readAttrs(fp, &aobject->attrs);
3738 if (stat != CAPS_SUCCESS0) goto raerr;
3739 stat = caps_readString(fp, &name);
3740 if (stat != CAPS_SUCCESS0) goto raerr;
3741 EG_free(name);
3742
3743 /* If the AIM was previously executed
3744 * then transfer links and post is needed to restore the state */
3745 if (aobject->last.sNum > analysis->pre.sNum) {
3746 analysis->reload = 1;
3747 }
3748
3749 /* pre was called without calling post
3750 * transfer links is needed in the call to post */
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_SUCCESS0) goto raerr;
3757 if (analysis->loadName == NULL((void*)0)) {
3758 fclose(fp);
3759 return CAPS_NULLNAME-308;
3760 }
3761 stat = caps_readString(fp, &analysis->path);
3762 if (stat != CAPS_SUCCESS0) goto raerr;
3763 stat = caps_readString(fp, &analysis->unitSys);
3764 if (stat != CAPS_SUCCESS0) goto raerr;
3765 stat = caps_readString(fp, &analysis->intents);
3766 if (stat != CAPS_SUCCESS0) 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((void*)0)) {
3778 fclose(fp);
3779 return EGADS_MALLOC-4;
3780 }
3781 for (i = 0; i < analysis->nField; i++) {
3782 stat = caps_readString(fp, &analysis->fields[i]);
3783 if (stat != CAPS_SUCCESS0) goto raerr;
3784 }
3785 analysis->ranks = (int *) EG_alloc(analysis->nField*sizeof(int));
3786 if (analysis->ranks == NULL((void*)0)) {
3787 fclose(fp);
3788 return EGADS_MALLOC-4;
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((void*)0)) {
3794 fclose(fp);
3795 return EGADS_MALLOC-4;
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_MAX4096, "%s\\%s", problem->root, analysis->path);
3805#else
3806 snprintf(filename, PATH_MAX4096, "%s/%s", problem->root, analysis->path);
3807#endif
3808 analysis->fullPath = EG_strdup(filename);
3809
3810 /* try to load the AIM */
3811 eFlag = 0;
3812 nField = 0;
3813 fields = NULL((void*)0);
3814 ranks = NULL((void*)0);
3815 fInOut = NULL((void*)0);
3816 instStore = NULL((void*)0);
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_SUCCESS0) {
3822 if (fields != NULL((void*)0)) {
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((void*)0)) {
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-338;
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((void*)0)) {
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-324;
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-324;
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-324;
3863 }
3864
3865 /* read the value objects */
3866
3867 if (analysis->analysisIn != NULL((void*)0)) {
3868 for (i = 0; i < analysis->nAnalysisIn; i++) {
3869#ifdef WIN32
3870 snprintf(filename, PATH_MAX4096, "%s\\VI-%4.4d", base, i+1);
3871#else
3872 snprintf(filename, PATH_MAX4096, "%s/VI-%4.4d", base, i+1);
3873#endif
3874 fp = fopen(filename, "rb");
3875 if (fp == NULL((void*)0)) {
3876 printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename);
3877 return CAPS_DIRERR-333;
3878 }
3879 stat = caps_readValue(fp, problem, analysis->analysisIn[i]);
3880 fclose(fp);
3881 if (stat != CAPS_SUCCESS0) {
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((void*)0)) {
3890 for (i = 0; i < analysis->nAnalysisOut; i++) {
3891#ifdef WIN32
3892 snprintf(filename, PATH_MAX4096, "%s\\VO-%4.4d", base, i+1);
3893#else
3894 snprintf(filename, PATH_MAX4096, "%s/VO-%4.4d", base, i+1);
3895#endif
3896 fp = fopen(filename, "rb");
3897 if (fp == NULL((void*)0)) {
3898 printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename);
3899 return CAPS_DIRERR-333;
3900 }
3901 stat = caps_readValue(fp, problem, analysis->analysisOut[i]);
3902 fclose(fp);
3903 if (stat != CAPS_SUCCESS0) {
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((void*)0)) {
3915 printf(" CAPS Error: Allocation for %s %d AnalysisDynO (caps_open)!\n",
3916 aobject->name, analysis->nAnalysisDynO);
3917 return EGADS_MALLOC-4;
3918 }
3919
3920 for (j = 0; j < analysis->nAnalysisDynO; j++)
3921 analysis->analysisDynO[j] = NULL((void*)0);
3922 for (j = 0; j < analysis->nAnalysisDynO; j++) {
3923 stat = caps_readInitObj(&analysis->analysisDynO[j], VALUE, ANALYSISDYNO,
3924 NULL((void*)0), aobject);
3925 if (stat != CAPS_SUCCESS0) {
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((void*)0)) {
3932 printf(" CAPS Error: Allocation for %s %d/%d AnalysisDynO (caps_open)!\n",
3933 aobject->name, j, analysis->nAnalysisDynO);
3934 return EGADS_MALLOC-4;
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((void*)0);
3943 value->meshWriter = NULL((void*)0);
3944 value->link = NULL((void*)0);
3945 value->vals.reals = NULL((void*)0);
3946 value->limits.dlims[0] = value->limits.dlims[1] = 0.0;
3947 value->linkMethod = Copy;
3948 value->gInType = 0;
3949 value->partial = NULL((void*)0);
3950 value->nderiv = 0;
3951 value->derivs = NULL((void*)0);
3952 analysis->analysisDynO[j]->blind = value;
3953 }
3954
3955 for (i = 0; i < analysis->nAnalysisDynO; i++) {
3956#ifdef WIN32
3957 snprintf(filename, PATH_MAX4096, "%s\\VD-%4.4d", base, i+1);
3958#else
3959 snprintf(filename, PATH_MAX4096, "%s/VD-%4.4d", base, i+1);
3960#endif
3961 fp = fopen(filename, "rb");
3962 if (fp == NULL((void*)0)) {
3963 printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename);
3964 return CAPS_DIRERR-333;
3965 }
3966 stat = caps_readValue(fp, problem, analysis->analysisDynO[i]);
3967 fclose(fp);
3968 if (stat != CAPS_SUCCESS0) {
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_SUCCESS0;
3977
3978raerr:
3979 fclose(fp);
3980 return CAPS_IOERR-332;
3981}
3982
3983
3984static int
3985caps_readState(capsObject *pobject)
3986{
3987 int i, j, ivec[2], nIn, nOut, stat;
3988 char filename[PATH_MAX4096], name[PATH_MAX4096], *phName;
3989 capsProblem *problem;
3990 capsAnalysis *analysis;
3991 capsBound *bound;
3992 capsValue *value;
3993 size_t n;
3994 FILE *fp, *fptxt = NULL((void*)0);
3995
3996 problem = (capsProblem *) pobject->blind;
3997#ifdef WIN32
3998 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\Problem", problem->root);
3999#else
4000 snprintf(filename, PATH_MAX4096, "%s/capsRestart/Problem", problem->root);
4001#endif
4002
4003 fp = fopen(filename, "rb");
4004 if (fp == NULL((void*)0)) {
4005 printf(" CAPS Error: Cannot open %s!\n", filename);
4006 return CAPS_DIRERR-333;
4007 }
4008 ivec[0] = CAPSMAJOR1;
4009 ivec[1] = CAPSMINOR21;
4010
4011 n = fread(&problem->sNum, sizeof(CAPSLONGunsigned long), 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_SUCCESS0) goto readerr;
4023 stat = caps_readOwn(fp, &pobject->last);
4024 if (stat != CAPS_SUCCESS0) goto readerr;
4025 stat = caps_readAttrs(fp, &pobject->attrs);
4026 if (stat != CAPS_SUCCESS0) goto readerr;
4027 if (pobject->name != NULL((void*)0)) EG_free(pobject->name);
4028 stat = caps_readString(fp, &pobject->name);
4029 if (stat != CAPS_SUCCESS0) goto readerr;
4030 stat = caps_readString(fp, &phName);
4031 if (stat != CAPS_SUCCESS0) goto readerr;
4032 if (phName != NULL((void*)0)) EG_free(phName);
4033 stat = caps_readPhrases(fp, problem);
4034 if (stat != CAPS_SUCCESS0) goto readerr;
4035 stat = caps_readOwn(fp, &problem->geometry);
4036 if (stat != CAPS_SUCCESS0) 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_SUCCESS0) 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 /* get the number of objects */
4063
4064#ifdef WIN32
4065 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\param.txt", problem->root);
4066#else
4067 snprintf(filename, PATH_MAX4096, "%s/capsRestart/param.txt", problem->root);
4068#endif
4069 fptxt = fopen(filename, "r");
4070 if (fptxt != NULL((void*)0)) {
4071 fscanf(fptxt, "%d %d", &problem->nParam, &problem->nUser);
4072 fclose(fptxt);
4073 }
4074
4075#ifdef WIN32
4076 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\geom.txt", problem->root);
4077#else
4078 snprintf(filename, PATH_MAX4096, "%s/capsRestart/geom.txt", problem->root);
4079#endif
4080 fptxt = fopen(filename, "r");
4081 if (fptxt != NULL((void*)0)) {
4082 fscanf(fptxt, "%d %d", &problem->nGeomIn, &problem->nGeomOut);
4083 fclose(fptxt);
4084 }
4085
4086#ifdef WIN32
4087 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\analy.txt", problem->root);
4088#else
4089 snprintf(filename, PATH_MAX4096, "%s/capsRestart/analy.txt", problem->root);
4090#endif
4091 fptxt = fopen(filename, "r");
4092 if (fptxt != NULL((void*)0)) {
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((void*)0)) return EGADS_MALLOC-4;
4098 for (i = 0; i < problem->nAnalysis; i++) problem->analysis[i] = NULL((void*)0);
4099 for (i = 0; i < problem->nAnalysis; i++) {
4100 stat = caps_readInitObj(&problem->analysis[i], ANALYSIS, NONE, NULL((void*)0),
4101 problem->mySelf);
4102 if (stat != CAPS_SUCCESS0) {
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((void*)0)) {
4113 fclose(fptxt);
4114 return EGADS_MALLOC-4;
4115 }
4116 problem->analysis[i]->name = EG_strdup(name);
4117 problem->analysis[i]->blind = analysis;
4118 analysis->loadName = NULL((void*)0);
4119 analysis->fullPath = NULL((void*)0);
4120 analysis->path = NULL((void*)0);
4121 analysis->unitSys = NULL((void*)0);
4122 analysis->major = CAPSMAJOR1;
4123 analysis->minor = CAPSMINOR21;
4124 analysis->instStore = NULL((void*)0);
4125 analysis->intents = NULL((void*)0);
4126 analysis->autoexec = 0;
4127 analysis->eFlag = 0;
4128 analysis->reload = 0;
4129 analysis->nField = 0;
4130 analysis->fields = NULL((void*)0);
4131 analysis->ranks = NULL((void*)0);
4132 analysis->fInOut = NULL((void*)0);
4133 analysis->nAnalysisIn = nIn;
4134 analysis->analysisIn = NULL((void*)0);
4135 analysis->nAnalysisOut = nOut;
4136 analysis->analysisOut = NULL((void*)0);
4137 analysis->nAnalysisDynO = 0;
4138 analysis->analysisDynO = NULL((void*)0);
4139 analysis->nBody = 0;
4140 analysis->bodies = NULL((void*)0);
4141 analysis->nTess = 0;
4142 analysis->tess = NULL((void*)0);
4143 analysis->pre.index = -1;
4144 analysis->pre.pname = NULL((void*)0);
4145 analysis->pre.pID = NULL((void*)0);
4146 analysis->pre.user = NULL((void*)0);
4147 analysis->pre.sNum = 0;
4148 analysis->info.magicnumber = CAPSMAGIC1234321;
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((void*)0);
4158 analysis->info.wCntxt.aimWriterNum = 0;
4159 for (j = 0; j < 6; j++) analysis->pre.datetime[j] = 0;
4160
4161 /* make the analysis value objects */
4162 if (nIn > 0) {
4163 analysis->analysisIn = (capsObject **)
4164 EG_alloc(nIn*sizeof(capsObject *));
4165 if (analysis->analysisIn == NULL((void*)0)) {
4166 fclose(fptxt);
4167 return EGADS_MALLOC-4;
4168 }
4169 for (j = 0; j < nIn; j++) analysis->analysisIn[j] = NULL((void*)0);
4170 value = (capsValue *) EG_alloc(nIn*sizeof(capsValue));
4171 if (value == NULL((void*)0)) {
4172 fclose(fptxt);
4173 EG_free(analysis->analysisIn);
4174 analysis->analysisIn = NULL((void*)0);
4175 return EGADS_MALLOC-4;
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((void*)0);
4185 value[j].meshWriter = NULL((void*)0);
4186 value[j].link = NULL((void*)0);
4187 value[j].vals.reals = NULL((void*)0);
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((void*)0);
4192 value[j].nderiv = 0;
4193 value[j].derivs = NULL((void*)0);
4194 }
4195 for (j = 0; j < nIn; j++) {
4196 stat = caps_readInitObj(&analysis->analysisIn[j], VALUE, ANALYSISIN,
4197 NULL((void*)0), problem->analysis[i]);
4198 if (stat != CAPS_SUCCESS0) {
4199 printf(" CAPS Error: aIn %d caps_readInitObj = %d (caps_open)!\n",
4200 j, stat);
4201 fclose(fptxt);
4202/*@-kepttrans@*/
4203 EG_free(value);
4204/*@+kepttrans@*/
4205 EG_free(analysis->analysisIn);
4206 analysis->analysisIn = NULL((void*)0);
4207 return stat;
4208 }
4209/*@-immediatetrans@*/
4210 analysis->analysisIn[j]->blind = &value[j];
4211/*@+immediatetrans@*/
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((void*)0)) {
4219 fclose(fptxt);
4220 return EGADS_MALLOC-4;
4221 }
4222 for (j = 0; j < nOut; j++) analysis->analysisOut[j] = NULL((void*)0);
4223 value = (capsValue *) EG_alloc(nOut*sizeof(capsValue));
4224 if (value == NULL((void*)0)) {
4225 fclose(fptxt);
4226 EG_free(analysis->analysisOut);
4227 analysis->analysisOut = NULL((void*)0);
4228 return EGADS_MALLOC-4;
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((void*)0);
4238 value[j].meshWriter = NULL((void*)0);
4239 value[j].link = NULL((void*)0);
4240 value[j].vals.reals = NULL((void*)0);
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((void*)0);
4245 value[j].nderiv = 0;
4246 value[j].derivs = NULL((void*)0);
4247 }
4248 for (j = 0; j < nOut; j++) {
4249 stat = caps_readInitObj(&analysis->analysisOut[j], VALUE, ANALYSISOUT,
4250 NULL((void*)0), problem->analysis[i]);
4251 if (stat != CAPS_SUCCESS0) {
4252 printf(" CAPS Error: aOut %d caps_readInitObj = %d (caps_open)!\n",
4253 j, stat);
4254 fclose(fptxt);
4255/*@-kepttrans@*/
4256 EG_free(value);
4257/*@+kepttrans@*/
4258 EG_free(analysis->analysisOut);
4259 analysis->analysisOut = NULL((void*)0);
4260 return stat;
4261 }
4262/*@-immediatetrans@*/
4263 analysis->analysisOut[j]->blind = &value[j];
4264/*@+immediatetrans@*/
4265 }
4266 analysis->analysisOut[0]->blind = value;
4267 }
4268 }
4269 }
4270 fclose(fptxt);
4271 }
4272
4273#ifdef WIN32
4274 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\bound.txt", problem->root);
4275#else
4276 snprintf(filename, PATH_MAX4096, "%s/capsRestart/bound.txt", problem->root);
4277#endif
4278 fptxt = fopen(filename, "r");
4279 if (fptxt != NULL((void*)0)) {
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((void*)0)) {
4285 fclose(fptxt);
4286 return EGADS_MALLOC-4;
4287 }
4288 for (i = 0; i < problem->nBound; i++) problem->bounds[i] = NULL((void*)0);
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((void*)0)) {
4293 fclose(fptxt);
4294 return EGADS_MALLOC-4;
4295 }
4296 bound->dim = 0;
4297 bound->state = Empty;
4298 bound->lunits = NULL((void*)0);
4299 bound->plimits[0] = bound->plimits[1] = bound->plimits[2] =
4300 bound->plimits[3] = 0.0;
4301 bound->geom = NULL((void*)0);
4302 bound->iBody = 0;
4303 bound->iEnt = 0;
4304 bound->curve = NULL((void*)0);
4305 bound->surface = NULL((void*)0);
4306 bound->index = j;
4307 bound->nVertexSet = 0;
4308 bound->vertexSet = NULL((void*)0);
4309
4310 stat = caps_readInitObj(&problem->bounds[i], BOUND, NONE, NULL((void*)0),
4311 problem->mySelf);
4312 if (stat != CAPS_SUCCESS0) {
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_SUCCESS0) {
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 /* make all of the rest of the Objects */
4333
4334 if (problem->nParam > 0) {
4335 problem->params = (capsObject **)
4336 EG_alloc(problem->nParam*sizeof(capsObject *));
4337 if (problem->params == NULL((void*)0)) return EGADS_MALLOC-4;
4338 for (i = 0; i < problem->nParam; i++) problem->params[i] = NULL((void*)0);
4339 for (i = 0; i < problem->nParam; i++) {
4340 stat = caps_makeVal(Integer, 1, &i, &value);
4341 if (stat != CAPS_SUCCESS0) return stat;
4342 stat = caps_readInitObj(&problem->params[i], VALUE, PARAMETER, NULL((void*)0),
4343 problem->mySelf);
4344 if (stat != CAPS_SUCCESS0) {
4345 printf(" CAPS Error: Param %d caps_readInitObj = %d (caps_open)!\n",
4346 i, stat);
4347/*@-kepttrans@*/
4348 EG_free(value);
4349/*@+kepttrans@*/
4350 return stat;
4351 }
4352/*@-kepttrans@*/
4353 problem->params[i]->blind = value;
4354/*@+kepttrans@*/
4355 }
4356 }
4357
4358 if (problem->nUser > 0) {
4359 problem->users = (capsObject **)
4360 EG_alloc(problem->nUser*sizeof(capsObject *));
4361 if (problem->users == NULL((void*)0)) return EGADS_MALLOC-4;
4362 for (i = 0; i < problem->nUser; i++) problem->users[i] = NULL((void*)0);
4363 for (i = 0; i < problem->nUser; i++) {
4364 stat = caps_makeVal(Integer, 1, &i, &value);
4365 if (stat != CAPS_SUCCESS0) return stat;
4366 stat = caps_readInitObj(&problem->users[i], VALUE, USER, NULL((void*)0),
4367 problem->mySelf);
4368 if (stat != CAPS_SUCCESS0) {
4369 printf(" CAPS Error: User %d caps_readInitObj = %d (caps_open)!\n",
4370 i, stat);
4371/*@-kepttrans@*/
4372 EG_free(value);
4373/*@+kepttrans@*/
4374 return stat;
4375 }
4376/*@-kepttrans@*/
4377 problem->users[i]->blind = value;
4378/*@+kepttrans@*/
4379 }
4380 }
4381
4382 if (problem->nGeomIn > 0) {
4383 problem->geomIn = (capsObject **)
4384 EG_alloc(problem->nGeomIn*sizeof(capsObject *));
4385 if (problem->geomIn == NULL((void*)0)) return EGADS_MALLOC-4;
4386 for (i = 0; i < problem->nGeomIn; i++) problem->geomIn[i] = NULL((void*)0);
4387 value = (capsValue *) EG_alloc(problem->nGeomIn*sizeof(capsValue));
4388 if (value == NULL((void*)0)) return EGADS_MALLOC-4;
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((void*)0);
4399 value[i].meshWriter = NULL((void*)0);
4400 value[i].link = NULL((void*)0);
4401 value[i].vals.reals = NULL((void*)0);
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((void*)0);
4407 value[i].nderiv = 0;
4408 value[i].derivs = NULL((void*)0);
4409 }
4410 for (i = 0; i < problem->nGeomIn; i++) {
4411 stat = caps_readInitObj(&problem->geomIn[i], VALUE, GEOMETRYIN, NULL((void*)0),
4412 problem->mySelf);
4413 if (stat != CAPS_SUCCESS0) {
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((void*)0);
4419 return stat;
4420 }
4421/*@-immediatetrans@*/
4422 problem->geomIn[i]->blind = &value[i];
4423/*@+immediatetrans@*/
4424 }
4425 }
4426
4427 if (problem->nGeomOut > 0) {
4428 problem->geomOut = (capsObject **)
4429 EG_alloc(problem->nGeomOut*sizeof(capsObject *));
4430 if (problem->geomOut == NULL((void*)0)) return EGADS_MALLOC-4;
4431 for (i = 0; i < problem->nGeomOut; i++) problem->geomOut[i] = NULL((void*)0);
4432 value = (capsValue *) EG_alloc(problem->nGeomOut*sizeof(capsValue));
4433 if (value == NULL((void*)0)) return EGADS_MALLOC-4;
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((void*)0);
4445 value[i].meshWriter = NULL((void*)0);
4446 value[i].link = NULL((void*)0);
4447 value[i].vals.reals = NULL((void*)0);
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((void*)0);
4452 value[i].nderiv = 0;
4453 value[i].derivs = NULL((void*)0);
4454 }
4455 for (i = 0; i < problem->nGeomOut; i++) {
4456 stat = caps_readInitObj(&problem->geomOut[i], VALUE, GEOMETRYOUT, NULL((void*)0),
4457 problem->mySelf);
4458 if (stat != CAPS_SUCCESS0) {
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((void*)0);
4464 return stat;
4465 }
4466/*@-immediatetrans@*/
4467 problem->geomOut[i]->blind = &value[i];
4468/*@+immediatetrans@*/
4469 }
4470 }
4471
4472 /* fill top-level objects */
4473
4474 if (problem->params != NULL((void*)0)) {
4475 for (i = 0; i < problem->nParam; i++) {
4476#ifdef WIN32
4477 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\VP-%4.4d",
4478 problem->root, i+1);
4479#else
4480 snprintf(filename, PATH_MAX4096, "%s/capsRestart/VP-%4.4d",
4481 problem->root, i+1);
4482#endif
4483 fp = fopen(filename, "rb");
4484 if (fp == NULL((void*)0)) {
4485 printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename);
4486 return CAPS_DIRERR-333;
4487 }
4488 stat = caps_readValue(fp, problem, problem->params[i]);
4489 fclose(fp);
4490 if (stat != CAPS_SUCCESS0) {
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((void*)0)) {
4499 for (i = 0; i < problem->nUser; i++) {
4500#ifdef WIN32
4501 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\VU-%4.4d",
4502 problem->root, i+1);
4503#else
4504 snprintf(filename, PATH_MAX4096, "%s/capsRestart/VU-%4.4d",
4505 problem->root, i+1);
4506#endif
4507 fp = fopen(filename, "rb");
4508 if (fp == NULL((void*)0)) {
4509 printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename);
4510 return CAPS_DIRERR-333;
4511 }
4512 stat = caps_readValue(fp, problem, problem->users[i]);
4513 fclose(fp);
4514 if (stat != CAPS_SUCCESS0) {
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((void*)0)) {
4523 for (i = 0; i < problem->nGeomIn; i++) {
4524#ifdef WIN32
4525 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\VI-%4.4d",
4526 problem->root, i+1);
4527#else
4528 snprintf(filename, PATH_MAX4096, "%s/capsRestart/VI-%4.4d",
4529 problem->root, i+1);
4530#endif
4531 fp = fopen(filename, "rb");
4532 if (fp == NULL((void*)0)) {
4533 printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename);
4534 return CAPS_DIRERR-333;
4535 }
4536 stat = caps_readValue(fp, problem, problem->geomIn[i]);
4537 fclose(fp);
4538 if (stat != CAPS_SUCCESS0) {
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((void*)0)) {
4547 for (i = 0; i < problem->nGeomOut; i++) {
4548#ifdef WIN32
4549 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\VO-%4.4d",
4550 problem->root, i+1);
4551#else
4552 snprintf(filename, PATH_MAX4096, "%s/capsRestart/VO-%4.4d",
4553 problem->root, i+1);
4554#endif
4555 fp = fopen(filename, "rb");
4556 if (fp == NULL((void*)0)) {
4557 printf(" CAPS Error: Cannot open %s (caps_open)!\n", filename);
4558 return CAPS_DIRERR-333;
4559 }
4560 stat = caps_readValue(fp, problem, problem->geomOut[i]);
4561 fclose(fp);
4562 if (stat != CAPS_SUCCESS0) {
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((void*)0)) {
4571 for (i = 0; i < problem->nAnalysis; i++) {
4572 stat = caps_readAnalysis(problem, problem->analysis[i]);
4573 if (stat != CAPS_SUCCESS0) {
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((void*)0)) {
4582 for (i = 0; i < problem->nBound; i++) {
4583 stat = caps_readBound(problem->bounds[i]);
4584 if (stat != CAPS_SUCCESS0) {
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_SUCCESS0;
4593
4594readerr:
4595 fclose(fp);
4596 return CAPS_IOERR-332;
4597}
4598
4599
4600int
4601caps_close(capsObject *pobject, int complete, /*@null@*/ const char *phName)
4602{
4603 int i, j, stat, state, npts;
4604 char path[PATH_MAX4096], filename[PATH_MAX4096], temp[PATH_MAX4096];
4605 ego model, body;
4606 capsProblem *problem;
4607 capsAnalysis *analysis;
4608 FILE *fp;
4609
4610 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
4611 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
4612 if (pobject->type != PROBLEM) return CAPS_BADTYPE-306;
4613 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
4614 if (abs(complete) > 1) return CAPS_BADVALUE-311;
4615 problem = (capsProblem *) pobject->blind;
4616 if (problem->stFlag != oReadOnly) {
4617 stat = caps_writeProblem(pobject);
4618 if (stat != CAPS_SUCCESS0)
4619 printf(" CAPS Warning: caps_writeProblem = %d (caps_close)!\n", stat);
4620 }
4621 problem->funID = CAPS_CLOSE21;
4622 if (problem->jrnl != NULL((void*)0)) fclose(problem->jrnl);
4623
4624 if ((complete == 1) && (problem->stFlag != oReadOnly)) {
4625#ifdef WIN32
4626 snprintf(path, PATH_MAX4096, "%s\\capsClosed", problem->root);
4627#else
4628 snprintf(path, PATH_MAX4096, "%s/capsClosed", problem->root);
4629#endif
4630 fp = fopen(path, "w");
4631 if (fp == NULL((void*)0)) {
4632 printf(" CAPS Warning: Failed to open capsClosed!\n");
4633 } else {
4634 fclose(fp);
4635 }
4636 /* remove any User Value Objects */
4637 caps_freeValueObjects(1, problem->nUser, problem->users);
4638#ifdef WIN32
4639 caps_rmWild(problem->root, "capsRestart\\VU-*");
4640 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\param.txt", problem->root);
4641 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\xxTempxx", problem->root);
4642#else
4643 caps_rmWild(problem->root, "capsRestart/VU-*");
4644 snprintf(filename, PATH_MAX4096, "%s/capsRestart/param.txt", problem->root);
4645 snprintf(temp, PATH_MAX4096, "%s/capsRestart/xxTempxx", problem->root);
4646#endif
4647 problem->nUser = 0;
4648 fp = fopen(temp, "w");
4649 if (fp == NULL((void*)0)) {
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((void*)0))
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_SUCCESS0)
4659 printf(" CAPS Warning: Cannot rename %s!\n", filename);
4660 }
4661 } else {
4662 /* remove any User Value Objects */
4663 caps_freeValueObjects(1, problem->nUser, problem->users);
4664 }
4665
4666 /* remove the lock file before possibly copying the phase */
4667 if (problem->stFlag != oReadOnly) caps_rmLockOnClose(problem->root);
4668
4669 if ((phName != NULL((void*)0)) && (complete == 1) && (problem->stFlag != oReadOnly)) {
4670 if (problem->phName == NULL((void*)0)) {
4671#ifdef WIN32
4672 snprintf(path, PATH_MAX4096, "%s\\..\\%s", problem->root, phName);
4673#else
4674 snprintf(path, PATH_MAX4096, "%s/../%s", problem->root, phName);
4675#endif
4676 stat = caps_prunePath(path);
4677 if (stat != CAPS_SUCCESS0) {
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-1) {
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_SUCCESS0) {
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((void*)0)) EG_free(problem->phName);
4697 if (problem->lunits != NULL((void*)0)) {
4698 for (i = 0; i < problem->nBodies; i++)
4699 if (problem->lunits[i] != NULL((void*)0)) 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 /* deal with geometry */
4707 if (problem->modl != NULL((void*)0)) {
4708 if (pobject->subtype == PARAMETRIC) {
4709 if (problem->analysis != NULL((void*)0)) {
4710 for (i = 0; i < problem->nAnalysis; i++) {
4711 analysis = (capsAnalysis *) problem->analysis[i]->blind;
4712 if (analysis == NULL((void*)0)) continue;
4713 if (analysis->tess != NULL((void*)0)) {
4714 for (j = 0; j < analysis->nTess; j++)
4715 if (analysis->tess[j] != NULL((void*)0)) {
4716 /* delete bodies in the tessellation not on the OpenCSM stack */
4717 body = NULL((void*)0);
4718 if (j >= analysis->nBody) {
4719 stat = EG_statusTessBody(analysis->tess[j], &body, &state,
4720 &npts);
4721 if (stat < EGADS_SUCCESS0) return stat;
4722 if (stat == EGADS_OUTSIDE1) return CAPS_SOURCEERR-330;
4723 }
4724 EG_deleteObject(analysis->tess[j]);
4725 if (body != NULL((void*)0)) EG_deleteObject(body);
4726 analysis->tess[j] = NULL((void*)0);
4727 }
4728 EG_free(analysis->tess);
4729 analysis->tess = NULL((void*)0);
4730 analysis->nTess = 0;
4731 }
4732 }
4733 }
4734 if (problem->stFlag != oMODL) {
4735 /* close up OpenCSM */
4736 ocsmFree(problem->modl);
4737 }
4738 if (problem->bodies != NULL((void*)0)) 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 /* deal with the CAPS Problem level Objects */
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((void*)0)) {
4753 for (i = problem->nBound-1; i >= 0; i--) {
4754 stat = caps_freeBound(problem->bounds[i]);
4755 if (stat != CAPS_SUCCESS0)
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((void*)0)) {
4762 for (i = 0; i < problem->nRegGIN; i++) EG_free(problem->regGIN[i].name);
4763 EG_free(problem->regGIN);
4764 }
4765
4766 /* close up the AIMs */
4767 if (problem->analysis != NULL((void*)0)) {
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((void*)0);
4778 EG_free(problem->analysis[i]);
4779 }
4780 EG_free(problem->analysis);
4781 }
4782
4783 /* close up the AIM subsystem */
4784 aim_cleanupAll(&problem->aimFPTR);
4785
4786 /* remove phrases */
4787 if (problem->phrases != NULL((void*)0)) {
4788 for (i = 0; i < problem->nPhrase; i++) {
4789 EG_free(problem->phrases[i].phase);
4790 if (problem->phrases[i].lines != NULL((void*)0)) {
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 /* do we blow away the phase? */
4800 if ((complete == -1) && (problem->root != NULL((void*)0)) &&
4801 (problem->stFlag != oReadOnly)) caps_rmDir(problem->root);
4802
4803 /* close up EGADS and free the problem */
4804 if (problem->root != NULL((void*)0)) EG_free(problem->root);
4805 if ((problem->context != NULL((void*)0)) && (problem->stFlag != oEGO))
4806 EG_close(problem->context);
4807 EG_free(problem);
4808
4809 /* cleanup and invalidate the object */
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((void*)0);
4816 EG_free(pobject);
4817
4818 return CAPS_SUCCESS0;
4819}
4820
4821
4822int
4823caps_phaseState(const char *prPath, /*@null@*/ const char *phName, int *bFlag)
4824{
4825 int i, n, len, status;
4826 char root[PATH_MAX4096], current[PATH_MAX4096];
4827 const char *prName;
4828
4829 *bFlag = 0;
4830 if (prPath == NULL((void*)0)) return CAPS_NULLNAME-308;
4831 if (phName != NULL((void*)0)) {
4832 if (strcmp(phName, "Scratch") == 0) {
4833 printf(" CAPS Error: Cannot use the phase Scratch!\n");
4834 return CAPS_BADNAME-317;
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-317;
4841 }
4842 }
4843
4844 /* set up our path and name */
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_SUCCESS0) {
4852 printf(" CAPS Error: %s is not a valid Problem Name!\n", prName);
4853 return status;
4854 }
4855 n = -1;
4856#ifdef WIN32
4857 /* do we have a Windows drive? */
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-333;
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 /* absolute path */
4879 status = caps_statFile(prPath);
4880 if (status == EGADS_SUCCESS0) {
4881 printf(" CAPS Info: %s lands on a flat file!\n", prPath);
4882 return CAPS_DIRERR-333;
4883 } else if (status == EGADS_NOTFOUND-1) {
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((void*)0)) {
4890 snprintf(root, PATH_MAX4096, "%s\\Scratch", prPath);
4891 } else {
4892 snprintf(root, PATH_MAX4096, "%s\\%s", prPath, phName);
4893 }
4894 } else {
4895 if (phName == NULL((void*)0)) {
4896 snprintf(root, PATH_MAX4096, "%c:%s\\Scratch", _getdrive()+64, prPath);
4897 } else {
4898 snprintf(root, PATH_MAX4096, "%c:%s\\%s", _getdrive()+64, prPath, phName);
4899 }
4900 }
4901#else
4902 if (phName == NULL((void*)0)) {
4903 snprintf(root, PATH_MAX4096, "%s/Scratch", prPath);
4904 } else {
4905 snprintf(root, PATH_MAX4096, "%s/%s", prPath, phName);
4906 }
4907#endif
4908 } else {
4909 /* relative path -- make it absolute */
4910 (void) getcwd(current, PATH_MAX4096);
4911#ifdef WIN32
4912 snprintf(root, PATH_MAX4096, "%s\\%s", current, prPath);
4913#else
4914 snprintf(root, PATH_MAX4096, "%s/%s", current, prPath);
4915#endif
4916 status = caps_statFile(root);
4917 if (status == EGADS_SUCCESS0) {
4918 printf(" CAPS Info: Path %s lands on a flat file\n", root);
4919 return status;
4920 } else if (status == EGADS_NOTFOUND-1) {
4921 printf(" CAPS Info: Path %s does not exist\n", root);
4922 return status;
4923 }
4924#ifdef WIN32
4925 if (phName == NULL((void*)0)) {
4926 snprintf(root, PATH_MAX4096, "%s\\%s\\Scratch", current, prPath);
4927 } else {
4928 snprintf(root, PATH_MAX4096, "%s\\%s\\%s", current, prPath, phName);
4929 }
4930#else
4931 if (phName == NULL((void*)0)) {
4932 snprintf(root, PATH_MAX4096, "%s/%s/Scratch", current, prPath);
4933 } else {
4934 snprintf(root, PATH_MAX4096, "%s/%s/%s", current, prPath, phName);
4935 }
4936#endif
4937 }
4938 status = caps_prunePath(root);
4939 if (status != CAPS_SUCCESS0) {
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_SUCCESS0) {
4945 printf(" CAPS Info: Path %s lands on a flat file\n", root);
4946 return status;
4947 } else if (status == EGADS_NOTFOUND-1) {
4948 printf(" CAPS Info: Path %s does not exist\n", root);
4949 return status;
4950 }
4951
4952#ifdef WIN32
4953 snprintf(current, PATH_MAX4096, "%s\\capsLock", root);
4954#else
4955 snprintf(current, PATH_MAX4096, "%s/capsLock", root);
4956#endif
4957 status = caps_statFile(current);
4958 if (status == EGADS_SUCCESS0) *bFlag += 1;
4959
4960#ifdef WIN32
4961 snprintf(current, PATH_MAX4096, "%s\\capsClosed", root);
4962#else
4963 snprintf(current, PATH_MAX4096, "%s/capsClosed", root);
4964#endif
4965 status = caps_statFile(current);
4966 if (status == EGADS_SUCCESS0) *bFlag += 2;
4967
4968 return CAPS_SUCCESS0;
4969}
4970
4971
4972int
4973caps_journalState(const capsObject *pobject)
4974{
4975 capsProblem *problem;
4976
4977 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
4978 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
4979 if (pobject->type != PROBLEM) return CAPS_BADTYPE-306;
4980 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
4981 problem = (capsProblem *) pobject->blind;
4982
4983 return problem->stFlag;
4984}
4985
4986
4987int
4988caps_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_LEN64], error[129], vstr[MAX_STRVAL_LEN256], *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((void*)0);
5004 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
5005 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
5006 if (pobject->type != PROBLEM) return CAPS_BADOBJECT-310;
5007 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
5008 problem = (capsProblem *) pobject->blind;
5009
5010 /* nothing to do for static geometry */
5011 if (pobject->subtype == STATIC) return CAPS_CLEAN-336;
5012
5013 /* do we need new geometry? */
5014 /* check for dirty geometry inputs */
5015 gstatus = 0;
5016 for (i = 0; i < problem->nGeomIn; i++) {
5017 source = object = problem->geomIn[i];
5018 do {
5019 if (source->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
5020 if (source->type != VALUE) return CAPS_BADTYPE-306;
5021 if (source->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
5022 value = (capsValue *) source->blind;
5023 if (value->link == object) return CAPS_CIRCULARLINK-319;
5024 last = source;
5025 source = value->link;
5026 } while (value->link != NULL((void*)0));
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-336;
5033
5034 /* generate new geometry */
5035 MODL = (modl_T *) problem->modl;
5036 MODL->context = problem->context;
5037 MODL->userdata = problem;
5038
5039 /* Note: GeometryIn already updated */
5040
5041 /* have OpenCSM do the rebuild */
5042 if (problem->bodies != NULL((void*)0)) {
5043 for (i = 0; i < problem->nBodies; i++)
5044 if (problem->lunits[i] != NULL((void*)0)) EG_free(problem->lunits[i]);
5045 /* remove old bodies & tessellations for all Analyses */
5046 for (i = 0; i < problem->nAnalysis; i++) {
5047 analy = (capsAnalysis *) problem->analysis[i]->blind;
5048 if (analy == NULL((void*)0)) continue;
5049 if (analy->tess != NULL((void*)0)) {
5050 for (j = 0; j < analy->nTess; j++)
5051 if (analy->tess[j] != NULL((void*)0)) {
5052 /* delete the body in the tessellation if not on the OpenCSM stack */
5053 body = NULL((void*)0);
5054 if (j >= analy->nBody) {
5055 stat = EG_statusTessBody(analy->tess[j], &body, &state, &npts);
5056 if (stat < EGADS_SUCCESS0) return stat;
5057 if (stat == EGADS_OUTSIDE1) return CAPS_SOURCEERR-330;
5058 }
5059 EG_deleteObject(analy->tess[j]);
5060 if (body != NULL((void*)0)) EG_deleteObject(body);
5061 analy->tess[j] = NULL((void*)0);
5062 }
5063 EG_free(analy->tess);
5064 analy->tess = NULL((void*)0);
5065 analy->nTess = 0;
5066 }
5067 if (analy->bodies != NULL((void*)0)) {
5068 EG_free(analy->bodies);
5069 analy->bodies = NULL((void*)0);
5070 analy->nBody = 0;
5071 }
5072 /* remove tracked sensitivity calculations */
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((void*)0);
5081 problem->lunits = NULL((void*)0);
5082 problem->geometry.sNum = 0;
5083 }
5084 buildTo = 0; /* all */
5085 nbody = 0;
5086 status = ocsmBuild(problem->modl, buildTo, &builtTo, &nbody, NULL((void*)0));
5087 fflush(stdoutstdout);
5088 if (status != SUCCESS0) {
5089 caps_makeSimpleErr(pobject, CERROR,
5090 "caps_build Error: ocsmBuild fails!",
5091 NULL((void*)0), NULL((void*)0), errors);
5092 if (*errors != NULL((void*)0)) {
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_BODY404) continue;
5102 nbody++;
5103 }
5104
5105 units = NULL((void*)0);
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((void*)0)) || (problem->lunits == NULL((void*)0))) {
5110 if (problem->bodies != NULL((void*)0)) EG_free(problem->bodies);
5111 if (problem->lunits != NULL((void*)0)) 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_BODY404) continue;
5115 EG_deleteObject(MODL->body[ibody].ebody);
5116 }
5117 caps_makeSimpleErr(pobject, CERROR,
5118 "caps_build: Error on Body memory allocation!",
5119 NULL((void*)0), NULL((void*)0), errors);
5120 if (*errors != NULL((void*)0)) {
5121 errs = *errors;
5122 *nErr = errs->nError;
5123 }
5124 return EGADS_MALLOC-4;
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_BODY404) 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 /* clear sensitivity registry */
5143 if (problem->regGIN != NULL((void*)0)) {
5144 for (i = 0; i < problem->nRegGIN; i++) EG_free(problem->regGIN[i].name);
5145 EG_free(problem->regGIN);
5146 problem->regGIN = NULL((void*)0);
5147 problem->nRegGIN = 0;
5148 }
5149
5150 /* get geometry outputs */
5151 for (i = 0; i < problem->nGeomOut; i++) {
5152 if (problem->geomOut[i]->magicnumber != CAPSMAGIC1234321) continue;
5153 if (problem->geomOut[i]->type != VALUE) continue;
5154 if (problem->geomOut[i]->blind == NULL((void*)0)) continue;
5155 value = (capsValue *) problem->geomOut[i]->blind;
5156 if (value->derivs != NULL((void*)0)) {
5157 /* clear all dots */
5158 for (j = 0; j < value->nderiv; j++) {
5159 if (value->derivs[j].name != NULL((void*)0)) EG_free(value->derivs[j].name);
5160 if (value->derivs[j].deriv != NULL((void*)0)) EG_free(value->derivs[j].deriv);
5161 }
5162 EG_free(value->derivs);
5163 value->derivs = NULL((void*)0);
5164 value->nderiv = 0;
5165 }
5166 if (value->type == String) {
5167 EG_free(value->vals.string);
5168 value->vals.string = NULL((void*)0);
5169 } else {
5170 if (value->length != 1)
5171 EG_free(value->vals.reals);
5172 value->vals.reals = NULL((void*)0);
5173 }
5174 if (value->partial != NULL((void*)0)) {
5175 EG_free(value->partial);
5176 value->partial = NULL((void*)0);
5177 }
5178 status = ocsmGetPmtr(problem->modl, value->pIndex, &type, &nrow, &ncol,
5179 name);
5180 if (status != SUCCESS0) {
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((void*)0), errors);
5186 if (*errors != NULL((void*)0)) {
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((void*)0), errors);
5198 if (*errors != NULL((void*)0)) {
5199 errs = *errors;
5200 *nErr = errs->nError;
5201 }
5202 return CAPS_MISMATCH-324;
5203 }
5204 if ((nrow == 0) || (ncol == 0)) {
5205 status = ocsmGetValuS(problem->modl, value->pIndex, vstr);
5206 if (status != SUCCESS0) {
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((void*)0), errors);
5212 if (*errors != NULL((void*)0)) {
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((void*)0)) 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((void*)0)) {
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((void*)0), errors);
5246 if (*errors != NULL((void*)0)) {
5247 errs = *errors;
5248 *nErr = errs->nError;
5249 }
5250 return EGADS_MALLOC-4;
5251 }
5252 value->vals.reals = values;
5253 }
5254 /* flip storage
5255 for (n = m = j = 0; j < ncol; j++)
5256 for (k = 0; k < nrow; k++, n++) { */
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 != SUCCESS0) {
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((void*)0), errors);
5267 if (*errors != NULL((void*)0)) {
5268 errs = *errors;
5269 *nErr = errs->nError;
5270 }
5271 return status;
5272 }
5273 if (values[n] == -HUGEQ99999999.0) 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((void*)0)) {
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((void*)0), errors);
5285 if (*errors != NULL((void*)0)) {
5286 errs = *errors;
5287 *nErr = errs->nError;
5288 }
5289 return EGADS_MALLOC-4;
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] == -HUGEQ99999999.0) value->partial[n] = IsNull;
5295 }
5296 value->nullVal = IsPartial;
5297 }
5298 }
5299 }
5300
5301 if (value->units != NULL((void*)0)) EG_free(value->units);
5302 value->units = NULL((void*)0);
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_SUCCESS0)
5309 printf(" CAPS Warning: caps_addHistory = %d (caps_build)\n", status);
5310 }
5311
5312 /* update the value objects for restart */
5313 status = caps_writeProblem(pobject);
5314 if (status != CAPS_SUCCESS0)
5315 printf(" CAPS Warning: caps_writeProblem = %d (caps_build)\n", status);
5316 status = caps_dumpGeomVals(problem, 2);
5317 if (status != CAPS_SUCCESS0)
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_SUCCESS0;
5324}
5325
5326
5327int
5328caps_brokenLink(/*@null@*/ blCB callBack)
5329{
5330 CAPScallBack = callBack;
5331 return CAPS_SUCCESS0;
5332}
5333
5334
5335static void
5336caps_findLinkVal(int nObjs, capsObject **objects, int index, const char *name,
5337 int *n)
5338{
5339 int i;
5340
5341 *n = -1;
5342
5343 /* do we have to search? */
5344 if (index < nObjs)
5345 if (objects[index]->name != NULL((void*)0))
5346 if (strcmp(name,objects[index]->name) == 0) {
5347 *n = index;
5348 return;
5349 }
5350
5351 /* look for name */
5352 for (i = 0; i < nObjs; i++)
5353 if (objects[i]->name != NULL((void*)0))
5354 if (strcmp(name,objects[i]->name) == 0) {
5355 *n = i;
5356 return;
5357 }
5358
5359}
5360
5361
5362static void
5363caps_transferObjInfo(capsObject *source, capsObject *destin)
5364{
5365 if ((source == NULL((void*)0)) || (destin == NULL((void*)0))) return;
71
Assuming 'source' is equal to NULL
5366
5367 destin->attrs = source->attrs;
5368 source->attrs = NULL((void*)0);
5369 destin->nHistory = source->nHistory;
5370 destin->history = source->history;
5371 source->nHistory = 0;
5372 source->history = NULL((void*)0);
5373 destin->last = source->last;
5374 source->last.pname = NULL((void*)0);
5375 source->last.pID = NULL((void*)0);
5376 source->last.user = NULL((void*)0);
5377}
5378
5379
5380static int
5381caps_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_MAX4096], current[PATH_MAX4096], temp[PATH_MAX4096], *env;
5386 char name[MAX_NAME_LEN64], *units, *fileList;
5387 double dot, lower, upper, *reals;
5388 void *modl;
5389 ego body;
5390 capsObject *objs, *link, **geomIn = NULL((void*)0), **geomOut = NULL((void*)0);
5391 capsValue *value, *val;
5392 capsProblem *problem;
5393 capsAnalysis *analysis;
5394 modl_T *MODL = NULL((void*)0);
5395 FILE *fp;
5396
5397 problem = (capsProblem *) object->blind;
5398 problem->iPhrase = problem->nPhrase - 1;
5399
5400 /* get the original CSM file */
5401#ifdef WIN32
5402 snprintf(filename, PATH_MAX4096, "%s\\capsCSMFilePath", problem->root);
5403#else
5404 snprintf(filename, PATH_MAX4096, "%s/capsCSMFilePath", problem->root);
5405#endif
5406 fp = fopen(filename, "r");
5407 if (fp == NULL((void*)0)) {
1
Assuming 'fp' is not equal to NULL
2
Taking false branch
5408 snprintf(temp, PATH_MAX4096, "Cannot open %s (caps_open)\n", filename);
5409 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5410 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5411 return CAPS_IOERR-332;
5412 }
5413 for (i = 0; i < PATH_MAX4096; i++) {
3
Loop condition is true. Entering loop body
5414 fscanf(fp, "%c", &current[i]);
5415 if (current[i] == '|') break;
4
Assuming the condition is true
5
Taking true branch
6
Execution continues on line 5417
5416 }
5417 fclose(fp);
5418 if (i
6.1
'i' is not equal to PATH_MAX
== PATH_MAX4096) return CAPS_DIRERR-333;
7
Taking false branch
5419 current[i] = 0;
5420
5421 /* do an OpenCSM load */
5422 status = ocsmLoad((char *) current, &modl);
5423 if (status < SUCCESS0) {
8
Assuming 'status' is >= SUCCESS
9
Taking false branch
5424 snprintf(temp, PATH_MAX4096, "Cannot Load %s (caps_open)!", current);
5425 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5426 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5427 return status;
5428 }
5429 MODL = (modl_T *) modl;
5430 if (MODL == NULL((void*)0)) {
10
Assuming 'MODL' is not equal to NULL
11
Taking false branch
5431 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot get OpenCSM MODL (caps_open)!",
5432 NULL((void*)0), NULL((void*)0), errors);
5433 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5434 return CAPS_NOTFOUND-303;
5435 }
5436 MODL->context = problem->context;
5437/*@-kepttrans@*/
5438 MODL->userdata = problem;
5439/*@+kepttrans@*/
5440 MODL->tessAtEnd = 0;
5441 status = ocsmRegSizeCB(problem->modl, caps_sizeCB);
5442 if (status != SUCCESS0)
12
Assuming 'status' is equal to SUCCESS
13
Taking false branch
5443 printf(" CAPS Warning: ocsmRegSizeCB = %d (caps_open)!", status);
5444 env = getenv("DUMPEGADS");
5445 if (env != NULL((void*)0)) {
14
Assuming 'env' is equal to NULL
15
Taking false branch
5446 MODL->dumpEgads = 1;
5447 MODL->loadEgads = 1;
5448 }
5449
5450 /* check that Branches are properly ordered */
5451 status = ocsmCheck(modl);
5452 if (status < SUCCESS0) {
16
Assuming 'status' is >= SUCCESS
17
Taking false branch
5453 snprintf(temp, PATH_MAX4096, "ocsmCheck = %d (caps_open)!", status);
5454 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5455 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5456 ocsmFree(modl);
5457 return status;
5458 }
5459 fflush(stdoutstdout);
5460
5461 /* get geometry counts */
5462 status = ocsmInfo(modl, &nbrch, &npmtr, &nbody);
5463 if (status != SUCCESS0) {
18
Assuming 'status' is equal to SUCCESS
19
Taking false branch
5464 snprintf(temp, PATH_MAX4096, "ocsmInfo returns %d (caps_open)!", status);
5465 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5466 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5467 ocsmFree(modl);
5468 return status;
5469 }
5470
5471 /* count the GeomIns and GeomOuts */
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 != SUCCESS0) {
22
Assuming 'status' is equal to SUCCESS
23
Taking false branch
5475 ocsmFree(modl);
5476 return status;
5477 }
5478 if (type == OCSM_OUTPMTR504) ngOut++;
24
Assuming 'type' is not equal to OCSM_OUTPMTR
25
Taking false branch
5479 if (type == OCSM_DESPMTR500) ngIn++;
26
Assuming 'type' is equal to OCSM_DESPMTR
27
Taking true branch
5480 if (type
27.1
'type' is not equal to OCSM_CFGPMTR
== OCSM_CFGPMTR501) ngIn++;
28
Taking false branch
5481 if (type
28.1
'type' is not equal to OCSM_CONPMTR
== OCSM_CONPMTR502) ngIn++;
29
Taking false branch
5482 }
5483
5484 /* allocate the objects for the geometry inputs */
5485 if (ngIn
31.1
'ngIn' is not equal to 0
!= 0) {
32
Taking true branch
5486 geomIn = (capsObject **) EG_alloc(ngIn*sizeof(capsObject *));
5487 if (geomIn == NULL((void*)0)) {
33
Assuming 'geomIn' is not equal to NULL
34
Taking false branch
5488 return EGADS_MALLOC-4;
5489 }
5490 for (i = 0; i < ngIn; i++) geomIn[i] = NULL((void*)0);
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((void*)0)) {
37
Assuming 'value' is not equal to NULL
38
Taking false branch
5493 EG_free(geomIn);
5494 return EGADS_MALLOC-4;
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_DESPMTR500) && (type != OCSM_CFGPMTR501) &&
40
Assuming 'type' is equal to OCSM_DESPMTR
5499 (type != OCSM_CONPMTR502)) continue;
5500 if ((nrow == 0) || (ncol == 0)) continue; /* ignore string pmtrs */
41
Assuming 'nrow' is not equal to 0
42
Assuming 'ncol' is not equal to 0
43
Taking false branch
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((void*)0);
5510 value[i].meshWriter = NULL((void*)0);
5511 value[i].link = NULL((void*)0);
5512 value[i].vals.reals = NULL((void*)0);
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
44.1
'ncol' is <= 1
> 1) || (nrow > 1)) {
45
Assuming 'nrow' is <= 1
46
Taking false branch
5519 value[i].dim = Vector;
5520 }
5521 value[i].gInType = 0;
5522 if (type
46.1
'type' is not equal to OCSM_CFGPMTR
== OCSM_CFGPMTR501) value[i].gInType = 1;
47
Taking false branch
5523 if (type
47.1
'type' is not equal to OCSM_CONPMTR
== OCSM_CONPMTR502) value[i].gInType = 2;
48
Taking false branch
5524 value[i].partial = NULL((void*)0);
5525 value[i].nderiv = 0;
5526 value[i].derivs = NULL((void*)0);
5527
5528 status = caps_makeObject(&objs);
5529 if (status != CAPS_SUCCESS0) {
49
Assuming 'status' is equal to CAPS_SUCCESS
50
Taking false branch
5530 EG_free(geomIn);
5531 EG_free(value);
5532 return EGADS_MALLOC-4;
5533 }
5534 if (i
50.1
'i' is equal to 0
== 0) objs->blind = value;
51
Taking true branch
5535/*@-kepttrans@*/
5536 objs->parent = object;
5537/*@+kepttrans@*/
5538 objs->name = NULL((void*)0);
5539 objs->type = VALUE;
5540 objs->subtype = GEOMETRYIN;
5541 objs->last.sNum = problem->sNum + 1;
5542/*@-immediatetrans@*/
5543 objs->blind = &value[i];
5544/*@+immediatetrans@*/
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
55
Taking true branch
5552 /* new variable! */
5553 if (nrow*ncol > 1) {
56
Assuming the condition is false
57
Taking false branch
5554 reals = (double *) EG_alloc(nrow*ncol*sizeof(double));
5555 if (reals == NULL((void*)0)) {
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/*@-kepttrans@*/
5562 EG_free(value);
5563/*@+kepttrans@*/
5564 return EGADS_MALLOC-4;
5565 }
5566 value[i].vals.reals = reals;
5567 } else {
5568 reals = &value[i].vals.real;
5569 }
5570 if (geomIn[i] != NULL((void*)0)) geomIn[i]->name = EG_strdup(name);
58
Taking true branch
5571/* flip storage
5572 for (n = j = 0; j < ncol; j++)
5573 for (k = 0; k < nrow; k++, n++) { */
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 != SUCCESS0) {
5579 for (jj = 0; jj <= i; jj++) {
5580 if (value[jj].length != 1) EG_free(value[jj].vals.reals);
5581 if (geomIn[jj] != NULL((void*)0)) EG_free(geomIn[jj]->name);
5582 }
5583 EG_free(geomIn);
5584/*@-kepttrans@*/
5585 EG_free(value);
5586/*@+kepttrans@*/
5587 return status;
5588 }
5589 }
5590 if (type == OCSM_CFGPMTR501) continue;
61
Assuming 'type' is not equal to OCSM_CFGPMTR
62
Taking false branch
5591 status = ocsmGetBnds(modl, value[i].pIndex, 1, 1, &lower, &upper);
5592 if (status != SUCCESS0) continue;
63
Assuming 'status' is equal to SUCCESS
64
Taking false branch
5593 if ((lower != -HUGEQ99999999.0) || (upper != HUGEQ99999999.0)) {
65
Assuming the condition is false
66
Assuming 'upper' is equal to HUGEQ
67
Taking false branch
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_SUCCESS0)
68
Assuming 'status' is equal to CAPS_SUCCESS
69
Taking false branch
5599 printf(" CAPS Warning: addHistory = %d (caps_open)!\n", status);
5600 } else {
5601 /* found the variable -- update the value */
5602 val = (capsValue *) problem->geomIn[n]->blind;
5603 if (geomIn[i] != NULL((void*)0)) geomIn[i]->name = EG_strdup(name);
5604 val->pIndex = 0; /* mark as found */
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((void*)0);
5611 reals = value[i].vals.reals;
5612 } else {
5613 value[i].vals.real = val->vals.real;
5614 reals = &value[i].vals.real;
5615 }
5616 /* flip storage
5617 for (m = j = 0; j < value[i].ncol; j++)
5618 for (k = 0; k < value[i].nrow; k++, m++) { */
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 != SUCCESS0) {
5623 snprintf(temp, PATH_MAX4096, "%d ocsmSetValuD[%d,%d] fails with %d!",
5624 value->pIndex, k+1, j+1, status);
5625 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5626 if (*errors != NULL((void*)0)) *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((void*)0)) EG_free(geomIn[jj]->name);
5630 }
5631 EG_free(geomIn);
5632/*@-kepttrans@*/
5633 EG_free(value);
5634/*@+kepttrans@*/
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 /* update the new object */
5643 caps_transferObjInfo(problem->geomIn[n], geomIn[i]);
70
Calling 'caps_transferObjInfo'
72
Returning from 'caps_transferObjInfo'
5644 }
5645 }
5646
5647 /* notify any broken links */
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((void*)0)) continue;
5652 if (CAPScallBack == NULL((void*)0)) {
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 /* cleanup old geomIns */
5662 caps_freeValueObjects(0, problem->nGeomIn, problem->geomIn);
5663 problem->nGeomIn = ngIn;
5664 problem->geomIn = geomIn;
5665
5666 /* allocate the objects for the geometry outputs */
5667 if (ngOut != 0) {
5668 units = NULL((void*)0);
5669 if (problem->lunits != NULL((void*)0)) units = problem->lunits[problem->nBodies-1];
5670 geomOut = (capsObject **) EG_alloc(ngOut*sizeof(capsObject *));
5671 if (geomOut == NULL((void*)0)) {
5672 return EGADS_MALLOC-4;
5673 }
5674 for (i = 0; i < ngOut; i++) geomOut[i] = NULL((void*)0);
5675 value = (capsValue *) EG_alloc(ngOut*sizeof(capsValue));
5676 if (value == NULL((void*)0)) {
5677 EG_free(geomOut);
5678 return EGADS_MALLOC-4;
5679 }
5680 for (i = j = 0; j < npmtr; j++) {
5681 ocsmGetPmtr(modl, j+1, &type, &nrow, &ncol, name);
5682 if (type != OCSM_OUTPMTR504) 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((void*)0);
5694 value[i].meshWriter = NULL((void*)0);
5695 value[i].link = NULL((void*)0);
5696 value[i].vals.reals = NULL((void*)0);
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((void*)0);
5701 value[i].nderiv = 0;
5702 value[i].derivs = NULL((void*)0);
5703 caps_geomOutUnits(name, units, &value[i].units);
5704
5705 status = caps_makeObject(&objs);
5706 if (status != CAPS_SUCCESS0) {
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-4;
5712 }
5713/*@-kepttrans@*/
5714 objs->parent = object;
5715/*@+kepttrans@*/
5716 objs->name = EG_strdup(name);
5717 objs->type = VALUE;
5718 objs->subtype = GEOMETRYOUT;
5719 objs->last.sNum = 0;
5720/*@-immediatetrans@*/
5721 objs->blind = &value[i];
5722/*@+immediatetrans@*/
5723 geomOut[i] = objs;
5724 geomOut[i]->last.sNum = problem->sNum;
5725
5726 /* update the new object from the old */
5727 if (n != -1) caps_transferObjInfo(problem->geomOut[n], geomOut[i]);
5728 i++;
5729 }
5730
5731 /* search for links in the Value Objects */
5732 for (i = 0; i < problem->nAnalysis; i++) {
5733 analysis = (capsAnalysis *) problem->analysis[i]->blind;
5734 if (analysis == NULL((void*)0)) continue;
5735 for (j = 0; j < analysis->nAnalysisIn; j++) {
5736 val = (capsValue *) analysis->analysisIn[j]->blind;
5737 if (val->link == NULL((void*)0)) 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((void*)0);
5743 if (CAPScallBack == NULL((void*)0)) {
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 /* cleanup old geomOuts */
5758 caps_freeValueObjects(0, problem->nGeomOut, problem->geomOut);
5759 problem->nGeomOut = ngOut;
5760 problem->geomOut = geomOut;
5761
5762 /* write the path file */
5763#ifdef WIN32
5764 snprintf(current, PATH_MAX4096, "%s\\capsCSMFilePath", problem->root);
5765#else
5766 snprintf(current, PATH_MAX4096, "%s/capsCSMFilePath", problem->root);
5767#endif
5768 caps_rmFile(current);
5769 status = ocsmGetFilelist(modl, &fileList);
5770 if (status != CAPS_SUCCESS0) {
5771 return status;
5772 }
5773 fp = fopen(current, "w");
5774 if (fp == NULL((void*)0)) {
5775 EG_free(fileList);
5776 return CAPS_IOERR-332;
5777 }
5778 fprintf(fp, "%s\n", fileList);
5779 fclose(fp);
5780 EG_free(fileList);
5781 fflush(stdoutstdout);
5782
5783 /* write an OpenCSM checkpoint file */
5784#ifdef WIN32
5785 snprintf(current, PATH_MAX4096, "%s\\capsRestart.cpc", problem->root);
5786#else
5787 snprintf(current, PATH_MAX4096, "%s/capsRestart.cpc", problem->root);
5788#endif
5789 caps_rmFile(current);
5790 status = ocsmSave(modl, current);
5791 if (status != CAPS_SUCCESS0) {
5792 return status;
5793 }
5794 fflush(stdoutstdout);
5795
5796 /* rebuild the dirty geometry */
5797 if (problem->bodies != NULL((void*)0)) {
5798 if (problem->lunits != NULL((void*)0))
5799 for (i = 0; i < problem->nBodies; i++)
5800 if (problem->lunits[i] != NULL((void*)0)) EG_free(problem->lunits[i]);
5801 /* remove old bodies & tessellations for all Analyses */
5802 for (i = 0; i < problem->nAnalysis; i++) {
5803 analysis = (capsAnalysis *) problem->analysis[i]->blind;
5804 if (analysis == NULL((void*)0)) continue;
5805 if (analysis->tess != NULL((void*)0)) {
5806 for (j = 0; j < analysis->nTess; j++)
5807 if (analysis->tess[j] != NULL((void*)0)) {
5808 /* delete the body in the tessellation if not on the OpenCSM stack */
5809 body = NULL((void*)0);
5810 if (j >= analysis->nBody) {
5811 status = EG_statusTessBody(analysis->tess[j], &body, &state,
5812 &npts);
5813 if (status != CAPS_SUCCESS0)
5814 printf(" CAPS Warning: statusTessBody = %d (caps_phaseCSMreload)\n",
5815 status);
5816 }
5817 EG_deleteObject(analysis->tess[j]);
5818 if (body != NULL((void*)0)) EG_deleteObject(body);
5819 analysis->tess[j] = NULL((void*)0);
5820 }
5821 EG_free(analysis->tess);
5822 analysis->tess = NULL((void*)0);
5823 analysis->nTess = 0;
5824 }
5825 if (analysis->bodies != NULL((void*)0)) {
5826 EG_free(analysis->bodies);
5827 analysis->bodies = NULL((void*)0);
5828 analysis->nBody = 0;
5829 }
5830 /* remove tracked sensitivity calculations */
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((void*)0);
5838 problem->lunits = NULL((void*)0);
5839 }
5840 problem->nBodies = 0;
5841 ocsmFree(problem->modl);
5842 problem->modl = modl;
5843 problem->sNum = problem->sNum + 1;
5844
5845 /* remove any Geometry Value Objects */
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 /* force a rebuild */
5855 problem->geometry.sNum = 0;
5856 jj = caps_build(object, nErr, errors);
5857 if (jj == CAPS_SUCCESS0) {
5858 /* populate the geometry info */
5859#ifdef WIN32
5860 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\geom.txt", problem->root);
5861 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\xxTempxx", problem->root);
5862#else
5863 snprintf(filename, PATH_MAX4096, "%s/capsRestart/geom.txt", problem->root);
5864 snprintf(temp, PATH_MAX4096, "%s/capsRestart/xxTempxx", problem->root);
5865#endif
5866 fp = fopen(temp, "w");
5867 if (fp == NULL((void*)0)) {
5868 snprintf(temp, PATH_MAX4096, "Cannot open %s (caps_phaseCSMreload)\n",
5869 filename);
5870 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5871 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5872 return CAPS_DIRERR-333;
5873 }
5874 fprintf(fp, "%d %d\n", problem->nGeomIn, problem->nGeomOut);
5875 if (problem->geomIn != NULL((void*)0))
5876 for (i = 0; i < problem->nGeomIn; i++)
5877 if (problem->geomIn[i] == NULL((void*)0)) {
5878 fprintf(fp, "geomIn%d\n", i);
5879 } else {
5880 fprintf(fp, "%s\n", problem->geomIn[i]->name);
5881 }
5882 if (problem->geomOut != NULL((void*)0))
5883 for (i = 0; i < problem->nGeomOut; i++)
5884 if (problem->geomOut[i] == NULL((void*)0)) {
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_SUCCESS0) {
5892 snprintf(temp, PATH_MAX4096, "Cannot rename %s (caps_phaseCSMreload)!\n",
5893 filename);
5894 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5895 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5896 return status;
5897 }
5898 status = caps_dumpGeomVals(problem, 1);
5899 if (status != CAPS_SUCCESS0)
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
5910static int
5911caps_phaseDeletion(capsProblem *problem)
5912{
5913 int i, j, k, m, status;
5914 char filename[PATH_MAX4096], temp[PATH_MAX4096];
5915 capsObject *link;
5916 capsValue *val;
5917 capsAnalysis *analysis;
5918 capsBound *bound;
5919 capsVertexSet *vertexSet;
5920 FILE *fp;
5921
5922 /* set any Bounds to delete if a marked Analysis is in the Bound */
5923 for (i = 0; i < problem->nAnalysis; i++) {
5924 if (problem->analysis[i] == NULL((void*)0)) continue;
5925 if (problem->analysis[i]->blind == NULL((void*)0)) continue;
5926 if (problem->analysis[i]->delMark == 0) continue;
5927 for (j = 0; j < problem->nBound; j++) {
5928 if (problem->bounds[j] == NULL((void*)0)) continue;
5929 if (problem->bounds[j]->delMark == 1) continue;
5930 if (problem->bounds[j]->blind == NULL((void*)0)) continue;
5931 bound = (capsBound *) problem->bounds[j]->blind;
5932 for (k = 0; j < bound->nVertexSet; k++) {
5933 if (bound->vertexSet[k] == NULL((void*)0)) continue;
5934 if (bound->vertexSet[k]->blind == NULL((void*)0)) 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 /* look at Value Objects of type PARAMETER */
5946 for (k = i = 0; i < problem->nParam; i++) {
5947 if (problem->params[i] == NULL((void*)0)) continue;
5948 if (problem->params[i]->blind == NULL((void*)0)) 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((void*)0)) continue;
5955 if (problem->params[i]->blind == NULL((void*)0)) continue;
5956 if (problem->params[i]->delMark == 0) {
5957 problem->params[j] = problem->params[i];
5958 j++;
5959 } else {
5960 /* search for links in the AnalysisIn Value Objects */
5961 for (k = 0; k < problem->nAnalysis; k++) {
5962 if (problem->analysis[k] == NULL((void*)0)) continue;
5963 if (problem->analysis[k]->blind == NULL((void*)0)) 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((void*)0);
5970 if (CAPScallBack == NULL((void*)0)) {
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 /* search for links in the GeometryIn Value Objects */
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((void*)0);
5985 if (CAPScallBack == NULL((void*)0)) {
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 /* delete the Value Object */
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((void*)0);
6010 }
6011#ifdef WIN32
6012 caps_rmWild(problem->root, "capsRestart\\VP-*");
6013 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\param.txt", problem->root);
6014 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\zzTempzz", problem->root);
6015#else
6016 caps_rmWild(problem->root, "capsRestart/VP-*");
6017 snprintf(filename, PATH_MAX4096, "%s/capsRestart/param.txt", problem->root);
6018 snprintf(temp, PATH_MAX4096, "%s/capsRestart/zzTempzz", problem->root);
6019#endif
6020 fp = fopen(temp, "w");
6021 if (fp == NULL((void*)0)) {
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((void*)0))
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_SUCCESS0)
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_SUCCESS0)
6038 printf(" CAPS Warning: Cannot rename %s (%d)!\n", filename, status);
6039 }
6040 }
6041 }
6042
6043 /* remove Bound Objects */
6044 for (j = problem->nBound-1; j >= 0; j--) {
6045 if (problem->bounds[j] == NULL((void*)0)) continue;
6046 if (problem->bounds[j]->blind == NULL((void*)0)) continue;
6047 if (problem->bounds[j]->delMark == 0) continue;
6048 bound = (capsBound *) problem->bounds[j]->blind;
6049#ifdef WIN32
6050 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\BN-%4.4d",
6051 problem->root, bound->index);
6052#else
6053 snprintf(filename, PATH_MAX4096, "%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_SUCCESS0)
6059 printf(" CAPS Warning: Delete of Bound %d ret = %d from freeBound!\n",
6060 j+1, status);
6061 }
6062
6063 /* remove Analysis Objects */
6064 for (j = i = 0; i < problem->nAnalysis; i++) {
6065 if (problem->analysis[i] == NULL((void*)0)) continue;
6066 if (problem->analysis[i]->blind == NULL((void*)0)) continue;
6067 if (problem->analysis[i]->delMark == 0) {
6068 problem->analysis[j] = problem->analysis[i];
6069 j++;
6070 } else {
6071 /* search for links in the AnalysisIn & GeomIn Value Objects */
6072 for (k = 0; k < problem->nAnalysis; k++) {
6073 if (problem->analysis[k] == NULL((void*)0)) continue;
6074 if (problem->analysis[k]->blind == NULL((void*)0)) 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((void*)0)) continue;
6081 if (link->subtype != ANALYSISOUT) continue;
6082 if (link->parent != problem->analysis[i]) continue;
6083 snprintf(temp, PATH_MAX4096, "%s:%s", problem->analysis[i]->name,
6084 link->name);
6085 val->link = NULL((void*)0);
6086 if (CAPScallBack == NULL((void*)0)) {
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((void*)0)) continue;
6098 if (link->subtype != ANALYSISOUT) continue;
6099 if (link->parent != problem->analysis[i]) continue;
6100 snprintf(temp, PATH_MAX4096, "%s:%s", problem->analysis[i]->name,
6101 link->name);
6102 val->link = NULL((void*)0);
6103 if (CAPScallBack == NULL((void*)0)) {
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((void*)0);
6128 }
6129 }
6130
6131 return CAPS_SUCCESS0;
6132}
6133
6134
6135int
6136caps_open(const char *prPath, /*@null@*/ const char *phName, int flag,
6137 /*@null@*/ 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_MAX4096], current[PATH_MAX4096];
6144 char name[MAX_NAME_LEN64], *fileList;
6145 char filename[PATH_MAX4096], temp[PATH_MAX4096], **tmp, line[129];
6146 CAPSLONGunsigned long 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((void*)0);
6157 size_t nw;
6158 FILE *fp;
6159 const char *aname, *astring, *prName, *fname = NULL((void*)0);
6160 const char *newPhase = "New Phase";
6161 const int *aints;
6162 const double *areals;
6163
6164 if (nErr == NULL((void*)0)) return CAPS_NULLVALUE-307;
6165 if (errors == NULL((void*)0)) return CAPS_NULLVALUE-307;
6166 *pobject = NULL((void*)0);
6167 *nErr = 0;
6168 *errors = NULL((void*)0);
6169 if (prPath == NULL((void*)0)) return CAPS_NULLNAME-308;
6170 len = strlen(prPath);
6171 for (i = 0; i < len; i++)
6172 if (prPath[i] == ' ') {
6173 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot use spaces in path (caps_open):",
6174 prPath, NULL((void*)0), errors);
6175 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6176 return CAPS_BADNAME-317;
6177 }
6178 if (phName != NULL((void*)0)) {
6179 if (strcmp(phName, "Scratch") == 0) {
6180 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot use the phase Scratch (caps_open)!",
6181 NULL((void*)0), NULL((void*)0), errors);
6182 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6183 return CAPS_BADNAME-317;
6184 }
6185 len = strlen(phName);
6186 for (i = 0; i < len; i++)
6187 if ((phName[i] == '/') || (phName[i] == '\\')) {
6188 caps_makeSimpleErr(NULL((void*)0), CERROR,
6189 "Cannot use slashes in phase name (caps_open):",
6190 phName, NULL((void*)0), errors);
6191 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6192 return CAPS_BADNAME-317;
6193 }
6194 }
6195 for (i = 0; i < PATH_MAX4096-1; i++) filename[i] = ' ';
6196 filename[PATH_MAX4096-1] = 0;
6197
6198 if (flag == oFileName) {
6199 /* filename input */
6200 fname = (const char *) ptr;
6201 if (fname == NULL((void*)0)) return CAPS_NULLNAME-308;
6202 n = -1;
6203#ifdef WIN32
6204 /* do we have a Windows drive? */
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_MAX4096, "Cannot change drive to %c (caps_open)!",
6216 fname[0]);
6217 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6218 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6219 return CAPS_DIRERR-333;
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 /* absolute path */
6229#ifdef WIN32
6230 if (fname[1] == ':') {
6231 snprintf(filename, PATH_MAX4096, "%s", fname);
6232 } else {
6233 snprintf(filename, PATH_MAX4096, "%c:%s", _getdrive()+64, fname);
6234 }
6235#else
6236 snprintf(filename, PATH_MAX4096, "%s", fname);
6237#endif
6238 } else {
6239 /* relative path -- make it absolute */
6240 (void) getcwd(current, PATH_MAX4096);
6241#ifdef WIN32
6242 snprintf(filename, PATH_MAX4096, "%s\\%s", current, fname);
6243#else
6244 snprintf(filename, PATH_MAX4096, "%s/%s", current, fname);
6245#endif
6246 }
6247 status = caps_prunePath(filename);
6248 if (status != CAPS_SUCCESS0) {
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((void*)0)) return CAPS_NULLOBJ-309;
6255 } else if (flag == oEGO) {
6256 model = (ego) ptr;
6257 if (model == NULL((void*)0)) return CAPS_NULLOBJ-309;
6258 status = EG_getTopology(model, &ref, &oclass, &mtype, data, &len, &childs,
6259 &senses);
6260 if (status != EGADS_SUCCESS0) return status;
6261 } else if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel)) {
6262 if (phName == NULL((void*)0)) {
6263 caps_makeSimpleErr(NULL((void*)0), CERROR,
6264 "Cannot start with a NULL PhaseName (caps_open)!",
6265 NULL((void*)0), NULL((void*)0), errors);
6266 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6267 return CAPS_DIRERR-333;
6268 }
6269 fname = (const char *) ptr;
6270 if (fname == NULL((void*)0)) return CAPS_NULLNAME-308;
6271 } else if ((flag == oContinue) || (flag == oReadOnly)) {
6272 close = 0;
6273 } else {
6274 /* other values of flag */
6275 return CAPS_NOTIMPLEMENT-334;
6276 }
6277
6278 /* does file exist? */
6279 fileLen = 0;
6280 if (flag == oFileName) {
6281 fp = fopen(filename, "rb");
6282 if (fp == NULL((void*)0)) return CAPS_NOTFOUND-303;
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-311;
6290
6291 /* find the file extension */
6292 len = strlen(filename);
6293 for (idot = len-1; idot > 0; idot--)
6294 if (filename[idot] == '.') break;
6295 if (idot == 0) return CAPS_BADNAME-317;
6296/*@-unrecog@*/
6297 if ((strcasecmp(&filename[idot],".csm") != 0) &&
6298 (strcasecmp(&filename[idot],".egads") != 0)) return CAPS_BADTYPE-306;
6299/*@+unrecog@*/
6300 }
6301
6302 /* set up our path and name */
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_SUCCESS0) {
6310 caps_makeSimpleErr(NULL((void*)0), CERROR, "Not a valid Problem Name (caps_open):",
6311 prName, NULL((void*)0), errors);
6312 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6313 return status;
6314 }
6315 n = -1;
6316#ifdef WIN32
6317 /* do we have a Windows drive? */
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_MAX4096, "Cannot change drive to %c (caps_open)!",
6329 prPath[0]);
6330 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6331 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6332 return CAPS_DIRERR-333;
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 /* absolute path */
6342 status = caps_statFile(prPath);
6343 if (status == EGADS_SUCCESS0) {
6344 caps_makeSimpleErr(NULL((void*)0), CERROR, "Lands on a flat file (caps_open):",
6345 prPath, NULL((void*)0), errors);
6346 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6347 return CAPS_DIRERR-333;
6348 } else if (status == EGADS_NOTFOUND-1) {
6349 status = caps_mkDir(prPath);
6350 if (status != EGADS_SUCCESS0) {
6351 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot mkDir (caps_open):",
6352 prPath, NULL((void*)0), errors);
6353 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6354 return status;
6355 }
6356 }
6357#ifdef WIN32
6358 if (prPath[1] == ':') {
6359 if (phName == NULL((void*)0)) {
6360 snprintf(root, PATH_MAX4096, "%s\\Scratch", prPath);
6361 } else {
6362 snprintf(root, PATH_MAX4096, "%s\\%s", prPath, phName);
6363 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel))
6364 snprintf(filename, PATH_MAX4096, "%s\\%s", prPath, fname);
6365 }
6366 } else {
6367 if (phName == NULL((void*)0)) {
6368 snprintf(root, PATH_MAX4096, "%c:%s\\Scratch", _getdrive()+64, prPath);
6369 } else {
6370 snprintf(root, PATH_MAX4096, "%c:%s\\%s", _getdrive()+64, prPath, phName);
6371 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel))
6372 snprintf(filename, PATH_MAX4096, "%c:%s\\%s", _getdrive()+64, prPath,
6373 fname);
6374 }
6375 }
6376#else
6377 if (phName == NULL((void*)0)) {
6378 snprintf(root, PATH_MAX4096, "%s/Scratch", prPath);
6379 } else {
6380 snprintf(root, PATH_MAX4096, "%s/%s", prPath, phName);
6381 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel))
6382 snprintf(filename, PATH_MAX4096, "%s/%s", prPath, fname);
6383 }
6384#endif
6385 } else {
6386 /* relative path -- make it absolute */
6387 (void) getcwd(current, PATH_MAX4096);
6388#ifdef WIN32
6389 snprintf(root, PATH_MAX4096, "%s\\%s", current, prPath);
6390#else
6391 snprintf(root, PATH_MAX4096, "%s/%s", current, prPath);
6392#endif
6393 status = caps_statFile(root);
6394 if (status == EGADS_SUCCESS0) {
6395 caps_makeSimpleErr(NULL((void*)0), CERROR, "Path lands on a flat file (caps_open):",
6396 root, NULL((void*)0), errors);
6397 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6398 return CAPS_DIRERR-333;
6399 } else if (status == EGADS_NOTFOUND-1) {
6400 status = caps_mkDir(root);
6401 if (status != EGADS_SUCCESS0) {
6402 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot make Path (caps_open):",
6403 root, NULL((void*)0), errors);
6404 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6405 return status;
6406 }
6407 }
6408#ifdef WIN32
6409 if (phName == NULL((void*)0)) {
6410 snprintf(root, PATH_MAX4096, "%s\\%s\\Scratch", current, prPath);
6411 } else {
6412 snprintf(root, PATH_MAX4096, "%s\\%s\\%s", current, prPath, phName);
6413 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel))
6414 snprintf(filename, PATH_MAX4096, "%s\\%s\\%s", current, prPath, fname);
6415 }
6416#else
6417 if (phName == NULL((void*)0)) {
6418 snprintf(root, PATH_MAX4096, "%s/%s/Scratch", current, prPath);
6419 } else {
6420 snprintf(root, PATH_MAX4096, "%s/%s/%s", current, prPath, phName);
6421 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel))
6422 snprintf(filename, PATH_MAX4096, "%s/%s/%s", current, prPath, fname);
6423 }
6424#endif
6425 }
6426 status = caps_prunePath(root);
6427 if (status != CAPS_SUCCESS0) {
6428 printf(" CAPS Error: Path '%s' has embedded space(s)!\n", root);
6429 return status;
6430 }
6431 /* not a continuation -- must not have a directory (unless Scratch)! */
6432 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel)) {
6433 status = caps_prunePath(filename);
6434 if (status != CAPS_SUCCESS0) {
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_SUCCESS0) {
6440 caps_makeSimpleErr(NULL((void*)0), CERROR, "Lands on a flat file (caps_open):",
6441 root, NULL((void*)0), errors);
6442 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6443 return CAPS_DIRERR-333;
6444 } else if (status != EGADS_NOTFOUND-1) {
6445 caps_makeSimpleErr(NULL((void*)0), CERROR, "Path already exists (caps_open):",
6446 root, NULL((void*)0), errors);
6447 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6448 return EGADS_EXISTS-30;
6449 }
6450#ifdef WIN32
6451 snprintf(current, PATH_MAX4096, "%s\\capsClosed", filename);
6452#else
6453 snprintf(current, PATH_MAX4096, "%s/capsClosed", filename);
6454#endif
6455 status = caps_statFile(current);
6456 if (status != EGADS_SUCCESS0) {
6457 caps_makeSimpleErr(NULL((void*)0), CERROR, "Not closed (caps_open):",
6458 filename, NULL((void*)0), errors);
6459 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6460 return CAPS_DIRERR-333;
6461 }
6462 status = caps_cpDir(filename, root);
6463 if (status != EGADS_SUCCESS0) {
6464 snprintf(temp, PATH_MAX4096, "Copy directory = %d (caps_open)", status);
6465 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6466 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6467 return status;
6468 }
6469 /* remove closed & lock markers */
6470#ifdef WIN32
6471 snprintf(current, PATH_MAX4096, "%s\\capsClosed", root);
6472#else
6473 snprintf(current, PATH_MAX4096, "%s/capsClosed", root);
6474#endif
6475 status = caps_rmFile(current);
6476 if ((status != EGADS_SUCCESS0) && (status != EGADS_NOTFOUND-1))
6477 printf(" CAPS Warning: Cannot remove Closed file!\n");
6478#ifdef WIN32
6479 snprintf(current, PATH_MAX4096, "%s\\capsLock", root);
6480#else
6481 snprintf(current, PATH_MAX4096, "%s/capsLock", root);
6482#endif
6483 status = caps_rmFile(current);
6484 if ((status != EGADS_SUCCESS0) && (status != EGADS_NOTFOUND-1))
6485 printf(" CAPS Warning: Cannot remove Lock file (caps_open)\n");
6486 } else if (flag == oContinue) {
6487 /* should not be closed */
6488#ifdef WIN32
6489 snprintf(current, PATH_MAX4096, "%s\\capsClosed", root);
6490#else
6491 snprintf(current, PATH_MAX4096, "%s/capsClosed", root);
6492#endif
6493 status = caps_statFile(current);
6494 if (status != EGADS_NOTFOUND-1) {
6495 caps_makeSimpleErr(NULL((void*)0), CERROR,
6496 "Found Closed file on continuation (caps_open)!",
6497 NULL((void*)0), NULL((void*)0), errors);
6498 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6499 return CAPS_EXISTS-331;
6500 }
6501 } else if (flag == oReadOnly) {
6502 /* should be closed */
6503#ifdef WIN32
6504 snprintf(current, PATH_MAX4096, "%s\\capsClosed", root);
6505#else
6506 snprintf(current, PATH_MAX4096, "%s/capsClosed", root);
6507#endif
6508 status = caps_statFile(current);
6509 if (status == EGADS_NOTFOUND-1) {
6510 caps_makeSimpleErr(NULL((void*)0), CERROR,
6511 "No Closed file on ReadOnly (caps_open)!",
6512 NULL((void*)0), NULL((void*)0), errors);
6513 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6514 return CAPS_EXISTS-331;
6515 }
6516 } else {
6517 status = caps_statFile(root);
6518 if (status == EGADS_SUCCESS0) {
6519 caps_makeSimpleErr(NULL((void*)0), CERROR, "Lands on a flat file (caps_open):",
6520 root, NULL((void*)0), errors);
6521 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6522 return CAPS_DIRERR-333;
6523 } else if (status != EGADS_NOTFOUND-1) {
6524 if (phName != NULL((void*)0)) {
6525 caps_makeSimpleErr(NULL((void*)0), CERROR, "Already exists (caps_open):",
6526 root, NULL((void*)0), errors);
6527 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6528 return EGADS_EXISTS-30;
6529 } else {
6530#ifdef WIN32
6531 snprintf(current, PATH_MAX4096, "%s\\capsLock", root);
6532#else
6533 snprintf(current, PATH_MAX4096, "%s/capsLock", root);
6534#endif
6535 if (caps_statFile(current) != EGADS_NOTFOUND-1) {
6536 caps_makeSimpleErr(NULL((void*)0), 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((void*)0)) *nErr = (*errors)->nError;
6540 return CAPS_DIRERR-333;
6541 }
6542 caps_rmDir(root);
6543 }
6544 }
6545 status = caps_mkDir(root);
6546 if (status != EGADS_SUCCESS0) {
6547 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot mkDir (caps_open)!",
6548 root, NULL((void*)0), errors);
6549 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6550 return status;
6551 }
6552 }
6553
6554 /* do we have a lock file? */
6555#ifdef WIN32
6556 snprintf(current, PATH_MAX4096, "%s\\capsLock", root);
6557#else
6558 snprintf(current, PATH_MAX4096, "%s/capsLock", root);
6559#endif
6560 if (caps_statFile(current) != EGADS_NOTFOUND-1) {
6561 caps_makeSimpleErr(NULL((void*)0), 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((void*)0)) *nErr = (*errors)->nError;
6565 return CAPS_DIRERR-333;
6566 }
6567 if (flag != oReadOnly) {
6568 tmp = (char **) EG_reall(CAPSlocks, (CAPSnLock+1)*sizeof(char *));
6569 if (tmp == NULL((void*)0)) {
6570 caps_makeSimpleErr(NULL((void*)0), CERROR, "ReAllocating Locks storage (caps_open)!",
6571 NULL((void*)0), NULL((void*)0), errors);
6572 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6573 return EGADS_MALLOC-4;
6574 }
6575 CAPSlocks = tmp;
6576 CAPSlocks[CAPSnLock] = EG_strdup(current);
6577 CAPSnLock++;
6578 fp = fopen(current, "w");
6579 if (fp == NULL((void*)0)) {
6580 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot open Lock file (caps_open)!",
6581 NULL((void*)0), NULL((void*)0), errors);
6582 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6583 return CAPS_DIRERR-333;
6584 }
6585 fclose(fp);
6586 }
6587 caps_initSignals();
6588
6589 /* check the outLevel env (mostly used for testing) */
6590 env = getenv("CAPS_OUTLEVEL");
6591 if (env != NULL((void*)0) && (env[0] == '0' ||
6592 env[0] == '1' ||
6593 env[0] == '2')) {
6594 outLevel = atoi(env);
6595 }
6596
6597 /* we are OK -- make the Problem */
6598
6599 problem = (capsProblem *) EG_alloc(sizeof(capsProblem));
6600 if (problem == NULL((void*)0)) return EGADS_MALLOC-4;
6601
6602 /* initialize all members */
6603 problem->signature = NULL((void*)0);
6604 problem->context = NULL((void*)0);
6605 problem->utsystem = NULL((void*)0);
6606 problem->root = EG_strdup(root);
6607 problem->phName = NULL((void*)0);
6608 problem->dbFlag = 0;
6609 problem->stFlag = flag;
6610 problem->jrnl = NULL((void*)0);
6611 problem->outLevel = outLevel;
6612 problem->funID = CAPS_OPEN0;
6613 problem->modl = NULL((void*)0);
6614 problem->iPhrase = -1;
6615 problem->nPhrase = 0;
6616 problem->phrases = NULL((void*)0);
6617 problem->nParam = 0;
6618 problem->params = NULL((void*)0);
6619 problem->nUser = 0;
6620 problem->users = NULL((void*)0);
6621 problem->nGeomIn = 0;
6622 problem->geomIn = NULL((void*)0);
6623 problem->nGeomOut = 0;
6624 problem->geomOut = NULL((void*)0);
6625 problem->nAnalysis = 0;
6626 problem->analysis = NULL((void*)0);
6627 problem->mBound = 0;
6628 problem->nBound = 0;
6629 problem->bounds = NULL((void*)0);
6630 problem->geometry.index = -1;
6631 problem->geometry.pname = NULL((void*)0);
6632 problem->geometry.pID = NULL((void*)0);
6633 problem->geometry.user = NULL((void*)0);
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((void*)0);
6638 problem->lunits = NULL((void*)0);
6639 problem->nEGADSmdl = 0;
6640 problem->nRegGIN = 0;
6641 problem->regGIN = NULL((void*)0);
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 < MAXANAL64; j++) {
6651 problem->aimFPTR.aimName[j] = NULL((void*)0);
6652 problem->aimFPTR.aimDLL[j] = NULL((void*)0);
6653 problem->aimFPTR.aimInit[j] = NULL((void*)0);
6654 problem->aimFPTR.aimDiscr[j] = NULL((void*)0);
6655 problem->aimFPTR.aimFreeD[j] = NULL((void*)0);
6656 problem->aimFPTR.aimLoc[j] = NULL((void*)0);
6657 problem->aimFPTR.aimInput[j] = NULL((void*)0);
6658 problem->aimFPTR.aimPAnal[j] = NULL((void*)0);
6659 problem->aimFPTR.aimPost[j] = NULL((void*)0);
6660 problem->aimFPTR.aimOutput[j] = NULL((void*)0);
6661 problem->aimFPTR.aimCalc[j] = NULL((void*)0);
6662 problem->aimFPTR.aimXfer[j] = NULL((void*)0);
6663 problem->aimFPTR.aimIntrp[j] = NULL((void*)0);
6664 problem->aimFPTR.aimIntrpBar[j] = NULL((void*)0);
6665 problem->aimFPTR.aimIntgr[j] = NULL((void*)0);
6666 problem->aimFPTR.aimIntgrBar[j] = NULL((void*)0);
6667 problem->aimFPTR.aimBdoor[j] = NULL((void*)0);
6668 problem->aimFPTR.aimClean[j] = NULL((void*)0);
6669 }
6670 if (phName != NULL((void*)0)) problem->phName = EG_strdup(phName);
6671 if (flag == oReadOnly) problem->dbFlag = 1;
6672
6673 status = caps_makeObject(&object);
6674 if (status != CAPS_SUCCESS0) {
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((void*)0)) {
6684 caps_close(object, close, NULL((void*)0));
6685 return CAPS_UNITERR-320;
6686 }
6687
6688 /* get EGADS context or open up EGADS */
6689 if (flag == oEGO) {
6690 status = EG_getContext(model, &problem->context);
6691 } else {
6692 status = EG_open(&problem->context);
6693 }
6694 if (status != EGADS_SUCCESS0) {
6695 caps_close(object, close, NULL((void*)0));
6696 return status;
6697 }
6698 if (problem->context == NULL((void*)0)) {
6699 caps_close(object, close, NULL((void*)0));
6700 return EGADS_NOTCNTX-9;
6701 }
6702
6703 /* load the CAPS state for continuations, read-only and new phase */
6704 if (flag > oEGO) {
6705 status = caps_readState(object);
6706 if (status != CAPS_SUCCESS0) {
6707 caps_close(object, close, NULL((void*)0));
6708 caps_rmDir(root);
6709 return status;
6710 }
6711
6712 /* reload the Geometry */
6713 if (object->subtype == PARAMETRIC) {
6714#ifdef WIN32
6715 snprintf(current, PATH_MAX4096, "%s\\capsRestart.cpc", root);
6716#else
6717 snprintf(current, PATH_MAX4096, "%s/capsRestart.cpc", root);
6718#endif
6719 if (problem->outLevel != 1) ocsmSetOutLevel(problem->outLevel);
6720 status = ocsmLoad(current, &problem->modl);
6721 if (status < SUCCESS0) {
6722 printf(" CAPS Error: Cannot ocsmLoad %s (caps_open)!\n", current);
6723 caps_close(object, close, NULL((void*)0));
6724 caps_rmDir(root);
6725 return status;
6726 }
6727 MODL = (modl_T *) problem->modl;
6728 if (MODL == NULL((void*)0)) {
6729 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot get OpenCSM MODL (caps_open)!",
6730 NULL((void*)0), NULL((void*)0), errors);
6731 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6732 caps_close(object, close, NULL((void*)0));
6733 caps_rmDir(root);
6734 return CAPS_NOTFOUND-303;
6735 }
6736 MODL->context = problem->context;
6737/*@-kepttrans@*/
6738 MODL->userdata = problem;
6739/*@+kepttrans@*/
6740 MODL->tessAtEnd = 0;
6741 status = ocsmRegSizeCB(problem->modl, caps_sizeCB);
6742 if (status != SUCCESS0)
6743 printf(" CAPS Warning: ocsmRegSizeCB = %d (caps_open)!", status);
6744 /* check that Branches are properly ordered */
6745 status = ocsmCheck(problem->modl);
6746 if (status < SUCCESS0) {
6747 snprintf(temp, PATH_MAX4096, "ocsmCheck = %d (caps_open)!", status);
6748 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6749 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6750 caps_close(object, close, NULL((void*)0));
6751 caps_rmDir(root);
6752 return status;
6753 }
6754 fflush(stdoutstdout);
6755 /* reset the GeomIns */
6756 if (problem->geomIn != NULL((void*)0))
6757 for (i = 0; i < problem->nGeomIn; i++) {
6758 if (problem->geomIn[i] == NULL((void*)0)) 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 != SUCCESS0) {
6765 snprintf(temp, PATH_MAX4096, "ocsmGetPmtr %d fails with %d (caps_open)!",
6766 value->pIndex, status);
6767 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6768 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6769 caps_close(object, close, NULL((void*)0));
6770 caps_rmDir(root);
6771 return status;
6772 }
6773 if ((ncol != value->ncol) || (nrow != value->nrow)) {
6774 snprintf(temp, PATH_MAX4096, "%s ncol = %d %d, nrow = %d %d (caps_open)!",
6775 name, ncol, value->ncol, nrow, value->nrow);
6776 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6777 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6778 caps_close(object, close, NULL((void*)0));
6779 caps_rmDir(root);
6780 return CAPS_MISMATCH-324;
6781 }
6782 /* flip storage
6783 for (n = j = 0; j < ncol; j++)
6784 for (k = 0; k < nrow; k++, n++) { */
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 != SUCCESS0) {
6790 snprintf(temp, PATH_MAX4096, "%d ocsmSetValuD[%d,%d] fails with %d!",
6791 value->pIndex, k+1, j+1, status);
6792 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6793 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6794 caps_close(object, close, NULL((void*)0));
6795 caps_rmDir(root);
6796 return status;
6797 }
6798 }
6799 }
6800
6801 nbody = 0;
6802 if ((flag != oPNreload) && (flag != oReadOnly)) {
6803 buildTo = 0; /* all */
6804 status = ocsmBuild(problem->modl, buildTo, &builtTo, &nbody, NULL((void*)0));
6805 fflush(stdoutstdout);
6806 if (status != SUCCESS0) {
6807 snprintf(temp, PATH_MAX4096, "ocsmBuild to %d fails with %d (caps_open)!",
6808 builtTo, status);
6809 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6810 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6811 caps_close(object, close, NULL((void*)0));
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_BODY404) 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((void*)0)) && (problem->lunits != NULL((void*)0))) {
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_BODY404) 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((void*)0)) EG_free(problem->lunits);
6839 problem->lunits = NULL((void*)0);
6840 snprintf(temp, PATH_MAX4096, "Malloc on %d Body (caps_open)!\n", nbody);
6841 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6842 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6843 caps_close(object, close, NULL((void*)0));
6844 caps_rmDir(root);
6845 return EGADS_MALLOC-4;
6846 }
6847 }
6848 status = ocsmInfo(problem->modl, &nbrch, &npmtr, &nbody);
6849 if (status != SUCCESS0) {
6850 caps_close(object, close, NULL((void*)0));
6851 caps_rmDir(root);
6852 snprintf(temp, PATH_MAX4096, "ocsmInfo returns %d (caps_open)!", status);
6853 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6854 if (*errors != NULL((void*)0)) *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 != SUCCESS0) {
6860 caps_close(object, close, NULL((void*)0));
6861 caps_rmDir(root);
6862 return status;
6863 }
6864 if (type == OCSM_OUTPMTR504) ngOut++;
6865 if (type == OCSM_DESPMTR500) ngIn++;
6866 if (type == OCSM_CFGPMTR501) ngIn++;
6867 if (type == OCSM_CONPMTR502) ngIn++;
6868 }
6869 if (ngIn != problem->nGeomIn) {
6870 snprintf(temp, PATH_MAX4096, "# Design Vars = %d -- from %s = %d (caps_open)!",
6871 ngIn, filename, problem->nGeomIn);
6872 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6873 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6874 caps_close(object, close, NULL((void*)0));
6875 caps_rmDir(root);
6876 return CAPS_MISMATCH-324;
6877 }
6878 if (ngOut != problem->nGeomOut) {
6879 snprintf(temp, PATH_MAX4096, "# Geometry Outs = %d -- from %s = %d (caps_open)!",
6880 ngOut, filename, problem->nGeomOut);
6881 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6882 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6883 caps_close(object, close, NULL((void*)0));
6884 caps_rmDir(root);
6885 return CAPS_MISMATCH-324;
6886 }
6887 /* check geomOuts */
6888 if (problem->geomOut != NULL((void*)0))
6889 for (i = j = 0; j < npmtr; j++) {
6890 ocsmGetPmtr(problem->modl, j+1, &type, &nrow, &ncol, name);
6891 if (type != OCSM_OUTPMTR504) continue;
6892 if (strcmp(name, problem->geomOut[i]->name) != 0) {
6893 snprintf(temp, PATH_MAX4096, "%d Geometry Outs %s != %s (caps_open)!",
6894 i+1, name, problem->geomOut[i]->name);
6895 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6896 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6897 caps_close(object, close, NULL((void*)0));
6898 caps_rmDir(root);
6899 return CAPS_MISMATCH-324;
6900 }
6901 i++;
6902 }
6903
6904 } else {
6905
6906 /* Problem is static */
6907 if (problem->outLevel != 1)
6908 EG_setOutLevel(problem->context, problem->outLevel);
6909#ifdef WIN32
6910 snprintf(current, PATH_MAX4096, "%s\\capsRestart.egads", root);
6911#else
6912 snprintf(current, PATH_MAX4096, "%s/capsRestart.egads", root);
6913#endif
6914 status = EG_loadModel(problem->context, 1, current, &model);
6915 if (status != EGADS_SUCCESS0) {
6916 snprintf(temp, PATH_MAX4096, "%s EG_loadModel = %d (caps_open)!",
6917 current, status);
6918 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6919 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6920 caps_close(object, close, NULL((void*)0));
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_SUCCESS0) {
6927 snprintf(temp, PATH_MAX4096, "%s EG_getTopology = %d (caps_open)!",
6928 current, status);
6929 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6930 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6931 caps_close(object, close, NULL((void*)0));
6932 return status;
6933 }
6934 nbody = problem->nBodies;
6935 /* get length units if exist */
6936 if (problem->nBodies > 0) {
6937 problem->lunits = (char **) EG_alloc(problem->nBodies*sizeof(char *));
6938 if ((problem->lunits != NULL((void*)0)) && (problem->bodies != NULL((void*)0)))
6939 for (i = 0; i < problem->nBodies; i++)
6940 caps_fillLengthUnits(problem, problem->bodies[i],
6941 &problem->lunits[i]);
6942 }
6943 }
6944
6945 /* set the bodies for the AIMs */
6946 if ((nbody > 0) && (problem->bodies != NULL((void*)0)) &&
6947 (problem->analysis != NULL((void*)0)))
6948 for (i = 0; i < problem->nAnalysis; i++) {
6949 analysis = (capsAnalysis *) problem->analysis[i]->blind;
6950 if (analysis == NULL((void*)0)) continue;
6951 status = caps_filter(problem, analysis);
6952 if (status != CAPS_SUCCESS0)
6953 printf(" CAPS Warning: %s caps_filter = %d (caps_open)!\n",
6954 problem->analysis[i]->name, status);
6955 }
6956
6957 /* get the capsDiscr structures */
6958 if ((problem->bounds != NULL((void*)0)) && (flag != oPNreload) && (flag != oReadOnly))
6959 for (i = 0; i < problem->nBound; i++) {
6960 if (problem->bounds[i] == NULL((void*)0)) continue;
6961 if (problem->bounds[i]->magicnumber != CAPSMAGIC1234321) continue;
6962 if (problem->bounds[i]->type != BOUND) continue;
6963 if (problem->bounds[i]->blind == NULL((void*)0)) continue;
6964 bound = (capsBound *) problem->bounds[i]->blind;
6965 for (j = 0; j < bound->nVertexSet; j++) {
6966 if (bound->vertexSet[j] == NULL((void*)0)) continue;
6967 if (bound->vertexSet[j]->magicnumber != CAPSMAGIC1234321) continue;
6968 if (bound->vertexSet[j]->type != VERTEXSET) continue;
6969 if (bound->vertexSet[j]->blind == NULL((void*)0)) continue;
6970 vertexset = (capsVertexSet *) bound->vertexSet[j]->blind;
6971 if (vertexset->analysis != NULL((void*)0))
6972 if (vertexset->analysis->blind != NULL((void*)0)) {
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_SUCCESS0) {
6979 aim_FreeDiscr(problem->aimFPTR, analysis->loadName,
6980 vertexset->discr);
6981 snprintf(temp, PATH_MAX4096, "Bound = %s, Analysis = %s aimDiscr = %d",
6982 problem->bounds[i]->name, analysis->loadName, status);
6983 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6984 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6985 caps_close(object, close, NULL((void*)0));
6986 return status;
6987 } else {
6988 /* check the validity of the discretization just returned */
6989 status = caps_checkDiscr(vertexset->discr, 129, line);
6990 if (status != CAPS_SUCCESS0) {
6991 snprintf(temp, PATH_MAX4096, "Bound = %s, Analysis = %s chkDiscr=%d",
6992 problem->bounds[i]->name, analysis->loadName, status);
6993 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, line, NULL((void*)0), errors);
6994 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6995 aim_FreeDiscr(problem->aimFPTR, analysis->loadName,
6996 vertexset->discr);
6997 caps_close(object, close, NULL((void*)0));
6998 return status;
6999 }
7000 }
7001 /* do the counts match? */
7002 if (vertexset->nDataSets > 0) {
7003 dataset = (capsDataSet *) vertexset->dataSets[0]->blind;
7004 if (dataset->npts != vertexset->discr->nPoints) {
7005 snprintf(temp, PATH_MAX4096, "DataSet = %s, npts = %d %d!",
7006 vertexset->dataSets[0]->name, dataset->npts,
7007 vertexset->discr->nPoints);
7008 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7009 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7010 aim_FreeDiscr(problem->aimFPTR, analysis->loadName,
7011 vertexset->discr);
7012 caps_close(object, close, NULL((void*)0));
7013 return CAPS_MISMATCH-324;
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_MAX4096, "DataSet = %s, npts = %d %d!",
7020 vertexset->dataSets[1]->name, dataset->npts,
7021 vertexset->discr->nVerts);
7022 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7023 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7024 aim_FreeDiscr(problem->aimFPTR, analysis->loadName,
7025 vertexset->discr);
7026 caps_close(object, close, NULL((void*)0));
7027 return CAPS_MISMATCH-324;
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 /* do an OpenCSM load */
7047 status = ocsmLoad((char *) filename, &problem->modl);
7048 if (status < SUCCESS0) {
7049 snprintf(temp, PATH_MAX4096, "Cannot Load %s (caps_open)!", filename);
7050 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7051 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7052 caps_close(object, close, NULL((void*)0));
7053 return status;
7054 }
7055 MODL = (modl_T *) problem->modl;
7056 } else {
7057 problem->modl = MODL;
7058 }
7059 if (MODL == NULL((void*)0)) {
7060 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot get OpenCSM MODL (caps_open)!",
7061 NULL((void*)0), NULL((void*)0), errors);
7062 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7063 caps_close(object, close, NULL((void*)0));
7064 return CAPS_NOTFOUND-303;
7065 }
7066 MODL->context = problem->context;
7067/*@-kepttrans@*/
7068 MODL->userdata = problem;
7069/*@+kepttrans@*/
7070 MODL->tessAtEnd = 0;
7071 status = ocsmRegSizeCB(problem->modl, caps_sizeCB);
7072 if (status != SUCCESS0)
7073 printf(" CAPS Warning: ocsmRegSizeCB = %d (caps_open)!\n", status);
7074
7075 env = getenv("DUMPEGADS");
7076 if (env != NULL((void*)0)) {
7077 MODL->dumpEgads = 1;
7078 MODL->loadEgads = 1;
7079 }
7080
7081 /* check that Branches are properly ordered */
7082 status = ocsmCheck(problem->modl);
7083 if (status < SUCCESS0) {
7084 snprintf(temp, PATH_MAX4096, "ocsmCheck = %d (caps_open)!", status);
7085 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7086 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7087 caps_close(object, close, NULL((void*)0));
7088 return status;
7089 }
7090 fflush(stdoutstdout);
7091
7092 status = ocsmInfo(problem->modl, &nbrch, &npmtr, &nbody);
7093 if (status != SUCCESS0) {
7094 snprintf(temp, PATH_MAX4096, "ocsmInfo returns %d (caps_open)!", status);
7095 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7096 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7097 caps_close(object, close, NULL((void*)0));
7098 return status;
7099 }
7100
7101 /* count the GeomIns and GeomOuts */
7102 for (ngIn = ngOut = i = 0; i < npmtr; i++) {
7103 status = ocsmGetPmtr(problem->modl, i+1, &type, &nrow, &ncol, name);
7104 if (status != SUCCESS0) {
7105 caps_close(object, close, NULL((void*)0));
7106 return status;
7107 }
7108 if (type == OCSM_OUTPMTR504) ngOut++;
7109 if (type == OCSM_DESPMTR500) ngIn++;
7110 if (type == OCSM_CFGPMTR501) ngIn++;
7111 if (type == OCSM_CONPMTR502) ngIn++;
7112 }
7113
7114 /* allocate the objects for the geometry inputs */
7115 if (ngIn != 0) {
7116 problem->geomIn = (capsObject **) EG_alloc(ngIn*sizeof(capsObject *));
7117 if (problem->geomIn == NULL((void*)0)) {
7118 caps_close(object, close, NULL((void*)0));
7119 return EGADS_MALLOC-4;
7120 }
7121 for (i = 0; i < ngIn; i++) problem->geomIn[i] = NULL((void*)0);
7122 value = (capsValue *) EG_alloc(ngIn*sizeof(capsValue));
7123 if (value == NULL((void*)0)) {
7124 caps_close(object, close, NULL((void*)0));
7125 return EGADS_MALLOC-4;
7126 }
7127 for (i = j = 0; j < npmtr; j++) {
7128 ocsmGetPmtr(problem->modl, j+1, &type, &nrow, &ncol, name);
7129 if ((type != OCSM_DESPMTR500) && (type != OCSM_CFGPMTR501) &&
7130 (type != OCSM_CONPMTR502)) continue;
7131 if ((nrow == 0) || (ncol == 0)) continue; /* ignore string pmtrs */
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((void*)0);
7141 value[i].meshWriter = NULL((void*)0);
7142 value[i].link = NULL((void*)0);
7143 value[i].vals.reals = NULL((void*)0);
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_CFGPMTR501) value[i].gInType = 1;
7154 if (type == OCSM_CONPMTR502) value[i].gInType = 2;
7155 value[i].partial = NULL((void*)0);
7156 value[i].nderiv = 0;
7157 value[i].derivs = NULL((void*)0);
7158
7159 status = caps_makeObject(&objs);
7160 if (status != CAPS_SUCCESS0) {
7161 EG_free(value);
7162 caps_close(object, close, NULL((void*)0));
7163 return EGADS_MALLOC-4;
7164 }
7165 if (i == 0) objs->blind = value;
7166/*@-kepttrans@*/
7167 objs->parent = object;
7168/*@+kepttrans@*/
7169 objs->name = NULL((void*)0);
7170 objs->type = VALUE;
7171 objs->subtype = GEOMETRYIN;
7172 objs->last.sNum = 1;
7173/*@-immediatetrans@*/
7174 objs->blind = &value[i];
7175/*@+immediatetrans@*/
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((void*)0)) {
7185 caps_close(object, close, NULL((void*)0));
7186 return EGADS_MALLOC-4;
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/* flip storage
7194 for (n = j = 0; j < ncol; j++)
7195 for (k = 0; k < nrow; k++, n++) { */
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 != SUCCESS0) {
7201 caps_close(object, close, NULL((void*)0));
7202 return status;
7203 }
7204 }
7205 if (type == OCSM_CFGPMTR501) continue;
7206 status = ocsmGetBnds(problem->modl, value[i].pIndex, 1, 1,
7207 &lower, &upper);
7208 if (status != SUCCESS0) continue;
7209 if ((lower != -HUGEQ99999999.0) || (upper != HUGEQ99999999.0)) {
7210 value[i].limits.dlims[0] = lower;
7211 value[i].limits.dlims[1] = upper;
7212 }
7213 }
7214 }
7215
7216 /* allocate the objects for the geometry outputs */
7217 if (ngOut != 0) {
7218 units = NULL((void*)0);
7219 if (problem->lunits != NULL((void*)0)) units = problem->lunits[problem->nBodies-1];
7220 problem->geomOut = (capsObject **) EG_alloc(ngOut*sizeof(capsObject *));
7221 if (problem->geomOut == NULL((void*)0)) {
7222 caps_close(object, close, NULL((void*)0));
7223 return EGADS_MALLOC-4;
7224 }
7225 for (i = 0; i < ngOut; i++) problem->geomOut[i] = NULL((void*)0);
7226 value = (capsValue *) EG_alloc(ngOut*sizeof(capsValue));
7227 if (value == NULL((void*)0)) {
7228 caps_close(object, close, NULL((void*)0));
7229 return EGADS_MALLOC-4;
7230 }
7231 for (i = j = 0; j < npmtr; j++) {
7232 ocsmGetPmtr(problem->modl, j+1, &type, &nrow, &ncol, name);
7233 if (type != OCSM_OUTPMTR504) 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((void*)0);
7244 value[i].meshWriter = NULL((void*)0);
7245 value[i].link = NULL((void*)0);
7246 value[i].vals.reals = NULL((void*)0);
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((void*)0);
7251 value[i].nderiv = 0;
7252 value[i].derivs = NULL((void*)0);
7253 caps_geomOutUnits(name, units, &value[i].units);
7254
7255 status = caps_makeObject(&objs);
7256 if (status != CAPS_SUCCESS0) {
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((void*)0));
7261 return EGADS_MALLOC-4;
7262 }
7263/*@-kepttrans@*/
7264 objs->parent = object;
7265/*@+kepttrans@*/
7266 objs->name = EG_strdup(name);
7267 objs->type = VALUE;
7268 objs->subtype = GEOMETRYOUT;
7269 objs->last.sNum = 0;
7270/*@-immediatetrans@*/
7271 objs->blind = &value[i];
7272/*@+immediatetrans@*/
7273 problem->geomOut[i] = objs;
7274 problem->geomOut[i]->last.sNum = problem->sNum;
7275 i++;
7276 }
7277 problem->nGeomOut = ngOut;
7278 }
7279
7280 /* write the path file */
7281#ifdef WIN32
7282 snprintf(current, PATH_MAX4096, "%s\\capsCSMFilePath", root);
7283#else
7284 snprintf(current, PATH_MAX4096, "%s/capsCSMFilePath", root);
7285#endif
7286 caps_rmFile(current);
7287 status = ocsmGetFilelist(problem->modl, &fileList);
7288 if (status != CAPS_SUCCESS0) {
7289 caps_close(object, close, NULL((void*)0));
7290 return status;
7291 }
7292 fp = fopen(current, "w");
7293 if (fp == NULL((void*)0)) {
7294 EG_free(fileList);
7295 caps_close(object, close, NULL((void*)0));
7296 return CAPS_IOERR-332;
7297 }
7298 fprintf(fp, "%s\n", fileList);
7299 fclose(fp);
7300 EG_free(fileList);
7301 fflush(stdoutstdout);
7302
7303 /* write an OpenCSM checkpoint file */
7304#ifdef WIN32
7305 snprintf(current, PATH_MAX4096, "%s\\capsRestart.cpc", root);
7306#else
7307 snprintf(current, PATH_MAX4096, "%s/capsRestart.cpc", root);
7308#endif
7309 caps_rmFile(current);
7310 status = ocsmSave(problem->modl, current);
7311 if (status != CAPS_SUCCESS0) {
7312 caps_close(object, close, NULL((void*)0));
7313 return status;
7314 }
7315 fflush(stdoutstdout);
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_SUCCESS0) {
7328 caps_close(object, close, NULL((void*)0));
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_SUCCESS0) {
7336 caps_close(object, close, NULL((void*)0));
7337 return status;
7338 }
7339 /* get length units if exist */
7340 if (problem->nBodies > 0) {
7341 problem->lunits = (char **) EG_alloc(problem->nBodies*sizeof(char *));
7342 if ((problem->lunits != NULL((void*)0)) && (problem->bodies != NULL((void*)0)))
7343 for (i = 0; i < problem->nBodies; i++)
7344 caps_fillLengthUnits(problem, problem->bodies[i],
7345 &problem->lunits[i]);
7346 }
7347
7348 /* get parameter values if saved by OpenCSM */
7349 status = EG_attributeNum(model, &nattr);
7350 if ((status == EGADS_SUCCESS0) && (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_SUCCESS0) continue;
7355 if (type != ATTRREAL2) 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 /* allocate the objects for the geometry inputs */
7362 if (ngIn != 0) {
7363 problem->geomIn = (capsObject **) EG_alloc(ngIn*sizeof(capsObject *));
7364 if (problem->geomIn == NULL((void*)0)) {
7365 caps_close(object, close, NULL((void*)0));
7366 return EGADS_MALLOC-4;
7367 }
7368 for (i = 0; i < ngIn; i++) problem->geomIn[i] = NULL((void*)0);
7369 value = (capsValue *) EG_alloc(ngIn*sizeof(capsValue));
7370 if (value == NULL((void*)0)) {
7371 caps_close(object, close, NULL((void*)0));
7372 return EGADS_MALLOC-4;
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_SUCCESS0) continue;
7378 if (type != ATTRREAL2) 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((void*)0);
7389 value[i].meshWriter = NULL((void*)0);
7390 value[i].link = NULL((void*)0);
7391 value[i].vals.reals = NULL((void*)0);
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((void*)0);
7396 value[i].nderiv = 0;
7397 value[i].derivs = NULL((void*)0);
7398 value[i].length = len;
7399 if (len > 1) value[i].dim = Vector;
7400
7401 status = caps_makeObject(&objs);
7402 if (status != CAPS_SUCCESS0) {
7403 EG_free(value);
7404 caps_close(object, close, NULL((void*)0));
7405 return EGADS_MALLOC-4;
7406 }
7407 if (i == 0) objs->blind = value;
7408 /*@-kepttrans@*/
7409 objs->parent = object;
7410 /*@+kepttrans@*/
7411 objs->name = NULL((void*)0);
7412 objs->type = VALUE;
7413 objs->subtype = GEOMETRYIN;
7414 objs->last.sNum = 1;
7415 /*@-immediatetrans@*/
7416 objs->blind = &value[i];
7417 /*@+immediatetrans@*/
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((void*)0)) {
7428 caps_close(object, close, NULL((void*)0));
7429 return EGADS_MALLOC-4;
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 /* allocate the objects for the geometry outputs */
7441 if (ngOut != 0) {
7442 problem->geomOut = (capsObject **) EG_alloc(ngOut*sizeof(capsObject *));
7443 if (problem->geomOut == NULL((void*)0)) {
7444 caps_close(object, close, NULL((void*)0));
7445 return EGADS_MALLOC-4;
7446 }
7447 for (i = 0; i < ngOut; i++) problem->geomOut[i] = NULL((void*)0);
7448 value = (capsValue *) EG_alloc(ngOut*sizeof(capsValue));
7449 if (value == NULL((void*)0)) {
7450 caps_close(object, close, NULL((void*)0));
7451 return EGADS_MALLOC-4;
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_SUCCESS0) continue;
7457 if (type != ATTRREAL2) 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((void*)0);
7467 value[i].meshWriter = NULL((void*)0);
7468 value[i].link = NULL((void*)0);
7469 value[i].vals.reals = NULL((void*)0);
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((void*)0);
7474 value[i].nderiv = 0;
7475 value[i].derivs = NULL((void*)0);
7476 value[i].length = len;
7477 if (len > 1) value[i].dim = Vector;
7478
7479 status = caps_makeObject(&objs);
7480 if (status != CAPS_SUCCESS0) {
7481 EG_free(value);
7482 caps_close(object, close, NULL((void*)0));
7483 return EGADS_MALLOC-4;
7484 }
7485 if (i == 0) objs->blind = value;
7486 /*@-kepttrans@*/
7487 objs->parent = object;
7488 /*@+kepttrans@*/
7489 objs->name = NULL((void*)0);
7490 objs->type = VALUE;
7491 objs->subtype = GEOMETRYOUT;
7492 objs->last.sNum = 1;
7493 /*@-immediatetrans@*/
7494 objs->blind = &value[i];
7495 /*@+immediatetrans@*/
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((void*)0)) {
7506 caps_close(object, close, NULL((void*)0));
7507 return EGADS_MALLOC-4;
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_MAX4096, "%s\\capsRestart.egads", root);
7520#else
7521 snprintf(current, PATH_MAX4096, "%s/capsRestart.egads", root);
7522#endif
7523 caps_rmFile(current);
7524 status = EG_saveModel(model, current);
7525 if (status != EGADS_SUCCESS0)
7526 printf(" CAPS Warning: Cannot save EGADS file = %d\n", status);
7527
7528 /* set geometry serial number */
7529 problem->geometry.sNum = 1;
7530 }
7531
7532 } else {
7533 if (flag == oFileName) {
7534 snprintf(temp, PATH_MAX4096,
7535 "Start Flag = %d filename = %s NOT initialized (caps_open)!",
7536 flag, filename);
7537 } else {
7538 snprintf(temp, PATH_MAX4096, "Start Flag = %d NOT initialized (caps_open)!",
7539 flag);
7540 }
7541 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7542 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7543 caps_close(object, close, NULL((void*)0));
7544 return CAPS_BADINIT-338;
7545 }
7546
7547 /* phase start -- use capsRestart & reset journal */
7548 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel)) {
7549#ifdef WIN32
7550 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\capsJournal.txt",
7551 problem->root);
7552#else
7553 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal.txt",
7554 problem->root);
7555#endif
7556 fp = fopen(filename, "w");
7557 if (fp == NULL((void*)0)) {
7558 snprintf(temp, PATH_MAX4096, "Cannot open %s on Phase (caps_open)",
7559 filename);
7560 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7561 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7562 caps_close(object, close, NULL((void*)0));
7563 caps_rmDir(root);
7564 return CAPS_DIRERR-333;
7565 }
7566 fprintf(fp, "%d %d\n", CAPSMAJOR1, CAPSMINOR21);
7567 env = getenv("ESP_ARCH");
7568 if (env == NULL((void*)0)) {
7569 snprintf(temp, PATH_MAX4096, "ESP_ARCH env variable is not set! (caps_open)");
7570 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7571 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7572 caps_close(object, close, NULL((void*)0));
7573 caps_rmDir(root);
7574 return CAPS_JOURNALERR-343;
7575 }
7576 fprintf(fp, "%s\n", env);
7577 env = getenv("CASREV");
7578 if (env == NULL((void*)0)) {
7579 snprintf(temp, PATH_MAX4096, "CASREV env variable is not set! (caps_open)");
7580 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7581 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7582 caps_close(object, close, NULL((void*)0));
7583 caps_rmDir(root);
7584 return CAPS_JOURNALERR-343;
7585 }
7586 fprintf(fp, "%s\n", env);
7587 fclose(fp);
7588#ifdef WIN32
7589 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\capsJournal", problem->root);
7590#else
7591 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal", problem->root);
7592#endif
7593 status = caps_rmFile(filename);
7594 if (status != CAPS_SUCCESS0)
7595 printf(" CAPS Warning: Cannot delete %s (caps_open)!\n", filename);
7596/*@-dependenttrans@*/
7597 problem->jrnl = fopen(filename, "wb");
7598/*@+dependenttrans@*/
7599 if (problem->jrnl == NULL((void*)0)) {
7600 snprintf(temp, PATH_MAX4096, "Cannot open %s on Phase (caps_open)", filename);
7601 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7602 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7603 caps_close(object, close, NULL((void*)0));
7604 caps_rmDir(root);
7605 return CAPS_DIRERR-333;
7606 }
7607 i = CAPS_OPEN0;
7608 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7609 if (nw != 1) goto owrterr;
7610 ret = problem->sNum;
7611 nw = fwrite(&ret, sizeof(CAPSLONGunsigned long), 1, problem->jrnl);
7612 if (nw != 1) goto owrterr;
7613 i = CAPS_SUCCESS0;
7614 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7615 if (nw != 1) goto owrterr;
7616
7617 ivec[0] = CAPSMAJOR1;
7618 ivec[1] = CAPSMINOR21;
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(CAPSLONGunsigned long), 1, problem->jrnl);
7624 if (nw != 1) goto owrterr;
7625 i = CAPS_OPEN0;
7626 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7627 if (nw != 1) goto owrterr;
7628 fflush(problem->jrnl);
7629
7630 /* cleanup Model files */
7631 for (i = 0; i < problem->nEGADSmdl; i++) {
7632#ifdef WIN32
7633 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\model%4.4d.egads",
7634 problem->root, i);
7635#else
7636 snprintf(filename, PATH_MAX4096, "%s/capsRestart/model%4.4d.egads",
7637 problem->root, i);
7638#endif
7639 status = caps_rmFile(filename);
7640 if (status != EGADS_SUCCESS0)
7641 printf(" CAPS Warning: Cannot remove file: %s\n", filename);
7642 }
7643 problem->nEGADSmdl = 0;
7644
7645 /* add new phase history to problem object */
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_SUCCESS0) {
7651 printf(" CAPS Error: intentPhrase = %d (caps_open)!\n", status);
7652 caps_close(object, close, NULL((void*)0));
7653 caps_rmDir(root);
7654 return status;
7655 }
7656 if (flag == oPNreload) {
7657 /* reload the CSM file */
7658 status = caps_phaseCSMreload(object, nErr, errors);
7659 if (status != CAPS_SUCCESS0) {
7660 caps_close(object, close, NULL((void*)0));
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_SUCCESS0) {
7668 printf(" CAPS Error: addHistory = %d (caps_open)!\n", status);
7669 caps_close(object, close, NULL((void*)0));
7670 caps_rmDir(root);
7671 return status;
7672 }
7673 problem->iPhrase = -1;
7674
7675 /* remove any objects marked for deletion */
7676 if (flag != oPNnoDel) {
7677 status = caps_phaseDeletion(problem);
7678 if (status != CAPS_SUCCESS0) {
7679 printf(" CAPS Error: phaseDelete = %d (caps_open)!\n", status);
7680 caps_close(object, close, NULL((void*)0));
7681 caps_rmDir(root);
7682 return status;
7683 }
7684 }
7685
7686 /* write out the problem state */
7687 status = caps_writeProblem(object);
7688 if (status != CAPS_SUCCESS0) {
7689 printf(" CAPS Error: writeProblem = %d (caps_open)!\n", status);
7690 caps_close(object, close, NULL((void*)0));
7691 caps_rmDir(root);
7692 return status;
7693 }
7694
7695 *pobject = object;
7696 return CAPS_SUCCESS0;
7697 }
7698
7699 /* read-only -- use capsRestart & no journal */
7700 if (flag == oReadOnly) {
7701
7702 *pobject = object;
7703 return CAPS_SUCCESS0;
7704 }
7705
7706 /* continuation -- use capsRestart & read from journal */
7707 if (flag == oContinue) {
7708#ifdef WIN32
7709 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\capsJournal.txt",
7710 problem->root);
7711#else
7712 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal.txt",
7713 problem->root);
7714#endif
7715 fp = fopen(filename, "r");
7716 if (fp == NULL((void*)0)) {
7717 snprintf(temp, PATH_MAX4096, "Cannot open %s on Continuation (caps_open)",
7718 filename);
7719 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7720 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7721 caps_close(object, close, NULL((void*)0));
7722 return CAPS_BADINIT-338;
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((void*)0)) && (strlen(temp) != 0)) i = 1;
7732 if ((units == NULL((void*)0)) && (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] != CAPSMAJOR1) || (ivec[1] != CAPSMINOR21) || (i == 1)) {
7738 snprintf(temp, PATH_MAX4096, "Journal from CAPS %d.%d and running %d.%d!",
7739 ivec[0], ivec[1], CAPSMAJOR1, CAPSMINOR21);
7740 snprintf(current, PATH_MAX4096, "Architecture %s vs %s\n", temp, env);
7741 snprintf(root, PATH_MAX4096, "OpenCASCADE %s vs %s\n", filename, units);
7742 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, current, root, errors);
7743 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7744 caps_close(object, close, NULL((void*)0));
7745 return CAPS_BADINIT-338;
7746 }
7747 }
7748
7749#ifdef WIN32
7750 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\capsJournal", problem->root);
7751#else
7752 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal", problem->root);
7753#endif
7754/*@-dependenttrans@*/
7755 problem->jrnl = fopen(filename, "rb");
7756/*@+dependenttrans@*/
7757 if (problem->jrnl == NULL((void*)0)) {
7758 printf(" CAPS Error: Cannot open %s for read (caps_open)!\n", filename);
7759 caps_close(object, close, NULL((void*)0));
7760 return CAPS_DIRERR-333;
7761 }
7762 nw = fread(&i, sizeof(int), 1, problem->jrnl);
7763 if (nw != 1) goto owrterr;
7764 if (i != CAPS_OPEN0) {
7765 caps_makeSimpleErr(NULL((void*)0), CERROR, "Journal Sequence Fail 0 (caps_open)!",
7766 NULL((void*)0), NULL((void*)0), errors);
7767 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7768 caps_close(object, close, NULL((void*)0));
7769 return CAPS_IOERR-332;
7770 }
7771 nw = fread(&ret, sizeof(CAPSLONGunsigned long), 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_SUCCESS0) {
7776 caps_makeSimpleErr(NULL((void*)0), CERROR, "Journal Sequence Fail 1 (caps_open)!",
7777 NULL((void*)0), NULL((void*)0), errors);
7778 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7779 caps_close(object, close, NULL((void*)0));
7780 return CAPS_IOERR-332;
7781 }
7782 nw = fread(ivec, sizeof(int), 2, problem->jrnl);
7783 if (nw != 2) goto owrterr;
7784 if ((ivec[0] != CAPSMAJOR1) || (ivec[1] != CAPSMINOR21)) {
7785 snprintf(temp, PATH_MAX4096, "Journal Sequence Fail %d %d (caps_open)!",
7786 ivec[0], ivec[1]);
7787 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7788 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7789 caps_close(object, close, NULL((void*)0));
7790 return CAPS_IOERR-332;
7791 }
7792 nw = fread(&ret, sizeof(CAPSLONGunsigned long), 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_OPEN0) {
7797 caps_makeSimpleErr(NULL((void*)0), CERROR, "Journal Sequence Fail 2 (caps_open)!",
7798 NULL((void*)0), NULL((void*)0), errors);
7799 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7800 caps_close(object, close, NULL((void*)0));
7801 return CAPS_IOERR-332;
7802 }
7803
7804 *pobject = object;
7805 return CAPS_SUCCESS0;
7806 }
7807
7808 /* start up */
7809 problem->writer.sNum = problem->sNum;
7810 caps_fillDateTime(problem->writer.datetime);
7811
7812 /* setup preliminary restart data */
7813#ifdef WIN32
7814 snprintf(current, PATH_MAX4096, "%s\\capsRestart", root);
7815#else
7816 snprintf(current, PATH_MAX4096, "%s/capsRestart", root);
7817#endif
7818 status = caps_statFile(current);
7819 if (status == EGADS_SUCCESS0) {
7820 snprintf(temp, PATH_MAX4096, "%s is a flat file (caps_open)", current);
7821 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7822 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7823 caps_close(object, close, NULL((void*)0));
7824 return CAPS_DIRERR-333;
7825 } else if (status == EGADS_NOTFOUND-1) {
7826 status = caps_mkDir(current);
7827 if (status != EGADS_SUCCESS0) {
7828 snprintf(temp, PATH_MAX4096, "Cannot mkDir %s (caps_open)", current);
7829 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7830 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7831 caps_close(object, close, NULL((void*)0));
7832 return status;
7833 }
7834 /* populate the geometry info */
7835#ifdef WIN32
7836 snprintf(filename, PATH_MAX4096, "%s\\geom.txt", current);
7837 snprintf(temp, PATH_MAX4096, "%s\\xxTempxx", current);
7838#else
7839 snprintf(filename, PATH_MAX4096, "%s/geom.txt", current);
7840 snprintf(temp, PATH_MAX4096, "%s/xxTempxx", current);
7841#endif
7842 fp = fopen(temp, "w");
7843 if (fp == NULL((void*)0)) {
7844 snprintf(temp, PATH_MAX4096, "Cannot open %s (caps_open)\n", filename);
7845 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7846 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7847 caps_close(object, close, NULL((void*)0));
7848 return CAPS_DIRERR-333;
7849 }
7850 fprintf(fp, "%d %d\n", problem->nGeomIn, problem->nGeomOut);
7851 if (problem->geomIn != NULL((void*)0))
7852 for (i = 0; i < problem->nGeomIn; i++)
7853 fprintf(fp, "%s\n", problem->geomIn[i]->name);
7854 if (problem->geomOut != NULL((void*)0))
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_SUCCESS0) {
7860 snprintf(temp, PATH_MAX4096, "Cannot rename %s (caps_open)!\n", filename);
7861 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7862 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7863 caps_close(object, close, NULL((void*)0));
7864 return status;
7865 }
7866 status = caps_dumpGeomVals(problem, 0);
7867 if (status != CAPS_SUCCESS0) {
7868 caps_close(object, close, NULL((void*)0));
7869 return CAPS_DIRERR-333;
7870 }
7871 }
7872 status = caps_writeProblem(object);
7873 if (status != CAPS_SUCCESS0) {
7874 caps_close(object, close, NULL((void*)0));
7875 return status;
7876 }
7877
7878 /* open journal file */
7879#ifdef WIN32
7880 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\capsJournal.txt",
7881 problem->root);
7882#else
7883 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal.txt",
7884 problem->root);
7885#endif
7886 fp = fopen(filename, "w");
7887 if (fp == NULL((void*)0)) {
7888 snprintf(temp, PATH_MAX4096, "Cannot open %s on Phase (caps_open)", filename);
7889 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7890 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7891 caps_close(object, close, NULL((void*)0));
7892 return CAPS_DIRERR-333;
7893 }
7894 fprintf(fp, "%d %d\n", CAPSMAJOR1, CAPSMINOR21);
7895 env = getenv("ESP_ARCH");
7896 if (env == NULL((void*)0)) {
7897 snprintf(temp, PATH_MAX4096, "ESP_ARCH env variable is not set! (caps_open)");
7898 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7899 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7900 caps_close(object, close, NULL((void*)0));
7901 return CAPS_JOURNALERR-343;
7902 }
7903 fprintf(fp, "%s\n", env);
7904 env = getenv("CASREV");
7905 if (env == NULL((void*)0)) {
7906 snprintf(temp, PATH_MAX4096, "CASREV env variable is not set! (caps_open)");
7907 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7908 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7909 caps_close(object, close, NULL((void*)0));
7910 return CAPS_JOURNALERR-343;
7911 }
7912 fprintf(fp, "%s\n", env);
7913 fclose(fp);
7914#ifdef WIN32
7915 snprintf(filename, PATH_MAX4096, "%s\\capsJournal", current);
7916#else
7917 snprintf(filename, PATH_MAX4096, "%s/capsJournal", current);
7918#endif
7919/*@-dependenttrans@*/
7920 problem->jrnl = fopen(filename, "wb");
7921/*@+dependenttrans@*/
7922 if (problem->jrnl == NULL((void*)0)) {
7923 snprintf(temp, PATH_MAX4096, "Cannot open %s (caps_open)", filename);
7924 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7925 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7926 caps_close(object, close, NULL((void*)0));
7927 return CAPS_DIRERR-333;
7928 }
7929 i = CAPS_OPEN0;
7930 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7931 if (nw != 1) goto owrterr;
7932 ret = 0;
7933 nw = fwrite(&ret, sizeof(CAPSLONGunsigned long), 1, problem->jrnl);
7934 if (nw != 1) goto owrterr;
7935 i = CAPS_SUCCESS0;
7936 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7937 if (nw != 1) goto owrterr;
7938
7939 ivec[0] = CAPSMAJOR1;
7940 ivec[1] = CAPSMINOR21;
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(CAPSLONGunsigned long), 1, problem->jrnl);
7946 if (nw != 1) goto owrterr;
7947 i = CAPS_OPEN0;
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_SUCCESS0;
7954
7955owrterr:
7956 fclose(problem->jrnl);
7957 printf(" CAPS Error: IO error on journal file (caps_open)!\n");
7958 caps_makeSimpleErr(NULL((void*)0), CERROR, "IO error on journal file (caps_open)!",
7959 NULL((void*)0), NULL((void*)0), errors);
7960 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7961 caps_close(object, close, NULL((void*)0));
7962 return CAPS_IOERR-332;
7963}
7964
7965
7966int
7967caps_outLevel(capsObject *pobject, int outLevel)
7968{
7969 int old;
7970 capsProblem *problem;
7971
7972 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
7973 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
7974 if (pobject->type != PROBLEM) return CAPS_BADTYPE-306;
7975 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
7976 if ((outLevel < 0) || (outLevel > 2)) return CAPS_RANGEERR-326;
7977 problem = (capsProblem *) pobject->blind;
7978 problem->funID = CAPS_OUTLEVEL22;
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
7992int
7993caps_getRootPath(capsObject *pobject, const char **root)
7994{
7995 capsProblem *problem;
7996
7997 *root = NULL((void*)0);
7998 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
7999 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
8000 if (pobject->type != PROBLEM) return CAPS_BADTYPE-306;
8001 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
8002 problem = (capsProblem *) pobject->blind;
8003 problem->funID = CAPS_GETROOTPATH26;
8004
8005 *root = problem->root;
8006
8007 return CAPS_SUCCESS0;
8008}
8009
8010
8011int
8012caps_intentPhrase(capsObject *pobject, int nLines, /*@null@*/const char **lines)
8013{
8014 int i, stat, ret, index = -1;
8015 capsProblem *problem;
8016 capsPhrase *tmp;
8017 CAPSLONGunsigned long sNum;
8018 capsJrnl args[1]; /* not really used */
8019
8020 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
8021 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
8022 if (pobject->type != PROBLEM) return CAPS_BADTYPE-306;
8023 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
8024 problem = (capsProblem *) pobject->blind;
8025
8026 args[0].type = jString;
8027 stat = caps_jrnlRead(CAPS_INTENTPHRASE27, problem, pobject, 0, args,
8028 &sNum, &ret);
8029 if (stat == CAPS_JOURNALERR-343) return stat;
8030 if (stat == CAPS_JOURNAL-342) return ret;
8031
8032 ret = CAPS_SUCCESS0;
8033 sNum = problem->sNum;
8034 if ((nLines > 0) && (lines != NULL((void*)0))) {
8035 if (problem->phrases == NULL((void*)0)) {
8036 problem->phrases = (capsPhrase *) EG_alloc(sizeof(capsPhrase));
8037 problem->nPhrase = 0;
8038 if (problem->phrases == NULL((void*)0)) ret = EGADS_MALLOC-4;
8039 } else {
8040 tmp = (capsPhrase *) EG_reall( problem->phrases,
8041 (problem->nPhrase+1)*sizeof(capsPhrase));
8042 if (tmp == NULL((void*)0)) {
8043 ret = EGADS_MALLOC-4;
8044 } else {
8045 problem->phrases = tmp;
8046 }
8047 }
8048 if ((ret == CAPS_SUCCESS0) && (problem->phrases != NULL((void*)0))) {
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((void*)0)) {
8054 EG_free(problem->phrases[problem->nPhrase].phase);
8055 ret = EGADS_MALLOC-4;
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_SUCCESS0) {
8063 index = problem->nPhrase;
8064 problem->nPhrase += 1;
8065 }
8066 }
8067 problem->iPhrase = index;
8068
8069 if (ret == CAPS_SUCCESS0) {
8070 problem->sNum += 1;
8071 stat = caps_writeProblem(pobject);
8072 if (stat != CAPS_SUCCESS0)
8073 printf(" CAPS Warning: caps_writeProblem = %d (caps_intentPhrase)\n",
8074 stat);
8075 }
8076
8077 caps_jrnlWrite(CAPS_INTENTPHRASE27, problem, pobject, ret, 0, args, sNum,
8078 problem->sNum);
8079
8080 return ret;
8081}
8082
8083
8084int
8085caps_debug(capsObject *pobject)
8086{
8087 capsProblem *problem;
8088
8089 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
8090 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
8091 if (pobject->type != PROBLEM) return CAPS_BADTYPE-306;
8092 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
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}