FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
hecmw_io_hec.c
Go to the documentation of this file.
1/*****************************************************************************
2 * Copyright (c) 2019 FrontISTR Commons
3 * This software is released under the MIT License, see LICENSE.txt
4 *****************************************************************************/
5
6#include <stdio.h>
7#include <stdlib.h>
8#include <errno.h>
9#include <stdbool.h>
10#include "hecmw_util.h"
11#include "hecmw_heclex.h"
12#include "hecmw_io_hec.h"
13#include "hecmw_io_mesh.h"
14#include "hecmw_io_struct.h"
15#include "hecmw_struct.h"
16#include "hecmw_config.h"
17#include "hecmw_system.h"
18#include "hecmw_dist.h"
19#include "hecmw_dist_print.h"
20#include "hecmw_common.h"
21#include "hecmw_path.h"
22#include "hecmw_conn_conv.h"
23
24static char grid_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
25static char include_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
26
27static int connectivity_type = HECMW_CONNTYPE_HECMW;
28
29/*----------------------------------------------------------------------------*/
30
31static void do_logging(int loglv, int msgno, int add_location, const char *fmt,
32 va_list ap) {
33 char line[100] = "";
34 char msg[HECMW_MSG_LEN + 1];
35 char *p;
36
37 HECMW_vsnprintf(msg, sizeof(msg), fmt, ap);
38 if (add_location) {
39 char *s = "";
40 if (strlen(msg) > 0) s = ": ";
41 p = HECMW_heclex_is_including() ? include_filename : grid_filename;
42 HECMW_snprintf(line, sizeof(line), "%s:%d%s", p, HECMW_heclex_get_lineno(),
43 s);
44 }
45 if (loglv == HECMW_LOG_ERROR) {
46 HECMW_set_error(msgno, "%s%s", line, msg);
47 } else {
48 HECMW_print_msg(loglv, msgno, "%s%s", line, msg);
49 }
50}
51
52static void set_err(int msgno, const char *fmt, ...) {
53 va_list ap;
54
55 va_start(ap, fmt);
56 do_logging(HECMW_LOG_ERROR, msgno, 1, fmt, ap);
57 va_end(ap);
58}
59
60static void set_err_token(int token, int msgno, const char *fmt, ...) {
61 int msg_no;
62 va_list ap;
63
64 if (!token) {
65 msg_no = HECMW_IO_HEC_E0003;
66 } else {
67 msg_no = msgno;
68 }
69 va_start(ap, fmt);
70 do_logging(HECMW_LOG_ERROR, msg_no, 1, fmt, ap);
71 va_end(ap);
72}
73
74/*-----------------------------------------------------------------------------
75 ReadFunc
76*/
77
78static int read_input(int msgno_invalid_token) {
79 int token;
80 char *p;
81
83 if (token != '=') {
84 set_err_token(token, msgno_invalid_token, "'=' required after INPUT");
85 return -1;
86 }
88 if (token != HECMW_HECLEX_FILENAME && token != HECMW_HECLEX_NAME) {
89 set_err_token(token, msgno_invalid_token, "Invalid filename for INPUT");
90 return -1;
91 }
93 if (strlen(p) > HECMW_FILENAME_LEN) {
94 set_err(HECMW_IO_E0002, "");
95 return -1;
96 }
98 strcpy(include_filename, p);
99 } else {
100 char separator[10];
101 char *dname = HECMW_dirname(grid_filename);
102 sprintf(separator, "%c", HECMW_get_path_separator());
103 if (strlen(dname) + strlen(separator) + strlen(p) > HECMW_FILENAME_LEN) {
104 set_err(HECMW_IO_E0002, "");
105 return -1;
106 }
107 sprintf(include_filename, "%s%s%s", dname, separator, p);
108 }
109 return 0;
110}
111
112/*----------------------------------------------------------------------------*/
113
114static int read_amp_head(void) {
115 int token;
116
117 /* !AMPLITUDE */
118 token = HECMW_heclex_next_token();
119 if (token != HECMW_HECLEX_H_AMPLITUDE) {
120 set_err_token(token, HECMW_IO_HEC_E0100, "!AMPLITUDE required");
121 return -1;
122 }
123
124 token = HECMW_heclex_next_token();
125 if (token != ',') {
126 set_err_token(token, HECMW_IO_HEC_E0100, "',' required after !AMPLITUDE");
127 return -1;
128 }
129
130 return 0;
131}
132
133static int read_amp_param_name(char *name) {
134 int token;
135 char *p;
136
137 token = HECMW_heclex_next_token();
138 if (token != '=') {
139 set_err_token(token, HECMW_IO_HEC_E0100, "'=' required after NAME");
140 return -1;
141 }
142 token = HECMW_heclex_next_token();
143 if (token != HECMW_HECLEX_NAME) {
144 set_err_token(token, HECMW_IO_HEC_E0100,
145 "NAME must begin with a letter or '_'");
146 return -1;
147 }
149 if (strlen(p) > HECMW_NAME_LEN) {
150 set_err(HECMW_IO_E0001, "");
151 return -1;
152 }
153 strcpy(name, p);
154 HECMW_toupper(name);
155 if (HECMW_io_is_reserved_name(name)) {
156 set_err(HECMW_IO_E0003, "");
157 return -1;
158 }
159 return 0;
160}
161
162static int read_amp_param_type(int *type) {
163 int token;
164
165 token = HECMW_heclex_next_token();
166 if (token != '=') {
167 set_err_token(token, HECMW_IO_HEC_E0100, "'=' required after TYPE");
168 return -1;
169 }
170 token = HECMW_heclex_next_token();
171 if (token != HECMW_HECLEX_K_TIMEVALUE) {
172 set_err_token(token, HECMW_IO_HEC_E0100, "Invalid TYPE");
173 return -1;
174 }
176 return 0;
177}
178
179static int read_amp_param_definition(int *definition) {
180 int token;
181
182 token = HECMW_heclex_next_token();
183 if (token != '=') {
184 set_err_token(token, HECMW_IO_HEC_E0100, "'=' required after DEFINITION");
185 return -1;
186 }
187 token = HECMW_heclex_next_token();
188 if (token != HECMW_HECLEX_K_TABULAR) {
189 set_err_token(token, HECMW_IO_HEC_E0100, "Invalid DEFINITION");
190 return -1;
191 }
192 *definition = HECMW_AMP_TYPEDEF_TABULAR;
193 return 0;
194}
195
196static int read_amp_param_time(int *time) {
197 int token;
198
199 token = HECMW_heclex_next_token();
200 if (token != '=') {
201 set_err_token(token, HECMW_IO_HEC_E0100, "'=' after TIME required");
202 return -1;
203 }
204 token = HECMW_heclex_next_token();
205 if (token != HECMW_HECLEX_K_STEP_TIME) {
206 set_err_token(token, HECMW_IO_HEC_E0100, "Invalid TIME");
207 return -1;
208 }
210 return 0;
211}
212
213static int read_amp_param_value(int *value) {
214 int token;
215
216 token = HECMW_heclex_next_token();
217 if (token != '=') {
218 set_err_token(token, HECMW_IO_HEC_E0100, "'=' required after VALUE");
219 return -1;
220 }
221 token = HECMW_heclex_next_token();
222 if (token == HECMW_HECLEX_K_RELATIVE) {
224 } else if (token == HECMW_HECLEX_K_ABSOLUTE) {
226 } else {
227 set_err_token(token, HECMW_IO_HEC_E0100, "Invalid VALUE");
228 return -1;
229 }
230 return 0;
231}
232
233static int read_amp_data(char *name, int type, int definition, int time,
234 int value) {
235 int i, token;
236 const int NITEM = 4;
237
238 i = 0;
239 while (1) {
240 double val, t, tmp;
241
242 token = HECMW_heclex_next_token();
243 if (i != 0 && token == HECMW_HECLEX_NL) break;
244 /* VAL */
245 if (token != HECMW_HECLEX_DOUBLE && token != HECMW_HECLEX_INT) {
246 set_err_token(token, HECMW_IO_HEC_E0100, "VAL required");
247 return -1;
248 }
250
251 /* ',' */
252 token = HECMW_heclex_next_token();
253 if (token != ',') {
254 set_err_token(token, HECMW_IO_HEC_E0100, "',' required after VAL");
255 return -1;
256 }
257
258 /* T */
259 token = HECMW_heclex_next_token();
260 if (token != HECMW_HECLEX_DOUBLE && token != HECMW_HECLEX_INT) {
261 set_err_token(token, HECMW_IO_HEC_E0100, "T required");
262 return -1;
263 }
265
266 /* type ABAQUS*/
267 if (type == HECMW_HECLEX_K_TIMEVALUE) {
268 tmp = val;
269 val = t;
270 t = tmp;
271 }
272
273 /* add */
274 if (HECMW_io_add_amp(name, definition, time, value, val, t) == NULL) {
275 return -1;
276 }
277
278 i++;
279
280 /* ',' or NL */
281 token = HECMW_heclex_next_token();
282 if (token != ',' && token != HECMW_HECLEX_NL) {
283 set_err_token(token, HECMW_IO_HEC_E0100, "',' or NL required");
284 return -1;
285 }
286 if (token == ',' && i == NITEM) {
287 token = HECMW_heclex_next_token();
288 if (token != HECMW_HECLEX_NL) {
289 set_err_token(token, HECMW_IO_HEC_E0100, "Only %d items allow per line",
290 NITEM);
291 return -1;
292 }
293 break;
294 }
295 if (token == HECMW_HECLEX_NL) break;
296 }
297 return 0;
298}
299
300static int read_amplitude(void) {
301 int token, state;
302 int type = -1;
303 int definition = HECMW_AMP_TYPEDEF_TABULAR;
304 int time = HECMW_AMP_TYPETIME_STEP;
305 int value = HECMW_AMP_TYPEVAL_RELATIVE;
306 int flag_name = 0; /* flag for NAME */
307 int flag_type = 0; /* flag for TYPE */
308 int flag_definition = 0; /* flag for DEFINITION */
309 int flag_time = 0; /* flag for TIME */
310 int flag_value = 0; /* flag for VALUE */
311 int flag_input = 0; /* flag for INPUT */
312 char name[HECMW_NAME_LEN + 1] = "";
313 enum {
314 ST_FINISHED,
315 ST_HEADER_LINE,
316 ST_HEADER_LINE_PARAM,
317 ST_DATA_INCLUDE,
318 ST_DATA_LINE,
319 ST_FINALIZE
320 };
321
322 state = ST_HEADER_LINE;
323 while (state != ST_FINISHED) {
324 if (state == ST_HEADER_LINE) {
325 if (read_amp_head()) return -1;
326 state = ST_HEADER_LINE_PARAM;
327 } else if (state == ST_HEADER_LINE_PARAM) {
328 token = HECMW_heclex_next_token();
329 if (token == HECMW_HECLEX_K_NAME) {
330 /* must */
331 if (read_amp_param_name(name)) return -1;
332 flag_name = 1;
333 } else if (token == HECMW_HECLEX_K_TYPE) {
334 /* optional */
335 if (read_amp_param_type(&type)) return -1;
336 flag_type = 1;
337 } else if (token == HECMW_HECLEX_K_DEFINITION) {
338 /* optional */
339 if (read_amp_param_definition(&definition)) return -1;
340 flag_definition = 1;
341 } else if (token == HECMW_HECLEX_K_TIME) {
342 /* optional */
343 if (read_amp_param_time(&time)) return -1;
344 flag_time = 1;
345 } else if (token == HECMW_HECLEX_K_VALUE) {
346 /* optional */
347 if (read_amp_param_value(&value)) return -1;
348 flag_value = 1;
349 } else if (token == HECMW_HECLEX_K_INPUT) {
350 /* optional */
351 if (read_input(HECMW_IO_HEC_E0100)) return -1;
352 flag_input = 1;
353 } else {
354 set_err_token(token, HECMW_IO_HEC_E0100, "Unknown paramter");
355 return -1;
356 }
357
358 /* check next state */
359 token = HECMW_heclex_next_token();
360 if (token == HECMW_HECLEX_NL) {
361 /* check NAME */
362 if (!flag_name) {
363 set_err(HECMW_IO_HEC_E0101, "");
364 return -1;
365 }
366 state = flag_input ? ST_DATA_INCLUDE : ST_DATA_LINE;
367 } else if (token == ',') {
368 ; /* continue this state */
369 } else {
370 set_err_token(token, HECMW_IO_HEC_E0100, "Unknown paramter");
371 return -1;
372 }
373 } else if (state == ST_DATA_INCLUDE) {
374 HECMW_assert(flag_input);
375 HECMW_assert(flag_name);
376
377 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
378 state = ST_DATA_LINE;
379 } else if (state == ST_DATA_LINE) {
380 HECMW_assert(flag_name);
381 if (read_amp_data(name, type, definition, time, value)) return -1;
382
383 /* check next state */
384 token = HECMW_heclex_next_token();
385 if (token != HECMW_HECLEX_DOUBLE && token != HECMW_HECLEX_INT) {
386 state = ST_FINISHED;
387 }
389 } else {
390 HECMW_assert(0);
391 }
392 }
393 HECMW_log(HECMW_LOG_DEBUG, "read_amplitude done");
394 return 0;
395}
396
397/*----------------------------------------------------------------------------*/
398
399static int read_contact_pair_head(int *last_token) {
400 int token;
401
402 /* !CONTACT */
403 token = HECMW_heclex_next_token();
404 if (token != HECMW_HECLEX_H_CONTACT_PAIR) {
405 set_err_token(token, HECMW_IO_HEC_E2100, "!CONTACT required");
406 return -1;
407 }
408
409 token = HECMW_heclex_next_token();
410 if (token != ',' && token != HECMW_HECLEX_NL) {
411 set_err_token(token, HECMW_IO_HEC_E2100,
412 "',' or NL required after !CONTACT");
413 return -1;
414 }
415 *last_token = token;
416
417 return 0;
418}
419
420static int read_contact_pair_param_name(char *name) {
421 int token;
422 char *p;
423
424 token = HECMW_heclex_next_token();
425 if (token != '=') {
426 set_err_token(token, HECMW_IO_HEC_E2100, "'=' required after NAME");
427 return -1;
428 }
429 token = HECMW_heclex_next_token();
430 if (token != HECMW_HECLEX_NAME) {
431 set_err_token(token, HECMW_IO_HEC_E2100,
432 "NAME must begin with a letter or '_'");
433 return -1;
434 }
436 if (strlen(p) > HECMW_NAME_LEN) {
437 set_err(HECMW_IO_E0001, "");
438 return -1;
439 }
440 strcpy(name, p);
441 HECMW_toupper(name);
442 if (HECMW_io_is_reserved_name(name)) {
443 set_err(HECMW_IO_E0003, "");
444 return -1;
445 }
446 return 0;
447}
448
449static int read_contact_pair_param_type(int *type) {
450 int token;
451
452 token = HECMW_heclex_next_token();
453 if (token != '=') {
454 set_err_token(token, HECMW_IO_HEC_E2100, "'=' required after TYPE");
455 return -1;
456 }
457 token = HECMW_heclex_next_token();
458 if (token == HECMW_HECLEX_K_NODE_SURF) {
460 } else if (token == HECMW_HECLEX_K_SURF_SURF) {
462 } else {
463 set_err_token(token, HECMW_IO_HEC_E2100, "Invalid TYPE");
464 return -1;
465 }
466 return 0;
467}
468
469static int read_contact_pair_data(char *name, int type) {
470 int token;
471 char *slave_grp, *master_grp;
472
473 slave_grp = NULL;
474 master_grp = NULL;
475
476 /* SLAVE NODE/SURF GROUP */
477 token = HECMW_heclex_next_token();
478 if (token == HECMW_HECLEX_NAME) {
479 slave_grp = HECMW_heclex_get_text();
480 if (strlen(slave_grp) > HECMW_NAME_LEN) {
481 set_err(HECMW_IO_E0001, "");
482 return -1;
483 }
484 HECMW_toupper(slave_grp);
485 slave_grp = HECMW_strdup(slave_grp);
486 if (slave_grp == NULL) {
487 HECMW_set_error(errno, "");
488 return -1;
489 }
490 } else {
491 if (type == HECMW_CONTACT_TYPE_NODE_SURF) {
492 set_err_token(token, HECMW_IO_HEC_E2100, "NGROUP name required");
493 } else if (type == HECMW_CONTACT_TYPE_SURF_SURF) {
494 set_err_token(token, HECMW_IO_HEC_E2100, "SGROUP name required");
495 } else {
496 HECMW_assert(0);
497 }
498 return -1;
499 }
500
501 /* ',' */
502 token = HECMW_heclex_next_token();
503 if (token != ',') {
504 set_err_token(token, HECMW_IO_HEC_E2100, "',' required after SGROUP");
505 return -1;
506 }
507
508 /* MASTER SURF GROUP */
509 token = HECMW_heclex_next_token();
510 if (token == HECMW_HECLEX_NAME) {
511 master_grp = HECMW_heclex_get_text();
512 if (strlen(master_grp) > HECMW_NAME_LEN) {
513 set_err(HECMW_IO_E0001, "");
514 return -1;
515 }
516 HECMW_toupper(master_grp);
517 master_grp = HECMW_strdup(master_grp);
518 if (master_grp == NULL) {
519 HECMW_set_error(errno, "");
520 return -1;
521 }
522 } else {
523 set_err_token(token, HECMW_IO_HEC_E2100, "SGROUP name required");
524 return -1;
525 }
526
527 /* NL */
528 token = HECMW_heclex_next_token();
529 if (token != HECMW_HECLEX_NL) {
530 set_err_token(token, HECMW_IO_HEC_E1000, "NL required after NGROUP");
531 return -1;
532 }
533
534 /* add */
535 if (HECMW_io_add_contact(name, type, slave_grp, master_grp) == NULL) {
536 return -1;
537 };
538 HECMW_free(slave_grp);
539 HECMW_free(master_grp);
540
541 return 0;
542}
543
544static int read_contact_pair(void) {
545 int token, state;
547 int flag_name = 0; /* flag for NAME */
548 int flag_input = 0; /* flag for INPUT */
549 char name[HECMW_NAME_LEN + 1] = "";
550 enum {
551 ST_FINISHED,
552 ST_HEADER_LINE,
553 ST_HEADER_LINE_PARAM,
554 ST_DATA_INCLUDE,
555 ST_DATA_LINE,
556 };
557
558 state = ST_HEADER_LINE;
559 while (state != ST_FINISHED) {
560 if (state == ST_HEADER_LINE) {
561 if (read_contact_pair_head(&token)) return -1;
562 if (token == HECMW_HECLEX_NL) {
563 state = ST_DATA_LINE;
564 } else if (token == ',') {
565 state = ST_HEADER_LINE_PARAM;
566 } else {
567 HECMW_assert(0);
568 }
569 } else if (state == ST_HEADER_LINE_PARAM) {
570 token = HECMW_heclex_next_token();
571 if (token == HECMW_HECLEX_K_NAME) {
572 /* must */
573 if (read_contact_pair_param_name(name)) return -1;
574 flag_name = 1;
575 } else if (token == HECMW_HECLEX_K_TYPE) {
576 /* optional */
577 if (read_contact_pair_param_type(&type)) return -1;
578 } else if (token == HECMW_HECLEX_K_INPUT) {
579 /* oprtional */
580 if (read_input(HECMW_IO_HEC_E2100)) return -1;
581 flag_input = 1;
582 } else {
583 set_err_token(token, HECMW_IO_HEC_E2100, "Unknown parameter");
584 return -1;
585 }
586
587 /* check next parameter */
588 token = HECMW_heclex_next_token();
589 if (token == HECMW_HECLEX_NL) {
590 /* check NAME */
591 if (!flag_name) {
592 set_err(HECMW_IO_HEC_E2101, "");
593 return -1;
594 }
595 if (flag_input) {
596 state = ST_DATA_INCLUDE;
597 } else {
598 state = ST_DATA_LINE;
599 }
600 } else if (token == ',') {
601 ; /* continue this state */
602 } else {
603 set_err_token(token, HECMW_IO_HEC_E2100, "Unknown parameter");
604 return -1;
605 }
606 } else if (state == ST_DATA_INCLUDE) {
607 HECMW_assert(flag_input);
608
609 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
610 state = ST_DATA_LINE;
611 } else if (state == ST_DATA_LINE) {
612 if (read_contact_pair_data(name, type)) return -1;
613
614 /* check next state */
615 token = HECMW_heclex_next_token();
616 if (token != HECMW_HECLEX_NAME) {
617 state = ST_FINISHED;
618 }
620 } else {
621 HECMW_assert(0);
622 }
623 }
624 HECMW_log(HECMW_LOG_DEBUG, "read_contact done");
625 return 0;
626}
627
628/*----------------------------------------------------------------------------*/
629#if 0
630static int
631read_ecopy(void)
632{
633 fprintf(stderr, "!ECOPY has not implemented yet\n");
635 return 0;
636}
637
638
639static int
640read_egen(void)
641{
642 fprintf(stderr, "!EGEN has not implemented yet\n");
644 return 0;
645}
646#endif
647
648/*----------------------------------------------------------------------------*/
649
650static int read_egrp_head(void) {
651 int token;
652
653 /* !EGROUP */
654 token = HECMW_heclex_next_token();
655 if (token != HECMW_HECLEX_H_EGROUP) {
656 set_err_token(token, HECMW_IO_HEC_E0500, "!EGROUP required");
657 return -1;
658 }
659
660 token = HECMW_heclex_next_token();
661 if (token != ',') {
662 set_err_token(token, HECMW_IO_HEC_E0500, "',' required after !EGROUP");
663 return -1;
664 }
665
666 return 0;
667}
668
669static int read_egrp_param_egrp(char *egrp) {
670 int token;
671 char *p;
672
673 token = HECMW_heclex_next_token();
674 if (token != '=') {
675 set_err_token(token, HECMW_IO_HEC_E0500, "'=' required after EGRP");
676 return -1;
677 }
678 token = HECMW_heclex_next_token();
679 if (token != HECMW_HECLEX_NAME) {
680 set_err_token(token, HECMW_IO_HEC_E0500,
681 "EGRP must begin with a letter or '_'");
682 return -1;
683 }
685 if (strlen(p) > HECMW_NAME_LEN) {
686 set_err(HECMW_IO_E0001, "");
687 return -1;
688 }
689 strcpy(egrp, p);
690 HECMW_toupper(egrp);
691 if (HECMW_io_is_reserved_name(egrp)) {
692 set_err(HECMW_IO_E0003, "");
693 return -1;
694 }
695 if (strcmp(egrp, "ALL") == 0) {
696 set_err(HECMW_IO_E0003, "Reserved name: %s", egrp);
697 return -1;
698 }
699 return 0;
700}
701
702static int read_egrp_data(char *egrp) {
703 int i, n, *elem, token;
704 struct hecmw_io_id *head, *prev, *p, *q;
705
706 n = 0;
707 prev = NULL;
708 head = NULL;
709 while (1) {
710 struct hecmw_io_id *id;
711
712 token = HECMW_heclex_next_token();
713 if (n != 0 && token == HECMW_HECLEX_NL) break;
714
715 id = HECMW_malloc(sizeof(*id));
716 if (id == NULL) {
717 HECMW_set_error(errno, "");
718 return -1;
719 }
720
721 /* elemX */
722 if (token != HECMW_HECLEX_INT) {
723 set_err_token(token, HECMW_IO_HEC_E0500, "Element ID required");
724 return -1;
725 }
726 id->id = HECMW_heclex_get_number();
727 id->next = NULL;
728 if (head == NULL) {
729 head = id;
730 } else {
731 prev->next = id;
732 }
733 prev = id;
734 n++;
735
736 /* ',' or NL */
737 token = HECMW_heclex_next_token();
738 if (token != ',' && token != HECMW_HECLEX_NL) {
739 set_err_token(token, HECMW_IO_HEC_E0500,
740 "',' or NL required after element ID");
741 return -1;
742 }
743 if (token == HECMW_HECLEX_NL) break;
744 }
746 HECMW_assert(n > 0);
747
748 /* add elem to group */
749 elem = HECMW_malloc(sizeof(*elem) * n);
750 if (elem == NULL) {
751 HECMW_set_error(errno, "");
752 return -1;
753 }
754 i = 0;
755 p = head;
756 while (p) {
757 elem[i++] = p->id;
758 q = p;
759 p = p->next;
760 HECMW_free(q);
761 }
762 if (HECMW_io_add_egrp(egrp, n, elem) < 0) {
763 return -1;
764 }
765 HECMW_free(elem);
766
767 return 0;
768}
769
770static int read_egrp_generate(char *egrp) {
771 int i, n, id, *elem, token;
772 int elem1, elem2, elem3;
773
774 while (1) {
775 /* elem1 */
776 token = HECMW_heclex_next_token();
777 if (token != HECMW_HECLEX_INT) {
778 set_err_token(token, HECMW_IO_HEC_E0500, "elem1 required");
779 return -1;
780 }
781 elem1 = HECMW_heclex_get_number();
782 if (elem1 <= 0) {
783 set_err(HECMW_IO_HEC_E0502, "");
784 return -1;
785 }
786
787 /* ',' */
788 token = HECMW_heclex_next_token();
789 if (token != ',') {
790 set_err_token(token, HECMW_IO_HEC_E0500, "',' required after elem1");
791 return -1;
792 }
793
794 /* elem2 */
795 token = HECMW_heclex_next_token();
796 if (token != HECMW_HECLEX_INT) {
797 set_err_token(token, HECMW_IO_HEC_E0500, "elem2 required");
798 return -1;
799 }
800 elem2 = HECMW_heclex_get_number();
801 if (elem2 <= 0) {
802 set_err(HECMW_IO_HEC_E0502, "");
803 return -1;
804 }
805
806 /* ',' or NL */
807 token = HECMW_heclex_next_token();
808 if (token == ',') {
809 /* elem3 */
810 token = HECMW_heclex_next_token();
811 if (token != HECMW_HECLEX_INT) {
812 set_err_token(token, HECMW_IO_HEC_E0500, "Increment required");
813 return -1;
814 }
815 elem3 = HECMW_heclex_get_number();
816 if (elem3 <= 0) {
817 set_err(HECMW_IO_HEC_E0502, "");
818 return -1;
819 }
820
821 /* NL */
822 token = HECMW_heclex_next_token();
823 if (token != HECMW_HECLEX_NL) {
824 set_err_token(token, HECMW_IO_HEC_E0500, "NL required after increment");
825 return -1;
826 }
827 } else if (token == HECMW_HECLEX_NL) {
828 elem3 = 1;
829 } else {
830 set_err_token(token, HECMW_IO_HEC_E0500,
831 "',' or NL required after elem2");
832 return -1;
833 }
835
836 /* make element */
837 if (elem1 > elem2) {
838 set_err(HECMW_IO_HEC_E0503,
839 "Cannot generate between %d and %d with an increment of %d",
840 elem1, elem2, elem3);
841 return -1;
842 }
843 if ((elem2 - elem1) % elem3) {
844 set_err(HECMW_IO_HEC_E0503,
845 "Cannot generate between %d and %d with an increment of %d",
846 elem1, elem2, elem3);
847 return -1;
848 }
849
850 n = (elem2 - elem1) / elem3 + 1;
851 elem = HECMW_malloc(sizeof(*elem) * n);
852 if (elem == NULL) {
853 HECMW_set_error(errno, "");
854 return -1;
855 }
856
857 i = 0;
858 for (id = elem1; id <= elem2; id += elem3) {
859 elem[i++] = id;
860 }
861 HECMW_assert(i == n);
862 if (HECMW_io_add_egrp(egrp, n, elem) < 0) return -1;
863 HECMW_free(elem);
864
865 /* check next state */
866 token = HECMW_heclex_next_token();
867 if (token != HECMW_HECLEX_INT) {
869 break;
870 }
872 }
873 return 0;
874}
875
876static int read_egroup(void) {
877 int token, state;
878 int flag_egrp = 0; /* flag for EGRP */
879 int flag_generate = 0; /* flag for GENERATE */
880 int flag_input = 0; /* flag for INPUT */
881 char egrp[HECMW_NAME_LEN + 1] = "";
882 enum {
883 ST_FINISHED,
884 ST_HEADER_LINE,
885 ST_HEADER_LINE_PARAM,
886 ST_DATA_INCLUDE,
887 ST_DATA_LINE,
888 ST_DATA_LINE_GENERATE
889 };
890
891 state = ST_HEADER_LINE;
892 while (state != ST_FINISHED) {
893 if (state == ST_HEADER_LINE) {
894 if (read_egrp_head()) return -1;
895 state = ST_HEADER_LINE_PARAM;
896 } else if (state == ST_HEADER_LINE_PARAM) {
897 token = HECMW_heclex_next_token();
898 if (token == HECMW_HECLEX_K_EGRP) {
899 /* must */
900 if (read_egrp_param_egrp(egrp)) return -1;
901 flag_egrp = 1;
902 } else if (token == HECMW_HECLEX_K_GENERATE) {
903 /* oprtional */
904 flag_generate = 1;
905 } else if (token == HECMW_HECLEX_K_INPUT) {
906 /* oprtional */
907 if (read_input(HECMW_IO_HEC_E0500)) return -1;
908 flag_input = 1;
909 } else {
910 set_err_token(token, HECMW_IO_HEC_E0500, "Unknown parameter");
911 return -1;
912 }
913
914 /* check next parameter */
915 token = HECMW_heclex_next_token();
916 if (token == HECMW_HECLEX_NL) {
917 if (flag_input) {
918 state = ST_DATA_INCLUDE;
919 } else if (flag_generate) {
920 state = ST_DATA_LINE_GENERATE;
921 } else {
922 state = ST_DATA_LINE;
923 }
924 /* check */
925 if (!flag_egrp) {
926 set_err(HECMW_IO_HEC_E0501, "");
927 return -1;
928 }
929 } else if (token == ',') {
930 ; /* continue this state */
931 } else {
932 set_err_token(token, HECMW_IO_HEC_E0500, "Unknown parameter");
933 return -1;
934 }
935 } else if (state == ST_DATA_INCLUDE) {
936 HECMW_assert(flag_input);
937 HECMW_assert(flag_egrp);
938
939 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
940 state = flag_generate ? ST_DATA_LINE_GENERATE : ST_DATA_LINE;
941 } else if (state == ST_DATA_LINE) {
942 HECMW_assert(!flag_generate);
943 HECMW_assert(flag_egrp);
944
945 if (read_egrp_data(egrp)) return -1;
946
947 /* check next state */
948 token = HECMW_heclex_next_token();
949 if (token != HECMW_HECLEX_INT) {
950 state = ST_FINISHED;
951 }
953 } else if (state == ST_DATA_LINE_GENERATE) {
954 HECMW_assert(flag_generate);
955 HECMW_assert(flag_egrp);
956
957 if (read_egrp_generate(egrp)) return -1;
958 state = ST_FINISHED;
959 } else {
960 HECMW_assert(0);
961 }
962 }
963 HECMW_log(HECMW_LOG_DEBUG, "read_egroup done");
964 return 0;
965}
966
967/*----------------------------------------------------------------------------*/
968
969static int read_elem_head(void) {
970 int token;
971
972 /* !ELEMENT */
973 token = HECMW_heclex_next_token();
974 if (token != HECMW_HECLEX_H_ELEMENT) {
975 set_err_token(token, HECMW_IO_HEC_E0600, "!ELLEMENT required");
976 return -1;
977 }
978
979 token = HECMW_heclex_next_token();
980 if (token != ',') {
981 set_err_token(token, HECMW_IO_HEC_E0600, "',' required after !ELEMENT");
982 return -1;
983 }
984
985 return 0;
986}
987
988static int read_elem_param_type(int *type) {
989 int token;
990
991 token = HECMW_heclex_next_token();
992 if (token != '=') {
993 set_err_token(token, HECMW_IO_HEC_E0600, "'=' required after TYPE");
994 return -1;
995 }
996 token = HECMW_heclex_next_token();
997 if (token != HECMW_HECLEX_INT) {
998 set_err_token(token, HECMW_IO_HEC_E0600, "Invalid TYPE");
999 return -1;
1000 }
1001 *type = HECMW_heclex_get_number();
1002 if (HECMW_get_max_node(*type) == -1) {
1003 set_err(HECMW_IO_HEC_E0601, "Invalid type: %d", *type);
1004 return -1;
1005 }
1006 return 0;
1007}
1008
1009static int read_elem_param_egrp(char *egrp) {
1010 int token;
1011 char *p;
1012
1013 token = HECMW_heclex_next_token();
1014 if (token != '=') {
1015 set_err_token(token, HECMW_IO_HEC_E0600, "'=' required after EGRP");
1016 return -1;
1017 }
1018 token = HECMW_heclex_next_token();
1019 if (token != HECMW_HECLEX_NAME) {
1020 set_err_token(token, HECMW_IO_HEC_E0600,
1021 "EGRP must begin with a letter or '_'");
1022 return -1;
1023 }
1025 if (strlen(p) > HECMW_NAME_LEN) {
1026 set_err(HECMW_IO_E0001, "");
1027 return -1;
1028 }
1029 strcpy(egrp, p);
1030 HECMW_toupper(egrp);
1031 if (HECMW_io_is_reserved_name(egrp)) {
1032 set_err(HECMW_IO_E0003, "");
1033 return -1;
1034 }
1035 if (strcmp(egrp, "ALL") == 0) {
1036 set_err(HECMW_IO_E0003, "Reserved name: %s", egrp);
1037 return -1;
1038 }
1039 return 0;
1040}
1041
1042static int read_elem_param_nmatitem(int *nmatitem) {
1043 int token;
1044
1045 token = HECMW_heclex_next_token();
1046 if (token != '=') {
1047 set_err_token(token, HECMW_IO_HEC_E0600, "'=' required after MATITEM");
1048 return -1;
1049 }
1050 token = HECMW_heclex_next_token();
1051 if (token != HECMW_HECLEX_INT) {
1052 set_err_token(token, HECMW_IO_HEC_E0602, "");
1053 return -1;
1054 }
1055 *nmatitem = HECMW_heclex_get_number();
1056 if (*nmatitem < 0) {
1057 set_err_token(token, HECMW_IO_HEC_E0602, "");
1058 return -1;
1059 }
1060 return 0;
1061}
1062
1063static int read_elem_data_conn(int *id, int nnode, int *node) {
1064 int token, i;
1065
1066 /* element ID */
1067 token = HECMW_heclex_next_token();
1068 if (token != HECMW_HECLEX_INT) {
1069 set_err_token(token, HECMW_IO_HEC_E0603, "");
1070 return -1;
1071 }
1073 if (*id <= 0) {
1074 set_err_token(token, HECMW_IO_HEC_E0603, "");
1075 return -1;
1076 }
1077
1078 /* ',' */
1079 token = HECMW_heclex_next_token();
1080 if (token != ',') {
1081 set_err_token(token, HECMW_IO_HEC_E0600, "',' required after elment ID");
1082 return -1;
1083 }
1084
1085 /* connectivity */
1086 i = 0;
1087 while (1) {
1088 token = HECMW_heclex_next_token();
1089 if (i != 0 && token == HECMW_HECLEX_NL) continue;
1090 if (token != HECMW_HECLEX_INT) {
1091 set_err(HECMW_IO_HEC_E0604, "");
1092 return -1;
1093 }
1094 node[i] = HECMW_heclex_get_number();
1095 if (node[i] <= 0) {
1096 set_err(HECMW_IO_HEC_E0604, "");
1097 return -1;
1098 }
1099
1100 if (i == nnode - 1) break;
1101
1102 /* ',' or NL */
1103 token = HECMW_heclex_next_token();
1104 if (token != ',' && token != HECMW_HECLEX_NL) {
1105 set_err_token(token, HECMW_IO_HEC_E0600,
1106 "',' or NL required after connectivity");
1107 return -1;
1108 }
1109
1110 i++;
1111 }
1112 return 0;
1113}
1114
1115static int read_elem_data_mat(int nmatitem, double *matitem) {
1116 int token, i;
1117
1118 /* default value */
1119 for (i = 0; i < nmatitem; i++) {
1120 matitem[i] = 0.0;
1121 }
1122
1123 /* MATITEM */
1124 for (i = 0; i < nmatitem; i++) {
1125 token = HECMW_heclex_next_token();
1126 if (token != HECMW_HECLEX_DOUBLE && token != HECMW_HECLEX_INT) {
1127 set_err_token(token, HECMW_IO_HEC_E0600, "required MATITEM");
1128 return -1;
1129 }
1130 matitem[i] = HECMW_heclex_get_number();
1131
1132 /* ',' or NL */
1133 token = HECMW_heclex_next_token();
1134 if (token != ',' && token != HECMW_HECLEX_NL) {
1135 set_err_token(token, HECMW_IO_HEC_E0600, "',' or NL required after MAT");
1136 return -1;
1137 }
1138 if (i == nmatitem - 1) {
1139 if (token != HECMW_HECLEX_NL) {
1140 set_err_token(token, HECMW_IO_HEC_E0600, "NL required after MAT");
1141 return -1;
1142 }
1143 } else {
1144 if (token != ',') {
1145 set_err_token(token, HECMW_IO_HEC_E0600, "',' required after MAT");
1146 return -1;
1147 }
1148 }
1149 }
1150 return 0;
1151}
1152
1153static int read_element(void) {
1154 int token, state;
1155 int id;
1156 int nnode = 0;
1157 int *node = NULL;
1158 double *matitem = NULL;
1159 int nmatitem = 0;
1160 int type = -1;
1161 int flag_type = 0; /* flag for TYPE */
1162 int flag_egrp = 0; /* flag for EGRP */
1163 int flag_matitem = 0; /* flag for MATITEM */
1164 int flag_input = 0; /* flag for INPUT */
1165 char egrp[HECMW_NAME_LEN + 1] = "";
1166 enum {
1167 st_finished,
1168 st_header_line,
1169 st_header_line_param,
1170 st_prepare,
1171 st_data_include,
1172 st_data_line_conn, /* read element ID and connectivity */
1173 st_data_line_matitem, /* read MATITEM */
1174 st_data_line_regist,
1175 st_finalize
1176 };
1177
1178 state = st_header_line;
1179 while (state != st_finished) {
1180 if (state == st_header_line) {
1181 if (read_elem_head()) return -1;
1182 state = st_header_line_param;
1183 } else if (state == st_header_line_param) {
1184 token = HECMW_heclex_next_token();
1185 if (token == HECMW_HECLEX_K_TYPE) {
1186 /* must */
1187 if (read_elem_param_type(&type)) return -1;
1188 flag_type = 1;
1189 } else if (token == HECMW_HECLEX_K_EGRP) {
1190 /* optional */
1191 if (read_elem_param_egrp(egrp)) return -1;
1192 flag_egrp = 1;
1193 } else if (token == HECMW_HECLEX_K_MATITEM) {
1194 /* optional */
1195 if (read_elem_param_nmatitem(&nmatitem)) return -1;
1196 flag_matitem = 1;
1197 } else if (token == HECMW_HECLEX_K_INPUT) {
1198 /* optional */
1199 if (read_input(HECMW_IO_HEC_E0600)) return -1;
1200 flag_input = 1;
1201 } else {
1202 set_err_token(token, HECMW_IO_HEC_E0600, "Unknown parameter");
1203 return -1;
1204 }
1205
1206 /* check next state */
1207 token = HECMW_heclex_next_token();
1208 if (token == HECMW_HECLEX_NL) {
1209 /* check TYPE */
1210 if (!flag_type) {
1211 set_err(HECMW_IO_HEC_E0606, "");
1212 return -1;
1213 }
1214 state = st_prepare;
1215 } else if (token == ',') {
1216 ; /* continue this state */
1217 } else {
1218 set_err_token(token, HECMW_IO_HEC_E0600, "Unknown parameter");
1219 return -1;
1220 }
1221 } else if (state == st_prepare) {
1222 HECMW_assert(flag_type);
1223 HECMW_assert(type != -1);
1224
1225 /* get # of connectivity */
1226 nnode = HECMW_get_max_node(type);
1227 HECMW_assert(nnode > 0);
1229
1230 node = HECMW_malloc(sizeof(*node) * nnode);
1231 if (node == NULL) {
1232 HECMW_set_error(errno, "");
1233 return -1;
1234 }
1235
1236 /* nmatitem */
1237 HECMW_assert(nmatitem >= 0);
1238
1239 if (flag_matitem && nmatitem) {
1240 HECMW_assert(nmatitem > 0);
1241 matitem = HECMW_malloc(sizeof(*matitem) * nmatitem);
1242 if (matitem == NULL) {
1243 HECMW_set_error(errno, "");
1244 return -1;
1245 }
1246 } else {
1247 matitem = NULL;
1248 }
1249
1250 /* set next state */
1251 state = flag_input ? st_data_include : st_data_line_conn;
1252 } else if (state == st_data_include) {
1253 HECMW_assert(flag_input);
1254 HECMW_assert(flag_type);
1255
1256 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
1257 state = st_data_line_conn;
1258 } else if (state == st_data_line_conn) {
1259 HECMW_assert(flag_type);
1260
1261 if (read_elem_data_conn(&id, nnode, node)) return -1;
1262 if (HECMW_convert_connectivity(connectivity_type, type, node)) return -1;
1263
1264 /* check next state */
1265 token = HECMW_heclex_next_token();
1266 if (flag_matitem) {
1267 if (token != ',' && token != HECMW_HECLEX_NL) {
1268 set_err_token(token, HECMW_IO_HEC_E0600,
1269 "',' or NL required after connectivity");
1270 return -1;
1271 }
1272 if (token == ',') {
1273 token = HECMW_heclex_next_token();
1274 if (token != HECMW_HECLEX_NL) {
1276 }
1277 }
1278 state = st_data_line_matitem;
1279 } else {
1280 if (token != HECMW_HECLEX_NL) {
1281 set_err_token(token, HECMW_IO_HEC_E0600, "NL required");
1282 return -1;
1283 }
1284 state = st_data_line_regist;
1285 }
1286 } else if (state == st_data_line_matitem) {
1287 HECMW_assert(flag_matitem);
1288 HECMW_assert(nmatitem > 0);
1289 HECMW_assert(matitem);
1290 HECMW_assert(flag_type);
1291
1292 if (read_elem_data_mat(nmatitem, matitem)) return -1;
1293 state = st_data_line_regist;
1294 } else if (state == st_data_line_regist) {
1295 HECMW_assert(node);
1296 HECMW_assert(flag_type);
1297
1298 /* add element */
1299 if (HECMW_io_add_elem(id, type, node, nmatitem, matitem) == NULL) {
1300 return -1;
1301 }
1302
1303 /* add element to eroup */
1304 if (HECMW_io_add_egrp("ALL", 1, &id) < 0) return -1;
1305
1306 if (flag_egrp) {
1307 if (HECMW_io_add_egrp(egrp, 1, &id) < 0) {
1308 return -1;
1309 }
1310 }
1311
1312 /* check next state */
1313 token = HECMW_heclex_next_token();
1314 if (token == HECMW_HECLEX_INT) {
1315 state = st_data_line_conn;
1316 } else {
1317 state = st_finalize;
1318 }
1320 } else if (state == st_finalize) {
1321 HECMW_free(node);
1322 HECMW_free(matitem);
1323
1324 /* set next state */
1325 state = st_finished;
1326 } else {
1327 HECMW_assert(0);
1328 }
1329 }
1330 HECMW_log(HECMW_LOG_DEBUG, "read_element done");
1331 return 0;
1332}
1333
1334/*----------------------------------------------------------------------------*/
1335
1336static int read_equation_head(int *last_token) {
1337 int token;
1338
1339 /* !EQUATION */
1340 token = HECMW_heclex_next_token();
1341 if (token != HECMW_HECLEX_H_EQUATION) {
1342 set_err_token(token, HECMW_IO_HEC_E0700, "!EQUATION required");
1343 return -1;
1344 }
1345
1346 token = HECMW_heclex_next_token();
1347 if (token != ',' && token != HECMW_HECLEX_NL) {
1348 set_err_token(token, HECMW_IO_HEC_E0700,
1349 "',' or NL required after !EQUATION");
1350 return -1;
1351 }
1352 *last_token = token;
1353
1354 return 0;
1355}
1356
1357static int read_equation_data_line1(int *neq, double *cnst) {
1358 int token;
1359 char *p;
1360
1361 /* NEQ */
1362 token = HECMW_heclex_next_token();
1363
1364 if (token != HECMW_HECLEX_INT && token != HECMW_HECLEX_NAME) {
1365 set_err_token(token, HECMW_IO_HEC_E0700, "required NEQ");
1366 return -1;
1367 }
1368
1369 if (token == HECMW_HECLEX_NAME) {
1371 if (strcmp(p, "link") == 0 || strcmp(p, "LINK") == 0) {
1372 *neq = 2;
1373 *cnst = 0.0;
1374 }
1376 return 0;
1377 }
1378
1379 *neq = HECMW_heclex_get_number();
1380 if (*neq < 2) {
1381 set_err(HECMW_IO_HEC_E0701, "");
1382 return -1;
1383 }
1384
1385 /* ',' */
1386 token = HECMW_heclex_next_token();
1387 if (token == ',') {
1388 /* const */
1389 token = HECMW_heclex_next_token();
1390 if (token != HECMW_HECLEX_DOUBLE && token != HECMW_HECLEX_INT) {
1391 set_err_token(token, HECMW_IO_HEC_E0700, "required CONST");
1392 return -1;
1393 }
1394 *cnst = HECMW_heclex_get_number();
1395 } else {
1396 *cnst = 0.0;
1398 }
1399
1400 /* NL */
1401 token = HECMW_heclex_next_token();
1402 if (token != HECMW_HECLEX_NL) {
1403 set_err_token(token, HECMW_IO_HEC_E0700, "NL required after NEQ");
1404 return -1;
1405 }
1406
1407 return 0;
1408}
1409
1410static int read_equation_data_line2(int neq, double cnst) {
1411 int i, token;
1412 int is_node = 0;
1413 int is_ngrp = 0;
1414 int is_link = 0;
1415 int is_beam = 0;
1416 const int NITEM = 100;
1417 char *p;
1418 struct hecmw_io_mpcitem *mpcitem;
1419 bool isAllDof = false;
1420
1421 mpcitem = HECMW_malloc(sizeof(*mpcitem) * neq);
1422 if (mpcitem == NULL) {
1423 HECMW_set_error(errno, "");
1424 return -1;
1425 }
1426
1427 token = HECMW_heclex_next_token();
1428 if (token == HECMW_HECLEX_NAME) {
1430 if (strcmp(p, "link") == 0 || strcmp(p, "LINK") == 0) {
1431 is_link = 1;
1432 }
1433 }
1435
1436 if (is_link == 0) {
1437 isAllDof = false;
1438 for (i = 0; i < neq; i++) {
1439 token = HECMW_heclex_next_token();
1440 if (i != 0 && token == HECMW_HECLEX_NL) break;
1441
1442 /* nod */
1443 if (token == HECMW_HECLEX_INT) {
1444 if (is_ngrp) {
1445 set_err(HECMW_IO_HEC_E0702, "");
1446 return -1;
1447 }
1448 mpcitem[i].node = HECMW_heclex_get_number();
1449 strcpy(mpcitem[i].ngrp, "");
1450 is_node = 1;
1451 } else if (token == HECMW_HECLEX_NAME) {
1452 char *p = HECMW_heclex_get_text();
1453 if (is_node) {
1454 set_err(HECMW_IO_HEC_E0702, "");
1455 return -1;
1456 }
1457 if (strlen(p) > HECMW_NAME_LEN) {
1458 set_err(HECMW_IO_E0001, "");
1459 return -1;
1460 }
1461 strcpy(mpcitem[i].ngrp, p);
1462 HECMW_toupper(mpcitem[i].ngrp);
1463 if (HECMW_io_is_reserved_name(mpcitem[i].ngrp)) {
1464 set_err(HECMW_IO_E0003, "");
1465 return -1;
1466 }
1467 mpcitem[i].node = -1;
1468 is_ngrp = 1;
1469 } else {
1470 set_err_token(token, HECMW_IO_HEC_E0700, "Node ID or NGRP required");
1471 return -1;
1472 }
1473
1474 /* ',' */
1475 token = HECMW_heclex_next_token();
1476 if (token != ',') {
1477 set_err_token(token, HECMW_IO_HEC_E0700, "',' required after node");
1478 return -1;
1479 }
1480
1481 /* DOF */
1482 token = HECMW_heclex_next_token();
1483 if (token != HECMW_HECLEX_INT) {
1484 set_err(HECMW_IO_HEC_E0703, "");
1485 return -1;
1486 }
1487 mpcitem[i].dof = HECMW_heclex_get_number();
1488 if (mpcitem[i].dof == 0) {
1489 isAllDof = true;
1490 mpcitem[i].dof = 1;
1491 }
1492 if (HECMW_io_check_mpc_dof(mpcitem[i].dof)) {
1493 set_err(HECMW_IO_HEC_E0703, "");
1494 return -1;
1495 }
1496
1497 /* ',' */
1498 token = HECMW_heclex_next_token();
1499 if (token != ',') {
1500 set_err_token(token, HECMW_IO_HEC_E0700, "',' required after DOF");
1501 return -1;
1502 }
1503
1504 /* A */
1505 token = HECMW_heclex_next_token();
1506 if (token != HECMW_HECLEX_DOUBLE && token != HECMW_HECLEX_INT) {
1507 set_err_token(token, HECMW_IO_HEC_E0700, "A(coefficient) required ");
1508 return -1;
1509 }
1510 mpcitem[i].a = HECMW_heclex_get_number();
1511
1512 /* ',' or NL */
1513 token = HECMW_heclex_next_token();
1514 if (token != ',' && token != HECMW_HECLEX_NL) {
1515 set_err_token(token, HECMW_IO_HEC_E0700,
1516 "',' or NL required after coefficient");
1517 return -1;
1518 }
1519 if (token == ',' && i == NITEM - 1) {
1520 token = HECMW_heclex_next_token();
1521 if (token != HECMW_HECLEX_NL) {
1522 set_err_token(token, HECMW_IO_HEC_E0700, "NL required");
1523 return -1;
1524 }
1525 continue;
1526 }
1527 if (token == HECMW_HECLEX_NL) continue;
1528 }
1529
1530 /* add */
1531 if (isAllDof) {
1532 for (i = 0; i < neq; i++) {
1533 mpcitem[i].dof = 1;
1534 }
1535 if (HECMW_io_add_mpc(neq, mpcitem, cnst) == NULL) return -1;
1536 for (i = 0; i < neq; i++) {
1537 mpcitem[i].dof = 2;
1538 }
1539 if (HECMW_io_add_mpc(neq, mpcitem, cnst) == NULL) return -1;
1540 for (i = 0; i < neq; i++) {
1541 mpcitem[i].dof = 3;
1542 }
1543 if (HECMW_io_add_mpc(neq, mpcitem, cnst) == NULL) return -1;
1544
1545 } else {
1546 if (HECMW_io_add_mpc(neq, mpcitem, cnst) == NULL) return -1;
1547 }
1548 HECMW_free(mpcitem);
1549
1550 /* link */
1551 } else if (is_link == 1) {
1552 token = HECMW_heclex_next_token();
1553
1554 /* ',' */
1555 token = HECMW_heclex_next_token();
1556 if (token != ',') {
1557 set_err_token(token, HECMW_IO_HEC_E0700, "',' required after DOF");
1558 return -1;
1559 }
1560
1561 token = HECMW_heclex_next_token();
1562 if (token != HECMW_HECLEX_INT) {
1563 return -1;
1564 }
1565 mpcitem[0].node = HECMW_heclex_get_number();
1566 strcpy(mpcitem[0].ngrp, "");
1567 mpcitem[0].a = 1.0;
1568
1569 /* ',' */
1570 token = HECMW_heclex_next_token();
1571 if (token != ',') {
1572 set_err_token(token, HECMW_IO_HEC_E0700, "',' required after DOF");
1573 return -1;
1574 }
1575
1576 token = HECMW_heclex_next_token();
1577 if (token != HECMW_HECLEX_INT) {
1578 return -1;
1579 }
1580 mpcitem[1].node = HECMW_heclex_get_number();
1581 strcpy(mpcitem[1].ngrp, "");
1582 mpcitem[1].a = -1.0;
1583
1584 /* add 1 */
1585 mpcitem[0].dof = 1;
1586 mpcitem[1].dof = 1;
1587 if (HECMW_io_add_mpc(neq, mpcitem, cnst) == NULL) return -1;
1588 /* add 2 */
1589 mpcitem[0].dof = 2;
1590 mpcitem[1].dof = 2;
1591 if (HECMW_io_add_mpc(neq, mpcitem, cnst) == NULL) return -1;
1592 /* add 3 */
1593 mpcitem[0].dof = 3;
1594 mpcitem[1].dof = 3;
1595 if (HECMW_io_add_mpc(neq, mpcitem, cnst) == NULL) return -1;
1596 HECMW_free(mpcitem);
1597
1598 token = HECMW_heclex_next_token();
1599 if (token != HECMW_HECLEX_NL) {
1600 return -1;
1601 }
1602 }
1603
1604 return 0;
1605}
1606
1607static int read_equation(void) {
1608 int token, state;
1609 int neq = -1;
1610 double cnst = 0.0;
1611 int flag_input = 0; /* flag for INPUT */
1612 char *p;
1613 enum {
1614 ST_FINISHED,
1615 ST_HEADER_LINE,
1616 ST_HEADER_LINE_PARAM,
1617 ST_DATA_INCLUDE,
1618 ST_DATA_LINE1,
1619 ST_DATA_LINE2
1620 };
1621
1622 state = ST_HEADER_LINE;
1623 while (state != ST_FINISHED) {
1624 if (state == ST_HEADER_LINE) {
1625 if (read_equation_head(&token)) return -1;
1626 if (token == ',') {
1627 state = ST_HEADER_LINE_PARAM;
1628 } else if (token == HECMW_HECLEX_NL) {
1629 state = ST_DATA_LINE1;
1630 } else {
1631 HECMW_assert(0);
1632 }
1633 } else if (state == ST_HEADER_LINE_PARAM) {
1634 token = HECMW_heclex_next_token();
1635 if (token == HECMW_HECLEX_K_INPUT) {
1636 /* optional */
1637 if (read_input(HECMW_IO_HEC_E0700)) return -1;
1638 flag_input = 1;
1639 } else {
1640 set_err_token(token, HECMW_IO_HEC_E0700, "Unknown parameter");
1641 return -1;
1642 }
1643
1644 /* check next state */
1645 token = HECMW_heclex_next_token();
1646 if (token == HECMW_HECLEX_NL) {
1647 state = flag_input ? ST_DATA_INCLUDE : ST_DATA_LINE1;
1648 } else {
1649 set_err_token(token, HECMW_IO_HEC_E0700, "NL required");
1650 return -1;
1651 }
1652 } else if (state == ST_DATA_INCLUDE) {
1653 HECMW_assert(flag_input);
1654
1655 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
1656 state = ST_DATA_LINE1;
1657 } else if (state == ST_DATA_LINE1) {
1658 if (read_equation_data_line1(&neq, &cnst)) return -1;
1659 state = ST_DATA_LINE2;
1660 } else if (state == ST_DATA_LINE2) {
1661 HECMW_assert(neq != -1);
1662 if (read_equation_data_line2(neq, cnst)) return -1;
1663
1664 /* check next state */
1665 token = HECMW_heclex_next_token();
1666 if (token == HECMW_HECLEX_INT) {
1667 state = ST_DATA_LINE1;
1668 } else if (token == HECMW_HECLEX_NAME) {
1670 if (strcmp(p, "link") == 0 || strcmp(p, "LINK") == 0) {
1671 state = ST_DATA_LINE1;
1672 } else {
1673 state = ST_FINISHED;
1674 }
1675 } else {
1676 state = ST_FINISHED;
1677 }
1679 } else {
1680 HECMW_assert(0);
1681 }
1682 }
1683 HECMW_log(HECMW_LOG_DEBUG, "read_equation done");
1684 return 0;
1685}
1686
1687/*----------------------------------------------------------------------------*/
1688
1689static int read_header(void) {
1690 int token, len;
1691 char *p;
1692 struct hecmw_io_header *header;
1693
1694 header = HECMW_malloc(sizeof(struct hecmw_io_header));
1695 if (header == NULL) {
1696 HECMW_set_error(errno, "");
1697 return -1;
1698 }
1699
1700 /* !HEAER */
1701 token = HECMW_heclex_next_token();
1702 if (token != HECMW_HECLEX_H_HEADER) {
1703 set_err_token(token, HECMW_IO_HEC_E0800, "!HEADER required");
1704 return -1;
1705 }
1706
1707 /* get header data */
1708 token = HECMW_heclex_next_token();
1709 if (token != HECMW_HECLEX_HEADER) {
1710 set_err_token(token, HECMW_IO_HEC_E0800, "TITLE required after !HEADER");
1711 return -1;
1712 }
1714 while (*p && *p == ' ') p++;
1715 if (p == NULL) p = "";
1716 len = strlen(p);
1717 if (len > HECMW_HEADER_LEN) len = HECMW_HEADER_LEN;
1718 strncpy(header->header, p, len);
1719 header->header[len] = '\0';
1720
1721 /* Note:
1722 * NL is ignored by LEX until the end of the header data.
1723 */
1724
1725 /* Ignore the rest of the header data */
1727 ;
1729
1730 /* set */
1732
1733 HECMW_log(HECMW_LOG_DEBUG, "read_header done");
1734 return 0;
1735}
1736
1737/*----------------------------------------------------------------------------*/
1738
1739static int read_include(void) {
1740 int token;
1741
1742 /* !INCLUDE */
1743 token = HECMW_heclex_next_token();
1744 if (token != HECMW_HECLEX_H_INCLUDE) {
1745 set_err_token(token, HECMW_IO_HEC_E0900, "!INCLUDE required");
1746 return -1;
1747 }
1748
1749 /* ',' */
1750 token = HECMW_heclex_next_token();
1751 if (token != ',') {
1752 set_err_token(token, HECMW_IO_HEC_E0900, "',' required after !INCLUDE");
1753 return -1;
1754 }
1755
1756 /* INPUT */
1757 token = HECMW_heclex_next_token();
1758 if (token != HECMW_HECLEX_K_INPUT) {
1759 set_err_token(token, HECMW_IO_HEC_E0901, "");
1760 return -1;
1761 }
1762
1763 /* =filename */
1764 if (read_input(HECMW_IO_HEC_E0900)) return -1;
1765
1766 /* NL */
1767 token = HECMW_heclex_next_token();
1768 if (token != HECMW_HECLEX_NL) {
1769 set_err_token(token, HECMW_IO_HEC_E0900, "NL required after INPUT value");
1770 return -1;
1771 }
1772
1773 /* include */
1774 if (HECMW_heclex_switch_to_include(include_filename)) {
1775 return -1;
1776 }
1777
1778 HECMW_log(HECMW_LOG_DEBUG, "read_include done");
1779 return 0;
1780}
1781
1782/*----------------------------------------------------------------------------*/
1783
1784static int read_initial_head(void) {
1785 int token;
1786
1787 /* !INITIAL CONDITION */
1788 token = HECMW_heclex_next_token();
1789 if (token != HECMW_HECLEX_H_INITIAL) {
1790 set_err_token(token, HECMW_IO_HEC_E1000, "!INITIAL CONDITION required");
1791 return -1;
1792 }
1793
1794 token = HECMW_heclex_next_token();
1795 if (token != ',') {
1796 set_err_token(token, HECMW_IO_HEC_E1001, "");
1797 return -1;
1798 }
1799
1800 return 0;
1801}
1802
1803static int read_initial_param_type(int *type) {
1804 int token;
1805
1806 token = HECMW_heclex_next_token();
1807 if (token != '=') {
1808 set_err_token(token, HECMW_IO_HEC_E1000, "'=' reqired after TYPE");
1809 return -1;
1810 }
1811 token = HECMW_heclex_next_token();
1812 if (token != HECMW_HECLEX_K_TEMPERATURE) {
1813 set_err_token(token, HECMW_IO_HEC_E1000, "TEMPERATURE required");
1814 return -1;
1815 }
1817 return 0;
1818}
1819
1820static int read_initial_data(int type) {
1821 int node, token;
1822 char *ngrp;
1823 double val;
1824
1825 /* node or ngrp */
1826 node = -1;
1827 ngrp = NULL;
1828 token = HECMW_heclex_next_token();
1829 if (token == HECMW_HECLEX_INT) {
1830 node = HECMW_heclex_get_number();
1831 if (node <= 0) {
1832 set_err(HECMW_IO_HEC_E1002, "");
1833 return -1;
1834 }
1835 } else if (token == HECMW_HECLEX_NAME) {
1836 ngrp = HECMW_heclex_get_text();
1837 if (strlen(ngrp) > HECMW_NAME_LEN) {
1838 set_err(HECMW_IO_E0001, "");
1839 return -1;
1840 }
1841 HECMW_toupper(ngrp);
1842 ngrp = HECMW_strdup(ngrp);
1843 if (ngrp == NULL) {
1844 HECMW_set_error(errno, "");
1845 return -1;
1846 }
1847 } else {
1848 set_err_token(token, HECMW_IO_HEC_E1000, "Node ID or NGROUP name required");
1849 return -1;
1850 }
1851
1852 /* ',' */
1853 token = HECMW_heclex_next_token();
1854 if (token != ',') {
1855 set_err_token(token, HECMW_IO_HEC_E1000, "',' required after node");
1856 return -1;
1857 }
1858
1859 /* VAL */
1860 token = HECMW_heclex_next_token();
1861 if (token != HECMW_HECLEX_DOUBLE && token != HECMW_HECLEX_INT) {
1862 set_err_token(token, HECMW_IO_HEC_E1000, "VAL required");
1863 return -1;
1864 }
1866
1867 /* NL */
1868 token = HECMW_heclex_next_token();
1869 if (token != HECMW_HECLEX_NL) {
1870 set_err_token(token, HECMW_IO_HEC_E1000, "NL required after VAL");
1871 return -1;
1872 }
1873
1874 /* add */
1875 HECMW_assert(type != -1);
1876 if (HECMW_io_add_initial(type, node, ngrp, val) == NULL) {
1877 return -1;
1878 };
1879 HECMW_free(ngrp);
1880
1881 return 0;
1882}
1883
1884static int read_initial(void) {
1885 int token, state;
1886 int type = -1;
1887 int flag_type = 0; /* flag for TYPE */
1888 int flag_input = 0; /* flag for INPUT */
1889 enum {
1890 ST_FINISHED,
1891 ST_HEADER_LINE,
1892 ST_HEADER_LINE_PARAM,
1893 ST_DATA_INCLUDE,
1894 ST_DATA_LINE
1895 };
1896
1897 state = ST_HEADER_LINE;
1898 while (state != ST_FINISHED) {
1899 if (state == ST_HEADER_LINE) {
1900 if (read_initial_head()) return -1;
1901 state = ST_HEADER_LINE_PARAM;
1902 } else if (state == ST_HEADER_LINE_PARAM) {
1903 token = HECMW_heclex_next_token();
1904 if (token == HECMW_HECLEX_K_TYPE) {
1905 /* must */
1906 if (read_initial_param_type(&type)) return -1;
1907 flag_type = 1;
1908 } else if (token == HECMW_HECLEX_K_INPUT) {
1909 /* oprtional */
1910 if (read_input(HECMW_IO_HEC_E1000)) return -1;
1911 flag_input = 1;
1912 } else {
1913 set_err_token(token, HECMW_IO_HEC_E1000, "Unknown parameter");
1914 return -1;
1915 }
1916
1917 /* check next parameter */
1918 token = HECMW_heclex_next_token();
1919 if (token == HECMW_HECLEX_NL) {
1920 if (flag_input) {
1921 state = ST_DATA_INCLUDE;
1922 } else {
1923 state = ST_DATA_LINE;
1924 }
1925 /* check */
1926 if (!flag_type) {
1927 set_err(HECMW_IO_HEC_E1001, "");
1928 return -1;
1929 }
1930 } else if (token == ',') {
1931 ; /* continue this state */
1932 } else {
1933 set_err_token(token, HECMW_IO_HEC_E1000, "Unknown parameter");
1934 return -1;
1935 }
1936 } else if (state == ST_DATA_INCLUDE) {
1937 HECMW_assert(flag_input);
1938 HECMW_assert(flag_type);
1939 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
1940 state = ST_DATA_LINE;
1941 } else if (state == ST_DATA_LINE) {
1942 HECMW_assert(flag_type);
1943 if (read_initial_data(type)) return -1;
1944
1945 /* check next state */
1946 token = HECMW_heclex_next_token();
1947 if (token != HECMW_HECLEX_INT && token != HECMW_HECLEX_NAME) {
1948 state = ST_FINISHED;
1949 }
1951 } else {
1952 HECMW_assert(0);
1953 }
1954 }
1955 HECMW_log(HECMW_LOG_DEBUG, "read_initial done");
1956 return 0;
1957}
1958
1959/*----------------------------------------------------------------------------*/
1960
1961static int read_matitem_head(int *item, int *last_token) {
1962 int token;
1963
1964 /* !ITEM */
1965 token = HECMW_heclex_next_token();
1966 if (token != HECMW_HECLEX_H_ITEM) {
1967 set_err_token(token, HECMW_IO_HEC_E1100, "!ITEM required");
1968 return -1;
1969 }
1970
1971 /* '=' */
1972 token = HECMW_heclex_next_token();
1973 if (token != '=') {
1974 set_err_token(token, HECMW_IO_HEC_E1100, "'=' required after !ITEM");
1975 return -1;
1976 }
1977
1978 /* ITEM */
1979 token = HECMW_heclex_next_token();
1980 if (token != HECMW_HECLEX_INT) {
1981 set_err_token(token, HECMW_IO_HEC_E1100, "requied !ITEM value");
1982 return -1;
1983 }
1984 *item = HECMW_heclex_get_number();
1985 if (*item <= 0) {
1986 set_err(HECMW_IO_HEC_E1104, "");
1987 return -1;
1988 }
1989
1990 /* ',' or NL */
1991 token = HECMW_heclex_next_token();
1992 if (token != ',' && token != HECMW_HECLEX_NL) {
1993 set_err_token(token, HECMW_IO_HEC_E1100, "',' or NL after !ITEM value");
1994 return -1;
1995 }
1996 *last_token = token;
1997
1998 return 0;
1999}
2000
2001static int read_matitem_param_subitem(int *subitem) {
2002 int token;
2003
2004 /* optional */
2005 token = HECMW_heclex_next_token();
2006 if (token != '=') {
2007 set_err_token(token, HECMW_IO_HEC_E1100, "'=' required after SUBITEM");
2008 return -1;
2009 }
2010 token = HECMW_heclex_next_token();
2011 if (token != HECMW_HECLEX_INT) {
2012 set_err_token(token, HECMW_IO_HEC_E1100, "SUBITEM value required");
2013 return -1;
2014 }
2015 *subitem = HECMW_heclex_get_number();
2016 if (*subitem <= 0) {
2017 set_err(HECMW_IO_HEC_E1106, "");
2018 return -1;
2019 }
2020 return 0;
2021}
2022
2023static int read_matitem_data(int subitem, int depend_temp,
2024 struct hecmw_io_matitem *matitem) {
2025 int i, token;
2026 double *val;
2027 double temp = 0.0;
2028 struct hecmw_io_matsubitem *p, *q, *msitem;
2029
2030 msitem = HECMW_malloc(sizeof(*msitem));
2031 if (msitem == NULL) {
2032 HECMW_set_error(errno, "");
2033 return -1;
2034 }
2035
2036 val = HECMW_malloc(sizeof(*val) * subitem);
2037 if (val == NULL) {
2038 HECMW_set_error(errno, "");
2039 return -1;
2040 }
2041
2042 for (i = 0; i < subitem; i++) {
2043 val[i] = 0.0; /* default value */
2044 }
2045
2046 for (i = 0; i < subitem; i++) {
2047 /* VAL */
2048 token = HECMW_heclex_next_token();
2049 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
2050 val[i] = HECMW_heclex_get_number();
2051 } else if (token == ',') {
2053 } else if (token == HECMW_HECLEX_NL) {
2054 break;
2055 } else {
2056 set_err_token(token, HECMW_IO_HEC_E1100, "VAL or ',' or NL reuqired");
2057 return -1;
2058 }
2059
2060 /* ',' or NL*/
2061 token = HECMW_heclex_next_token();
2062 if (token != ',' && token != HECMW_HECLEX_NL) {
2063 set_err_token(token, HECMW_IO_HEC_E1100, "',' or NL required after VAL");
2064 return -1;
2065 }
2066 if (token == HECMW_HECLEX_NL) break;
2067 }
2068
2069 if (token != HECMW_HECLEX_NL) {
2070 /* TEMP or NL */
2071 token = HECMW_heclex_next_token();
2072 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
2073 temp = HECMW_heclex_get_number();
2074 } else if (token == HECMW_HECLEX_NL) {
2075 ;
2076 } else {
2077 set_err_token(token, HECMW_IO_HEC_E1100, "Temperature or NL required");
2078 return -1;
2079 }
2080 }
2081
2082 if (depend_temp) {
2083 /* previous TEMP */
2084 q = NULL;
2085 for (p = matitem->subitem; p; p = (q = p)->next)
2086 ;
2087 if (q && temp <= q->temp) {
2088 set_err(HECMW_IO_HEC_E1107, "");
2089 return -1;
2090 }
2091 }
2092
2093 if (token != HECMW_HECLEX_NL) {
2094 /* NL */
2095 token = HECMW_heclex_next_token();
2096 if (token != HECMW_HECLEX_NL) {
2097 set_err_token(token, HECMW_IO_HEC_E1100, "NL required");
2098 return -1;
2099 }
2100 }
2101
2102 /* set */
2103 msitem->val = val;
2104 msitem->temp = temp;
2105 msitem->next = NULL;
2106
2107 q = NULL;
2108 for (p = matitem->subitem; p; p = (q = p)->next)
2109 ;
2110 if (q == NULL) {
2111 matitem->subitem = msitem;
2112 } else {
2113 q->next = msitem;
2114 }
2115
2116 return 0;
2117}
2118
2119static int read_matitem(struct hecmw_io_matitem *matitem) {
2120 int token, state;
2121 int item = -1;
2122 int subitem = 1;
2123 int flag_item = 0; /* flag for !ITEM */
2124 int flag_subitem = 0; /* flag for SUBITEM */
2125 int depend_temp = 0;
2126 enum {
2127 ST_FINISHED,
2128 ST_HEADER_LINE,
2129 ST_HEADER_LINE_PARAM,
2130 ST_PREPARE,
2131 ST_DATA_LINE
2132 };
2133
2134 HECMW_assert(matitem);
2135
2136 state = ST_HEADER_LINE;
2137 while (state != ST_FINISHED) {
2138 if (state == ST_HEADER_LINE) {
2139 if (read_matitem_head(&item, &token)) return -1;
2140 if (token == ',') {
2141 state = ST_HEADER_LINE_PARAM;
2142 } else if (token == HECMW_HECLEX_NL) {
2143 state = ST_PREPARE;
2144 }
2145 flag_item = 1;
2146 } else if (state == ST_HEADER_LINE_PARAM) {
2147 token = HECMW_heclex_next_token();
2148 if (token == HECMW_HECLEX_K_SUBITEM) {
2149 if (read_matitem_param_subitem(&subitem)) return -1;
2150 flag_subitem = 1;
2151 } else {
2152 set_err_token(token, HECMW_IO_HEC_E1100, "Unknown parameter");
2153 return -1;
2154 }
2155
2156 /* NL */
2157 token = HECMW_heclex_next_token();
2158 if (token != HECMW_HECLEX_NL) {
2159 set_err_token(token, HECMW_IO_HEC_E1100, "NL required after SUBITEM");
2160 return -1;
2161 }
2162
2163 /* set next state */
2164 state = ST_PREPARE;
2165 } else if (state == ST_PREPARE) {
2166 HECMW_assert(flag_item);
2167 HECMW_assert(item > 0);
2168 HECMW_assert(subitem > 0);
2169
2170 matitem->item = item;
2171 matitem->nval = subitem;
2172 matitem->subitem = NULL;
2173
2174 depend_temp = 0;
2175
2176 /* set next state */
2177 state = ST_DATA_LINE;
2178 } else if (state == ST_DATA_LINE) {
2179 HECMW_assert(flag_item);
2180 HECMW_assert(item > 0);
2181 HECMW_assert(subitem > 0);
2182
2183 if (read_matitem_data(subitem, depend_temp, matitem)) return -1;
2184 depend_temp = 1;
2185
2186 /* check next state */
2187 token = HECMW_heclex_next_token();
2188 if (token != HECMW_HECLEX_DOUBLE && token != HECMW_HECLEX_INT) {
2189 state = ST_FINISHED;
2190 }
2192 } else {
2193 HECMW_assert(0);
2194 }
2195 }
2196 return 0;
2197}
2198
2199static int read_material_head(void) {
2200 int token;
2201
2202 /* !MATERIAL */
2203 token = HECMW_heclex_next_token();
2204 if (token != HECMW_HECLEX_H_MATERIAL) {
2205 set_err_token(token, HECMW_IO_HEC_E1100, "!MATERIAL required");
2206 return -1;
2207 }
2208
2209 token = HECMW_heclex_next_token();
2210 if (token != ',') {
2211 set_err_token(token, HECMW_IO_HEC_E1101, "");
2212 return -1;
2213 }
2214
2215 return 0;
2216}
2217
2218static int read_material_param_name(char *name) {
2219 int token;
2220 char *p;
2221
2222 token = HECMW_heclex_next_token();
2223 if (token != '=') {
2224 set_err_token(token, HECMW_IO_HEC_E1100, "'=' required after NAME");
2225 return -1;
2226 }
2227 token = HECMW_heclex_next_token();
2228 if (token != HECMW_HECLEX_NAME) {
2229 set_err_token(token, HECMW_IO_HEC_E1100,
2230 "NAME must begin with a letter or '_'");
2231 return -1;
2232 }
2234 if (strlen(p) > HECMW_NAME_LEN) {
2235 set_err(HECMW_IO_E0001, "");
2236 return -1;
2237 }
2238 strcpy(name, p);
2239 HECMW_toupper(name);
2240 if (HECMW_io_is_reserved_name(name)) {
2241 set_err(HECMW_IO_E0003, "");
2242 return -1;
2243 }
2244 if (HECMW_io_get_mat(name)) {
2245 set_err(HECMW_IO_HEC_E1102, "%s alredy exists", name);
2246 return -1;
2247 }
2248 return 0;
2249}
2250
2251static int read_material_param_item(int *item) {
2252 int token;
2253
2254 token = HECMW_heclex_next_token();
2255 if (token != '=') {
2256 set_err_token(token, HECMW_IO_HEC_E1100, "'=' required after ITEM");
2257 return -1;
2258 }
2259 token = HECMW_heclex_next_token();
2260 if (token != HECMW_HECLEX_INT) {
2261 set_err_token(token, HECMW_IO_HEC_E1100, "Invalid ITEM");
2262 return -1;
2263 }
2264 *item = HECMW_heclex_get_number();
2265 if (*item <= 0) {
2266 set_err(HECMW_IO_HEC_E1103, "");
2267 return -1;
2268 }
2269 return 0;
2270}
2271
2272static int matitem_comp(const void *matitem1, const void *matitem2) {
2273 const struct hecmw_io_matitem *m1, *m2;
2274
2275 m1 = matitem1;
2276 m2 = matitem2;
2277
2278 if (m1->item == m2->item) return 0;
2279 if (m1->item < m2->item) {
2280 return -1;
2281 } else {
2282 return 1;
2283 }
2284}
2285
2286static int read_material_data(int item, char *name) {
2287 int i;
2288 struct hecmw_io_material *mat;
2289 struct hecmw_io_matitem *matitem;
2290
2291 mat = HECMW_malloc(sizeof(*mat));
2292 if (mat == NULL) {
2293 HECMW_set_error(errno, "");
2294 return -1;
2295 }
2296
2297 matitem = HECMW_malloc(sizeof(*matitem) * item);
2298 if (matitem == NULL) {
2299 HECMW_set_error(errno, "");
2300 return -1;
2301 }
2302
2303 for (i = 0; i < item; i++) {
2304 if (read_matitem(&matitem[i])) return -1;
2305 }
2306
2307 /* sort */
2308 qsort(matitem, item, sizeof(*matitem), matitem_comp);
2309
2310 /* check !ITEM value */
2311 for (i = 0; i < item; i++) {
2312 if (matitem[i].item != i + 1) {
2313 HECMW_set_error(HECMW_IO_HEC_E1105, "In MATERIAL %s", name);
2314 return -1;
2315 }
2316 }
2317
2318 /* set */
2319 strcpy(mat->name, name);
2320 mat->nitem = item;
2321 mat->item = matitem;
2322 mat->next = NULL;
2323
2324 /* add */
2325 if (HECMW_io_add_mat(name, mat) == NULL) return -1;
2326
2327 return 0;
2328}
2329
2330static int read_material(void) {
2331 int token, state;
2332 int item = 1;
2333 int flag_name = 0; /* flag for NAME */
2334 int flag_item = 0; /* flag for ITEM */
2335 int flag_input = 0; /* flag for INPUT */
2336 char name[HECMW_NAME_LEN + 1] = "";
2337 enum {
2338 ST_FINISHED,
2339 ST_HEADER_LINE,
2340 ST_HEADER_LINE_PARAM,
2341 ST_DATA_INCLUDE,
2342 ST_DATA_LINE
2343 };
2344
2345 state = ST_HEADER_LINE;
2346 while (state != ST_FINISHED) {
2347 if (state == ST_HEADER_LINE) {
2348 if (read_material_head()) return -1;
2349 state = ST_HEADER_LINE_PARAM;
2350 } else if (state == ST_HEADER_LINE_PARAM) {
2351 token = HECMW_heclex_next_token();
2352 if (token == HECMW_HECLEX_K_NAME) {
2353 /* must */
2354 if (read_material_param_name(name)) return -1;
2355 flag_name = 1;
2356 } else if (token == HECMW_HECLEX_K_ITEM) {
2357 /* optioanal */
2358 if (read_material_param_item(&item)) return -1;
2359 flag_item = 1;
2360 } else if (token == HECMW_HECLEX_K_INPUT) {
2361 /* oprtional */
2362 if (read_input(HECMW_IO_HEC_E1100)) return -1;
2363 flag_input = 1;
2364 } else {
2365 set_err_token(token, HECMW_IO_HEC_E1100, "Unknown parameter");
2366 return -1;
2367 }
2368
2369 /* check next parameter */
2370 token = HECMW_heclex_next_token();
2371 if (token == HECMW_HECLEX_NL) {
2372 /* check */
2373 if (!flag_name) {
2374 set_err(HECMW_IO_HEC_E1101, "");
2375 return -1;
2376 }
2377 state = flag_input ? ST_DATA_INCLUDE : ST_DATA_LINE;
2378 } else if (token == ',') {
2379 ; /* continue this state */
2380 } else {
2381 set_err_token(token, HECMW_IO_HEC_E1100, "Unknown parameter");
2382 return -1;
2383 }
2384 } else if (state == ST_DATA_INCLUDE) {
2385 HECMW_assert(flag_input);
2386 HECMW_assert(flag_name);
2387 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
2388 state = ST_DATA_LINE;
2389 } else if (state == ST_DATA_LINE) {
2390 HECMW_assert(flag_name);
2391 if (read_material_data(item, name)) return -1;
2392 state = ST_FINISHED;
2393 } else {
2394 HECMW_assert(0);
2395 }
2396 }
2397 HECMW_log(HECMW_LOG_DEBUG, "read_material done");
2398 return 0;
2399}
2400
2401/*----------------------------------------------------------------------------*/
2402#if 0
2403static int
2404read_ncopy(void)
2405{
2406 fprintf(stderr, "!NCOPY has not implemented yet\n");
2408 return 0;
2409}
2410
2411
2412static int
2413read_nfill(void)
2414{
2415 fprintf(stderr, "!NFILL has not implemented yet\n");
2417 return 0;
2418}
2419
2420
2421static int
2422read_ngen(void)
2423{
2424 fprintf(stderr, "!NGEN has not implemented yet\n");
2426 return 0;
2427}
2428#endif
2429
2430/*----------------------------------------------------------------------------*/
2431
2432static int read_ngrp_head(void) {
2433 int token;
2434
2435 /* !NGROUP */
2436 token = HECMW_heclex_next_token();
2437 if (token != HECMW_HECLEX_H_NGROUP) {
2438 set_err_token(token, HECMW_IO_HEC_E1500, "!NGROUP required");
2439 return -1;
2440 }
2441
2442 token = HECMW_heclex_next_token();
2443 if (token != ',') {
2444 set_err_token(token, HECMW_IO_HEC_E1500, "',' required after !NGROUP");
2445 return -1;
2446 }
2447
2448 return 0;
2449}
2450
2451static int read_ngrp_param_ngrp(char *ngrp) {
2452 int token;
2453 char *p;
2454
2455 token = HECMW_heclex_next_token();
2456 if (token != '=') {
2457 set_err_token(token, HECMW_IO_HEC_E1500, "'=' required after NGRP");
2458 return -1;
2459 }
2460 token = HECMW_heclex_next_token();
2461 if (token != HECMW_HECLEX_NAME) {
2462 set_err_token(token, HECMW_IO_HEC_E1500,
2463 "NGRP must begin with a letter or '_'");
2464 return -1;
2465 }
2467 if (strlen(p) > HECMW_NAME_LEN) {
2468 set_err(HECMW_IO_E0001, "");
2469 return -1;
2470 }
2471 strcpy(ngrp, p);
2472 HECMW_toupper(ngrp);
2473 if (HECMW_io_is_reserved_name(ngrp)) {
2474 set_err(HECMW_IO_E0003, "");
2475 return -1;
2476 }
2477 if (strcmp(ngrp, "EQUATION_BLOCK") == 0) {
2478 HECMW_set_error(HECMW_IO_E0003, "Reserved name: %s", ngrp);
2479 return -1;
2480 }
2481 if (strcmp(ngrp, "ALL") == 0) {
2482 HECMW_set_error(HECMW_IO_E0003, "Reserved name: %s", ngrp);
2483 return -1;
2484 }
2485 return 0;
2486}
2487
2488static int read_ngrp_data(char *ngrp) {
2489 int i, n, *node, token;
2490 struct hecmw_io_id *head, *prev, *p, *q;
2491
2492 n = 0;
2493 prev = NULL;
2494 head = NULL;
2495 while (1) {
2496 struct hecmw_io_id *id;
2497
2498 token = HECMW_heclex_next_token();
2499 if (n != 0 && token == HECMW_HECLEX_NL) break;
2500
2501 id = HECMW_malloc(sizeof(*id));
2502 if (id == NULL) {
2503 HECMW_set_error(errno, "");
2504 return -1;
2505 }
2506
2507 /* nodX */
2508 if (token != HECMW_HECLEX_INT) {
2509 set_err_token(token, HECMW_IO_HEC_E1500, "Node ID required");
2510 return -1;
2511 }
2512 id->id = HECMW_heclex_get_number();
2513 id->next = NULL;
2514 if (head == NULL) {
2515 head = id;
2516 } else {
2517 prev->next = id;
2518 }
2519 prev = id;
2520 n++;
2521
2522 /* ',' or NL */
2523 token = HECMW_heclex_next_token();
2524 if (token != ',' && token != HECMW_HECLEX_NL) {
2525 set_err_token(token, HECMW_IO_HEC_E1500,
2526 "',' or NL required after node ID");
2527 return -1;
2528 }
2529 if (token == HECMW_HECLEX_NL) break;
2530 }
2532 HECMW_assert(n > 0);
2533
2534 /* add node to group */
2535 node = HECMW_malloc(sizeof(*node) * n);
2536 if (node == NULL) {
2537 HECMW_set_error(errno, "");
2538 return -1;
2539 }
2540 i = 0;
2541 p = head;
2542 while (p) {
2543 node[i++] = p->id;
2544 q = p;
2545 p = p->next;
2546 HECMW_free(q);
2547 }
2548 if (HECMW_io_add_ngrp(ngrp, n, node) < 0) return -1;
2549 HECMW_free(node);
2550
2551 return 0;
2552}
2553
2554static int read_ngrp_generate(char *ngrp) {
2555 int i, n, id, *node, token;
2556 int nod1, nod2, nod3;
2557
2558 while (1) {
2559 /* nod1 */
2560 token = HECMW_heclex_next_token();
2561 if (token != HECMW_HECLEX_INT) {
2562 set_err_token(token, HECMW_IO_HEC_E1500, "nod1 required");
2563 return -1;
2564 }
2565 nod1 = HECMW_heclex_get_number();
2566 if (nod1 <= 0) {
2567 set_err(HECMW_IO_HEC_E1502, "");
2568 return -1;
2569 }
2570
2571 /* ',' */
2572 token = HECMW_heclex_next_token();
2573 if (token != ',') {
2574 set_err_token(token, HECMW_IO_HEC_E1500, "',' required after nod1");
2575 return -1;
2576 }
2577
2578 /* nod2 */
2579 token = HECMW_heclex_next_token();
2580 if (token != HECMW_HECLEX_INT) {
2581 set_err_token(token, HECMW_IO_HEC_E1500, "nod2 requird");
2582 return -1;
2583 }
2584 nod2 = HECMW_heclex_get_number();
2585 if (nod2 <= 0) {
2586 set_err(HECMW_IO_HEC_E1502, "");
2587 return -1;
2588 }
2589
2590 /* ',' or NL */
2591 token = HECMW_heclex_next_token();
2592 if (token == ',') {
2593 /* nod3 */
2594 token = HECMW_heclex_next_token();
2595 if (token != HECMW_HECLEX_INT) {
2596 set_err_token(token, HECMW_IO_HEC_E1500, "Increment required");
2597 return -1;
2598 }
2599 nod3 = HECMW_heclex_get_number();
2600 if (nod3 <= 0) {
2601 set_err(HECMW_IO_HEC_E1502, "");
2602 return -1;
2603 }
2604
2605 /* NL */
2606 token = HECMW_heclex_next_token();
2607 if (token != HECMW_HECLEX_NL) {
2608 set_err_token(token, HECMW_IO_HEC_E1500, "NL required after increment");
2609 return -1;
2610 }
2611 } else if (token == HECMW_HECLEX_NL) {
2612 nod3 = 1;
2613 } else {
2614 set_err_token(token, HECMW_IO_HEC_E1500, "',' or NL required after nod2");
2615 return -1;
2616 }
2617 HECMW_assert(token == HECMW_HECLEX_NL);
2618
2619 /* make node */
2620 if (nod1 > nod2) {
2621 set_err(HECMW_IO_HEC_E1503,
2622 "Cannot generate between %d and %d with an increment of %d", nod1,
2623 nod2, nod3);
2624 return -1;
2625 }
2626 if ((nod2 - nod1) % nod3) {
2627 set_err(HECMW_IO_HEC_E1503,
2628 "Cannot generate between %d and %d with an increment of %d", nod1,
2629 nod2, nod3);
2630 return -1;
2631 }
2632
2633 n = (nod2 - nod1) / nod3 + 1;
2634 node = HECMW_malloc(sizeof(int) * n);
2635 if (node == NULL) {
2636 HECMW_set_error(errno, "");
2637 return -1;
2638 }
2639
2640 i = 0;
2641 for (id = nod1; id <= nod2; id += nod3) {
2642 node[i++] = id;
2643 }
2644 HECMW_assert(i == n);
2645 if (HECMW_io_add_ngrp(ngrp, n, node) < 0) return -1;
2646 HECMW_free(node);
2647
2648 /* check next state */
2649 token = HECMW_heclex_next_token();
2650 if (token != HECMW_HECLEX_INT) {
2652 break;
2653 }
2655 }
2656 return 0;
2657}
2658
2659static int read_ngroup(void) {
2660 int token, state;
2661 int flag_ngrp = 0; /* flag for NGRP */
2662 int flag_generate = 0; /* flag for GENERATE */
2663 int flag_input = 0; /* flag for INPUT */
2664 char ngrp[HECMW_NAME_LEN + 1] = "";
2665 enum {
2666 st_finished,
2667 st_header_line,
2668 st_header_line_param,
2669 st_data_include,
2670 st_data_line,
2671 st_data_line_generate
2672 };
2673
2674 state = st_header_line;
2675 while (state != st_finished) {
2676 if (state == st_header_line) {
2677 if (read_ngrp_head()) return -1;
2678 state = st_header_line_param;
2679 } else if (state == st_header_line_param) {
2680 token = HECMW_heclex_next_token();
2681 if (token == HECMW_HECLEX_K_NGRP) {
2682 /* must */
2683 if (read_ngrp_param_ngrp(ngrp)) return -1;
2684 flag_ngrp = 1;
2685 } else if (token == HECMW_HECLEX_K_GENERATE) {
2686 /* oprtional */
2687 flag_generate = 1;
2688 } else if (token == HECMW_HECLEX_K_INPUT) {
2689 /* oprtional */
2690 if (read_input(HECMW_IO_HEC_E1500)) return -1;
2691 flag_input = 1;
2692 } else {
2693 set_err_token(token, HECMW_IO_HEC_E1500, "Unknown parameter");
2694 return -1;
2695 }
2696
2697 /* check next parameter */
2698 token = HECMW_heclex_next_token();
2699 if (token == HECMW_HECLEX_NL) {
2700 if (flag_input) {
2701 state = st_data_include;
2702 } else if (flag_generate) {
2703 state = st_data_line_generate;
2704 } else {
2705 state = st_data_line;
2706 }
2707 /* check */
2708 if (!flag_ngrp) {
2709 set_err(HECMW_IO_HEC_E1501, "");
2710 return -1;
2711 }
2712 } else if (token == ',') {
2713 ; /* continue this state */
2714 } else {
2715 set_err_token(token, HECMW_IO_HEC_E1500, "Unknown parameter");
2716 return -1;
2717 }
2718 } else if (state == st_data_include) {
2719 HECMW_assert(flag_input);
2720 HECMW_assert(flag_ngrp);
2721 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
2722 state = flag_generate ? st_data_line_generate : st_data_line;
2723 } else if (state == st_data_line) {
2724 HECMW_assert(flag_ngrp);
2725 if (read_ngrp_data(ngrp)) return -1;
2726
2727 /* check next state */
2728 token = HECMW_heclex_next_token();
2729 if (token != HECMW_HECLEX_INT) {
2730 state = st_finished;
2731 }
2733 } else if (state == st_data_line_generate) {
2734 HECMW_assert(flag_generate);
2735 HECMW_assert(flag_ngrp);
2736 if (read_ngrp_generate(ngrp)) return -1;
2737 state = st_finished;
2738 } else {
2739 HECMW_assert(0);
2740 }
2741 }
2742 HECMW_log(HECMW_LOG_DEBUG, "read_ngroup done");
2743 return 0;
2744}
2745
2746/*----------------------------------------------------------------------------*/
2747
2748static int read_node_head(int *last_token) {
2749 int token;
2750
2751 /* !NODE */
2752 token = HECMW_heclex_next_token();
2753 if (token != HECMW_HECLEX_H_NODE) {
2754 set_err_token(token, HECMW_IO_HEC_E1600, "!NODE required");
2755 return -1;
2756 }
2757
2758 token = HECMW_heclex_next_token();
2759 if (token != ',' && token != HECMW_HECLEX_NL) {
2760 set_err_token(token, HECMW_IO_HEC_E1600, "',' or NL required after !NODE");
2761 return -1;
2762 }
2763 *last_token = token;
2764
2765 return 0;
2766}
2767
2768static int read_node_param_system(int *system) {
2769 int token;
2770
2771 token = HECMW_heclex_next_token();
2772 if (token != '=') {
2773 set_err_token(token, HECMW_IO_HEC_E1600, "'=' required after SYSTEM");
2774 return -1;
2775 }
2776 token = HECMW_heclex_next_token();
2777 if (token != 'C' && token != 'R') {
2778 set_err_token(token, HECMW_IO_HEC_E1600, "Invalid SYSTEM");
2779 return -1;
2780 }
2781 *system = token;
2782 return 0;
2783}
2784
2785static int read_node_param_ngrp(char *ngrp) {
2786 int token;
2787 char *p;
2788
2789 token = HECMW_heclex_next_token();
2790 if (token != '=') {
2791 set_err_token(token, HECMW_IO_HEC_E1600, "'=' required after NGRP");
2792 return -1;
2793 }
2794 token = HECMW_heclex_next_token();
2795 if (token != HECMW_HECLEX_NAME) {
2796 set_err_token(token, HECMW_IO_HEC_E1600,
2797 "NGRP must begin with a letter or '_'");
2798 return -1;
2799 }
2801 if (strlen(p) > HECMW_NAME_LEN) {
2802 set_err(HECMW_IO_E0001, "");
2803 return -1;
2804 }
2805 strcpy(ngrp, p);
2806 HECMW_toupper(ngrp);
2807 if (HECMW_io_is_reserved_name(ngrp)) {
2808 set_err(HECMW_IO_E0003, "");
2809 return -1;
2810 }
2811 if (strcmp(ngrp, "ALL") == 0) {
2812 HECMW_set_error(HECMW_IO_E0003, "Reserved name: %s", ngrp);
2813 return -1;
2814 }
2815 return 0;
2816}
2817
2818static int read_node_data(int *id_arg, double *x_arg, double *y_arg,
2819 double *z_arg) {
2820 int id, token;
2821 double x, y, z;
2822
2823 /* node ID */
2824 token = HECMW_heclex_next_token();
2825 if (token == HECMW_HECLEX_INT) {
2827 if (id <= 0) {
2828 set_err(HECMW_IO_HEC_E1601, "");
2829 return -1;
2830 }
2831 } else {
2832 set_err(HECMW_IO_HEC_E1601, "");
2833 return -1;
2834 }
2835
2836 /* ',' */
2837 token = HECMW_heclex_next_token();
2838 if (token != ',') {
2839 set_err_token(token, HECMW_IO_HEC_E1600, "',' required after nood ID");
2840 return -1;
2841 }
2842
2843 x = y = z = 0.0;
2844 while (1) {
2845 /* X */
2846 token = HECMW_heclex_next_token();
2847 if (token == HECMW_HECLEX_NL) break;
2848 if (token == ',') {
2850 } else if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
2852 } else {
2853 set_err_token(token, HECMW_IO_HEC_E1600, "X required");
2854 return -1;
2855 }
2856
2857 /* ',' */
2858 token = HECMW_heclex_next_token();
2859 if (token == HECMW_HECLEX_NL) break;
2860 if (token != ',') {
2861 set_err_token(token, HECMW_IO_HEC_E1600, "',' required after X");
2862 return -1;
2863 }
2864
2865 /* Y */
2866 token = HECMW_heclex_next_token();
2867 if (token == HECMW_HECLEX_NL) break;
2868 if (token == ',') {
2870 } else if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
2872 } else {
2873 set_err_token(token, HECMW_IO_HEC_E1600, "Y required");
2874 return -1;
2875 }
2876
2877 /* ',' */
2878 token = HECMW_heclex_next_token();
2879 if (token == HECMW_HECLEX_NL) break;
2880 if (token != ',') {
2881 set_err_token(token, HECMW_IO_HEC_E1600, "',' required after Y");
2882 return -1;
2883 }
2884
2885 /* Z */
2886 token = HECMW_heclex_next_token();
2887 if (token == HECMW_HECLEX_NL) break;
2888 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
2890 } else {
2891 set_err_token(token, HECMW_IO_HEC_E1600, "Z required");
2892 return -1;
2893 }
2894
2895 /* ',' or NL */
2896 token = HECMW_heclex_next_token();
2897 if (token == HECMW_HECLEX_NL) break;
2898 if (token == ',') {
2899 token = HECMW_heclex_next_token();
2900 if (token != HECMW_HECLEX_NL) {
2901 set_err_token(token, HECMW_IO_HEC_E1600, "NL required after Z");
2902 return -1;
2903 }
2904 }
2905
2906 break;
2907 }
2908
2909 *id_arg = id;
2910 *x_arg = x;
2911 *y_arg = y;
2912 *z_arg = z;
2913
2914 return 0;
2915}
2916
2917static int read_node_convert_coord(int system, double *x, double *y,
2918 double *z) {
2919 struct hecmw_coord coord, result;
2920
2921 /* prepare */
2922 coord.x = *x;
2923 coord.y = *y;
2924 coord.z = *z;
2925
2926 /* reflect parameter SYSTEM */
2927 if (system == 'C') {
2928 coord.y = HECMW_degree_to_radian(coord.y);
2929 if (HECMW_cylindrical_to_cartesian(&coord, &result)) {
2930 HECMW_assert(0);
2931 }
2932 coord = result;
2933 }
2934
2935 /* reflect !SYSTEM */
2936 if (HECMW_system(HECMW_io_get_system(), &coord, &result)) {
2937 HECMW_assert(0);
2938 }
2939
2940 *x = result.x;
2941 *y = result.y;
2942 *z = result.z;
2943
2944 return 0;
2945}
2946
2947static int read_node(void) {
2948 int token, state;
2949 int system = 'R'; /* C:cylindrical coordinates, R:cartesian coordinates */
2950 int flag_system = 0; /* flag for SYSTEM */
2951 int flag_ngrp = 0; /* flag for NGRP */
2952 int flag_input = 0; /* flag for INPUT */
2953 char ngrp[HECMW_NAME_LEN + 1] = "";
2954 enum {
2955 ST_FINISHED,
2956 ST_HEADER_LINE,
2957 ST_HEADER_LINE_PARAM,
2958 ST_DATA_INCLUDE,
2959 ST_DATA_LINE
2960 };
2961
2962 state = ST_HEADER_LINE;
2963 while (state != ST_FINISHED) {
2964 if (state == ST_HEADER_LINE) {
2965 if (read_node_head(&token)) return -1;
2966 if (token == HECMW_HECLEX_NL) {
2967 state = ST_DATA_LINE;
2968 } else if (token == ',') {
2969 state = ST_HEADER_LINE_PARAM;
2970 } else {
2971 HECMW_assert(0);
2972 }
2973 } else if (state == ST_HEADER_LINE_PARAM) {
2974 token = HECMW_heclex_next_token();
2975 if (token == HECMW_HECLEX_K_SYSTEM) {
2976 /* optional */
2977 if (read_node_param_system(&system)) return -1;
2978 flag_system = 1;
2979 } else if (token == HECMW_HECLEX_K_NGRP) {
2980 /* optional */
2981 if (read_node_param_ngrp(ngrp)) return -1;
2982 flag_ngrp = 1;
2983 } else if (token == HECMW_HECLEX_K_INPUT) {
2984 /* optional */
2985 if (read_input(HECMW_IO_HEC_E1600)) return -1;
2986 flag_input = 1;
2987 } else {
2988 set_err_token(token, HECMW_IO_HEC_E1600, "Unknown parameter");
2989 return -1;
2990 }
2991
2992 /* check next parameter */
2993 token = HECMW_heclex_next_token();
2994 if (token == HECMW_HECLEX_NL) {
2995 state = flag_input ? ST_DATA_INCLUDE : ST_DATA_LINE;
2996 } else if (token == ',') {
2997 ; /* continue this state */
2998 } else {
2999 set_err_token(token, HECMW_IO_HEC_E1600, "Unknown parameter");
3000 return -1;
3001 }
3002 } else if (state == ST_DATA_INCLUDE) {
3003 HECMW_assert(flag_input);
3004 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
3005 state = ST_DATA_LINE;
3006 } else if (state == ST_DATA_LINE) {
3007 int id;
3008 double x, y, z;
3009
3010 if (read_node_data(&id, &x, &y, &z)) return -1;
3011 if (read_node_convert_coord(system, &x, &y, &z)) return -1;
3012
3013 /* add node */
3014 if (HECMW_io_add_node(id, x, y, z) == NULL) return -1;
3015
3016 /* add node to group */
3017 if (HECMW_io_add_ngrp("ALL", 1, &id) < 0) return -1;
3018
3019 if (flag_ngrp) {
3020 if (HECMW_io_add_ngrp(ngrp, 1, &id) < 0) return -1;
3021 }
3022
3023 /* check next state */
3024 token = HECMW_heclex_next_token();
3025 if (token != HECMW_HECLEX_INT) {
3026 state = ST_FINISHED;
3027 } else {
3028 state = ST_DATA_LINE;
3029 }
3031 } else {
3032 HECMW_assert(0);
3033 }
3034 }
3035 HECMW_log(HECMW_LOG_DEBUG, "read_node done");
3036 return 0;
3037}
3038
3039/*----------------------------------------------------------------------------*/
3040
3041static int read_section_head(void) {
3042 int token;
3043
3044 /* !SECTION */
3045 token = HECMW_heclex_next_token();
3046 if (token != HECMW_HECLEX_H_SECTION) {
3047 set_err_token(token, HECMW_IO_HEC_E1700, "!SECTION required");
3048 return -1;
3049 }
3050
3051 token = HECMW_heclex_next_token();
3052 if (token != ',') {
3053 set_err_token(token, HECMW_IO_HEC_E1700, "',' required after !SECTION");
3054 return -1;
3055 }
3056
3057 return 0;
3058}
3059
3060static int read_section_param_type(int *type) {
3061 int token;
3062
3063 token = HECMW_heclex_next_token();
3064 if (token != '=') {
3065 set_err_token(token, HECMW_IO_HEC_E1700, "'=' required after TYPE");
3066 return -1;
3067 }
3068 token = HECMW_heclex_next_token();
3069 if (token == HECMW_HECLEX_K_SOLID) {
3070 *type = HECMW_SECT_TYPE_SOLID;
3071 } else if (token == HECMW_HECLEX_K_SHELL) {
3072 *type = HECMW_SECT_TYPE_SHELL;
3073 } else if (token == HECMW_HECLEX_K_BEAM) {
3074 *type = HECMW_SECT_TYPE_BEAM;
3075 } else if (token == HECMW_HECLEX_K_INTERFACE) {
3077 } else {
3078 set_err_token(token, HECMW_IO_HEC_E1700, "Invalid TYPE");
3079 return -1;
3080 }
3081 return 0;
3082}
3083
3084static int read_section_param_egrp(char *egrp) {
3085 int token;
3086 char *p;
3087
3088 token = HECMW_heclex_next_token();
3089 if (token != '=') {
3090 set_err_token(token, HECMW_IO_HEC_E1700, "'=' reuqired after EGRP");
3091 return -1;
3092 }
3093 token = HECMW_heclex_next_token();
3094 if (token != HECMW_HECLEX_NAME) {
3095 set_err_token(token, HECMW_IO_HEC_E1700,
3096 "EGRP must begin with a letter or '_'");
3097 return -1;
3098 }
3100 if (strlen(p) > HECMW_NAME_LEN) {
3101 set_err(HECMW_IO_E0001, "");
3102 return -1;
3103 }
3104 strcpy(egrp, p);
3105 HECMW_toupper(egrp);
3106 if (HECMW_io_is_reserved_name(egrp)) {
3107 set_err(HECMW_IO_E0003, "");
3108 return -1;
3109 }
3110 return 0;
3111}
3112
3113static int read_section_param_material(char *material) {
3114 int token;
3115 char *p;
3116
3117 token = HECMW_heclex_next_token();
3118 if (token != '=') {
3119 set_err_token(token, HECMW_IO_HEC_E1700, "'=' reuqired after MATERIAL");
3120 return -1;
3121 }
3122 token = HECMW_heclex_next_token();
3123 if (token != HECMW_HECLEX_NAME) {
3124 set_err_token(token, HECMW_IO_HEC_E1700,
3125 "MATERIAL must begin with a letter or '_'");
3126 return -1;
3127 }
3129 if (strlen(p) > HECMW_NAME_LEN) {
3130 set_err(HECMW_IO_E0001, "");
3131 return -1;
3132 }
3133 strcpy(material, p);
3134 HECMW_toupper(material);
3135 if (HECMW_io_is_reserved_name(material)) {
3136 set_err(HECMW_IO_E0003, "");
3137 return -1;
3138 }
3139 return 0;
3140}
3141
3142#if 0
3143static int
3144read_section_param_composite(int *composite)
3145{
3146 int token;
3147
3148 *composite = 1; /* default value */
3149 token = HECMW_heclex_next_token();
3150 if(token == '=') {
3151 token = HECMW_heclex_next_token();
3152 if(token != HECMW_HECLEX_INT) {
3153 set_err_token(token, HECMW_IO_HEC_E1700, "COMPOSITE value reuqired");
3154 return -1;
3155 }
3156 *composite = HECMW_heclex_get_number();
3157 } else {
3159 }
3160 if(*composite <= 0) {
3161 set_err(HECMW_IO_HEC_E1704, "");
3162 return -1;
3163 }
3164 return 0;
3165}
3166#endif
3167
3168static int read_section_param_secopt(int *secopt_arg) {
3169 int token, secopt;
3170
3171 token = HECMW_heclex_next_token();
3172 if (token != '=') {
3173 set_err_token(token, HECMW_IO_HEC_E1700, "'=' required after SECOPT");
3174 return -1;
3175 }
3176 token = HECMW_heclex_next_token();
3177 if (token != HECMW_HECLEX_INT) {
3178 set_err_token(token, HECMW_IO_HEC_E1700, "SECOPT value reuqired");
3179 return -1;
3180 }
3181 secopt = HECMW_heclex_get_number();
3182 if (secopt != HECMW_SECT_OPT_PSTRESS && secopt != HECMW_SECT_OPT_PSTRAIN &&
3183 secopt != HECMW_SECT_OPT_ASYMMETRY &&
3184 secopt != HECMW_SECT_OPT_PSTRESS_RI &&
3185 secopt != HECMW_SECT_OPT_PSTRAIN_RI &&
3186 secopt != HECMW_SECT_OPT_ASYMMETRY_RI) {
3187 set_err_token(token, HECMW_IO_HEC_E1700, "Invalid SECOPT");
3188 return -1;
3189 }
3190
3191 *secopt_arg = secopt;
3192
3193 return 0;
3194}
3195
3196static int read_section_solid(union hecmw_io_section_item *sect_item) {
3197 int token;
3198 double thickness;
3199
3200 /* THICKNESS */
3201 token = HECMW_heclex_next_token();
3202 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3203 thickness = HECMW_heclex_get_number();
3204
3205 /* NL */
3206 token = HECMW_heclex_next_token();
3207 if (token != HECMW_HECLEX_NL) {
3208 set_err_token(token, HECMW_IO_HEC_E1700, "NL required after THICKNESS");
3209 return -1;
3210 }
3211 } else {
3212 thickness = 1.0;
3214 }
3215
3216 if (thickness <= 0.0) {
3217 set_err(HECMW_IO_HEC_E1705, "");
3218 return -1;
3219 }
3220
3221 /* set */
3222 sect_item->solid.thickness = thickness;
3223
3224 return 0;
3225}
3226
3227static int read_section_shell(union hecmw_io_section_item *sect_item) {
3228 double thickness;
3229 int token, integpoints;
3230
3231 /* THICKNESS */
3232 token = HECMW_heclex_next_token();
3233 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3234 thickness = HECMW_heclex_get_number();
3235 } else {
3236 set_err_token(token, HECMW_IO_HEC_E1700, "THICKNESS reuiqred");
3237 return -1;
3238 }
3239 if (thickness <= 0.0) {
3240 set_err(HECMW_IO_HEC_E1705, "");
3241 return -1;
3242 }
3243
3244 /* ',' */
3245 token = HECMW_heclex_next_token();
3246 if (token != ',') {
3247 set_err_token(token, HECMW_IO_HEC_E1700, "',' required after THICKNESS");
3248 return -1;
3249 }
3250
3251 /* INTEGPOINTS */
3252 token = HECMW_heclex_next_token();
3253 if (token == HECMW_HECLEX_INT) {
3254 integpoints = HECMW_heclex_get_number();
3255 } else {
3256 set_err_token(token, HECMW_IO_HEC_E1700, "INTEGPOINTS required");
3257 return -1;
3258 }
3259 if (integpoints <= 0) {
3260 set_err(HECMW_IO_HEC_E1706, "");
3261 return -1;
3262 }
3263
3264 /* NL */
3265 token = HECMW_heclex_next_token();
3266 if (token != HECMW_HECLEX_NL) {
3267 set_err_token(token, HECMW_IO_HEC_E1700, "NL required after INTEGPOINTS");
3268 return -1;
3269 }
3270
3271 /* set */
3272 sect_item->shell.thickness = thickness;
3273 sect_item->shell.integpoints = integpoints;
3274
3275 return 0;
3276}
3277
3278static int read_section_beam(union hecmw_io_section_item *sect_item) {
3279 double nx, ny, nz, area, Iyy, Izz, Jx;
3280 int token;
3281
3282 /* vx */
3283 token = HECMW_heclex_next_token();
3284 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3286 } else {
3287 set_err_token(token, HECMW_IO_HEC_E1700, "vx reuiqred");
3288 return -1;
3289 }
3290
3291 /* ',' */
3292 token = HECMW_heclex_next_token();
3293 if (token != ',') {
3294 set_err_token(token, HECMW_IO_HEC_E1700, "',' required after vx");
3295 return -1;
3296 }
3297
3298 /* vy */
3299 token = HECMW_heclex_next_token();
3300 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3302 } else {
3303 set_err_token(token, HECMW_IO_HEC_E1700, "vy reuiqred");
3304 return -1;
3305 }
3306
3307 /* ',' */
3308 token = HECMW_heclex_next_token();
3309 if (token != ',') {
3310 set_err_token(token, HECMW_IO_HEC_E1700, "',' required after vy");
3311 return -1;
3312 }
3313
3314 /* vz */
3315 token = HECMW_heclex_next_token();
3316 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3318 } else {
3319 set_err_token(token, HECMW_IO_HEC_E1700, "vz reuiqred");
3320 return -1;
3321 }
3322
3323 /* ',' */
3324 token = HECMW_heclex_next_token();
3325 if (token != ',') {
3326 set_err_token(token, HECMW_IO_HEC_E1700, "',' required after vz");
3327 return -1;
3328 }
3329
3330 /* area */
3331 token = HECMW_heclex_next_token();
3332 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3333 area = HECMW_heclex_get_number();
3334 } else {
3335 set_err_token(token, HECMW_IO_HEC_E1700, "area required");
3336 return -1;
3337 }
3338 if (area <= 0) {
3339 set_err(HECMW_IO_HEC_E1707, "");
3340 return -1;
3341 }
3342
3343 /* ',' */
3344 token = HECMW_heclex_next_token();
3345 if (token != ',') {
3346 set_err_token(token, HECMW_IO_HEC_E1700, "',' required after vz");
3347 return -1;
3348 }
3349
3350 /* Iyy */
3351 token = HECMW_heclex_next_token();
3352 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3354 } else {
3355 set_err_token(token, HECMW_IO_HEC_E1700, "Iyy reuiqred");
3356 return -1;
3357 }
3358 if (Iyy <= 0) {
3359 set_err(HECMW_IO_HEC_E1708, "");
3360 return -1;
3361 }
3362
3363 /* ',' */
3364 token = HECMW_heclex_next_token();
3365 if (token != ',') {
3366 set_err_token(token, HECMW_IO_HEC_E1700, "',' required after Iyy");
3367 return -1;
3368 }
3369
3370 /* Izz */
3371 token = HECMW_heclex_next_token();
3372 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3374 } else {
3375 set_err_token(token, HECMW_IO_HEC_E1700, "Izz reuiqred");
3376 return -1;
3377 }
3378 if (Izz <= 0) {
3379 set_err(HECMW_IO_HEC_E1709, "");
3380 return -1;
3381 }
3382
3383 /* ',' */
3384 token = HECMW_heclex_next_token();
3385 if (token != ',') {
3386 set_err_token(token, HECMW_IO_HEC_E1700, "',' required after Izz");
3387 return -1;
3388 }
3389
3390 /* Jx */
3391 token = HECMW_heclex_next_token();
3392 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3394 } else {
3395 set_err_token(token, HECMW_IO_HEC_E1700, "Jx reuiqred");
3396 return -1;
3397 }
3398 if (Jx <= 0) {
3399 set_err(HECMW_IO_HEC_E1710, "");
3400 return -1;
3401 }
3402
3403 /* NL */
3404 token = HECMW_heclex_next_token();
3405 if (token != HECMW_HECLEX_NL) {
3406 set_err_token(token, HECMW_IO_HEC_E1700, "NL required after Jx");
3407 return -1;
3408 }
3409
3410 /* set */
3411 sect_item->beam.vxyz[0] = nx;
3412 sect_item->beam.vxyz[1] = ny;
3413 sect_item->beam.vxyz[2] = nz;
3414 sect_item->beam.area = area;
3415 sect_item->beam.Iyy = Iyy;
3416 sect_item->beam.Izz = Izz;
3417 sect_item->beam.Jx = Jx;
3418
3419 return 0;
3420}
3421
3422static int read_section_interface(union hecmw_io_section_item *sect_item) {
3423 int token;
3424 double thickness;
3425 double gapcon = 0.0;
3426 double gaprad1 = 0.0;
3427 double gaprad2 = 0.0;
3428
3429 while (1) {
3430 /* THICKNESS */
3431 token = HECMW_heclex_next_token();
3432 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3433 thickness = HECMW_heclex_get_number();
3434 } else {
3435 set_err_token(token, HECMW_IO_HEC_E1700, "THICKNESS required");
3436 return -1;
3437 }
3438 if (thickness <= 0.0) {
3439 set_err(HECMW_IO_HEC_E1705, "");
3440 return -1;
3441 }
3442
3443 /* ',' or NL */
3444 token = HECMW_heclex_next_token();
3445 if (token != ',' && token != HECMW_HECLEX_NL) {
3446 set_err_token(token, HECMW_IO_HEC_E1700,
3447 "',' or NL reuqired after THICKNESS");
3448 return -1;
3449 }
3450 if (token == HECMW_HECLEX_NL) break;
3451
3452 /* GAPCON */
3453 token = HECMW_heclex_next_token();
3454 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3455 gapcon = HECMW_heclex_get_number();
3456 } else if (token == ',') {
3458 } else if (token == HECMW_HECLEX_NL) {
3459 break;
3460 } else {
3461 set_err_token(token, HECMW_IO_HEC_E1700, "GAPCON reuiqred");
3462 return -1;
3463 }
3464
3465 /* ',' or NL */
3466 token = HECMW_heclex_next_token();
3467 if (token != ',' && token != HECMW_HECLEX_NL) {
3468 set_err_token(token, HECMW_IO_HEC_E1700,
3469 "',' or NL reuiqred after GAPCON");
3470 return -1;
3471 }
3472 if (token == HECMW_HECLEX_NL) break;
3473
3474 /* GAPRAD1 */
3475 token = HECMW_heclex_next_token();
3476 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3477 gaprad1 = HECMW_heclex_get_number();
3478 } else if (token == ',') {
3480 } else if (token == HECMW_HECLEX_NL) {
3481 break;
3482 } else {
3483 set_err_token(token, HECMW_IO_HEC_E1700, "GAPRAD1 reuiqred");
3484 return -1;
3485 }
3486
3487 /* ',' or NL */
3488 token = HECMW_heclex_next_token();
3489 if (token != ',' && token != HECMW_HECLEX_NL) {
3490 set_err_token(token, HECMW_IO_HEC_E1700,
3491 "',' or NL reuqired after GAPRAD1");
3492 return -1;
3493 }
3494 if (token == HECMW_HECLEX_NL) break;
3495
3496 /* GAPRAD2 */
3497 token = HECMW_heclex_next_token();
3498 if (token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3499 gaprad2 = HECMW_heclex_get_number();
3500 } else if (token == HECMW_HECLEX_NL) {
3502 } else {
3503 set_err_token(token, HECMW_IO_HEC_E1700, "GAPRAD2 reuiqred");
3504 return -1;
3505 }
3506
3507 /* NL */
3508 token = HECMW_heclex_next_token();
3509 if (token != HECMW_HECLEX_NL) {
3510 set_err_token(token, HECMW_IO_HEC_E1700, "NL required after GAPRAD2");
3511 return -1;
3512 }
3513 break;
3514 }
3515
3516 /* set */
3517 sect_item->interface.thickness = thickness;
3518 sect_item->interface.gapcon = gapcon;
3519 sect_item->interface.gaprad1 = gaprad1;
3520 sect_item->interface.gaprad2 = gaprad2;
3521
3522 return 0;
3523}
3524
3525static int read_section(void) {
3526 int token, state;
3527 int type = -1;
3528 int secopt = 0;
3529 int composite = -1;
3530 union hecmw_io_section_item sect_item;
3531 int flag_type = 0; /* flag for TYPE */
3532 int flag_egrp = 0; /* flag for EGRP */
3533 int flag_material = 0; /* flag for MATERIAL */
3534 int flag_composite = 0; /* flag for COMPOSITE */
3535 int flag_secopt = 0; /* flag for SECOPT */
3536 int flag_input = 0; /* flag for INPUT */
3537 char egrp[HECMW_NAME_LEN + 1] = "";
3538 char material[HECMW_NAME_LEN + 1] = "ALL";
3539 enum {
3540 ST_FINISHED,
3541 ST_HEADER_LINE,
3542 ST_HEADER_LINE_PARAM,
3543 ST_DATA_INCLUDE,
3544 ST_DATA_LINE_SOLID,
3545 ST_DATA_LINE_SHELL,
3546 ST_DATA_LINE_BEAM,
3547 ST_DATA_LINE_INTERFACE,
3548 ST_DATA_LINE_REGIST
3549 };
3550
3551 state = ST_HEADER_LINE;
3552 while (state != ST_FINISHED) {
3553 if (state == ST_HEADER_LINE) {
3554 if (read_section_head()) return -1;
3555 state = ST_HEADER_LINE_PARAM;
3556 } else if (state == ST_HEADER_LINE_PARAM) {
3557 token = HECMW_heclex_next_token();
3558 if (token == HECMW_HECLEX_K_TYPE) {
3559 /* must */
3560 if (read_section_param_type(&type)) return -1;
3561 flag_type = 1;
3562 } else if (token == HECMW_HECLEX_K_EGRP) {
3563 /* must */
3564 if (read_section_param_egrp(egrp)) return -1;
3565 flag_egrp = 1;
3566 } else if (token == HECMW_HECLEX_K_MATERIAL) {
3567 /* optional */
3568 if (flag_composite) {
3569 set_err(HECMW_IO_HEC_E1703, "");
3570 return -1;
3571 }
3572 if (read_section_param_material(material)) return -1;
3573 flag_material = 1;
3574#if 0
3575 } else if(token == HECMW_HECLEX_K_COMPOSITE) {
3576 /* optional */
3577 if(flag_material) {
3578 set_err(HECMW_IO_HEC_E1703, "");
3579 return -1;
3580 }
3581 if(read_section_param_composite(&composite)) return -1;
3582 flag_composite = 1;
3583#endif
3584 } else if (token == HECMW_HECLEX_K_SECOPT) {
3585 /* optional */
3586 if (read_section_param_secopt(&secopt)) return -1;
3587 flag_secopt = 1;
3588 } else if (token == HECMW_HECLEX_K_INPUT) {
3589 /* optional */
3590 if (read_input(HECMW_IO_HEC_E1700)) return -1;
3591 flag_input = 1;
3592 } else {
3593 set_err_token(token, HECMW_IO_HEC_E1700, "Unknown parameter");
3594 return -1;
3595 }
3596
3597 /* check next parameter */
3598 token = HECMW_heclex_next_token();
3599 if (token == HECMW_HECLEX_NL) {
3600 /* check */
3601 if (!flag_type) {
3602 set_err(HECMW_IO_HEC_E1701, "");
3603 return -1;
3604 }
3605 if (!flag_egrp) {
3606 set_err(HECMW_IO_HEC_E1702, "");
3607 return -1;
3608 }
3609 /* set next state */
3610 if (flag_input) {
3611 state = ST_DATA_INCLUDE;
3612 } else if (type == HECMW_SECT_TYPE_SOLID) {
3613 state = ST_DATA_LINE_SOLID;
3614 } else if (type == HECMW_SECT_TYPE_SHELL) {
3615 state = ST_DATA_LINE_SHELL;
3616 } else if (type == HECMW_SECT_TYPE_BEAM) {
3617 state = ST_DATA_LINE_BEAM;
3618 } else if (type == HECMW_SECT_TYPE_INTERFACE) {
3619 state = ST_DATA_LINE_INTERFACE;
3620 } else {
3621 HECMW_assert(0);
3622 }
3623 } else if (token == ',') {
3624 ; /* continue this state */
3625 } else {
3626 set_err_token(token, HECMW_IO_HEC_E1700, "Unknown parameter");
3627 return -1;
3628 }
3629 } else if (state == ST_DATA_INCLUDE) {
3630 HECMW_assert(flag_input);
3631
3632 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
3633
3634 /* set next state */
3635 if (type == HECMW_SECT_TYPE_SOLID) {
3636 state = ST_DATA_LINE_SOLID;
3637 } else if (type == HECMW_SECT_TYPE_SHELL) {
3638 state = ST_DATA_LINE_SHELL;
3639 } else if (type == HECMW_SECT_TYPE_BEAM) {
3640 state = ST_DATA_LINE_BEAM;
3641 } else if (type == HECMW_SECT_TYPE_INTERFACE) {
3642 state = ST_DATA_LINE_INTERFACE;
3643 } else {
3644 HECMW_assert(0);
3645 }
3646 } else if (state == ST_DATA_LINE_SOLID) {
3647 HECMW_assert(flag_egrp);
3648 HECMW_assert(flag_type);
3650
3651 if (read_section_solid(&sect_item)) return -1;
3652 state = ST_DATA_LINE_REGIST;
3653 } else if (state == ST_DATA_LINE_SHELL) {
3654 HECMW_assert(flag_egrp);
3655 HECMW_assert(flag_type);
3657
3658 if (read_section_shell(&sect_item)) return -1;
3659 state = ST_DATA_LINE_REGIST;
3660 } else if (state == ST_DATA_LINE_BEAM) {
3661 HECMW_assert(flag_egrp);
3662 HECMW_assert(flag_type);
3664
3665 if (read_section_beam(&sect_item)) return -1;
3666 state = ST_DATA_LINE_REGIST;
3667 } else if (state == ST_DATA_LINE_INTERFACE) {
3668 HECMW_assert(flag_egrp);
3669 HECMW_assert(flag_type);
3671
3672 if (read_section_interface(&sect_item)) return -1;
3673 state = ST_DATA_LINE_REGIST;
3674 } else if (state == ST_DATA_LINE_REGIST) {
3675 struct hecmw_io_section sect;
3676 HECMW_assert(flag_type);
3677 HECMW_assert(flag_egrp);
3678
3679 /* set */
3680 strcpy(sect.egrp, egrp);
3681 strcpy(sect.material, material);
3682 sect.composite = composite;
3683 sect.secopt = secopt;
3684 sect.type = type;
3685 sect.sect = sect_item;
3686 sect.next = NULL;
3687
3688 /* add */
3689 if (HECMW_io_add_sect(&sect) == NULL) return -1;
3690
3691 /* set next state */
3692 state = ST_FINISHED;
3693 } else {
3694 HECMW_assert(0);
3695 }
3696 }
3697 HECMW_log(HECMW_LOG_DEBUG, "read_section done");
3698 return 0;
3699}
3700
3701/*----------------------------------------------------------------------------*/
3702
3703static int read_sgrp_head(void) {
3704 int token;
3705
3706 /* !SGROUP */
3707 token = HECMW_heclex_next_token();
3708 if (token != HECMW_HECLEX_H_SGROUP) {
3709 set_err_token(token, HECMW_IO_HEC_E1800, "!SGROUP required");
3710 return -1;
3711 }
3712
3713 token = HECMW_heclex_next_token();
3714 if (token != ',') {
3715 set_err_token(token, HECMW_IO_HEC_E1800, "',' required after !SGROUP");
3716 return -1;
3717 }
3718
3719 return 0;
3720}
3721
3722static int read_sgrp_param_sgrp(char *sgrp) {
3723 int token;
3724 char *p;
3725
3726 token = HECMW_heclex_next_token();
3727 if (token != '=') {
3728 set_err_token(token, HECMW_IO_HEC_E1800, "'=' required after SGRP");
3729 return -1;
3730 }
3731 token = HECMW_heclex_next_token();
3732 if (token != HECMW_HECLEX_NAME) {
3733 set_err_token(token, HECMW_IO_HEC_E1800,
3734 "SGRP must begin with a letter or '_'");
3735 return -1;
3736 }
3738 if (strlen(p) > HECMW_NAME_LEN) {
3739 set_err(HECMW_IO_E0001, "");
3740 return -1;
3741 }
3742 strcpy(sgrp, p);
3743 HECMW_toupper(sgrp);
3744 if (HECMW_io_is_reserved_name(sgrp)) {
3745 set_err(HECMW_IO_E0003, "");
3746 return -1;
3747 }
3748 return 0;
3749}
3750
3751static int read_sgrp_data(char *sgrp) {
3752 int i, n, *elem, *surf, token;
3753 struct hecmw_io_id *elem_head, *surf_head, *elem_prev, *surf_prev;
3754 struct hecmw_io_id *eid, *sid, *pe, *qe, *ps, *qs;
3755
3756 n = 0;
3757 elem_head = surf_head = NULL;
3758 elem_prev = surf_prev = NULL;
3759 while (1) {
3760 token = HECMW_heclex_next_token();
3761 if (n != 0 && token == HECMW_HECLEX_NL) break;
3762
3763 eid = HECMW_malloc(sizeof(*eid));
3764 if (eid == NULL) {
3765 HECMW_set_error(errno, "");
3766 return -1;
3767 }
3768 eid->next = NULL;
3769
3770 /* elemX */
3771 if (token != HECMW_HECLEX_INT) {
3772 set_err_token(token, HECMW_IO_HEC_E1800, "Element ID required");
3773 return -1;
3774 }
3775 eid->id = HECMW_heclex_get_number();
3776
3777 if (elem_head == NULL) {
3778 elem_head = elem_prev = eid;
3779 } else {
3780 elem_prev->next = eid;
3781 elem_prev = eid;
3782 }
3783
3784 /* ',' */
3785 token = HECMW_heclex_next_token();
3786 if (token != ',') {
3787 set_err_token(token, HECMW_IO_HEC_E1800, "',' reuqired after element ID");
3788 return -1;
3789 }
3790
3791 sid = HECMW_malloc(sizeof(*sid));
3792 if (sid == NULL) {
3793 HECMW_set_error(errno, "");
3794 return -1;
3795 }
3796 sid->next = NULL;
3797
3798 /* lsufX */
3799 token = HECMW_heclex_next_token();
3800 if (token != HECMW_HECLEX_INT) {
3801 set_err_token(token, HECMW_IO_HEC_E1800, "Surface ID required");
3802 return -1;
3803 }
3804 sid->id = HECMW_heclex_get_number();
3805
3806 if (surf_head == NULL) {
3807 surf_head = surf_prev = sid;
3808 } else {
3809 surf_prev->next = sid;
3810 surf_prev = sid;
3811 }
3812
3813 n++;
3814
3815 /* ',' or NL */
3816 token = HECMW_heclex_next_token();
3817 if (token != ',' && token != HECMW_HECLEX_NL) {
3818 set_err_token(token, HECMW_IO_HEC_E1800,
3819 "',' or NL required after surface ID");
3820 return -1;
3821 }
3822 if (token == HECMW_HECLEX_NL) break;
3823 }
3824
3825 if (n > 0) {
3826 /* add elem and surf to group */
3827 elem = HECMW_malloc(sizeof(*elem) * n);
3828 if (elem == NULL) {
3829 HECMW_set_error(errno, "");
3830 return -1;
3831 }
3832 surf = HECMW_malloc(sizeof(*surf) * n);
3833 if (surf == NULL) {
3834 HECMW_set_error(errno, "");
3835 return -1;
3836 }
3837 i = 0;
3838 qe = qs = NULL;
3839 pe = elem_head;
3840 ps = surf_head;
3841 for (i = 0; i < n; i++) {
3842 HECMW_assert(pe);
3843 HECMW_assert(ps);
3844 elem[i] = pe->id;
3845 surf[i] = ps->id;
3846 qe = pe;
3847 qs = ps;
3848 pe = pe->next;
3849 ps = ps->next;
3850 HECMW_free(qe);
3851 HECMW_free(qs);
3852 }
3853 if (HECMW_io_add_sgrp(sgrp, n, elem, surf) < 0) return -1;
3854
3855 HECMW_free(elem);
3856 HECMW_free(surf);
3857 }
3858
3859 return 0;
3860}
3861
3862static int read_sgroup(void) {
3863 int token, state;
3864 int flag_sgrp = 0; /* flag for SGRP */
3865 int flag_input = 0; /* flag for INPUT */
3866 char sgrp[HECMW_NAME_LEN + 1] = "";
3867 enum {
3868 ST_FINISHED,
3869 ST_HEADER_LINE,
3870 ST_HEADER_LINE_PARAM,
3871 ST_DATA_INCLUDE,
3872 ST_DATA_LINE
3873 };
3874
3875 state = ST_HEADER_LINE;
3876 while (state != ST_FINISHED) {
3877 if (state == ST_HEADER_LINE) {
3878 if (read_sgrp_head()) return -1;
3879 state = ST_HEADER_LINE_PARAM;
3880 } else if (state == ST_HEADER_LINE_PARAM) {
3881 token = HECMW_heclex_next_token();
3882 if (token == HECMW_HECLEX_K_SGRP) {
3883 /* must */
3884 if (read_sgrp_param_sgrp(sgrp)) return -1;
3885 flag_sgrp = 1;
3886 } else if (token == HECMW_HECLEX_K_INPUT) {
3887 /* oprtional */
3888 if (read_input(HECMW_IO_HEC_E1800)) return -1;
3889 flag_input = 1;
3890 } else {
3891 set_err_token(token, HECMW_IO_HEC_E1800, "Unknown parameter");
3892 return -1;
3893 }
3894
3895 /* check next parameter */
3896 token = HECMW_heclex_next_token();
3897 if (token == HECMW_HECLEX_NL) {
3898 /* check */
3899 if (!flag_sgrp) {
3900 set_err(HECMW_IO_HEC_E1801, "");
3901 return -1;
3902 }
3903 state = flag_input ? ST_DATA_INCLUDE : ST_DATA_LINE;
3904 } else if (token == ',') {
3905 ; /* continue this state */
3906 } else {
3907 set_err_token(token, HECMW_IO_HEC_E1800, "Unknown parameter");
3908 return -1;
3909 }
3910 } else if (state == ST_DATA_INCLUDE) {
3911 HECMW_assert(flag_input);
3912 HECMW_assert(flag_sgrp);
3913 if (HECMW_heclex_switch_to_include(include_filename)) return -1;
3914 state = ST_DATA_LINE;
3915 } else if (state == ST_DATA_LINE) {
3916 HECMW_assert(flag_sgrp);
3917 if (read_sgrp_data(sgrp)) return -1;
3918
3919 /* check next state */
3920 token = HECMW_heclex_next_token();
3921 if (token != HECMW_HECLEX_INT) {
3922 state = ST_FINISHED;
3923 } else {
3924 state = ST_DATA_LINE;
3925 }
3927 } else {
3928 HECMW_assert(0);
3929 }
3930 }
3931 HECMW_log(HECMW_LOG_DEBUG, "read_sgroup done");
3932 return 0;
3933}
3934
3935/*----------------------------------------------------------------------------*/
3936#if 0
3937static int
3938read_system_head(void)
3939{
3940 int token;
3941
3942 /* !SYSTEM */
3943 token = HECMW_heclex_next_token();
3944 if(token != HECMW_HECLEX_H_SYSTEM) {
3945 set_err_token(token, HECMW_IO_HEC_E1900, "!SYSTEM required");
3946 return -1;
3947 }
3948
3949 /* NL */
3950 token = HECMW_heclex_next_token();
3951 if(token != HECMW_HECLEX_NL) {
3952 set_err_token(token, HECMW_IO_HEC_E1900, "NL required after !SYSTEM");
3953 return -1;
3954 }
3955
3956 return 0;
3957}
3958
3959
3960static int
3961read_system_data_line1a(struct hecmw_system_param *system, int *last_token)
3962{
3963 int token;
3964
3965 /* Xa */
3966 token = HECMW_heclex_next_token();
3967 if(token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3968 system->xa = HECMW_heclex_get_number();
3969 } else if(token == ',') {
3970 system->xa = 0.0;
3972 } else {
3973 set_err_token(token, HECMW_IO_HEC_E1900, "Xa required");
3974 return -1;
3975 }
3976
3977 /* ',' */
3978 token = HECMW_heclex_next_token();
3979 if(token != ',') {
3980 set_err_token(token, HECMW_IO_HEC_E1900, "',' required after Xa");
3981 return -1;
3982 }
3983
3984 /* Ya */
3985 token = HECMW_heclex_next_token();
3986 if(token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
3987 system->ya = HECMW_heclex_get_number();
3988 } else if(token == ',') {
3989 system->ya = 0.0;
3991 } else {
3992 set_err_token(token, HECMW_IO_HEC_E1900, "Ya required");
3993 return -1;
3994 }
3995
3996 /* ',' */
3997 token = HECMW_heclex_next_token();
3998 if(token != ',') {
3999 set_err_token(token, HECMW_IO_HEC_E1900, "',' required after Ya");
4000 return -1;
4001 }
4002
4003 /* Za */
4004 token = HECMW_heclex_next_token();
4005 if(token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
4006 system->za = HECMW_heclex_get_number();
4007 } else if(token == ',' || token == HECMW_HECLEX_NL) {
4008 system->za = 0.0;
4010 } else {
4011 set_err_token(token, HECMW_IO_HEC_E1900, "Za required");
4012 return -1;
4013 }
4014
4015 /* ',' or NL */
4016 token = HECMW_heclex_next_token();
4017 if(token != ',' && token != HECMW_HECLEX_NL) {
4018 set_err_token(token, HECMW_IO_HEC_E1900, "',' or NL required after Za");
4019 return -1;
4020 }
4021 *last_token = token;
4022
4023 return 0;
4024}
4025
4026
4027static int
4028read_system_data_line1b(struct hecmw_system_param *system)
4029{
4030 int token;
4031
4032 /* Xb */
4033 token = HECMW_heclex_next_token();
4034 if(token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
4035 system->xb = HECMW_heclex_get_number();
4036 } else if(token == ',') {
4037 system->xb = 0.0;
4039 } else {
4040 set_err_token(token, HECMW_IO_HEC_E1900, "Xb required");
4041 return -1;
4042 }
4043
4044 /* ',' */
4045 token = HECMW_heclex_next_token();
4046 if(token != ',') {
4047 set_err_token(token, HECMW_IO_HEC_E1900, "',' required after Xb");
4048 return -1;
4049 }
4050
4051 /* Yb */
4052 token = HECMW_heclex_next_token();
4053 if(token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
4054 system->yb = HECMW_heclex_get_number();
4055 } else if(token == ',') {
4056 system->yb = 0.0;
4058 } else {
4059 set_err_token(token, HECMW_IO_HEC_E1900, "Yb required");
4060 return -1;
4061 }
4062
4063 /* ',' */
4064 token = HECMW_heclex_next_token();
4065 if(token != ',') {
4066 set_err_token(token, HECMW_IO_HEC_E1900, "',' required after Yb");
4067 return -1;
4068 }
4069
4070 /* Zb */
4071 token = HECMW_heclex_next_token();
4072 if(token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
4073 system->zb = HECMW_heclex_get_number();
4074 } else if(token == HECMW_HECLEX_NL) {
4075 system->zb = 0.0;
4077 } else {
4078 set_err_token(token, HECMW_IO_HEC_E1900, "Zb required");
4079 return -1;
4080 }
4081
4082 /*NL */
4083 token = HECMW_heclex_next_token();
4084 if(token != HECMW_HECLEX_NL) {
4085 set_err_token(token, HECMW_IO_HEC_E1900, "NL required after Zb");
4086 return -1;
4087 }
4088
4089 return 0;
4090}
4091
4092
4093static int
4094read_system_data_line2(struct hecmw_system_param *system)
4095{
4096 int token;
4097
4098 /* Xc */
4099 token = HECMW_heclex_next_token();
4100 if(token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
4101 system->xc = HECMW_heclex_get_number();
4102 } else if(token == ',') {
4103 system->xc = 0.0;
4105 } else {
4106 set_err_token(token, HECMW_IO_HEC_E1900, "Xc required");
4107 return -1;
4108 }
4109
4110 /* ',' */
4111 token = HECMW_heclex_next_token();
4112 if(token != ',') {
4113 set_err_token(token, HECMW_IO_HEC_E1900, "',' required after Xc");
4114 return -1;
4115 }
4116
4117 /* Yc */
4118 token = HECMW_heclex_next_token();
4119 if(token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
4120 system->yc = HECMW_heclex_get_number();
4121 } else if(token == ',') {
4122 system->yc = 0.0;
4124 } else {
4125 set_err_token(token, HECMW_IO_HEC_E1900, "Yc required");
4126 return -1;
4127 }
4128
4129 /* ',' */
4130 token = HECMW_heclex_next_token();
4131 if(token != ',') {
4132 set_err_token(token, HECMW_IO_HEC_E1900, "',' required after Yc");
4133 return -1;
4134 }
4135
4136 /* Zc */
4137 token = HECMW_heclex_next_token();
4138 if(token == HECMW_HECLEX_DOUBLE || token == HECMW_HECLEX_INT) {
4139 system->zc = HECMW_heclex_get_number();
4140 } else if(token == HECMW_HECLEX_NL) {
4141 system->zc = 0.0;
4143 } else {
4144 set_err_token(token, HECMW_IO_HEC_E1900, "Zc required");
4145 return -1;
4146 }
4147
4148 /* NL */
4149 token = HECMW_heclex_next_token();
4150 if(token != HECMW_HECLEX_NL) {
4151 set_err_token(token, HECMW_IO_HEC_E1900, "NL required after Zc");
4152 return -1;
4153 }
4154
4155 return 0;
4156}
4157
4158
4159static int
4160read_system(void)
4161{
4162 int token,state;
4163 struct hecmw_system_param *system;
4164 enum {
4165 ST_FINISHED,
4166 ST_HEADER_LINE,
4167 ST_DATA_LINE1,
4168 ST_DATA_LINE2
4169 };
4170
4171 system = HECMW_malloc(sizeof(*system));
4172 if(system == NULL) {
4173 HECMW_set_error(errno, "");
4174 return -1;
4175 }
4176
4177 /* default values */
4178 system->xa = 0.0;
4179 system->ya = 0.0;
4180 system->za = 0.0;
4181 system->xb = 0.0;
4182 system->yb = 0.0;
4183 system->zb = 0.0;
4184 system->xc = 0.0;
4185 system->yc = 0.0;
4186 system->zc = 0.0;
4187
4188 state = ST_HEADER_LINE;
4189 while(state != ST_FINISHED) {
4190 if(state == ST_HEADER_LINE) {
4191 if(read_system_head()) return -1;
4192 /* check next state */
4193 token = HECMW_heclex_next_token();
4194 if(token != HECMW_HECLEX_DOUBLE && token != HECMW_HECLEX_INT && token != ',') {
4195 /* clear !SYSTEM */
4196 HECMW_free(system);
4197 system = NULL;
4198 state = ST_FINISHED;
4199 } else {
4200 state = ST_DATA_LINE1;
4201 }
4203 } else if(state == ST_DATA_LINE1) {
4204 if(read_system_data_line1a(system, &token)) return -1;
4205 if(token == HECMW_HECLEX_NL) {
4206 state = ST_FINISHED;
4207 continue;
4208 }
4209 HECMW_assert(token == ',');
4210
4211 if(read_system_data_line1b(system)) return -1;
4212 token = HECMW_heclex_next_token();
4213 if(token != HECMW_HECLEX_DOUBLE && token != HECMW_HECLEX_INT && token != ',') {
4214 state = ST_FINISHED;
4215 } else {
4216 state = ST_DATA_LINE2;
4217 }
4219 } else if(state == ST_DATA_LINE2) {
4220 if(read_system_data_line2(system)) return -1;
4221 state = ST_FINISHED;
4222 } else {
4223 HECMW_assert(0);
4224 }
4225 }
4226
4227 /* set */
4228 HECMW_io_set_system(system);
4229
4230 HECMW_log(HECMW_LOG_DEBUG, "read_system done");
4231 return 0;
4232}
4233#endif
4234
4235/*----------------------------------------------------------------------------*/
4236
4237static int read_zero(void) {
4238 int token;
4239 double zero;
4240 struct hecmw_io_zero *new_zero;
4241
4242 /* !ZERO */
4243 token = HECMW_heclex_next_token();
4244 if (token != HECMW_HECLEX_H_ZERO) {
4245 set_err_token(token, HECMW_IO_HEC_E2000, "!ZERO required");
4246 return -1;
4247 }
4248
4249 /* NL */
4250 token = HECMW_heclex_next_token();
4251 if (token != HECMW_HECLEX_NL) {
4252 set_err_token(token, HECMW_IO_HEC_E2000, "NL reqyured after !ZERO");
4253 return -1;
4254 }
4255
4256 /* ZERO */
4257 token = HECMW_heclex_next_token();
4258 if (token != HECMW_HECLEX_INT && token != HECMW_HECLEX_DOUBLE) {
4259 set_err_token(token, HECMW_IO_HEC_E2000, "ZERO required");
4260 return -1;
4261 }
4263
4264 /* NL */
4265 token = HECMW_heclex_next_token();
4266 if (token != HECMW_HECLEX_NL) {
4267 set_err_token(token, HECMW_IO_HEC_E2000, "NL reqyured after ZERO");
4268 return -1;
4269 }
4270
4271 new_zero = HECMW_malloc(sizeof(*new_zero));
4272 if (new_zero == NULL) {
4273 HECMW_set_error(errno, "");
4274 return -1;
4275 }
4276 new_zero->zero = zero;
4277
4278 /* set */
4279 HECMW_io_set_zero(new_zero);
4280
4281 HECMW_log(HECMW_LOG_DEBUG, "read_zero done");
4282 return 0;
4283}
4284
4285/*----------------------------------------------------------------------------*/
4286
4287static int read_connectivity(void) {
4288 int token, type;
4289
4290 /* !CONNECTIVITY */
4291 token = HECMW_heclex_next_token();
4292 if (token != HECMW_HECLEX_H_CONNECTIVITY) {
4293 set_err_token(token, HECMW_IO_HEC_E0200, "!CONNECTIVITY required");
4294 return -1;
4295 }
4296
4297 /* , or NL */
4298 token = HECMW_heclex_next_token();
4299 if (token != ',' && token != HECMW_HECLEX_NL) {
4300 set_err_token(token, HECMW_IO_HEC_E0200,
4301 "',' or NL reqyured after !CONNECTIVITY");
4302 return -1;
4303 }
4304 if (token == HECMW_HECLEX_NL) {
4305 connectivity_type = HECMW_CONNTYPE_HECMW; /* set default value */
4306 return 0;
4307 }
4308
4309 /* TYPE */
4310 token = HECMW_heclex_next_token();
4311 if (token != HECMW_HECLEX_K_TYPE) {
4312 set_err_token(token, HECMW_IO_HEC_E0200, "TYPE required");
4313 return -1;
4314 }
4315
4316 /* = */
4317 token = HECMW_heclex_next_token();
4318 if (token != '=') {
4319 set_err_token(token, HECMW_IO_HEC_E0200, "'=' reqyured after TYPE");
4320 return -1;
4321 }
4322
4323 /* TYPE value */
4324 token = HECMW_heclex_next_token();
4325 switch (token) {
4327 type = HECMW_CONNTYPE_HECMW;
4328 break;
4330 type = HECMW_CONNTYPE_ABAQUS;
4331 break;
4334 break;
4335 default:
4336 set_err_token(token, HECMW_IO_HEC_E0200, "Unsupported connectivity TYPE");
4337 return -1;
4338 }
4339
4340 /* NL */
4341 token = HECMW_heclex_next_token();
4342 if (token != HECMW_HECLEX_NL) {
4343 set_err_token(token, HECMW_IO_HEC_E0200, "NL reqyured after TYPE value");
4344 return -1;
4345 }
4346
4347 connectivity_type = type;
4348
4349 HECMW_log(HECMW_LOG_DEBUG, "read_connectivity done");
4350 return 0;
4351}
4352
4353/*------------------------------------------------------------------------------
4354 ReadFunc table
4355*/
4356
4357typedef int (*ReadFunc)(void);
4358
4359static struct read_func_table {
4360 int token;
4361 ReadFunc func;
4362} read_func_table[] = {
4363 {HECMW_HECLEX_H_AMPLITUDE, read_amplitude},
4364 {HECMW_HECLEX_H_CONNECTIVITY, read_connectivity},
4365 {HECMW_HECLEX_H_CONTACT_PAIR, read_contact_pair},
4366 /* { HECMW_HECLEX_H_ECOPY, read_ecopy }, */
4367 /* { HECMW_HECLEX_H_EGEN, read_egen }, */
4368 {HECMW_HECLEX_H_EGROUP, read_egroup},
4369 {HECMW_HECLEX_H_ELEMENT, read_element},
4370 {HECMW_HECLEX_H_EQUATION, read_equation},
4371 {HECMW_HECLEX_H_HEADER, read_header},
4372 {HECMW_HECLEX_H_INCLUDE, read_include},
4373 {HECMW_HECLEX_H_INITIAL, read_initial},
4374 {HECMW_HECLEX_H_MATERIAL, read_material},
4375 /* { HECMW_HECLEX_H_NCOPY, read_ncopy }, */
4376 /* { HECMW_HECLEX_H_NFILL, read_nfill }, */
4377 /* { HECMW_HECLEX_H_NGEN, read_ngen }, */
4378 {HECMW_HECLEX_H_NGROUP, read_ngroup},
4379 {HECMW_HECLEX_H_NODE, read_node},
4380 {HECMW_HECLEX_H_SECTION, read_section},
4381 {HECMW_HECLEX_H_SGROUP, read_sgroup},
4382 /* { HECMW_HECLEX_H_SYSTEM, read_system }, */
4383 {HECMW_HECLEX_H_ZERO, read_zero},
4384};
4385
4386#define N_READ_FUNC (sizeof(read_func_table) / sizeof(read_func_table[0]))
4387
4388/* static int (* get_read_func(int token))(void) */
4389static ReadFunc get_read_func(int token) {
4390 int i;
4391
4392 for (i = 0; i < N_READ_FUNC; i++) {
4393 if (token == read_func_table[i].token) {
4394 return read_func_table[i].func;
4395 }
4396 }
4397 return NULL;
4398}
4399
4400static int parse(void) {
4401 int token;
4402 ReadFunc func;
4403
4404 while ((token = HECMW_heclex_next_token())) {
4405 if (token == HECMW_HECLEX_NL) continue;
4406 if (token == HECMW_HECLEX_H_END) {
4407 /* stop reading */
4408 return 0;
4409 }
4410 func = get_read_func(token);
4411 if (func == NULL) {
4412 char *p = HECMW_heclex_get_text();
4413 if (p[0] == '!') {
4414 set_err(HECMW_IO_HEC_E0099, "");
4415 } else {
4416 set_err(HECMW_IO_HEC_E0098, "");
4417 }
4418 return -1;
4419 }
4420 HECMW_heclex_unput_token(); /* unput !XXXX */
4421 if ((*func)()) return -1;
4422 }
4423 return 0;
4424}
4425
4426/* read only. Not make hecmwST_local_mesh */
4427int HECMW_read_entire_mesh(const char *filename) {
4428 FILE *fp;
4429
4430 HECMW_log(HECMW_LOG_DEBUG, "Start to read HECMW-ENTIRE mesh");
4431
4432 if (filename == NULL) {
4435 "Not specified filename for HECMW-ENTIRE mesh input routine");
4436 return -1;
4437 }
4438 HECMW_log(HECMW_LOG_DEBUG, "HECMW-ENTIRE mesh file is '%s'", filename);
4439
4440 if (strlen(filename) > HECMW_FILENAME_LEN) {
4442 return -1;
4443 }
4444
4445 strcpy(grid_filename, filename);
4446 HECMW_io_set_gridfile(grid_filename);
4447
4448 if ((fp = fopen(filename, "r")) == NULL) {
4449 HECMW_set_error(HECMW_IO_HEC_E0001, "File: %s, %s", filename,
4450 strerror(errno));
4451 return -1;
4452 }
4453
4454 if (HECMW_heclex_set_input(fp)) return -1;
4455
4456 HECMW_log(HECMW_LOG_DEBUG, "Parsing...");
4457 if (parse()) {
4458 return -1;
4459 }
4460
4461 if (fclose(fp)) {
4462 HECMW_set_error(HECMW_IO_HEC_E0002, "File: %s, %s", filename,
4463 strerror(errno));
4464 return -1;
4465 }
4466
4467 strcpy(grid_filename, "Unknown");
4468
4469 return 0;
4470}
4471
4472struct hecmwST_local_mesh *HECMW_get_entire_mesh(const char *filename) {
4473 struct hecmwST_local_mesh *local_mesh;
4474
4475 if (HECMW_io_init()) return NULL;
4476 if (HECMW_io_pre_process()) return NULL;
4477 if (HECMW_read_entire_mesh(filename)) return NULL;
4478 if (HECMW_io_post_process()) return NULL;
4479 local_mesh = HECMW_io_make_local_mesh();
4480 if (local_mesh == NULL) return NULL;
4481 if (HECMW_io_finalize()) return NULL;
4482
4483 strcpy(grid_filename, "Unknown");
4484
4485 return local_mesh;
4486}
HECMW_Comm HECMW_comm_get_comm(void)
Definition: hecmw_comm.c:699
#define HECMW_MAX_NODE_MAX
#define HECMW_FILENAME_LEN
Definition: hecmw_config.h:72
#define HECMW_MSG_LEN
Definition: hecmw_config.h:74
#define HECMW_HEADER_LEN
Definition: hecmw_config.h:68
#define HECMW_NAME_LEN
Definition: hecmw_config.h:70
int HECMW_convert_connectivity(int from, int hecmw_etype, int *conn)
#define HECMW_CONNTYPE_ABAQUS
#define HECMW_CONNTYPE_NASTRAN
#define HECMW_CONNTYPE_HECMW
int HECMW_set_error(int errorno, const char *fmt,...)
Definition: hecmw_error.c:37
int HECMW_get_max_node(int etype)
Definition: hecmw_etype.c:409
int HECMW_cylindrical_to_cartesian(const struct hecmw_coord *coord, struct hecmw_coord *result)
double HECMW_degree_to_radian(double deg)
int HECMW_heclex_next_token(void)
double HECMW_heclex_get_number(void)
int HECMW_heclex_switch_to_include(const char *filename)
int HECMW_heclex_unput_token(void)
int HECMW_heclex_get_lineno(void)
int HECMW_heclex_set_input(FILE *fp)
char * HECMW_heclex_get_text(void)
int HECMW_heclex_is_including(void)
@ HECMW_HECLEX_K_SURF_SURF
Definition: hecmw_heclex.h:68
@ HECMW_HECLEX_K_GENERATE
Definition: hecmw_heclex.h:49
@ HECMW_HECLEX_H_EGROUP
Definition: hecmw_heclex.h:24
@ HECMW_HECLEX_H_ELEMENT
Definition: hecmw_heclex.h:25
@ HECMW_HECLEX_K_INPUT
Definition: hecmw_heclex.h:51
@ HECMW_HECLEX_K_TABULAR
Definition: hecmw_heclex.h:71
@ HECMW_HECLEX_K_SHELL
Definition: hecmw_heclex.h:64
@ HECMW_HECLEX_K_TYPE
Definition: hecmw_heclex.h:74
@ HECMW_HECLEX_H_EQUATION
Definition: hecmw_heclex.h:27
@ HECMW_HECLEX_K_SYSTEM
Definition: hecmw_heclex.h:69
@ HECMW_HECLEX_K_COMPOSITE
Definition: hecmw_heclex.h:46
@ HECMW_HECLEX_DOUBLE
Definition: hecmw_heclex.h:14
@ HECMW_HECLEX_INT
Definition: hecmw_heclex.h:13
@ HECMW_HECLEX_K_ABAQUS
Definition: hecmw_heclex.h:43
@ HECMW_HECLEX_H_ZERO
Definition: hecmw_heclex.h:41
@ HECMW_HECLEX_H_ITEM
Definition: hecmw_heclex.h:31
@ HECMW_HECLEX_K_BEAM
Definition: hecmw_heclex.h:45
@ HECMW_HECLEX_FILENAME
Definition: hecmw_heclex.h:16
@ HECMW_HECLEX_K_SUBITEM
Definition: hecmw_heclex.h:67
@ HECMW_HECLEX_K_VALUE
Definition: hecmw_heclex.h:75
@ HECMW_HECLEX_K_DEFINITION
Definition: hecmw_heclex.h:47
@ HECMW_HECLEX_H_NODE
Definition: hecmw_heclex.h:37
@ HECMW_HECLEX_K_EGRP
Definition: hecmw_heclex.h:48
@ HECMW_HECLEX_K_MATERIAL
Definition: hecmw_heclex.h:54
@ HECMW_HECLEX_H_END
Definition: hecmw_heclex.h:26
@ HECMW_HECLEX_K_SOLID
Definition: hecmw_heclex.h:65
@ HECMW_HECLEX_H_CONNECTIVITY
Definition: hecmw_heclex.h:20
@ HECMW_HECLEX_H_NGROUP
Definition: hecmw_heclex.h:36
@ HECMW_HECLEX_K_ABSOLUTE
Definition: hecmw_heclex.h:44
@ HECMW_HECLEX_K_RELATIVE
Definition: hecmw_heclex.h:60
@ HECMW_HECLEX_K_HECMW
Definition: hecmw_heclex.h:50
@ HECMW_HECLEX_H_INITIAL
Definition: hecmw_heclex.h:30
@ HECMW_HECLEX_K_NGRP
Definition: hecmw_heclex.h:58
@ HECMW_HECLEX_K_NAME
Definition: hecmw_heclex.h:56
@ HECMW_HECLEX_K_NASTRAN
Definition: hecmw_heclex.h:57
@ HECMW_HECLEX_H_MATERIAL
Definition: hecmw_heclex.h:32
@ HECMW_HECLEX_K_NODE_SURF
Definition: hecmw_heclex.h:59
@ HECMW_HECLEX_HEADER
Definition: hecmw_heclex.h:17
@ HECMW_HECLEX_K_SECOPT
Definition: hecmw_heclex.h:61
@ HECMW_HECLEX_H_AMPLITUDE
Definition: hecmw_heclex.h:19
@ HECMW_HECLEX_H_CONTACT_PAIR
Definition: hecmw_heclex.h:21
@ HECMW_HECLEX_NL
Definition: hecmw_heclex.h:12
@ HECMW_HECLEX_K_INTERFACE
Definition: hecmw_heclex.h:52
@ HECMW_HECLEX_K_STEP_TIME
Definition: hecmw_heclex.h:66
@ HECMW_HECLEX_H_INCLUDE
Definition: hecmw_heclex.h:29
@ HECMW_HECLEX_K_ITEM
Definition: hecmw_heclex.h:53
@ HECMW_HECLEX_H_SECTION
Definition: hecmw_heclex.h:38
@ HECMW_HECLEX_K_SGRP
Definition: hecmw_heclex.h:63
@ HECMW_HECLEX_H_SGROUP
Definition: hecmw_heclex.h:39
@ HECMW_HECLEX_H_SYSTEM
Definition: hecmw_heclex.h:40
@ HECMW_HECLEX_NAME
Definition: hecmw_heclex.h:15
@ HECMW_HECLEX_K_TEMPERATURE
Definition: hecmw_heclex.h:72
@ HECMW_HECLEX_H_HEADER
Definition: hecmw_heclex.h:28
@ HECMW_HECLEX_K_MATITEM
Definition: hecmw_heclex.h:55
@ HECMW_HECLEX_K_TIME
Definition: hecmw_heclex.h:73
@ HECMW_HECLEX_K_TIMEVALUE
Definition: hecmw_heclex.h:76
struct hecmwST_local_mesh * HECMW_get_entire_mesh(const char *filename)
int HECMW_read_entire_mesh(const char *filename)
int(* ReadFunc)(void)
#define N_READ_FUNC
int HECMW_io_check_mpc_dof(int dof)
int HECMW_io_is_reserved_name(const char *name)
int HECMW_io_add_ngrp(const char *name, int nnode, int *node)
struct hecmw_io_material * HECMW_io_get_mat(const char *name)
struct hecmw_io_element * HECMW_io_add_elem(int id, int type, int *node, int nmatitem, double *matitem)
int HECMW_io_add_sgrp(const char *name, int n_item, int *elem, int *surf)
int HECMW_io_add_egrp(const char *name, int nelem, int *elem)
struct hecmwST_local_mesh * HECMW_io_make_local_mesh(void)
struct hecmw_io_contact * HECMW_io_add_contact(const char *name, int type, const char *slave_grp, const char *master_grp)
struct hecmw_io_node * HECMW_io_add_node(int id, double x, double y, double z)
void HECMW_io_set_zero(struct hecmw_io_zero *zero)
struct hecmw_io_amplitude * HECMW_io_add_amp(const char *name, int definition, int time, int value, double val, double t)
struct hecmw_io_initial * HECMW_io_add_initial(int type, int node, const char *ngrp, double val)
struct hecmw_io_section * HECMW_io_add_sect(struct hecmw_io_section *sect)
struct hecmw_io_mpc * HECMW_io_add_mpc(int neq, const struct hecmw_io_mpcitem *mpcitem, double cnst)
int HECMW_io_init(void)
int HECMW_io_pre_process(void)
void HECMW_io_set_system(struct hecmw_system_param *system)
int HECMW_io_post_process(void)
struct hecmw_system_param * HECMW_io_get_system(void)
int HECMW_io_set_gridfile(char *gridfile)
int HECMW_io_finalize(void)
struct hecmw_io_material * HECMW_io_add_mat(const char *name, struct hecmw_io_material *mat)
void HECMW_io_set_header(struct hecmw_io_header *header)
#define NULL
#define HECMW_INITIAL_TYPE_TEMPERATURE
int HECMW_log(int loglv, const char *fmt,...)
Definition: hecmw_log.c:260
#define HECMW_LOG_ERROR
Definition: hecmw_log.h:15
#define HECMW_LOG_DEBUG
Definition: hecmw_log.h:21
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
#define HECMW_strdup(s)
Definition: hecmw_malloc.h:23
#define HECMW_malloc(size)
Definition: hecmw_malloc.h:20
#define HECMW_IO_HEC_E0002
Definition: hecmw_msgno.h:195
#define HECMW_IO_HEC_E0600
Definition: hecmw_msgno.h:208
#define HECMW_IO_HEC_E1106
Definition: hecmw_msgno.h:231
#define HECMW_IO_HEC_E0601
Definition: hecmw_msgno.h:209
#define HECMW_IO_HEC_E0604
Definition: hecmw_msgno.h:212
#define HECMW_IO_HEC_E2000
Definition: hecmw_msgno.h:256
#define HECMW_IO_HEC_E0900
Definition: hecmw_msgno.h:220
#define HECMW_IO_HEC_E2101
Definition: hecmw_msgno.h:258
#define HECMW_IO_HEC_E1500
Definition: hecmw_msgno.h:236
#define HECMW_IO_HEC_E1104
Definition: hecmw_msgno.h:229
#define HECMW_IO_HEC_E1100
Definition: hecmw_msgno.h:225
#define HECMW_IO_HEC_E1700
Definition: hecmw_msgno.h:242
#define HECMW_IO_HEC_E1800
Definition: hecmw_msgno.h:253
#define HECMW_IO_HEC_E1709
Definition: hecmw_msgno.h:251
#define HECMW_IO_HEC_E1105
Definition: hecmw_msgno.h:230
#define HECMW_IO_HEC_E1001
Definition: hecmw_msgno.h:223
#define HECMW_IO_HEC_E0701
Definition: hecmw_msgno.h:216
#define HECMW_IO_HEC_E0702
Definition: hecmw_msgno.h:217
#define HECMW_IO_HEC_E0001
Definition: hecmw_msgno.h:194
#define HECMW_IO_HEC_E1103
Definition: hecmw_msgno.h:228
#define HECMW_IO_HEC_E1710
Definition: hecmw_msgno.h:252
#define HECMW_IO_HEC_E0098
Definition: hecmw_msgno.h:197
#define HECMW_IO_HEC_E2100
Definition: hecmw_msgno.h:257
#define HECMW_IO_HEC_E1702
Definition: hecmw_msgno.h:244
#define HECMW_IO_HEC_E0703
Definition: hecmw_msgno.h:218
#define HECMW_IO_HEC_E0003
Definition: hecmw_msgno.h:196
#define HECMW_IO_HEC_E1708
Definition: hecmw_msgno.h:250
#define HECMW_IO_HEC_E1704
Definition: hecmw_msgno.h:246
#define HECMW_IO_HEC_E0606
Definition: hecmw_msgno.h:214
#define HECMW_IO_HEC_E1900
Definition: hecmw_msgno.h:255
#define HECMW_IO_HEC_E0800
Definition: hecmw_msgno.h:219
#define HECMW_IO_HEC_E1706
Definition: hecmw_msgno.h:248
#define HECMW_IO_HEC_E1502
Definition: hecmw_msgno.h:238
#define HECMW_IO_HEC_E1707
Definition: hecmw_msgno.h:249
#define HECMW_IO_HEC_E0099
Definition: hecmw_msgno.h:198
#define HECMW_IO_HEC_E0100
Definition: hecmw_msgno.h:199
#define HECMW_IO_HEC_E0602
Definition: hecmw_msgno.h:210
#define HECMW_IO_E0003
Definition: hecmw_msgno.h:143
#define HECMW_IO_HEC_E1000
Definition: hecmw_msgno.h:222
#define HECMW_IO_HEC_E1703
Definition: hecmw_msgno.h:245
#define HECMW_IO_HEC_E1002
Definition: hecmw_msgno.h:224
#define HECMW_IO_HEC_E1107
Definition: hecmw_msgno.h:232
#define HECMW_IO_HEC_E0502
Definition: hecmw_msgno.h:206
#define HECMW_IO_E0002
Definition: hecmw_msgno.h:142
#define HECMW_IO_HEC_E1102
Definition: hecmw_msgno.h:227
#define HECMW_IO_HEC_E0501
Definition: hecmw_msgno.h:205
#define HECMW_IO_HEC_E0901
Definition: hecmw_msgno.h:221
#define HECMW_IO_HEC_E1801
Definition: hecmw_msgno.h:254
#define HECMW_IO_HEC_E1501
Definition: hecmw_msgno.h:237
#define HECMW_IO_HEC_E0500
Definition: hecmw_msgno.h:204
#define HECMW_IO_HEC_E0200
Definition: hecmw_msgno.h:201
#define HECMW_IO_HEC_E1101
Definition: hecmw_msgno.h:226
#define HECMW_IO_HEC_E0700
Definition: hecmw_msgno.h:215
#define HECMW_IO_HEC_E1503
Definition: hecmw_msgno.h:239
#define HECMW_IO_HEC_E1600
Definition: hecmw_msgno.h:240
#define HECMW_IO_HEC_E1601
Definition: hecmw_msgno.h:241
#define HECMW_IO_HEC_E1705
Definition: hecmw_msgno.h:247
#define HECMW_IO_E0001
Definition: hecmw_msgno.h:141
#define HECMW_IO_HEC_E0503
Definition: hecmw_msgno.h:207
#define HECMW_IO_HEC_E0603
Definition: hecmw_msgno.h:211
#define HECMW_IO_HEC_E0101
Definition: hecmw_msgno.h:200
#define HECMW_IO_HEC_E1701
Definition: hecmw_msgno.h:243
int HECMW_get_path_separator(void)
Definition: hecmw_path.c:34
int HECMW_is_absolute_path(const char *path)
Definition: hecmw_path.c:45
char * HECMW_dirname(const char *path)
Definition: hecmw_path.c:167
int nnode
char head[HECMW_HEADER_LEN+1]
#define HECMW_AMP_TYPEDEF_TABULAR
Definition: hecmw_struct.h:62
#define HECMW_SECT_TYPE_SOLID
Definition: hecmw_struct.h:15
#define HECMW_SECT_OPT_PSTRAIN
Definition: hecmw_struct.h:22
#define HECMW_SECT_TYPE_SHELL
Definition: hecmw_struct.h:16
#define HECMW_SECT_TYPE_INTERFACE
Definition: hecmw_struct.h:18
#define HECMW_SECT_OPT_ASYMMETRY_RI
Definition: hecmw_struct.h:26
#define HECMW_CONTACT_TYPE_NODE_SURF
Definition: hecmw_struct.h:125
#define HECMW_SECT_OPT_PSTRESS
Definition: hecmw_struct.h:21
#define HECMW_AMP_TYPEVAL_RELATIVE
Definition: hecmw_struct.h:68
#define HECMW_AMP_TYPEVAL_ABSOLUTE
Definition: hecmw_struct.h:69
#define HECMW_CONTACT_TYPE_SURF_SURF
Definition: hecmw_struct.h:126
#define HECMW_SECT_OPT_ASYMMETRY
Definition: hecmw_struct.h:23
#define HECMW_SECT_TYPE_BEAM
Definition: hecmw_struct.h:17
#define HECMW_AMP_TYPETIME_STEP
Definition: hecmw_struct.h:65
#define HECMW_SECT_OPT_PSTRAIN_RI
Definition: hecmw_struct.h:25
#define HECMW_SECT_OPT_PSTRESS_RI
Definition: hecmw_struct.h:24
int HECMW_system(struct hecmw_system_param *param, struct hecmw_coord *coord, struct hecmw_coord *result)
Definition: hecmw_system.c:12
void HECMW_abort(HECMW_Comm comm)
Definition: hecmw_util.c:88
void HECMW_print_msg(int loglv, int msgno, const char *fmt,...)
Definition: hecmw_util.c:138
int HECMW_snprintf(char *str, size_t size, const char *format,...)
Definition: hecmw_util.c:153
char * HECMW_toupper(char *s)
Definition: hecmw_util.c:102
int HECMW_vsnprintf(char *str, size_t size, const char *format, va_list ap)
Definition: hecmw_util.c:145
#define HECMW_assert(cond)
Definition: hecmw_util.h:40
Separator_result * separator
Definition: matrix_repart.c:16
char header[HECMW_HEADER_LEN+1]
struct hecmw_io_id * next
struct hecmw_io_material * next
struct hecmw_io_material::hecmw_io_matitem * item
char name[HECMW_NAME_LEN+1]
char egrp[HECMW_NAME_LEN+1]
union hecmw_io_section::hecmw_io_section_item sect
char material[HECMW_NAME_LEN+1]