Bug Summary

File:capsProblem.c
Warning:line 5571, column 29
Access to field 'name' results in a dereference of a null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

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