Bug Summary

File:capsProblem.c
Warning:line 5365, column 22
Access to field 'attrs' results in a dereference of a null pointer (loaded from variable 'destin')

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-100348-88608-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 destin->attrs = source->attrs;
55
Access to field 'attrs' results in a dereference of a null pointer (loaded from variable 'destin')
5366 source->attrs = NULL((void*)0);
5367 destin->nHistory = source->nHistory;
5368 destin->history = source->history;
5369 source->nHistory = 0;
5370 source->history = NULL((void*)0);
5371 destin->last = source->last;
5372 source->last.pname = NULL((void*)0);
5373 source->last.pID = NULL((void*)0);
5374 source->last.user = NULL((void*)0);
5375}
5376
5377
5378static int
5379caps_phaseCSMreload(capsObject *object, int *nErr, capsErrs **errors)
5380{
5381 int i, j, jj, k, n, status, nbrch, npmtr, nbody, ngOut, ngIn;
5382 int nrow, ncol, type, npts, state;
5383 char filename[PATH_MAX4096], current[PATH_MAX4096], temp[PATH_MAX4096], *env;
5384 char name[MAX_NAME_LEN64], *units, *fileList;
5385 double dot, lower, upper, *reals;
5386 void *modl;
5387 ego body;
5388 capsObject *objs, *link, **geomIn = NULL((void*)0), **geomOut = NULL((void*)0);
5389 capsValue *value, *val;
5390 capsProblem *problem;
5391 capsAnalysis *analysis;
5392 modl_T *MODL = NULL((void*)0);
5393 FILE *fp;
5394
5395 problem = (capsProblem *) object->blind;
5396 problem->iPhrase = -1;
5397
5398 /* get the original CSM file */
5399#ifdef WIN32
5400 snprintf(filename, PATH_MAX4096, "%s\\capsCSMFilePath", problem->root);
5401#else
5402 snprintf(filename, PATH_MAX4096, "%s/capsCSMFilePath", problem->root);
5403#endif
5404 fp = fopen(filename, "r");
5405 if (fp == NULL((void*)0)) {
1
Assuming 'fp' is not equal to NULL
2
Taking false branch
5406 snprintf(temp, PATH_MAX4096, "Cannot open %s (caps_open)\n", filename);
5407 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5408 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5409 return CAPS_IOERR-332;
5410 }
5411 for (i = 0; i < PATH_MAX4096; i++) {
3
Loop condition is true. Entering loop body
5412 fscanf(fp, "%c", &current[i]);
5413 if (current[i] == '|') break;
4
Assuming the condition is true
5
Taking true branch
6
Execution continues on line 5415
5414 }
5415 fclose(fp);
5416 if (i
6.1
'i' is not equal to PATH_MAX
== PATH_MAX4096) return CAPS_DIRERR-333;
7
Taking false branch
5417 current[i] = 0;
5418
5419 /* do an OpenCSM load */
5420 status = ocsmLoad((char *) current, &modl);
5421 if (status < SUCCESS0) {
8
Assuming 'status' is >= SUCCESS
9
Taking false branch
5422 snprintf(temp, PATH_MAX4096, "Cannot Load %s (caps_open)!", current);
5423 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5424 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5425 return status;
5426 }
5427 MODL = (modl_T *) modl;
5428 if (MODL == NULL((void*)0)) {
10
Assuming 'MODL' is not equal to NULL
11
Taking false branch
5429 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot get OpenCSM MODL (caps_open)!",
5430 NULL((void*)0), NULL((void*)0), errors);
5431 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5432 return CAPS_NOTFOUND-303;
5433 }
5434 MODL->context = problem->context;
5435/*@-kepttrans@*/
5436 MODL->userdata = problem;
5437/*@+kepttrans@*/
5438 MODL->tessAtEnd = 0;
5439 status = ocsmRegSizeCB(problem->modl, caps_sizeCB);
5440 if (status != SUCCESS0)
12
Assuming 'status' is equal to SUCCESS
13
Taking false branch
5441 printf(" CAPS Warning: ocsmRegSizeCB = %d (caps_open)!", status);
5442 env = getenv("DUMPEGADS");
5443 if (env != NULL((void*)0)) {
14
Assuming 'env' is equal to NULL
15
Taking false branch
5444 MODL->dumpEgads = 1;
5445 MODL->loadEgads = 1;
5446 }
5447
5448 /* check that Branches are properly ordered */
5449 status = ocsmCheck(modl);
5450 if (status < SUCCESS0) {
16
Assuming 'status' is >= SUCCESS
17
Taking false branch
5451 snprintf(temp, PATH_MAX4096, "ocsmCheck = %d (caps_open)!", status);
5452 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5453 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5454 ocsmFree(modl);
5455 return status;
5456 }
5457 fflush(stdoutstdout);
5458
5459 /* get geometry counts */
5460 status = ocsmInfo(modl, &nbrch, &npmtr, &nbody);
5461 if (status != SUCCESS0) {
18
Assuming 'status' is equal to SUCCESS
19
Taking false branch
5462 snprintf(temp, PATH_MAX4096, "ocsmInfo returns %d (caps_open)!", status);
5463 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5464 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5465 ocsmFree(modl);
5466 return status;
5467 }
5468
5469 /* count the GeomIns and GeomOuts */
5470 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 5483
5471 status = ocsmGetPmtr(modl, i+1, &type, &nrow, &ncol, name);
5472 if (status != SUCCESS0) {
22
Assuming 'status' is equal to SUCCESS
23
Taking false branch
5473 ocsmFree(modl);
5474 return status;
5475 }
5476 if (type == OCSM_OUTPMTR504) ngOut++;
24
Assuming 'type' is not equal to OCSM_OUTPMTR
25
Taking false branch
5477 if (type == OCSM_DESPMTR500) ngIn++;
26
Assuming 'type' is equal to OCSM_DESPMTR
27
Taking true branch
5478 if (type
27.1
'type' is not equal to OCSM_CFGPMTR
== OCSM_CFGPMTR501) ngIn++;
28
Taking false branch
5479 if (type
28.1
'type' is not equal to OCSM_CONPMTR
== OCSM_CONPMTR502) ngIn++;
29
Taking false branch
5480 }
5481
5482 /* allocate the objects for the geometry inputs */
5483 if (ngIn
31.1
'ngIn' is not equal to 0
!= 0) {
32
Taking true branch
5484 geomIn = (capsObject **) EG_alloc(ngIn*sizeof(capsObject *));
5485 if (geomIn == NULL((void*)0)) {
33
Assuming 'geomIn' is not equal to NULL
34
Taking false branch
5486 return EGADS_MALLOC-4;
5487 }
5488 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 5489
5489 value = (capsValue *) EG_alloc(ngIn*sizeof(capsValue));
5490 if (value == NULL((void*)0)) {
37
Assuming 'value' is not equal to NULL
38
Taking false branch
5491 EG_free(geomIn);
5492 return EGADS_MALLOC-4;
5493 }
5494 for (i = j = 0; j < npmtr; j++) {
39
Loop condition is true. Entering loop body
43
Loop condition is false. Execution continues on line 5546
5495 ocsmGetPmtr(modl, j+1, &type, &nrow, &ncol, name);
5496 if ((type != OCSM_DESPMTR500) && (type != OCSM_CFGPMTR501) &&
40
Assuming 'type' is equal to OCSM_DESPMTR
5497 (type != OCSM_CONPMTR502)) continue;
5498 if ((nrow == 0) || (ncol == 0)) continue; /* ignore string pmtrs */
41
Assuming 'nrow' is equal to 0
42
Execution continues on line 5494
5499 value[i].nrow = nrow;
5500 value[i].ncol = ncol;
5501 value[i].type = Double;
5502 value[i].dim = Scalar;
5503 value[i].index = i+1;
5504 value[i].pIndex = j+1;
5505 value[i].lfixed = value[i].sfixed = Fixed;
5506 value[i].nullVal = NotAllowed;
5507 value[i].units = NULL((void*)0);
5508 value[i].meshWriter = NULL((void*)0);
5509 value[i].link = NULL((void*)0);
5510 value[i].vals.reals = NULL((void*)0);
5511 value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0;
5512 value[i].linkMethod = Copy;
5513 value[i].length = value[i].nrow*value[i].ncol;
5514 if ((ncol > 1) && (nrow > 1)) {
5515 value[i].dim = Array2D;
5516 } else if ((ncol > 1) || (nrow > 1)) {
5517 value[i].dim = Vector;
5518 }
5519 value[i].gInType = 0;
5520 if (type == OCSM_CFGPMTR501) value[i].gInType = 1;
5521 if (type == OCSM_CONPMTR502) value[i].gInType = 2;
5522 value[i].partial = NULL((void*)0);
5523 value[i].nderiv = 0;
5524 value[i].derivs = NULL((void*)0);
5525
5526 status = caps_makeObject(&objs);
5527 if (status != CAPS_SUCCESS0) {
5528 EG_free(geomIn);
5529 EG_free(value);
5530 return EGADS_MALLOC-4;
5531 }
5532 if (i == 0) objs->blind = value;
5533/*@-kepttrans@*/
5534 objs->parent = object;
5535/*@+kepttrans@*/
5536 objs->name = NULL((void*)0);
5537 objs->type = VALUE;
5538 objs->subtype = GEOMETRYIN;
5539 objs->last.sNum = problem->sNum + 1;
5540/*@-immediatetrans@*/
5541 objs->blind = &value[i];
5542/*@+immediatetrans@*/
5543 geomIn[i] = objs;
5544 i++;
5545 }
5546 for (i = 0; i < ngIn; i++) {
44
Loop condition is true. Entering loop body
5547 ocsmGetPmtr(modl, value[i].pIndex, &type, &nrow, &ncol, name);
5548 caps_findLinkVal(problem->nGeomIn, problem->geomIn, i, name, &n);
5549 if (n == -1) {
45
Taking false branch
5550 /* new variable! */
5551 if (nrow*ncol > 1) {
5552 reals = (double *) EG_alloc(nrow*ncol*sizeof(double));
5553 if (reals == NULL((void*)0)) {
5554 for (j = 0; j < i; j++) {
5555 if (value[j].length != 1) EG_free(value[j].vals.reals);
5556 EG_free(geomIn[j]->name);
5557 }
5558 EG_free(geomIn);
5559/*@-kepttrans@*/
5560 EG_free(value);
5561/*@+kepttrans@*/
5562 return EGADS_MALLOC-4;
5563 }
5564 value[i].vals.reals = reals;
5565 } else {
5566 reals = &value[i].vals.real;
5567 }
5568 if (geomIn[i] != NULL((void*)0)) geomIn[i]->name = EG_strdup(name);
5569/* flip storage
5570 for (n = j = 0; j < ncol; j++)
5571 for (k = 0; k < nrow; k++, n++) { */
5572 for (n = k = 0; k < nrow; k++)
5573 for (j = 0; j < ncol; j++, n++) {
5574 status = ocsmGetValu(modl, value[i].pIndex, k+1, j+1, &reals[n],
5575 &dot);
5576 if (status != SUCCESS0) {
5577 for (jj = 0; jj <= i; jj++) {
5578 if (value[jj].length != 1) EG_free(value[jj].vals.reals);
5579 if (geomIn[jj] != NULL((void*)0)) EG_free(geomIn[jj]->name);
5580 }
5581 EG_free(geomIn);
5582/*@-kepttrans@*/
5583 EG_free(value);
5584/*@+kepttrans@*/
5585 return status;
5586 }
5587 }
5588 if (type == OCSM_CFGPMTR501) continue;
5589 status = ocsmGetBnds(modl, value[i].pIndex, 1, 1, &lower, &upper);
5590 if (status != SUCCESS0) continue;
5591 if ((lower != -HUGEQ99999999.0) || (upper != HUGEQ99999999.0)) {
5592 value[i].limits.dlims[0] = lower;
5593 value[i].limits.dlims[1] = upper;
5594 }
5595 } else {
5596 /* found the variable -- update the value */
5597 val = (capsValue *) problem->geomIn[n]->blind;
5598 if (geomIn[i] != NULL((void*)0)) geomIn[i]->name = EG_strdup(name);
46
Taking false branch
5599 val->pIndex = 0; /* mark as found */
5600 value[i].nrow = val->nrow;
5601 value[i].ncol = val->ncol;
5602 value[i].length = value[i].nrow*value[i].ncol;
5603 if (value[i].length > 1) {
47
Assuming field 'length' is <= 1
48
Taking false branch
5604 value[i].vals.reals = val->vals.reals;
5605 val->vals.reals = NULL((void*)0);
5606 reals = value[i].vals.reals;
5607 } else {
5608 value[i].vals.real = val->vals.real;
5609 reals = &value[i].vals.real;
5610 }
5611 /* flip storage
5612 for (n = j = 0; j < value[i].ncol; j++)
5613 for (k = 0; k < value[i].nrow; k++, n++) { */
5614 for (n = k = 0; k < value[i].nrow; k++)
49
Assuming 'k' is >= field 'nrow'
50
Loop condition is false. Execution continues on line 5633
5615 for (j = 0; j < value[i].ncol; j++, n++) {
5616 status = ocsmSetValuD(modl, value[i].pIndex, k+1, j+1, reals[n]);
5617 if (status != SUCCESS0) {
5618 snprintf(temp, PATH_MAX4096, "%d ocsmSetValuD[%d,%d] fails with %d!",
5619 value->pIndex, k+1, j+1, status);
5620 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5621 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5622 for (jj = 0; jj <= i; jj++) {
5623 if (value[jj].length != 1) EG_free(value[jj].vals.reals);
5624 if (geomIn[jj] != NULL((void*)0)) EG_free(geomIn[jj]->name);
5625 }
5626 EG_free(geomIn);
5627/*@-kepttrans@*/
5628 EG_free(value);
5629/*@+kepttrans@*/
5630 return status;
5631 }
5632 }
5633 if (value[i].gInType != val->gInType)
51
Assuming 'value[i].gInType' is equal to 'val->gInType'
52
Taking false branch
5634 printf(" CAPS Info: %s Change of GeometryIn type from %d to %d\n",
5635 name, val->gInType, value[i].gInType);
5636 }
5637 /* update the new object */
5638 caps_transferObjInfo(problem->geomIn[n], geomIn[i]);
53
Passing null pointer value via 2nd parameter 'destin'
54
Calling 'caps_transferObjInfo'
5639 }
5640 }
5641
5642 /* notify any broken links */
5643 for (i = 0; i < problem->nGeomIn; i++) {
5644 val = (capsValue *) problem->geomIn[i]->blind;
5645 if (val->pIndex == 0) continue;
5646 if (val->link == NULL((void*)0)) continue;
5647 if (CAPScallBack == NULL((void*)0)) {
5648 caps_brokenLinkCB(object, val->link, val->linkMethod,
5649 problem->geomIn[i]->name, GEOMETRYIN);
5650 } else {
5651 CAPScallBack(object, val->link, val->linkMethod,
5652 problem->geomIn[i]->name, GEOMETRYIN);
5653 }
5654 }
5655
5656 /* cleanup old geomIns */
5657 caps_freeValueObjects(0, problem->nGeomIn, problem->geomIn);
5658 problem->nGeomIn = ngIn;
5659 problem->geomIn = geomIn;
5660
5661 /* allocate the objects for the geometry outputs */
5662 if (ngOut != 0) {
5663 units = NULL((void*)0);
5664 if (problem->lunits != NULL((void*)0)) units = problem->lunits[problem->nBodies-1];
5665 geomOut = (capsObject **) EG_alloc(ngOut*sizeof(capsObject *));
5666 if (geomOut == NULL((void*)0)) {
5667 return EGADS_MALLOC-4;
5668 }
5669 for (i = 0; i < ngOut; i++) geomOut[i] = NULL((void*)0);
5670 value = (capsValue *) EG_alloc(ngOut*sizeof(capsValue));
5671 if (value == NULL((void*)0)) {
5672 EG_free(geomOut);
5673 return EGADS_MALLOC-4;
5674 }
5675 for (i = j = 0; j < npmtr; j++) {
5676 ocsmGetPmtr(modl, j+1, &type, &nrow, &ncol, name);
5677 if (type != OCSM_OUTPMTR504) continue;
5678 caps_findLinkVal(problem->nGeomOut, problem->geomOut, i, name, &n);
5679 value[i].length = 1;
5680 value[i].type = DoubleDeriv;
5681 value[i].nrow = 1;
5682 value[i].ncol = 1;
5683 value[i].dim = Scalar;
5684 value[i].index = i+1;
5685 value[i].pIndex = j+1;
5686 value[i].lfixed = value[i].sfixed = Change;
5687 value[i].nullVal = IsNull;
5688 value[i].units = NULL((void*)0);
5689 value[i].meshWriter = NULL((void*)0);
5690 value[i].link = NULL((void*)0);
5691 value[i].vals.reals = NULL((void*)0);
5692 value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0;
5693 value[i].linkMethod = Copy;
5694 value[i].gInType = 0;
5695 value[i].partial = NULL((void*)0);
5696 value[i].nderiv = 0;
5697 value[i].derivs = NULL((void*)0);
5698 caps_geomOutUnits(name, units, &value[i].units);
5699
5700 status = caps_makeObject(&objs);
5701 if (status != CAPS_SUCCESS0) {
5702 for (k = 0; k < i; k++)
5703 if (value[k].length > 1) EG_free(value[k].vals.reals);
5704 EG_free(geomOut);
5705 EG_free(value);
5706 return EGADS_MALLOC-4;
5707 }
5708/*@-kepttrans@*/
5709 objs->parent = object;
5710/*@+kepttrans@*/
5711 objs->name = EG_strdup(name);
5712 objs->type = VALUE;
5713 objs->subtype = GEOMETRYOUT;
5714 objs->last.sNum = 0;
5715/*@-immediatetrans@*/
5716 objs->blind = &value[i];
5717/*@+immediatetrans@*/
5718 geomOut[i] = objs;
5719 geomOut[i]->last.sNum = problem->sNum;
5720
5721 /* update the new object from the old */
5722 if (n != -1) caps_transferObjInfo(problem->geomOut[n], geomOut[i]);
5723 i++;
5724 }
5725
5726 /* search for links in the Value Objects */
5727 for (i = 0; i < problem->nAnalysis; i++) {
5728 analysis = (capsAnalysis *) problem->analysis[i]->blind;
5729 if (analysis == NULL((void*)0)) continue;
5730 for (j = 0; j < analysis->nAnalysisIn; j++) {
5731 val = (capsValue *) analysis->analysisIn[j]->blind;
5732 if (val->link == NULL((void*)0)) continue;
5733 if (val->link->subtype != GEOMETRYOUT) continue;
5734 caps_findLinkVal(ngOut, geomOut, ngOut, val->link->name, &n);
5735 if (n == -1) {
5736 link = val->link;
5737 val->link = NULL((void*)0);
5738 if (CAPScallBack == NULL((void*)0)) {
5739 caps_brokenLinkCB(object, link, val->linkMethod, link->name,
5740 GEOMETRYOUT);
5741 } else {
5742 CAPScallBack(object, link, val->linkMethod, link->name,
5743 GEOMETRYOUT);
5744 }
5745 } else {
5746 val->link = geomOut[n];
5747 }
5748 }
5749 }
5750 }
5751
5752 /* cleanup old geomOuts */
5753 caps_freeValueObjects(0, problem->nGeomOut, problem->geomOut);
5754 problem->nGeomOut = ngOut;
5755 problem->geomOut = geomOut;
5756
5757 /* write the path file */
5758#ifdef WIN32
5759 snprintf(current, PATH_MAX4096, "%s\\capsCSMFilePath", problem->root);
5760#else
5761 snprintf(current, PATH_MAX4096, "%s/capsCSMFilePath", problem->root);
5762#endif
5763 caps_rmFile(current);
5764 status = ocsmGetFilelist(modl, &fileList);
5765 if (status != CAPS_SUCCESS0) {
5766 return status;
5767 }
5768 fp = fopen(current, "w");
5769 if (fp == NULL((void*)0)) {
5770 EG_free(fileList);
5771 return CAPS_IOERR-332;
5772 }
5773 fprintf(fp, "%s\n", fileList);
5774 fclose(fp);
5775 EG_free(fileList);
5776 fflush(stdoutstdout);
5777
5778 /* write an OpenCSM checkpoint file */
5779#ifdef WIN32
5780 snprintf(current, PATH_MAX4096, "%s\\capsRestart.cpc", problem->root);
5781#else
5782 snprintf(current, PATH_MAX4096, "%s/capsRestart.cpc", problem->root);
5783#endif
5784 caps_rmFile(current);
5785 status = ocsmSave(modl, current);
5786 if (status != CAPS_SUCCESS0) {
5787 return status;
5788 }
5789 fflush(stdoutstdout);
5790
5791 /* rebuild the dirty geometry */
5792 if (problem->bodies != NULL((void*)0)) {
5793 if (problem->lunits != NULL((void*)0))
5794 for (i = 0; i < problem->nBodies; i++)
5795 if (problem->lunits[i] != NULL((void*)0)) EG_free(problem->lunits[i]);
5796 /* remove old bodies & tessellations for all Analyses */
5797 for (i = 0; i < problem->nAnalysis; i++) {
5798 analysis = (capsAnalysis *) problem->analysis[i]->blind;
5799 if (analysis == NULL((void*)0)) continue;
5800 if (analysis->tess != NULL((void*)0)) {
5801 for (j = 0; j < analysis->nTess; j++)
5802 if (analysis->tess[j] != NULL((void*)0)) {
5803 /* delete the body in the tessellation if not on the OpenCSM stack */
5804 body = NULL((void*)0);
5805 if (j >= analysis->nBody) {
5806 status = EG_statusTessBody(analysis->tess[j], &body, &state,
5807 &npts);
5808 if (status != CAPS_SUCCESS0)
5809 printf(" CAPS Warning: statusTessBody = %d (caps_phaseCSMreload)\n",
5810 status);
5811 }
5812 EG_deleteObject(analysis->tess[j]);
5813 if (body != NULL((void*)0)) EG_deleteObject(body);
5814 analysis->tess[j] = NULL((void*)0);
5815 }
5816 EG_free(analysis->tess);
5817 analysis->tess = NULL((void*)0);
5818 analysis->nTess = 0;
5819 }
5820 if (analysis->bodies != NULL((void*)0)) {
5821 EG_free(analysis->bodies);
5822 analysis->bodies = NULL((void*)0);
5823 analysis->nBody = 0;
5824 }
5825 /* remove tracked sensitivity calculations */
5826 analysis->info.pIndex = 0;
5827 analysis->info.irow = 0;
5828 analysis->info.icol = 0;
5829 }
5830 EG_free(problem->bodies);
5831 EG_free(problem->lunits);
5832 problem->bodies = NULL((void*)0);
5833 problem->lunits = NULL((void*)0);
5834 }
5835 problem->nBodies = 0;
5836 ocsmFree(problem->modl);
5837 problem->modl = modl;
5838 problem->sNum = problem->sNum + 1;
5839
5840 /* remove any Geometry Value Objects */
5841#ifdef WIN32
5842 caps_rmWild(problem->root, "capsRestart\\VI-*");
5843 caps_rmWild(problem->root, "capsRestart\\VO-*");
5844#else
5845 caps_rmWild(problem->root, "capsRestart/VI-*");
5846 caps_rmWild(problem->root, "capsRestart/VO-*");
5847#endif
5848
5849 /* force a rebuild */
5850 problem->geometry.sNum = 0;
5851 jj = caps_build(object, nErr, errors);
5852 if (jj == CAPS_SUCCESS0) {
5853 /* populate the geometry info */
5854#ifdef WIN32
5855 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\geom.txt", problem->root);
5856 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\xxTempxx", problem->root);
5857#else
5858 snprintf(filename, PATH_MAX4096, "%s/capsRestart/geom.txt", problem->root);
5859 snprintf(temp, PATH_MAX4096, "%s/capsRestart/xxTempxx", problem->root);
5860#endif
5861 fp = fopen(temp, "w");
5862 if (fp == NULL((void*)0)) {
5863 snprintf(temp, PATH_MAX4096, "Cannot open %s (caps_phaseCSMreload)\n",
5864 filename);
5865 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5866 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5867 return CAPS_DIRERR-333;
5868 }
5869 fprintf(fp, "%d %d\n", problem->nGeomIn, problem->nGeomOut);
5870 if (problem->geomIn != NULL((void*)0))
5871 for (i = 0; i < problem->nGeomIn; i++)
5872 if (problem->geomIn[i] == NULL((void*)0)) {
5873 fprintf(fp, "geomIn%d\n", i);
5874 } else {
5875 fprintf(fp, "%s\n", problem->geomIn[i]->name);
5876 }
5877 if (problem->geomOut != NULL((void*)0))
5878 for (i = 0; i < problem->nGeomOut; i++)
5879 if (problem->geomOut[i] == NULL((void*)0)) {
5880 fprintf(fp, "geomOut%d\n", i);
5881 } else {
5882 fprintf(fp, "%s\n", problem->geomOut[i]->name);
5883 }
5884 fclose(fp);
5885 status = caps_rename(temp, filename);
5886 if (status != CAPS_SUCCESS0) {
5887 snprintf(temp, PATH_MAX4096, "Cannot rename %s (caps_phaseCSMreload)!\n",
5888 filename);
5889 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
5890 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
5891 return status;
5892 }
5893 status = caps_dumpGeomVals(problem, 1);
5894 if (status != CAPS_SUCCESS0)
5895 printf(" CAPS Warning: caps_dumpGeomVals = %d (caps_phaseCSMreload)\n",
5896 status);
5897 } else {
5898 printf(" CAPS Warning: caps_build = %d (caps_phaseCSMreload)\n", jj);
5899 }
5900
5901 return jj;
5902}
5903
5904
5905static int
5906caps_phaseDeletion(capsProblem *problem)
5907{
5908 int i, j, k, m, status;
5909 char filename[PATH_MAX4096], temp[PATH_MAX4096];
5910 capsObject *link;
5911 capsValue *val;
5912 capsAnalysis *analysis;
5913 capsBound *bound;
5914 capsVertexSet *vertexSet;
5915 FILE *fp;
5916
5917 /* set any Bounds to delete if a marked Analysis is in the Bound */
5918 for (i = 0; i < problem->nAnalysis; i++) {
5919 if (problem->analysis[i] == NULL((void*)0)) continue;
5920 if (problem->analysis[i]->blind == NULL((void*)0)) continue;
5921 if (problem->analysis[i]->delMark == 0) continue;
5922 for (j = 0; j < problem->nBound; j++) {
5923 if (problem->bounds[j] == NULL((void*)0)) continue;
5924 if (problem->bounds[j]->delMark == 1) continue;
5925 if (problem->bounds[j]->blind == NULL((void*)0)) continue;
5926 bound = (capsBound *) problem->bounds[j]->blind;
5927 for (k = 0; j < bound->nVertexSet; k++) {
5928 if (bound->vertexSet[k] == NULL((void*)0)) continue;
5929 if (bound->vertexSet[k]->blind == NULL((void*)0)) continue;
5930 vertexSet = (capsVertexSet *) bound->vertexSet[k]->blind;
5931 if (vertexSet->analysis == problem->analysis[i]) {
5932 problem->bounds[j]->delMark = 1;
5933 break;
5934 }
5935 }
5936 if (problem->bounds[j]->delMark == 1) break;
5937 }
5938 }
5939
5940 /* look at Value Objects of type PARAMETER */
5941 for (k = i = 0; i < problem->nParam; i++) {
5942 if (problem->params[i] == NULL((void*)0)) continue;
5943 if (problem->params[i]->blind == NULL((void*)0)) continue;
5944 if (problem->params[i]->delMark == 0) continue;
5945 k++;
5946 }
5947 if (k != 0) {
5948 for (j = i = 0; i < problem->nParam; i++) {
5949 if (problem->params[i] == NULL((void*)0)) continue;
5950 if (problem->params[i]->blind == NULL((void*)0)) continue;
5951 if (problem->params[i]->delMark == 0) {
5952 problem->params[j] = problem->params[i];
5953 j++;
5954 } else {
5955 /* search for links in the AnalysisIn Value Objects */
5956 for (k = 0; k < problem->nAnalysis; k++) {
5957 if (problem->analysis[k] == NULL((void*)0)) continue;
5958 if (problem->analysis[k]->blind == NULL((void*)0)) continue;
5959 if (problem->analysis[k]->delMark == 1) continue;
5960 analysis = (capsAnalysis *) problem->analysis[k]->blind;
5961 for (m = 0; m < analysis->nAnalysisIn; m++) {
5962 val = (capsValue *) analysis->analysisIn[m]->blind;
5963 if (val->link != problem->params[i]) continue;
5964 val->link = NULL((void*)0);
5965 if (CAPScallBack == NULL((void*)0)) {
5966 caps_brokenLinkCB(problem->mySelf, analysis->analysisIn[m],
5967 val->linkMethod, problem->params[i]->name,
5968 PARAMETER);
5969 } else {
5970 CAPScallBack(problem->mySelf, analysis->analysisIn[m],
5971 val->linkMethod, problem->params[i]->name, PARAMETER);
5972 }
5973 }
5974 }
5975 /* search for links in the GeometryIn Value Objects */
5976 for (k = 0; k < problem->nGeomIn; k++) {
5977 val = (capsValue *) problem->geomIn[k]->blind;
5978 if (val->link != problem->params[i]) continue;
5979 val->link = NULL((void*)0);
5980 if (CAPScallBack == NULL((void*)0)) {
5981 caps_brokenLinkCB(problem->mySelf, problem->geomIn[k],
5982 val->linkMethod, problem->params[i]->name,
5983 PARAMETER);
5984 } else {
5985 CAPScallBack(problem->mySelf, problem->geomIn[k],
5986 val->linkMethod, problem->params[i]->name, PARAMETER);
5987 }
5988 }
5989 /* delete the Value Object */
5990 caps_freeValue(problem->params[i]->blind);
5991 EG_free(problem->params[i]->blind);
5992 caps_freeHistory(problem->params[i]);
5993 caps_freeAttrs(&problem->params[i]->attrs);
5994 caps_freeOwner(&problem->params[i]->last);
5995 problem->params[i]->magicnumber = 0;
5996 EG_free(problem->params[i]->name);
5997 EG_free(problem->params[i]);
5998 }
5999 }
6000 if (problem->nParam != j) {
6001 problem->nParam = j;
6002 if (j == 0) {
6003 EG_free(problem->params);
6004 problem->params = NULL((void*)0);
6005 }
6006#ifdef WIN32
6007 caps_rmWild(problem->root, "capsRestart\\VP-*");
6008 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\param.txt", problem->root);
6009 snprintf(temp, PATH_MAX4096, "%s\\capsRestart\\zzTempzz", problem->root);
6010#else
6011 caps_rmWild(problem->root, "capsRestart/VP-*");
6012 snprintf(filename, PATH_MAX4096, "%s/capsRestart/param.txt", problem->root);
6013 snprintf(temp, PATH_MAX4096, "%s/capsRestart/zzTempzz", problem->root);
6014#endif
6015 fp = fopen(temp, "w");
6016 if (fp == NULL((void*)0)) {
6017 printf(" CAPS Warning: Cannot open %s (caps_phaseDeletion)\n", filename);
6018 } else {
6019 fprintf(fp, "%d %d\n", problem->nParam, problem->nUser);
6020 if (problem->params != NULL((void*)0))
6021 for (i = 0; i < problem->nParam; i++) {
6022 fprintf(fp, "%s\n", problem->params[i]->name);
6023 val = (capsValue *) problem->params[i]->blind;
6024 val->index = i+1;
6025 status = caps_writeValueObj(problem, problem->params[i]);
6026 if (status != CAPS_SUCCESS0)
6027 printf(" CAPS Warning: caps_writeValueObj = %d (caps_phaseDeletion)\n",
6028 status);
6029 }
6030 fclose(fp);
6031 status = caps_rename(temp, filename);
6032 if (status != CAPS_SUCCESS0)
6033 printf(" CAPS Warning: Cannot rename %s (%d)!\n", filename, status);
6034 }
6035 }
6036 }
6037
6038 /* remove Bound Objects */
6039 for (j = problem->nBound-1; j >= 0; j--) {
6040 if (problem->bounds[j] == NULL((void*)0)) continue;
6041 if (problem->bounds[j]->blind == NULL((void*)0)) continue;
6042 if (problem->bounds[j]->delMark == 0) continue;
6043 bound = (capsBound *) problem->bounds[j]->blind;
6044#ifdef WIN32
6045 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\BN-%4.4d",
6046 problem->root, bound->index);
6047#else
6048 snprintf(filename, PATH_MAX4096, "%s/capsRestart/BN-%4.4d",
6049 problem->root, bound->index);
6050#endif
6051 caps_rmDir(filename);
6052 status = caps_freeBound(problem->bounds[j]);
6053 if (status != CAPS_SUCCESS0)
6054 printf(" CAPS Warning: Delete of Bound %d ret = %d from freeBound!\n",
6055 j+1, status);
6056 }
6057
6058 /* remove Analysis Objects */
6059 for (j = i = 0; i < problem->nAnalysis; i++) {
6060 if (problem->analysis[i] == NULL((void*)0)) continue;
6061 if (problem->analysis[i]->blind == NULL((void*)0)) continue;
6062 if (problem->analysis[i]->delMark == 0) {
6063 problem->analysis[j] = problem->analysis[i];
6064 j++;
6065 } else {
6066 /* search for links in the AnalysisIn & GeomIn Value Objects */
6067 for (k = 0; k < problem->nAnalysis; k++) {
6068 if (problem->analysis[k] == NULL((void*)0)) continue;
6069 if (problem->analysis[k]->blind == NULL((void*)0)) continue;
6070 if (problem->analysis[k]->delMark == 1) continue;
6071 analysis = (capsAnalysis *) problem->analysis[k]->blind;
6072 for (m = 0; m < analysis->nAnalysisIn; m++) {
6073 val = (capsValue *) analysis->analysisIn[m]->blind;
6074 link = val->link;
6075 if (link == NULL((void*)0)) continue;
6076 if (link->subtype != ANALYSISOUT) continue;
6077 if (link->parent != problem->analysis[i]) continue;
6078 snprintf(temp, PATH_MAX4096, "%s:%s", problem->analysis[i]->name,
6079 link->name);
6080 val->link = NULL((void*)0);
6081 if (CAPScallBack == NULL((void*)0)) {
6082 caps_brokenLinkCB(problem->mySelf, analysis->analysisIn[m],
6083 val->linkMethod, temp, ANALYSISOUT);
6084 } else {
6085 CAPScallBack(problem->mySelf, analysis->analysisIn[m],
6086 val->linkMethod, temp, ANALYSISOUT);
6087 }
6088 }
6089 for (m = 0; m < problem->nGeomIn; m++) {
6090 val = (capsValue *) problem->geomIn[m]->blind;
6091 link = val->link;
6092 if (link == NULL((void*)0)) continue;
6093 if (link->subtype != ANALYSISOUT) continue;
6094 if (link->parent != problem->analysis[i]) continue;
6095 snprintf(temp, PATH_MAX4096, "%s:%s", problem->analysis[i]->name,
6096 link->name);
6097 val->link = NULL((void*)0);
6098 if (CAPScallBack == NULL((void*)0)) {
6099 caps_brokenLinkCB(problem->mySelf, problem->geomIn[m],
6100 val->linkMethod, temp, ANALYSISOUT);
6101 } else {
6102 CAPScallBack(problem->mySelf, problem->geomIn[m],
6103 val->linkMethod, temp, ANALYSISOUT);
6104 }
6105 }
6106 }
6107 analysis = (capsAnalysis *) problem->analysis[i]->blind;
6108 caps_rmDir(analysis->fullPath);
6109 caps_freeAnalysis(0, analysis);
6110 caps_freeHistory(problem->analysis[i]);
6111 caps_freeAttrs(&problem->analysis[i]->attrs);
6112 caps_freeOwner(&problem->analysis[i]->last);
6113 problem->analysis[i]->magicnumber = 0;
6114 EG_free(problem->analysis[i]->name);
6115 EG_free(problem->analysis[i]);
6116 }
6117 }
6118 if (problem->nAnalysis != j) {
6119 problem->nAnalysis = j;
6120 if (j == 0) {
6121 EG_free(problem->analysis);
6122 problem->analysis = NULL((void*)0);
6123 }
6124 }
6125
6126 return CAPS_SUCCESS0;
6127}
6128
6129
6130int
6131caps_open(const char *prPath, /*@null@*/ const char *phName, int flag,
6132 /*@null@*/ void *ptr, int outLevel, capsObject **pobject,
6133 int *nErr, capsErrs **errors)
6134{
6135 int i, j, k, n, len, status, oclass, mtype, *senses, idot = 0;
6136 int type, nattr, ngIn, ngOut, buildTo, builtTo, ibody;
6137 int nrow, ncol, nbrch, npmtr, nbody, ivec[2], close = -1;
6138 char byte, *units, *env, root[PATH_MAX4096], current[PATH_MAX4096];
6139 char name[MAX_NAME_LEN64], *fileList;
6140 char filename[PATH_MAX4096], temp[PATH_MAX4096], **tmp, line[129];
6141 CAPSLONGunsigned long fileLen, ret;
6142 double dot, lower, upper, data[4], *reals;
6143 ego model, ref, *childs;
6144 capsObject *object, *objs;
6145 capsProblem *problem;
6146 capsAnalysis *analysis;
6147 capsBound *bound;
6148 capsVertexSet *vertexset;
6149 capsDataSet *dataset;
6150 capsValue *value;
6151 modl_T *MODL = NULL((void*)0);
6152 size_t nw;
6153 FILE *fp;
6154 const char *aname, *astring, *prName, *fname = NULL((void*)0);
6155 const char *newPhase = "New Phase";
6156 const int *aints;
6157 const double *areals;
6158
6159 if (nErr == NULL((void*)0)) return CAPS_NULLVALUE-307;
6160 if (errors == NULL((void*)0)) return CAPS_NULLVALUE-307;
6161 *pobject = NULL((void*)0);
6162 *nErr = 0;
6163 *errors = NULL((void*)0);
6164 if (prPath == NULL((void*)0)) return CAPS_NULLNAME-308;
6165 len = strlen(prPath);
6166 for (i = 0; i < len; i++)
6167 if (prPath[i] == ' ') {
6168 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot use spaces in path (caps_open):",
6169 prPath, NULL((void*)0), errors);
6170 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6171 return CAPS_BADNAME-317;
6172 }
6173 if (phName != NULL((void*)0)) {
6174 if (strcmp(phName, "Scratch") == 0) {
6175 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot use the phase Scratch (caps_open)!",
6176 NULL((void*)0), NULL((void*)0), errors);
6177 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6178 return CAPS_BADNAME-317;
6179 }
6180 len = strlen(phName);
6181 for (i = 0; i < len; i++)
6182 if ((phName[i] == '/') || (phName[i] == '\\')) {
6183 caps_makeSimpleErr(NULL((void*)0), CERROR,
6184 "Cannot use slashes in phase name (caps_open):",
6185 phName, NULL((void*)0), errors);
6186 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6187 return CAPS_BADNAME-317;
6188 }
6189 }
6190 for (i = 0; i < PATH_MAX4096-1; i++) filename[i] = ' ';
6191 filename[PATH_MAX4096-1] = 0;
6192
6193 if (flag == oFileName) {
6194 /* filename input */
6195 fname = (const char *) ptr;
6196 if (fname == NULL((void*)0)) return CAPS_NULLNAME-308;
6197 n = -1;
6198#ifdef WIN32
6199 /* do we have a Windows drive? */
6200 if (fname[1] == ':') {
6201 int id, oldrive;
6202 if (fname[0] >= 97) {
6203 id = fname[0] - 96;
6204 } else {
6205 id = fname[0] - 64;
6206 }
6207 oldrive = _getdrive();
6208 status = _chdrive(id);
6209 if (status == -1) {
6210 snprintf(temp, PATH_MAX4096, "Cannot change drive to %c (caps_open)!",
6211 fname[0]);
6212 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6213 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6214 return CAPS_DIRERR-333;
6215 }
6216 (void) _chdrive(oldrive);
6217 n = 0;
6218 }
6219#endif
6220 if (n == -1)
6221 if ((fname[0] == '/') || (fname[0] == '\\')) n = 0;
6222 if (n == 0) {
6223 /* absolute path */
6224#ifdef WIN32
6225 if (fname[1] == ':') {
6226 snprintf(filename, PATH_MAX4096, "%s", fname);
6227 } else {
6228 snprintf(filename, PATH_MAX4096, "%c:%s", _getdrive()+64, fname);
6229 }
6230#else
6231 snprintf(filename, PATH_MAX4096, "%s", fname);
6232#endif
6233 } else {
6234 /* relative path -- make it absolute */
6235 (void) getcwd(current, PATH_MAX4096);
6236#ifdef WIN32
6237 snprintf(filename, PATH_MAX4096, "%s\\%s", current, fname);
6238#else
6239 snprintf(filename, PATH_MAX4096, "%s/%s", current, fname);
6240#endif
6241 }
6242 status = caps_prunePath(filename);
6243 if (status != CAPS_SUCCESS0) {
6244 printf(" CAPS Error: Path '%s' has embedded space(s)!\n", filename);
6245 return status;
6246 }
6247 } else if (flag == oMODL) {
6248 MODL = (modl_T *) ptr;
6249 if (MODL == NULL((void*)0)) return CAPS_NULLOBJ-309;
6250 } else if (flag == oEGO) {
6251 model = (ego) ptr;
6252 if (model == NULL((void*)0)) return CAPS_NULLOBJ-309;
6253 status = EG_getTopology(model, &ref, &oclass, &mtype, data, &len, &childs,
6254 &senses);
6255 if (status != EGADS_SUCCESS0) return status;
6256 } else if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel)) {
6257 if (phName == NULL((void*)0)) {
6258 caps_makeSimpleErr(NULL((void*)0), CERROR,
6259 "Cannot start with a NULL PhaseName (caps_open)!",
6260 NULL((void*)0), NULL((void*)0), errors);
6261 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6262 return CAPS_DIRERR-333;
6263 }
6264 fname = (const char *) ptr;
6265 if (fname == NULL((void*)0)) return CAPS_NULLNAME-308;
6266 } else if ((flag == oContinue) || (flag == oReadOnly)) {
6267 close = 0;
6268 } else {
6269 /* other values of flag */
6270 return CAPS_NOTIMPLEMENT-334;
6271 }
6272
6273 /* does file exist? */
6274 fileLen = 0;
6275 if (flag == oFileName) {
6276 fp = fopen(filename, "rb");
6277 if (fp == NULL((void*)0)) return CAPS_NOTFOUND-303;
6278 do {
6279 ret = fread(&byte, sizeof(char), 1, fp);
6280 fileLen++;
6281 } while (ret != 0);
6282 fclose(fp);
6283 if (fileLen > 0) fileLen--;
6284 if (fileLen == 0) return CAPS_BADVALUE-311;
6285
6286 /* find the file extension */
6287 len = strlen(filename);
6288 for (idot = len-1; idot > 0; idot--)
6289 if (filename[idot] == '.') break;
6290 if (idot == 0) return CAPS_BADNAME-317;
6291/*@-unrecog@*/
6292 if ((strcasecmp(&filename[idot],".csm") != 0) &&
6293 (strcasecmp(&filename[idot],".egads") != 0)) return CAPS_BADTYPE-306;
6294/*@+unrecog@*/
6295 }
6296
6297 /* set up our path and name */
6298 len = strlen(prPath);
6299 for (i = len-1; i > 0; i--)
6300 if ((prPath[i] == '/') || (prPath[i] == '\\')) break;
6301 if (i != 0) i++;
6302 prName = &prPath[i];
6303 status = caps_isNameOK(prName);
6304 if (status != CAPS_SUCCESS0) {
6305 caps_makeSimpleErr(NULL((void*)0), CERROR, "Not a valid Problem Name (caps_open):",
6306 prName, NULL((void*)0), errors);
6307 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6308 return status;
6309 }
6310 n = -1;
6311#ifdef WIN32
6312 /* do we have a Windows drive? */
6313 if (prPath[1] == ':') {
6314 int drive, oldrive;
6315 if (prPath[0] >= 97) {
6316 drive = prPath[0] - 96;
6317 } else {
6318 drive = prPath[0] - 64;
6319 }
6320 oldrive = _getdrive();
6321 status = _chdrive(drive);
6322 if (status == -1) {
6323 snprintf(temp, PATH_MAX4096, "Cannot change drive to %c (caps_open)!",
6324 prPath[0]);
6325 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6326 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6327 return CAPS_DIRERR-333;
6328 }
6329 (void) _chdrive(oldrive);
6330 n = 0;
6331 }
6332#endif
6333 if (n == -1)
6334 if ((prPath[0] == '/') || (prPath[0] == '\\')) n = 0;
6335 if (n == 0) {
6336 /* absolute path */
6337 status = caps_statFile(prPath);
6338 if (status == EGADS_SUCCESS0) {
6339 caps_makeSimpleErr(NULL((void*)0), CERROR, "Lands on a flat file (caps_open):",
6340 prPath, NULL((void*)0), errors);
6341 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6342 return CAPS_DIRERR-333;
6343 } else if (status == EGADS_NOTFOUND-1) {
6344 status = caps_mkDir(prPath);
6345 if (status != EGADS_SUCCESS0) {
6346 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot mkDir (caps_open):",
6347 prPath, NULL((void*)0), errors);
6348 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6349 return status;
6350 }
6351 }
6352#ifdef WIN32
6353 if (prPath[1] == ':') {
6354 if (phName == NULL((void*)0)) {
6355 snprintf(root, PATH_MAX4096, "%s\\Scratch", prPath);
6356 } else {
6357 snprintf(root, PATH_MAX4096, "%s\\%s", prPath, phName);
6358 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel))
6359 snprintf(filename, PATH_MAX4096, "%s\\%s", prPath, fname);
6360 }
6361 } else {
6362 if (phName == NULL((void*)0)) {
6363 snprintf(root, PATH_MAX4096, "%c:%s\\Scratch", _getdrive()+64, prPath);
6364 } else {
6365 snprintf(root, PATH_MAX4096, "%c:%s\\%s", _getdrive()+64, prPath, phName);
6366 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel))
6367 snprintf(filename, PATH_MAX4096, "%c:%s\\%s", _getdrive()+64, prPath,
6368 fname);
6369 }
6370 }
6371#else
6372 if (phName == NULL((void*)0)) {
6373 snprintf(root, PATH_MAX4096, "%s/Scratch", prPath);
6374 } else {
6375 snprintf(root, PATH_MAX4096, "%s/%s", prPath, phName);
6376 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel))
6377 snprintf(filename, PATH_MAX4096, "%s/%s", prPath, fname);
6378 }
6379#endif
6380 } else {
6381 /* relative path -- make it absolute */
6382 (void) getcwd(current, PATH_MAX4096);
6383#ifdef WIN32
6384 snprintf(root, PATH_MAX4096, "%s\\%s", current, prPath);
6385#else
6386 snprintf(root, PATH_MAX4096, "%s/%s", current, prPath);
6387#endif
6388 status = caps_statFile(root);
6389 if (status == EGADS_SUCCESS0) {
6390 caps_makeSimpleErr(NULL((void*)0), CERROR, "Path lands on a flat file (caps_open):",
6391 root, NULL((void*)0), errors);
6392 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6393 return CAPS_DIRERR-333;
6394 } else if (status == EGADS_NOTFOUND-1) {
6395 status = caps_mkDir(root);
6396 if (status != EGADS_SUCCESS0) {
6397 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot make Path (caps_open):",
6398 root, NULL((void*)0), errors);
6399 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6400 return status;
6401 }
6402 }
6403#ifdef WIN32
6404 if (phName == NULL((void*)0)) {
6405 snprintf(root, PATH_MAX4096, "%s\\%s\\Scratch", current, prPath);
6406 } else {
6407 snprintf(root, PATH_MAX4096, "%s\\%s\\%s", current, prPath, phName);
6408 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel))
6409 snprintf(filename, PATH_MAX4096, "%s\\%s\\%s", current, prPath, fname);
6410 }
6411#else
6412 if (phName == NULL((void*)0)) {
6413 snprintf(root, PATH_MAX4096, "%s/%s/Scratch", current, prPath);
6414 } else {
6415 snprintf(root, PATH_MAX4096, "%s/%s/%s", current, prPath, phName);
6416 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel))
6417 snprintf(filename, PATH_MAX4096, "%s/%s/%s", current, prPath, fname);
6418 }
6419#endif
6420 }
6421 status = caps_prunePath(root);
6422 if (status != CAPS_SUCCESS0) {
6423 printf(" CAPS Error: Path '%s' has embedded space(s)!\n", root);
6424 return status;
6425 }
6426 /* not a continuation -- must not have a directory (unless Scratch)! */
6427 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel)) {
6428 status = caps_prunePath(filename);
6429 if (status != CAPS_SUCCESS0) {
6430 printf(" CAPS Error: Path '%s' has embedded space(s)!\n", filename);
6431 return status;
6432 }
6433 status = caps_statFile(root);
6434 if (status == EGADS_SUCCESS0) {
6435 caps_makeSimpleErr(NULL((void*)0), CERROR, "Lands on a flat file (caps_open):",
6436 root, NULL((void*)0), errors);
6437 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6438 return CAPS_DIRERR-333;
6439 } else if (status != EGADS_NOTFOUND-1) {
6440 caps_makeSimpleErr(NULL((void*)0), CERROR, "Path already exists (caps_open):",
6441 root, NULL((void*)0), errors);
6442 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6443 return EGADS_EXISTS-30;
6444 }
6445#ifdef WIN32
6446 snprintf(current, PATH_MAX4096, "%s\\capsClosed", filename);
6447#else
6448 snprintf(current, PATH_MAX4096, "%s/capsClosed", filename);
6449#endif
6450 status = caps_statFile(current);
6451 if (status != EGADS_SUCCESS0) {
6452 caps_makeSimpleErr(NULL((void*)0), CERROR, "Not closed (caps_open):",
6453 filename, NULL((void*)0), errors);
6454 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6455 return CAPS_DIRERR-333;
6456 }
6457 status = caps_cpDir(filename, root);
6458 if (status != EGADS_SUCCESS0) {
6459 snprintf(temp, PATH_MAX4096, "Copy directory = %d (caps_open)", status);
6460 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6461 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6462 return status;
6463 }
6464 /* remove closed & lock markers */
6465#ifdef WIN32
6466 snprintf(current, PATH_MAX4096, "%s\\capsClosed", root);
6467#else
6468 snprintf(current, PATH_MAX4096, "%s/capsClosed", root);
6469#endif
6470 status = caps_rmFile(current);
6471 if ((status != EGADS_SUCCESS0) && (status != EGADS_NOTFOUND-1))
6472 printf(" CAPS Warning: Cannot remove Closed file!\n");
6473#ifdef WIN32
6474 snprintf(current, PATH_MAX4096, "%s\\capsLock", root);
6475#else
6476 snprintf(current, PATH_MAX4096, "%s/capsLock", root);
6477#endif
6478 status = caps_rmFile(current);
6479 if ((status != EGADS_SUCCESS0) && (status != EGADS_NOTFOUND-1))
6480 printf(" CAPS Warning: Cannot remove Lock file (caps_open)\n");
6481 } else if (flag == oContinue) {
6482 /* should not be closed */
6483#ifdef WIN32
6484 snprintf(current, PATH_MAX4096, "%s\\capsClosed", root);
6485#else
6486 snprintf(current, PATH_MAX4096, "%s/capsClosed", root);
6487#endif
6488 status = caps_statFile(current);
6489 if (status != EGADS_NOTFOUND-1) {
6490 caps_makeSimpleErr(NULL((void*)0), CERROR,
6491 "Found Closed file on continuation (caps_open)!",
6492 NULL((void*)0), NULL((void*)0), errors);
6493 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6494 return CAPS_EXISTS-331;
6495 }
6496 } else if (flag == oReadOnly) {
6497 /* should be closed */
6498#ifdef WIN32
6499 snprintf(current, PATH_MAX4096, "%s\\capsClosed", root);
6500#else
6501 snprintf(current, PATH_MAX4096, "%s/capsClosed", root);
6502#endif
6503 status = caps_statFile(current);
6504 if (status == EGADS_NOTFOUND-1) {
6505 caps_makeSimpleErr(NULL((void*)0), CERROR,
6506 "No Closed file on ReadOnly (caps_open)!",
6507 NULL((void*)0), NULL((void*)0), errors);
6508 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6509 return CAPS_EXISTS-331;
6510 }
6511 } else {
6512 status = caps_statFile(root);
6513 if (status == EGADS_SUCCESS0) {
6514 caps_makeSimpleErr(NULL((void*)0), CERROR, "Lands on a flat file (caps_open):",
6515 root, NULL((void*)0), errors);
6516 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6517 return CAPS_DIRERR-333;
6518 } else if (status != EGADS_NOTFOUND-1) {
6519 if (phName != NULL((void*)0)) {
6520 caps_makeSimpleErr(NULL((void*)0), CERROR, "Already exists (caps_open):",
6521 root, NULL((void*)0), errors);
6522 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6523 return EGADS_EXISTS-30;
6524 } else {
6525#ifdef WIN32
6526 snprintf(current, PATH_MAX4096, "%s\\capsLock", root);
6527#else
6528 snprintf(current, PATH_MAX4096, "%s/capsLock", root);
6529#endif
6530 if (caps_statFile(current) != EGADS_NOTFOUND-1) {
6531 caps_makeSimpleErr(NULL((void*)0), CERROR, "Lock file exists (caps_open)!",
6532 "If you believe that no one else is running here remove:",
6533 current, errors);
6534 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6535 return CAPS_DIRERR-333;
6536 }
6537 caps_rmDir(root);
6538 }
6539 }
6540 status = caps_mkDir(root);
6541 if (status != EGADS_SUCCESS0) {
6542 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot mkDir (caps_open)!",
6543 root, NULL((void*)0), errors);
6544 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6545 return status;
6546 }
6547 }
6548
6549 /* do we have a lock file? */
6550#ifdef WIN32
6551 snprintf(current, PATH_MAX4096, "%s\\capsLock", root);
6552#else
6553 snprintf(current, PATH_MAX4096, "%s/capsLock", root);
6554#endif
6555 if (caps_statFile(current) != EGADS_NOTFOUND-1) {
6556 caps_makeSimpleErr(NULL((void*)0), CERROR, "Lock file exists (caps_open)!",
6557 "If you believe that no one else is running here remove:",
6558 current, errors);
6559 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6560 return CAPS_DIRERR-333;
6561 }
6562 if (flag != oReadOnly) {
6563 tmp = (char **) EG_reall(CAPSlocks, (CAPSnLock+1)*sizeof(char *));
6564 if (tmp == NULL((void*)0)) {
6565 caps_makeSimpleErr(NULL((void*)0), CERROR, "ReAllocating Locks storage (caps_open)!",
6566 NULL((void*)0), NULL((void*)0), errors);
6567 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6568 return EGADS_MALLOC-4;
6569 }
6570 CAPSlocks = tmp;
6571 CAPSlocks[CAPSnLock] = EG_strdup(current);
6572 CAPSnLock++;
6573 fp = fopen(current, "w");
6574 if (fp == NULL((void*)0)) {
6575 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot open Lock file (caps_open)!",
6576 NULL((void*)0), NULL((void*)0), errors);
6577 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6578 return CAPS_DIRERR-333;
6579 }
6580 fclose(fp);
6581 }
6582 caps_initSignals();
6583
6584 /* check the outLevel env (mostly used for testing) */
6585 env = getenv("CAPS_OUTLEVEL");
6586 if (env != NULL((void*)0) && (env[0] == '0' ||
6587 env[0] == '1' ||
6588 env[0] == '2')) {
6589 outLevel = atoi(env);
6590 }
6591
6592 /* we are OK -- make the Problem */
6593
6594 problem = (capsProblem *) EG_alloc(sizeof(capsProblem));
6595 if (problem == NULL((void*)0)) return EGADS_MALLOC-4;
6596
6597 /* initialize all members */
6598 problem->signature = NULL((void*)0);
6599 problem->context = NULL((void*)0);
6600 problem->utsystem = NULL((void*)0);
6601 problem->root = EG_strdup(root);
6602 problem->phName = NULL((void*)0);
6603 problem->dbFlag = 0;
6604 problem->stFlag = flag;
6605 problem->jrnl = NULL((void*)0);
6606 problem->outLevel = outLevel;
6607 problem->funID = CAPS_OPEN0;
6608 problem->modl = NULL((void*)0);
6609 problem->iPhrase = -1;
6610 problem->nPhrase = 0;
6611 problem->phrases = NULL((void*)0);
6612 problem->nParam = 0;
6613 problem->params = NULL((void*)0);
6614 problem->nUser = 0;
6615 problem->users = NULL((void*)0);
6616 problem->nGeomIn = 0;
6617 problem->geomIn = NULL((void*)0);
6618 problem->nGeomOut = 0;
6619 problem->geomOut = NULL((void*)0);
6620 problem->nAnalysis = 0;
6621 problem->analysis = NULL((void*)0);
6622 problem->mBound = 0;
6623 problem->nBound = 0;
6624 problem->bounds = NULL((void*)0);
6625 problem->geometry.index = -1;
6626 problem->geometry.pname = NULL((void*)0);
6627 problem->geometry.pID = NULL((void*)0);
6628 problem->geometry.user = NULL((void*)0);
6629 problem->geometry.sNum = 0;
6630 for (j = 0; j < 6; j++) problem->geometry.datetime[j] = 0;
6631 problem->nBodies = 0;
6632 problem->bodies = NULL((void*)0);
6633 problem->lunits = NULL((void*)0);
6634 problem->nEGADSmdl = 0;
6635 problem->nRegGIN = 0;
6636 problem->regGIN = NULL((void*)0);
6637 problem->sNum = problem->writer.sNum = 1;
6638 problem->jpos = 0;
6639 problem->writer.index = -1;
6640 problem->writer.pname = EG_strdup(prName);
6641 caps_getStaticStrings(&problem->signature, &problem->writer.pID,
6642 &problem->writer.user);
6643 for (j = 0; j < 6; j++) problem->writer.datetime[j] = 0;
6644 problem->aimFPTR.aim_nAnal = 0;
6645 for (j = 0; j < MAXANAL64; j++) {
6646 problem->aimFPTR.aimName[j] = NULL((void*)0);
6647 problem->aimFPTR.aimDLL[j] = NULL((void*)0);
6648 problem->aimFPTR.aimInit[j] = NULL((void*)0);
6649 problem->aimFPTR.aimDiscr[j] = NULL((void*)0);
6650 problem->aimFPTR.aimFreeD[j] = NULL((void*)0);
6651 problem->aimFPTR.aimLoc[j] = NULL((void*)0);
6652 problem->aimFPTR.aimInput[j] = NULL((void*)0);
6653 problem->aimFPTR.aimPAnal[j] = NULL((void*)0);
6654 problem->aimFPTR.aimPost[j] = NULL((void*)0);
6655 problem->aimFPTR.aimOutput[j] = NULL((void*)0);
6656 problem->aimFPTR.aimCalc[j] = NULL((void*)0);
6657 problem->aimFPTR.aimXfer[j] = NULL((void*)0);
6658 problem->aimFPTR.aimIntrp[j] = NULL((void*)0);
6659 problem->aimFPTR.aimIntrpBar[j] = NULL((void*)0);
6660 problem->aimFPTR.aimIntgr[j] = NULL((void*)0);
6661 problem->aimFPTR.aimIntgrBar[j] = NULL((void*)0);
6662 problem->aimFPTR.aimBdoor[j] = NULL((void*)0);
6663 problem->aimFPTR.aimClean[j] = NULL((void*)0);
6664 }
6665 if (phName != NULL((void*)0)) problem->phName = EG_strdup(phName);
6666 if (flag == oReadOnly) problem->dbFlag = 1;
6667
6668 status = caps_makeObject(&object);
6669 if (status != CAPS_SUCCESS0) {
6670 EG_free(problem);
6671 return status;
6672 }
6673 problem->mySelf = object;
6674 object->type = PROBLEM;
6675 object->blind = problem;
6676
6677 problem->utsystem = caps_initUnits();
6678 if (problem->utsystem == NULL((void*)0)) {
6679 caps_close(object, close, NULL((void*)0));
6680 return CAPS_UNITERR-320;
6681 }
6682
6683 /* get EGADS context or open up EGADS */
6684 if (flag == oEGO) {
6685 status = EG_getContext(model, &problem->context);
6686 } else {
6687 status = EG_open(&problem->context);
6688 }
6689 if (status != EGADS_SUCCESS0) {
6690 caps_close(object, close, NULL((void*)0));
6691 return status;
6692 }
6693 if (problem->context == NULL((void*)0)) {
6694 caps_close(object, close, NULL((void*)0));
6695 return EGADS_NOTCNTX-9;
6696 }
6697
6698 /* load the CAPS state for continuations, read-only and new phase */
6699 if (flag > oEGO) {
6700 status = caps_readState(object);
6701 if (status != CAPS_SUCCESS0) {
6702 caps_close(object, close, NULL((void*)0));
6703 caps_rmDir(root);
6704 return status;
6705 }
6706
6707 /* reload the Geometry */
6708 if (object->subtype == PARAMETRIC) {
6709#ifdef WIN32
6710 snprintf(current, PATH_MAX4096, "%s\\capsRestart.cpc", root);
6711#else
6712 snprintf(current, PATH_MAX4096, "%s/capsRestart.cpc", root);
6713#endif
6714 if (problem->outLevel != 1) ocsmSetOutLevel(problem->outLevel);
6715 status = ocsmLoad(current, &problem->modl);
6716 if (status < SUCCESS0) {
6717 printf(" CAPS Error: Cannot ocsmLoad %s (caps_open)!\n", current);
6718 caps_close(object, close, NULL((void*)0));
6719 caps_rmDir(root);
6720 return status;
6721 }
6722 MODL = (modl_T *) problem->modl;
6723 if (MODL == NULL((void*)0)) {
6724 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot get OpenCSM MODL (caps_open)!",
6725 NULL((void*)0), NULL((void*)0), errors);
6726 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6727 caps_close(object, close, NULL((void*)0));
6728 caps_rmDir(root);
6729 return CAPS_NOTFOUND-303;
6730 }
6731 MODL->context = problem->context;
6732/*@-kepttrans@*/
6733 MODL->userdata = problem;
6734/*@+kepttrans@*/
6735 MODL->tessAtEnd = 0;
6736 status = ocsmRegSizeCB(problem->modl, caps_sizeCB);
6737 if (status != SUCCESS0)
6738 printf(" CAPS Warning: ocsmRegSizeCB = %d (caps_open)!", status);
6739 /* check that Branches are properly ordered */
6740 status = ocsmCheck(problem->modl);
6741 if (status < SUCCESS0) {
6742 snprintf(temp, PATH_MAX4096, "ocsmCheck = %d (caps_open)!", status);
6743 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6744 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6745 caps_close(object, close, NULL((void*)0));
6746 caps_rmDir(root);
6747 return status;
6748 }
6749 fflush(stdoutstdout);
6750 /* reset the GeomIns */
6751 if (problem->geomIn != NULL((void*)0))
6752 for (i = 0; i < problem->nGeomIn; i++) {
6753 if (problem->geomIn[i] == NULL((void*)0)) continue;
6754 value = (capsValue *) problem->geomIn[i]->blind;
6755 reals = value->vals.reals;
6756 if (value->length == 1) reals = &value->vals.real;
6757 status = ocsmGetPmtr(problem->modl, value->pIndex, &type,
6758 &nrow, &ncol, name);
6759 if (status != SUCCESS0) {
6760 snprintf(temp, PATH_MAX4096, "ocsmGetPmtr %d fails with %d (caps_open)!",
6761 value->pIndex, status);
6762 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6763 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6764 caps_close(object, close, NULL((void*)0));
6765 caps_rmDir(root);
6766 return status;
6767 }
6768 if ((ncol != value->ncol) || (nrow != value->nrow)) {
6769 snprintf(temp, PATH_MAX4096, "%s ncol = %d %d, nrow = %d %d (caps_open)!",
6770 name, ncol, value->ncol, nrow, value->nrow);
6771 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6772 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6773 caps_close(object, close, NULL((void*)0));
6774 caps_rmDir(root);
6775 return CAPS_MISMATCH-324;
6776 }
6777 /* flip storage
6778 for (n = j = 0; j < ncol; j++)
6779 for (k = 0; k < nrow; k++, n++) { */
6780 for (n = k = 0; k < nrow; k++)
6781 for (j = 0; j < ncol; j++, n++) {
6782 status = ocsmSetValuD(problem->modl, value->pIndex,
6783 k+1, j+1, reals[n]);
6784 if (status != SUCCESS0) {
6785 snprintf(temp, PATH_MAX4096, "%d ocsmSetValuD[%d,%d] fails with %d!",
6786 value->pIndex, k+1, j+1, status);
6787 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6788 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6789 caps_close(object, close, NULL((void*)0));
6790 caps_rmDir(root);
6791 return status;
6792 }
6793 }
6794 }
6795
6796 nbody = 0;
6797 if ((flag != oPNreload) && (flag != oReadOnly)) {
6798 buildTo = 0; /* all */
6799 status = ocsmBuild(problem->modl, buildTo, &builtTo, &nbody, NULL((void*)0));
6800 fflush(stdoutstdout);
6801 if (status != SUCCESS0) {
6802 snprintf(temp, PATH_MAX4096, "ocsmBuild to %d fails with %d (caps_open)!",
6803 builtTo, status);
6804 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6805 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6806 caps_close(object, close, NULL((void*)0));
6807 caps_rmDir(root);
6808 return status;
6809 }
6810 nbody = 0;
6811 for (ibody = 1; ibody <= MODL->nbody; ibody++) {
6812 if (MODL->body[ibody].onstack != 1) continue;
6813 if (MODL->body[ibody].botype == OCSM_NULL_BODY404) continue;
6814 nbody++;
6815 }
6816 }
6817
6818 if (nbody > 0) {
6819 problem->bodies = (ego *) EG_alloc(nbody*sizeof(ego));
6820 problem->lunits = (char **) EG_alloc(nbody*sizeof(char *));
6821 if ((problem->bodies != NULL((void*)0)) && (problem->lunits != NULL((void*)0))) {
6822 problem->nBodies = nbody;
6823 i = 0;
6824 for (ibody = 1; ibody <= MODL->nbody; ibody++) {
6825 if (MODL->body[ibody].onstack != 1) continue;
6826 if (MODL->body[ibody].botype == OCSM_NULL_BODY404) continue;
6827 problem->bodies[i] = MODL->body[ibody].ebody;
6828 caps_fillLengthUnits(problem, problem->bodies[i],
6829 &problem->lunits[i]);
6830 i++;
6831 }
6832 } else {
6833 if (problem->lunits != NULL((void*)0)) EG_free(problem->lunits);
6834 problem->lunits = NULL((void*)0);
6835 snprintf(temp, PATH_MAX4096, "Malloc on %d Body (caps_open)!\n", nbody);
6836 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6837 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6838 caps_close(object, close, NULL((void*)0));
6839 caps_rmDir(root);
6840 return EGADS_MALLOC-4;
6841 }
6842 }
6843 status = ocsmInfo(problem->modl, &nbrch, &npmtr, &nbody);
6844 if (status != SUCCESS0) {
6845 caps_close(object, close, NULL((void*)0));
6846 caps_rmDir(root);
6847 snprintf(temp, PATH_MAX4096, "ocsmInfo returns %d (caps_open)!", status);
6848 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6849 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6850 return status;
6851 }
6852 for (ngIn = ngOut = i = 0; i < npmtr; i++) {
6853 status = ocsmGetPmtr(problem->modl, i+1, &type, &nrow, &ncol, name);
6854 if (status != SUCCESS0) {
6855 caps_close(object, close, NULL((void*)0));
6856 caps_rmDir(root);
6857 return status;
6858 }
6859 if (type == OCSM_OUTPMTR504) ngOut++;
6860 if (type == OCSM_DESPMTR500) ngIn++;
6861 if (type == OCSM_CFGPMTR501) ngIn++;
6862 if (type == OCSM_CONPMTR502) ngIn++;
6863 }
6864 if (ngIn != problem->nGeomIn) {
6865 snprintf(temp, PATH_MAX4096, "# Design Vars = %d -- from %s = %d (caps_open)!",
6866 ngIn, filename, problem->nGeomIn);
6867 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6868 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6869 caps_close(object, close, NULL((void*)0));
6870 caps_rmDir(root);
6871 return CAPS_MISMATCH-324;
6872 }
6873 if (ngOut != problem->nGeomOut) {
6874 snprintf(temp, PATH_MAX4096, "# Geometry Outs = %d -- from %s = %d (caps_open)!",
6875 ngOut, filename, problem->nGeomOut);
6876 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6877 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6878 caps_close(object, close, NULL((void*)0));
6879 caps_rmDir(root);
6880 return CAPS_MISMATCH-324;
6881 }
6882 /* check geomOuts */
6883 if (problem->geomOut != NULL((void*)0))
6884 for (i = j = 0; j < npmtr; j++) {
6885 ocsmGetPmtr(problem->modl, j+1, &type, &nrow, &ncol, name);
6886 if (type != OCSM_OUTPMTR504) continue;
6887 if (strcmp(name, problem->geomOut[i]->name) != 0) {
6888 snprintf(temp, PATH_MAX4096, "%d Geometry Outs %s != %s (caps_open)!",
6889 i+1, name, problem->geomOut[i]->name);
6890 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6891 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6892 caps_close(object, close, NULL((void*)0));
6893 caps_rmDir(root);
6894 return CAPS_MISMATCH-324;
6895 }
6896 i++;
6897 }
6898
6899 } else {
6900
6901 /* Problem is static */
6902 if (problem->outLevel != 1)
6903 EG_setOutLevel(problem->context, problem->outLevel);
6904#ifdef WIN32
6905 snprintf(current, PATH_MAX4096, "%s\\capsRestart.egads", root);
6906#else
6907 snprintf(current, PATH_MAX4096, "%s/capsRestart.egads", root);
6908#endif
6909 status = EG_loadModel(problem->context, 1, current, &model);
6910 if (status != EGADS_SUCCESS0) {
6911 snprintf(temp, PATH_MAX4096, "%s EG_loadModel = %d (caps_open)!",
6912 current, status);
6913 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6914 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6915 caps_close(object, close, NULL((void*)0));
6916 return status;
6917 }
6918 problem->modl = model;
6919 status = EG_getTopology(model, &ref, &oclass, &mtype, data,
6920 &problem->nBodies, &problem->bodies, &senses);
6921 if (status != EGADS_SUCCESS0) {
6922 snprintf(temp, PATH_MAX4096, "%s EG_getTopology = %d (caps_open)!",
6923 current, status);
6924 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6925 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6926 caps_close(object, close, NULL((void*)0));
6927 return status;
6928 }
6929 nbody = problem->nBodies;
6930 /* get length units if exist */
6931 if (problem->nBodies > 0) {
6932 problem->lunits = (char **) EG_alloc(problem->nBodies*sizeof(char *));
6933 if ((problem->lunits != NULL((void*)0)) && (problem->bodies != NULL((void*)0)))
6934 for (i = 0; i < problem->nBodies; i++)
6935 caps_fillLengthUnits(problem, problem->bodies[i],
6936 &problem->lunits[i]);
6937 }
6938 }
6939
6940 /* set the bodies for the AIMs */
6941 if ((nbody > 0) && (problem->bodies != NULL((void*)0)) &&
6942 (problem->analysis != NULL((void*)0)))
6943 for (i = 0; i < problem->nAnalysis; i++) {
6944 analysis = (capsAnalysis *) problem->analysis[i]->blind;
6945 if (analysis == NULL((void*)0)) continue;
6946 status = caps_filter(problem, analysis);
6947 if (status != CAPS_SUCCESS0)
6948 printf(" CAPS Warning: %s caps_filter = %d (caps_open)!\n",
6949 problem->analysis[i]->name, status);
6950 }
6951
6952 /* get the capsDiscr structures */
6953 if ((problem->bounds != NULL((void*)0)) && (flag != oPNreload) && (flag != oReadOnly))
6954 for (i = 0; i < problem->nBound; i++) {
6955 if (problem->bounds[i] == NULL((void*)0)) continue;
6956 if (problem->bounds[i]->magicnumber != CAPSMAGIC1234321) continue;
6957 if (problem->bounds[i]->type != BOUND) continue;
6958 if (problem->bounds[i]->blind == NULL((void*)0)) continue;
6959 bound = (capsBound *) problem->bounds[i]->blind;
6960 for (j = 0; j < bound->nVertexSet; j++) {
6961 if (bound->vertexSet[j] == NULL((void*)0)) continue;
6962 if (bound->vertexSet[j]->magicnumber != CAPSMAGIC1234321) continue;
6963 if (bound->vertexSet[j]->type != VERTEXSET) continue;
6964 if (bound->vertexSet[j]->blind == NULL((void*)0)) continue;
6965 vertexset = (capsVertexSet *) bound->vertexSet[j]->blind;
6966 if (vertexset->analysis != NULL((void*)0))
6967 if (vertexset->analysis->blind != NULL((void*)0)) {
6968 analysis = (capsAnalysis *) vertexset->analysis->blind;
6969 vertexset->discr->dim = bound->dim;
6970 vertexset->discr->instStore = analysis->instStore;
6971 status = aim_Discr(problem->aimFPTR, analysis->loadName,
6972 problem->bounds[i]->name, vertexset->discr);
6973 if (status != CAPS_SUCCESS0) {
6974 aim_FreeDiscr(problem->aimFPTR, analysis->loadName,
6975 vertexset->discr);
6976 snprintf(temp, PATH_MAX4096, "Bound = %s, Analysis = %s aimDiscr = %d",
6977 problem->bounds[i]->name, analysis->loadName, status);
6978 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
6979 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6980 caps_close(object, close, NULL((void*)0));
6981 return status;
6982 } else {
6983 /* check the validity of the discretization just returned */
6984 status = caps_checkDiscr(vertexset->discr, 129, line);
6985 if (status != CAPS_SUCCESS0) {
6986 snprintf(temp, PATH_MAX4096, "Bound = %s, Analysis = %s chkDiscr=%d",
6987 problem->bounds[i]->name, analysis->loadName, status);
6988 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, line, NULL((void*)0), errors);
6989 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
6990 aim_FreeDiscr(problem->aimFPTR, analysis->loadName,
6991 vertexset->discr);
6992 caps_close(object, close, NULL((void*)0));
6993 return status;
6994 }
6995 }
6996 /* do the counts match? */
6997 if (vertexset->nDataSets > 0) {
6998 dataset = (capsDataSet *) vertexset->dataSets[0]->blind;
6999 if (dataset->npts != vertexset->discr->nPoints) {
7000 snprintf(temp, PATH_MAX4096, "DataSet = %s, npts = %d %d!",
7001 vertexset->dataSets[0]->name, dataset->npts,
7002 vertexset->discr->nPoints);
7003 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7004 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7005 aim_FreeDiscr(problem->aimFPTR, analysis->loadName,
7006 vertexset->discr);
7007 caps_close(object, close, NULL((void*)0));
7008 return CAPS_MISMATCH-324;
7009 }
7010 }
7011 if (vertexset->nDataSets > 1) {
7012 dataset = (capsDataSet *) vertexset->dataSets[1]->blind;
7013 if (dataset->npts != vertexset->discr->nVerts) {
7014 snprintf(temp, PATH_MAX4096, "DataSet = %s, npts = %d %d!",
7015 vertexset->dataSets[1]->name, dataset->npts,
7016 vertexset->discr->nVerts);
7017 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7018 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7019 aim_FreeDiscr(problem->aimFPTR, analysis->loadName,
7020 vertexset->discr);
7021 caps_close(object, close, NULL((void*)0));
7022 return CAPS_MISMATCH-324;
7023 }
7024 }
7025 }
7026 }
7027 }
7028
7029 } else if ((flag == oMODL) || (strcasecmp(&filename[idot],".csm") == 0)) {
7030 object->subtype = PARAMETRIC;
7031 object->name = EG_strdup(prName);
7032 object->last.index = -1;
7033 object->last.pname = EG_strdup(prName);
7034 object->last.sNum = problem->sNum;
7035 caps_getStaticStrings(&problem->signature, &object->last.pID,
7036 &object->last.user);
7037
7038 if (problem->outLevel != 1) ocsmSetOutLevel(problem->outLevel);
7039
7040 if (flag == oFileName) {
7041 /* do an OpenCSM load */
7042 status = ocsmLoad((char *) filename, &problem->modl);
7043 if (status < SUCCESS0) {
7044 snprintf(temp, PATH_MAX4096, "Cannot Load %s (caps_open)!", filename);
7045 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7046 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7047 caps_close(object, close, NULL((void*)0));
7048 return status;
7049 }
7050 MODL = (modl_T *) problem->modl;
7051 } else {
7052 problem->modl = MODL;
7053 }
7054 if (MODL == NULL((void*)0)) {
7055 caps_makeSimpleErr(NULL((void*)0), CERROR, "Cannot get OpenCSM MODL (caps_open)!",
7056 NULL((void*)0), NULL((void*)0), errors);
7057 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7058 caps_close(object, close, NULL((void*)0));
7059 return CAPS_NOTFOUND-303;
7060 }
7061 MODL->context = problem->context;
7062/*@-kepttrans@*/
7063 MODL->userdata = problem;
7064/*@+kepttrans@*/
7065 MODL->tessAtEnd = 0;
7066 status = ocsmRegSizeCB(problem->modl, caps_sizeCB);
7067 if (status != SUCCESS0)
7068 printf(" CAPS Warning: ocsmRegSizeCB = %d (caps_open)!\n", status);
7069
7070 env = getenv("DUMPEGADS");
7071 if (env != NULL((void*)0)) {
7072 MODL->dumpEgads = 1;
7073 MODL->loadEgads = 1;
7074 }
7075
7076 /* check that Branches are properly ordered */
7077 status = ocsmCheck(problem->modl);
7078 if (status < SUCCESS0) {
7079 snprintf(temp, PATH_MAX4096, "ocsmCheck = %d (caps_open)!", status);
7080 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7081 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7082 caps_close(object, close, NULL((void*)0));
7083 return status;
7084 }
7085 fflush(stdoutstdout);
7086
7087 status = ocsmInfo(problem->modl, &nbrch, &npmtr, &nbody);
7088 if (status != SUCCESS0) {
7089 snprintf(temp, PATH_MAX4096, "ocsmInfo returns %d (caps_open)!", status);
7090 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7091 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7092 caps_close(object, close, NULL((void*)0));
7093 return status;
7094 }
7095
7096 /* count the GeomIns and GeomOuts */
7097 for (ngIn = ngOut = i = 0; i < npmtr; i++) {
7098 status = ocsmGetPmtr(problem->modl, i+1, &type, &nrow, &ncol, name);
7099 if (status != SUCCESS0) {
7100 caps_close(object, close, NULL((void*)0));
7101 return status;
7102 }
7103 if (type == OCSM_OUTPMTR504) ngOut++;
7104 if (type == OCSM_DESPMTR500) ngIn++;
7105 if (type == OCSM_CFGPMTR501) ngIn++;
7106 if (type == OCSM_CONPMTR502) ngIn++;
7107 }
7108
7109 /* allocate the objects for the geometry inputs */
7110 if (ngIn != 0) {
7111 problem->geomIn = (capsObject **) EG_alloc(ngIn*sizeof(capsObject *));
7112 if (problem->geomIn == NULL((void*)0)) {
7113 caps_close(object, close, NULL((void*)0));
7114 return EGADS_MALLOC-4;
7115 }
7116 for (i = 0; i < ngIn; i++) problem->geomIn[i] = NULL((void*)0);
7117 value = (capsValue *) EG_alloc(ngIn*sizeof(capsValue));
7118 if (value == NULL((void*)0)) {
7119 caps_close(object, close, NULL((void*)0));
7120 return EGADS_MALLOC-4;
7121 }
7122 for (i = j = 0; j < npmtr; j++) {
7123 ocsmGetPmtr(problem->modl, j+1, &type, &nrow, &ncol, name);
7124 if ((type != OCSM_DESPMTR500) && (type != OCSM_CFGPMTR501) &&
7125 (type != OCSM_CONPMTR502)) continue;
7126 if ((nrow == 0) || (ncol == 0)) continue; /* ignore string pmtrs */
7127 value[i].nrow = nrow;
7128 value[i].ncol = ncol;
7129 value[i].type = Double;
7130 value[i].dim = Scalar;
7131 value[i].index = i+1;
7132 value[i].pIndex = j+1;
7133 value[i].lfixed = value[i].sfixed = Fixed;
7134 value[i].nullVal = NotAllowed;
7135 value[i].units = NULL((void*)0);
7136 value[i].meshWriter = NULL((void*)0);
7137 value[i].link = NULL((void*)0);
7138 value[i].vals.reals = NULL((void*)0);
7139 value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0;
7140 value[i].linkMethod = Copy;
7141 value[i].length = value[i].nrow*value[i].ncol;
7142 if ((ncol > 1) && (nrow > 1)) {
7143 value[i].dim = Array2D;
7144 } else if ((ncol > 1) || (nrow > 1)) {
7145 value[i].dim = Vector;
7146 }
7147 value[i].gInType = 0;
7148 if (type == OCSM_CFGPMTR501) value[i].gInType = 1;
7149 if (type == OCSM_CONPMTR502) value[i].gInType = 2;
7150 value[i].partial = NULL((void*)0);
7151 value[i].nderiv = 0;
7152 value[i].derivs = NULL((void*)0);
7153
7154 status = caps_makeObject(&objs);
7155 if (status != CAPS_SUCCESS0) {
7156 EG_free(value);
7157 caps_close(object, close, NULL((void*)0));
7158 return EGADS_MALLOC-4;
7159 }
7160 if (i == 0) objs->blind = value;
7161/*@-kepttrans@*/
7162 objs->parent = object;
7163/*@+kepttrans@*/
7164 objs->name = NULL((void*)0);
7165 objs->type = VALUE;
7166 objs->subtype = GEOMETRYIN;
7167 objs->last.sNum = 1;
7168/*@-immediatetrans@*/
7169 objs->blind = &value[i];
7170/*@+immediatetrans@*/
7171 problem->geomIn[i] = objs;
7172 i++;
7173 }
7174 problem->nGeomIn = ngIn;
7175 for (i = 0; i < ngIn; i++) {
7176 ocsmGetPmtr(problem->modl, value[i].pIndex, &type, &nrow, &ncol, name);
7177 if (nrow*ncol > 1) {
7178 reals = (double *) EG_alloc(nrow*ncol*sizeof(double));
7179 if (reals == NULL((void*)0)) {
7180 caps_close(object, close, NULL((void*)0));
7181 return EGADS_MALLOC-4;
7182 }
7183 value[i].vals.reals = reals;
7184 } else {
7185 reals = &value[i].vals.real;
7186 }
7187 problem->geomIn[i]->name = EG_strdup(name);
7188/* flip storage
7189 for (n = j = 0; j < ncol; j++)
7190 for (k = 0; k < nrow; k++, n++) { */
7191 for (n = k = 0; k < nrow; k++)
7192 for (j = 0; j < ncol; j++, n++) {
7193 status = ocsmGetValu(problem->modl, value[i].pIndex, k+1, j+1,
7194 &reals[n], &dot);
7195 if (status != SUCCESS0) {
7196 caps_close(object, close, NULL((void*)0));
7197 return status;
7198 }
7199 }
7200 if (type == OCSM_CFGPMTR501) continue;
7201 status = ocsmGetBnds(problem->modl, value[i].pIndex, 1, 1,
7202 &lower, &upper);
7203 if (status != SUCCESS0) continue;
7204 if ((lower != -HUGEQ99999999.0) || (upper != HUGEQ99999999.0)) {
7205 value[i].limits.dlims[0] = lower;
7206 value[i].limits.dlims[1] = upper;
7207 }
7208 }
7209 }
7210
7211 /* allocate the objects for the geometry outputs */
7212 if (ngOut != 0) {
7213 units = NULL((void*)0);
7214 if (problem->lunits != NULL((void*)0)) units = problem->lunits[problem->nBodies-1];
7215 problem->geomOut = (capsObject **) EG_alloc(ngOut*sizeof(capsObject *));
7216 if (problem->geomOut == NULL((void*)0)) {
7217 caps_close(object, close, NULL((void*)0));
7218 return EGADS_MALLOC-4;
7219 }
7220 for (i = 0; i < ngOut; i++) problem->geomOut[i] = NULL((void*)0);
7221 value = (capsValue *) EG_alloc(ngOut*sizeof(capsValue));
7222 if (value == NULL((void*)0)) {
7223 caps_close(object, close, NULL((void*)0));
7224 return EGADS_MALLOC-4;
7225 }
7226 for (i = j = 0; j < npmtr; j++) {
7227 ocsmGetPmtr(problem->modl, j+1, &type, &nrow, &ncol, name);
7228 if (type != OCSM_OUTPMTR504) continue;
7229 value[i].length = 1;
7230 value[i].type = DoubleDeriv;
7231 value[i].nrow = 1;
7232 value[i].ncol = 1;
7233 value[i].dim = Scalar;
7234 value[i].index = i+1;
7235 value[i].pIndex = j+1;
7236 value[i].lfixed = value[i].sfixed = Change;
7237 value[i].nullVal = IsNull;
7238 value[i].units = NULL((void*)0);
7239 value[i].meshWriter = NULL((void*)0);
7240 value[i].link = NULL((void*)0);
7241 value[i].vals.reals = NULL((void*)0);
7242 value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0;
7243 value[i].linkMethod = Copy;
7244 value[i].gInType = 0;
7245 value[i].partial = NULL((void*)0);
7246 value[i].nderiv = 0;
7247 value[i].derivs = NULL((void*)0);
7248 caps_geomOutUnits(name, units, &value[i].units);
7249
7250 status = caps_makeObject(&objs);
7251 if (status != CAPS_SUCCESS0) {
7252 for (k = 0; k < i; k++)
7253 if (value[k].length > 1) EG_free(value[k].vals.reals);
7254 EG_free(value);
7255 caps_close(object, close, NULL((void*)0));
7256 return EGADS_MALLOC-4;
7257 }
7258/*@-kepttrans@*/
7259 objs->parent = object;
7260/*@+kepttrans@*/
7261 objs->name = EG_strdup(name);
7262 objs->type = VALUE;
7263 objs->subtype = GEOMETRYOUT;
7264 objs->last.sNum = 0;
7265/*@-immediatetrans@*/
7266 objs->blind = &value[i];
7267/*@+immediatetrans@*/
7268 problem->geomOut[i] = objs;
7269 problem->geomOut[i]->last.sNum = problem->sNum;
7270 i++;
7271 }
7272 problem->nGeomOut = ngOut;
7273 }
7274
7275 /* write the path file */
7276#ifdef WIN32
7277 snprintf(current, PATH_MAX4096, "%s\\capsCSMFilePath", root);
7278#else
7279 snprintf(current, PATH_MAX4096, "%s/capsCSMFilePath", root);
7280#endif
7281 caps_rmFile(current);
7282 status = ocsmGetFilelist(problem->modl, &fileList);
7283 if (status != CAPS_SUCCESS0) {
7284 caps_close(object, close, NULL((void*)0));
7285 return status;
7286 }
7287 fp = fopen(current, "w");
7288 if (fp == NULL((void*)0)) {
7289 EG_free(fileList);
7290 caps_close(object, close, NULL((void*)0));
7291 return CAPS_IOERR-332;
7292 }
7293 fprintf(fp, "%s\n", fileList);
7294 fclose(fp);
7295 EG_free(fileList);
7296 fflush(stdoutstdout);
7297
7298 /* write an OpenCSM checkpoint file */
7299#ifdef WIN32
7300 snprintf(current, PATH_MAX4096, "%s\\capsRestart.cpc", root);
7301#else
7302 snprintf(current, PATH_MAX4096, "%s/capsRestart.cpc", root);
7303#endif
7304 caps_rmFile(current);
7305 status = ocsmSave(problem->modl, current);
7306 if (status != CAPS_SUCCESS0) {
7307 caps_close(object, close, NULL((void*)0));
7308 return status;
7309 }
7310 fflush(stdoutstdout);
7311
7312 } else if ((flag == oEGO) || (strcasecmp(&filename[idot],".egads") == 0)) {
7313 object->subtype = STATIC;
7314 object->name = EG_strdup(prName);
7315 object->last.index = -1;
7316 object->last.pname = EG_strdup(prName);
7317 object->last.sNum = problem->sNum;
7318 caps_getStaticStrings(&problem->signature, &object->last.pID,
7319 &object->last.user);
7320 if (flag == oFileName) {
7321 status = EG_loadModel(problem->context, 1, filename, &model);
7322 if (status != EGADS_SUCCESS0) {
7323 caps_close(object, close, NULL((void*)0));
7324 return status;
7325 }
7326 }
7327 problem->modl = model;
7328 status = EG_getTopology(model, &ref, &oclass, &mtype, data,
7329 &problem->nBodies, &problem->bodies, &senses);
7330 if (status != EGADS_SUCCESS0) {
7331 caps_close(object, close, NULL((void*)0));
7332 return status;
7333 }
7334 /* get length units if exist */
7335 if (problem->nBodies > 0) {
7336 problem->lunits = (char **) EG_alloc(problem->nBodies*sizeof(char *));
7337 if ((problem->lunits != NULL((void*)0)) && (problem->bodies != NULL((void*)0)))
7338 for (i = 0; i < problem->nBodies; i++)
7339 caps_fillLengthUnits(problem, problem->bodies[i],
7340 &problem->lunits[i]);
7341 }
7342
7343 /* get parameter values if saved by OpenCSM */
7344 status = EG_attributeNum(model, &nattr);
7345 if ((status == EGADS_SUCCESS0) && (nattr != 0)) {
7346 for (ngIn = ngOut = i = 0; i < nattr; i++) {
7347 status = EG_attributeGet(model, i+1, &aname, &type, &len, &aints,
7348 &areals, &astring);
7349 if (status != EGADS_SUCCESS0) continue;
7350 if (type != ATTRREAL2) continue;
7351 if (strncmp(aname, "_outpmtr_", 9) == 0) ngOut++;
7352 if (strncmp(aname, "_despmtr_", 9) == 0) ngIn++;
7353 if (strncmp(aname, "_cfgpmtr_", 9) == 0) ngIn++;
7354 }
7355
7356 /* allocate the objects for the geometry inputs */
7357 if (ngIn != 0) {
7358 problem->geomIn = (capsObject **) EG_alloc(ngIn*sizeof(capsObject *));
7359 if (problem->geomIn == NULL((void*)0)) {
7360 caps_close(object, close, NULL((void*)0));
7361 return EGADS_MALLOC-4;
7362 }
7363 for (i = 0; i < ngIn; i++) problem->geomIn[i] = NULL((void*)0);
7364 value = (capsValue *) EG_alloc(ngIn*sizeof(capsValue));
7365 if (value == NULL((void*)0)) {
7366 caps_close(object, close, NULL((void*)0));
7367 return EGADS_MALLOC-4;
7368 }
7369 for (i = j = 0; j < nattr; j++) {
7370 status = EG_attributeGet(model, j+1, &aname, &type, &len, &aints,
7371 &areals, &astring);
7372 if (status != EGADS_SUCCESS0) continue;
7373 if (type != ATTRREAL2) continue;
7374 if ((strncmp(aname, "_despmtr_", 9) != 0) &&
7375 (strncmp(aname, "_cfgpmtr_", 9) != 0)) continue;
7376 value[i].nrow = len;
7377 value[i].ncol = 1;
7378 value[i].type = Double;
7379 value[i].dim = Scalar;
7380 value[i].index = value[i].pIndex = j+1;
7381 value[i].lfixed = value[i].sfixed = Fixed;
7382 value[i].nullVal = NotAllowed;
7383 value[i].units = NULL((void*)0);
7384 value[i].meshWriter = NULL((void*)0);
7385 value[i].link = NULL((void*)0);
7386 value[i].vals.reals = NULL((void*)0);
7387 value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0;
7388 value[i].linkMethod = Copy;
7389 value[i].gInType = (strncmp(aname, "_cfgpmtr_", 9) == 0) ? 1 : 0;
7390 value[i].partial = NULL((void*)0);
7391 value[i].nderiv = 0;
7392 value[i].derivs = NULL((void*)0);
7393 value[i].length = len;
7394 if (len > 1) value[i].dim = Vector;
7395
7396 status = caps_makeObject(&objs);
7397 if (status != CAPS_SUCCESS0) {
7398 EG_free(value);
7399 caps_close(object, close, NULL((void*)0));
7400 return EGADS_MALLOC-4;
7401 }
7402 if (i == 0) objs->blind = value;
7403 /*@-kepttrans@*/
7404 objs->parent = object;
7405 /*@+kepttrans@*/
7406 objs->name = NULL((void*)0);
7407 objs->type = VALUE;
7408 objs->subtype = GEOMETRYIN;
7409 objs->last.sNum = 1;
7410 /*@-immediatetrans@*/
7411 objs->blind = &value[i];
7412 /*@+immediatetrans@*/
7413 problem->geomIn[i] = objs;
7414 i++;
7415 }
7416 problem->nGeomIn = ngIn;
7417 for (i = 0; i < ngIn; i++) {
7418 EG_attributeGet(model, value[i].pIndex, &aname, &type, &len, &aints,
7419 &areals, &astring);
7420 if (len > 1) {
7421 reals = (double *) EG_alloc(len*sizeof(double));
7422 if (reals == NULL((void*)0)) {
7423 caps_close(object, close, NULL((void*)0));
7424 return EGADS_MALLOC-4;
7425 }
7426 value[i].vals.reals = reals;
7427 } else {
7428 reals = &value[i].vals.real;
7429 }
7430 problem->geomIn[i]->name = EG_strdup(&aname[9]);
7431 for (j = 0; j < len; j++) reals[j] = areals[j];
7432 }
7433 }
7434
7435 /* allocate the objects for the geometry outputs */
7436 if (ngOut != 0) {
7437 problem->geomOut = (capsObject **) EG_alloc(ngOut*sizeof(capsObject *));
7438 if (problem->geomOut == NULL((void*)0)) {
7439 caps_close(object, close, NULL((void*)0));
7440 return EGADS_MALLOC-4;
7441 }
7442 for (i = 0; i < ngOut; i++) problem->geomOut[i] = NULL((void*)0);
7443 value = (capsValue *) EG_alloc(ngOut*sizeof(capsValue));
7444 if (value == NULL((void*)0)) {
7445 caps_close(object, close, NULL((void*)0));
7446 return EGADS_MALLOC-4;
7447 }
7448 for (i = j = 0; j < nattr; j++) {
7449 status = EG_attributeGet(model, j+1, &aname, &type, &len, &aints,
7450 &areals, &astring);
7451 if (status != EGADS_SUCCESS0) continue;
7452 if (type != ATTRREAL2) continue;
7453 if (strncmp(aname, "_outpmtr_", 9) != 0) continue;
7454 value[i].nrow = len;
7455 value[i].ncol = 1;
7456 value[i].type = Double;
7457 value[i].dim = Scalar;
7458 value[i].index = value[i].pIndex = j+1;
7459 value[i].lfixed = value[i].sfixed = Fixed;
7460 value[i].nullVal = NotAllowed;
7461 value[i].units = NULL((void*)0);
7462 value[i].meshWriter = NULL((void*)0);
7463 value[i].link = NULL((void*)0);
7464 value[i].vals.reals = NULL((void*)0);
7465 value[i].limits.dlims[0] = value[i].limits.dlims[1] = 0.0;
7466 value[i].linkMethod = Copy;
7467 value[i].gInType = 0;
7468 value[i].partial = NULL((void*)0);
7469 value[i].nderiv = 0;
7470 value[i].derivs = NULL((void*)0);
7471 value[i].length = len;
7472 if (len > 1) value[i].dim = Vector;
7473
7474 status = caps_makeObject(&objs);
7475 if (status != CAPS_SUCCESS0) {
7476 EG_free(value);
7477 caps_close(object, close, NULL((void*)0));
7478 return EGADS_MALLOC-4;
7479 }
7480 if (i == 0) objs->blind = value;
7481 /*@-kepttrans@*/
7482 objs->parent = object;
7483 /*@+kepttrans@*/
7484 objs->name = NULL((void*)0);
7485 objs->type = VALUE;
7486 objs->subtype = GEOMETRYOUT;
7487 objs->last.sNum = 1;
7488 /*@-immediatetrans@*/
7489 objs->blind = &value[i];
7490 /*@+immediatetrans@*/
7491 problem->geomOut[i] = objs;
7492 i++;
7493 }
7494 problem->nGeomOut = ngOut;
7495 for (i = 0; i < ngOut; i++) {
7496 EG_attributeGet(model, value[i].pIndex, &aname, &type, &len, &aints,
7497 &areals, &astring);
7498 if (len > 1) {
7499 reals = (double *) EG_alloc(len*sizeof(double));
7500 if (reals == NULL((void*)0)) {
7501 caps_close(object, close, NULL((void*)0));
7502 return EGADS_MALLOC-4;
7503 }
7504 value[i].vals.reals = reals;
7505 } else {
7506 reals = &value[i].vals.real;
7507 }
7508 problem->geomOut[i]->name = EG_strdup(&aname[9]);
7509 for (j = 0; j < len; j++) reals[j] = areals[j];
7510 }
7511 }
7512
7513#ifdef WIN32
7514 snprintf(current, PATH_MAX4096, "%s\\capsRestart.egads", root);
7515#else
7516 snprintf(current, PATH_MAX4096, "%s/capsRestart.egads", root);
7517#endif
7518 caps_rmFile(current);
7519 status = EG_saveModel(model, current);
7520 if (status != EGADS_SUCCESS0)
7521 printf(" CAPS Warning: Cannot save EGADS file = %d\n", status);
7522
7523 /* set geometry serial number */
7524 problem->geometry.sNum = 1;
7525 }
7526
7527 } else {
7528 if (flag == oFileName) {
7529 snprintf(temp, PATH_MAX4096,
7530 "Start Flag = %d filename = %s NOT initialized (caps_open)!",
7531 flag, filename);
7532 } else {
7533 snprintf(temp, PATH_MAX4096, "Start Flag = %d NOT initialized (caps_open)!",
7534 flag);
7535 }
7536 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7537 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7538 caps_close(object, close, NULL((void*)0));
7539 return CAPS_BADINIT-338;
7540 }
7541
7542 /* phase start -- use capsRestart & reset journal */
7543 if ((flag == oPhaseName) || (flag == oPNreload) || (flag == oPNnoDel)) {
7544#ifdef WIN32
7545 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\capsJournal.txt",
7546 problem->root);
7547#else
7548 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal.txt",
7549 problem->root);
7550#endif
7551 fp = fopen(filename, "w");
7552 if (fp == NULL((void*)0)) {
7553 snprintf(temp, PATH_MAX4096, "Cannot open %s on Phase (caps_open)",
7554 filename);
7555 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7556 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7557 caps_close(object, close, NULL((void*)0));
7558 caps_rmDir(root);
7559 return CAPS_DIRERR-333;
7560 }
7561 fprintf(fp, "%d %d\n", CAPSMAJOR1, CAPSMINOR21);
7562 env = getenv("ESP_ARCH");
7563 if (env == NULL((void*)0)) {
7564 snprintf(temp, PATH_MAX4096, "ESP_ARCH env variable is not set! (caps_open)");
7565 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7566 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7567 caps_close(object, close, NULL((void*)0));
7568 caps_rmDir(root);
7569 return CAPS_JOURNALERR-343;
7570 }
7571 fprintf(fp, "%s\n", env);
7572 env = getenv("CASREV");
7573 if (env == NULL((void*)0)) {
7574 snprintf(temp, PATH_MAX4096, "CASREV env variable is not set! (caps_open)");
7575 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7576 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7577 caps_close(object, close, NULL((void*)0));
7578 caps_rmDir(root);
7579 return CAPS_JOURNALERR-343;
7580 }
7581 fprintf(fp, "%s\n", env);
7582 fclose(fp);
7583#ifdef WIN32
7584 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\capsJournal", problem->root);
7585#else
7586 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal", problem->root);
7587#endif
7588 status = caps_rmFile(filename);
7589 if (status != CAPS_SUCCESS0)
7590 printf(" CAPS Warning: Cannot delete %s (caps_open)!\n", filename);
7591/*@-dependenttrans@*/
7592 problem->jrnl = fopen(filename, "wb");
7593/*@+dependenttrans@*/
7594 if (problem->jrnl == NULL((void*)0)) {
7595 snprintf(temp, PATH_MAX4096, "Cannot open %s on Phase (caps_open)", filename);
7596 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7597 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7598 caps_close(object, close, NULL((void*)0));
7599 caps_rmDir(root);
7600 return CAPS_DIRERR-333;
7601 }
7602 i = CAPS_OPEN0;
7603 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7604 if (nw != 1) goto owrterr;
7605 ret = problem->sNum;
7606 nw = fwrite(&ret, sizeof(CAPSLONGunsigned long), 1, problem->jrnl);
7607 if (nw != 1) goto owrterr;
7608 i = CAPS_SUCCESS0;
7609 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7610 if (nw != 1) goto owrterr;
7611
7612 ivec[0] = CAPSMAJOR1;
7613 ivec[1] = CAPSMINOR21;
7614 nw = fwrite(ivec, sizeof(int), 2, problem->jrnl);
7615 if (nw != 2) goto owrterr;
7616
7617 ret = problem->sNum;
7618 nw = fwrite(&ret, sizeof(CAPSLONGunsigned long), 1, problem->jrnl);
7619 if (nw != 1) goto owrterr;
7620 i = CAPS_OPEN0;
7621 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7622 if (nw != 1) goto owrterr;
7623 fflush(problem->jrnl);
7624
7625 /* cleanup Model files */
7626 for (i = 0; i < problem->nEGADSmdl; i++) {
7627#ifdef WIN32
7628 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\model%4.4d.egads",
7629 problem->root, i);
7630#else
7631 snprintf(filename, PATH_MAX4096, "%s/capsRestart/model%4.4d.egads",
7632 problem->root, i);
7633#endif
7634 status = caps_rmFile(filename);
7635 if (status != EGADS_SUCCESS0)
7636 printf(" CAPS Warning: Cannot remove file: %s\n", filename);
7637 }
7638 problem->nEGADSmdl = 0;
7639
7640 if (flag == oPNreload) {
7641 /* reload the CSM file */
7642 status = caps_phaseCSMreload(object, nErr, errors);
7643 if (status != CAPS_SUCCESS0) {
7644 caps_close(object, close, NULL((void*)0));
7645 caps_rmDir(root);
7646 return status;
7647 }
7648 }
7649
7650 /* add new phase history to problem object */
7651 problem->jpos = 0;
7652 status = caps_intentPhrase(object, 1, &newPhase);
7653 if (status != CAPS_SUCCESS0) {
7654 printf(" CAPS Error: intentPhrase = %d (caps_open)!\n", status);
7655 caps_close(object, close, NULL((void*)0));
7656 caps_rmDir(root);
7657 return status;
7658 }
7659 object->last.sNum = problem->sNum;
7660 status = caps_addHistory(object, problem);
7661 if (status != CAPS_SUCCESS0) {
7662 printf(" CAPS Error: addHistory = %d (caps_open)!\n", status);
7663 caps_close(object, close, NULL((void*)0));
7664 caps_rmDir(root);
7665 return status;
7666 }
7667 problem->iPhrase = -1;
7668
7669 /* remove any objects marked for deletion */
7670 if (flag != oPNnoDel) {
7671 status = caps_phaseDeletion(problem);
7672 if (status != CAPS_SUCCESS0) {
7673 printf(" CAPS Error: phaseDelete = %d (caps_open)!\n", status);
7674 caps_close(object, close, NULL((void*)0));
7675 caps_rmDir(root);
7676 return status;
7677 }
7678 }
7679
7680 /* write out the problem state */
7681 status = caps_writeProblem(object);
7682 if (status != CAPS_SUCCESS0) {
7683 printf(" CAPS Error: writeProblem = %d (caps_open)!\n", status);
7684 caps_close(object, close, NULL((void*)0));
7685 caps_rmDir(root);
7686 return status;
7687 }
7688
7689 *pobject = object;
7690 return CAPS_SUCCESS0;
7691 }
7692
7693 /* read-only -- use capsRestart & no journal */
7694 if (flag == oReadOnly) {
7695
7696 *pobject = object;
7697 return CAPS_SUCCESS0;
7698 }
7699
7700 /* continuation -- use capsRestart & read from journal */
7701 if (flag == oContinue) {
7702#ifdef WIN32
7703 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\capsJournal.txt",
7704 problem->root);
7705#else
7706 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal.txt",
7707 problem->root);
7708#endif
7709 fp = fopen(filename, "r");
7710 if (fp == NULL((void*)0)) {
7711 snprintf(temp, PATH_MAX4096, "Cannot open %s on Continuation (caps_open)",
7712 filename);
7713 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7714 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7715 caps_close(object, close, NULL((void*)0));
7716 return CAPS_BADINIT-338;
7717 } else {
7718 fscanf(fp, "%d %d", &ivec[0], &ivec[1]);
7719 env = getenv("ESP_ARCH");
7720 fscanf(fp, "%s", temp);
7721 units = getenv("CASREV");
7722 fscanf(fp, "%s", filename);
7723 fclose(fp);
7724 i = 0;
7725 if ((env == NULL((void*)0)) && (strlen(temp) != 0)) i = 1;
7726 if ((units == NULL((void*)0)) && (strlen(filename) != 0)) i = 1;
7727 if (i == 0) {
7728 if (strcmp(env, temp) != 0) i = 1;
7729 if (strcmp(units, filename) != 0) i = 1;
7730 }
7731 if ((ivec[0] != CAPSMAJOR1) || (ivec[1] != CAPSMINOR21) || (i == 1)) {
7732 snprintf(temp, PATH_MAX4096, "Journal from CAPS %d.%d and running %d.%d!",
7733 ivec[0], ivec[1], CAPSMAJOR1, CAPSMINOR21);
7734 snprintf(current, PATH_MAX4096, "Architecture %s vs %s\n", temp, env);
7735 snprintf(root, PATH_MAX4096, "OpenCASCADE %s vs %s\n", filename, units);
7736 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, current, root, errors);
7737 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7738 caps_close(object, close, NULL((void*)0));
7739 return CAPS_BADINIT-338;
7740 }
7741 }
7742
7743#ifdef WIN32
7744 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\capsJournal", problem->root);
7745#else
7746 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal", problem->root);
7747#endif
7748/*@-dependenttrans@*/
7749 problem->jrnl = fopen(filename, "rb");
7750/*@+dependenttrans@*/
7751 if (problem->jrnl == NULL((void*)0)) {
7752 printf(" CAPS Error: Cannot open %s for read (caps_open)!\n", filename);
7753 caps_close(object, close, NULL((void*)0));
7754 return CAPS_DIRERR-333;
7755 }
7756 nw = fread(&i, sizeof(int), 1, problem->jrnl);
7757 if (nw != 1) goto owrterr;
7758 if (i != CAPS_OPEN0) {
7759 caps_makeSimpleErr(NULL((void*)0), CERROR, "Journal Sequence Fail 0 (caps_open)!",
7760 NULL((void*)0), NULL((void*)0), errors);
7761 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7762 caps_close(object, close, NULL((void*)0));
7763 return CAPS_IOERR-332;
7764 }
7765 nw = fread(&ret, sizeof(CAPSLONGunsigned long), 1, problem->jrnl);
7766 if (nw != 1) goto owrterr;
7767 nw = fread(&i, sizeof(int), 1, problem->jrnl);
7768 if (nw != 1) goto owrterr;
7769 if (i != CAPS_SUCCESS0) {
7770 caps_makeSimpleErr(NULL((void*)0), CERROR, "Journal Sequence Fail 1 (caps_open)!",
7771 NULL((void*)0), NULL((void*)0), errors);
7772 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7773 caps_close(object, close, NULL((void*)0));
7774 return CAPS_IOERR-332;
7775 }
7776 nw = fread(ivec, sizeof(int), 2, problem->jrnl);
7777 if (nw != 2) goto owrterr;
7778 if ((ivec[0] != CAPSMAJOR1) || (ivec[1] != CAPSMINOR21)) {
7779 snprintf(temp, PATH_MAX4096, "Journal Sequence Fail %d %d (caps_open)!",
7780 ivec[0], ivec[1]);
7781 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7782 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7783 caps_close(object, close, NULL((void*)0));
7784 return CAPS_IOERR-332;
7785 }
7786 nw = fread(&ret, sizeof(CAPSLONGunsigned long), 1, problem->jrnl);
7787 if (nw != 1) goto owrterr;
7788 nw = fread(&i, sizeof(int), 1, problem->jrnl);
7789 if (nw != 1) goto owrterr;
7790 if (i != CAPS_OPEN0) {
7791 caps_makeSimpleErr(NULL((void*)0), CERROR, "Journal Sequence Fail 2 (caps_open)!",
7792 NULL((void*)0), NULL((void*)0), errors);
7793 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7794 caps_close(object, close, NULL((void*)0));
7795 return CAPS_IOERR-332;
7796 }
7797
7798 *pobject = object;
7799 return CAPS_SUCCESS0;
7800 }
7801
7802 /* start up */
7803 problem->writer.sNum = problem->sNum;
7804 caps_fillDateTime(problem->writer.datetime);
7805
7806 /* setup preliminary restart data */
7807#ifdef WIN32
7808 snprintf(current, PATH_MAX4096, "%s\\capsRestart", root);
7809#else
7810 snprintf(current, PATH_MAX4096, "%s/capsRestart", root);
7811#endif
7812 status = caps_statFile(current);
7813 if (status == EGADS_SUCCESS0) {
7814 snprintf(temp, PATH_MAX4096, "%s is a flat file (caps_open)", current);
7815 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7816 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7817 caps_close(object, close, NULL((void*)0));
7818 return CAPS_DIRERR-333;
7819 } else if (status == EGADS_NOTFOUND-1) {
7820 status = caps_mkDir(current);
7821 if (status != EGADS_SUCCESS0) {
7822 snprintf(temp, PATH_MAX4096, "Cannot mkDir %s (caps_open)", current);
7823 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7824 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7825 caps_close(object, close, NULL((void*)0));
7826 return status;
7827 }
7828 /* populate the geometry info */
7829#ifdef WIN32
7830 snprintf(filename, PATH_MAX4096, "%s\\geom.txt", current);
7831 snprintf(temp, PATH_MAX4096, "%s\\xxTempxx", current);
7832#else
7833 snprintf(filename, PATH_MAX4096, "%s/geom.txt", current);
7834 snprintf(temp, PATH_MAX4096, "%s/xxTempxx", current);
7835#endif
7836 fp = fopen(temp, "w");
7837 if (fp == NULL((void*)0)) {
7838 snprintf(temp, PATH_MAX4096, "Cannot open %s (caps_open)\n", filename);
7839 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7840 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7841 caps_close(object, close, NULL((void*)0));
7842 return CAPS_DIRERR-333;
7843 }
7844 fprintf(fp, "%d %d\n", problem->nGeomIn, problem->nGeomOut);
7845 if (problem->geomIn != NULL((void*)0))
7846 for (i = 0; i < problem->nGeomIn; i++)
7847 fprintf(fp, "%s\n", problem->geomIn[i]->name);
7848 if (problem->geomOut != NULL((void*)0))
7849 for (i = 0; i < problem->nGeomOut; i++)
7850 fprintf(fp, "%s\n", problem->geomOut[i]->name);
7851 fclose(fp);
7852 status = caps_rename(temp, filename);
7853 if (status != CAPS_SUCCESS0) {
7854 snprintf(temp, PATH_MAX4096, "Cannot rename %s (caps_open)!\n", filename);
7855 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7856 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7857 caps_close(object, close, NULL((void*)0));
7858 return status;
7859 }
7860 status = caps_dumpGeomVals(problem, 0);
7861 if (status != CAPS_SUCCESS0) {
7862 caps_close(object, close, NULL((void*)0));
7863 return CAPS_DIRERR-333;
7864 }
7865 }
7866 status = caps_writeProblem(object);
7867 if (status != CAPS_SUCCESS0) {
7868 caps_close(object, close, NULL((void*)0));
7869 return status;
7870 }
7871
7872 /* open journal file */
7873#ifdef WIN32
7874 snprintf(filename, PATH_MAX4096, "%s\\capsRestart\\capsJournal.txt",
7875 problem->root);
7876#else
7877 snprintf(filename, PATH_MAX4096, "%s/capsRestart/capsJournal.txt",
7878 problem->root);
7879#endif
7880 fp = fopen(filename, "w");
7881 if (fp == NULL((void*)0)) {
7882 snprintf(temp, PATH_MAX4096, "Cannot open %s on Phase (caps_open)", filename);
7883 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7884 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7885 caps_close(object, close, NULL((void*)0));
7886 return CAPS_DIRERR-333;
7887 }
7888 fprintf(fp, "%d %d\n", CAPSMAJOR1, CAPSMINOR21);
7889 env = getenv("ESP_ARCH");
7890 if (env == NULL((void*)0)) {
7891 snprintf(temp, PATH_MAX4096, "ESP_ARCH env variable is not set! (caps_open)");
7892 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7893 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7894 caps_close(object, close, NULL((void*)0));
7895 return CAPS_JOURNALERR-343;
7896 }
7897 fprintf(fp, "%s\n", env);
7898 env = getenv("CASREV");
7899 if (env == NULL((void*)0)) {
7900 snprintf(temp, PATH_MAX4096, "CASREV env variable is not set! (caps_open)");
7901 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7902 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7903 caps_close(object, close, NULL((void*)0));
7904 return CAPS_JOURNALERR-343;
7905 }
7906 fprintf(fp, "%s\n", env);
7907 fclose(fp);
7908#ifdef WIN32
7909 snprintf(filename, PATH_MAX4096, "%s\\capsJournal", current);
7910#else
7911 snprintf(filename, PATH_MAX4096, "%s/capsJournal", current);
7912#endif
7913/*@-dependenttrans@*/
7914 problem->jrnl = fopen(filename, "wb");
7915/*@+dependenttrans@*/
7916 if (problem->jrnl == NULL((void*)0)) {
7917 snprintf(temp, PATH_MAX4096, "Cannot open %s (caps_open)", filename);
7918 caps_makeSimpleErr(NULL((void*)0), CERROR, temp, NULL((void*)0), NULL((void*)0), errors);
7919 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7920 caps_close(object, close, NULL((void*)0));
7921 return CAPS_DIRERR-333;
7922 }
7923 i = CAPS_OPEN0;
7924 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7925 if (nw != 1) goto owrterr;
7926 ret = 0;
7927 nw = fwrite(&ret, sizeof(CAPSLONGunsigned long), 1, problem->jrnl);
7928 if (nw != 1) goto owrterr;
7929 i = CAPS_SUCCESS0;
7930 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7931 if (nw != 1) goto owrterr;
7932
7933 ivec[0] = CAPSMAJOR1;
7934 ivec[1] = CAPSMINOR21;
7935 nw = fwrite(ivec, sizeof(int), 2, problem->jrnl);
7936 if (nw != 2) goto owrterr;
7937
7938 ret = problem->sNum;
7939 nw = fwrite(&ret, sizeof(CAPSLONGunsigned long), 1, problem->jrnl);
7940 if (nw != 1) goto owrterr;
7941 i = CAPS_OPEN0;
7942 nw = fwrite(&i, sizeof(int), 1, problem->jrnl);
7943 if (nw != 1) goto owrterr;
7944 fflush(problem->jrnl);
7945
7946 *pobject = object;
7947 return CAPS_SUCCESS0;
7948
7949owrterr:
7950 fclose(problem->jrnl);
7951 printf(" CAPS Error: IO error on journal file (caps_open)!\n");
7952 caps_makeSimpleErr(NULL((void*)0), CERROR, "IO error on journal file (caps_open)!",
7953 NULL((void*)0), NULL((void*)0), errors);
7954 if (*errors != NULL((void*)0)) *nErr = (*errors)->nError;
7955 caps_close(object, close, NULL((void*)0));
7956 return CAPS_IOERR-332;
7957}
7958
7959
7960int
7961caps_outLevel(capsObject *pobject, int outLevel)
7962{
7963 int old;
7964 capsProblem *problem;
7965
7966 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
7967 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
7968 if (pobject->type != PROBLEM) return CAPS_BADTYPE-306;
7969 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
7970 if ((outLevel < 0) || (outLevel > 2)) return CAPS_RANGEERR-326;
7971 problem = (capsProblem *) pobject->blind;
7972 problem->funID = CAPS_OUTLEVEL22;
7973
7974 if (pobject->subtype == PARAMETRIC) {
7975 ocsmSetOutLevel(outLevel);
7976 old = problem->outLevel;
7977 } else {
7978 old = EG_setOutLevel(problem->context, outLevel);
7979 }
7980 if (old >= 0) problem->outLevel = outLevel;
7981
7982 return old;
7983}
7984
7985
7986int
7987caps_getRootPath(capsObject *pobject, const char **root)
7988{
7989 capsProblem *problem;
7990
7991 *root = NULL((void*)0);
7992 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
7993 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
7994 if (pobject->type != PROBLEM) return CAPS_BADTYPE-306;
7995 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
7996 problem = (capsProblem *) pobject->blind;
7997 problem->funID = CAPS_GETROOTPATH26;
7998
7999 *root = problem->root;
8000
8001 return CAPS_SUCCESS0;
8002}
8003
8004
8005int
8006caps_intentPhrase(capsObject *pobject, int nLines, /*@null@*/const char **lines)
8007{
8008 int i, stat, ret, index = -1;
8009 capsProblem *problem;
8010 capsPhrase *tmp;
8011 CAPSLONGunsigned long sNum;
8012 capsJrnl args[1]; /* not really used */
8013
8014 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
8015 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
8016 if (pobject->type != PROBLEM) return CAPS_BADTYPE-306;
8017 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
8018 problem = (capsProblem *) pobject->blind;
8019
8020 args[0].type = jString;
8021 stat = caps_jrnlRead(CAPS_INTENTPHRASE27, problem, pobject, 0, args,
8022 &sNum, &ret);
8023 if (stat == CAPS_JOURNALERR-343) return stat;
8024 if (stat == CAPS_JOURNAL-342) return ret;
8025
8026 ret = CAPS_SUCCESS0;
8027 sNum = problem->sNum;
8028 if ((nLines > 0) && (lines != NULL((void*)0))) {
8029 if (problem->phrases == NULL((void*)0)) {
8030 problem->phrases = (capsPhrase *) EG_alloc(sizeof(capsPhrase));
8031 problem->nPhrase = 0;
8032 if (problem->phrases == NULL((void*)0)) ret = EGADS_MALLOC-4;
8033 } else {
8034 tmp = (capsPhrase *) EG_reall( problem->phrases,
8035 (problem->nPhrase+1)*sizeof(capsPhrase));
8036 if (tmp == NULL((void*)0)) {
8037 ret = EGADS_MALLOC-4;
8038 } else {
8039 problem->phrases = tmp;
8040 }
8041 }
8042 if ((ret == CAPS_SUCCESS0) && (problem->phrases != NULL((void*)0))) {
8043 problem->phrases[problem->nPhrase].phase = EG_strdup(problem->phName);
8044 problem->phrases[problem->nPhrase].nLines = 0;
8045 problem->phrases[problem->nPhrase].lines = (char **)
8046 EG_alloc(nLines*sizeof(char *));
8047 if (problem->phrases[problem->nPhrase].lines == NULL((void*)0)) {
8048 EG_free(problem->phrases[problem->nPhrase].phase);
8049 ret = EGADS_MALLOC-4;
8050 } else {
8051 for (i = 0; i < nLines; i++)
8052 problem->phrases[problem->nPhrase].lines[i] = EG_strdup(lines[i]);
8053 problem->phrases[problem->nPhrase].nLines = nLines;
8054 }
8055 }
8056 if (ret == CAPS_SUCCESS0) {
8057 index = problem->nPhrase;
8058 problem->nPhrase += 1;
8059 }
8060 }
8061 problem->iPhrase = index;
8062
8063 if (ret == CAPS_SUCCESS0) {
8064 problem->sNum += 1;
8065 stat = caps_writeProblem(pobject);
8066 if (stat != CAPS_SUCCESS0)
8067 printf(" CAPS Warning: caps_writeProblem = %d (caps_intentPhrase)\n",
8068 stat);
8069 }
8070
8071 caps_jrnlWrite(CAPS_INTENTPHRASE27, problem, pobject, ret, 0, args, sNum,
8072 problem->sNum);
8073
8074 return ret;
8075}
8076
8077
8078int
8079caps_debug(capsObject *pobject)
8080{
8081 capsProblem *problem;
8082
8083 if (pobject == NULL((void*)0)) return CAPS_NULLOBJ-309;
8084 if (pobject->magicnumber != CAPSMAGIC1234321) return CAPS_BADOBJECT-310;
8085 if (pobject->type != PROBLEM) return CAPS_BADTYPE-306;
8086 if (pobject->blind == NULL((void*)0)) return CAPS_NULLBLIND-321;
8087 problem = (capsProblem *) pobject->blind;
8088
8089 if (problem->stFlag != oReadOnly) {
8090 problem->dbFlag++;
8091 if (problem->dbFlag == 2) problem->dbFlag = 0;
8092 }
8093
8094 return problem->dbFlag;
8095}