FrontISTR  5.2.0
Large-scale structural analysis program with finit element method
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 
24 static char grid_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
25 static char include_filename[HECMW_FILENAME_LEN + 1] = "Unknown";
26 
27 static int connectivity_type = HECMW_CONNTYPE_HECMW;
28 
29 /*----------------------------------------------------------------------------*/
30 
31 static 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 
52 static 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 
60 static 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 
78 static int read_input(int msgno_invalid_token) {
79  int token;
80  char *p;
81 
82  token = HECMW_heclex_next_token();
83  if (token != '=') {
84  set_err_token(token, msgno_invalid_token, "'=' required after INPUT");
85  return -1;
86  }
87  token = HECMW_heclex_next_token();
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  }
97  if (HECMW_is_absolute_path(p)) {
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 
114 static 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 
133 static 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  }
148  p = HECMW_heclex_get_text();
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 
162 static 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  }
175  *type = HECMW_HECLEX_K_TIMEVALUE;
176  return 0;
177 }
178 
179 static 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 
196 static 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  }
209  *time = HECMW_AMP_TYPETIME_STEP;
210  return 0;
211 }
212 
213 static 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 
233 static 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  }
249  val = HECMW_heclex_get_number();
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 
300 static 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 
399 static 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 
420 static 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  }
435  p = HECMW_heclex_get_text();
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 
449 static 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 
469 static 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 
544 static int read_contact_pair(void) {
545  int token, state;
546  int type = HECMW_CONTACT_TYPE_NODE_SURF;
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
630 static int
631 read_ecopy(void)
632 {
633  fprintf(stderr, "!ECOPY has not implemented yet\n");
635  return 0;
636 }
637 
638 
639 static int
640 read_egen(void)
641 {
642  fprintf(stderr, "!EGEN has not implemented yet\n");
644  return 0;
645 }
646 #endif
647 
648 /*----------------------------------------------------------------------------*/
649 
650 static 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 
669 static 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  }
684  p = HECMW_heclex_get_text();
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 
702 static 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 
770 static 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  }
834  HECMW_assert(token == HECMW_HECLEX_NL);
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 
876 static 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 
969 static 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 
988 static 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 
1009 static 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  }
1024  p = HECMW_heclex_get_text();
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 
1042 static 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 
1063 static 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  }
1072  *id = HECMW_heclex_get_number();
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 
1115 static 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 
1153 static 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);
1228  HECMW_assert(nnode <= HECMW_MAX_NODE_MAX);
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 
1336 static 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 
1357 static 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) {
1370  p = HECMW_heclex_get_text();
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 
1410 static 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) {
1429  p = HECMW_heclex_get_text();
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 
1607 static 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) {
1669  p = HECMW_heclex_get_text();
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 
1689 static 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  }
1713  p = HECMW_heclex_get_text();
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 
1739 static 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 
1784 static 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 
1803 static 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 
1820 static 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  }
1865  val = HECMW_heclex_get_number();
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 
1884 static 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 
1961 static 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 
2001 static 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 
2023 static 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 
2119 static 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 
2199 static 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 
2218 static 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  }
2233  p = HECMW_heclex_get_text();
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 
2251 static 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 
2272 static 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 
2286 static 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 
2330 static 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
2403 static int
2404 read_ncopy(void)
2405 {
2406  fprintf(stderr, "!NCOPY has not implemented yet\n");
2408  return 0;
2409 }
2410 
2411 
2412 static int
2413 read_nfill(void)
2414 {
2415  fprintf(stderr, "!NFILL has not implemented yet\n");
2417  return 0;
2418 }
2419 
2420 
2421 static int
2422 read_ngen(void)
2423 {
2424  fprintf(stderr, "!NGEN has not implemented yet\n");
2426  return 0;
2427 }
2428 #endif
2429 
2430 /*----------------------------------------------------------------------------*/
2431 
2432 static 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 
2451 static 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  }
2466  p = HECMW_heclex_get_text();
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 
2488 static 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  }
2531  HECMW_assert(head);
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 
2554 static 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 
2659 static 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 
2748 static 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 
2768 static 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 
2785 static 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  }
2800  p = HECMW_heclex_get_text();
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 
2818 static 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) {
2826  id = HECMW_heclex_get_number();
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 
2917 static 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 
2947 static 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 
3041 static 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 
3060 static 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) {
3076  *type = HECMW_SECT_TYPE_INTERFACE;
3077  } else {
3078  set_err_token(token, HECMW_IO_HEC_E1700, "Invalid TYPE");
3079  return -1;
3080  }
3081  return 0;
3082 }
3083 
3084 static 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  }
3099  p = HECMW_heclex_get_text();
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 
3113 static 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  }
3128  p = HECMW_heclex_get_text();
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
3143 static int
3144 read_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 
3168 static 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 
3196 static 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 
3227 static 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 
3278 static 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) {
3285  nx = HECMW_heclex_get_number();
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) {
3301  ny = HECMW_heclex_get_number();
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) {
3317  nz = HECMW_heclex_get_number();
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) {
3353  Iyy = HECMW_heclex_get_number();
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) {
3373  Izz = HECMW_heclex_get_number();
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) {
3393  Jx = HECMW_heclex_get_number();
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 
3422 static 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 
3525 static 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 
3703 static 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 
3722 static 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  }
3737  p = HECMW_heclex_get_text();
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 
3751 static 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 
3862 static 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
3937 static int
3938 read_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 
3960 static int
3961 read_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 
4027 static int
4028 read_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 
4093 static int
4094 read_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 
4159 static int
4160 read_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 
4237 static 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 
4287 static 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) {
4326  case HECMW_HECLEX_K_HECMW:
4327  type = HECMW_CONNTYPE_HECMW;
4328  break;
4329  case HECMW_HECLEX_K_ABAQUS:
4330  type = HECMW_CONNTYPE_ABAQUS;
4331  break;
4333  type = HECMW_CONNTYPE_NASTRAN;
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 
4357 typedef int (*ReadFunc)(void);
4358 
4359 static 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) */
4389 static 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 
4400 static 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 */
4427 int 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 
4472 struct 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)
char * HECMW_heclex_get_text(void)
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)
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
int HECMW_read_entire_mesh(const char *filename)
struct hecmwST_local_mesh * HECMW_get_entire_mesh(const char *filename)
int(* ReadFunc)(void)
#define N_READ_FUNC
struct hecmw_io_mpc * HECMW_io_add_mpc(int neq, const struct hecmw_io_mpcitem *mpcitem, double cnst)
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_section * HECMW_io_add_sect(struct hecmw_io_section *sect)
int HECMW_io_add_sgrp(const char *name, int n_item, int *elem, int *surf)
struct hecmw_io_amplitude * HECMW_io_add_amp(const char *name, int definition, int time, int value, double val, double t)
int HECMW_io_add_egrp(const char *name, int nelem, int *elem)
struct hecmw_io_initial * HECMW_io_add_initial(int type, int node, const char *ngrp, double val)
struct hecmw_io_contact * HECMW_io_add_contact(const char *name, int type, const char *slave_grp, const char *master_grp)
struct hecmw_io_material * HECMW_io_add_mat(const char *name, struct hecmw_io_material *mat)
struct hecmwST_local_mesh * HECMW_io_make_local_mesh(void)
void HECMW_io_set_zero(struct hecmw_io_zero *zero)
int HECMW_io_init(void)
struct hecmw_io_element * HECMW_io_add_elem(int id, int type, int *node, int nmatitem, double *matitem)
int HECMW_io_pre_process(void)
void HECMW_io_set_system(struct hecmw_system_param *system)
struct hecmw_io_node * HECMW_io_add_node(int id, double x, double y, double z)
int HECMW_io_post_process(void)
struct hecmw_io_material * HECMW_io_get_mat(const char *name)
int HECMW_io_set_gridfile(char *gridfile)
int HECMW_io_finalize(void)
struct hecmw_system_param * HECMW_io_get_system(void)
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
char * HECMW_dirname(const char *path)
Definition: hecmw_path.c:167
int HECMW_get_path_separator(void)
Definition: hecmw_path.c:34
int HECMW_is_absolute_path(const char *path)
Definition: hecmw_path.c:45
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
char * HECMW_toupper(char *s)
Definition: hecmw_util.c:102
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
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]